@portone/docx-editor 0.1.0

package/dist/table/cellBorders.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The cell border presets the built-in menu offers, each with the name written on its row.
+ * A menu of your own takes the list from the root entry and hands the preset it picked to
+ * `setCellBorders`.
+ */
+import type { CellBorderPreset } from "./cellFormatting";
+export interface CellBorderOption {
+    /** What the row is called on screen */
+    label: string;
+    preset: CellBorderPreset;
+}
+export declare const DEFAULT_CELL_BORDERS: readonly CellBorderOption[];

package/dist/table/cellBorders.js

@@ -0,0 +1,9 @@
+// src/table/cellBorders.ts
+var DEFAULT_CELL_BORDERS = [
+  { label: "All borders", preset: "all" },
+  { label: "Outer borders", preset: "outer" },
+  { label: "No borders", preset: "none" }
+];
+export {
+  DEFAULT_CELL_BORDERS
+};

package/dist/table/cellFormatting.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A job applies to the cell holding the caret, or to every cell a cell selection covers.
+ * All XML handling belongs to `docx/tableFormatting`; this file only decides which cells take part
+ * and which of their sides a border preset writes.
+ *
+ * A cell already in the state the job wants is left untouched, so its original XML survives.
+ * That is also what tells the menu whether an entry has anything to do: following the ProseMirror
+ * convention, calling a command without `dispatch` only reports whether it would change something.
+ */
+import type { EditorState } from "prosemirror-state";
+import { type CellSide } from "../docx/tableFormatting";
+import { type CellVerticalAlign } from "../model/format";
+import type { TableCommand } from "./commands";
+/**
+ * Which sides of the selected block a preset writes.
+ * `all` and `none` speak for every side of every selected cell, while `outer` writes only the sides
+ * that lie on the edge of the block, leaving the lines inside it as they are (the same as Word).
+ */
+export type CellBorderPreset = "all" | "outer" | "none";
+export type MixedCellValue<T> = T | "mixed" | null;
+export interface ActiveCellPadding {
+    top: MixedCellValue<number>;
+    right: MixedCellValue<number>;
+    bottom: MixedCellValue<number>;
+    left: MixedCellValue<number>;
+}
+/** The effective vertical alignment of the selected cells. An omitted OOXML value means top. */
+export declare function activeCellVerticalAlign(state: EditorState): MixedCellValue<CellVerticalAlign>;
+/** The effective padding on each side of the selected cells, with mixed sides reported separately. */
+export declare function activeCellPadding(state: EditorState): ActiveCellPadding;
+/** Places content at the top, center, or bottom of every selected cell. */
+export declare function setCellVerticalAlign(align: CellVerticalAlign): TableCommand;
+/** Writes direct padding only for the sides supplied, leaving every omitted side unchanged. */
+export declare function setCellPadding(values: Partial<Record<CellSide, number>>): TableCommand;
+/** Draws (or clears) the lines of the selected cells. */
+export declare function setCellBorders(preset: CellBorderPreset): TableCommand;
+/**
+ * Colors the visible lines of the selected cells as `#RRGGBB`. Inherited table lines become direct
+ * cell overrides only on the sides that are visible. Null resets the resulting color to `auto`.
+ */
+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. */
+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;
+/**
+ * The color shared by every line the selected cells draw.
+ * The lines are looked at as they appear on screen, so a color the table's inside lines gave is
+ * counted too. Null when the lines differ, or when none is drawn.
+ */
+export declare function activeCellBorderColor(state: EditorState): string | null;
+/**
+ * Whether the border color has anything visible to act on in the current cell selection.
+ */
+export declare function canSetCellBorderColor(state: EditorState): boolean;

package/dist/table/cellFormatting.js

