@kerebron/editor-kits 0.4.1

package/esm/extension-tables/src/utilities/copypaste.d.ts

@@ -0,0 +1,35 @@
+import { Fragment, Node, NodeType, Slice } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { Rect } from './TableMap.js';
+/**
+ * @internal
+ */
+export type Area = {
+    width: number;
+    height: number;
+    rows: Fragment[];
+};
+/**
+ * Get a rectangular area of cells from a slice, or null if the outer
+ * nodes of the slice aren't table cells or rows.
+ *
+ * @internal
+ */
+export declare function pastedCells(slice: Slice): Area | null;
+export declare function fitSlice(nodeType: NodeType, slice: Slice): Node;
+/**
+ * Clip or extend (repeat) the given set of cells to cover the given
+ * width and height. Will clip rowspan/colspan cells at the edges when
+ * they stick out.
+ *
+ * @internal
+ */
+export declare function clipCells({ width, height, rows }: Area, newWidth: number, newHeight: number): Area;
+/**
+ * Insert the given set of cells (as returned by `pastedCells`) into a
+ * table, at the position pointed at by rect.
+ *
+ * @internal
+ */
+export declare function insertCells(state: EditorState, dispatch: (tr: Transaction) => void, tableStart: number, rect: Rect, cells: Area): void;
+//# sourceMappingURL=copypaste.d.ts.map

package/esm/extension-tables/src/utilities/copypaste.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copypaste.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/copypaste.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAU,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG5E,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG7D,OAAO,EAAa,IAAI,EAAY,MAAM,eAAe,CAAC;AAG1D;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC;AAIvE;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,CA0CrD;AA+BD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAI/D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,IAAI,CAwDN;AA2ID;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,IAAI,EACnC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,IAAI,GACV,IAAI,CA8DN"}

package/esm/extension-tables/src/utilities/copypaste.js

