@stll/folio-core 0.37.4 → 0.38.0

package/dist/internal/compare/inline-presentation.d.ts

@@ -0,0 +1,20 @@
+import { FolioContentBlock, FolioContentInlineComparisonResult } from "../../compare/content-types.js";
+//#region src/internal/compare/inline-presentation.d.ts
+/** Derived from the descriptor grammar; tests use it to prove full coverage. */
+declare const CANONICAL_INLINE_PRESENTATION_PROPERTIES: readonly ("bold" | "italic" | "underline" | "strike" | "fontFamily" | "fontSizePt" | "color")[];
+type InlinePresentationBlock = Pick<FolioContentBlock, "previewRuns" | "text">;
+type CanonicalInlinePresentationSegmentsOptions = {
+  baseBlock: InlinePresentationBlock;
+  revisedBlock: InlinePresentationBlock;
+  maxSegments: number;
+};
+/**
+ * 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.
+ */
+declare const canonicalInlinePresentationSegments: ({ baseBlock, revisedBlock, maxSegments }: CanonicalInlinePresentationSegmentsOptions) => FolioContentInlineComparisonResult;
+/** Effective and authored presentation equality, independent of run splits. */
+declare const sameCanonicalInlinePresentation: (baseBlock: InlinePresentationBlock, revisedBlock: InlinePresentationBlock) => boolean;
+//#endregion
+export { CANONICAL_INLINE_PRESENTATION_PROPERTIES, canonicalInlinePresentationSegments, sameCanonicalInlinePresentation };

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

