@stll/folio-core 0.37.5 → 0.39.0

package/dist/internal/compare/inline-presentation.js

@@ -0,0 +1,222 @@
+import { panic } from "better-result";
+//#region src/internal/compare/inline-presentation.ts
+/**
+* Canonical interpretation of the inline presentation carried by comparison
+* snapshots.
+*
+* Effective and explicitly authored values are separate facts. Every caller
+* compares them through the descriptor grammar below, so adding a supported
+* property cannot update redline planning while leaving verification behind.
+*/
+const NO_PRESENTATION_DIFFERENCE = Symbol("no-inline-presentation-difference");
+const HEX_COLOR = /^#?(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/u;
+const normalizeInlinePresentationColor = (color) => HEX_COLOR.test(color) ? color.replace(/^#/u, "").toUpperCase() : color;
+/**
+* The one grammar for every modeled run-presentation property. The
+* `SamePropertySet` constraint also rejects a field added to `FolioContentRun`
+* without a corresponding authored-formatting representation, or vice versa.
+*/
+const INLINE_PRESENTATION_GRAMMAR = {
+	boolean: [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	],
+	string: ["fontFamily"],
+	number: ["fontSizePt"],
+	color: ["color"]
+};
+const INLINE_PRESENTATION_HOT_PATH_GRAMMAR = INLINE_PRESENTATION_GRAMMAR;
+/** Derived from the descriptor grammar; tests use it to prove full coverage. */
+const CANONICAL_INLINE_PRESENTATION_PROPERTIES = Object.freeze([
+	...INLINE_PRESENTATION_GRAMMAR.boolean,
+	...INLINE_PRESENTATION_GRAMMAR.string,
+	...INLINE_PRESENTATION_GRAMMAR.number,
+	...INLINE_PRESENTATION_GRAMMAR.color
+]);
+const canonicalColor = (value) => value === null || value === void 0 ? value : normalizeInlinePresentationColor(value);
+const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
+	let changed = false;
+	const baseDirect = base?.directFormatting ?? {};
+	const revisedDirect = revised?.directFormatting ?? {};
+	for (const property of INLINE_PRESENTATION_HOT_PATH_GRAMMAR.boolean) {
+		const baseAuthored = baseDirect[property];
+		const revisedAuthored = revisedDirect[property];
+		const baseEffective = base?.[property] === true;
+		const revisedEffective = revised?.[property] === true;
+		let value;
+		if (baseAuthored !== revisedAuthored) value = revisedAuthored ?? null;
+		else if (baseEffective === revisedEffective) value = NO_PRESENTATION_DIFFERENCE;
+		else value = revisedEffective;
+		if (value !== NO_PRESENTATION_DIFFERENCE) {
+			changed = true;
+			if (patch !== null) patch[property] = value;
+		}
+	}
+	const stringProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.string[0];
+	let stringValue;
+	if (baseDirect[stringProperty] !== revisedDirect[stringProperty]) stringValue = revisedDirect[stringProperty] ?? null;
+	else if (base?.[stringProperty] === revised?.[stringProperty]) stringValue = NO_PRESENTATION_DIFFERENCE;
+	else stringValue = revised?.[stringProperty] ?? null;
+	if (stringValue !== NO_PRESENTATION_DIFFERENCE) {
+		changed = true;
+		if (patch !== null) patch[stringProperty] = stringValue;
+	}
+	const numberProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.number[0];
+	let numberValue;
+	if (baseDirect[numberProperty] !== revisedDirect[numberProperty]) numberValue = revisedDirect[numberProperty] ?? null;
+	else if (base?.[numberProperty] === revised?.[numberProperty]) numberValue = NO_PRESENTATION_DIFFERENCE;
+	else numberValue = revised?.[numberProperty] ?? null;
+	if (numberValue !== NO_PRESENTATION_DIFFERENCE) {
+		changed = true;
+		if (patch !== null) patch[numberProperty] = numberValue;
+	}
+	const colorProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.color[0];
+	const baseAuthoredColor = canonicalColor(baseDirect[colorProperty]);
+	const revisedAuthoredColor = canonicalColor(revisedDirect[colorProperty]);
+	const baseEffectiveColor = canonicalColor(base?.[colorProperty]);
+	const revisedEffectiveColor = canonicalColor(revised?.[colorProperty]);
+	let color;
+	if (baseAuthoredColor !== revisedAuthoredColor) color = revisedAuthoredColor ?? null;
+	else if (baseEffectiveColor === revisedEffectiveColor) color = NO_PRESENTATION_DIFFERENCE;
+	else color = revisedEffectiveColor ?? null;
+	if (color !== NO_PRESENTATION_DIFFERENCE) {
+		changed = true;
+		if (patch !== null) patch[colorProperty] = color;
+	}
+	return changed;
+};
+const canonicalInlinePresentationsEqual = (base, revised) => !writeCanonicalInlinePresentationDifferences(base, revised, null);
+const changedCanonicalInlinePresentation = (base, revised) => {
+	const patch = {};
+	return writeCanonicalInlinePresentationDifferences(base, revised, patch) ? patch : null;
+};
+const sameCanonicalInlinePresentationPatch = (left, right) => {
+	for (const property of INLINE_PRESENTATION_GRAMMAR.boolean) if (left[property] !== right[property]) return false;
+	for (const property of INLINE_PRESENTATION_GRAMMAR.string) if (left[property] !== right[property]) return false;
+	for (const property of INLINE_PRESENTATION_GRAMMAR.number) if (left[property] !== right[property]) return false;
+	for (const property of INLINE_PRESENTATION_GRAMMAR.color) if (left[property] !== right[property]) return false;
+	return true;
+};
+/**
+* Walk the shared UTF-16 coordinate space once. Run boundaries may differ;
+* malformed run streams never yield a trusted projection.
+*/
+const visitAlignedRunRanges = (options) => {
+	const { baseBlock, revisedBlock } = options;
+	if (baseBlock.text !== revisedBlock.text) return "unalignable";
+	const baseRuns = baseBlock.previewRuns ?? [{ text: baseBlock.text }];
+	const revisedRuns = revisedBlock.previewRuns ?? [{ text: revisedBlock.text }];
+	let baseRunIndex = 0;
+	let revisedRunIndex = 0;
+	let baseRunOffset = 0;
+	let revisedRunOffset = 0;
+	let baseBlockOffset = 0;
+	let revisedBlockOffset = 0;
+	let exceededBudget = false;
+	while (true) {
+		let baseRunText = baseRuns[baseRunIndex]?.text;
+		while (baseRunText !== void 0 && baseRunOffset === baseRunText.length) {
+			baseRunIndex++;
+			baseRunOffset = 0;
+			baseRunText = baseRuns[baseRunIndex]?.text;
+		}
+		let revisedRunText = revisedRuns[revisedRunIndex]?.text;
+		while (revisedRunText !== void 0 && revisedRunOffset === revisedRunText.length) {
+			revisedRunIndex++;
+			revisedRunOffset = 0;
+			revisedRunText = revisedRuns[revisedRunIndex]?.text;
+		}
+		if (baseRunIndex === baseRuns.length || revisedRunIndex === revisedRuns.length) {
+			if (!(baseRunIndex === baseRuns.length && revisedRunIndex === revisedRuns.length && baseBlockOffset === baseBlock.text.length && revisedBlockOffset === revisedBlock.text.length)) return "unalignable";
+			if (exceededBudget) return "budget-exceeded";
+			return "complete";
+		}
+		if (baseRunText === void 0 || revisedRunText === void 0) return "unalignable";
+		if (baseRunOffset === 0 && !baseBlock.text.startsWith(baseRunText, baseBlockOffset) || revisedRunOffset === 0 && !revisedBlock.text.startsWith(revisedRunText, revisedBlockOffset)) return "unalignable";
+		const length = Math.min(baseRunText.length - baseRunOffset, revisedRunText.length - revisedRunOffset);
+		const baseRun = baseRuns[baseRunIndex];
+		const revisedRun = revisedRuns[revisedRunIndex];
+		if (options.type === "equivalence") {
+			if (!canonicalInlinePresentationsEqual(baseRun, revisedRun)) return "stopped";
+		} else if (!exceededBudget) {
+			const formatting = changedCanonicalInlinePresentation(baseRun, revisedRun);
+			if (formatting !== null) {
+				const previous = options.segments.at(-1);
+				if (previous && previous.endOffset === baseBlockOffset && sameCanonicalInlinePresentationPatch(previous.formatting, formatting)) previous.endOffset += length;
+				else if (options.segments.length >= options.maxSegments) exceededBudget = true;
+				else options.segments.push({
+					startOffset: baseBlockOffset,
+					endOffset: baseBlockOffset + length,
+					formatting
+				});
+			}
+		}
+		baseRunOffset += length;
+		revisedRunOffset += length;
+		baseBlockOffset += length;
+		revisedBlockOffset += length;
+	}
+};
+const hasAlignedRunStream = (block) => {
+	if (block.previewRuns === void 0) return true;
+	let offset = 0;
+	for (const run of block.previewRuns) {
+		if (!block.text.startsWith(run.text, offset)) return false;
+		offset += run.text.length;
+	}
+	return offset === block.text.length;
+};
+/**
+* Collect coalesced canonical presentation differences in character order.
+* Invalid run streams take precedence over the segment budget, so malformed
+* content cannot change meaning as the caller's remaining budget changes.
+*/
+const canonicalInlinePresentationSegments = ({ baseBlock, revisedBlock, maxSegments }) => {
+	const segments = [];
+	const result = visitAlignedRunRanges({
+		type: "segments",
+		baseBlock,
+		revisedBlock,
+		maxSegments,
+		segments
+	});
+	switch (result) {
+		case "complete": return {
+			status: "compared",
+			segments
+		};
+		case "budget-exceeded": return {
+			status: "budget-exceeded",
+			maximum: maxSegments
+		};
+		case "unalignable": {
+			const baseAligned = hasAlignedRunStream(baseBlock);
+			if (baseAligned === hasAlignedRunStream(revisedBlock)) return {
+				status: "unalignable",
+				side: "both"
+			};
+			if (baseAligned) return {
+				status: "unalignable",
+				side: "revised"
+			};
+			return {
+				status: "unalignable",
+				side: "base"
+			};
+		}
+		case "stopped": return panic("A segment traversal cannot stop at a presentation difference");
+		default: return result;
+	}
+};
+/** Effective and authored presentation equality, independent of run splits. */
+const sameCanonicalInlinePresentation = (baseBlock, revisedBlock) => {
+	return visitAlignedRunRanges({
+		type: "equivalence",
+		baseBlock,
+		revisedBlock
+	}) === "complete";
+};
+//#endregion
+export { CANONICAL_INLINE_PRESENTATION_PROPERTIES, canonicalInlinePresentationSegments, sameCanonicalInlinePresentation };