@@ -0,0 +1,283 @@
+// Utilities used for copy/paste handling.
+//
+// This module handles pasting cell content into tables, or pasting
+// anything into a cell selection, as replacing a block of cells with
+// the content of the selection. When pasting cells into a cell, that
+// involves placing the block of pasted content so that its top left
+// aligns with the selection cell, optionally extending the table to
+// the right or bottom to make sure it is large enough. Pasting into a
+// cell selection is different, here the cells in the selection are
+// clipped to the selection's rectangle, optionally repeating the
+// pasted cells when they are smaller than the selection.
+import { Fragment, Slice } from 'prosemirror-model';
+import { Transform } from 'prosemirror-transform';
+import { CellSelection } from './CellSelection.js';
+import { tableNodeTypes } from './tableNodeTypes.js';
+import { TableMap } from './TableMap.js';
+import { removeColSpan } from './util.js';
+// Utilities to help with copying and pasting table cells
+/**
+ * Get a rectangular area of cells from a slice, or null if the outer
+ * nodes of the slice aren't table cells or rows.
+ *
+ * @internal
+ */
+export function pastedCells(slice) {
+    if (!slice.size)
+        return null;
+    let { content, openStart, openEnd } = slice;
+    while (content.childCount == 1 &&
+        ((openStart > 0 && openEnd > 0) ||
+            content.child(0).type.spec.tableRole == 'table')) {
+        openStart--;
+        openEnd--;
+        content = content.child(0).content;
+    }
+    const first = content.child(0);
+    const role = first.type.spec.tableRole;
+    const schema = first.type.schema, rows = [];
+    if (role == 'row') {
+        for (let i = 0; i < content.childCount; i++) {
+            let cells = content.child(i).content;
+            const left = i ? 0 : Math.max(0, openStart - 1);
+            const right = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
+            if (left || right) {
+                cells = fitSlice(tableNodeTypes(schema).row, new Slice(cells, left, right)).content;
+            }
+            rows.push(cells);
+        }
+    }
+    else if (role == 'cell' || role == 'header_cell') {
+        rows.push(openStart || openEnd
+            ? fitSlice(tableNodeTypes(schema).row, new Slice(content, openStart, openEnd)).content
+            : content);
+    }
+    else {
+        return null;
+    }
+    return ensureRectangular(schema, rows);
+}
+// Compute the width and height of a set of cells, and make sure each
+// row has the same number of cells.
+function ensureRectangular(schema, rows) {
+    const widths = [];
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        for (let j = row.childCount - 1; j >= 0; j--) {
+            const { rowspan, colspan } = row.child(j).attrs;
+            for (let r = i; r < i + rowspan; r++) {
+                widths[r] = (widths[r] || 0) + colspan;
+            }
+        }
+    }
+    let width = 0;
+    for (let r = 0; r < widths.length; r++)
+        width = Math.max(width, widths[r]);
+    for (let r = 0; r < widths.length; r++) {
+        if (r >= rows.length)
+            rows.push(Fragment.empty);
+        if (widths[r] < width) {
+            const empty = tableNodeTypes(schema).cell.createAndFill();
+            const cells = [];
+            for (let i = widths[r]; i < width; i++) {
+                cells.push(empty);
+            }
+            rows[r] = rows[r].append(Fragment.from(cells));
+        }
+    }
+    return { height: rows.length, width, rows };
+}
+export function fitSlice(nodeType, slice) {
+    const node = nodeType.createAndFill();
+    const tr = new Transform(node).replace(0, node.content.size, slice);
+    return tr.doc;
+}
+/**
+ * Clip or extend (repeat) the given set of cells to cover the given
+ * width and height. Will clip rowspan/colspan cells at the edges when
+ * they stick out.
+ *
+ * @internal
+ */
+export function clipCells({ width, height, rows }, newWidth, newHeight) {
+    if (width != newWidth) {
+        const added = [];
+        const newRows = [];
+        for (let row = 0; row < rows.length; row++) {
+            const frag = rows[row], cells = [];
+            for (let col = added[row] || 0, i = 0; col < newWidth; i++) {
+                let cell = frag.child(i % frag.childCount);
+                if (col + cell.attrs.colspan > newWidth) {
+                    cell = cell.type.createChecked(removeColSpan(cell.attrs, cell.attrs.colspan, col + cell.attrs.colspan - newWidth), cell.content);
+                }
+                cells.push(cell);
+                col += cell.attrs.colspan;
+                for (let j = 1; j < cell.attrs.rowspan; j++) {
+                    added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
+                }
+            }
+            newRows.push(Fragment.from(cells));
+        }
+        rows = newRows;
+        width = newWidth;
+    }
+    if (height != newHeight) {
+        const newRows = [];
+        for (let row = 0, i = 0; row < newHeight; row++, i++) {
+            const cells = [], source = rows[i % height];
+            for (let j = 0; j < source.childCount; j++) {
+                let cell = source.child(j);
+                if (row + cell.attrs.rowspan > newHeight) {
+                    cell = cell.type.create({
+                        ...cell.attrs,
+                        rowspan: Math.max(1, newHeight - cell.attrs.rowspan),
+                    }, cell.content);
+                }
+                cells.push(cell);
+            }
+            newRows.push(Fragment.from(cells));
+        }
+        rows = newRows;
+        height = newHeight;
+    }
+    return { width, height, rows };
+}
+// Make sure a table has at least the given width and height. Return
+// true if something was changed.
+function growTable(tr, map, table, start, width, height, mapFrom) {
+    const schema = tr.doc.type.schema;
+    const types = tableNodeTypes(schema);
+    let empty;
+    let emptyHead;
+    if (width > map.width) {
+        for (let row = 0, rowEnd = 0; row < map.height; row++) {
+            const rowNode = table.child(row);
+            rowEnd += rowNode.nodeSize;
+            const cells = [];
+            let add;
+            if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell) {
+                add = empty || (empty = types.cell.createAndFill());
+            }
+            else {
+                add = emptyHead ||
+                    (emptyHead = types.header_cell.createAndFill());
+            }
+            for (let i = map.width; i < width; i++)
+                cells.push(add);
+            tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start), cells);
+        }
+    }
+    if (height > map.height) {
+        const cells = [];
+        for (let i = 0, start = (map.height - 1) * map.width; i < Math.max(map.width, width); i++) {
+            const header = i >= map.width
+                ? false
+                : table.nodeAt(map.map[start + i]).type == types.header_cell;
+            cells.push(header
+                ? emptyHead || (emptyHead = types.header_cell.createAndFill())
+                : empty || (empty = types.cell.createAndFill()));
+        }
+        const emptyRow = types.row.create(null, Fragment.from(cells)), rows = [];
+        for (let i = map.height; i < height; i++)
+            rows.push(emptyRow);
+        tr.insert(tr.mapping.slice(mapFrom).map(start + table.nodeSize - 2), rows);
+    }
+    return !!(empty || emptyHead);
+}
+// Make sure the given line (left, top) to (right, top) doesn't cross
+// any rowspan cells by splitting cells that cross it. Return true if
+// something changed.
+function isolateHorizontal(tr, map, table, start, left, right, top, mapFrom) {
+    if (top == 0 || top == map.height)
+        return false;
+    let found = false;
+    for (let col = left; col < right; col++) {
+        const index = top * map.width + col, pos = map.map[index];
+        if (map.map[index - map.width] == pos) {
+            found = true;
+            const cell = table.nodeAt(pos);
+            const { top: cellTop, left: cellLeft } = map.findCell(pos);
+            tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + start), null, {
+                ...cell.attrs,
+                rowspan: top - cellTop,
+            });
+            tr.insert(tr.mapping.slice(mapFrom).map(map.positionAt(top, cellLeft, table)), cell.type.createAndFill({
+                ...cell.attrs,
+                rowspan: cellTop + cell.attrs.rowspan - top,
+            }));
+            col += cell.attrs.colspan - 1;
+        }
+    }
+    return found;
+}
+// Make sure the given line (left, top) to (left, bottom) doesn't
+// cross any colspan cells by splitting cells that cross it. Return
+// true if something changed.
+function isolateVertical(tr, map, table, start, top, bottom, left, mapFrom) {
+    if (left == 0 || left == map.width)
+        return false;
+    let found = false;
+    for (let row = top; row < bottom; row++) {
+        const index = row * map.width + left, pos = map.map[index];
+        if (map.map[index - 1] == pos) {
+            found = true;
+            const cell = table.nodeAt(pos);
+            const cellLeft = map.colCount(pos);
+            const updatePos = tr.mapping.slice(mapFrom).map(pos + start);
+            tr.setNodeMarkup(updatePos, null, removeColSpan(cell.attrs, left - cellLeft, cell.attrs.colspan - (left - cellLeft)));
+            tr.insert(updatePos + cell.nodeSize, cell.type.createAndFill(removeColSpan(cell.attrs, 0, left - cellLeft)));
+            row += cell.attrs.rowspan - 1;
+        }
+    }
+    return found;
+}
+/**
+ * Insert the given set of cells (as returned by `pastedCells`) into a
+ * table, at the position pointed at by rect.
+ *
+ * @internal
+ */
+export function insertCells(state, dispatch, tableStart, rect, cells) {
+    let table = tableStart ? state.doc.nodeAt(tableStart - 1) : state.doc;
+    if (!table) {
+        throw new Error('No table found');
+    }
+    let map = TableMap.get(table);
+    const { top, left } = rect;
+    const right = left + cells.width, bottom = top + cells.height;
+    const tr = state.tr;
+    let mapFrom = 0;
+    function recomp() {
+        table = tableStart ? tr.doc.nodeAt(tableStart - 1) : tr.doc;
+        if (!table) {
+            throw new Error('No table found');
+        }
+        map = TableMap.get(table);
+        mapFrom = tr.mapping.maps.length;
+    }
+    // Prepare the table to be large enough and not have any cells
+    // crossing the boundaries of the rectangle that we want to
+    // insert into. If anything about it changes, recompute the table
+    // map so that subsequent operations can see the current shape.
+    if (growTable(tr, map, table, tableStart, right, bottom, mapFrom))
+        recomp();
+    if (isolateHorizontal(tr, map, table, tableStart, left, right, top, mapFrom)) {
+        recomp();
+    }
+    if (isolateHorizontal(tr, map, table, tableStart, left, right, bottom, mapFrom)) {
+        recomp();
+    }
+    if (isolateVertical(tr, map, table, tableStart, top, bottom, left, mapFrom)) {
+        recomp();
+    }
+    if (isolateVertical(tr, map, table, tableStart, top, bottom, right, mapFrom)) {
+        recomp();
+    }
+    for (let row = top; row < bottom; row++) {
+        const from = map.positionAt(row, left, table), to = map.positionAt(row, right, table);
+        tr.replace(tr.mapping.slice(mapFrom).map(from + tableStart), tr.mapping.slice(mapFrom).map(to + tableStart), new Slice(cells.rows[row - top], 0, 0));
+    }
+    recomp();
+    tr.setSelection(new CellSelection(tr.doc.resolve(tableStart + map.positionAt(top, left, table)), tr.doc.resolve(tableStart + map.positionAt(bottom - 1, right - 1, table))));
+    dispatch(tr);
+}

