@sametalmdr/word-editor 0.2.0-alpha → 0.3.0-alpha

package/dist/commands/marks.js

@@ -1,153 +1,153 @@
-import { EMPTY_MARKS, locateParagraph, paragraphLength, withMark } from "../model/node.js";
-import { isCollapsed, paragraphIdOf, selectionRange } from "../model/position.js";
-import { rangeMarkState, sliceRuns } from "../model/runs.js";
-import { setMarkStep } from "../model/step.js";
-import { createTransaction } from "../model/transaction.js";
-
-/**
- * Marks a collapsed cursor inherits.
- *
- * **Left-biased**: the marks of the character *before* the cursor, falling back
- * to the character after it at offset 0. Typing right after bold text has to
- * continue bold — a right-biased rule would break that, which is the behaviour
- * users notice immediately.
- *
- * @param {import("../model/node.js").Doc} doc
- * @param {import("../model/position.js").Position} pos
- * @returns {import("../model/node.js").Marks}
- */
-export function marksAt(doc, pos) {
-  const at = locateParagraph(doc, paragraphIdOf(pos));
-  if (at === null) {
-    return EMPTY_MARKS;
-  }
-  const runs = at.para.content;
-
-  if (pos.offset > 0) {
-    const before = sliceRuns(runs, pos.offset - 1, pos.offset);
-    if (before.length > 0) {
-      return before[0].marks;
-    }
-  }
-
-  const after = sliceRuns(runs, pos.offset, pos.offset + 1);
-  if (after.length > 0) {
-    return after[0].marks;
-  }
-
-  // Empty paragraph: the sole empty run still carries marks (see `normalize`).
-  return runs.length > 0 ? runs[0].marks : EMPTY_MARKS;
-}
-
-/**
- * The marks that apply to what the user would type right now — what a toolbar
- * button should light up for.
- *
- * For a range, reports only marks carried by **every** character, which is the
- * same all-or-nothing rule `toggleMark` uses. So a lit button always means "press
- * to remove".
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @returns {import("../model/node.js").Marks}
- */
-export function marksAtSelection(state) {
-  const { doc, selection } = state;
-
-  if (isCollapsed(selection)) {
-    return state.storedMarks ?? marksAt(doc, selection.head);
-  }
-
-  /** @type {Record<string, true>} */
-  const common = {};
-  for (const name of /** @type {import("../model/node.js").MarkName[]} */ ([
-    "bold",
-    "italic",
-    "underline",
-  ])) {
-    if (rangeHasMarkThroughout(state, name)) {
-      common[name] = true;
-    }
-  }
-  return common;
-}
-
-/**
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {import("../model/node.js").MarkName} mark
- * @returns {boolean}
- */
-function rangeHasMarkThroughout(state, mark) {
-  const { doc, selection } = state;
-  const range = selectionRange(doc, selection);
-  if (range === null) {
-    return false;
-  }
-
-  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
-  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
-  // A mark range never crosses containers (ADR-0007), so the whole walk stays
-  // inside one container's paragraph list.
-  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
-    return false;
-  }
-
-  let sawAny = false;
-  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
-    const para = fromAt.container.content[i];
-    const start = i === fromAt.paraIndex ? range.from.offset : 0;
-    const end = i === toAt.paraIndex ? range.to.offset : paragraphLength(para);
-    if (end <= start) {
-      continue;
-    }
-    if (rangeMarkState(para.content, start, end, mark) !== "all") {
-      return false;
-    }
-    sawAny = true;
-  }
-  return sawAny;
-}
-
-/**
- * Toggles a mark.
- *
- * **Collapsed selection:** changes no document content. It sets `storedMarks`
- * instead, so the next typed character comes out formatted. The resulting
- * transaction has zero steps, which keeps a single dispatch path while letting
- * `HistoryEngine` skip it — pressing Ctrl+B then Ctrl+Z undoes the previous real
- * edit, not the pending format.
- *
- * **Range selection:** all-or-nothing. The mark is removed only when *every*
- * character already carries it; otherwise it is applied to the whole range. A
- * partially bold selection therefore goes fully bold on the first press.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {import("../model/node.js").MarkName} mark
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function toggleMark(state, mark) {
-  const { doc, selection } = state;
-
-  if (isCollapsed(selection)) {
-    const current = state.storedMarks ?? marksAt(doc, selection.head);
-    const tr = createTransaction(doc, selection, "format");
-    tr.setStoredMarks(withMark(current, mark, current[mark] !== true));
-    return tr.build();
-  }
-
-  const range = selectionRange(doc, selection);
-  if (range === null) {
-    return null;
-  }
-
-  const value = !rangeHasMarkThroughout(state, mark);
-  const tr = createTransaction(doc, selection, "format");
-  tr.step(setMarkStep(range.from, range.to, mark, value));
-  if (!tr.changesDoc) {
-    return null;
-  }
-
-  // Marks never move characters, so the selection is preserved as-is.
-  tr.setSelection(selection);
-  tr.setStoredMarks(null);
-  return tr.build();
-}
+import { EMPTY_MARKS, locateParagraph, paragraphLength, withMark } from "../model/node.js";
+import { isCollapsed, paragraphIdOf, selectionRange } from "../model/position.js";
+import { rangeMarkState, sliceRuns } from "../model/runs.js";
+import { setMarkStep } from "../model/step.js";
+import { createTransaction } from "../model/transaction.js";
+
+/**
+ * Marks a collapsed cursor inherits.
+ *
+ * **Left-biased**: the marks of the character *before* the cursor, falling back
+ * to the character after it at offset 0. Typing right after bold text has to
+ * continue bold — a right-biased rule would break that, which is the behaviour
+ * users notice immediately.
+ *
+ * @param {import("../model/node.js").Doc} doc
+ * @param {import("../model/position.js").Position} pos
+ * @returns {import("../model/node.js").Marks}
+ */
+export function marksAt(doc, pos) {
+  const at = locateParagraph(doc, paragraphIdOf(pos));
+  if (at === null) {
+    return EMPTY_MARKS;
+  }
+  const runs = at.para.content;
+
+  if (pos.offset > 0) {
+    const before = sliceRuns(runs, pos.offset - 1, pos.offset);
+    if (before.length > 0) {
+      return before[0].marks;
+    }
+  }
+
+  const after = sliceRuns(runs, pos.offset, pos.offset + 1);
+  if (after.length > 0) {
+    return after[0].marks;
+  }
+
+  // Empty paragraph: the sole empty run still carries marks (see `normalize`).
+  return runs.length > 0 ? runs[0].marks : EMPTY_MARKS;
+}
+
+/**
+ * The marks that apply to what the user would type right now — what a toolbar
+ * button should light up for.
+ *
+ * For a range, reports only marks carried by **every** character, which is the
+ * same all-or-nothing rule `toggleMark` uses. So a lit button always means "press
+ * to remove".
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @returns {import("../model/node.js").Marks}
+ */
+export function marksAtSelection(state) {
+  const { doc, selection } = state;
+
+  if (isCollapsed(selection)) {
+    return state.storedMarks ?? marksAt(doc, selection.head);
+  }
+
+  /** @type {Record<string, true>} */
+  const common = {};
+  for (const name of /** @type {import("../model/node.js").MarkName[]} */ ([
+    "bold",
+    "italic",
+    "underline",
+  ])) {
+    if (rangeHasMarkThroughout(state, name)) {
+      common[name] = true;
+    }
+  }
+  return common;
+}
+
+/**
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {import("../model/node.js").MarkName} mark
+ * @returns {boolean}
+ */
+function rangeHasMarkThroughout(state, mark) {
+  const { doc, selection } = state;
+  const range = selectionRange(doc, selection);
+  if (range === null) {
+    return false;
+  }
+
+  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
+  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
+  // A mark range never crosses containers (ADR-0007), so the whole walk stays
+  // inside one container's paragraph list.
+  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
+    return false;
+  }
+
+  let sawAny = false;
+  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
+    const para = fromAt.container.content[i];
+    const start = i === fromAt.paraIndex ? range.from.offset : 0;
+    const end = i === toAt.paraIndex ? range.to.offset : paragraphLength(para);
+    if (end <= start) {
+      continue;
+    }
+    if (rangeMarkState(para.content, start, end, mark) !== "all") {
+      return false;
+    }
+    sawAny = true;
+  }
+  return sawAny;
+}
+
+/**
+ * Toggles a mark.
+ *
+ * **Collapsed selection:** changes no document content. It sets `storedMarks`
+ * instead, so the next typed character comes out formatted. The resulting
+ * transaction has zero steps, which keeps a single dispatch path while letting
+ * `HistoryEngine` skip it — pressing Ctrl+B then Ctrl+Z undoes the previous real
+ * edit, not the pending format.
+ *
+ * **Range selection:** all-or-nothing. The mark is removed only when *every*
+ * character already carries it; otherwise it is applied to the whole range. A
+ * partially bold selection therefore goes fully bold on the first press.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {import("../model/node.js").MarkName} mark
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function toggleMark(state, mark) {
+  const { doc, selection } = state;
+
+  if (isCollapsed(selection)) {
+    const current = state.storedMarks ?? marksAt(doc, selection.head);
+    const tr = createTransaction(doc, selection, "format");
+    tr.setStoredMarks(withMark(current, mark, current[mark] !== true));
+    return tr.build();
+  }
+
+  const range = selectionRange(doc, selection);
+  if (range === null) {
+    return null;
+  }
+
+  const value = !rangeHasMarkThroughout(state, mark);
+  const tr = createTransaction(doc, selection, "format");
+  tr.step(setMarkStep(range.from, range.to, mark, value));
+  if (!tr.changesDoc) {
+    return null;
+  }
+
+  // Marks never move characters, so the selection is preserved as-is.
+  tr.setSelection(selection);
+  tr.setStoredMarks(null);
+  return tr.build();
+}

package/dist/commands/paragraph-props.js

@@ -1,176 +1,176 @@
-import { locateParagraph } from "../model/node.js";
-import { paragraphIdOf, selectionRange } from "../model/position.js";
-import { setParagraphPropsStep } from "../model/step.js";
-import { createTransaction } from "../model/transaction.js";
-
-// ADR-0030: paragraph indentation is editable through a DIRECT
-// `Paragraph.pPrOverride` record — never by mutating `Doc.styles`, for the
-// same measured reason ADR-0029 gave for `jc`: 70.5% of real corpus
-// paragraphs share a `pPrRef` with at least one other (worst case 471 on one
-// ref), so writing the styles table would silently re-indent unrelated
-// paragraphs. This module is `commands/alignment.js`'s sibling; the only
-// structural difference is that a patch names KEYS, because a paragraph can
-// carry four independent indent fields at once.
-
-/**
- * The `pPrOverride` keys this UI writes. Deliberately not everything
- * `readPPr` produces — `spacing.*` and `numPr.*` are read and rendered
- * correctly but nothing here writes them, so nothing here claims to. The
- * export side names the same set (`WRITABLE_PPR_KEYS`) and a gate test
- * partitions it against `readPPr`'s own output.
- * @type {readonly string[]}
- */
-export const INDENT_KEYS = /** @type {const} */ ([
-  "ind.left",
-  "ind.right",
-  "ind.firstLine",
-  "ind.hanging",
-]);
-
-/**
- * OOXML measures `w:ind` in twips (twentieths of a point). The UI shows
- * centimetres, so the conversion lives at that boundary — NOT here, and not in
- * the model: the model stays in OOXML units end to end, the same discipline
- * that keeps `BoxLayout.x` in points until `ptToEmu` at the export seam.
- */
-export const TWIPS_PER_CM = 567;
-
-/**
- * The effective value of one indent key at a paragraph: its own direct
- * override, else the import-resolved value for its `pPrRef`, else absent.
- *
- * Unlike `paragraphAlignment` there is no docDefaults last resort and no
- * hardcoded fallback: OOXML's default indent is the ABSENCE of the attribute,
- * which the renderer already handles by writing no padding at all. Inventing
- * a 0 here would turn "inherited nothing" into "explicitly zero" — a real
- * difference on export.
- * @param {import("../model/node.js").Doc} doc
- * @param {import("../model/node.js").Paragraph} para
- * @param {string} key  one of `INDENT_KEYS`
- * @returns {number | null}  null when nothing in the chain declares one
- */
-export function paragraphIndent(doc, para, key) {
-  const own = para.pPrOverride?.[key];
-  if (typeof own === "number") {
-    return own;
-  }
-  if (para.pPrRef !== undefined) {
-    // `Doc.styles` holds raw XML attribute STRINGS (readPPr's convention),
-    // while an override holds numbers — the same duality `applyRunStyle`'s
-    // `toNumber` absorbs for `sz` (ADR-0028).
-    const resolved = doc.styles[para.pPrRef]?.[key];
-    const parsed = typeof resolved === "string" ? Number.parseInt(resolved, 10) : resolved;
-    if (typeof parsed === "number" && Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return null;
-}
-
-/**
- * The value of one indent key shared by EVERY paragraph the selection touches,
- * or null when they disagree — the same all-or-nothing shape
- * `alignmentAtSelection`/`marksAtSelection` use, so a populated input always
- * means "every selected paragraph is already this" and a blank one means
- * "mixed", never "zero".
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {string} key
- * @returns {number | null}
- */
-export function indentAtSelection(state, key) {
-  const paragraphs = selectedParagraphs(state);
-  if (paragraphs === null || paragraphs.length === 0) {
-    return null;
-  }
-  const first = paragraphIndent(state.doc, paragraphs[0].para, key);
-  for (const entry of paragraphs) {
-    if (paragraphIndent(state.doc, entry.para, key) !== first) {
-      return null; // mixed — the input goes blank
-    }
-  }
-  return first;
-}
-
-/**
- * Every paragraph the selection touches, in document order. Identical to
- * `commands/alignment.js`'s own — a collapsed caret selects the ONE paragraph
- * it sits in, because a paragraph-level change has an unambiguous target even
- * with no selection, so there is no `storedMarks`-style pending state here.
- * @param {import("../state/editor-state.js").EditorState} state
- * @returns {{container: import("../model/node.js").Container, para: import("../model/node.js").Paragraph, paraIndex: number}[] | null}
- */
-function selectedParagraphs(state) {
-  const { doc, selection } = state;
-  const range = selectionRange(doc, selection) ?? { from: selection.head, to: selection.head };
-
-  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
-  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
-  // A selection never spans containers (ADR-0007), same rule marks follow.
-  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
-    return null;
-  }
-
-  const out = [];
-  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
-    out.push({ container: fromAt.container, para: fromAt.container.content[i], paraIndex: i });
-  }
-  return out;
-}
-
-/**
- * Patches paragraph-level properties on every paragraph the selection touches.
- *
- * A key mapped to `undefined` clears that override; a key simply absent from
- * `patch` is left alone. Returns null when nothing would change, so a
- * redundant edit never reaches the history stack — `setAlignment`'s own rule.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {Record<string, number | undefined>} patch  keys from `INDENT_KEYS`
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function setParagraphProps(state, patch) {
-  const { doc, selection } = state;
-  const paragraphs = selectedParagraphs(state);
-  if (paragraphs === null || paragraphs.length === 0) {
-    return null;
-  }
-
-  const entries = paragraphs
-    .filter((entry) => !patchIsNoOp(entry.para, patch))
-    .map((entry) => ({ containerId: entry.container.id, paragraphId: entry.para.id, patch }));
-  if (entries.length === 0) {
-    return null;
-  }
-
-  const tr = createTransaction(doc, selection, "format");
-  tr.step(setParagraphPropsStep(entries));
-  if (!tr.changesDoc) {
-    return null;
-  }
-
-  // Indentation never moves characters, so the selection is preserved as-is.
-  tr.setSelection(selection);
-  tr.setStoredMarks(null);
-  return tr.build();
-}
-
-/**
- * Whether applying `patch` to this paragraph's OWN override record would
- * change nothing. Deliberately compares against the paragraph's own override,
- * not its effective value: clearing a key whose inherited value happens to
- * equal the override is a real change (it hands the field back to the style
- * chain), and treating it as a no-op would make that un-doable.
- * @param {import("../model/node.js").Paragraph} para
- * @param {Record<string, number | undefined>} patch
- * @returns {boolean}
- */
-function patchIsNoOp(para, patch) {
-  const own = para.pPrOverride ?? {};
-  for (const [key, value] of Object.entries(patch)) {
-    const before = key in own ? own[key] : undefined;
-    if (before !== value) {
-      return false;
-    }
-  }
-  return true;
-}
+import { locateParagraph } from "../model/node.js";
+import { paragraphIdOf, selectionRange } from "../model/position.js";
+import { setParagraphPropsStep } from "../model/step.js";
+import { createTransaction } from "../model/transaction.js";
+
+// ADR-0030: paragraph indentation is editable through a DIRECT
+// `Paragraph.pPrOverride` record — never by mutating `Doc.styles`, for the
+// same measured reason ADR-0029 gave for `jc`: 70.5% of real corpus
+// paragraphs share a `pPrRef` with at least one other (worst case 471 on one
+// ref), so writing the styles table would silently re-indent unrelated
+// paragraphs. This module is `commands/alignment.js`'s sibling; the only
+// structural difference is that a patch names KEYS, because a paragraph can
+// carry four independent indent fields at once.
+
+/**
+ * The `pPrOverride` keys this UI writes. Deliberately not everything
+ * `readPPr` produces — `spacing.*` and `numPr.*` are read and rendered
+ * correctly but nothing here writes them, so nothing here claims to. The
+ * export side names the same set (`WRITABLE_PPR_KEYS`) and a gate test
+ * partitions it against `readPPr`'s own output.
+ * @type {readonly string[]}
+ */
+export const INDENT_KEYS = /** @type {const} */ ([
+  "ind.left",
+  "ind.right",
+  "ind.firstLine",
+  "ind.hanging",
+]);
+
+/**
+ * OOXML measures `w:ind` in twips (twentieths of a point). The UI shows
+ * centimetres, so the conversion lives at that boundary — NOT here, and not in
+ * the model: the model stays in OOXML units end to end, the same discipline
+ * that keeps `BoxLayout.x` in points until `ptToEmu` at the export seam.
+ */
+export const TWIPS_PER_CM = 567;
+
+/**
+ * The effective value of one indent key at a paragraph: its own direct
+ * override, else the import-resolved value for its `pPrRef`, else absent.
+ *
+ * Unlike `paragraphAlignment` there is no docDefaults last resort and no
+ * hardcoded fallback: OOXML's default indent is the ABSENCE of the attribute,
+ * which the renderer already handles by writing no padding at all. Inventing
+ * a 0 here would turn "inherited nothing" into "explicitly zero" — a real
+ * difference on export.
+ * @param {import("../model/node.js").Doc} doc
+ * @param {import("../model/node.js").Paragraph} para
+ * @param {string} key  one of `INDENT_KEYS`
+ * @returns {number | null}  null when nothing in the chain declares one
+ */
+export function paragraphIndent(doc, para, key) {
+  const own = para.pPrOverride?.[key];
+  if (typeof own === "number") {
+    return own;
+  }
+  if (para.pPrRef !== undefined) {
+    // `Doc.styles` holds raw XML attribute STRINGS (readPPr's convention),
+    // while an override holds numbers — the same duality `applyRunStyle`'s
+    // `toNumber` absorbs for `sz` (ADR-0028).
+    const resolved = doc.styles[para.pPrRef]?.[key];
+    const parsed = typeof resolved === "string" ? Number.parseInt(resolved, 10) : resolved;
+    if (typeof parsed === "number" && Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return null;
+}
+
+/**
+ * The value of one indent key shared by EVERY paragraph the selection touches,
+ * or null when they disagree — the same all-or-nothing shape
+ * `alignmentAtSelection`/`marksAtSelection` use, so a populated input always
+ * means "every selected paragraph is already this" and a blank one means
+ * "mixed", never "zero".
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {string} key
+ * @returns {number | null}
+ */
+export function indentAtSelection(state, key) {
+  const paragraphs = selectedParagraphs(state);
+  if (paragraphs === null || paragraphs.length === 0) {
+    return null;
+  }
+  const first = paragraphIndent(state.doc, paragraphs[0].para, key);
+  for (const entry of paragraphs) {
+    if (paragraphIndent(state.doc, entry.para, key) !== first) {
+      return null; // mixed — the input goes blank
+    }
+  }
+  return first;
+}
+
+/**
+ * Every paragraph the selection touches, in document order. Identical to
+ * `commands/alignment.js`'s own — a collapsed caret selects the ONE paragraph
+ * it sits in, because a paragraph-level change has an unambiguous target even
+ * with no selection, so there is no `storedMarks`-style pending state here.
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @returns {{container: import("../model/node.js").Container, para: import("../model/node.js").Paragraph, paraIndex: number}[] | null}
+ */
+function selectedParagraphs(state) {
+  const { doc, selection } = state;
+  const range = selectionRange(doc, selection) ?? { from: selection.head, to: selection.head };
+
+  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
+  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
+  // A selection never spans containers (ADR-0007), same rule marks follow.
+  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
+    return null;
+  }
+
+  const out = [];
+  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
+    out.push({ container: fromAt.container, para: fromAt.container.content[i], paraIndex: i });
+  }
+  return out;
+}
+
+/**
+ * Patches paragraph-level properties on every paragraph the selection touches.
+ *
+ * A key mapped to `undefined` clears that override; a key simply absent from
+ * `patch` is left alone. Returns null when nothing would change, so a
+ * redundant edit never reaches the history stack — `setAlignment`'s own rule.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {Record<string, number | undefined>} patch  keys from `INDENT_KEYS`
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function setParagraphProps(state, patch) {
+  const { doc, selection } = state;
+  const paragraphs = selectedParagraphs(state);
+  if (paragraphs === null || paragraphs.length === 0) {
+    return null;
+  }
+
+  const entries = paragraphs
+    .filter((entry) => !patchIsNoOp(entry.para, patch))
+    .map((entry) => ({ containerId: entry.container.id, paragraphId: entry.para.id, patch }));
+  if (entries.length === 0) {
+    return null;
+  }
+
+  const tr = createTransaction(doc, selection, "format");
+  tr.step(setParagraphPropsStep(entries));
+  if (!tr.changesDoc) {
+    return null;
+  }
+
+  // Indentation never moves characters, so the selection is preserved as-is.
+  tr.setSelection(selection);
+  tr.setStoredMarks(null);
+  return tr.build();
+}
+
+/**
+ * Whether applying `patch` to this paragraph's OWN override record would
+ * change nothing. Deliberately compares against the paragraph's own override,
+ * not its effective value: clearing a key whose inherited value happens to
+ * equal the override is a real change (it hands the field back to the style
+ * chain), and treating it as a no-op would make that un-doable.
+ * @param {import("../model/node.js").Paragraph} para
+ * @param {Record<string, number | undefined>} patch
+ * @returns {boolean}
+ */
+function patchIsNoOp(para, patch) {
+  const own = para.pPrOverride ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const before = key in own ? own[key] : undefined;
+    if (before !== value) {
+      return false;
+    }
+  }
+  return true;
+}