@@ -0,0 +1,25 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/internal/paragraphFormattingSerialization.d.ts
+type ExhaustiveFields<Source, Classified extends keyof Source> = Exclude<keyof Source, Classified> extends never ? Source : never;
+type ParagraphNumberingReference = document_d_exports.ParagraphFormatting["numPr"] | null;
+type ClassifiedParagraphFormattingField = "alignment" | "bidi" | "kinsoku" | "overflowPunctuation" | "spaceBefore" | "spaceAfter" | "lineSpacing" | "lineSpacingRule" | "snapToGrid" | "beforeAutospacing" | "afterAutospacing" | "spacingExplicit" | "indentLeft" | "indentRight" | "indentFirstLine" | "hangingIndent" | "borders" | "shading" | "tabs" | "keepNext" | "keepLines" | "widowControl" | "pageBreakBefore" | "contextualSpacing" | "numPr" | "numPrFromStyle" | "outlineLevel" | "styleId" | "frame" | "suppressLineNumbers" | "suppressAutoHyphens" | "runProperties" | "runInWithNext";
+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`. */
+type ModeledParagraphFormattingEmission = Readonly<{
+  propertiesXml?: string;
+  paragraphMarkPropertiesInnerXml?: string;
+}>;
+/**
+ * Resolve paragraph formatting into its exact fallback `w:pPr` instructions.
+ * Every input field is classified here so parser capture fingerprints and the
+ * serializer cannot drift apart when paragraph formatting grows.
+ */
+declare const modelParagraphFormattingEmission: (input: ExhaustiveParagraphFormatting | undefined) => ModeledParagraphFormattingEmission;
+//#endregion
+export { ModeledParagraphFormattingEmission, isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, paragraphNumberingReferencesEqual, sameAuthoredParagraphNumberingReference };

package/dist/internal/paragraphFormattingSerialization.js

@@ -0,0 +1,164 @@
+import { serializeBorder } from "../docx/serializer/borderSerializer.js";
+import { serializeShading, serializeTextFormatting } from "../docx/serializer/textFormattingSerializer.js";
+import { escapeXml, intAttr } from "../docx/serializer/xmlUtils.js";
+//#region src/internal/paragraphFormattingSerialization.ts
+const modelParagraphNumberingReference = (reference) => {
+	if (!reference) return null;
+	const { numId, ilvl } = reference;
+	return {
+		...numId !== void 0 ? { numId } : {},
+		...ilvl !== void 0 ? { ilvl } : {}
+	};
+};
+/** Compare numbering references by their emitted id and effective level. */
+const paragraphNumberingReferencesEqual = (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 ?? 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) => {
+	if (value === true) return `<w:${name}/>`;
+	if (value === false) return `<w:${name} w:val="0"/>`;
+	return "";
+};
+const serializeParagraphBorders = (borders) => {
+	if (!borders) return "";
+	const { top, left, bottom, right, between, bar } = borders;
+	const parts = [
+		serializeBorder(top, "top"),
+		serializeBorder(left, "left"),
+		serializeBorder(bottom, "bottom"),
+		serializeBorder(right, "right"),
+		serializeBorder(between, "between"),
+		serializeBorder(bar, "bar")
+	].filter(Boolean);
+	return parts.length === 0 ? "" : `<w:pBdr>${parts.join("")}</w:pBdr>`;
+};
+const serializeTabStops = (tabs) => {
+	if (!tabs || tabs.length === 0) return "";
+	return `<w:tabs>${tabs.map((tab) => {
+		const { alignment, position, leader } = tab;
+		const attrs = [`w:val="${alignment}"`, `w:pos="${intAttr(position)}"`];
+		if (leader && leader !== "none") attrs.push(`w:leader="${leader}"`);
+		return `<w:tab ${attrs.join(" ")}/>`;
+	}).join("")}</w:tabs>`;
+};
+const serializeSpacing = (formatting) => {
+	const attrs = [];
+	if (formatting.spaceBefore !== void 0) attrs.push(`w:before="${intAttr(formatting.spaceBefore)}"`);
+	if (formatting.spaceAfter !== void 0) attrs.push(`w:after="${intAttr(formatting.spaceAfter)}"`);
+	if (formatting.lineSpacing !== void 0) attrs.push(`w:line="${intAttr(formatting.lineSpacing)}"`);
+	if (formatting.lineSpacingRule) attrs.push(`w:lineRule="${formatting.lineSpacingRule}"`);
+	if (formatting.beforeAutospacing !== void 0) attrs.push(`w:beforeAutospacing="${formatting.beforeAutospacing ? "1" : "0"}"`);
+	if (formatting.afterAutospacing !== void 0) attrs.push(`w:afterAutospacing="${formatting.afterAutospacing ? "1" : "0"}"`);
+	return attrs.length === 0 ? "" : `<w:spacing ${attrs.join(" ")}/>`;
+};
+const serializeIndentation = (formatting) => {
+	const attrs = [];
+	if (formatting.indentLeft !== void 0) attrs.push(`w:left="${intAttr(formatting.indentLeft)}"`);
+	if (formatting.indentRight !== void 0) attrs.push(`w:right="${intAttr(formatting.indentRight)}"`);
+	if (formatting.indentFirstLine !== void 0) {
+		const attribute = formatting.hangingIndent ? "hanging" : "firstLine";
+		const value = formatting.hangingIndent ? Math.abs(formatting.indentFirstLine) : formatting.indentFirstLine;
+		attrs.push(`w:${attribute}="${intAttr(value)}"`);
+	}
+	return attrs.length === 0 ? "" : `<w:ind ${attrs.join(" ")}/>`;
+};
+const serializeNumbering = (numPr) => {
+	const modeled = modelParagraphNumberingReference(numPr ?? null);
+	if (!modeled) return "";
+	const parts = [];
+	if (modeled.ilvl !== void 0) parts.push(`<w:ilvl w:val="${intAttr(modeled.ilvl)}"/>`);
+	if (modeled.numId !== void 0) parts.push(`<w:numId w:val="${intAttr(modeled.numId)}"/>`);
+	return parts.length === 0 ? "" : `<w:numPr>${parts.join("")}</w:numPr>`;
+};
+const serializeFrameProperties = (frame) => {
+	if (!frame) return "";
+	const { dropCap, lines, width, height, hSpace, vSpace, hAnchor, vAnchor, x, y, xAlign, yAlign, wrap } = frame;
+	const attrs = [];
+	if (dropCap) attrs.push(`w:dropCap="${dropCap}"`);
+	if (lines !== void 0) attrs.push(`w:lines="${intAttr(lines)}"`);
+	if (width !== void 0) attrs.push(`w:w="${intAttr(width)}"`);
+	if (height !== void 0) attrs.push(`w:h="${intAttr(height)}"`);
+	if (hSpace !== void 0) attrs.push(`w:hSpace="${intAttr(hSpace)}"`);
+	if (vSpace !== void 0) attrs.push(`w:vSpace="${intAttr(vSpace)}"`);
+	if (hAnchor) attrs.push(`w:hAnchor="${hAnchor}"`);
+	if (vAnchor) attrs.push(`w:vAnchor="${vAnchor}"`);
+	if (x !== void 0) attrs.push(`w:x="${x}"`);
+	if (y !== void 0) attrs.push(`w:y="${y}"`);
+	if (xAlign) attrs.push(`w:xAlign="${xAlign}"`);
+	if (yAlign) attrs.push(`w:yAlign="${yAlign}"`);
+	if (wrap) attrs.push(`w:wrap="${wrap}"`);
+	return attrs.length === 0 ? "" : `<w:framePr ${attrs.join(" ")}/>`;
+};
+const modelSpacingProvenance = (spacingExplicit) => {
+	if (spacingExplicit) {
+		const { before: _before, after: _after } = spacingExplicit;
+	}
+};
+const extractRunPropertiesInnerXml = (runPropertiesXml) => {
+	if (!runPropertiesXml.startsWith("<w:rPr>") || !runPropertiesXml.endsWith("</w:rPr>")) return "";
+	return runPropertiesXml.slice(7, -8);
+};
+/**
+* Resolve paragraph formatting into its exact fallback `w:pPr` instructions.
+* Every input field is classified here so parser capture fingerprints and the
+* serializer cannot drift apart when paragraph formatting grows.
+*/
+const modelParagraphFormattingEmission = (input) => {
+	if (!input) return {};
+	const { alignment, bidi, kinsoku, overflowPunctuation, spaceBefore, spaceAfter, lineSpacing, lineSpacingRule, snapToGrid, beforeAutospacing, afterAutospacing, spacingExplicit, indentLeft, indentRight, indentFirstLine, hangingIndent, borders, shading, tabs, keepNext, keepLines, widowControl, pageBreakBefore, contextualSpacing, numPr, numPrFromStyle, outlineLevel, styleId, frame, suppressLineNumbers, suppressAutoHyphens, runProperties, runInWithNext } = input;
+	modelSpacingProvenance(spacingExplicit);
+	const propertiesXml = [
+		styleId ? `<w:pStyle w:val="${escapeXml(styleId)}"/>` : "",
+		serializeToggle("keepNext", keepNext),
+		serializeToggle("keepLines", keepLines),
+		serializeToggle("pageBreakBefore", pageBreakBefore),
+		serializeFrameProperties(frame),
+		serializeToggle("widowControl", widowControl),
+		isStyleSourcedParagraphNumbering(numPr, numPrFromStyle) ? "" : serializeNumbering(numPr),
+		serializeToggle("suppressLineNumbers", suppressLineNumbers),
+		serializeParagraphBorders(borders),
+		serializeShading(shading),
+		serializeTabStops(tabs),
+		serializeToggle("suppressAutoHyphens", suppressAutoHyphens),
+		serializeToggle("kinsoku", kinsoku),
+		serializeToggle("overflowPunct", overflowPunctuation),
+		serializeToggle("bidi", bidi),
+		serializeToggle("snapToGrid", snapToGrid),
+		serializeSpacing({
+			spaceBefore,
+			spaceAfter,
+			lineSpacing,
+			lineSpacingRule,
+			beforeAutospacing,
+			afterAutospacing
+		}),
+		serializeIndentation({
+			indentLeft,
+			indentRight,
+			indentFirstLine,
+			hangingIndent
+		}),
+		serializeToggle("contextualSpacing", contextualSpacing),
+		alignment ? `<w:jc w:val="${alignment}"/>` : "",
+		outlineLevel !== void 0 ? `<w:outlineLvl w:val="${outlineLevel}"/>` : ""
+	].join("");
+	const paragraphMarkPropertiesInnerXml = `${extractRunPropertiesInnerXml(serializeTextFormatting(runProperties))}${runInWithNext === true ? "<w:specVanish/>" : ""}`;
+	const emission = {};
+	if (propertiesXml) emission.propertiesXml = propertiesXml;
+	if (paragraphMarkPropertiesInnerXml) emission.paragraphMarkPropertiesInnerXml = paragraphMarkPropertiesInnerXml;
+	return emission;
+};
+//#endregion
+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/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/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);
@@ -814,7 +816,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);

package/dist/prosemirror/commands/comments.d.ts

@@ -1,4 +1,5 @@
 import { Command, EditorState } from "prosemirror-state";
+import { Mapping } from "prosemirror-transform";
 //#region src/prosemirror/commands/comments.d.ts
 /**
  * Add a comment mark to the current selection.
@@ -46,6 +47,15 @@ declare function rejectAllChanges(): Command;
  * mapped through concurrent edits.
  */
 declare function resolveAllChangesInHeadlessState(state: EditorState, mode: ResolveMode): EditorState;
+/**
+ * Resolve through the editor command path when a caller must map a position in
+ * the reviewed document back to the tracked source. The bulk resolver is
+ * faster, but deliberately replaces inline content without retaining mapping.
+ */
+declare const resolveAllChangesInHeadlessStateWithMapping: (state: EditorState, mode: ResolveMode) => {
+  state: EditorState;
+  mapping: Mapping;
+};
 /**
  * Find the document range covered by all revision carriers with any of the
  * given ids. Returns null when none are present (already accepted/rejected, or
@@ -174,4 +184,4 @@ declare function findNextChange(state: EditorState, startPos: number): ChangeRan
  */
 declare function findPreviousChange(state: EditorState, startPos: number): ChangeRange | null;
 //#endregion
-export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState };
+export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping };