@kerebron/extension-tables 0.0.1

package/esm/utilities/input.js

@@ -0,0 +1,241 @@
+// This file defines a number of helpers for wiring up user input to
+// table-related functionality.
+import { keydownHandler } from 'prosemirror-keymap';
+import { Fragment } from 'prosemirror-model';
+import { Selection, TextSelection, } from 'prosemirror-state';
+import { CellSelection } from './CellSelection.js';
+import { deleteCellSelection } from './commands.js';
+import { clipCells, fitSlice, insertCells, pastedCells } from './copypaste.js';
+import { tableNodeTypes } from './tableNodeTypes.js';
+import { TableMap } from './TableMap.js';
+import { cellAround, inSameTable, isInTable, nextCell, selectionCell, tableEditingKey, } from './util.js';
+export const handleKeyDown = keydownHandler({
+    ArrowLeft: arrow('horiz', -1),
+    ArrowRight: arrow('horiz', 1),
+    // ArrowUp: arrow('vert', -1),
+    // ArrowDown: arrow('vert', 1),
+    'Shift-ArrowLeft': shiftArrow('horiz', -1),
+    'Shift-ArrowRight': shiftArrow('horiz', 1),
+    'Shift-ArrowUp': shiftArrow('vert', -1),
+    'Shift-ArrowDown': shiftArrow('vert', 1),
+    Backspace: deleteCellSelection,
+    'Mod-Backspace': deleteCellSelection,
+    Delete: deleteCellSelection,
+    'Mod-Delete': deleteCellSelection,
+});
+function maybeSetSelection(state, dispatch, selection) {
+    if (selection.eq(state.selection))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.setSelection(selection).scrollIntoView());
+    return true;
+}
+/**
+ * @internal
+ */
+export function arrow(axis, dir) {
+    return (state, dispatch, view) => {
+        if (!view)
+            return false;
+        const sel = state.selection;
+        if (sel instanceof CellSelection) {
+            return maybeSetSelection(state, dispatch, Selection.near(sel.$headCell, dir));
+        }
+        if (axis != 'horiz' && !sel.empty)
+            return false;
+        const end = atEndOfCell(view, axis, dir);
+        if (end == null)
+            return false;
+        if (axis == 'horiz') {
+            return maybeSetSelection(state, dispatch, Selection.near(state.doc.resolve(sel.head + dir), dir));
+        }
+        else {
+            const $cell = state.doc.resolve(end);
+            const $next = nextCell($cell, axis, dir);
+            let newSel;
+            if ($next)
+                newSel = Selection.near($next, 1);
+            else if (dir < 0) {
+                newSel = Selection.near(state.doc.resolve($cell.before(-1)), -1);
+            }
+            else
+                newSel = Selection.near(state.doc.resolve($cell.after(-1)), 1);
+            return maybeSetSelection(state, dispatch, newSel);
+        }
+    };
+}
+function shiftArrow(axis, dir) {
+    return (state, dispatch, view) => {
+        if (!view)
+            return false;
+        const sel = state.selection;
+        let cellSel;
+        if (sel instanceof CellSelection) {
+            cellSel = sel;
+        }
+        else {
+            const end = atEndOfCell(view, axis, dir);
+            if (end == null)
+                return false;
+            cellSel = new CellSelection(state.doc.resolve(end));
+        }
+        const $head = nextCell(cellSel.$headCell, axis, dir);
+        if (!$head)
+            return false;
+        return maybeSetSelection(state, dispatch, new CellSelection(cellSel.$anchorCell, $head));
+    };
+}
+export function handleTripleClick(view, pos) {
+    const doc = view.state.doc, $cell = cellAround(doc.resolve(pos));
+    if (!$cell)
+        return false;
+    view.dispatch(view.state.tr.setSelection(new CellSelection($cell)));
+    return true;
+}
+/**
+ * @public
+ */
+export function handlePaste(view, _, slice) {
+    if (!isInTable(view.state))
+        return false;
+    let cells = pastedCells(slice);
+    const sel = view.state.selection;
+    if (sel instanceof CellSelection) {
+        if (!cells) {
+            cells = {
+                width: 1,
+                height: 1,
+                rows: [
+                    Fragment.from(fitSlice(tableNodeTypes(view.state.schema).cell, slice)),
+                ],
+            };
+        }
+        const table = sel.$anchorCell.node(-1);
+        const start = sel.$anchorCell.start(-1);
+        const rect = TableMap.get(table).rectBetween(sel.$anchorCell.pos - start, sel.$headCell.pos - start);
+        cells = clipCells(cells, rect.right - rect.left, rect.bottom - rect.top);
+        insertCells(view.state, view.dispatch, start, rect, cells);
+        return true;
+    }
+    else if (cells) {
+        const $cell = selectionCell(view.state);
+        const start = $cell.start(-1);
+        insertCells(view.state, view.dispatch, start, TableMap.get($cell.node(-1)).findCell($cell.pos - start), cells);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function handleMouseDown(view, startEvent) {
+    if (startEvent.ctrlKey || startEvent.metaKey)
+        return;
+    const startDOMCell = domInCell(view, startEvent.target);
+    let $anchor;
+    if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
+        // Adding to an existing cell selection
+        setCellSelection(view.state.selection.$anchorCell, startEvent);
+        startEvent.preventDefault();
+    }
+    else if (startEvent.shiftKey &&
+        startDOMCell &&
+        ($anchor = cellAround(view.state.selection.$anchor)) != null &&
+        cellUnderMouse(view, startEvent)?.pos != $anchor.pos) {
+        // Adding to a selection that starts in another cell (causing a
+        // cell selection to be created).
+        setCellSelection($anchor, startEvent);
+        startEvent.preventDefault();
+    }
+    else if (!startDOMCell) {
+        // Not in a cell, let the default behavior happen.
+        return;
+    }
+    // Create and dispatch a cell selection between the given anchor and
+    // the position under the mouse.
+    function setCellSelection($anchor, event) {
+        let $head = cellUnderMouse(view, event);
+        const starting = tableEditingKey.getState(view.state) == null;
+        if (!$head || !inSameTable($anchor, $head)) {
+            if (starting)
+                $head = $anchor;
+            else
+                return;
+        }
+        const selection = new CellSelection($anchor, $head);
+        if (starting || !view.state.selection.eq(selection)) {
+            const tr = view.state.tr.setSelection(selection);
+            if (starting)
+                tr.setMeta(tableEditingKey, $anchor.pos);
+            view.dispatch(tr);
+        }
+    }
+    // Stop listening to mouse motion events.
+    function stop() {
+        view.root.removeEventListener('mouseup', stop);
+        view.root.removeEventListener('dragstart', stop);
+        view.root.removeEventListener('mousemove', move);
+        if (tableEditingKey.getState(view.state) != null) {
+            view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
+        }
+    }
+    function move(_event) {
+        const event = _event;
+        const anchor = tableEditingKey.getState(view.state);
+        let $anchor;
+        if (anchor != null) {
+            // Continuing an existing cross-cell selection
+            $anchor = view.state.doc.resolve(anchor);
+        }
+        else if (domInCell(view, event.target) != startDOMCell) {
+            // Moving out of the initial cell -- start a new cell selection
+            $anchor = cellUnderMouse(view, startEvent);
+            if (!$anchor)
+                return stop();
+        }
+        if ($anchor)
+            setCellSelection($anchor, event);
+    }
+    view.root.addEventListener('mouseup', stop);
+    view.root.addEventListener('dragstart', stop);
+    view.root.addEventListener('mousemove', move);
+}
+// Check whether the cursor is at the end of a cell (so that further
+// motion would move out of the cell)
+function atEndOfCell(view, axis, dir) {
+    if (!(view.state.selection instanceof TextSelection))
+        return null;
+    const { $head } = view.state.selection;
+    for (let d = $head.depth - 1; d >= 0; d--) {
+        const parent = $head.node(d), index = dir < 0 ? $head.index(d) : $head.indexAfter(d);
+        if (index != (dir < 0 ? 0 : parent.childCount))
+            return null;
+        if (parent.type.spec.tableRole == 'cell' ||
+            parent.type.spec.tableRole == 'header_cell') {
+            const cellPos = $head.before(d);
+            const dirStr = axis == 'vert'
+                ? (dir > 0 ? 'down' : 'up')
+                : dir > 0
+                    ? 'right'
+                    : 'left';
+            return view.endOfTextblock(dirStr) ? cellPos : null;
+        }
+    }
+    return null;
+}
+function domInCell(view, dom) {
+    for (; dom && dom != view.dom; dom = dom.parentNode) {
+        if (dom.nodeName == 'TD' || dom.nodeName == 'TH') {
+            return dom;
+        }
+    }
+    return null;
+}
+function cellUnderMouse(view, event) {
+    const mousePos = view.posAtCoords({
+        left: event.clientX,
+        top: event.clientY,
+    });
+    if (!mousePos)
+        return null;
+    return mousePos ? cellAround(view.state.doc.resolve(mousePos.pos)) : null;
+}

package/esm/utilities/tableEditing.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * @public
+ */
+export type TableEditingOptions = {
+    allowTableNodeSelection?: boolean;
+};
+/**
+ * Creates a [plugin](http://prosemirror.net/docs/ref/#state.Plugin)
+ * that, when added to an editor, enables cell-selection, handles
+ * cell-based copy/paste, and makes sure tables stay well-formed (each
+ * row has the same width, and cells don't overlap).
+ *
+ * You should probably put this plugin near the end of your array of
+ * plugins, since it handles mouse and arrow key events in tables
+ * rather broadly, and other plugins, like the gap cursor or the
+ * column-width dragging plugin, might want to get a turn first to
+ * perform more specific behavior.
+ *
+ * @public
+ */
+export declare function tableEditing({ allowTableNodeSelection, }?: TableEditingOptions): Plugin;
+//# sourceMappingURL=tableEditing.d.ts.map

package/esm/utilities/tableEditing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableEditing.d.ts","sourceRoot":"","sources":["../../src/utilities/tableEditing.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAY3C;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,EAC3B,uBAA+B,GAChC,GAAE,mBAAwB,GAAG,MAAM,CAgDnC"}

package/esm/utilities/tableEditing.js

@@ -0,0 +1,63 @@
+// This file defines a plugin that handles the drawing of cell
+// selections and the basic user interactions for creating and working
+// with such selections. It also makes sure that, after each
+// transaction, the shapes of tables are normalized to be rectangular
+// and not contain overlapping cells.
+import { Plugin } from 'prosemirror-state';
+import { drawCellSelection, normalizeSelection } from './CellSelection.js';
+import { fixTables } from './fixTables.js';
+import { handleKeyDown, handleMouseDown, handlePaste, handleTripleClick, } from './input.js';
+import { tableEditingKey } from './util.js';
+/**
+ * Creates a [plugin](http://prosemirror.net/docs/ref/#state.Plugin)
+ * that, when added to an editor, enables cell-selection, handles
+ * cell-based copy/paste, and makes sure tables stay well-formed (each
+ * row has the same width, and cells don't overlap).
+ *
+ * You should probably put this plugin near the end of your array of
+ * plugins, since it handles mouse and arrow key events in tables
+ * rather broadly, and other plugins, like the gap cursor or the
+ * column-width dragging plugin, might want to get a turn first to
+ * perform more specific behavior.
+ *
+ * @public
+ */
+export function tableEditing({ allowTableNodeSelection = false, } = {}) {
+    return new Plugin({
+        key: tableEditingKey,
+        // This piece of state is used to remember when a mouse-drag
+        // cell-selection is happening, so that it can continue even as
+        // transactions (which might move its anchor cell) come in.
+        state: {
+            init() {
+                return null;
+            },
+            apply(tr, cur) {
+                const set = tr.getMeta(tableEditingKey);
+                if (set != null)
+                    return set == -1 ? null : set;
+                if (cur == null || !tr.docChanged)
+                    return cur;
+                const { deleted, pos } = tr.mapping.mapResult(cur);
+                return deleted ? null : pos;
+            },
+        },
+        props: {
+            decorations: drawCellSelection,
+            handleDOMEvents: {
+                mousedown: handleMouseDown,
+            },
+            createSelectionBetween(view) {
+                return tableEditingKey.getState(view.state) != null
+                    ? view.state.selection
+                    : null;
+            },
+            handleTripleClick,
+            handleKeyDown,
+            handlePaste,
+        },
+        appendTransaction(_, oldState, state) {
+            return normalizeSelection(state, fixTables(state, oldState), allowTableNodeSelection);
+        },
+    });
+}

package/esm/utilities/tableNodeTypes.d.ts

@@ -0,0 +1,14 @@
+import { NodeSpec, NodeType, Schema } from 'prosemirror-model';
+/**
+ * @public
+ */
+export type TableNodes = Record<'table' | 'table_row' | 'table_cell' | 'table_header', NodeSpec>;
+/**
+ * @public
+ */
+export type TableRole = 'table' | 'row' | 'cell' | 'header_cell';
+/**
+ * @public
+ */
+export declare function tableNodeTypes(schema: Schema): Record<TableRole, NodeType>;
+//# sourceMappingURL=tableNodeTypes.d.ts.map

package/esm/utilities/tableNodeTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableNodeTypes.d.ts","sourceRoot":"","sources":["../../src/utilities/tableNodeTypes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAC7B,OAAO,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,EACrD,QAAQ,CACT,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,aAAa,CAAC;AAEjE;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAW1E"}

package/esm/utilities/tableNodeTypes.js

@@ -0,0 +1,16 @@
+// Helper for creating a schema that supports tables.
+/**
+ * @public
+ */
+export function tableNodeTypes(schema) {
+    let result = schema.cached.tableNodeTypes;
+    if (!result) {
+        result = schema.cached.tableNodeTypes = {};
+        for (const name in schema.nodes) {
+            const type = schema.nodes[name], role = type.spec.tableRole;
+            if (role)
+                result[role] = type;
+        }
+    }
+    return result;
+}

package/esm/utilities/util.d.ts

@@ -0,0 +1,73 @@
+import { EditorState } from 'prosemirror-state';
+import { Attrs, Node, ResolvedPos } from 'prosemirror-model';
+import { Rect, TableMap } from './TableMap.js';
+/**
+ * @public
+ */
+export type MutableAttrs = Record<string, unknown>;
+/**
+ * @public
+ */
+export interface CellAttrs {
+    colspan: number;
+    rowspan: number;
+    colwidth: number[] | null;
+}
+/**
+ * @public
+ */
+export declare const tableEditingKey: any;
+/**
+ * @public
+ */
+export declare function cellAround($pos: ResolvedPos): ResolvedPos | null;
+export declare function cellWrapping($pos: ResolvedPos): null | Node;
+/**
+ * @public
+ */
+export declare function isInTable(state: EditorState): boolean;
+/**
+ * @internal
+ */
+export declare function selectionCell(state: EditorState): ResolvedPos;
+/**
+ * @public
+ */
+export declare function cellNear($pos: ResolvedPos): ResolvedPos | undefined;
+/**
+ * @public
+ */
+export declare function pointsAtCell($pos: ResolvedPos): boolean;
+/**
+ * @public
+ */
+export declare function moveCellForward($pos: ResolvedPos): ResolvedPos;
+/**
+ * @internal
+ */
+export declare function inSameTable($cellA: ResolvedPos, $cellB: ResolvedPos): boolean;
+/**
+ * @public
+ */
+export declare function findCell($pos: ResolvedPos): Rect;
+/**
+ * @public
+ */
+export declare function colCount($pos: ResolvedPos): number;
+/**
+ * @public
+ */
+export declare function nextCell($pos: ResolvedPos, axis: 'horiz' | 'vert', dir: number): ResolvedPos | null;
+/**
+ * @public
+ */
+export declare function removeColSpan(attrs: CellAttrs, pos: number, n?: number): CellAttrs;
+/**
+ * @public
+ */
+export declare function addColSpan(attrs: CellAttrs, pos: number, n?: number): Attrs;
+/**
+ * @public
+ */
+export declare function columnIsHeader(map: TableMap, table: Node, col: number): boolean;
+//# sourceMappingURL=util.d.ts.map

package/esm/utilities/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/utilities/util.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAA4B,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG7D,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CAC3B;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,KAA0C,CAAC;AAEvE;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAOhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAO3D;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAMrD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAkB7D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAmBnE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAE9D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAM7E;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAEhD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAElD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,GAAG,EAAE,MAAM,GACV,WAAW,GAAG,IAAI,CAOpB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,SAAI,GAAG,SAAS,CAS7E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,SAAI,GAAG,KAAK,CAOtE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,IAAI,EACX,GAAG,EAAE,MAAM,GACV,OAAO,CAQT"}

package/esm/utilities/util.js

@@ -0,0 +1,155 @@
+// Various helper function for working with tables
+import { PluginKey } from 'prosemirror-state';
+import { tableNodeTypes } from './tableNodeTypes.js';
+import { TableMap } from './TableMap.js';
+/**
+ * @public
+ */
+export const tableEditingKey = new PluginKey('selectingCells');
+/**
+ * @public
+ */
+export function cellAround($pos) {
+    for (let d = $pos.depth - 1; d > 0; d--) {
+        if ($pos.node(d).type.spec.tableRole == 'row') {
+            return $pos.node(0).resolve($pos.before(d + 1));
+        }
+    }
+    return null;
+}
+export function cellWrapping($pos) {
+    for (let d = $pos.depth; d > 0; d--) {
+        // Sometimes the cell can be in the same depth.
+        const role = $pos.node(d).type.spec.tableRole;
+        if (role === 'cell' || role === 'header_cell')
+            return $pos.node(d);
+    }
+    return null;
+}
+/**
+ * @public
+ */
+export function isInTable(state) {
+    const $head = state.selection.$head;
+    for (let d = $head.depth; d > 0; d--) {
+        if ($head.node(d).type.spec.tableRole == 'row')
+            return true;
+    }
+    return false;
+}
+/**
+ * @internal
+ */
+export function selectionCell(state) {
+    const sel = state.selection;
+    if ('$anchorCell' in sel && sel.$anchorCell) {
+        return sel.$anchorCell.pos > sel.$headCell.pos
+            ? sel.$anchorCell
+            : sel.$headCell;
+    }
+    else if ('node' in sel &&
+        sel.node &&
+        sel.node.type.spec.tableRole == 'cell') {
+        return sel.$anchor;
+    }
+    const $cell = cellAround(sel.$head) || cellNear(sel.$head);
+    if ($cell) {
+        return $cell;
+    }
+    throw new RangeError(`No cell found around position ${sel.head}`);
+}
+/**
+ * @public
+ */
+export function cellNear($pos) {
+    for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
+        const role = after.type.spec.tableRole;
+        if (role == 'cell' || role == 'header_cell')
+            return $pos.doc.resolve(pos);
+    }
+    for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
+        const role = before.type.spec.tableRole;
+        if (role == 'cell' || role == 'header_cell') {
+            return $pos.doc.resolve(pos - before.nodeSize);
+        }
+    }
+}
+/**
+ * @public
+ */
+export function pointsAtCell($pos) {
+    return $pos.parent.type.spec.tableRole == 'row' && !!$pos.nodeAfter;
+}
+/**
+ * @public
+ */
+export function moveCellForward($pos) {
+    return $pos.node(0).resolve($pos.pos + $pos.nodeAfter.nodeSize);
+}
+/**
+ * @internal
+ */
+export function inSameTable($cellA, $cellB) {
+    return ($cellA.depth == $cellB.depth &&
+        $cellA.pos >= $cellB.start(-1) &&
+        $cellA.pos <= $cellB.end(-1));
+}
+/**
+ * @public
+ */
+export function findCell($pos) {
+    return TableMap.get($pos.node(-1)).findCell($pos.pos - $pos.start(-1));
+}
+/**
+ * @public
+ */
+export function colCount($pos) {
+    return TableMap.get($pos.node(-1)).colCount($pos.pos - $pos.start(-1));
+}
+/**
+ * @public
+ */
+export function nextCell($pos, axis, dir) {
+    const table = $pos.node(-1);
+    const map = TableMap.get(table);
+    const tableStart = $pos.start(-1);
+    const moved = map.nextCell($pos.pos - tableStart, axis, dir);
+    return moved == null ? null : $pos.node(0).resolve(tableStart + moved);
+}
+/**
+ * @public
+ */
+export function removeColSpan(attrs, pos, n = 1) {
+    const result = { ...attrs, colspan: attrs.colspan - n };
+    if (result.colwidth) {
+        result.colwidth = result.colwidth.slice();
+        result.colwidth.splice(pos, n);
+        if (!result.colwidth.some((w) => w > 0))
+            result.colwidth = null;
+    }
+    return result;
+}
+/**
+ * @public
+ */
+export function addColSpan(attrs, pos, n = 1) {
+    const result = { ...attrs, colspan: attrs.colspan + n };
+    if (result.colwidth) {
+        result.colwidth = result.colwidth.slice();
+        for (let i = 0; i < n; i++)
+            result.colwidth.splice(pos, 0, 0);
+    }
+    return result;
+}
+/**
+ * @public
+ */
+export function columnIsHeader(map, table, col) {
+    const headerCell = tableNodeTypes(table.type.schema).header_cell;
+    for (let row = 0; row < map.height; row++) {
+        if (table.nodeAt(map.map[col + row * map.width]).type != headerCell) {
+            return false;
+        }
+    }
+    return true;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@kerebron/extension-tables",
+  "version": "0.0.1",
+  "license": "MIT",
+  "module": "./esm/ExtensionTables.js",
+  "exports": {
+    ".": {
+      "import": "./esm/ExtensionTables.js"
+    },
+    "./NodeTable": {
+      "import": "./esm/NodeTable.js"
+    },
+    "./NodeTableRow": {
+      "import": "./esm/NodeTableRow.js"
+    },
+    "./NodeTableHeader": {
+      "import": "./esm/NodeTableHeader.js"
+    },
+    "./NodeTableCell": {
+      "import": "./esm/NodeTableCell.js"
+    }
+  },
+  "dependencies": {
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}