package/esm/extension-tables/src/utilities/createCell.d.ts

@@ -0,0 +1,3 @@
+import { Fragment, Node as ProsemirrorNode, NodeType } from 'prosemirror-model';
+export declare function createCell(cellType: NodeType, cellContent?: Fragment | ProsemirrorNode | Array<ProsemirrorNode>): ProsemirrorNode | null | undefined;
+//# sourceMappingURL=createCell.d.ts.map

package/esm/extension-tables/src/utilities/createCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCell.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/createCell.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,IAAI,eAAe,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEhF,wBAAgB,UAAU,CACxB,QAAQ,EAAE,QAAQ,EAClB,WAAW,CAAC,EAAE,QAAQ,GAAG,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC,GAChE,eAAe,GAAG,IAAI,GAAG,SAAS,CAMpC"}

package/esm/extension-tables/src/utilities/createCell.js

@@ -0,0 +1,6 @@
+export function createCell(cellType, cellContent) {
+    if (cellContent) {
+        return cellType.createChecked(null, cellContent);
+    }
+    return cellType.createAndFill();
+}

package/esm/extension-tables/src/utilities/createTable.d.ts

@@ -0,0 +1,3 @@
+import { Fragment, Node as ProsemirrorNode, Schema } from 'prosemirror-model';
+export declare function createTable(schema: Schema, rowsCount: number, colsCount: number, withHeaderRow: boolean, cellContent?: Fragment | ProsemirrorNode | Array<ProsemirrorNode>): ProsemirrorNode;
+//# sourceMappingURL=createTable.d.ts.map