package/dist/internal/paragraphFormattingSerialization.d.ts

@@ -6,6 +6,8 @@ type ClassifiedParagraphFormattingField = "alignment" | "bidi" | "kinsoku" | "ov
 type ExhaustiveParagraphFormatting = ExhaustiveFields<document_d_exports.ParagraphFormatting, ClassifiedParagraphFormattingField>;
 /** Compare numbering references by their emitted id and effective level. */
 declare const paragraphNumberingReferencesEqual: (left: ParagraphNumberingReference, right: ParagraphNumberingReference) => boolean;
+/** Compare the authored `w:numPr` attributes, including an absent `w:ilvl`. */
+declare const sameAuthoredParagraphNumberingReference: (left: ParagraphNumberingReference, right: ParagraphNumberingReference) => boolean;
 /** Whether resolved numbering still belongs to the paragraph's style tier. */
 declare const isStyleSourcedParagraphNumbering: (numPr: ParagraphNumberingReference, numPrFromStyle: ParagraphNumberingReference) => boolean;
 /** Exact fallback-emission instructions for the modeled part of `w:pPr`. */
@@ -20,4 +22,4 @@ type ModeledParagraphFormattingEmission = Readonly<{
  */
 declare const modelParagraphFormattingEmission: (input: ExhaustiveParagraphFormatting | undefined) => ModeledParagraphFormattingEmission;
 //#endregion
-export { ModeledParagraphFormattingEmission, isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual };
+export { ModeledParagraphFormattingEmission, isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual, sameAuthoredParagraphNumberingReference };

package/dist/internal/paragraphFormattingSerialization.js

@@ -17,6 +17,13 @@ const paragraphNumberingReferencesEqual = (left, right) => {
 	if (modeledLeft === null || modeledRight === null) return modeledLeft === null && modeledRight === null;
 	return modeledLeft.numId === modeledRight.numId && (modeledLeft.ilvl ?? 0) === (modeledRight.ilvl ?? 0);
 };
+/** Compare the authored `w:numPr` attributes, including an absent `w:ilvl`. */
+const sameAuthoredParagraphNumberingReference = (left, right) => {
+	const modeledLeft = modelParagraphNumberingReference(left);
+	const modeledRight = modelParagraphNumberingReference(right);
+	if (modeledLeft === null || modeledRight === null) return modeledLeft === null && modeledRight === null;
+	return modeledLeft.numId === modeledRight.numId && modeledLeft.ilvl === modeledRight.ilvl;
+};
 /** Whether resolved numbering still belongs to the paragraph's style tier. */
 const isStyleSourcedParagraphNumbering = (numPr, numPrFromStyle) => numPr != null && numPrFromStyle != null && paragraphNumberingReferencesEqual(numPr, numPrFromStyle);
 const serializeToggle = (name, value) => {
@@ -154,4 +161,4 @@ const modelParagraphFormattingEmission = (input) => {
 	return emission;
 };
 //#endregion
-export { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual };
+export { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual, sameAuthoredParagraphNumberingReference };

package/dist/internal/sectionReferenceResolution.d.ts

@@ -0,0 +1,21 @@
+import { document_d_exports } from "../types/document.js";
+import { RemovedSectionReference } from "./sectionEndpointResolution.js";
+import { Node } from "prosemirror-model";
+//#region src/internal/sectionReferenceResolution.d.ts
+type SectionReferenceInventory = {
+  references: readonly RemovedSectionReference[];
+  revisionRelationships: ReadonlySet<string>;
+};
+declare const captureSectionReferenceInventory: (document: Node, finalProperties: document_d_exports.SectionProperties | undefined) => SectionReferenceInventory;
+declare const resolvedSectionReferenceLosses: ({ before, after }: {
+  before: SectionReferenceInventory;
+  after: SectionReferenceInventory;
+}) => RemovedSectionReference[];
+declare const withSectionReferenceResolution: <T>({ document, removedReferences, repack }: {
+  document: document_d_exports.Document;
+  removedReferences: readonly RemovedSectionReference[];
+  repack: () => Promise<T>;
+}) => Promise<T>;
+declare const consumeSectionReferenceResolution: (document: document_d_exports.Document) => readonly RemovedSectionReference[];
+//#endregion
+export { SectionReferenceInventory, captureSectionReferenceInventory, consumeSectionReferenceResolution, resolvedSectionReferenceLosses, withSectionReferenceResolution };

package/dist/internal/sectionReferenceResolution.js

@@ -0,0 +1,72 @@
+import { expectParagraphAttrs } from "../prosemirror/attrs/index.js";
+import { panic } from "better-result";
+//#region src/internal/sectionReferenceResolution.ts
+const relationshipKey = ({ part, relationshipId }) => `${part}:${relationshipId}`;
+const referenceKey = (reference) => `${relationshipKey(reference)}:${reference.type}`;
+const captureSectionReferenceInventory = (document, finalProperties) => {
+	const references = [];
+	const revisionRelationships = /* @__PURE__ */ new Set();
+	const collect = (properties) => {
+		if (!properties) return;
+		const start = references.length;
+		const append = (selection) => {
+			for (const { type, rId } of selection.headerReferences ?? []) references.push({
+				part: "header",
+				type,
+				relationshipId: rId
+			});
+			for (const { type, rId } of selection.footerReferences ?? []) references.push({
+				part: "footer",
+				type,
+				relationshipId: rId
+			});
+		};
+		append(properties);
+		const history = properties.propertyChanges?.filter(({ previousReferences }) => previousReferences !== void 0) ?? [];
+		for (const change of history) if (change.previousReferences) append(change.previousReferences);
+		if (history.length > 0) for (const reference of references.slice(start)) revisionRelationships.add(relationshipKey(reference));
+	};
+	document.descendants((node) => {
+		if (node.type.name === "paragraph") collect(expectParagraphAttrs(node)._sectionProperties);
+	});
+	collect(finalProperties);
+	return {
+		references,
+		revisionRelationships
+	};
+};
+const resolvedSectionReferenceLosses = ({ before, after }) => {
+	const remaining = /* @__PURE__ */ new Map();
+	for (const reference of after.references) {
+		const key = referenceKey(reference);
+		remaining.set(key, (remaining.get(key) ?? 0) + 1);
+	}
+	const removed = [];
+	for (const reference of before.references) {
+		if (!before.revisionRelationships.has(relationshipKey(reference))) continue;
+		const key = referenceKey(reference);
+		const count = remaining.get(key) ?? 0;
+		if (count > 0) remaining.set(key, count - 1);
+		else removed.push(reference);
+	}
+	return removed;
+};
+const activeResolutions = /* @__PURE__ */ new WeakMap();
+const withSectionReferenceResolution = async ({ document, removedReferences, repack }) => {
+	if (activeResolutions.has(document)) panic("A section reference repack is already active");
+	activeResolutions.set(document, removedReferences.map((reference) => ({ ...reference })));
+	try {
+		const result = await repack();
+		if (activeResolutions.has(document)) panic("The section reference repack did not consume its resolution");
+		return result;
+	} finally {
+		activeResolutions.delete(document);
+	}
+};
+const consumeSectionReferenceResolution = (document) => {
+	const references = activeResolutions.get(document) ?? [];
+	activeResolutions.delete(document);
+	return references;
+};
+//#endregion
+export { captureSectionReferenceInventory, consumeSectionReferenceResolution, resolvedSectionReferenceLosses, withSectionReferenceResolution };

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

@@ -393,6 +393,7 @@ const RUN_FORMATTING_OVERRIDE_HANDLER_ENTRIES = Object.entries({
 	fontSizeCs(formatting, value) {
 		if (typeof value === "number") formatting.complexScriptFontSize = value / 2;
 	},
+	noProof() {},
 	hidden(formatting, value) {
 		if (typeof value === "boolean") formatting.hidden = value;
 	},

package/dist/layout-engine/index.js

@@ -11,6 +11,7 @@ import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacing
 import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPageIndex.js";
 import { INITIAL_RENDERED_BREAK_STATE, PAGE_ADVANCE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
 import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, scheduleSectionBreak } from "./section-breaks.js";
+import { applySectionVerticalAlignment } from "./sectionVerticalAlignment.js";
 import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak } from "./tableRowBreak.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
 import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, resolveTableCellPadding, tableColumnsArePinned } from "./types.js";
@@ -145,16 +146,15 @@ function applyContextualSpacing(blocks) {
 * reservations as page floors so every column participates in the same footnote geometry.
 */
 function layoutDocument(blocks, measures, options) {
-	const layout = layoutDocumentPass(blocks, measures, options);
-	if (!options.footnoteHeightById) return layout;
-	return reflowFootnoteColumns({
-		initialLayout: layout,
+	const initialLayout = layoutDocumentPass(blocks, measures, options);
+	return applySectionVerticalAlignment(options.footnoteHeightById ? reflowFootnoteColumns({
+		initialLayout,
 		...options.footnoteReservedHeights ? { initialReserveFloors: options.footnoteReservedHeights } : {},
 		runLayout: (reserveFloors) => layoutDocumentPass(blocks, measures, {
 			...options,
 			footnoteReservedHeights: reserveFloors
 		})
-	});
+	}) : initialLayout, options.sectionVerticalAlignments);
 }
 function layoutDocumentPass(blocks, measures, options) {
 	if (blocks.length !== measures.length) panic(`layoutDocument: expected one measure per block (blocks=${blocks.length}, measures=${measures.length})`);

package/dist/layout-engine/sectionVerticalAlignment.d.ts

@@ -0,0 +1,7 @@
+import { Layout } from "./types.js";
+import { VerticalAlign } from "@stll/docx-core/model";
+//#region src/layout-engine/sectionVerticalAlignment.d.ts
+/** Align each page's body inside the authored section content frame. */
+declare const applySectionVerticalAlignment: (layout: Layout, alignments: readonly (VerticalAlign | undefined)[] | undefined) => Layout;
+//#endregion
+export { applySectionVerticalAlignment };

package/dist/layout-engine/sectionVerticalAlignment.js

@@ -0,0 +1,52 @@
+//#region src/layout-engine/sectionVerticalAlignment.ts
+const isFlowFragment = (fragment) => {
+	switch (fragment.kind) {
+		case "paragraph": return true;
+		case "table": return !fragment.isFloating;
+		case "image": return !fragment.isAnchored;
+		case "textBox": return !fragment.isPositioned;
+		default: return false;
+	}
+};
+const alignedOffset = (alignment, availableHeight) => {
+	switch (alignment) {
+		case "center": return availableHeight / 2;
+		case "bottom": return availableHeight;
+		case "top":
+		case "both": return 0;
+		default: return 0;
+	}
+};
+const alignPage = (page, alignment) => {
+	if (alignment !== "center" && alignment !== "bottom") return page;
+	const flow = page.fragments.filter(isFlowFragment);
+	if (flow.length === 0) return page;
+	const contentBottom = page.size.h - page.margins.bottom - (page.footnoteReservedHeight ?? 0);
+	const occupiedBottom = Math.max(...flow.map((fragment) => fragment.y + fragment.height));
+	const offset = alignedOffset(alignment, Math.max(0, contentBottom - occupiedBottom));
+	if (offset === 0) return page;
+	const flowSet = new Set(flow);
+	return {
+		...page,
+		fragments: page.fragments.map((fragment) => flowSet.has(fragment) ? {
+			...fragment,
+			y: fragment.y + offset
+		} : fragment)
+	};
+};
+/** Align each page's body inside the authored section content frame. */
+const applySectionVerticalAlignment = (layout, alignments) => {
+	if (alignments === void 0) return layout;
+	let changed = false;
+	const pages = layout.pages.map((page) => {
+		const aligned = alignPage(page, alignments[page.sectionIndex ?? 0]);
+		changed ||= aligned !== page;
+		return aligned;
+	});
+	return changed ? {
+		...layout,
+		pages
+	} : layout;
+};
+//#endregion
+export { applySectionVerticalAlignment };

package/dist/layout-engine/types.d.ts

@@ -1,5 +1,5 @@
 import { OutlineStyleAttr } from "../types/documentEnumValues.js";
-import { ImagePosition, ImageWrap, NumberFormat, SdtProperties, SdtType, ShapeTextBody, TableCellFormatting, TableWidthType } from "@stll/docx-core/model";
+import { ImagePosition, ImageWrap, NumberFormat, SdtProperties, SdtType, ShapeTextBody, TableCellFormatting, TableWidthType, VerticalAlign } from "@stll/docx-core/model";
 declare namespace types_d_exports {
   export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListMarkerFormatting, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionPageNumbering, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, resolveTableCellPadding, tableColumnsArePinned };
 }
@@ -1252,6 +1252,8 @@ type LayoutOptions = {
   finalColumns?: ColumnLayout;
   /** Body-level final section page-number policy. */
   finalPageNumbering?: SectionPageNumbering;
+  /** Vertical body alignment for each section, indexed by section ordinal. */
+  sectionVerticalAlignments?: readonly (VerticalAlign | undefined)[];
   /** Column configuration. */
   columns?: ColumnLayout;
   /** Gap between rendered pages (for UI). */

package/dist/markdown/renderRuns.js

@@ -148,6 +148,7 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 	const renderChild = (child) => {
 		if (child.type === "run") return renderRun(ctx, pkg, child, paraId);
 		if (child.type === "hyperlink") return renderHyperlink(ctx, pkg, child, paraId);
+		if (child.type === "mathEquation") return child.plainText ? escapeInline(child.plainText) : "";
 		return "";
 	};
 	if (ctx.opts.trackedChanges === "clean") {

package/dist/markdown/renderTable.js

@@ -160,6 +160,7 @@ function renderHtmlChildren(ctx, pkg, children, paraId) {
 	return children.map((child) => {
 		if (child.type === "run") return renderHtmlRun(ctx, pkg, child, paraId);
 		if (child.type === "hyperlink") return renderHtmlHyperlink(ctx, pkg, child, paraId);
+		if (child.type === "mathEquation") return child.plainText ? escapeHtml(child.plainText) : "";
 		return "";
 	}).join("");
 }

package/dist/pdf/writePdf.js

@@ -116,7 +116,7 @@ const buildDestination = ({ pageRefs, pages, pageIndex, yPx }) => {
 		pdfNull
 	]));
 };
-const buildAnnotation = ({ document, link, page, pages, pageRefs }) => {
+const buildLinkAnnotation = ({ document, link, page, pages, pageRefs }) => {
 	const topLeft = displayPointToPdf(page.heightPx, link.rect.xPx, link.rect.yPx);
 	const bottomRight = displayPointToPdf(page.heightPx, link.rect.xPx + link.rect.widthPx, link.rect.yPx + link.rect.heightPx);
 	let action;
@@ -160,6 +160,26 @@ const buildAnnotation = ({ document, link, page, pages, pageRefs }) => {
 		["Dest", destination]
 	])));
 };
