@stll/folio-core 0.53.0 → 0.54.0

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 };

package/dist/prosemirror/styles/tableStyleRegions.js

@@ -0,0 +1,55 @@
+//#region src/prosemirror/styles/tableStyleRegions.ts
+/**
+* The horizontal band a row takes by position: every row but a styled first
+* or last row alternates, starting with band 1.
+*/
+const tableRowBand = (look, rowIndex, totalRows) => {
+	if (look.noHBand) return;
+	const styledFirstRow = rowIndex === 0 && look.firstRow;
+	const styledLastRow = rowIndex === totalRows - 1 && look.lastRow;
+	if (styledFirstRow || styledLastRow) return;
+	return (look.firstRow && rowIndex > 0 ? rowIndex - 1 : rowIndex) % 2 === 0 ? "band1Horz" : "band2Horz";
+};
+/**
+* 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.
+*/
+const tableCellStyleRegions = ({ look, rowIndex, totalRows, column, colspan, totalColumns, rowBand, rowConditionalFormat: rowCnf, cellConditionalFormat: cellCnf }) => {
+	const rowIsFirstRow = rowCnf?.firstRow ?? rowIndex === 0;
+	const rowIsLastRow = rowCnf?.lastRow ?? rowIndex === totalRows - 1;
+	const isFirstRow = cellCnf?.firstRow ?? rowIsFirstRow;
+	const isLastRow = cellCnf?.lastRow ?? rowIsLastRow;
+	const isFirstCol = cellCnf?.firstColumn ?? column === 0;
+	const isLastCol = cellCnf?.lastColumn ?? column + colspan === totalColumns;
+	let verticalBand;
+	if (!look.noVBand) {
+		const bandColumn = column - (look.firstColumn ? 1 : 0);
+		if (bandColumn >= 0 && !(look.lastColumn && isLastCol) && !(look.firstColumn && isFirstCol)) verticalBand = bandColumn % 2 === 0 ? "band1Vert" : "band2Vert";
+	}
+	if (cellCnf?.oddVBand) verticalBand = "band1Vert";
+	else if (cellCnf?.evenVBand) verticalBand = "band2Vert";
+	let horizontalBand = rowBand;
+	if (rowCnf?.oddHBand) horizontalBand = "band1Horz";
+	else if (rowCnf?.evenHBand) horizontalBand = "band2Horz";
+	if (cellCnf?.oddHBand) horizontalBand = "band1Horz";
+	else if (cellCnf?.evenHBand) horizontalBand = "band2Horz";
+	const firstRowOn = look.firstRow || rowCnf?.firstRow === true || cellCnf?.firstRow === true;
+	const lastRowOn = look.lastRow || rowCnf?.lastRow === true || cellCnf?.lastRow === true;
+	const firstColOn = look.firstColumn || rowCnf?.firstColumn === true || cellCnf?.firstColumn === true;
+	const lastColOn = look.lastColumn || rowCnf?.lastColumn === true || cellCnf?.lastColumn === true;
+	const regions = ["wholeTable"];
+	if (horizontalBand) regions.push(horizontalBand);
+	if (verticalBand) regions.push(verticalBand);
+	if (isFirstCol && firstColOn) regions.push("firstCol");
+	if (isLastCol && lastColOn) regions.push("lastCol");
+	if (isFirstRow && firstRowOn) regions.push("firstRow");
+	if (isLastRow && lastRowOn) regions.push("lastRow");
+	if (isFirstRow && isFirstCol && firstRowOn && firstColOn) regions.push("nwCell");
+	if (isFirstRow && isLastCol && firstRowOn && lastColOn) regions.push("neCell");
+	if (isLastRow && isFirstCol && lastRowOn && firstColOn) regions.push("swCell");
+	if (isLastRow && isLastCol && lastRowOn && lastColOn) regions.push("seCell");
+	return regions;
+};
+//#endregion
+export { tableCellStyleRegions, tableRowBand };