package/esm/extension-tables/src/utilities/createTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTable.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/createTable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,IAAI,eAAe,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAK9E,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,OAAO,EACtB,WAAW,CAAC,EAAE,QAAQ,GAAG,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC,GAChE,eAAe,CAyCjB"}

package/esm/extension-tables/src/utilities/createTable.js

@@ -0,0 +1,31 @@
+import { createCell } from './createCell.js';
+import { getTableNodeTypes } from './getTableNodeTypes.js';
+export function createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {
+    const types = getTableNodeTypes(schema);
+    const headerCells = [];
+    const cells = [];
+    for (let index = 0; index < colsCount; index += 1) {
+        const cell = createCell(types.cell, cellContent);
+        if (cell) {
+            cells.push(cell);
+        }
+        if (withHeaderRow) {
+            const headerCell = createCell(types.header_cell, cellContent);
+            if (headerCell) {
+                headerCells.push(headerCell);
+            }
+        }
+    }
+    const rows = [];
+    for (let index = 0; index < rowsCount; index += 1) {
+        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));
+    }
+    const attrs = {};
+    const tableSpec = schema.spec.nodes.get('table');
+    for (const [key, attrSpec] of Object.entries(tableSpec.attrs || {})) {
+        if ('undefined' !== typeof attrSpec.default) {
+            attrs[key] = attrSpec.default;
+        }
+    }
+    return types.table.createChecked(attrs, rows);
+}

package/esm/extension-tables/src/utilities/fixTables.d.ts

@@ -0,0 +1,20 @@
+import { Node } from 'prosemirror-model';
+import { EditorState, PluginKey, Transaction } from 'prosemirror-state';
+/**
+ * @public
+ */
+export declare const fixTablesKey: PluginKey<{
+    fixTables: boolean;
+}>;
+/**
+ * Inspect all tables in the given state's document and return a
+ * transaction that fixes them, if necessary. If `oldState` was
+ * provided, that is assumed to hold a previous, known-good state,
+ * which will be used to avoid re-scanning unchanged parts of the
+ * document.
+ *
+ * @public
+ */
+export declare function fixTables(state: EditorState, oldState?: EditorState): Transaction | undefined;
+export declare function fixTable(state: EditorState, table: Node, tablePos: number, tr: Transaction | undefined): Transaction | undefined;
+//# sourceMappingURL=fixTables.d.ts.map