+const buildCommentAnnotation = ({ document, comment, page }) => {
+	const rect = comment.rects.at(-1);
+	if (rect === void 0) return Result.err(new WritePdfError({ message: `comment ${String(comment.commentId)} has no anchor rectangle` }));
+	const topLeft = displayPointToPdf(page.heightPx, rect.xPx, rect.yPx);
+	const bottomRight = displayPointToPdf(page.heightPx, rect.xPx + rect.widthPx, rect.yPx + rect.heightPx);
+	return Result.ok(document.add(pdfDict([
+		["Type", pdfName("Annot")],
+		["Subtype", pdfName("Text")],
+		["Rect", pdfNumberArray([
+			Math.min(topLeft.x, bottomRight.x),
+			Math.min(topLeft.y, bottomRight.y),
+			Math.max(topLeft.x, bottomRight.x),
+			Math.max(topLeft.y, bottomRight.y)
+		])],
+		["Contents", pdfTextString(comment.contents)],
+		["T", pdfTextString(comment.author)],
+		["Name", pdfName("Comment")],
+		["NM", pdfAsciiString(`folio-comment-${String(comment.commentId)}`)]
+	])));
+};
 const buildOutlineTree = (entries, document) => {
 	const roots = [];
 	const ancestors = [];
@@ -255,6 +275,11 @@ const writePdf = async (list, options) => {
 	}
 	const outlineRoots = buildOutlineTree(list.outline, document);
 	const outlineRef = outlineRoots.length === 0 ? void 0 : document.allocate();
+	const commentLocations = /* @__PURE__ */ new Map();
+	for (const [pageIndex, page] of list.pages.entries()) for (const comment of page.comments) commentLocations.set(comment.commentId, {
+		pageIndex,
+		comment
+	});
 	for (const [pageIndex, page] of list.pages.entries()) {
 		const pageRef = pageRefs[pageIndex];
 		if (pageRef === void 0) return Result.err(new WritePdfError({ message: `page ${String(pageIndex)} lost its object` }));
@@ -266,7 +291,7 @@ const writePdf = async (list, options) => {
 		const contentRef = document.add(pdfFlateStream([], new TextEncoder().encode(renderContentStream(parts, resources))));
 		const annotationRefs = [];
 		for (const link of page.links) {
-			const annotation = buildAnnotation({
+			const annotation = buildLinkAnnotation({
 				document,
 				link,
 				page,
@@ -276,6 +301,16 @@ const writePdf = async (list, options) => {
 			if (annotation.isErr()) return Result.err(annotation.error);
 			annotationRefs.push(annotation.value);
 		}
+		for (const { pageIndex: commentPageIndex, comment } of commentLocations.values()) {
+			if (commentPageIndex !== pageIndex) continue;
+			const annotation = buildCommentAnnotation({
+				document,
+				comment,
+				page
+			});
+			if (annotation.isErr()) return Result.err(annotation.error);
+			annotationRefs.push(annotation.value);
+		}
 		document.define(pageRef, pdfDict([
 			["Type", pdfName("Page")],
 			["Parent", pagesRef],

package/dist/prosemirror/attrs/index.js

@@ -1,4 +1,5 @@
 import { EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, NUMBER_FORMAT_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_TEXT_DIRECTION_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_EFFECT_VALUES, THEME_COLOR_SLOT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
+import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES } from "../schema/marks.js";
@@ -241,6 +242,7 @@ const readParagraphAttrs = (node) => {
 	optionalRecord(attrs, "spacingFromDocDefaults", "paragraph.attrs.spacingFromDocDefaults", issues);
 	optionalRecord(attrs, "spacingFromImplicitDefaultStyle", "paragraph.attrs.spacingFromImplicitDefaultStyle", issues);
 	optionalTextFormatting(attrs, "defaultTextFormatting", "paragraph.attrs.defaultTextFormatting", issues);
+	optionalTextFormatting(attrs, "_tableRunFormatting", "paragraph.attrs._tableRunFormatting", issues);
 	optionalRecord(attrs, "numPr", "paragraph.attrs.numPr", issues);
 	validateNumPr(attrs["numPr"], issues);
 	optionalBookmarkArray(attrs["bookmarks"], issues);
@@ -517,6 +519,7 @@ const readTextBoxAttrs = (node) => {
 	optionalNumber(attrs, "width", "textBox.attrs.width", issues);
 	optionalNumber(attrs, "height", "textBox.attrs.height", issues);
 	optionalOneOf(attrs, "autoFit", "textBox.attrs.autoFit", issues, TEXT_BOX_AUTO_FIT_VALUES);
+	optionalWordArt(attrs, "wordArt", "textBox.attrs.wordArt", issues);
 	optionalOneOf(attrs, "textWrap", "textBox.attrs.textWrap", issues, TEXT_BOX_TEXT_WRAP_VALUES);
 	optionalString(attrs, "textBoxId", "textBox.attrs.textBoxId", issues);
 	optionalString(attrs, "fillColor", "textBox.attrs.fillColor", issues);
@@ -814,7 +817,24 @@ const mergeNodeAttrs = (node, readAttrs, label, patch) => {
 	for (const [key, value] of Object.entries(mergedAttrs)) if (value !== void 0) nextAttrs[key] = value;
 	return nextAttrs;
 };
-const mergeImageAttrs = (node, patch) => mergeNodeAttrs(node, readImageAttrs, "image attrs", patch);
+const IMAGE_RESOURCE_ATTRS = /* @__PURE__ */ new Set([
+	"rId",
+	"_docxRawXml",
+	"_docxRawXmlMode",
+	"_docxObjectPreview"
+]);
+const imageAttrValuesEqual = (left, right) => {
+	if (left === right) return true;
+	if ((left === void 0 || left === null) && (right === void 0 || right === null)) return true;
+	return canonicalJson(left) === canonicalJson(right);
+};
+const mergeImageAttrs = (node, patch) => {
+	const current = expectImageAttrs(node);
+	const merged = mergeNodeAttrs(node, readImageAttrs, "image attrs", patch);
+	if (!Object.entries(patch).some(([key, value]) => !IMAGE_RESOURCE_ATTRS.has(key) && !imageAttrValuesEqual(Reflect.get(current, key), value)) || current._docxRawXml === void 0 || current._docxRawXmlMode === DRAWING_RAW_XML_MODES.PRESERVE_ONLY) return merged;
+	const { _docxRawXml: _discardedRawXml, ...editableAttrs } = merged;
+	return editableAttrs;
+};
 const mergeParagraphAttrs = (node, patch) => mergeNodeAttrs(node, readParagraphAttrs, "paragraph attrs", patch);
 const mergeTableAttrs = (node, patch) => mergeNodeAttrs(node, readTableAttrs, "table attrs", patch);
 const mergeTableRowAttrs = (node, patch) => mergeNodeAttrs(node, readTableRowAttrs, "table row attrs", patch);
@@ -1528,6 +1548,40 @@ const optionalNestedRecord = (attrs, key, path, issues, validate) => {
 	}
 	validate(value, path, issues);
 };
+const optionalWordArt = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!isRecord(value)) {
+		issues.push({
+			path,
+			message: "Expected an object."
+		});
+		return;
+	}
+	optionalString(value, "preset", `${path}.preset`, issues);
+	optionalBoolean(value, "fromWordArt", `${path}.fromWordArt`, issues);
+	const adjustments = value["adjustments"];
+	if (adjustments === void 0 || adjustments === null) return;
+	if (!Array.isArray(adjustments)) {
+		issues.push({
+			path: `${path}.adjustments`,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, adjustment] of adjustments.entries()) {
+		const adjustmentPath = `${path}.adjustments[${index}]`;
+		if (!isRecord(adjustment)) {
+			issues.push({
+				path: adjustmentPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		optionalString(adjustment, "name", `${adjustmentPath}.name`, issues);
+		optionalString(adjustment, "formula", `${adjustmentPath}.formula`, issues);
+	}
+};
 const PARAGRAPH_FORMATTING_BOOLEAN_KEYS = [
 	"bidi",
 	"kinsoku",