@milkdown/preset-gfm 6.5.3 → 7.0.0-next.0

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

@@ -1,381 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-
-import type { Node, ResolvedPos } from '@milkdown/prose/model'
-import { Fragment, Slice } from '@milkdown/prose/model'
-import type {
-  EditorState,
-  Transaction,
-} from '@milkdown/prose/state'
-import {
-  NodeSelection,
-  Selection,
-  SelectionRange,
-  TextSelection,
-} from '@milkdown/prose/state'
-import type { 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)
-    const map = TableMap.get(table)
-    const 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
-      const from = pos + start + 1
-
-      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)
-    const map = TableMap.get(table)
-    const start = this.$anchorCell.start(-1)
-    const rect = map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start)
-    const seen: Record<number, boolean> = {}
-    const 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
-          const 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
-    const ranges = this.ranges
-    for (let i = 0; i < ranges.length; i++) {
-      const { $from, $to } = ranges[i] as SelectionRange
-      const 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)
-    const map = TableMap.get(table)
-    const 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)
-    const headTop = this.$headCell.index(-1)
-    if (Math.min(anchorTop, headTop) > 0)
-      return false
-    const anchorBot = anchorTop + (this.$anchorCell.nodeAfter as Node).attrs.rowspan
-    const 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))
-    const start = $anchorCell.start(-1)
-    const anchorRect = map.findCell($anchorCell.pos - start)
-    const 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))
-    const start = this.$anchorCell.start(-1)
-    const anchorLeft = map.colCount(this.$anchorCell.pos - start)
-    const 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
-    const 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))
-    const start = $anchorCell.start(-1)
-    const anchorRect = map.findCell($anchorCell.pos - start)
-    const 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,
-    }
-  }
-
-  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)
-    const $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
-  let beforeTo = $to.pos
-  let 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
-  const doc = (tr || state).doc
-  let normalize, role
-  // eslint-disable-next-line no-cond-assign
-  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)
-      const 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
-}

package/src/table/plugin/column-resizing.ts