@@ -0,0 +1,173 @@
+// src/table/cellFormatting.ts
+import { isInTable as pmIsInTable, selectedRect } from "prosemirror-tables";
+import {
+  ALL_CELL_SIDES,
+  editCellProps
+} from "../docx/tableFormatting.js";
+import {
+  NO_FILL,
+  toCellFormat
+} from "../model/format.js";
+import { isLockedCell, transactionAllowed } from "../schema/locks.js";
+import { cellDefaultsAt, tableCellSources } from "./gridBorders.js";
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function outerSides(rect, pos) {
+  const cell = rect.map.findCell(pos);
+  const sides = [];
+  if (cell.top === rect.top) sides.push("top");
+  if (cell.bottom === rect.bottom) sides.push("bottom");
+  if (cell.left === rect.left) sides.push("left");
+  if (cell.right === rect.right) sides.push("right");
+  return sides;
+}
+function borderEdit(preset, rect, pos) {
+  return {
+    kind: "borders",
+    line: preset === "none" ? "none" : "single",
+    sides: preset === "outer" ? outerSides(rect, pos) : ALL_CELL_SIDES
+  };
+}
+function planChanges(rect, edit) {
+  const sources = tableCellSources(rect.table);
+  const changes = [];
+  for (const pos of rect.map.cellsInRect(rect)) {
+    const cell = rect.table.nodeAt(pos);
+    if (!cell) continue;
+    const next = editCellProps(
+      text(cell.attrs.tcPr),
+      edit(rect, pos),
+      cellDefaultsAt(rect.map, pos, sources),
+      sources.margins
+    );
+    if (!next) continue;
+    changes.push({
+      pos,
+      attrs: { ...cell.attrs, tcPr: next.tcPr, format: next.format }
+    });
+  }
+  return changes;
+}
+function cellFormatCommand(edit) {
+  return (state, dispatch) => {
+    if (!pmIsInTable(state)) return false;
+    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.doc)) return false;
+    dispatch?.(transaction);
+    return true;
+  };
+}
+function shared(values) {
+  const [first, ...rest] = values;
+  if (first === void 0) return null;
+  return rest.every((value) => value === first) ? first : "mixed";
+}
+function activeCellVerticalAlign(state) {
+  return shared(
+    cellFormats(state).map((format) => format?.verticalAlign ?? "top")
+  );
+}
+function activeCellPadding(state) {
+  const formats = cellFormats(state);
+  return {
+    top: shared(formats.map((format) => format?.paddingTopPt ?? null)),
+    right: shared(formats.map((format) => format?.paddingRightPt ?? null)),
+    bottom: shared(formats.map((format) => format?.paddingBottomPt ?? null)),
+    left: shared(formats.map((format) => format?.paddingLeftPt ?? null))
+  };
+}
+function setCellVerticalAlign(align) {
+  return cellFormatCommand(() => ({ kind: "verticalAlign", align }));
+}
+function setCellPadding(values) {
+  return cellFormatCommand(() => ({ kind: "padding", values }));
+}
+function applyChanges(tr, tableStart, changes) {
+  for (const change of changes) {
+    tr.setNodeMarkup(tableStart + change.pos, null, change.attrs);
+  }
+  return tr;
+}
+function setCellBorders(preset) {
+  return cellFormatCommand((rect, pos) => borderEdit(preset, rect, pos));
+}
+function setCellBorderColor(hex) {
+  return cellFormatCommand(() => ({ kind: "borderColor", hex }));
+}
+function setCellBackground(hex) {
+  return cellFormatCommand(() => ({ kind: "background", hex }));
+}
+function selectedCells(state) {
+  if (!pmIsInTable(state)) return [];
+  const rect = selectedRect(state);
+  const cells = [];
+  for (const pos of rect.map.cellsInRect(rect)) {
+    const cell = rect.table.nodeAt(pos);
+    if (cell) cells.push(cell);
+  }
+  return cells;
+}
+function cellFormats(state) {
+  return selectedCells(state).map((cell) => toCellFormat(cell.attrs.format));
+}
+function canSetCellFormatting(state) {
+  const cells = selectedCells(state);
+  return cells.length > 0 && cells.every((cell) => !isLockedCell(cell));
+}
+function sharedValue(values) {
+  const [first, ...rest] = values;
+  if (first === void 0) return null;
+  return rest.every((value) => value === first) ? first : null;
+}
+function borderColorOf(border) {
+  if (border === void 0 || border === "none") return null;
+  const color = border.slice(border.lastIndexOf(" ") + 1);
+  return color.startsWith("#") ? color : null;
+}
+function activeCellBackground(state) {
+  const shared2 = sharedValue(
+    cellFormats(state).map((format) => format?.background ?? null)
+  );
+  return shared2 === NO_FILL ? null : shared2;
+}
+function activeCellBorderColor(state) {
+  const colors = cellFormats(state).flatMap(
+    (format) => [
+      format?.borderTop,
+      format?.borderBottom,
+      format?.borderLeft,
+      format?.borderRight
+    ].map(borderColorOf).filter((color) => color !== null)
+  );
+  return sharedValue(colors);
+}
+function canSetCellBorderColor(state) {
+  return canSetCellFormatting(state) && cellFormats(state).some(
+    (format) => [
+      format?.borderTop,
+      format?.borderBottom,
+      format?.borderLeft,
+      format?.borderRight
+    ].some((border) => border !== void 0 && border !== "none")
+  );
+}
+export {
+  activeCellBackground,
+  activeCellBorderColor,
+  activeCellPadding,
+  activeCellVerticalAlign,
+  canSetCellBorderColor,
+  canSetCellFormatting,
+  setCellBackground,
+  setCellBorderColor,
+  setCellBorders,
+  setCellPadding,
+  setCellVerticalAlign
+};