package/esm/extension-tables/src/utilities/fixTables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixTables.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/fixTables.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKxE;;GAEG;AACH,eAAO,MAAM,YAAY;eAA8B,OAAO;EAAiB,CAAC;AAkChF;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,WAAW,GACrB,WAAW,GAAG,SAAS,CAYzB;AAID,wBAAgB,QAAQ,CACtB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,WAAW,GAAG,SAAS,GAC1B,WAAW,GAAG,SAAS,CA0EzB"}

package/esm/extension-tables/src/utilities/fixTables.js

@@ -0,0 +1,146 @@
+// This file defines helpers for normalizing tables, making sure no
+// cells overlap (which can happen, if you have the wrong col- and
+// rowspans) and that each row has the same width. Uses the problems
+// reported by `TableMap`.
+import { PluginKey } from 'prosemirror-state';
+import { tableNodeTypes } from './tableNodeTypes.js';
+import { TableMap } from './TableMap.js';
+import { removeColSpan } from './util.js';
+/**
+ * @public
+ */
+export const fixTablesKey = new PluginKey('fix-tables');
+/**
+ * Helper for iterating through the nodes in a document that changed
+ * compared to the given previous document. Useful for avoiding
+ * duplicate work on each transaction.
+ *
+ * @public
+ */
+function changedDescendants(old, cur, offset, f) {
+    const oldSize = old.childCount, curSize = cur.childCount;
+    outer: for (let i = 0, j = 0; i < curSize; i++) {
+        const child = cur.child(i);
+        for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
+            if (old.child(scan) == child) {
+                j = scan + 1;
+                offset += child.nodeSize;
+                continue outer;
+            }
+        }
+        f(child, offset);
+        if (j < oldSize && old.child(j).sameMarkup(child)) {
+            changedDescendants(old.child(j), child, offset + 1, f);
+        }
+        else
+            child.nodesBetween(0, child.content.size, f, offset + 1);
+        offset += child.nodeSize;
+    }
+}
+/**
+ * Inspect all tables in the given state's document and return a
+ * transaction that fixes them, if necessary. If `oldState` was
+ * provided, that is assumed to hold a previous, known-good state,
+ * which will be used to avoid re-scanning unchanged parts of the
+ * document.
+ *
+ * @public
+ */
+export function fixTables(state, oldState) {
+    let tr;
+    const check = (node, pos) => {
+        if (node.type.spec.tableRole == 'table') {
+            tr = fixTable(state, node, pos, tr);
+        }
+    };
+    if (!oldState)
+        state.doc.descendants(check);
+    else if (oldState.doc != state.doc) {
+        changedDescendants(oldState.doc, state.doc, 0, check);
+    }
+    return tr;
+}
+// Fix the given table, if necessary. Will append to the transaction
+// it was given, if non-null, or create a new one if necessary.
+export function fixTable(state, table, tablePos, tr) {
+    const map = TableMap.get(table);
+    if (!map.problems)
+        return tr;
+    if (!tr)
+        tr = state.tr;
+    // Track which rows we must add cells to, so that we can adjust that
+    // when fixing collisions.
+    const mustAdd = [];
+    for (let i = 0; i < map.height; i++)
+        mustAdd.push(0);
+    for (let i = 0; i < map.problems.length; i++) {
+        const prob = map.problems[i];
+        if (prob.type == 'collision') {
+            const cell = table.nodeAt(prob.pos);
+            if (!cell)
+                continue;
+            const attrs = cell.attrs;
+            for (let j = 0; j < attrs.rowspan; j++)
+                mustAdd[prob.row + j] += prob.n;
+            tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, removeColSpan(attrs, attrs.colspan - prob.n, prob.n));
+        }
+        else if (prob.type == 'missing') {
+            mustAdd[prob.row] += prob.n;
+        }
+        else if (prob.type == 'overlong_rowspan') {
+            const cell = table.nodeAt(prob.pos);
+            if (!cell)
+                continue;
+            tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, {
+                ...cell.attrs,
+                rowspan: cell.attrs.rowspan - prob.n,
+            });
+        }
+        else if (prob.type == 'colwidth mismatch') {
+            const cell = table.nodeAt(prob.pos);
+            if (!cell)
+                continue;
+            tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, {
+                ...cell.attrs,
+                colwidth: prob.colwidth,
+            });
+        }
+        else if (prob.type == 'zero_sized') {
+            const pos = tr.mapping.map(tablePos);
+            tr.delete(pos, pos + table.nodeSize);
+        }
+    }
+    let first, last;
+    for (let i = 0; i < mustAdd.length; i++) {
+        if (mustAdd[i]) {
+            if (first == null)
+                first = i;
+            last = i;
+        }
+    }
+    // Add the necessary cells, using a heuristic for whether to add the
+    // cells at the start or end of the rows (if it looks like a 'bite'
+    // was taken out of the table, add cells at the start of the row
+    // after the bite. Otherwise add them at the end).
+    for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
+        const row = table.child(i);
+        const end = pos + row.nodeSize;
+        const add = mustAdd[i];
+        if (add > 0) {
+            let role = 'cell';
+            if (row.firstChild) {
+                role = row.firstChild.type.spec.tableRole;
+            }
+            const nodes = [];
+            for (let j = 0; j < add; j++) {
+                const node = tableNodeTypes(state.schema)[role].createAndFill();
+                if (node)
+                    nodes.push(node);
+            }
+            const side = (i == 0 || first == i - 1) && last == i ? pos + 1 : end - 1;
+            tr.insert(tr.mapping.map(side), nodes);
+        }
+        pos = end;
+    }
+    return tr.setMeta(fixTablesKey, { fixTables: true });
+}