@@ -1,288 +0,0 @@
-/* Copyright 2021, Milkdown by Mirone. */
-import type { Attrs, Node } from '@milkdown/prose/model'
-import type { EditorState, Transaction } from '@milkdown/prose/state'
-import { Plugin, PluginKey } from '@milkdown/prose/state'
-import type { EditorView } from '@milkdown/prose/view'
-import { Decoration, DecorationSet } from '@milkdown/prose/view'
-
-import { tableNodeTypes } from './schema'
-import { TableMap } from './table-map'
-import { TableView, updateColumns } from './table-view'
-import { cellAround, pointsAtCell, setAttr } from './util'
-
-export const key = new PluginKey('tableColumnResizing')
-
-export function columnResizing({
-  handleWidth = 5,
-  cellMinWidth = 25,
-  View = TableView,
-  lastColumnResizable = true,
-} = {}) {
-  const plugin = new Plugin({
-    key,
-    state: {
-      init(this: Plugin, _, state) {
-        this.spec.props!.nodeViews![tableNodeTypes(state.schema).table.name] = node =>
-          new View(node, cellMinWidth)
-        return new ResizeState(-1, false)
-      },
-      apply(tr, prev) {
-        return prev.apply(tr)
-      },
-    },
-    props: {
-      attributes(state) {
-        const pluginState = key.getState(state)
-        return pluginState.activeHandle > -1 ? { class: 'resize-cursor' } : (undefined as unknown as Attrs)
-      },
-
-      handleDOMEvents: {
-        mousemove(view, event) {
-          if (!view.editable)
-            return
-          handleMouseMove(view, event as MouseEvent, handleWidth, lastColumnResizable)
-        },
-        mouseleave(view) {
-          if (!view.editable)
-            return
-          handleMouseLeave(view)
-        },
-        mousedown(view, event) {
-          if (!view.editable)
-            return
-          handleMouseDown(view, event as MouseEvent, cellMinWidth)
-        },
-      },
-
-      decorations(state) {
-        const pluginState = key.getState(state)
-        if (pluginState.activeHandle > -1)
-          return handleDecorations(state, pluginState.activeHandle)
-
-        return null
-      },
-
-      nodeViews: {},
-    },
-  })
-  return plugin
-}
-
-class ResizeState {
-  constructor(public activeHandle: number, public dragging: null | boolean) {
-    this.activeHandle = activeHandle
-    this.dragging = dragging
-  }
-
-  apply(this: ResizeState, tr: Transaction) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let state = this
-    const action = tr.getMeta(key)
-    if (action && action.setHandle != null)
-      return new ResizeState(action.setHandle, null)
-    if (action && action.setDragging !== undefined)
-      return new ResizeState(state.activeHandle, action.setDragging)
-    if (state.activeHandle > -1 && tr.docChanged) {
-      let handle = tr.mapping.map(state.activeHandle, -1)
-      if (!pointsAtCell(tr.doc.resolve(handle)))
-        handle = 0
-      state = new ResizeState(handle, state.dragging)
-    }
-    return state
-  }
-}
-
-function handleMouseMove(view: EditorView, event: MouseEvent, handleWidth: number, lastColumnResizable: boolean) {
-  const pluginState = key.getState(view.state)
-
-  if (!pluginState.dragging) {
-    const target = domCellAround(event.target as Element)
-    let cell = -1
-    if (target) {
-      const { left, right } = target.getBoundingClientRect()
-      if (
-        right - event.clientX <= handleWidth
-                // hover on the right border of the cell, the `target` is the next cell
-                || event.clientX === Math.floor(left)
-      )
-        cell = edgeCell(view, event, 'right')
-      else if (event.clientX - left <= handleWidth)
-        cell = edgeCell(view, event, 'left')
-    }
-
-    if (cell != pluginState.activeHandle) {
-      if (!lastColumnResizable && cell !== -1) {
-        const $cell = view.state.doc.resolve(cell)
-        const table = $cell.node(-1)
-        const map = TableMap.get(table)
-        const start = $cell.start(-1)
-
-        const col = map.colCount($cell.pos - start) + $cell.nodeAfter!.attrs.colspan - 1
-
-        if (col == map.width - 1)
-          return
-      }
-
-      updateHandle(view, cell)
-    }
-  }
-}
-
-function handleMouseLeave(view: EditorView) {
-  const pluginState = key.getState(view.state)
-  if (pluginState.activeHandle > -1 && !pluginState.dragging)
-    updateHandle(view, -1)
-}
-
-function handleMouseDown(view: EditorView, event: MouseEvent, cellMinWidth: number) {
-  const pluginState = key.getState(view.state)
-  if (pluginState.activeHandle == -1 || pluginState.dragging)
-    return false
-
-  const cell = view.state.doc.nodeAt(pluginState.activeHandle) as Node
-  const width = currentColWidth(view, pluginState.activeHandle, cell.attrs)
-  view.dispatch(
-    view.state.tr.setMeta(key, {
-      setDragging: { startX: event.clientX, startWidth: width },
-    }),
-  )
-
-  function finish(event: MouseEvent) {
-    window.removeEventListener('mouseup', finish)
-    window.removeEventListener('mousemove', move)
-    const pluginState = key.getState(view.state)
-    if (pluginState.dragging) {
-      updateColumnWidth(view, pluginState.activeHandle, draggedWidth(pluginState.dragging, event, cellMinWidth))
-      view.dispatch(view.state.tr.setMeta(key, { setDragging: null }))
-    }
-  }
-  function move(event: MouseEvent) {
-    if (!event.which)
-      return finish(event)
-    const pluginState = key.getState(view.state)
-    const dragged = draggedWidth(pluginState.dragging, event, cellMinWidth)
-    displayColumnWidth(view, pluginState.activeHandle, dragged, cellMinWidth)
-  }
-
-  window.addEventListener('mouseup', finish)
-  window.addEventListener('mousemove', move)
-  event.preventDefault()
-  return true
-}
-
-function currentColWidth(view: EditorView, cellPos: number, { colspan, colwidth }: Attrs) {
-  const width = colwidth && colwidth[colwidth.length - 1]
-  if (width)
-    return width
-  const dom = view.domAtPos(cellPos)
-  const node = dom.node.childNodes[dom.offset] as HTMLElement
-  let domWidth = node.offsetWidth
-  let parts = colspan
-  if (colwidth) {
-    for (let i = 0; i < colspan; i++) {
-      if (colwidth[i]) {
-        domWidth -= colwidth[i]
-        parts--
-      }
-    }
-  }
-  return domWidth / parts
-}
-
-function domCellAround(target: Element | null) {
-  while (target && target.nodeName != 'TD' && target.nodeName != 'TH')
-    target = target.classList.contains('ProseMirror') ? null : (target.parentNode as Element)
-  return target
-}
-
-function edgeCell(view: EditorView, event: MouseEvent, side: 'left' | 'right') {
-  const found = view.posAtCoords({ left: event.clientX, top: event.clientY })
-  if (!found)
-    return -1
-  const { pos } = found
-  const $cell = cellAround(view.state.doc.resolve(pos))
-  if (!$cell)
-    return -1
-  if (side == 'right')
-    return $cell.pos
-  const map = TableMap.get($cell.node(-1))
-  const start = $cell.start(-1)
-  const index = map.map.indexOf($cell.pos - start)
-  return index % map.width == 0 ? -1 : start + (map.map[index - 1] as number)
-}
-
-function draggedWidth(dragging: { startX: number; startWidth: number }, event: MouseEvent, cellMinWidth: number) {
-  const offset = event.clientX - dragging.startX
-  return Math.max(cellMinWidth, dragging.startWidth + offset)
-}
-
-function updateHandle(view: EditorView, value: number) {
-  view.dispatch(view.state.tr.setMeta(key, { setHandle: value }))
-}
-
-function updateColumnWidth(view: EditorView, cell: number, width: number) {
-  const $cell = view.state.doc.resolve(cell)
-  const table = $cell.node(-1)
-  const map = TableMap.get(table)
-  const start = $cell.start(-1)
-  const col = map.colCount($cell.pos - start) + ($cell.nodeAfter as Node).attrs.colspan - 1
-  const tr = view.state.tr
-  for (let row = 0; row < map.height; row++) {
-    const mapIndex = row * map.width + col
-    // Rowspanning cell that has already been handled
-    if (row && map.map[mapIndex] == map.map[mapIndex - map.width])
-      continue
-    const pos = map.map[mapIndex] as number
-    const { attrs } = table.nodeAt(pos) as Node
-    const index = attrs.colspan == 1 ? 0 : col - map.colCount(pos)
-    if (attrs.colwidth && attrs.colwidth[index] == width)
-      continue
-    const colwidth = attrs.colwidth ? attrs.colwidth.slice() : zeroes(attrs.colspan)
-    colwidth[index] = width
-    tr.setNodeMarkup(start + pos, null, setAttr(attrs, 'colwidth', colwidth))
-  }
-  if (tr.docChanged)
-    view.dispatch(tr)
-}
-
-function displayColumnWidth(view: EditorView, cell: number, width: number, cellMinWidth: number) {
-  const $cell = view.state.doc.resolve(cell)
-  const table = $cell.node(-1)
-  const start = $cell.start(-1)
-  const col = TableMap.get(table).colCount($cell.pos - start) + ($cell.nodeAfter as Node).attrs.colspan - 1
-  let dom = view.domAtPos($cell.start(-1)).node as HTMLElement
-  while (dom.nodeName != 'TABLE') dom = dom.parentNode as HTMLElement
-  updateColumns(table, dom.firstChild as HTMLTableColElement, dom as HTMLTableElement, cellMinWidth, col, width)
-}
-
-function zeroes(n: number) {
-  const result = []
-  for (let i = 0; i < n; i++) result.push(0)
-  return result
-}
-
-function handleDecorations(state: EditorState, cell: number) {
-  const decorations = []
-  const $cell = state.doc.resolve(cell)
-  const table = $cell.node(-1)
-  const map = TableMap.get(table)
-  const start = $cell.start(-1)
-  const col = map.colCount($cell.pos - start) + ($cell.nodeAfter as Node).attrs.colspan
-  for (let row = 0; row < map.height; row++) {
-    const index = col + row * map.width - 1
-    // For positions that are have either a different cell or the end
-    // of the table to their right, and either the top of the table or
-    // a different cell above them, add a decoration
-    if (
-      (col == map.width || map.map[index] != map.map[index + 1])
-            && (row == 0 || map.map[index - 1] != map.map[index - 1 - map.width])
-    ) {
-      const cellPos = map.map[index] as number
-      const pos = start + cellPos + (table.nodeAt(cellPos) as Node).nodeSize - 1
-      const dom = document.createElement('div')
-      dom.className = 'column-resize-handle'
-      decorations.push(Decoration.widget(pos, dom))
-    }
-  }
-  return DecorationSet.create(state.doc, decorations)
-}