package/dist/table/columns.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `prosemirror-tables`' `addColumn` gets the grid math right but creates the new cells
+ * without any formatting. So only its skeleton is followed here, with inheritance of
+ * the reference cell's formatting and an update of the grid column widths added on top.
+ * Deletion is left to `deleteColumn`, and only the deleted columns are dropped from the
+ * grid.
+ *
+ * Adding a column leaves the grid total the same as it was before: widening the table
+ * by the new column's width would push it past the page.
+ */
+import { type EditorState, type Transaction } from "prosemirror-state";
+/**
+ * Builds the transaction that adds a column right of the column holding the cursor.
+ * `null` when the cursor is outside a table. The cursor moves into a cell of the new
+ * column.
+ */
+export declare function buildAddColumnAfterTransaction(state: EditorState): Transaction | null;
+/** The left-hand version. Only the insertion position differs */
+export declare function buildAddColumnBeforeTransaction(state: EditorState): Transaction | null;
+/**
+ * Builds the transaction that deletes the column holding the cursor (or the columns
+ * spanned by a multi-column selection).
+ * `null` outside a table, or when every column of the table is selected.
+ */
+export declare function buildDeleteColumnTransaction(state: EditorState): Transaction | null;

package/dist/table/columns.js

@@ -0,0 +1,155 @@
+// src/table/columns.ts
+import {
+  TextSelection
+} from "prosemirror-state";
+import {
+  addColSpan,
+  deleteColumn as pmDeleteColumn,
+  isInTable as pmIsInTable,
+  selectedRect,
+  TableMap,
+  tableNodeTypes
+} from "prosemirror-tables";
+import { spanCount, toTableWidth } from "../model/format.js";
+import {
+  colwidthOf,
+  inheritCellAttrs
+} from "./format.js";
+import {
+  cellWidthForGridCol,
+  gridColsScaledTo,
+  gridTotal,
+  rescaleCellWidths,
+  tableGridCols,
+  writeGridCols
+} from "./widths.js";
+function spanAttrsOf(cell) {
+  return {
+    ...cell.attrs,
+    colspan: spanCount(cell.attrs.colspan),
+    rowspan: spanCount(cell.attrs.rowspan),
+    colwidth: colwidthOf(cell)
+  };
+}
+function columnSlice(cell, offset) {
+  const value = colwidthOf(cell);
+  if (!value) return null;
+  const entry = value[offset] ?? value[0];
+  return typeof entry === "number" ? [entry] : null;
+}
+function newColumnCellAttrs(rect, referenceCell, referencePos, referenceGridCol) {
+  return inheritCellAttrs(referenceCell, {
+    colspan: 1,
+    rowspan: 1,
+    colwidth: columnSlice(
+      referenceCell,
+      referenceGridCol - rect.map.colCount(referencePos)
+    ),
+    tcW: cellWidthForGridCol(
+      tableGridCols(rect.table),
+      referenceGridCol,
+      toTableWidth(referenceCell.attrs.tcW),
+      spanCount(referenceCell.attrs.colspan)
+    )
+  });
+}
+function isCrossedFromLeft(map, col, index) {
+  return col > 0 && col < map.width && map.map[index - 1] === map.map[index];
+}
+function growColspan(tr, rect, col, index) {
+  const { map, table, tableStart } = rect;
+  const pos = map.map[index];
+  const cell = table.nodeAt(pos);
+  if (!cell) return 1;
+  const attrs = spanAttrsOf(cell);
+  tr.setNodeMarkup(
+    tr.mapping.map(tableStart + pos),
+    null,
+    addColSpan(attrs, col - map.colCount(pos))
+  );
+  return attrs.rowspan;
+}
+function widthIsPageShare(table) {
+  return toTableWidth(table.attrs.tblW)?.type === "pct";
+}
+function insertGridCol(tr, rect, col, referenceGridCol) {
+  const gridCols = tableGridCols(rect.table);
+  if (!gridCols) return;
+  const at = Math.min(col, gridCols.length);
+  const inserted = gridCols[referenceGridCol] ?? gridCols[gridCols.length - 1] ?? 0;
+  const grown = [...gridCols.slice(0, at), inserted, ...gridCols.slice(at)];
+  if (widthIsPageShare(rect.table)) {
+    writeGridCols(tr, rect.tableStart, grown);
+    return;
+  }
+  const shared = gridColsScaledTo(grown, gridTotal(gridCols));
+  writeGridCols(tr, rect.tableStart, shared);
+  rescaleCellWidths(tr, rect.tableStart, shared);
+}
+function insertColumnWithFormat(tr, rect, col) {
+  const { map, table, tableStart } = rect;
+  const referenceOffset = col > 0 ? -1 : 0;
+  const referenceGridCol = col + referenceOffset;
+  for (let row = 0; row < map.height; row++) {
+    const index = row * map.width + col;
+    if (isCrossedFromLeft(map, col, index)) {
+      row += growColspan(tr, rect, col, index) - 1;
+      continue;
+    }
+    const referencePos = map.map[index + referenceOffset];
+    const referenceCell = referencePos != null ? table.nodeAt(referencePos) : null;
+    const type = referenceCell ? referenceCell.type : tableNodeTypes(table.type.schema).cell;
+    const attrs = referenceCell ? newColumnCellAttrs(rect, referenceCell, referencePos, referenceGridCol) : null;
+    const node = type.createAndFill(attrs);
+    if (!node) continue;
+    tr.insert(
+      tr.mapping.map(tableStart + map.positionAt(row, col, table)),
+      node
+    );
+  }
+  insertGridCol(tr, rect, col, referenceGridCol);
+}
+function buildAddColumnTransaction(state, column) {
+  if (!pmIsInTable(state)) return null;
+  const rect = selectedRect(state);
+  const col = column(rect);
+  const tr = state.tr;
+  insertColumnWithFormat(tr, rect, col);
+  const tablePos = tr.mapping.map(rect.tableStart - 1);
+  const table = tr.doc.nodeAt(tablePos);
+  if (table) {
+    const map = TableMap.get(table);
+    const row = Math.min(rect.top, map.height - 1);
+    const cellPos = map.map[row * map.width + col];
+    tr.setSelection(TextSelection.near(tr.doc.resolve(tablePos + 1 + cellPos)));
+  }
+  return tr.scrollIntoView();
+}
+function buildAddColumnAfterTransaction(state) {
+  return buildAddColumnTransaction(state, (rect) => rect.right);
+}
+function buildAddColumnBeforeTransaction(state) {
+  return buildAddColumnTransaction(state, (rect) => rect.left);
+}
+function buildDeleteColumnTransaction(state) {
+  if (!pmIsInTable(state)) return null;
+  const rect = selectedRect(state);
+  const { left, right, tableStart } = rect;
+  const gridCols = tableGridCols(rect.table);
+  const captured = [];
+  pmDeleteColumn(state, (tr2) => captured.push(tr2));
+  const tr = captured[0];
+  if (!tr) return null;
+  if (gridCols) {
+    writeGridCols(tr, tableStart, [
+      ...gridCols.slice(0, left),
+      ...gridCols.slice(right)
+    ]);
+  }
+  return tr;
+}
+export {
+  buildAddColumnAfterTransaction,
+  buildAddColumnBeforeTransaction,
+  buildDeleteColumnTransaction
+};

