@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/schema/nodes.d.ts

@@ -56,6 +56,8 @@ type PreservedXmlAttrs = {
 type PreservedBlockAttrs = {
   /** Replayable markup, as `captureVerbatimXml` wrote it. */
   xml: string;
+  /** Plain text safely extracted from a related w:altChunk part, when available. */
+  readerText?: string;
 };
 type BookmarkBoundaryAttrs = {
   type: "start";
@@ -118,6 +120,13 @@ type ParagraphAttrs = {
    * `paragraphNumberingAttr`, so a model value cannot land here unconverted.
    */
   numPr?: ParagraphNumberingAttr;
+  /** Clipboard-only hint, replaced with a numbered paragraph before insertion. */
+  _pastedHtmlList?: {
+    group: number;
+    level: number;
+    kind: "bullet" | "numbered";
+    start?: number;
+  };
   /**
    * The style-sourced numPr value when `numPr` came from the paragraph
    * style rather than direct formatting. While `numPr` still equals this,
@@ -526,7 +535,7 @@ type ImageAttrs = {
 /**
  * Field node attributes
  */
-type FieldAttrs = {
+type CommonFieldAttrs = {
   /** Field type: PAGE, NUMPAGES, DATE, MERGEFIELD, etc. */
   fieldType: document_d_exports.FieldType;
   /** Full field instruction (e.g. "PAGE \\* MERGEFORMAT") */
@@ -535,20 +544,30 @@ type FieldAttrs = {
   displayText: string;
   /** Imported cache that proved numbered REF resolution for this field. */
   _numberedRefBaseline?: string;
-  /** Whether the field came from w:fldSimple or a complex fldChar range */
-  fieldKind: "simple" | "complex";
   /** Field is locked */
   fldLock?: boolean;
   /** Field is dirty and should be recalculated by the host application */
   dirty?: boolean;
-  /**
-   * `displayText` is a rendering fallback folio synthesized (e.g. a legacy
-   * `FORMCHECKBOX` with no cached result run), not authored content. A save
-   * omits it from the field's result so an unedited field keeps its
-   * original, resultless bytes. See `ComplexField.fieldResultIsFallback`.
-   */
-  fieldResultIsFallback?: boolean;
+  /** Authored empty result runs, which have no visible ProseMirror children. */
+  _docxEmptyResultRuns?: document_d_exports.Run[];
 };
+type FieldAttrs = CommonFieldAttrs & ({
+  fieldKind: "simple";
+  fieldResultIsFallback?: never;
+  formFieldDataXml?: never;
+  _docxFieldCode?: never;
+} | {
+  fieldKind: "complex";
+  /** Synthesized display text that must not become an authored result run. */
+  fieldResultIsFallback?: boolean;
+  /** Captured `w:ffData` on a complex field's begin character. */
+  formFieldDataXml?: string;
+  /** Source code runs; valid only while the instruction still matches. */
+  _docxFieldCode?: {
+    instruction: string;
+    runs: document_d_exports.Run[];
+  };
+});
 /**
  * Math equation node attributes
  */
@@ -649,6 +668,12 @@ type BlockSdtAttrs = {
   /** Verbatim XML for sdt siblings after sdtContent (range markers). */
   rawSdtChildrenAfterContent?: string;
 };
+/** Verbatim shell retained around editable block custom XML content. */
+type BlockCustomXmlAttrs = {
+  openingXml: string;
+  closingXml: string;
+  _originallyEmpty: boolean;
+};
 /**
  * The `mc:AlternateContent` a shape or text box was read from, with a
  * fingerprint of the node it was attached to. `fromProseDoc` hands the element
@@ -992,6 +1017,8 @@ type TableAttrs = {
    * none and a copy does not inherit one.
    */
   _preserved?: document_d_exports.TablePreservedMarkup;
+  /** Transparent table-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /**
    * Marks this whole table as a *suggested* insertion (AI proposal). The table
    * is dropped from serialized DOCX until accepted; because OOXML has no tracked
@@ -1003,6 +1030,8 @@ type TableAttrs = {
  * Table row attributes
  */
 type TableRowAttrs = {
+  /** Transaction-local cleanup state; cleared before dispatch or continuation capture. */
+  _batchRowCleanup?: "pending" | null;
   /** Row height (in twips) */
   height?: number;
   /** Height rule ('auto', 'exact', 'atLeast') */
@@ -1054,6 +1083,8 @@ type TableRowAttrs = {
    * name the same control. See `TableRow.contentControls`.
    */
   contentControls?: document_d_exports.SdtProperties[];
+  /** Transparent row-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /**
    * Markup the authored `w:tr` carried beside its cells, with the cell count
    * that places it back between the same two cells. Follows the record the
@@ -1219,10 +1250,12 @@ type TableCellAttrs = {
    * outermost first. The row's twin, one level down.
    */
   contentControls?: document_d_exports.SdtProperties[];
+  /** Transparent row-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /** Preserve a DOCX vMerge restart even when PM cannot model it as a rowspan. */
   _preserveVMergeRestart?: boolean;
   /** Original DOCX vMerge continuation cells skipped into this PM rowspan. */
   _docxVMergeContinuationCells?: unknown;
 };
 //#endregion
-export { AlternateContentAttrs, AuthoredEmuAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CommentReferenceAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PRESERVED_XML_LEVELS, PageBreakRunAttrs, ParagraphAttrs, ParagraphAttrsPatch, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs, TextBoxTextBodyContentState };
+export { AlternateContentAttrs, AuthoredEmuAttrs, BlockCustomXmlAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CommentReferenceAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PRESERVED_XML_LEVELS, PageBreakRunAttrs, ParagraphAttrs, ParagraphAttrsPatch, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs, TextBoxTextBodyContentState };

package/dist/prosemirror/sectionMarkEdits.d.ts

@@ -0,0 +1,20 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/sectionMarkEdits.d.ts
+type SectionMarkEdits = {
+  /** Section records whose paragraph mark a replacement deleted. */
+  deletedMarks: ReadonlySet<document_d_exports.SectionProperties>;
+  /**
+   * Paragraphs of the final document, by position, and the section record
+   * each must hold because of the mark it now ends with.
+   */
+  carriers: readonly {
+    position: number;
+    record: document_d_exports.SectionProperties | null;
+  }[];
+};
+/** Read `transactions`, applied in order and ending at `finalDoc`. */
+declare const sectionMarkEditsOf: (transactions: readonly Transaction[], finalDoc: Node) => SectionMarkEdits;
+//#endregion
+export { SectionMarkEdits, sectionMarkEditsOf };

package/dist/prosemirror/sectionMarkEdits.js

@@ -0,0 +1,59 @@
+import { sectionPropertiesOf } from "./sectionCarrier.js";
+import { Mapping, ReplaceStep } from "prosemirror-transform";
+//#region src/prosemirror/sectionMarkEdits.ts
+const isParagraph = (node) => node.type.name === "paragraph";
+/** Read `transactions`, applied in order and ending at `finalDoc`. */
+const sectionMarkEditsOf = (transactions, finalDoc) => {
+	const deletedMarks = /* @__PURE__ */ new Set();
+	const carriers = [];
+	const replacements = [];
+	const mapping = new Mapping();
+	for (const transaction of transactions) for (const [index, step] of transaction.steps.entries()) {
+		const doc = transaction.docs[index];
+		if (step instanceof ReplaceStep && step.from < step.to && doc) replacements.push({
+			step,
+			doc,
+			mapIndex: mapping.maps.length
+		});
+		const map = transaction.mapping.maps[index];
+		if (map) mapping.appendMap(map);
+	}
+	for (const { step, doc, mapIndex } of replacements) {
+		const { from, to } = step;
+		doc.nodesBetween(from, to, (node, position) => {
+			if (!isParagraph(node)) return true;
+			const record = sectionPropertiesOf(node);
+			const markFrom = position + node.nodeSize - 1;
+			if (record && markFrom >= from && markFrom + 1 <= to) deletedMarks.add(record);
+			return false;
+		});
+		const $from = doc.resolve(from);
+		const $to = doc.resolve(to);
+		if (!isParagraph($from.parent) || !isParagraph($to.parent) || $from.start() === $to.start()) continue;
+		const leftRecord = sectionPropertiesOf($from.parent);
+		const rightRecord = sectionPropertiesOf($to.parent);
+		if (leftRecord === null && rightRecord === null) continue;
+		const after = mapping.slice(mapIndex);
+		const left = after.mapResult(from, -1);
+		const right = after.mapResult(to, 1);
+		if (right.deleted) continue;
+		const $right = finalDoc.resolve(right.pos);
+		if (!isParagraph($right.parent)) continue;
+		carriers.push({
+			position: $right.before(),
+			record: rightRecord
+		});
+		if (left.deleted) continue;
+		const $left = finalDoc.resolve(left.pos);
+		if (isParagraph($left.parent) && $left.start() !== $right.start()) carriers.push({
+			position: $left.before(),
+			record: null
+		});
+	}
+	return {
+		deletedMarks,
+		carriers
+	};
+};
+//#endregion
+export { sectionMarkEditsOf };

package/dist/prosemirror/storyListNumbering.d.ts

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/storyListNumbering.d.ts
+type StoryListNumbering = {
+  /** The story with every colliding list moved to its own ids. */
+  doc: Node;
+  /** `numbering` plus the lists the story defines. */
+  numbering: document_d_exports.NumberingDefinitions | undefined;
+};
+/**
+ * The story in `state` as it should be written into a package whose numbering
+ * is now `numbering`, and that numbering completed with the story's lists.
+ */
+declare const storyListNumbering: (state: EditorState, numbering: document_d_exports.NumberingDefinitions | undefined) => StoryListNumbering;
+//#endregion
+export { storyListNumbering };

package/dist/prosemirror/storyListNumbering.js

@@ -0,0 +1,102 @@
+import { getCachedNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
+import { paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { completeNumberingForDoc, paragraphListReferences } from "./listInstanceReferences.js";
+import { paragraphNumberingAttr } from "./numberingAttr.js";
+import { getPackageNumberingDefinitions } from "./plugins/documentNumbering.js";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/storyListNumbering.ts
+const remappedNumPr = (numPr, numIds) => {
+	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+	const next = numId === void 0 ? void 0 : numIds.get(numId);
+	if (next === void 0) return numPr;
+	const ilvl = paragraphNumberingLevel(numPr ?? void 0);
+	return paragraphNumberingAttr(paragraphNumberingReference(ilvl === void 0 ? { numId: next } : {
+		numId: next,
+		ilvl
+	}));
+};
+const remappedAbstractNumId = (abstractNumId, remap) => {
+	if (abstractNumId === null || abstractNumId === void 0 || remap.baseAbstractNumIds.has(abstractNumId)) return abstractNumId;
+	let next = remap.abstractNumIds.get(abstractNumId);
+	if (next === void 0) {
+		next = remap.nextAbstractNumId++;
+		remap.abstractNumIds.set(abstractNumId, next);
+	}
+	return next;
+};
+const maxOf = (ids, floor) => {
+	let max = floor;
+	for (const id of ids) max = Math.max(max, id);
+	return max;
+};
+/**
+* The story in `state` as it should be written into a package whose numbering
+* is now `numbering`, and that numbering completed with the story's lists.
+*/
+const storyListNumbering = (state, numbering) => {
+	const packageDefinitions = getPackageNumberingDefinitions(state);
+	const storyBase = new Set((packageDefinitions?.nums ?? []).map(({ numId }) => numId));
+	const defined = new Set((numbering?.nums ?? []).map(({ numId }) => numId));
+	const definedMap = numbering ? getCachedNumberingMap(numbering) : null;
+	const referenced = /* @__PURE__ */ new Set();
+	const colliding = /* @__PURE__ */ new Set();
+	state.doc.descendants((node) => {
+		if (node.type.name !== "paragraph") return true;
+		for (const numId of paragraphListReferences(node)) referenced.add(numId);
+		const attrs = expectParagraphAttrs(node);
+		const numId = paragraphNumberingReferenceId(attrs.numPr);
+		if (numId !== void 0 && !storyBase.has(numId) && definedMap?.hasNumbering(numId)) {
+			const level = definedMap.getLevel(numId, paragraphNumberingLevel(attrs.numPr) ?? 0);
+			if (!(level !== null && isBulletLevel(level) === (attrs.listIsBullet === true) && (attrs.listAbstractNumId ?? void 0) === (definedMap.getAbstractNumId(numId) ?? void 0))) colliding.add(numId);
+		}
+		return false;
+	});
+	if (colliding.size === 0) return {
+		doc: state.doc,
+		numbering: completeNumberingForDoc(numbering, state.doc)
+	};
+	let nextNumId = maxOf([...defined, ...referenced], 0) + 1;
+	const remap = {
+		numIds: new Map([...colliding].map((numId) => [numId, nextNumId++])),
+		baseAbstractNumIds: new Set((packageDefinitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId)),
+		abstractNumIds: /* @__PURE__ */ new Map(),
+		nextAbstractNumId: maxOf((numbering?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), -1) + 1
+	};
+	const tr = new Transform(state.doc);
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		const attrs = expectParagraphAttrs(node);
+		const numId = paragraphNumberingReferenceId(attrs.numPr);
+		const moves = numId !== void 0 && remap.numIds.has(numId);
+		const changes = attrs._propertyChanges?.map((change) => {
+			const previous = change.previousFormatting;
+			const previousNumId = paragraphNumberingReferenceId(previous?.numPr ?? void 0);
+			if (!previous || previousNumId === void 0 || !remap.numIds.has(previousNumId)) return change;
+			return {
+				...change,
+				previousFormatting: {
+					...previous,
+					numPr: remappedNumPr(previous.numPr, remap.numIds),
+					listAbstractNumId: remappedAbstractNumId(previous.listAbstractNumId, remap) ?? void 0
+				}
+			};
+		});
+		const changesMoved = changes?.some((change, index) => change !== attrs._propertyChanges?.[index]);
+		if (moves || changesMoved) tr.setNodeMarkup(pos, void 0, {
+			...node.attrs,
+			...moves ? {
+				numPr: remappedNumPr(attrs.numPr, remap.numIds),
+				listAbstractNumId: remappedAbstractNumId(attrs.listAbstractNumId, remap) ?? null
+			} : {},
+			...changesMoved ? { _propertyChanges: changes } : {}
+		});
+		return false;
+	});
+	return {
+		doc: tr.doc,
+		numbering: completeNumberingForDoc(numbering, tr.doc)
+	};
+};
+//#endregion
+export { storyListNumbering };

package/dist/prosemirror/styles/paragraphStyleCascade.d.ts

@@ -0,0 +1,59 @@
+import { document_d_exports } from "../../types/document.js";
+import { ParagraphAttrs } from "../schema/nodes.js";
+import { TableCellParagraphSpacingOverlay } from "./styleResolver.js";
+import { StyleEngine } from "../../style-engine/styleEngine.js";
+import "../../style-engine/index.js";
+import { TableStyleRegion } from "./tableStyleRegions.js";
+//#region src/prosemirror/styles/paragraphStyleCascade.d.ts
+/** The resolver surface the paragraph cascade reads. */
+type ParagraphCascadeResolver = Pick<StyleEngine, "getStyle" | "getDocDefaults" | "getDefaultParagraphStyle" | "getDefaultCharacterStyle" | "getRunStyleOwnProperties" | "resolveParagraphStyleInTable">;
+/**
+ * Resolve an embedded character-style reference without importing
+ * `docDefaults`. The caller already has the paragraph cascade, including
+ * document defaults, and will layer these own properties over it.
+ */
+type ParagraphDefaultFormattingResolver = Pick<StyleEngine, "getStyle" | "getDocDefaults" | "getDefaultParagraphStyle" | "getDefaultCharacterStyle" | "getRunStyleOwnProperties">;
+declare function resolveRunFormattingWithoutDefaults(formatting: document_d_exports.TextFormatting | undefined, styleResolver: ParagraphDefaultFormattingResolver | null): document_d_exports.TextFormatting | undefined;
+/** @internal Recompute a paragraph's inherited run defaults from authored package state. */
+declare function resolveParagraphDefaultTextFormatting(styleId: string | undefined, formatting: document_d_exports.Paragraph["formatting"] | undefined, styleResolver: ParagraphDefaultFormattingResolver, options?: {
+  includeParagraphMarkRunProperties?: boolean;
+}): document_d_exports.TextFormatting | undefined;
+type ParagraphStyleCascadeInput = {
+  styleId: string | undefined;
+  /** What the paragraph states itself; each stated field wins over the cascade. */
+  formatting: document_d_exports.ParagraphFormatting | undefined;
+  styleResolver: ParagraphCascadeResolver;
+  /**
+   * The enclosing table style's modeled paragraph fields, layered between
+   * docDefaults and the paragraph's own style chain (cell paragraphs only).
+   */
+  tableParagraphOverlay?: TableCellParagraphSpacingOverlay | undefined;
+  /** Whether the paragraph mark's own run properties join the run defaults. */
+  includeParagraphMarkRunProperties: boolean;
+};
+type ParagraphStyleCascade = {
+  /** The effective attrs, with the provenance a save needs to keep inherited values out of `w:pPr`. */
+  attrs: ParagraphAttrs;
+  /** The resolved style cascade the attrs were read from. */
+  stylePpr: document_d_exports.ParagraphFormatting | undefined;
+};
+/**
+ * Project a paragraph's style cascade onto its editor attrs: each field the
+ * paragraph states wins, every other field reads the cascade, and the
+ * provenance attrs record which is which.
+ */
+declare function paragraphStyleCascadeAttrs({ styleId, formatting, styleResolver, tableParagraphOverlay, includeParagraphMarkRunProperties }: ParagraphStyleCascadeInput): ParagraphStyleCascade;
+/**
+ * Pick the modeled paragraph fields out of a table style's (or conditional
+ * region's) `w:pPr` for use as the cell-paragraph cascade overlay.
+ */
+declare function extractTableParagraphOverlay(pPr: document_d_exports.ParagraphFormatting | undefined): TableCellParagraphSpacingOverlay | undefined;
+/**
+ * The paragraph overlay a table style gives one cell's paragraphs: its base
+ * `w:pPr`, then each applicable region's (`regions`, lowest precedence first,
+ * from `tableCellStyleRegions`). A table naming no style, or a style the part
+ * does not define, reads the default table style (ECMA-376 §17.7.6).
+ */
+declare function tableCellParagraphOverlay(styleResolver: Pick<StyleEngine, "getStyle" | "getDefaultTableStyle">, tableStyleId: string | null | undefined, regions: readonly TableStyleRegion[]): TableCellParagraphSpacingOverlay | undefined;
+//#endregion
+export { ParagraphCascadeResolver, ParagraphStyleCascade, ParagraphStyleCascadeInput, extractTableParagraphOverlay, paragraphStyleCascadeAttrs, resolveParagraphDefaultTextFormatting, resolveRunFormattingWithoutDefaults, tableCellParagraphOverlay };

package/dist/prosemirror/styles/paragraphStyleCascade.js

@@ -0,0 +1,145 @@
+import { mergeParagraphNumbering, paragraphNumberingReferenceId } from "../../docx/numberingReference.js";
+import { mergeParagraphFormatting, mergeParagraphTabStops } from "../../utils/paragraphFormattingMerge.js";
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { paragraphNumberingAttr } from "../numberingAttr.js";
+import { directionFromBidi } from "../paragraphDirection.js";
+import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { lineSpacingProvenanceFromSpacing } from "../paragraphSpacing.js";
+import { stripParagraphMarkOnlyFormatting } from "../runStyleFormatting.js";
+import { cascadeStyleTextFormatting } from "./styleToggleCascade.js";
+//#region src/prosemirror/styles/paragraphStyleCascade.ts
+function resolveRunFormattingWithoutDefaults(formatting, styleResolver) {
+	if (!formatting || !styleResolver) return formatting;
+	return cascadeStyleTextFormatting([{
+		formatting: formatting.styleId ? styleResolver.getRunStyleOwnProperties(formatting.styleId) : void 0,
+		type: "style"
+	}, {
+		formatting,
+		type: "direct"
+	}]).formatting;
+}
+/** @internal Recompute a paragraph's inherited run defaults from authored package state. */
+function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, options = {}) {
+	const style = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
+	const paragraphStyleRpr = style?.type === "paragraph" ? style.rPr : void 0;
+	const rawParagraphMarkRpr = options.includeParagraphMarkRunProperties === false ? void 0 : formatting?.runProperties;
+	const paragraphRunProperties = rawParagraphMarkRpr ? stripParagraphMarkOnlyFormatting(resolveRunFormattingWithoutDefaults(rawParagraphMarkRpr, styleResolver) ?? {}) : void 0;
+	const orderedBodyToggleFormatting = cascadeStyleTextFormatting([
+		{
+			formatting: styleResolver.getDocDefaults()?.rPr,
+			type: "defaults"
+		},
+		{
+			formatting: paragraphStyleRpr,
+			type: "style"
+		},
+		{
+			formatting: styleResolver.getDefaultCharacterStyle()?.rPr,
+			type: "style"
+		}
+	], { ordinaryFormatting: mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr) });
+	const bodyRunDefaults = orderedBodyToggleFormatting.formatting;
+	return cascadeStyleTextFormatting([{
+		cascade: orderedBodyToggleFormatting,
+		type: "carried"
+	}, {
+		formatting: paragraphRunProperties,
+		type: "direct"
+	}], { ordinaryFormatting: mergeTextFormatting(bodyRunDefaults, paragraphRunProperties) }).formatting;
+}
+/**
+* Project a paragraph's style cascade onto its editor attrs: each field the
+* paragraph states wins, every other field reads the cascade, and the
+* provenance attrs record which is which.
+*/
+function paragraphStyleCascadeAttrs({ styleId, formatting, styleResolver, tableParagraphOverlay, includeParagraphMarkRunProperties }) {
+	const attrs = {};
+	const set = (key, val) => {
+		if (val !== void 0) attrs[key] = val;
+	};
+	const stylePpr = styleResolver.resolveParagraphStyleInTable(styleId, tableParagraphOverlay).paragraphFormatting;
+	const resolvedFormatting = styleResolvedParagraphFormatting(stylePpr);
+	if (resolvedFormatting) attrs._resolvedFormatting = resolvedFormatting;
+	set("alignment", formatting?.alignment ?? stylePpr?.alignment);
+	set("alignmentFromStyle", stylePpr?.alignment);
+	set("spaceBefore", formatting?.spaceBefore ?? stylePpr?.spaceBefore);
+	set("spaceAfter", formatting?.spaceAfter ?? stylePpr?.spaceAfter);
+	set("lineSpacing", formatting?.lineSpacing ?? stylePpr?.lineSpacing);
+	set("lineSpacingRule", formatting?.lineSpacingRule ?? stylePpr?.lineSpacingRule);
+	set("lineSpacingExplicit", lineSpacingProvenanceFromSpacing(formatting));
+	set("snapToGrid", formatting?.snapToGrid ?? stylePpr?.snapToGrid);
+	set("spacingExplicit", formatting?.spacingExplicit);
+	const paragraphStyle = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
+	const docDefaultSpacing = styleResolver.getDocDefaults()?.pPr;
+	const spacingFromStyle = {};
+	if (formatting?.spaceBefore === void 0 && stylePpr?.spaceBefore !== void 0) spacingFromStyle.before = true;
+	if (formatting?.spaceAfter === void 0 && stylePpr?.spaceAfter !== void 0) spacingFromStyle.after = true;
+	if (spacingFromStyle.before || spacingFromStyle.after) attrs.spacingFromImplicitDefaultStyle = spacingFromStyle;
+	const spacingFromDocDefaults = {};
+	if (formatting?.spaceBefore === void 0 && tableParagraphOverlay?.spaceBefore === void 0 && paragraphStyle?.pPr?.spaceBefore === void 0 && docDefaultSpacing?.spaceBefore !== void 0) spacingFromDocDefaults.before = true;
+	if (formatting?.spaceAfter === void 0 && tableParagraphOverlay?.spaceAfter === void 0 && paragraphStyle?.pPr?.spaceAfter === void 0 && docDefaultSpacing?.spaceAfter !== void 0) spacingFromDocDefaults.after = true;
+	if (spacingFromDocDefaults.before || spacingFromDocDefaults.after) attrs.spacingFromDocDefaults = spacingFromDocDefaults;
+	const effectiveIndent = mergeParagraphFormatting(formatting?.numPr?.kind === "none" && paragraphNumberingReferenceId(stylePpr?.numPr) !== void 0 ? void 0 : stylePpr, formatting);
+	set("indentLeft", effectiveIndent?.indentLeft);
+	set("indentRight", formatting?.indentRight ?? stylePpr?.indentRight);
+	set("indentFirstLine", effectiveIndent?.indentFirstLine);
+	set("hangingIndent", effectiveIndent?.hangingIndent);
+	set("borders", formatting?.borders ?? stylePpr?.borders);
+	set("shading", formatting?.shading ?? stylePpr?.shading);
+	set("tabs", mergeParagraphTabStops(stylePpr?.tabs, formatting?.tabs));
+	set("kinsoku", formatting?.kinsoku ?? stylePpr?.kinsoku);
+	set("overflowPunctuation", formatting?.overflowPunctuation ?? stylePpr?.overflowPunctuation);
+	set("suppressAutoHyphens", formatting?.suppressAutoHyphens ?? stylePpr?.suppressAutoHyphens);
+	set("pageBreakBefore", formatting?.pageBreakBefore ?? stylePpr?.pageBreakBefore);
+	set("keepNext", formatting?.keepNext ?? stylePpr?.keepNext);
+	set("keepLines", formatting?.keepLines ?? stylePpr?.keepLines);
+	set("widowControl", formatting?.widowControl ?? stylePpr?.widowControl);
+	set("contextualSpacing", formatting?.contextualSpacing ?? stylePpr?.contextualSpacing);
+	set("runInWithNext", formatting?.runInWithNext ?? stylePpr?.runInWithNext);
+	set("outlineLevel", formatting?.outlineLevel ?? stylePpr?.outlineLevel);
+	set("direction", directionFromBidi(formatting?.bidi ?? stylePpr?.bidi));
+	set("defaultTextFormatting", resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, { includeParagraphMarkRunProperties }));
+	const styleNumbering = stylePpr?.numPr;
+	if (styleNumbering?.kind === "reference" && (formatting?.numPr === void 0 || formatting.numPr.kind === "levelOnly")) {
+		const merged = mergeParagraphNumbering(styleNumbering, formatting?.numPr);
+		if (merged !== void 0) attrs.numPr = paragraphNumberingAttr(merged);
+		attrs.numPrFromStyle = paragraphNumberingAttr(styleNumbering);
+	}
+	return {
+		attrs,
+		stylePpr
+	};
+}
+/**
+* Pick the modeled paragraph fields out of a table style's (or conditional
+* region's) `w:pPr` for use as the cell-paragraph cascade overlay.
+*/
+function extractTableParagraphOverlay(pPr) {
+	if (!pPr) return;
+	const overlay = {};
+	if (pPr.spaceBefore !== void 0) overlay.spaceBefore = pPr.spaceBefore;
+	if (pPr.spaceAfter !== void 0) overlay.spaceAfter = pPr.spaceAfter;
+	if (pPr.lineSpacing !== void 0) overlay.lineSpacing = pPr.lineSpacing;
+	if (pPr.lineSpacingRule !== void 0) overlay.lineSpacingRule = pPr.lineSpacingRule;
+	if (pPr.contextualSpacing !== void 0) overlay.contextualSpacing = pPr.contextualSpacing;
+	if (pPr.frame !== void 0) overlay.frame = pPr.frame;
+	return Object.keys(overlay).length > 0 ? overlay : void 0;
+}
+/**
+* The paragraph overlay a table style gives one cell's paragraphs: its base
+* `w:pPr`, then each applicable region's (`regions`, lowest precedence first,
+* from `tableCellStyleRegions`). A table naming no style, or a style the part
+* does not define, reads the default table style (ECMA-376 §17.7.6).
+*/
+function tableCellParagraphOverlay(styleResolver, tableStyleId, regions) {
+	const style = (tableStyleId ? styleResolver.getStyle(tableStyleId) : void 0) ?? styleResolver.getDefaultTableStyle();
+	if (!style) return;
+	let overlay = extractTableParagraphOverlay(style.pPr);
+	for (const region of regions) {
+		const conditional = style.tblStylePr?.find(({ type }) => type === region);
+		overlay = mergeParagraphFormatting(overlay, extractTableParagraphOverlay(conditional?.pPr));
+	}
+	return overlay;
+}
+//#endregion
+export { extractTableParagraphOverlay, paragraphStyleCascadeAttrs, resolveParagraphDefaultTextFormatting, resolveRunFormattingWithoutDefaults, tableCellParagraphOverlay };

package/dist/prosemirror/styles/resolvedStyleAttrs.d.ts

@@ -1,6 +1,7 @@
-import { ParagraphAttrsPatch } from "../schema/nodes.js";
+import { ParagraphAttrs, ParagraphAttrsPatch } from "../schema/nodes.js";
 import { ResolvedParagraphStyle } from "./styleResolver.js";
 import { NumberingMap } from "../../docx/numberingParser.js";
+import { DirectParagraphIndentation } from "../paragraphIndentation.js";
 //#region src/prosemirror/styles/resolvedStyleAttrs.d.ts
 type ResolvedStyleIdentity = {
   styleId: string;
@@ -37,6 +38,24 @@ declare function listAttrsFromNumbering(numPr: {
   numId: number;
   ilvl: number;
 }, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
+/**
+ * The numbering level's indentation a directly numbered paragraph reads as its
+ * own where it states none: the load path folds the level's `w:ind` into the
+ * paragraph (a direct `w:ind` wins per group, left vs first line/hanging), so
+ * a paragraph a command numbers carries it too, and the save writes it where a
+ * reopen reads it back.
+ */
+declare function listLevelIndentAttrPatch(stated: DirectParagraphIndentation | undefined, numPr: {
+  numId: number;
+  ilvl: number;
+}, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
+/**
+ * The indentation a paragraph leaving its list keeps: the level's indentation
+ * it only read from its numbering goes with the numbering, back to what its
+ * style gives, while an indentation of its own stays. The inverse of
+ * {@link listLevelIndentAttrPatch}.
+ */
+declare function listLevelIndentRemovalPatch(attrs: Readonly<ParagraphAttrs>, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
 /** Recompute every level-dependent attr when a paragraph changes list level. */
 declare function listLevelAttrPatch(attrs: {
   listImplicitChildLevelAdvances?: number | null;
@@ -45,4 +64,4 @@ declare function listLevelAttrPatch(attrs: {
   ilvl: number;
 }, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
 //#endregion
-export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listLevelAttrPatch, paragraphAttrsFromResolvedStyle };
+export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listLevelAttrPatch, listLevelIndentAttrPatch, listLevelIndentRemovalPatch, paragraphAttrsFromResolvedStyle };

package/dist/prosemirror/styles/resolvedStyleAttrs.js

@@ -112,6 +112,43 @@ function listAttrsFromNumbering(numPr, numbering) {
 		...rendering && listRenderingAttrPatch(rendering)
 	};
 }
+/**
+* The numbering level's indentation a directly numbered paragraph reads as its
+* own where it states none: the load path folds the level's `w:ind` into the
+* paragraph (a direct `w:ind` wins per group, left vs first line/hanging), so
+* a paragraph a command numbers carries it too, and the save writes it where a
+* reopen reads it back.
+*/
+function listLevelIndentAttrPatch(stated, numPr, numbering) {
+	const level = numbering?.getLevel(numPr.numId, numPr.ilvl);
+	if (!level?.pPr) return {};
+	const patch = {};
+	if (stated?.indentLeft === void 0 && level.pPr.indentLeft !== void 0) patch.indentLeft = level.pPr.indentLeft;
+	if (stated?.indentFirstLine === void 0 && numberingLevelHasMarkerSlot(level)) {
+		if (level.pPr.indentFirstLine !== void 0) patch.indentFirstLine = level.pPr.indentFirstLine;
+		if (level.pPr.hangingIndent !== void 0) patch.hangingIndent = level.pPr.hangingIndent;
+	}
+	return patch;
+}
+/**
+* The indentation a paragraph leaving its list keeps: the level's indentation
+* it only read from its numbering goes with the numbering, back to what its
+* style gives, while an indentation of its own stays. The inverse of
+* {@link listLevelIndentAttrPatch}.
+*/
+function listLevelIndentRemovalPatch(attrs, numbering) {
+	if (attrs.numPr?.kind !== "reference") return {};
+	const level = numbering?.getLevel(attrs.numPr.numId, attrs.numPr.ilvl ?? 0);
+	if (!level?.pPr) return {};
+	const resolved = attrs.numPrFromStyle != null ? void 0 : attrs._resolvedFormatting;
+	const patch = {};
+	if (level.pPr.indentLeft !== void 0 && attrs.indentLeft === level.pPr.indentLeft) patch.indentLeft = resolved?.indentLeft ?? null;
+	if (level.pPr.indentFirstLine !== void 0 && attrs.indentFirstLine === level.pPr.indentFirstLine && attrs.hangingIndent === (level.pPr.hangingIndent ?? false)) {
+		patch.indentFirstLine = resolved?.indentFirstLine ?? null;
+		patch.hangingIndent = resolved?.hangingIndent ?? false;
+	}
+	return patch;
+}
 /** Recompute every level-dependent attr when a paragraph changes list level. */
 function listLevelAttrPatch(attrs, numPr, numbering) {
 	const level = numbering?.getLevel(numPr.numId, numPr.ilvl);
@@ -125,4 +162,4 @@ function listLevelAttrPatch(attrs, numPr, numbering) {
 	};
 }
 //#endregion
-export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listLevelAttrPatch, paragraphAttrsFromResolvedStyle };
+export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listLevelAttrPatch, listLevelIndentAttrPatch, listLevelIndentRemovalPatch, paragraphAttrsFromResolvedStyle };

package/dist/prosemirror/styles/tableStyleRegions.d.ts

@@ -0,0 +1,31 @@
+import { document_d_exports } from "../../types/document.js";
+import "../../types/index.js";
+import { ResolvedTableLook } from "../../docx/tableLook.js";
+//#region src/prosemirror/styles/tableStyleRegions.d.ts
+type TableStyleRegion = "wholeTable" | "band1Horz" | "band2Horz" | "band1Vert" | "band2Vert" | "firstCol" | "lastCol" | "firstRow" | "lastRow" | "nwCell" | "neCell" | "swCell" | "seCell";
+/**
+ * The horizontal band a row takes by position: every row but a styled first
+ * or last row alternates, starting with band 1.
+ */
+declare const tableRowBand: (look: ResolvedTableLook, rowIndex: number, totalRows: number) => "band1Horz" | "band2Horz" | undefined;
+type TableCellPlacement = {
+  look: ResolvedTableLook;
+  rowIndex: number;
+  totalRows: number;
+  /** The first grid column the cell covers. */
+  column: number;
+  colspan: number;
+  totalColumns: number;
+  /** The band `tableRowBand` gives the cell's row. */
+  rowBand: "band1Horz" | "band2Horz" | undefined;
+  rowConditionalFormat?: document_d_exports.ConditionalFormatStyle | undefined;
+  cellConditionalFormat?: document_d_exports.ConditionalFormatStyle | undefined;
+};
+/**
+ * The regions that apply to one cell, lowest precedence first: the whole
+ * table, banding, columns, rows, then corners (ECMA-376 §17.7.6). A cell's or
+ * row's `w:cnfStyle` overrides what its position implies.
+ */
+declare const tableCellStyleRegions: ({ look, rowIndex, totalRows, column, colspan, totalColumns, rowBand, rowConditionalFormat: rowCnf, cellConditionalFormat: cellCnf }: TableCellPlacement) => TableStyleRegion[];
+//#endregion
+export { TableCellPlacement, TableStyleRegion, tableCellStyleRegions, tableRowBand };