@stll/folio-core 0.46.0 → 0.47.0

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/mergeDocumentContent.js

@@ -1,3 +1,4 @@
+import { paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { cloneParagraphWithoutPropertySource } from "../docx/paragraphPropertySource.js";
 //#region src/utils/mergeDocumentContent.ts
 /**
@@ -110,14 +111,15 @@ function remapTable(table, numIdRemap, abstractNumIdRemap) {
 	};
 }
 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,7 +49,7 @@ function getParagraphByIndex(body, paragraphIndex) {
 				}
 				continue;
 			}
-			if (block.type === "preservedBlock") 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 };

package/dist/utils/tableOperations.js

@@ -1,4 +1,17 @@
+import { TABLE_JUSTIFICATION_VALUES } from "../types/documentEnumValues.js";
 //#region src/utils/tableOperations.ts
+const TABLE_PROPERTY_JUSTIFICATION_ORDER = {
+	left: 0,
+	center: 1,
+	right: 2,
+	start: 3,
+	end: 4
+};
+const TABLE_PROPERTY_JUSTIFICATIONS = Object.freeze(TABLE_JUSTIFICATION_VALUES.toSorted((left, right) => TABLE_PROPERTY_JUSTIFICATION_ORDER[left] - TABLE_PROPERTY_JUSTIFICATION_ORDER[right]));
+const toTablePropertyJustification = (value) => {
+	for (const justification of TABLE_PROPERTY_JUSTIFICATIONS) if (value === justification) return justification;
+	return "left";
+};
 const getColumnCount = (table) => {
 	let maxCols = 0;
 	for (const row of table.rows) {
@@ -256,4 +269,4 @@ const splitCell = (table, rowIndex, columnIndex) => {
 	};
 };
 //#endregion
-export { addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell };
+export { TABLE_PROPERTY_JUSTIFICATIONS, addColumn, addRow, createTableContext, deleteColumn, deleteRow, getCellAt, getColumnCount, mergeCells, splitCell, toTablePropertyJustification };

package/dist/utils/tablePlacement.d.ts

@@ -0,0 +1,7 @@
+import { TableAlignment } from "../types/formatting.js";
+//#region src/utils/tablePlacement.d.ts
+type PhysicalTableAlignment = "left" | "center" | "right";
+/** Resolve an OOXML table placement to a physical inline alignment. */
+declare const resolveTablePlacementAlignment: (placement: TableAlignment, rightToLeft: boolean) => PhysicalTableAlignment;
+//#endregion
+export { PhysicalTableAlignment, resolveTablePlacementAlignment };

package/dist/utils/tablePlacement.js

@@ -0,0 +1,14 @@
+//#region src/utils/tablePlacement.ts
+/** Resolve an OOXML table placement to a physical inline alignment. */
+const resolveTablePlacementAlignment = (placement, rightToLeft) => {
+	switch (placement) {
+		case "center": return "center";
+		case "left":
+		case "start": return rightToLeft ? "right" : "left";
+		case "right":
+		case "end": return rightToLeft ? "left" : "right";
+		default: return placement;
+	}
+};
+//#endregion
+export { resolveTablePlacementAlignment };

package/dist/utils/textDirectionFlow.d.ts

@@ -0,0 +1,15 @@
+import { TextDirection } from "@stll/docx-core/model";
+//#region src/utils/textDirectionFlow.d.ts
+type TextFlowCss = {
+  /** `horizontal-tb` needs no declaration; the others are written out. */
+  writingMode: "horizontal-tb" | "vertical-lr" | "vertical-rl";
+  /**
+   * CSS has no writing mode for a bottom-to-top flow, so the nearest one is
+   * turned upside down.
+   */
+  rotateDegrees?: 180;
+};
+/** The CSS a `w:textDirection` token renders as, through the flow it names. */
+declare const textFlowCss: (direction: TextDirection) => TextFlowCss;
+//#endregion
+export { TextFlowCss, textFlowCss };

package/dist/utils/textDirectionFlow.js

@@ -0,0 +1,38 @@
+import { TEXT_DIRECTION_FLOW_BY_TOKEN } from "@stll/docx-core/model";
+//#region src/utils/textDirectionFlow.ts
+/**
+* The CSS one `w:textDirection` flow renders as.
+*
+* `ST_TextDirection` spells each of its six flows twice — a Strict spelling
+* and a Transitional one — so rendering is decided per flow and read through
+* `TEXT_DIRECTION_FLOW_BY_TOKEN`. Both CSS projections, the editor's inline
+* style and `tableCellToStyle`, read this one map: a cell written `tbRl` and
+* its Strict twin written `rl` cannot render differently in one and the same
+* in the other.
+*/
+/**
+* Each text flow, and the CSS that renders it.
+*
+* `tb` and `tbV` are the horizontal flows. `rl` and `rlV` run their lines
+* right to left, `lrV` runs them left to right, and `lr` runs them left to
+* right with its characters bottom-to-top, which CSS cannot express: it takes
+* the nearest writing mode turned over.
+*
+* Total over the flows on purpose: a flow nobody mapped would otherwise render
+* as horizontal text with nothing to say it had been dropped.
+*/
+const TEXT_FLOW_CSS = {
+	tb: { writingMode: "horizontal-tb" },
+	tbV: { writingMode: "horizontal-tb" },
+	rl: { writingMode: "vertical-rl" },
+	rlV: { writingMode: "vertical-rl" },
+	lrV: { writingMode: "vertical-lr" },
+	lr: {
+		writingMode: "vertical-lr",
+		rotateDegrees: 180
+	}
+};
+/** The CSS a `w:textDirection` token renders as, through the flow it names. */
+const textFlowCss = (direction) => TEXT_FLOW_CSS[TEXT_DIRECTION_FLOW_BY_TOKEN[direction]];
+//#endregion
+export { textFlowCss };

package/dist/utils/textFormattingMerge.js

@@ -31,14 +31,26 @@ function mergeStyleTextFormatting(target, source) {
 	}
 	return result;
 }
+/**
+* A merge answers "what does this text look like once the style, the paragraph
+* mark and the run have all had their say". `preserved` is not a value: it is
+* the bytes one specific `w:rPr` held, and carrying it across a merge would
+* write a style's or a paragraph mark's markup into every run that inherits
+* from it. So no merged formatting has one, on any path out of the function.
+*/
+const withoutPreserved = (formatting) => {
+	if (formatting.preserved === void 0) return formatting;
+	const { preserved: _preserved, ...values } = formatting;
+	return values;
+};
 function mergeTextFormatting(target, source) {
 	if (!source && !target) return;
-	if (!source) return target;
-	if (!target) return { ...source };
-	const result = { ...target };
+	if (!source) return target && withoutPreserved(target);
+	if (!target) return withoutPreserved({ ...source });
+	const result = { ...withoutPreserved(target) };
 	for (const key of Object.keys(source)) {
 		const value = source[key];
-		if (value === void 0) continue;
+		if (value === void 0 || key === "preserved") continue;
 		if (key === "fontFamily" && typeof value === "object") {
 			result["fontFamily"] = mergeFontFamily(target.fontFamily, value);
 			continue;