package/dist/table/commands.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Building a transaction and running it are kept apart.
+ * Following the ProseMirror convention, calling a command without `dispatch` only
+ * reports whether it can run right now, and that answer takes in the lock guard
+ * (`schema/locks`), so no caller has to ask about locks separately.
+ */
+import type { EditorState, Transaction } from "prosemirror-state";
+export type TableCommand = (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
+/** Whether the cursor sits inside a table. Used to enable and disable the table buttons */
+export declare function isInTable(state: EditorState): boolean;
+export declare const addRowBefore: TableCommand;
+export declare const addRowAfter: TableCommand;
+export declare const deleteRow: TableCommand;
+export declare const addColumnBefore: TableCommand;
+export declare const addColumnAfter: TableCommand;
+export declare const deleteColumn: TableCommand;
+export declare const deleteTable: TableCommand;
+export declare const mergeCells: TableCommand;
+export declare const splitCell: TableCommand;

package/dist/table/commands.js

@@ -0,0 +1,63 @@
+// src/table/commands.ts
+import {
+  deleteTable as pmDeleteTable,
+  isInTable as pmIsInTable
+} from "prosemirror-tables";
+import { transactionAllowed } from "../schema/locks.js";
+import {
+  buildAddColumnAfterTransaction,
+  buildAddColumnBeforeTransaction,
+  buildDeleteColumnTransaction
+} from "./columns.js";
+import { buildMergeCellsTransaction, buildSplitCellTransaction } from "./merge.js";
+import {
+  buildAddRowAfterTransaction,
+  buildAddRowBeforeTransaction,
+  buildDeleteRowTransaction
+} from "./rows.js";
+function isInTable(state) {
+  return pmIsInTable(state);
+}
+function toCommand(build) {
+  return (state, dispatch) => {
+    const tr = build(state);
+    if (!tr || !transactionAllowed(tr, state.doc)) return false;
+    dispatch?.(tr);
+    return true;
+  };
+}
+var addRowBefore = toCommand(
+  buildAddRowBeforeTransaction
+);
+var addRowAfter = toCommand(buildAddRowAfterTransaction);
+var deleteRow = toCommand(buildDeleteRowTransaction);
+var addColumnBefore = toCommand(
+  buildAddColumnBeforeTransaction
+);
+var addColumnAfter = toCommand(
+  buildAddColumnAfterTransaction
+);
+var deleteColumn = toCommand(
+  buildDeleteColumnTransaction
+);
+function buildDeleteTableTransaction(state) {
+  if (!pmIsInTable(state)) return null;
+  const captured = [];
+  pmDeleteTable(state, (tr) => captured.push(tr));
+  return captured[0] ?? null;
+}
+var deleteTable = toCommand(buildDeleteTableTransaction);
+var mergeCells = toCommand(buildMergeCellsTransaction);
+var splitCell = toCommand(buildSplitCellTransaction);
+export {
+  addColumnAfter,
+  addColumnBefore,
+  addRowAfter,
+  addRowBefore,
+  deleteColumn,
+  deleteRow,
+  deleteTable,
+  isInTable,
+  mergeCells,
+  splitCell
+};

package/dist/table/format.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { GridRect } from "../docx/tableFormatting";
+export type NodeAttrs = Record<string, unknown>;
+export type { GridRect };
+/** Only the parts of what `selectedRect()` returns that are actually used here */
+export interface TableGridMap {
+    width: number;
+    height: number;
+    map: number[];
+    colCount(pos: number): number;
+    positionAt(row: number, col: number, table: PMNode): number;
+    /** The coordinates the cell at this position covers, merges included */
+    findCell(pos: number): GridRect;
+    /** The positions of the cells the block covers, each one listed once */
+    cellsInRect(rect: GridRect): number[];
+}
+export interface TableRect extends GridRect {
+    map: TableGridMap;
+    table: PMNode;
+    tableStart: number;
+}
+/** The list of on-screen widths. `prosemirror-tables` uses it for column resizing */
+export declare function colwidthOf(cell: PMNode): number[] | null;
+/** Copies only the formatting of the reference cell. Values passed in `overrides` win */
+export declare function inheritCellAttrs(cell: PMNode, overrides?: NodeAttrs): NodeAttrs;
+/**
+ * Copies only the formatting of the reference row. `null` when there is no reference
+ * row, meaning the schema defaults should be used
+ */
+export declare function inheritRowAttrs(row: PMNode | null): NodeAttrs | null;

package/dist/table/format.js

@@ -0,0 +1,26 @@
+// src/table/format.ts
+function isNumberArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "number");
+}
+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 };
+}
+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;
+}
+export {
+  colwidthOf,
+  inheritCellAttrs,
+  inheritRowAttrs
+};

package/dist/table/gridBorders.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The lines a cell draws because of where it sits in the grid, kept true after a structure edit.
+ *
+ * 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
+ * formatting, which is what a background has to do but not a line: the row appended under the last
+ * one would draw the table's outer line against the row above it, and deleting the last row would
+ * leave the table with no line along its bottom.
+ *
+ * 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.
+ */
+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";
+/**
+ * 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.
+ */
+export interface TableCellSources {
+    outer: TableFormat | null;
+    inside: InsideBorders;
+    margins: CellMargins;
+}
+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;