package/esm/extension-tables/src/utilities/getTableNodeTypes.d.ts

@@ -0,0 +1,5 @@
+import { NodeType, Schema } from 'prosemirror-model';
+export declare function getTableNodeTypes(schema: Schema): {
+    [key: string]: NodeType;
+};
+//# sourceMappingURL=getTableNodeTypes.d.ts.map

package/esm/extension-tables/src/utilities/getTableNodeTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTableNodeTypes.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/getTableNodeTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAErD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAkB7E"}

package/esm/extension-tables/src/utilities/getTableNodeTypes.js

@@ -0,0 +1,14 @@
+export function getTableNodeTypes(schema) {
+    if (schema.cached.tableNodeTypes) {
+        return schema.cached.tableNodeTypes;
+    }
+    const roles = {};
+    Object.keys(schema.nodes).forEach((type) => {
+        const nodeType = schema.nodes[type];
+        if (nodeType.spec.tableRole) {
+            roles[nodeType.spec.tableRole] = nodeType;
+        }
+    });
+    schema.cached.tableNodeTypes = roles;
+    return roles;
+}

package/esm/extension-tables/src/utilities/input.d.ts

@@ -0,0 +1,21 @@
+import { Slice } from 'prosemirror-model';
+import { Command } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+type Axis = 'horiz' | 'vert';
+/**
+ * @public
+ */
+export type Direction = -1 | 1;
+export declare const handleKeyDown: (view: EditorView, event: KeyboardEvent) => boolean;
+/**
+ * @internal
+ */
+export declare function arrow(axis: Axis, dir: Direction): Command;
+export declare function handleTripleClick(view: EditorView, pos: number): boolean;
+/**
+ * @public
+ */
+export declare function handlePaste(view: EditorView, _: ClipboardEvent, slice: Slice): boolean;
+export declare function handleMouseDown(view: EditorView, startEvent: MouseEvent): void;
+export {};
+//# sourceMappingURL=input.d.ts.map

package/esm/extension-tables/src/utilities/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/input.ts"],"names":[],"mappings":"AAGA,OAAO,EAAyB,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EACL,OAAO,EAKR,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAkB9C,KAAK,IAAI,GAAG,OAAO,GAAG,MAAM,CAAC;AAE7B;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AAE/B,eAAO,MAAM,aAAa,4BAwFpB,aAAc,YAzElB,CAAC;AAYH;;GAEG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CA+BzD;AAyBD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAMxE;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,CAAC,EAAE,cAAc,EACjB,KAAK,EAAE,KAAK,GACX,OAAO,CAuCT;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,GACrB,IAAI,CAqEN"}