@portone/docx-editor 0.2.1 → 0.3.0

package/dist/schema/guards.js

@@ -1,9 +1,10 @@
 // src/schema/guards.ts
+import { changesOnlyDisplayAttrs, displayOnly } from "./displayDerivation.js";
 import {
   transactionReaches
 } from "./editGuard.js";
 import { lockGuard } from "./locks.js";
-import { bookmarkGuard, noteGuard } from "./preservedGuards.js";
+import { bookmarkGuard, noteGuard, sectionGuard } from "./preservedGuards.js";
 import {
   isCommentNode,
   protectionAllows
@@ -36,7 +37,8 @@ var EDIT_GUARDS = [
   protectionGuard,
   lockGuard,
   bookmarkGuard,
-  noteGuard
+  noteGuard,
+  sectionGuard
 ];
 function judgesSteps(guard) {
   return guard.step !== void 0;
@@ -44,8 +46,14 @@ function judgesSteps(guard) {
 function lifted(guard, tr) {
   return guard.liftedBy?.some((pass) => tr.getMeta(pass) === true) === true;
 }
+function displayOnlyTransaction(tr, state) {
+  return tr.getMeta(displayOnly) === true && tr.steps.every(
+    (step, index) => changesOnlyDisplayAttrs(step, tr.docs[index] ?? state.doc)
+  );
+}
 function transactionAllowed(tr, state) {
   if (!tr.docChanged) return true;
+  if (displayOnlyTransaction(tr, state)) return true;
   if (EDIT_GUARDS.some((guard) => guard.change?.(tr, state) === false)) {
     return false;
   }
@@ -66,14 +74,32 @@ function transactionAllowed(tr, state) {
 function editShut(state, intent) {
   return EDIT_GUARDS.some((guard) => guard.shuts(intent, state));
 }
+function intentOver(from, to, kind) {
+  return from === to ? { kind: "insert", at: from } : { kind, from, to };
+}
 function selectionIntents(selection, kind) {
   return selection.ranges.map(
-    (range) => range.$from.pos === range.$to.pos ? { kind: "insert", at: range.$from.pos } : { kind, from: range.$from.pos, to: range.$to.pos }
+    (range) => intentOver(range.$from.pos, range.$to.pos, kind)
+  );
+}
+function guardedCommand(build) {
+  return (state, dispatch) => {
+    const tr = build(state);
+    if (tr === null || !transactionAllowed(tr, state)) return false;
+    dispatch?.(tr);
+    return true;
+  };
+}
+function openStretches(state, stretches, kind) {
+  return stretches.filter(
+    (stretch) => !editShut(state, intentOver(stretch.from, stretch.to, kind))
   );
 }
 export {
   EDIT_GUARDS,
   editShut,
+  guardedCommand,
+  openStretches,
   protectionAllowsTransaction,
   selectionIntents,
   stepReaches,

package/dist/schema/index.d.ts

@@ -1,2 +1,4 @@
+export type { AttrClass } from "./attrRoles";
+export { attrsOfClass } from "./attrRoles";
 export { docxSchema, isPageBreak } from "./docxSchema";
 export { imageNodeSpec, runMarkSpec } from "./rendering";

package/dist/schema/index.js

@@ -1,7 +1,9 @@
 // src/schema/index.ts
+import { attrsOfClass } from "./attrRoles.js";
 import { docxSchema, isPageBreak } from "./docxSchema.js";
 import { imageNodeSpec, runMarkSpec } from "./rendering.js";
 export {
+  attrsOfClass,
   docxSchema,
   imageNodeSpec,
   isPageBreak,

package/dist/schema/locks.d.ts

@@ -1,9 +1,10 @@
 /**
- * Evaluates OOXML content and deletion locks for inline controls and whole table cells. Commands
- * query these predicates before editing; `editor/plugins/lockedContent` enforces them at runtime.
+ * Evaluates OOXML content and deletion locks for inline controls and whole table cells.
  *
- * `lockGuard` is what `./guards` registers all of this as, so that a caller asking the one guard
- * list asks the locks along with every other rule an edit is judged by.
+ * `lockGuard` is what `./guards` registers all of this as, and it is the only way in: a caller
+ * asking about a lock asks the one guard list, which asks the locks along with every other rule an
+ * edit is judged by. What a lock says about a whole document or a whole selection - a question
+ * about the document rather than about an edit - is exported beside it.
  */
 import type { Mark, Node as PMNode } from "prosemirror-model";
 import { PluginKey, type Selection } from "prosemirror-state";
@@ -58,51 +59,17 @@ export interface ControlSpan extends StepRange {
  */
 export declare function controlSpans(block: Textblock): ControlSpan[];
 /**
- * Whether what stands at this position sits inside a cell a control shuts.
+ * Whether a lock shuts editing where this selection stands, which is what a menu that would lift a
+ * lock is built on (`editor/commands/lockCommands`).
  *
- * This is the question a paragraph edit leaves its locked paragraphs out by
- * (`editor/paragraphEdits`), and it is deliberately not `rangeTouchesLocked` over the paragraph:
- * a paragraph merely holding a locked control keeps its own alignment and indent.
- */
-export declare function insideLockedCell(doc: PMNode, pos: number): boolean;
-/**
- * Whether this stretch reaches contents a lock shuts: text inside a control that shuts its
- * contents, or what a locked cell holds, the cell itself included.
- *
- * This is the question about editing what stands there rather than about taking it away, so every
- * control the stretch meets answers with its contents clause. The lock commands and the formatting
- * commands ask it of the stretch they are about to mark, so it is exported.
- */
-export declare function rangeTouchesLocked(doc: PMNode, from: number, to: number): boolean;
-/**
- * Whether something inserted at this spot would land inside a locked control or a locked cell.
- *
- * Only a spot with the very same control on both sides is inside one. At either edge the other
- * side belongs to a different control or to none, and since the mark is not inclusive what goes
- * in there falls outside the control.
- */
-export declare function insertionInsideLocked(doc: PMNode, pos: number): boolean;
-/**
- * Whether the guard shuts editing where this selection stands.
- *
- * This is the question a command that rewrites whatever is selected has to ask before it reports
- * that it applies (`editor/insertImage`), and the one a menu offering to lift a lock is built on
- * (`editor/commands/lockCommands`). A caret is shut by standing inside a control rather than
- * against its edge, which is the same rule an insertion follows.
+ * This is a reading of the selection rather than of an edit - the lock guard answers an edit
+ * (`./guards`) - and it names the locks alone, which is what the menu says. A caret is shut by
+ * standing inside a control rather than against its edge, which is the same rule an insertion
+ * follows.
  * A control locked against deletion alone shuts nothing here: its contents stand open, so editing
  * where it stands goes through, and only taking the control away is refused.
  */
 export declare function selectionShut(selection: Selection, doc: PMNode): boolean;
-/**
- * Whether the guard would refuse putting something in place of what this selection covers, which
- * is what an image insertion does (`editor/insertImage`).
- *
- * A different question from `selectionShut`: what the selection covers whole goes away rather than
- * being edited, so the deletion clause answers for it. A control that may be taken away whole may
- * therefore be replaced, and one locked against deletion alone may not, even though editing inside
- * it would have gone through.
- */
-export declare function replacementShut(selection: Selection, doc: PMNode): boolean;
 /**
  * The locks the document carries, as `./guards` registers them.
  *

package/dist/schema/locks.js

@@ -127,11 +127,6 @@ function selectionShut(selection, doc) {
     (range) => markShut(doc, range.$from.pos, range.$to.pos)
   );
 }
-function replacementShut(selection, doc) {
-  return selection.ranges.some(
-    (range) => replaceShut(doc, range.$from.pos, range.$to.pos)
-  );
-}
 function editedRanges(step) {
   if (step instanceof ReplaceAroundStep) {
     return [
@@ -215,13 +210,9 @@ export {
   carriesLock,
   controlSpans,
   historyReplay,
-  insertionInsideLocked,
-  insideLockedCell,
   isLockedCell,
   lockGuard,
   lockedMarkOf,
-  rangeTouchesLocked,
-  replacementShut,
   selectionShut,
   unlockAllowed
 };

package/dist/schema/preservedGuards.d.ts

@@ -1,11 +1,13 @@
 /**
- * The guards over the nodes a document is opened with and the editor only preserves: the two ends
- * of a bookmark range, and the reference standing where a footnote or an endnote is called.
+ * The guards over what a document is opened with and the editor only preserves: the two ends of a
+ * bookmark range, the reference standing where a footnote or an endnote is called, and the
+ * paragraph that ends a section.
  *
- * Neither is content the editor writes, so nothing in it can put such a node back once it is gone,
- * and a document that lost one of a bookmark's two ends cannot be written back as a file at all
- * (`docx/exportDocx` refuses it). What each guard holds is therefore the whole list of the nodes it
- * answers for, in the order the document carries them.
+ * None of it is content the editor writes, so nothing in it can put such a thing back once it is
+ * gone, and a document that lost one of a bookmark's two ends cannot be written back as a file at
+ * all (`docx/exportDocx` refuses it). What the first two guards hold is therefore the whole list of
+ * the nodes they answer for, in the order the document carries them; a section break, which an
+ * edit may legitimately move from one paragraph to another, is held by its number instead.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type ChangeGuard, type EditGuardName } from "./editGuard";
@@ -27,4 +29,22 @@ type Signature = (node: PMNode) => string;
 export declare function preservedNodeGuard(name: EditGuardName, holds: (node: PMNode) => boolean, signature: Signature): ChangeGuard;
 export declare const bookmarkGuard: ChangeGuard;
 export declare const noteGuard: ChangeGuard;
+/**
+ * A guard that lets a change through only while it leaves at least as many section breaks standing
+ * as it found.
+ *
+ * A paragraph-level `w:sectPr` is not content: it is where one section of the document ends, and
+ * the section carries the page size, the margins and the headers everything up to it is laid out
+ * under. Joining that paragraph into the one above it - a Backspace at its start, a selection run
+ * across its boundary - would take the whole section away with it, and nothing the editor writes
+ * puts a section back.
+ *
+ * It counts rather than compares, so splitting such a paragraph is still allowed: Enter leaves the
+ * break on the half that ends up last (`docx/cloning`), and one break stands where one stood. An
+ * edit that adds a break is no business of this guard's either.
+ *
+ * The count walks the whole document, so it is reached for only once a step has touched a
+ * paragraph that lays a break down.
+ */
+export declare const sectionGuard: ChangeGuard;
 export {};

package/dist/schema/preservedGuards.js

@@ -1,4 +1,5 @@
 // src/schema/preservedGuards.ts
+import { parseProps, propsChild } from "../ooxml/props.js";
 import {
   rangeHolds,
   transactionReaches
@@ -43,8 +44,37 @@ var noteGuard = preservedNodeGuard(
   isNoteReference,
   (node) => JSON.stringify(node.attrs)
 );
+function endsASection(node) {
+  if (node.type.name !== "paragraph") return false;
+  const pPr = node.attrs.pPr;
+  if (typeof pPr !== "string") return false;
+  const props = parseProps(pPr);
+  return props !== null && propsChild(props.children, "sectPr") !== void 0;
+}
+function sectionBreaks(doc) {
+  let seen = 0;
+  doc.descendants((node) => {
+    if (endsASection(node)) seen += 1;
+    return true;
+  });
+  return seen;
+}
+var sectionGuard = {
+  name: "section",
+  change: (tr) => !transactionReaches(tr, endsASection) || sectionBreaks(tr.doc) >= sectionBreaks(tr.before),
+  shuts: (intent, state) => {
+    if (intent.kind !== "replace") return false;
+    const $from = state.doc.resolve(intent.from);
+    const $to = state.doc.resolve(intent.to);
+    if ($from.parent.type.name === "paragraph" && $from.sameParent($to)) {
+      return false;
+    }
+    return rangeHolds(state.doc, intent.from, intent.to, endsASection);
+  }
+};
 export {
   bookmarkGuard,
   noteGuard,
-  preservedNodeGuard
+  preservedNodeGuard,
+  sectionGuard
 };

package/dist/schema/protection.d.ts

@@ -38,7 +38,13 @@ export declare function isCommentNode(node: PMNode): boolean;
  * reads the same as it did before the comment, and the two compare equal.
  */
 export declare function withoutComments(node: PMNode): PMNode;
-/** Whether the two documents differ in nothing but their comments */
+/**
+ * Whether the two documents differ in nothing but their comments.
+ *
+ * The comparison is by source (`./sourceEquality`): a display value worked out again beside a
+ * comment is no content change, so it neither turns a comment edit into a body edit nor takes the
+ * ownership question off it.
+ */
 export declare function changesOnlyComments(before: PMNode, after: PMNode): boolean;
 /**
  * Whether a comment written under this identity may be edited or deleted.

package/dist/schema/protection.js

@@ -1,5 +1,6 @@
 // src/schema/protection.ts
 import { Fragment } from "prosemirror-model";
+import { sameSource } from "./sourceEquality.js";
 var COMMENT_NODES = /* @__PURE__ */ new Set([
   "commentStart",
   "commentEnd",
@@ -17,7 +18,7 @@ function withoutComments(node) {
   return node.copy(Fragment.fromArray(kept));
 }
 function changesOnlyComments(before, after) {
-  return withoutComments(before).eq(withoutComments(after));
+  return sameSource(withoutComments(before), withoutComments(after));
 }
 function stringOrNull(value) {
   return typeof value === "string" ? value : null;

package/dist/schema/sourceEquality.d.ts

@@ -11,17 +11,9 @@
  * type, the text, the marks and the source and session attrs all have to agree, and the recursion
  * runs the same way, so a node that says the same thing in a different shape is still a change.
  */
-import { type Node as PMNode } from "prosemirror-model";
+import type { Node as PMNode } from "prosemirror-model";
 /**
  * Whether the two would write the same XML: the same type, text, marks and source attrs, all the
  * way down. What the editor works out for the screen is not compared.
  */
 export declare function sameSource(a: PMNode, b: PMNode): boolean;
-/**
- * The node with every worked-out attr back at the value the schema starts it on, on itself and on
- * everything inside it.
- *
- * `sameSource` needs no such copy, and takes none. This is for a caller that has to hand a whole
- * document to something comparing the ordinary way.
- */
-export declare function withoutDisplayAttrs(node: PMNode): PMNode;

package/dist/schema/sourceEquality.js

@@ -1,7 +1,4 @@
 // src/schema/sourceEquality.ts
-import {
-  Fragment
-} from "prosemirror-model";
 import { displayAttrsOf } from "./attrRoles.js";
 function sameValue(a, b) {
   if (a === b) return true;
@@ -37,29 +34,6 @@ function sameSource(a, b) {
   }
   return true;
 }
-function withoutDisplay(type, attrs) {
-  return Object.fromEntries(
-    Object.entries(attrs).map(
-      ([name, value]) => displayAttrsOf(type).includes(name) ? [name, type.spec.attrs?.[name]?.default ?? null] : [name, value]
-    )
-  );
-}
-function withoutDisplayMarkAttrs(mark) {
-  return displayAttrsOf(mark.type).length === 0 ? mark : mark.type.create(withoutDisplay(mark.type, mark.attrs));
-}
-var childrenOf = (node) => Array.from({ length: node.childCount }, (_, at) => node.child(at));
-function withoutDisplayAttrs(node) {
-  const marks = node.marks.map(withoutDisplayMarkAttrs);
-  if (node.isText) return node.mark(marks);
-  return node.type.create(
-    withoutDisplay(node.type, node.attrs),
-    Fragment.fromArray(
-      childrenOf(node).map((child) => withoutDisplayAttrs(child))
-    ),
-    marks
-  );
-}
 export {
-  sameSource,
-  withoutDisplayAttrs
+  sameSource
 };

package/dist/styles/inlineStyle.js

@@ -59,20 +59,29 @@ function lineHeightValue(spacing) {
   return `max(${pt(spacing.pt)},${SINGLE_LINE_RATIO}em)`;
 }
 function textDecoration(format) {
+  const underline = format.underline !== void 0 && format.underline !== "none" ? format.underline : void 0;
   const lines = [];
-  if (format.underline) lines.push("underline");
+  if (underline) lines.push("underline");
   if (format.strike) lines.push("line-through");
-  if (lines.length === 0) return [];
+  if (lines.length === 0) {
+    return format.underline === "none" || format.strike === false ? ["text-decoration-line:none"] : [];
+  }
   const css = [`text-decoration-line:${lines.join(" ")}`];
-  const style = format.underline ? UNDERLINE_STYLES[format.underline] : void 0;
+  const style = underline ? UNDERLINE_STYLES[underline] : void 0;
   if (style) css.push(`text-decoration-style:${style}`);
   return css;
 }
 function inheritedRunCss(format, fontFallbacks) {
   const css = [];
-  if (format.bold) css.push("font-weight:bold");
-  if (format.italic) css.push("font-style:italic");
-  if (format.smallCaps) css.push("font-variant:small-caps");
+  if (format.bold !== void 0) {
+    css.push(`font-weight:${format.bold ? "bold" : "normal"}`);
+  }
+  if (format.italic !== void 0) {
+    css.push(`font-style:${format.italic ? "italic" : "normal"}`);
+  }
+  if (format.smallCaps !== void 0) {
+    css.push(`font-variant:${format.smallCaps ? "small-caps" : "normal"}`);
+  }
   css.push(...textDecoration(format));
   if (format.fontSizePt !== void 0)
     css.push(`font-size:${pt(format.fontSizePt)}`);

package/dist/table/cellFormatting.d.ts

@@ -41,7 +41,14 @@ export declare function setCellBorders(preset: CellBorderPreset): TableCommand;
 export declare function setCellBorderColor(hex: string | null): TableCommand;
 /** Fills the selected cells with `#RRGGBB`. Null takes the fill away */
 export declare function setCellBackground(hex: string | null): TableCommand;
-/** Whether direct cell formatting can act on the whole current cell selection. */
+/**
+ * Whether direct cell formatting can act on the whole current cell selection.
+ *
+ * What a cell records about itself is rewritten around its content, which is the block intent the
+ * guards answer (`schema/guards`): a cell a control shuts is refused, and so is every cell while a
+ * protection shuts the body. The spot asked about stands inside the cell, since that is where the
+ * control wrapping it is an ancestor.
+ */
 export declare function canSetCellFormatting(state: EditorState): boolean;
 /** The fill shared by the selected cells. Null when they differ or none is filled */
 export declare function activeCellBackground(state: EditorState): string | null;

package/dist/table/cellFormatting.js

@@ -8,9 +8,7 @@ import {
   NO_FILL,
   toCellFormat
 } from "../model/format.js";
-import { transactionAllowed } from "../schema/guards.js";
-import { isLockedCell } from "../schema/locks.js";
-import { editsShut } from "../schema/protectionState.js";
+import { editShut, guardedCommand } from "../schema/guards.js";
 import { cellDefaultsAt, tableCellSources } from "./gridBorders.js";
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -52,19 +50,12 @@ function planChanges(rect, edit) {
   return changes;
 }
 function cellFormatCommand(edit) {
-  return (state, dispatch) => {
-    if (!pmIsInTable(state)) return false;
+  return guardedCommand((state) => {
+    if (!canSetCellFormatting(state)) return null;
     const rect = selectedRect(state);
-    if (rect.map.cellsInRect(rect).some((pos) => isLockedCell(rect.table.nodeAt(pos)))) {
-      return false;
-    }
     const changes = planChanges(rect, edit);
-    if (changes.length === 0) return false;
-    const transaction = applyChanges(state.tr, rect.tableStart, changes);
-    if (!transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changes.length === 0 ? null : applyChanges(state.tr, rect.tableStart, changes);
+  });
 }
 function shared(values) {
   const [first, ...rest] = values;
@@ -112,17 +103,18 @@ function selectedCells(state) {
   const cells = [];
   for (const pos of rect.map.cellsInRect(rect)) {
     const cell = rect.table.nodeAt(pos);
-    if (cell) cells.push(cell);
+    if (cell) cells.push({ node: cell, pos: rect.tableStart + pos });
   }
   return cells;
 }
 function cellFormats(state) {
-  return selectedCells(state).map((cell) => toCellFormat(cell.attrs.format));
+  return selectedCells(state).map(
+    ({ node }) => toCellFormat(node.attrs.format)
+  );
 }
 function canSetCellFormatting(state) {
-  if (editsShut(state)) return false;
   const cells = selectedCells(state);
-  return cells.length > 0 && cells.every((cell) => !isLockedCell(cell));
+  return cells.length > 0 && cells.every(({ pos }) => !editShut(state, { kind: "block", at: pos + 1 }));
 }
 function sharedValue(values) {
   const [first, ...rest] = values;

package/dist/table/commands.js

@@ -3,7 +3,7 @@ import {
   deleteTable as pmDeleteTable,
   isInTable as pmIsInTable
 } from "prosemirror-tables";
-import { transactionAllowed } from "../schema/guards.js";
+import { guardedCommand } from "../schema/guards.js";
 import {
   buildAddColumnAfterTransaction,
   buildAddColumnBeforeTransaction,
@@ -18,26 +18,22 @@ import {
 function isInTable(state) {
   return pmIsInTable(state);
 }
-function toCommand(build) {
-  return (state, dispatch) => {
-    const tr = build(state);
-    if (!tr || !transactionAllowed(tr, state)) return false;
-    dispatch?.(tr);
-    return true;
-  };
-}
-var addRowBefore = toCommand(
+var addRowBefore = guardedCommand(
   buildAddRowBeforeTransaction
 );
-var addRowAfter = toCommand(buildAddRowAfterTransaction);
-var deleteRow = toCommand(buildDeleteRowTransaction);
-var addColumnBefore = toCommand(
+var addRowAfter = guardedCommand(
+  buildAddRowAfterTransaction
+);
+var deleteRow = guardedCommand(
+  buildDeleteRowTransaction
+);
+var addColumnBefore = guardedCommand(
   buildAddColumnBeforeTransaction
 );
-var addColumnAfter = toCommand(
+var addColumnAfter = guardedCommand(
   buildAddColumnAfterTransaction
 );
-var deleteColumn = toCommand(
+var deleteColumn = guardedCommand(
   buildDeleteColumnTransaction
 );
 function buildDeleteTableTransaction(state) {
@@ -46,9 +42,15 @@ function buildDeleteTableTransaction(state) {
   pmDeleteTable(state, (tr) => captured.push(tr));
   return captured[0] ?? null;
 }
-var deleteTable = toCommand(buildDeleteTableTransaction);
-var mergeCells = toCommand(buildMergeCellsTransaction);
-var splitCell = toCommand(buildSplitCellTransaction);
+var deleteTable = guardedCommand(
+  buildDeleteTableTransaction
+);
+var mergeCells = guardedCommand(
+  buildMergeCellsTransaction
+);
+var splitCell = guardedCommand(
+  buildSplitCellTransaction
+);
 export {
   addColumnAfter,
   addColumnBefore,

package/dist/table/format.d.ts

@@ -2,6 +2,9 @@
  * Newly created cells and rows inherit only the formatting of the cell or row they
  * are based on. Values that have to be recomputed from the grid (colspan, rowspan,
  * colwidth) are not inherited.
+ *
+ * What that comes to per attr is `docx/cloning`, which answers the same question for a
+ * paragraph an edit makes out of another paragraph.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { GridRect } from "../docx/tableFormatting";

package/dist/table/format.js

@@ -1,4 +1,5 @@
 // src/table/format.ts
+import { CLONE_POLICIES } from "../docx/cloning.js";
 function isNumberArray(value) {
   return Array.isArray(value) && value.every((entry) => typeof entry === "number");
 }
@@ -6,18 +7,11 @@ function colwidthOf(cell) {
   const value = cell.attrs.colwidth;
   return isNumberArray(value) ? value : null;
 }
-var INHERITED_CELL_ATTRS = ["tcAttrs", "tcPr", "tcW", "format"];
 function inheritCellAttrs(cell, overrides = {}) {
-  const attrs = {};
-  for (const key of INHERITED_CELL_ATTRS) attrs[key] = cell.attrs[key];
-  return { ...attrs, ...overrides };
+  return { ...CLONE_POLICIES.tableCell.attrs(cell, "copy"), ...overrides };
 }
-var INHERITED_ROW_ATTRS = ["trAttrs", "trPr", "format"];
 function inheritRowAttrs(row) {
-  if (!row) return null;
-  const attrs = {};
-  for (const key of INHERITED_ROW_ATTRS) attrs[key] = row.attrs[key];
-  return attrs;
+  return row ? CLONE_POLICIES.tableRow.attrs(row, "copy") : null;
 }
 export {
   colwidthOf,

package/dist/table/gridBorders.d.ts

@@ -1,5 +1,5 @@
 /**
- * The lines a cell draws because of where it sits in the grid, kept true after a structure edit.
+ * The lines a cell draws because of where it sits in the grid.
  *
  * Every line of a table is drawn by its cells (see `docx/tableFormatting`), so which line a side
  * falls back on depends on where in the grid the cell sits. A new cell inherits its neighbour's
@@ -9,13 +9,14 @@
  *
  * So the cells of a table whose grid moved derive their display values again, along the same path
  * the import takes. What a cell wrote down itself lives in its `w:tcPr` and is read straight back
- * out of it, so only the share that came from the table can change.
+ * out of it, so only the share that came from the table can change. `cellFixes` says which cells
+ * carry the wrong lines and `sameFormattingInputs` whether anything they depend on moved; the
+ * deriver that runs them after an edit is `editor/plugins/tableDisplay`.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { Plugin } from "prosemirror-state";
 import { type CellBorderDefaults } from "../docx/tableFormatting";
 import { type CellMargins, type InsideBorders, type TableFormat } from "../model/format";
-import type { TableGridMap } from "./format";
+import type { NodeAttrs, TableGridMap } from "./format";
 /**
  * What a table lays down for its cells to draw.
  * The values a table style laid down are not in the `tblPr`, so the table carries them separately.
@@ -28,15 +29,12 @@ export interface TableCellSources {
 export declare function tableCellSources(table: PMNode): TableCellSources;
 /** The lines the cell at this position falls back on for the sides it draws no border of its own on */
 export declare function cellDefaultsAt(map: TableGridMap, pos: number, sources: TableCellSources): CellBorderDefaults;
-/** Derives shared-border display values before the first editor view is drawn. */
-export declare function withDerivedGridBorders(doc: PMNode): PMNode;
-/**
- * Keeps the derived lines current after a table's grid or border inputs change.
- *
- * The tables are paired up by the order they stand in. A document that gained or lost a whole table
- * pairs the ones after it with the wrong partner, which costs a derivation that changes no cell.
- *
- * No transaction of its own goes to the history: ProseMirror hands an appended transaction to the
- * history as part of the same event, so a single undo takes the edit and this correction back together.
- */
-export declare function gridBorders(): Plugin;
+export interface CellFix {
+    /** The position of the cell within the table's content */
+    pos: number;
+    attrs: NodeAttrs;
+}
+/** The cells of this table whose display values do not match the spot they now sit in */
+export declare function cellFixes(table: PMNode): CellFix[];
+/** Whether everything the cells' lines are derived from reads the same in both tables */
+export declare function sameFormattingInputs(a: PMNode, b: PMNode): boolean;