@stll/folio-core 0.45.0 → 0.47.0

package/dist/utils/findReplace.js

@@ -1,3 +1,4 @@
+import { panic } from "better-result";
 //#region src/utils/findReplace.ts
 const createDefaultFindOptions = () => ({
 	matchCase: false,
@@ -101,17 +102,58 @@ const getRunSearchProjection = (run) => {
 		pageBreakOffsets
 	};
 };
-const getHyperlinkSearchProjection = (hyperlink) => joinSearchProjections(hyperlink.children.flatMap((child) => child.type === "run" ? [getRunSearchProjection(child)] : []));
+const getHyperlinkSearchProjection = (hyperlink) => joinSearchProjections(hyperlink.children.flatMap((child) => {
+	if (child.type === "run") return [getRunSearchProjection(child)];
+	return child.type === "inlineWrapper" ? [getParagraphContentSearchProjection(child)] : [];
+}));
+/** Nothing on the line: a marker, or markup with no text under it. */
+const noSearchText = () => ({
+	text: "",
+	pageBreakOffsets: []
+});
+/**
+* The text one paragraph content item puts on the line, for searching.
+*
+* A `switch` with a `never` default rather than an `if`-chain ending in the
+* empty projection: a chain answers "no text" for a member nobody considered,
+* and a member that holds runs and answers "no text" is text the reader can
+* see and find cannot. That is what the revision wrappers and the transparent
+* inline wrappers were doing — a search for a phrase inside a `w:bdo`, a smart
+* tag or an insertion found nothing.
+*
+* The offsets this produces are resolved back to an editor position by
+* `resolveFindMatchRange`, against the text `getSearchableParagraphText`
+* builds from the ProseMirror tree. So the two have to agree character for
+* character, and this one mirrors that one: every text node counts, including
+* the deleted and moved-away text the editor still shows struck through. A
+* member skipped here shifts every later offset and the replacement lands on
+* the wrong characters.
+*/
 const getParagraphContentSearchProjection = (content) => {
-	if (content.type === "run") return getRunSearchProjection(content);
-	if (content.type === "hyperlink") return getHyperlinkSearchProjection(content);
-	if (content.type === "inlineSdt") return joinSearchProjections(content.content.map(getParagraphContentSearchProjection));
-	if (content.type === "simpleField") return joinSearchProjections(content.content.map((child) => child.type === "run" ? getRunSearchProjection(child) : getHyperlinkSearchProjection(child)));
-	if (content.type === "complexField") return joinSearchProjections(content.fieldResult.map(getRunSearchProjection));
-	return {
-		text: "",
-		pageBreakOffsets: []
-	};
+	switch (content.type) {
+		case "run": return getRunSearchProjection(content);
+		case "hyperlink": return getHyperlinkSearchProjection(content);
+		case "inlineSdt":
+		case "simpleField":
+		case "inlineWrapper":
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo": return joinSearchProjections(content.content.map(getParagraphContentSearchProjection));
+		case "complexField": return joinSearchProjections(content.fieldResult.map(getRunSearchProjection));
+		case "bookmarkStart":
+		case "bookmarkEnd":
+		case "commentRangeStart":
+		case "commentRangeEnd":
+		case "commentReference":
+		case "moveFromRangeStart":
+		case "moveFromRangeEnd":
+		case "moveToRangeStart":
+		case "moveToRangeEnd":
+		case "mathEquation":
+		case "preservedInline": return noSearchText();
+		default: panic(`Unsupported paragraph content: ${JSON.stringify(content)}`);
+	}
 };
 const getParagraphSearchProjection = (paragraph) => joinSearchProjections(paragraph.content.map(getParagraphContentSearchProjection));
 const findContentIndexAtOffset = (paragraph, offset) => {

package/dist/utils/formatToStyle.d.ts

@@ -36,6 +36,88 @@ declare function borderToStyle(border: document_d_exports.BorderSpec | undefined
  * @returns CSS color string or empty string
  */
 declare function resolveShadingFill(shading: document_d_exports.ShadingProperties | undefined | null, theme?: document_d_exports.Theme | null): string;
+/** The CSS `text-decoration-style` keywords folio paints an underline with. */
+type CssTextDecorationStyle = "solid" | "double" | "dotted" | "dashed" | "wavy";
+/**
+ * What an authored underline paints as, in CSS.
+ *
+ * `decorationStyle` is absent for the member that paints no line at all; the
+ * caller decides whether that means "omit the decoration" or "inherit".
+ * `decorationThickness` is absent wherever the font's own underline weight is
+ * what Word draws.
+ */
+type UnderlineDecorationCss = {
+  readonly decorationStyle?: CssTextDecorationStyle;
+  readonly decorationThickness?: string;
+};
+/**
+ * The underline every DOM backend draws when the author named no member.
+ *
+ * It is also what an underline CSS cannot spell parses back as; see
+ * `underlineStyleFromCssDecoration`.
+ */
+declare const PLAIN_UNDERLINE = "single";
+/**
+ * Every `ST_Underline` member's CSS line. The one table: the ProseMirror mark's
+ * `toDOM`, the DOM painter and `textToStyle` all render a run from this, so a
+ * member cannot paint one line in the editor and another on the page.
+ *
+ * `none` cancels an underline inherited from the style chain rather than
+ * naming a line style, and `text-decoration-style: none` is not a CSS keyword,
+ * so that member names no keyword and carries no declarations at all.
+ *
+ * Where CSS has no keyword for what Word draws, the member is approximated and
+ * the approximation is stated here rather than at a call site: `words`
+ * underlines the spaces between words too (`text-decoration-skip-ink` skips
+ * descender ink, not spaces, and `text-decoration-skip: spaces` never
+ * shipped); `wavyDouble` draws two straight lines rather than two wavy ones;
+ * `dashLong`, `dotDash` and `dotDotDash` draw the single dash pattern CSS has.
+ * The `*Heavy` members and `thick` differ from their plain counterparts in
+ * weight only, which the thickness carries, so the line they name is their
+ * plain counterpart's.
+ */
+declare const UNDERLINE_DECORATION_STYLES: {
+  readonly none: undefined;
+  readonly single: "solid";
+  readonly words: "solid";
+  readonly double: "double";
+  readonly thick: "solid";
+  readonly dotted: "dotted";
+  readonly dottedHeavy: "dotted";
+  readonly dash: "dashed";
+  readonly dashedHeavy: "dashed";
+  readonly dashLong: "dashed";
+  readonly dashLongHeavy: "dashed";
+  readonly dotDash: "dashed";
+  readonly dashDotHeavy: "dashed";
+  readonly dotDotDash: "dashed";
+  readonly dashDotDotHeavy: "dashed";
+  readonly wave: "wavy";
+  readonly wavyHeavy: "wavy";
+  readonly wavyDouble: "double";
+};
+/**
+ * The CSS an authored underline paints with.
+ *
+ * CSS has no heavy keyword, so a weight is stated as a length: the plain ratio
+ * the display list strokes with, times the weight the member's own row carries
+ * (`display-list/build/strokes.ts`). Both backends therefore scale the same way
+ * with the font size, and which members are heavy is read off the row rather
+ * than listed again here, so the page and the editor cannot disagree about it.
+ */
+declare const underlineDecorationCss: (style: document_d_exports.UnderlineStyle) => UnderlineDecorationCss;
+/**
+ * The `ST_Underline` member an authored `text-decoration` or
+ * `text-decoration-style` value parses back as.
+ *
+ * The table is many-to-one, so the inverse cannot be: several members share
+ * every keyword. It resolves each keyword to that keyword's canonical author,
+ * the plain member whose own CSS is exactly the keyword, so a member folio
+ * cannot spell in CSS comes back as the sibling it is drawn as: `dottedHeavy`
+ * as `dotted`, `words` and `thick` as `single`, `wavyDouble` as `double`. A
+ * value naming no keyword folio writes parses as the plain underline.
+ */
+declare const underlineStyleFromCssDecoration: (value: string) => document_d_exports.UnderlineStyle;
 /**
  * Merge multiple CSSProperties objects
  *
@@ -54,7 +136,7 @@ declare function mergeStyles(...styles: (CSSProperties | undefined | null)[]): C
  */
 declare function tableCellToStyle(formatting: {
   verticalAlign?: "top" | "center" | "bottom";
-  textDirection?: string;
+  textDirection?: document_d_exports.TextDirection;
   shading?: document_d_exports.ShadingProperties;
   borders?: {
     top?: document_d_exports.BorderSpec;
@@ -99,4 +181,4 @@ declare function sectionToStyle(sectionProps: {
   };
 } | undefined | null, theme?: document_d_exports.Theme | null): CSSProperties;
 //#endregion
-export { borderToStyle, mergeStyles, paragraphToStyle, resolveShadingFill, sectionToStyle, tableCellToStyle, textToStyle };
+export { CssTextDecorationStyle, PLAIN_UNDERLINE, UNDERLINE_DECORATION_STYLES, UnderlineDecorationCss, borderToStyle, mergeStyles, paragraphToStyle, resolveShadingFill, sectionToStyle, tableCellToStyle, textToStyle, underlineDecorationCss, underlineStyleFromCssDecoration };

package/dist/utils/formatToStyle.js

@@ -1,7 +1,13 @@
+import { UNDERLINE_STROKES } from "../display-list/build/strokes.js";
+import { UNDERLINE_THICKNESS_RATIO } from "../display-list/build/textDecorations.js";
+import { UNDERLINE_STYLE_VALUES } from "../types/documentEnumValues.js";
+import { cssBorderStyle } from "./borderCss.js";
 import { resolveColor, resolveHighlightToCss, resolveShadingColor } from "./colorResolver.js";
 import { resolveFontFamily, resolveThemeFont } from "./fontResolver.js";
 import { getHorizontalScaleFactor, normalizeHorizontalScalePercent } from "./horizontalScale.js";
+import { textFlowCss } from "./textDirectionFlow.js";
 import { AUTO_PARAGRAPH_SPACING_PX, eighthsToPixels, formatPx, halfPointsToPixels, halfPointsToPoints, twipsToPixels } from "./units.js";
+import { statesNoBorder } from "@stll/docx-core/model";
 //#region src/utils/formatToStyle.ts
 /**
 * Convert TextFormatting to CSS properties for a run/span
@@ -31,10 +37,12 @@ function textToStyle(formatting, theme) {
 	const decorations = [];
 	const decorationStyles = [];
 	const decorationColors = [];
+	let decorationThickness;
 	if (formatting.underline && formatting.underline.style !== "none") {
 		decorations.push("underline");
-		const underlineStyle = mapUnderlineStyle(formatting.underline.style);
-		if (underlineStyle !== "solid") decorationStyles.push(underlineStyle);
+		const underline = underlineDecorationCss(formatting.underline.style);
+		if (underline.decorationStyle !== void 0 && underline.decorationStyle !== "solid") decorationStyles.push(underline.decorationStyle);
+		decorationThickness = underline.decorationThickness;
 		if (formatting.underline.color) decorationColors.push(resolveColor(formatting.underline.color, theme));
 	}
 	if (formatting.strike) decorations.push("line-through");
@@ -43,6 +51,7 @@ function textToStyle(formatting, theme) {
 		style.textDecoration = decorations.join(" ");
 		if (decorationStyles.length > 0) style.textDecorationStyle = decorationStyles[0];
 		if (decorationColors.length > 0) style.textDecorationColor = decorationColors[0];
+		if (decorationThickness !== void 0) style.textDecorationThickness = decorationThickness;
 	}
 	if (formatting.vertAlign) switch (formatting.vertAlign) {
 		case "superscript":
@@ -90,7 +99,7 @@ function textToStyle(formatting, theme) {
 function paragraphToStyle(formatting, theme) {
 	if (!formatting) return {};
 	const style = {};
-	if (formatting.alignment) style.textAlign = mapAlignment(formatting.alignment);
+	if (formatting.alignment) style.textAlign = CSS_TEXT_ALIGN_BY_PARAGRAPH_ALIGNMENT[formatting.alignment];
 	if (formatting.beforeAutospacing) style.marginTop = formatPx(AUTO_PARAGRAPH_SPACING_PX);
 	else if (formatting.spaceBefore !== void 0) style.marginTop = formatPx(twipsToPixels(formatting.spaceBefore));
 	if (formatting.afterAutospacing) style.marginBottom = formatPx(AUTO_PARAGRAPH_SPACING_PX);
@@ -136,11 +145,11 @@ function paragraphToStyle(formatting, theme) {
 * @returns Partial CSSProperties with border styles
 */
 function borderToStyle(border, side = "", theme) {
-	if (!border || border.style === "none" || border.style === "nil") return {};
+	if (!border || statesNoBorder(border.style)) return {};
 	const style = {};
 	const widthPx = border.size !== void 0 && border.size !== 0 ? eighthsToPixels(border.size) : 1;
 	const color = border.color ? resolveColor(border.color, theme) : "#000000";
-	const cssStyle = mapBorderStyle(border.style);
+	const cssStyle = cssBorderStyle(border.style);
 	const widthKey = `border${side}Width`;
 	const styleKey = `border${side}Style`;
 	const colorKey = `border${side}Color`;
@@ -211,58 +220,126 @@ function resolveShadingFill(shading, theme) {
 	return "";
 }
 /**
-* Map OOXML underline style to CSS text-decoration-style
+* The underline every DOM backend draws when the author named no member.
+*
+* It is also what an underline CSS cannot spell parses back as; see
+* `underlineStyleFromCssDecoration`.
 */
-function mapUnderlineStyle(underlineStyle) {
-	switch (underlineStyle) {
-		case "double": return "double";
-		case "dotted":
-		case "dottedHeavy": return "dotted";
-		case "dash":
-		case "dashedHeavy":
-		case "dashLong":
-		case "dashLongHeavy":
-		case "dotDash":
-		case "dashDotHeavy":
-		case "dotDotDash":
-		case "dashDotDotHeavy": return "dashed";
-		case "wave":
-		case "wavyHeavy":
-		case "wavyDouble": return "wavy";
-		default: return "solid";
-	}
-}
+const PLAIN_UNDERLINE = "single";
 /**
-* Map OOXML paragraph alignment to CSS text-align
+* Every `ST_Underline` member's CSS line. The one table: the ProseMirror mark's
+* `toDOM`, the DOM painter and `textToStyle` all render a run from this, so a
+* member cannot paint one line in the editor and another on the page.
+*
+* `none` cancels an underline inherited from the style chain rather than
+* naming a line style, and `text-decoration-style: none` is not a CSS keyword,
+* so that member names no keyword and carries no declarations at all.
+*
+* Where CSS has no keyword for what Word draws, the member is approximated and
+* the approximation is stated here rather than at a call site: `words`
+* underlines the spaces between words too (`text-decoration-skip-ink` skips
+* descender ink, not spaces, and `text-decoration-skip: spaces` never
+* shipped); `wavyDouble` draws two straight lines rather than two wavy ones;
+* `dashLong`, `dotDash` and `dotDotDash` draw the single dash pattern CSS has.
+* The `*Heavy` members and `thick` differ from their plain counterparts in
+* weight only, which the thickness carries, so the line they name is their
+* plain counterpart's.
 */
-function mapAlignment(alignment) {
-	switch (alignment) {
-		case "center": return "center";
-		case "right": return "right";
-		case "both":
-		case "distribute": return "justify";
-		default: return "left";
+const UNDERLINE_DECORATION_STYLES = {
+	none: void 0,
+	single: "solid",
+	words: "solid",
+	double: "double",
+	thick: "solid",
+	dotted: "dotted",
+	dottedHeavy: "dotted",
+	dash: "dashed",
+	dashedHeavy: "dashed",
+	dashLong: "dashed",
+	dashLongHeavy: "dashed",
+	dotDash: "dashed",
+	dashDotHeavy: "dashed",
+	dotDotDash: "dashed",
+	dashDotDotHeavy: "dashed",
+	wave: "wavy",
+	wavyHeavy: "wavy",
+	wavyDouble: "double"
+};
+/**
+* The CSS an authored underline paints with.
+*
+* CSS has no heavy keyword, so a weight is stated as a length: the plain ratio
+* the display list strokes with, times the weight the member's own row carries
+* (`display-list/build/strokes.ts`). Both backends therefore scale the same way
+* with the font size, and which members are heavy is read off the row rather
+* than listed again here, so the page and the editor cannot disagree about it.
+*/
+const underlineDecorationCss = (style) => {
+	const decorationStyle = UNDERLINE_DECORATION_STYLES[style];
+	if (decorationStyle === void 0) return {};
+	const { weight } = UNDERLINE_STROKES[style];
+	if (weight === 1) return { decorationStyle };
+	return {
+		decorationStyle,
+		decorationThickness: `${(UNDERLINE_THICKNESS_RATIO * weight).toFixed(4)}em`
+	};
+};
+/**
+* Each CSS keyword's canonical author, derived from the one table: the first
+* member in enumeration order that paints exactly that keyword at the font's
+* own weight.
+*/
+const CANONICAL_UNDERLINE_STYLE_BY_CSS = (() => {
+	const canonical = /* @__PURE__ */ new Map();
+	for (const style of UNDERLINE_STYLE_VALUES) {
+		const { decorationStyle, decorationThickness } = underlineDecorationCss(style);
+		if (decorationStyle === void 0 || decorationThickness !== void 0) continue;
+		if (!canonical.has(decorationStyle)) canonical.set(decorationStyle, style);
 	}
-}
+	return canonical;
+})();
 /**
-* Map OOXML border style to CSS border-style
+* The `ST_Underline` member an authored `text-decoration` or
+* `text-decoration-style` value parses back as.
+*
+* The table is many-to-one, so the inverse cannot be: several members share
+* every keyword. It resolves each keyword to that keyword's canonical author,
+* the plain member whose own CSS is exactly the keyword, so a member folio
+* cannot spell in CSS comes back as the sibling it is drawn as: `dottedHeavy`
+* as `dotted`, `words` and `thick` as `single`, `wavyDouble` as `double`. A
+* value naming no keyword folio writes parses as the plain underline.
 */
-function mapBorderStyle(borderStyle) {
-	switch (borderStyle) {
-		case "none":
-		case "nil": return "none";
-		case "double":
-		case "triple": return "double";
-		case "dotted": return "dotted";
-		case "dashed":
-		case "dashSmallGap": return "dashed";
-		case "threeDEmboss": return "ridge";
-		case "threeDEngrave": return "groove";
-		case "outset": return "outset";
-		case "inset": return "inset";
-		default: return "solid";
+const underlineStyleFromCssDecoration = (value) => {
+	for (const token of value.toLowerCase().split(/[\s,]+/u)) {
+		const style = CANONICAL_UNDERLINE_STYLE_BY_CSS.get(token);
+		if (style !== void 0) return style;
 	}
-}
+	return PLAIN_UNDERLINE;
+};
+/**
+* Every `ST_Jc` member, and the CSS `text-align` that renders it.
+*
+* `start` and `end` carry straight over: CSS spells the direction-aware edges
+* the same way and resolves them against the element's direction, as Word
+* does. The Kashida justifications and `distribute` all render as `justify`,
+* which is as close as CSS gets. `numTab` aligns to the list number's tab
+* stop, which CSS cannot express, so it renders at the start edge — where a
+* numbered paragraph without one sits.
+*/
+const CSS_TEXT_ALIGN_BY_PARAGRAPH_ALIGNMENT = {
+	start: "start",
+	end: "end",
+	numTab: "start",
+	left: "left",
+	center: "center",
+	right: "right",
+	both: "justify",
+	distribute: "justify",
+	mediumKashida: "justify",
+	highKashida: "justify",
+	lowKashida: "justify",
+	thaiDistribute: "justify"
+};
 /**
 * Merge multiple CSSProperties objects
 *
@@ -287,7 +364,11 @@ function tableCellToStyle(formatting, theme) {
 	if (!formatting) return {};
 	const style = {};
 	if (formatting.verticalAlign) style.verticalAlign = formatting.verticalAlign;
-	if (formatting.textDirection && (formatting.textDirection.includes("rl") || formatting.textDirection.includes("Rl"))) style.direction = "rtl";
+	if (formatting.textDirection) {
+		const flow = textFlowCss(formatting.textDirection);
+		if (flow.writingMode !== "horizontal-tb") style.writingMode = flow.writingMode;
+		if (flow.rotateDegrees !== void 0) style.transform = `rotate(${String(flow.rotateDegrees)}deg)`;
+	}
 	if (formatting.shading) {
 		const bgColor = resolveShadingFill(formatting.shading, theme);
 		if (bgColor) style.backgroundColor = bgColor;
@@ -328,4 +409,4 @@ function sectionToStyle(sectionProps, theme) {
 	return style;
 }
 //#endregion
-export { borderToStyle, mergeStyles, paragraphToStyle, resolveShadingFill, sectionToStyle, tableCellToStyle, textToStyle };
+export { PLAIN_UNDERLINE, UNDERLINE_DECORATION_STYLES, borderToStyle, mergeStyles, paragraphToStyle, resolveShadingFill, sectionToStyle, tableCellToStyle, textToStyle, underlineDecorationCss, underlineStyleFromCssDecoration };

package/dist/utils/headingCollector.js

@@ -1,4 +1,5 @@
 import { resolveHeadingLevel } from "../docx/builtInStyles.js";
+import { readOutlineLevelAttr } from "../prosemirror/outlineLevelAttr.js";
 //#region src/utils/headingCollector.ts
 /**
 * Collect all headings from a ProseMirror document, in document order.
@@ -14,8 +15,8 @@ function collectHeadings(doc, styles) {
 	doc.descendants((node, pos) => {
 		if (node.type.name !== "paragraph") return;
 		const level = resolveHeadingLevel({
-			outlineLevel: node.attrs["outlineLevel"],
-			styleId: node.attrs["styleId"]
+			outlineLevel: readOutlineLevelAttr(node.attrs["outlineLevel"]),
+			styleId: typeof node.attrs["styleId"] === "string" ? node.attrs["styleId"] : null
 		}, styles);
 		if (level === void 0) return;
 		let text = "";

package/dist/utils/imageLuminance.d.ts

@@ -0,0 +1,15 @@
+//#region src/utils/imageLuminance.d.ts
+type ImageLuminance = {
+  brightness?: number | null;
+  contrast?: number | null;
+};
+/** Clamp a finite percentage to the range accepted by DrawingML `a:lum`. */
+declare const normalizeImageLuminancePercent: (value: number) => number;
+/**
+ * Convert DrawingML brightness and contrast percentages into Word's single
+ * linear per-channel transfer, expressed as CSS filters without an
+ * intermediate clamp changing the result.
+ */
+declare const imageLuminanceFilter: ({ brightness, contrast }: ImageLuminance) => string | undefined;
+//#endregion
+export { ImageLuminance, imageLuminanceFilter, normalizeImageLuminancePercent };

package/dist/utils/imageLuminance.js

@@ -0,0 +1,32 @@
+//#region src/utils/imageLuminance.ts
+const MAX_PERCENT = 100;
+const HARD_STEP_SLOPE = 1e3;
+/** Clamp a finite percentage to the range accepted by DrawingML `a:lum`. */
+const normalizeImageLuminancePercent = (value) => Math.max(-100, Math.min(MAX_PERCENT, value));
+const finitePercent = (value) => value == null || !Number.isFinite(value) ? 0 : normalizeImageLuminancePercent(value);
+const styleNumber = (value) => {
+	const rounded = Math.round(value * 1e6) / 1e6;
+	return String(Object.is(rounded, -0) ? 0 : rounded);
+};
+/**
+* Convert DrawingML brightness and contrast percentages into Word's single
+* linear per-channel transfer, expressed as CSS filters without an
+* intermediate clamp changing the result.
+*/
+const imageLuminanceFilter = ({ brightness, contrast }) => {
+	const bright = finitePercent(brightness) / MAX_PERCENT;
+	const contrastAmount = finitePercent(contrast) / MAX_PERCENT;
+	if (bright === 0 && contrastAmount === 0) return;
+	const slope = contrastAmount >= 0 ? Math.min(HARD_STEP_SLOPE, 1 / (1 - contrastAmount)) : Math.max(0, 1 + contrastAmount);
+	const pivot = .5 - bright / 2;
+	const intercept = pivot + bright - slope * pivot;
+	if (intercept >= 0) {
+		const brightnessAmount = slope + 2 * intercept;
+		if (brightnessAmount <= 0) return "brightness(0)";
+		return `contrast(${styleNumber(slope / brightnessAmount)}) brightness(${styleNumber(brightnessAmount)})`;
+	}
+	const contrastFactor = 1 - 2 * intercept;
+	return `brightness(${styleNumber(slope / contrastFactor)}) contrast(${styleNumber(contrastFactor)})`;
+};
+//#endregion
+export { imageLuminanceFilter, normalizeImageLuminancePercent };

package/dist/utils/mergeDocumentContent.js

@@ -1,3 +1,4 @@
+import { paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { cloneParagraphWithoutPropertySource } from "../docx/paragraphPropertySource.js";
 //#region src/utils/mergeDocumentContent.ts
 /**
@@ -91,6 +92,12 @@ function remapBlock(block, numIdRemap, abstractNumIdRemap) {
 	};
 	return block;
 }
+/** A cell holds no content control, so the walk stays inside its own union. */
+function remapCellBlock(block, numIdRemap, abstractNumIdRemap) {
+	if (block.type === "paragraph") return remapParagraph(block, numIdRemap, abstractNumIdRemap);
+	if (block.type === "table") return remapTable(block, numIdRemap, abstractNumIdRemap);
+	return block;
+}
 function remapTable(table, numIdRemap, abstractNumIdRemap) {
 	return {
 		...table,
@@ -98,36 +105,21 @@ function remapTable(table, numIdRemap, abstractNumIdRemap) {
 			...row,
 			cells: row.cells.map((cell) => ({
 				...cell,
-				content: cell.content.map((item) => remapCellItem(item, numIdRemap, abstractNumIdRemap))
+				content: cell.content.map((item) => remapCellBlock(item, numIdRemap, abstractNumIdRemap))
 			}))
 		}))
 	};
 }
-/**
-* `TableCell.content` is typed as `(Paragraph | Table)[]` — narrower than
-* `BlockContent` — because folio's own DOCX parser flattens a `w:sdt` inside
-* a cell into its `sdtContent` children (see `tableParser.ts`) rather than
-* keeping a `blockSdt` wrapper. A hand-built `Document` is not bound by that
-* invariant, so delegate to `remapBlock` (which fully handles paragraph,
-* table, and container blocks, including nested tables) and only accept its
-* result back into the cell when it is still a `Paragraph | Table` — an
-* anomalous `blockSdt` (or any other shape `remapBlock` had to pass through
-* unchanged) is left as-is rather than smuggled into a field the type system
-* says can't hold it.
-*/
-function remapCellItem(item, numIdRemap, abstractNumIdRemap) {
-	const remapped = remapBlock(item, numIdRemap, abstractNumIdRemap);
-	return remapped.type === "blockSdt" ? item : remapped;
-}
 function remapParagraph(paragraph, numIdRemap, abstractNumIdRemap) {
-	const numId = paragraph.formatting?.numPr?.numId;
+	const numPr = paragraph.formatting?.numPr;
+	const numId = paragraphNumberingReferenceId(numPr);
 	const remappedNumId = numId === void 0 ? void 0 : numIdRemap.get(numId);
-	if (remappedNumId === void 0) return paragraph;
+	if (remappedNumId === void 0 || numPr?.kind !== "reference") return paragraph;
 	return cloneParagraphWithoutPropertySource(paragraph, {
 		formatting: {
 			...paragraph.formatting,
 			numPr: {
-				...paragraph.formatting?.numPr,
+				...numPr,
 				numId: remappedNumId
 			}
 		},

package/dist/utils/paragraphFormattingMerge.js

@@ -1,4 +1,5 @@
 import { mergeTextFormatting } from "./textFormattingMerge.js";
+import { mergeParagraphNumbering } from "@stll/docx-core/model";
 //#region src/utils/paragraphFormattingMerge.ts
 const PARAGRAPH_REPLACE_KEYS = [
 	"alignment",
@@ -41,6 +42,28 @@ function mergeParagraphTabStops(inherited, direct) {
 	return [...stopsByPosition.values()].toSorted((a, b) => a.position - b.position);
 }
 /**
+* A resolved cascade carries no captured bytes.
+*
+* `preserved` holds the markup of the one element it was read from, and the
+* two attribute remainders beside it hold the attributes of the `w:ind` and
+* `w:spacing` that element carried. A style's `w:pPr` is not a paragraph's
+* direct formatting, and a merge that let a spread carry either would write
+* the same bytes at two tiers and make an inherited value outrank the tier it
+* came from — the rule #873 states for every other inherited `w:pPr` value.
+* Every caller of the merge below builds a resolved cascade rather than a
+* saved element, so the drop is unconditional and belongs here, where a new
+* field cannot slip past it in a spread.
+*
+* The remainders inside `borders`, `shading` and `tabs` are not dropped, and
+* that is the same rule rather than an exception: those records replace
+* wholesale, so an inherited one is written back only where the whole record
+* is, and the attributes the author wrote on it belong with it.
+*/
+const withoutPreservedMarkup = (formatting) => {
+	const { preserved: _preserved, indentPreservedAttributes: _indentPreservedAttributes, spacingPreservedAttributes: _spacingPreservedAttributes, ...resolved } = formatting;
+	return resolved;
+};
+/**
 * Merge paragraph properties for OOXML style cascade resolution.
 *
 * The source is the higher-priority layer. Most `w:pPr` properties replace an
@@ -51,11 +74,11 @@ function mergeParagraphTabStops(inherited, direct) {
 function mergeParagraphFormatting(target, source) {
 	if (!source) return target;
 	if (!target) {
-		const result = { ...source };
+		const result = withoutPreservedMarkup(source);
 		if (source.tabs !== void 0) result.tabs = [...source.tabs];
 		return result;
 	}
-	const result = { ...target };
+	const result = withoutPreservedMarkup(target);
 	for (const key of PARAGRAPH_REPLACE_KEYS) copyDefinedParagraphProperty(result, source, key);
 	if (source.indentFirstLine !== void 0) result.hangingIndent = source.hangingIndent === true;
 	const mergedRunProperties = mergeTextFormatting(result.runProperties, source.runProperties);
@@ -64,10 +87,8 @@ function mergeParagraphFormatting(target, source) {
 		...result.borders,
 		...source.borders
 	};
-	if (source.numPr !== void 0) result.numPr = {
-		...result.numPr,
-		...source.numPr
-	};
+	const mergedNumbering = mergeParagraphNumbering(result.numPr, source.numPr);
+	if (mergedNumbering !== void 0) result.numPr = mergedNumbering;
 	if (source.frame !== void 0) result.frame = {
 		...result.frame,
 		...source.frame

package/dist/utils/replaceText.js

@@ -49,6 +49,7 @@ function getParagraphByIndex(body, paragraphIndex) {
 				}
 				continue;
 			}
+			if (block.type !== "blockSdt") continue;
 			const found = walkBlocks(block.content);
 			if (found !== null) return found;
 		}

package/dist/utils/tableOperations.d.ts

@@ -3,8 +3,10 @@ import { document_d_exports } from "../types/document.js";
 type TablePropertiesCommand = {
   width?: number | null;
   widthType?: document_d_exports.TableWidthType | null;
-  justification?: "left" | "center" | "right" | null;
+  justification?: document_d_exports.TableAlignment | null;
 };
+declare const TABLE_PROPERTY_JUSTIFICATIONS: readonly ("start" | "center" | "end" | "left" | "right")[];
+declare const toTablePropertyJustification: (value: string | null | undefined) => NonNullable<TablePropertiesCommand["justification"]>;
 type TableAction = "addRowAbove" | "addRowBelow" | "addColumnLeft" | "addColumnRight" | "deleteRow" | "deleteColumn" | "mergeCells" | "splitCell" | "deleteTable" | "selectTable" | "selectRow" | "selectColumn" | "borderAll" | "borderOutside" | "borderInside" | "borderNone" | "borderTop" | "borderBottom" | "borderLeft" | "borderRight" | {
   type: "cellFillColor";
   color: string | null;
@@ -17,7 +19,7 @@ type TableAction = "addRowAbove" | "addRowBelow" | "addColumnLeft" | "addColumnR
 } | {
   type: "cellBorder";
   side: "top" | "bottom" | "left" | "right" | "all";
-  style: string;
+  style: document_d_exports.BorderStyle;
   size: number;
   color: string;
 } | {
@@ -84,4 +86,4 @@ declare const deleteColumn: (table: document_d_exports.Table, columnIndex: numbe
 declare const mergeCells: (table: document_d_exports.Table, selection: TableSelection) => document_d_exports.Table;
 declare const splitCell: (table: document_d_exports.Table, rowIndex: number, columnIndex: number) => document_d_exports.Table;
 //#endregion
-export { TableAction, TableContext, TablePropertiesCommand, TableSelection, addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell };
+export { TABLE_PROPERTY_JUSTIFICATIONS, TableAction, TableContext, TablePropertiesCommand, TableSelection, addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell, toTablePropertyJustification };