@milkdown/preset-gfm 6.1.5 → 6.3.1

package/src/index.ts

@@ -42,7 +42,7 @@ export {
     // node
     doc,
     em,
-    hardbreak,
+    HardbreakFilterPluginKey as hardbreak,
     heading,
     hr,
     image,

package/src/table/command.ts

@@ -1,8 +1,8 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { Command } from '@milkdown/prose/commands';
 import { Node, NodeType } from '@milkdown/prose/model';
-import { Selection } from '@milkdown/prose/state';
-import { isInTable } from '@milkdown/prose/tables';
+import { Command, Selection } from '@milkdown/prose/state';
+
+import { isInTable } from './plugin/util';
 
 export const exitTable =
     (node: NodeType): Command =>

package/src/table/nodes/index.ts

@@ -2,14 +2,17 @@
 import { createCmd, createCmdKey, MarkdownNode, schemaCtx } from '@milkdown/core';
 import { InputRule } from '@milkdown/prose/inputrules';
 import { NodeType } from '@milkdown/prose/model';
-import { Plugin, PluginKey, Selection, TextSelection } from '@milkdown/prose/state';
-import { columnResizing, goToNextCell, tableEditing } from '@milkdown/prose/tables';
+import { Selection, TextSelection } from '@milkdown/prose/state';
 import { createPlugin, createShortcut } from '@milkdown/utils';
 
 import { exitTable } from '../command';
 import { operatorPlugin } from '../operator-plugin';
+import { autoInsertZeroSpace } from '../plugin/auto-insert-zero-space';
+import { columnResizing } from '../plugin/column-resizing';
+import { goToNextCell } from '../plugin/commands';
+import { schema } from '../plugin/schema';
+import { tableEditing } from '../plugin/table-editing';
 import { createTable } from '../utils';
-import { schema } from './schema';
 
 export const SupportedKeys = {
     NextCell: 'NextCell',
@@ -25,8 +28,6 @@ export const NextCell = createCmdKey('NextCell');
 export const BreakTable = createCmdKey('BreakTable');
 export const InsertTable = createCmdKey('InsertTable');
 
-export const TableContentFilterPluginKey = new PluginKey('MILKDOWN_TABLE_CONTENT_FILTER');
-
 export const table = createPlugin<Keys, Record<string, unknown>, keyof typeof schema>((utils) => {
     return {
         schema: () => ({
@@ -166,32 +167,7 @@ export const table = createPlugin<Keys, Record<string, unknown>, keyof typeof sc
             [SupportedKeys.ExitTable]: createShortcut(BreakTable, 'Mod-Enter'),
         },
         prosePlugins: (_, ctx) => {
-            return [
-                operatorPlugin(ctx, utils),
-                columnResizing({}),
-                tableEditing(),
-                new Plugin({
-                    key: TableContentFilterPluginKey,
-                    filterTransaction: (tr, state) => {
-                        const isInsertHr = tr.getMeta('hardbreak');
-                        const [step] = tr.steps;
-                        if (isInsertHr && step) {
-                            const { from } = step as unknown as { from: number };
-                            const $from = state.doc.resolve(from);
-                            let curDepth = $from.depth;
-                            let canApply = true;
-                            while (curDepth > 0) {
-                                if ($from.node(curDepth).type.name === 'table') {
-                                    canApply = false;
-                                }
-                                curDepth--;
-                            }
-                            return canApply;
-                        }
-                        return true;
-                    },
-                }),
-            ];
+            return [operatorPlugin(ctx, utils), autoInsertZeroSpace(), columnResizing(), tableEditing()];
         },
     };
 });

package/src/table/operator-plugin/actions.ts

@@ -1,6 +1,8 @@
 /* Copyright 2021, Milkdown by Mirone. */
 import { Ctx, ThemeIcon, themeManagerCtx } from '@milkdown/core';
-import { Command } from '@milkdown/prose/commands';
+import { Command } from '@milkdown/prose/state';
+import { EditorView } from '@milkdown/prose/view';
+
 import {
     addColumnAfter,
     addColumnBefore,
@@ -10,9 +12,7 @@ import {
     isInTable,
     selectedRect,
     setCellAttr,
-} from '@milkdown/prose/tables';
-import { EditorView } from '@milkdown/prose/view';
-
+} from '../plugin';
 import { addRowWithAlignment } from '../utils';
 import { getCellSelection, isFirstRowSelected } from './helper';
 

package/src/table/operator-plugin/calc-pos.ts

@@ -1,9 +1,11 @@
 /* Copyright 2021, Milkdown by Mirone. */
 
+import { missingRootElement } from '@milkdown/exception';
 import { calculateNodePosition } from '@milkdown/prose';
-import { CellSelection } from '@milkdown/prose/tables';
 import { EditorView } from '@milkdown/prose/view';
 
+import { CellSelection } from '../plugin';
+
 export const calculatePosition = (view: EditorView, dom: HTMLElement) => {
     const { selection } = view.state as unknown as { selection: CellSelection };
     const isCol = selection.isColSelection();
@@ -12,7 +14,7 @@ export const calculatePosition = (view: EditorView, dom: HTMLElement) => {
     calculateNodePosition(view, dom, (selected, target, parent) => {
         const $editor = dom.parentElement;
         if (!$editor) {
-            throw new Error();
+            throw missingRootElement();
         }
         let left = !isRow
             ? selected.left - parent.left + (selected.width - target.width) / 2

package/src/table/operator-plugin/helper.ts

@@ -1,7 +1,8 @@
 /* Copyright 2021, Milkdown by Mirone. */
-import { CellSelection, TableMap } from '@milkdown/prose/tables';
 import { EditorView } from '@milkdown/prose/view';
 
+import { CellSelection } from '../plugin';
+import { TableMap } from '../plugin/table-map';
 import { Item } from './actions';
 
 export const getCellSelection = (view: EditorView): CellSelection => view.state.selection as unknown as CellSelection;

package/src/table/operator-plugin/index.ts

@@ -2,10 +2,10 @@
 
 import { Ctx } from '@milkdown/core';
 import { Plugin, PluginKey } from '@milkdown/prose/state';
-import { CellSelection } from '@milkdown/prose/tables';
 import { Decoration, DecorationSet } from '@milkdown/prose/view';
 import { Utils } from '@milkdown/utils';
 
+import { CellSelection } from '../plugin';
 import { CellPos, getCellsInColumn, getCellsInRow } from '../utils';
 import { createActions } from './actions';
 import { calculatePosition } from './calc-pos';

package/src/table/operator-plugin/style.ts

@@ -10,8 +10,8 @@ export const injectStyle = (themeManager: ThemeManager, { css, injectGlobal }: E
         .milkdown {
             .tableWrapper {
                 table {
-                    width: calc(100% - 2em) !important;
-                    margin: 1em 0 1em 1em !important;
+                    width: calc(100% - 32px) !important;
+                    margin: 16px 0 16px 16px !important;
 
                     .milkdown-cell-left,
                     .milkdown-cell-point,
@@ -37,24 +37,24 @@ export const injectStyle = (themeManager: ThemeManager, { css, injectGlobal }: E
                     }
 
                     .milkdown-cell-left {
-                        left: calc(-6px - 0.5em);
+                        left: -14px;
                         top: 0;
                         bottom: 0;
-                        width: 0.5em;
+                        width: 8px;
                     }
 
                     .milkdown-cell-top {
                         left: 0;
                         right: 0;
-                        top: calc(-6px - 0.5em);
-                        height: 0.5em;
+                        top: -14px;
+                        height: 8px;
                     }
 
                     .milkdown-cell-point {
-                        left: calc(-2px - 1em);
-                        top: calc(-2px - 1em);
-                        width: 1em;
-                        height: 1em;
+                        left: -18px;
+                        top: -18px;
+                        width: 16px;
+                        height: 16px;
 
                         .icon {
                             position: absolute;
@@ -90,8 +90,8 @@ export const injectStyle = (themeManager: ThemeManager, { css, injectGlobal }: E
             position: relative;
             color: ${palette('solid', 0.87)};
 
-            width: 2em;
-            line-height: 2em;
+            width: 48px;
+            line-height: 48px;
             text-align: center;
             transition: all 0.4s ease-in-out;
 

package/src/table/operator-plugin/widget.ts

@@ -1,7 +1,7 @@
 /* Copyright 2021, Milkdown by Mirone. */
 
 import { Ctx, ThemeIcon, themeManagerCtx } from '@milkdown/core';
-import { Decoration, WidgetDecorationSpec } from '@milkdown/prose/view';
+import { Decoration } from '@milkdown/prose/view';
 
 import { CellPos, selectLine, selectTable } from '../utils';
 import { ToolTipPos } from './constant';
@@ -21,19 +21,9 @@ const calculateClassName = (pos: ToolTipPos) => {
     }
 };
 
-export function createWidget(ctx: Ctx, cell: CellPos, pos: ToolTipPos.Point): Decoration<WidgetDecorationSpec>;
-export function createWidget(
-    ctx: Ctx,
-    cell: CellPos,
-    pos: ToolTipPos.Left,
-    index: number,
-): Decoration<WidgetDecorationSpec>;
-export function createWidget(
-    ctx: Ctx,
-    cell: CellPos,
-    pos: ToolTipPos.Top,
-    index: number,
-): Decoration<WidgetDecorationSpec>;
+export function createWidget(ctx: Ctx, cell: CellPos, pos: ToolTipPos.Point): Decoration;
+export function createWidget(ctx: Ctx, cell: CellPos, pos: ToolTipPos.Left, index: number): Decoration;
+export function createWidget(ctx: Ctx, cell: CellPos, pos: ToolTipPos.Top, index: number): Decoration;
 export function createWidget(ctx: Ctx, cell: CellPos, pos: ToolTipPos, index = 0) {
     return Decoration.widget(cell.pos + 1, (view) => {
         const div = document.createElement('div');

package/src/table/plugin/auto-insert-zero-space.ts

@@ -0,0 +1,51 @@
+/* Copyright 2021, Milkdown by Mirone. */
+import { browser } from '@milkdown/prose';
+import { Node } from '@milkdown/prose/model';
+import { Plugin, PluginKey } from '@milkdown/prose/state';
+
+import { isInTable } from './util';
+
+const isEmptyParagraph = (node: Node) => {
+    return node.type.name === 'paragraph' && node.nodeSize === 2;
+};
+
+const isParagraph = (node: Node) => {
+    return node.type.name === 'paragraph';
+};
+
+const pluginKey = new PluginKey('plugin_autoInsertZeroSpace');
+
+export const autoInsertZeroSpace = () => {
+    return new Plugin({
+        key: pluginKey,
+        props: {
+            handleDOMEvents: {
+                compositionstart(view) {
+                    const { state, dispatch } = view;
+                    const { tr, selection } = state;
+                    const { $from } = selection;
+                    if (browser.safari && isInTable(state) && selection.empty && isEmptyParagraph($from.parent)) {
+                        dispatch(tr.insertText('\u2060', $from.start()));
+                    }
+                    return false;
+                },
+                compositionend(view) {
+                    const { state, dispatch } = view;
+                    const { tr, selection } = state;
+                    const { $from } = selection;
+
+                    if (
+                        browser.safari &&
+                        isInTable(state) &&
+                        selection.empty &&
+                        isParagraph($from.parent) &&
+                        $from.parent.textContent.startsWith('\u2060')
+                    ) {
+                        dispatch(tr.delete($from.start(), $from.start() + 1));
+                    }
+                    return false;
+                },
+            },
+        },
+    });
+};

package/src/table/plugin/cell-selection.ts

@@ -0,0 +1,352 @@
+/* Copyright 2021, Milkdown by Mirone. */
+
+import { Fragment, Node, ResolvedPos, Slice } from '@milkdown/prose/model';
+import {
+    EditorState,
+    NodeSelection,
+    Selection,
+    SelectionRange,
+    TextSelection,
+    Transaction,
+} from '@milkdown/prose/state';
+import { Mappable } from '@milkdown/prose/transform';
+import { Decoration, DecorationSet } from '@milkdown/prose/view';
+
+import { TableMap } from './table-map';
+import { inSameTable, pointsAtCell, removeColSpan, setAttr } from './util';
+
+// ::- A [`Selection`](http://prosemirror.net/docs/ref/#state.Selection)
+// subclass that represents a cell selection spanning part of a table.
+// With the plugin enabled, these will be created when the user
+// selects across cells, and will be drawn by giving selected cells a
+// `selectedCell` CSS class.
+export class CellSelection extends Selection {
+    // :: (ResolvedPos, ?ResolvedPos)
+    // A table selection is identified by its anchor and head cells. The
+    // positions given to this constructor should point _before_ two
+    // cells in the same table. They may be the same, to select a single
+    // cell.
+    constructor(public $anchorCell: ResolvedPos, public $headCell = $anchorCell) {
+        const table = $anchorCell.node(-1),
+            map = TableMap.get(table),
+            start = $anchorCell.start(-1);
+        const rect = map.rectBetween($anchorCell.pos - start, $headCell.pos - start);
+        const doc = $anchorCell.node(0);
+        const cells = map.cellsInRect(rect).filter((p) => p != $headCell.pos - start);
+        // Make the head cell the first range, so that it counts as the
+        // primary part of the selection
+        cells.unshift($headCell.pos - start);
+        const ranges = cells.map((pos) => {
+            const cell = table.nodeAt(pos) as Node,
+                from = pos + start + 1;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return new (SelectionRange as any)(doc.resolve(from), doc.resolve(from + cell.content.size));
+        });
+        super(ranges[0].$from, ranges[0].$to, ranges);
+        // :: ResolvedPos
+        // A resolved position pointing _in front of_ the anchor cell (the one
+        // that doesn't move when extending the selection).
+        this.$anchorCell = $anchorCell;
+        // :: ResolvedPos
+        // A resolved position pointing in front of the head cell (the one
+        // moves when extending the selection).
+        this.$headCell = $headCell;
+    }
+
+    map(doc: Node, mapping: Mappable): Selection {
+        const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
+        const $headCell = doc.resolve(mapping.map(this.$headCell.pos));
+        if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
+            const tableChanged = this.$anchorCell.node(-1) != $anchorCell.node(-1);
+            if (tableChanged && this.isRowSelection()) return CellSelection.rowSelection($anchorCell, $headCell);
+            else if (tableChanged && this.isColSelection()) return CellSelection.colSelection($anchorCell, $headCell);
+            else return new CellSelection($anchorCell, $headCell);
+        }
+        return TextSelection.between($anchorCell, $headCell);
+    }
+
+    // :: () → Slice
+    // Returns a rectangular slice of table rows containing the selected
+    // cells.
+    override content(): Slice {
+        const table = this.$anchorCell.node(-1),
+            map = TableMap.get(table),
+            start = this.$anchorCell.start(-1);
+        const rect = map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start);
+        const seen: Record<number, boolean> = {},
+            rows = [];
+        for (let row = rect.top; row < rect.bottom; row++) {
+            const rowContent = [];
+            for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
+                const pos = map.map[index] as number;
+                if (!seen[pos]) {
+                    seen[pos] = true;
+                    const cellRect = map.findCell(pos);
+                    let cell = table.nodeAt(pos) as Node;
+                    const extraLeft = rect.left - cellRect.left,
+                        extraRight = cellRect.right - rect.right;
+                    if (extraLeft > 0 || extraRight > 0) {
+                        let attrs = cell.attrs;
+                        if (extraLeft > 0) attrs = removeColSpan(attrs, 0, extraLeft);
+                        if (extraRight > 0) attrs = removeColSpan(attrs, attrs['colspan'] - extraRight, extraRight);
+                        if (cellRect.left < rect.left) cell = cell.type.createAndFill(attrs) as Node;
+                        else cell = cell.type.create(attrs, cell.content);
+                    }
+                    if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
+                        const attrs = setAttr(
+                            cell.attrs,
+                            'rowspan',
+                            Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top),
+                        );
+                        if (cellRect.top < rect.top) cell = cell.type.createAndFill(attrs) as Node;
+                        else cell = cell.type.create(attrs, cell.content);
+                    }
+                    rowContent.push(cell);
+                }
+            }
+            rows.push(table.child(row).copy(Fragment.from(rowContent)));
+        }
+
+        const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
+        return new Slice(Fragment.from(fragment), 1, 1);
+    }
+
+    override replace(tr: Transaction, content = Slice.empty) {
+        const mapFrom = tr.steps.length,
+            ranges = this.ranges;
+        for (let i = 0; i < ranges.length; i++) {
+            const { $from, $to } = ranges[i] as SelectionRange,
+                mapping = tr.mapping.slice(mapFrom);
+            tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+        }
+        const sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
+        if (sel) tr.setSelection(sel);
+    }
+
+    override replaceWith(tr: Transaction, node: Node) {
+        this.replace(tr, new Slice(Fragment.from(node), 0, 0));
+    }
+
+    forEachCell(f: (node: Node, index: number) => void) {
+        const table = this.$anchorCell.node(-1),
+            map = TableMap.get(table),
+            start = this.$anchorCell.start(-1);
+        const cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start));
+        for (let i = 0; i < cells.length; i++)
+            f(table.nodeAt(cells[i] as number) as Node, start + (cells[i] as number));
+    }
+
+    // :: () → bool
+    // True if this selection goes all the way from the top to the
+    // bottom of the table.
+    isColSelection() {
+        const anchorTop = this.$anchorCell.index(-1),
+            headTop = this.$headCell.index(-1);
+        if (Math.min(anchorTop, headTop) > 0) return false;
+        const anchorBot = anchorTop + (this.$anchorCell.nodeAfter as Node).attrs['rowspan'],
+            headBot = headTop + (this.$headCell.nodeAfter as Node).attrs['rowspan'];
+        return Math.max(anchorBot, headBot) == this.$headCell.node(-1).childCount;
+    }
+
+    // :: (ResolvedPos, ?ResolvedPos) → CellSelection
+    // Returns the smallest column selection that covers the given anchor
+    // and head cell.
+    static colSelection($anchorCell: ResolvedPos, $headCell = $anchorCell) {
+        const map = TableMap.get($anchorCell.node(-1)),
+            start = $anchorCell.start(-1);
+        const anchorRect = map.findCell($anchorCell.pos - start),
+            headRect = map.findCell($headCell.pos - start);
+        const doc = $anchorCell.node(0);
+        if (anchorRect.top <= headRect.top) {
+            if (anchorRect.top > 0) {
+                const left = map.map[anchorRect.left] as number;
+                $anchorCell = doc.resolve(start + left);
+            }
+            if (headRect.bottom < map.height) {
+                const pos = map.map[map.width * (map.height - 1) + headRect.right - 1] as number;
+                $headCell = doc.resolve(start + pos);
+            }
+        } else {
+            if (headRect.top > 0) {
+                const left = map.map[anchorRect.left] as number;
+                $headCell = doc.resolve(start + left);
+            }
+            if (anchorRect.bottom < map.height) {
+                const pos = map.map[map.width * (map.height - 1) + anchorRect.right - 1] as number;
+                $anchorCell = doc.resolve(start + pos);
+            }
+        }
+        return new CellSelection($anchorCell, $headCell);
+    }
+
+    // :: () → bool
+    // True if this selection goes all the way from the left to the
+    // right of the table.
+    isRowSelection() {
+        const map = TableMap.get(this.$anchorCell.node(-1)),
+            start = this.$anchorCell.start(-1);
+        const anchorLeft = map.colCount(this.$anchorCell.pos - start),
+            headLeft = map.colCount(this.$headCell.pos - start);
+        if (Math.min(anchorLeft, headLeft) > 0) return false;
+        const anchorRight = anchorLeft + (this.$anchorCell.nodeAfter as Node).attrs['colspan'],
+            headRight = headLeft + (this.$headCell.nodeAfter as Node).attrs['colspan'];
+        return Math.max(anchorRight, headRight) == map.width;
+    }
+
+    eq(other: Selection): boolean {
+        return (
+            other instanceof CellSelection &&
+            other.$anchorCell.pos == this.$anchorCell.pos &&
+            other.$headCell.pos == this.$headCell.pos
+        );
+    }
+
+    // :: (ResolvedPos, ?ResolvedPos) → CellSelection
+    // Returns the smallest row selection that covers the given anchor
+    // and head cell.
+    static rowSelection($anchorCell: ResolvedPos, $headCell = $anchorCell) {
+        const map = TableMap.get($anchorCell.node(-1)),
+            start = $anchorCell.start(-1);
+        const anchorRect = map.findCell($anchorCell.pos - start),
+            headRect = map.findCell($headCell.pos - start);
+        const doc = $anchorCell.node(0);
+        if (anchorRect.left <= headRect.left) {
+            if (anchorRect.left > 0) {
+                const pos = map.map[anchorRect.top * map.width] as number;
+                $anchorCell = doc.resolve(start + pos);
+            }
+            if (headRect.right < map.width) {
+                const pos = map.map[map.width * (headRect.top + 1) - 1] as number;
+                $headCell = doc.resolve(start + pos);
+            }
+        } else {
+            if (headRect.left > 0) {
+                const pos = map.map[headRect.top * map.width] as number;
+                $headCell = doc.resolve(start + pos);
+            }
+            if (anchorRect.right < map.width) {
+                const pos = map.map[map.width * (anchorRect.top + 1) - 1] as number;
+
+                $anchorCell = doc.resolve(start + pos);
+            }
+        }
+        return new CellSelection($anchorCell, $headCell);
+    }
+
+    toJSON() {
+        return {
+            type: 'cell',
+            anchor: this.$anchorCell.pos,
+            head: this.$headCell.pos,
+        };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static override fromJSON(doc: Node, json: any) {
+        return new CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
+    }
+
+    // :: (Node, number, ?number) → CellSelection
+    static create(doc: Node, anchorCell: number, headCell = anchorCell) {
+        return new CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
+    }
+
+    override getBookmark() {
+        return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
+    }
+}
+
+CellSelection.prototype.visible = false;
+
+Selection.jsonID('cell', CellSelection);
+
+class CellBookmark {
+    constructor(public anchor: number, public head: number) {
+        this.anchor = anchor;
+        this.head = head;
+    }
+    map(mapping: Mappable) {
+        return new CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
+    }
+    resolve(doc: Node): Selection {
+        const $anchorCell = doc.resolve(this.anchor),
+            $headCell = doc.resolve(this.head);
+        if (
+            $anchorCell.parent.type.spec['tableRole'] == 'row' &&
+            $headCell.parent.type.spec['tableRole'] == 'row' &&
+            $anchorCell.index() < $anchorCell.parent.childCount &&
+            $headCell.index() < $headCell.parent.childCount &&
+            inSameTable($anchorCell, $headCell)
+        )
+            return new CellSelection($anchorCell, $headCell);
+        else return Selection.near($headCell, 1);
+    }
+}
+
+export function drawCellSelection(state: EditorState) {
+    if (!(state.selection instanceof CellSelection)) return null;
+    const cells: Decoration[] = [];
+    state.selection.forEachCell((node, pos) => {
+        cells.push(Decoration.node(pos, pos + node.nodeSize, { class: 'selectedCell' }));
+    });
+    return DecorationSet.create(state.doc, cells);
+}
+
+function isCellBoundarySelection({ $from, $to }: Selection) {
+    if ($from.pos == $to.pos || $from.pos < $from.pos - 6) return false; // Cheap elimination
+    let afterFrom = $from.pos,
+        beforeTo = $to.pos,
+        depth = $from.depth;
+    for (; depth >= 0; depth--, afterFrom++) if ($from.after(depth + 1) < $from.end(depth)) break;
+    for (let d = $to.depth; d >= 0; d--, beforeTo--) if ($to.before(d + 1) > $to.start(d)) break;
+    return afterFrom == beforeTo && /row|table/.test($from.node(depth).type.spec['tableRole']);
+}
+
+function isTextSelectionAcrossCells({ $from, $to }: Selection) {
+    let fromCellBoundaryNode;
+    let toCellBoundaryNode;
+
+    for (let i = $from.depth; i > 0; i--) {
+        const node = $from.node(i);
+        if (node.type.spec['tableRole'] === 'cell' || node.type.spec['tableRole'] === 'header_cell') {
+            fromCellBoundaryNode = node;
+            break;
+        }
+    }
+
+    for (let i = $to.depth; i > 0; i--) {
+        const node = $to.node(i);
+        if (node.type.spec['tableRole'] === 'cell' || node.type.spec['tableRole'] === 'header_cell') {
+            toCellBoundaryNode = node;
+            break;
+        }
+    }
+
+    return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;
+}
+
+export function normalizeSelection(state: EditorState, tr: Transaction | undefined, allowTableNodeSelection: boolean) {
+    const sel = (tr || state).selection,
+        doc = (tr || state).doc;
+    let normalize, role;
+    if (sel instanceof NodeSelection && (role = sel.node.type.spec['tableRole'])) {
+        if (role == 'cell' || role == 'header_cell') {
+            normalize = CellSelection.create(doc, sel.from);
+        } else if (role == 'row') {
+            const $cell = doc.resolve(sel.from + 1);
+            normalize = CellSelection.rowSelection($cell, $cell);
+        } else if (!allowTableNodeSelection) {
+            const map = TableMap.get(sel.node),
+                start = sel.from + 1;
+            const pos = map.map[map.width * map.height - 1] as number;
+            const lastCell = start + pos;
+            normalize = CellSelection.create(doc, start + 1, lastCell);
+        }
+    } else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) {
+        normalize = TextSelection.create(doc, sel.from);
+    } else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {
+        normalize = TextSelection.create(doc, sel.$from.start(), sel.$from.end());
+    }
+    if (normalize) (tr || (tr = state.tr)).setSelection(normalize);
+    return tr;
+}