package/dist/prosemirror/tableCellPaste.d.ts

@@ -0,0 +1,74 @@
+import { Fragment, Node, Slice } from "prosemirror-model";
+import { EditorState, Transaction } from "prosemirror-state";
+import { CellSelection, Rect } from "prosemirror-tables";
+//#region src/prosemirror/tableCellPaste.d.ts
+/** A rectangular block of cells, one fragment of cells per row. */
+type PastedCells = {
+  width: number;
+  height: number;
+  rows: Fragment[];
+};
+/** What a tracked paste records its changes as. */
+type TableCellPasteRevision = {
+  revisionId: number;
+  author: string;
+  date: string;
+};
+type TableCellPasteHooks = {
+  /**
+   * The revision a split merge, a grown row or a grown column is tracked
+   * under; untracked when absent.
+   */
+  revision?: TableCellPasteRevision;
+  /**
+   * Replace the content of the cell at `cellPos` with `slice`. Untracked
+   * pastes replace it outright; a tracked paste keeps the old content as a
+   * deletion.
+   */
+  replaceCellContent?: CellContentReplacer;
+};
+type CellContentReplacer = (tr: Transaction, cellPos: number, slice: Slice) => void;
+/**
+ * A pasted slice whose table cells are new cells: a copy of a cell must not
+ * claim the source cell's identity, revisions, or the continuation cells its
+ * merge stored, whatever the paste lands on.
+ */
+declare const pastedSliceWithNewTableCells: (slice: Slice) => Slice;
+/** The cells a slice holds, or null when it holds none (it is not table content). */
+declare const pastedCells: (slice: Slice) => PastedCells | null;
+/**
+ * The range of a cell's content a paste replaces. A block of whole paragraphs
+ * (a pasted cell's content) replaces all of it; open content (text, or
+ * paragraphs cut from a longer run) goes from the start of the first paragraph
+ * to the end of the last, so it takes on the cell's paragraph formatting the
+ * way a paste into a paragraph does.
+ */
+declare const cellPasteRange: (cell: Node, cellPos: number, slice: Slice) => {
+  from: number;
+  to: number;
+};
+/**
+ * Paste a block of cells into the table at `tableStart` from (`top`, `left`):
+ * grow the table to hold it, split the merges its edges cut through, then give
+ * each cell the block covers its pasted cell. Where the block's cells have the
+ * table's shapes the table keeps its cells, with their formatting and
+ * identity, and takes the pasted content; otherwise the block's cells replace
+ * them, except in a tracked paste, which keeps the table's shape. Selects the
+ * pasted block.
+ */
+declare const insertTableCells: (tr: Transaction, tableStart: number, { top, left }: Pick<Rect, "top" | "left">, cells: PastedCells, { revision, replaceCellContent }?: TableCellPasteHooks) => Transaction;
+/**
+ * Paste into every cell of a cell selection: each takes the pasted cell at its
+ * place in the block, the block repeating to cover the selection, or the
+ * pasted content itself when it holds no cells. The table keeps its shape.
+ */
+declare const fillSelectedCells: (tr: Transaction, selection: CellSelection, slice: Slice, { replaceCellContent }?: TableCellPasteHooks) => Transaction;
+/**
+ * Paste `slice` into the table the selection is in: into every selected cell
+ * of a cell selection, or, when the slice holds cells, as a block of cells
+ * from the cell holding the cursor. False otherwise, so the paste falls
+ * through to the ordinary one.
+ */
+declare const pasteTableCells: (state: EditorState, slice: Slice, dispatch?: (tr: Transaction) => void, hooks?: TableCellPasteHooks) => boolean;
+//#endregion
+export { CellContentReplacer, PastedCells, TableCellPasteHooks, TableCellPasteRevision, cellPasteRange, fillSelectedCells, insertTableCells, pasteTableCells, pastedCells, pastedSliceWithNewTableCells };