function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
// Copyright (C) 2015-2016 by Marijn Haverbeke <marijnh@gmail.com> and others
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
// License about this file:
// This file is originally forked from
// https://github.com/ProseMirror/prosemirror-tables/blob/0e74c6a1761651ccf3701eb8529fa9187ad5c91d/src/columnresizing.js
// and most of the original codes had been modified to support the bevaviors
// that czi-prosemirror needs.
// The plugin provides the following behaviors:
// - Let user resize a column without changing the total width of the table.
// - Let user set the left margin of the table.
// - Let user set the right margin of the table.
import TableNodeView from './ui/TableNodeView.js';
import { Node } from 'prosemirror-model';
import { EditorState, Plugin, PluginKey } from 'prosemirror-state';
import { Transform } from 'prosemirror-transform';
import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
import { findParentNodeOfTypeClosestToPos } from 'prosemirror-utils';
import nullthrows from 'nullthrows';
import { cellAround, pointsAtCell, tableNodeTypes, TableMap, TableView } from 'prosemirror-tables';
var PLUGIN_KEY = new PluginKey('tableColumnResizing');

// [FS] IRAD-949 2020-05-27
// Fix:Cell Resize Handler causes edit diificult to firsrst/last two chars in the cell.
// Rezie cursor position issue fixed.

var CELL_MIN_WIDTH = 30;
var HANDLE_WIDTH = 5;
var HANDLE_RIGHT_WIDTH = 20;
var cancelDrag = null;
var isEnabled = true;

// The immutable plugin state that stores the information for resizing.
var ResizeState = /*#__PURE__*/function () {
  function ResizeState(cellPos, forMarginLeft, draggingInfo) {
    _classCallCheck(this, ResizeState);
    _defineProperty(this, "cellPos", void 0);
    _defineProperty(this, "forMarginLeft", void 0);
    _defineProperty(this, "draggingInfo", void 0);
    this.cellPos = cellPos;
    this.draggingInfo = draggingInfo;
    this.forMarginLeft = forMarginLeft;
  }
  return _createClass(ResizeState, [{
    key: "apply",
    value: function apply(tr) {
      var state = this;
      var action = tr.getMeta(PLUGIN_KEY);
      if (action && typeof action.setCellPos === 'number') {
        return new ResizeState(action.setCellPos, action.setForMarginLeft, null);
      }
      if (action && action.setDraggingInfo !== undefined) {
        return new ResizeState(state.cellPos, state.forMarginLeft, action.setDraggingInfo);
      }
      if (state.cellPos && state.cellPos > -1 && tr.docChanged) {
        var cellPos = tr.mapping.map(state.cellPos, -1);
        if (!pointsAtCell(tr.doc.resolve(cellPos))) {
          cellPos = null;
        }
        state = new ResizeState(cellPos, cellPos ? state.forMarginLeft : false, state.draggingInfo);
      }
      return state;
    }
  }]);
}(); // Function that handles the mousemove event inside table cell.
function handleMouseMove(view, event) {
  var resizeState = PLUGIN_KEY.getState(view.state);
  if (resizeState.draggingInfo) {
    return;
  }
  var target = domCellAround(event.target);
  var forMarginLeft = false;
  var cell = -1;
  if (target instanceof HTMLTableCellElement) {
    var _target$getBoundingCl = target.getBoundingClientRect(),
      left = _target$getBoundingCl.left,
      right = _target$getBoundingCl.right;
    var offsetLeft = event.clientX - left;
    // [FS] IRAD-949 2020-05-27
    // Fix:Cell Resize Handler causes edit diificult to firsrst/last two chars in the cell.
    // Rezie cursor position issue fixed.
    if (offsetLeft <= HANDLE_WIDTH) {
      if (target.cellIndex === 0) {
        forMarginLeft = true;
        cell = edgeCell(view, event, 'right');
      } else {
        cell = edgeCell(view, event, 'left');
      }
    } else if (right - event.clientX <= HANDLE_WIDTH) {
      cell = edgeCell(view, event, 'right');
    }
  }
  if (cell === resizeState.cellPos && forMarginLeft === resizeState.forMarginLeft) {
    return;
  }
  if (cell !== -1) {
    var $cell = view.state.doc.resolve(cell);
    if (!$cell) {
      return;
    }
  }
  updateResizeHandle(view, cell, forMarginLeft);
}

// Function that handles the mouseleave event from the table cell.
function handleMouseLeave(view) {
  var resizeState = PLUGIN_KEY.getState(view.state);
  var cellPos = resizeState.cellPos,
    draggingInfo = resizeState.draggingInfo;
  if (cellPos > -1 && !draggingInfo) {
    updateResizeHandle(view, -1, false);
  }
}

// Function that handles the mousedown event from the table cell.
function handleMouseDown(view, event) {
  var _this = this;
  // It's possible that the resize action that happened earlier was inturrupted
  // while its dependent mouse events were stopped or prevented by others.
  // We need to stop the previous resize action if it did not finish.
  cancelDrag && cancelDrag(event);
  var resizeState = PLUGIN_KEY.getState(view.state);
  if (resizeState.cellPos === -1 || resizeState.draggingInfo) {
    return false;
  }
  var dragStarted = false;
  var dragMoveHandler = null;
  var finish = function finish(event) {
    window.removeEventListener('mouseup', finish, true);
    window.removeEventListener('mousemove', _this.move, true);
    dragStarted && handleDragEnd(view, event);
    cancelDrag = null;
  };
  var move = function move(event) {
    if (event.which) {
      if (!dragStarted) {
        handleDragStart(view, event);
        dragStarted = true;
      }
      // Move events should be batched to avoid over-handling the mouse
      // event.
      dragMoveHandler = dragMoveHandler || batchMouseHandler(handleDragMove);
      dragMoveHandler(view, event);
    } else {
      finish(event);
    }
  };
  cancelDrag = finish;
  window.addEventListener('mouseup', finish, true);
  window.addEventListener('mousemove', move, true);
  event.preventDefault();
  return true;
}
function handleDragStart(view, event) {
  var resizeState = PLUGIN_KEY.getState(view.state);
  if (resizeState.cellPos === -1 || resizeState.draggingInfo) {
    return;
  }
  view.dispatch(view.state.tr.setMeta(PLUGIN_KEY, {
    setDraggingInfo: calculateDraggingInfo(view, event, resizeState)
  }));
}

// Function that handles the mouse event while resizing the table cell.
// This will temporarily updates the table's style until the resize ends.
function handleDragMove(view, event) {
  var resizeState = PLUGIN_KEY.getState(view.state);
  var draggingInfo = resizeState.draggingInfo,
    forMarginLeft = resizeState.forMarginLeft;
  if (!draggingInfo) {
    return;
  }
  var startX = draggingInfo.startX,
    columnWidths = draggingInfo.columnWidths,
    taregtColumnIndex = draggingInfo.taregtColumnIndex,
    columnElements = draggingInfo.columnElements,
    tableElement = draggingInfo.tableElement,
    tableMarginLeft = draggingInfo.tableMarginLeft,
    tableMarginRight = draggingInfo.tableMarginRight;
  var totalWidth = 0;
  var ml = tableMarginLeft;
  var dx = event.clientX - startX;
  var lastIndex = columnWidths.length - 1;
  var widths = columnWidths.map(function (cw, index) {
    var ww;
    if (forMarginLeft) {
      if (index === 0) {
        // Resize the first column.
        ww = Math.min(Math.max(CELL_MIN_WIDTH, cw - dx), cw + tableMarginLeft);
        // Resize table's left margin.
        ml = Math.max(0, tableMarginLeft + cw - ww);
      } else {
        // The rest columns remain the same,
        ww = cw;
      }
    } else if (index === taregtColumnIndex && index === lastIndex) {
      // Resize the last column.
      ww = Math.min(cw + tableMarginRight, Math.max(CELL_MIN_WIDTH, cw + dx));
    } else if (index === taregtColumnIndex) {
      // Resize the column.
      ww = Math.min(Math.max(CELL_MIN_WIDTH, cw + dx), cw + (columnWidths[index + 1] || 0) - CELL_MIN_WIDTH);
    } else if (index === taregtColumnIndex + 1) {
      // Resize the column's previous column.
      ww = Math.min(Math.max(CELL_MIN_WIDTH, cw - dx), cw + (columnWidths[index - 1] || 0) - CELL_MIN_WIDTH);
    } else {
      // This column does not resize.
      ww = cw;
    }
    totalWidth += ww;
    return ww;
  });
  var tableElementStyle = tableElement.style;
  tableElementStyle.marginLeft = "".concat(ml, "px");
  // [FS] IRAD-993 2020-06-26
  // Fix:Table exceeds the canvas
  tableElementStyle.width = Math.round(totalWidth - ml) + 'px';
  tableElementStyle.minWidth = '';
  columnElements.forEach(function (colEl, index) {
    colEl.style.width = Math.round(widths[index]) + 'px';
  });
}

// Function that handles the mouse event while stop resizing the table cell.
function handleDragEnd(view, event) {
  var resizeState = PLUGIN_KEY.getState(view.state);
  var cellPos = resizeState.cellPos,
    draggingInfo = resizeState.draggingInfo;
  if (!draggingInfo) {
    return;
  }
  var columnElements = draggingInfo.columnElements,
    tableElement = draggingInfo.tableElement;
  var widths = columnElements.map(function (colEl) {
    return parseFloat(colEl.style.width);
  });
  var $cell = view.state.doc.resolve(cellPos);
  var start = $cell.start(-1);
  var table = $cell.node(-1);
  var map = TableMap.get(table);
  var tr = view.state.tr;
  for (var row = 0; row < map.height; row++) {
    for (var col = 0; col < widths.length; col++) {
      var mapIndex = row * map.width + col;
      if (row && map.map[mapIndex] == map.map[mapIndex - map.width]) {
        // Rowspanning cell that has already been handled
        continue;
      }
      var pos = map.map[mapIndex];
      var _table$nodeAt = table.nodeAt(pos),
        attrs = _table$nodeAt.attrs;
      var colspan = attrs.colspan || 1;
      var colwidth = widths.slice(col, col + colspan);
      if (colspan > 1) {
        // The current cell spans across multiple columns, this forwards to
        // the next cell for the next iteration.
        col += colspan - 1;
      }
      if (attrs.colwidth && compareNumbersList(attrs.colwidth, colwidth)) {
        continue;
      }
      attrs.colwidth = colwidth;
      tr = tr.setNodeMarkup(start + pos, null, attrs);
    }
  }
  var marginLeft = parseFloat(tableElement.style.marginLeft) || null;
  if (table.attrs.marginLeft !== marginLeft) {
    var nodeType = table.type;
    var _attrs = _objectSpread(_objectSpread({}, table.attrs), {}, {
      marginLeft: marginLeft
    });
    var tableLookup = findParentNodeOfTypeClosestToPos($cell, view.state.schema.nodes[nodeType.name]);
    var tablePos = nullthrows(tableLookup && tableLookup.pos);
    tr = tr.setNodeMarkup(tablePos, nodeType, _attrs);
  }
  if (tr.docChanged) {
    // Let editor know the change.
    view.dispatch(tr);
  }
  // Hides the resize handle bars.
  view.dispatch(view.state.tr.setMeta(PLUGIN_KEY, {
    setDraggingInfo: null
  }));
}

// Helper that prepares the information needed before the resizing starts.
function calculateDraggingInfo(view, event, resizeState) {
  var cellPos = resizeState.cellPos,
    forMarginLeft = resizeState.forMarginLeft;
  var dom = view.domAtPos(cellPos);
  var tableEl = dom.node.closest('table');
  var tableWrapper = tableEl.closest('.tableWrapper');
  var colGroupEl = tableEl.querySelector('colgroup');
  var colEls = colGroupEl ? Array.from(colGroupEl.querySelectorAll('col')) : [];
  var tableWrapperRect = tableWrapper.getBoundingClientRect();
  var tableRect = tableEl.getBoundingClientRect();
  var defaultColumnWidth = tableWrapperRect.width / colEls.length;
  var startX = event.clientX;
  var offsetLeft = startX - tableRect.left;
  var tableWidth = 0;
  var taregtColumnIndex = -1;
  var tableMarginLeftStyle = tableEl.style.marginLeft;
  var tableMarginLeft = tableMarginLeftStyle && /\d+px/.test(tableMarginLeftStyle) ? parseFloat(tableMarginLeftStyle) : 0;
  var tableMarginRight = tableWrapperRect.right - tableRect.right;

  // Calculate the inital width of each column.
  // Calculate the inital width of the table.
  // Find out the target column to resize.
  var columnWidths = Array.from(colEls).map(function (colEl, ii) {
    var cssWidth = colEl.style.width;
    var colWidth = Math.max(CELL_MIN_WIDTH, cssWidth && parseFloat(cssWidth) || defaultColumnWidth);
    if (tableWidth + colWidth > tableWrapperRect.width) {
      // column is too wide, make it fit.
      // colWidth -= tableWrapperRect.width - (tableWidth + colWidth);
      // [FS] IRAD-993 2020-06-24
      // Fix:Table exceeds the canvas
      var tosub = Math.abs(tableWrapperRect.width - (tableWidth + colWidth));
      colWidth = colWidth - tosub;
    }

    // The edges of the column's right border.
    // [FS] IRAD-949 2020-05-27
    // Fix:Cell Resize Handler causes edit diificult to firsrst/last two chars in the cell.
    var edgeLeft = tableWidth + colWidth - HANDLE_RIGHT_WIDTH / 2;
    var edgeRight = tableWidth + colWidth + HANDLE_RIGHT_WIDTH / 2;
    if (offsetLeft >= edgeLeft && offsetLeft <= edgeRight) {
      // [FS] IRAD-993 2020-06-24
      // Fix:Table exceeds the canvas
      if (taregtColumnIndex === -1) {
        // This is the column to resize.
        taregtColumnIndex = ii;
      }
    }
    tableWidth += colWidth;
    return colWidth;
  });
  if (forMarginLeft) {
    // Both the first column and the table's left margin should resize.
    taregtColumnIndex = 0;
  }
  if (taregtColumnIndex < 0) {
    // Nothing to resize. This happens when the mouse isn't nearby any position
    // that is alllowed to resize a column.
    return null;
  }
  return {
    columnElements: colEls,
    taregtColumnIndex: taregtColumnIndex,
    columnWidths: columnWidths,
    startX: startX,
    tableElement: tableEl,
    tableMarginLeft: tableMarginLeft,
    tableMarginRight: tableMarginRight,
    tableWidth: tableWidth,
    tableWrapperWidth: tableWrapperRect.width
  };
}

// Helper that finds the closest cell element from a given event target.
function domCellAround(target) {
  while (target && target.nodeName !== 'TD' && target.nodeName !== 'TH') {
    target = target.classList.contains('ProseMirror') ? null : target.parentElement;
  }
  return target;
}

// Helper that resolves the prose-mirror node postion of a cell from a given
// event target.
function edgeCell(view, event, side) {
  var _view$posAtCoords = view.posAtCoords({
      left: event.clientX,
      top: event.clientY
    }),
    pos = _view$posAtCoords.pos;
  var $cell = cellAround(view.state.doc.resolve(pos));
  if (!$cell) {
    return -1;
  }
  if (side == 'right') {
    return $cell.pos;
  }
  var map = TableMap.get($cell.node(-1));
  var start = $cell.start(-1);
  var index = map.map.indexOf($cell.pos - start);
  return index % map.width == 0 ? -1 : start + map.map[index - 1];
}

// Update the resize handler (UI) state.
function updateResizeHandle(view, cellPos, forMarginLeft) {
  view.dispatch(view.state.tr.setMeta(PLUGIN_KEY, {
    setCellPos: cellPos,
    setForMarginLeft: forMarginLeft
  }));
}

// Get the decorations that renders the resize handle bars.
function handleDecorations(state, resizeState) {
  if (!resizeState.cellPos) {
    return DecorationSet.create(state.doc, []);
  }
  var decorations = [];
  var $cell = state.doc.resolve(resizeState.cellPos);
  var table = $cell.node(-1);
  var map = TableMap.get(table);
  var start = $cell.start(-1);
  var col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan;
  for (var row = 0; row < map.height; row++) {
    var 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])) {
      var cellPos = map.map[index];
      var pos = start + cellPos + table.nodeAt(cellPos).nodeSize - 1;
      var dom = document.createElement('div');
      var className = 'column-resize-handle';
      if (resizeState.forMarginLeft) {
        className += ' for-margin-left';
      }
      dom.className = className;
      decorations.push(Decoration.widget(pos, dom));
    }
  }
  return DecorationSet.create(state.doc, decorations);
}

// Creates a custom table view that renders the margin-left style.
function createTableView(node, view) {
  // [FS] IRAD-1008 2020-07-16
  // Does not allow Table cell Resize in disable mode
  isEnabled = view.editable;
  return new TableNodeView(node, CELL_MIN_WIDTH, view);
}
function batchMouseHandler(handler) {
  var target = null;
  var clientX = 0;
  var clientY = 0;
  var view = null;
  var onMouseEvent = function onMouseEvent() {
    if (view && target) {
      var pointerEvent = {
        target: target,
        clientX: clientX,
        clientY: clientY
      };
      handler(view, pointerEvent);
    }
  };
  return function (ev, me) {
    target = me.target;
    clientX = me.clientX;
    clientY = me.clientY;
    view = ev;
    requestAnimationFrame(onMouseEvent);
  };
}
function compareNumbersList(one, two) {
  if (one.length !== two.length) {
    return false;
  }
  return !one.some(function (value, index) {
    return two[index] !== value;
  });
}

// Plugin that supports table columns resizing.
var TableResizePlugin = /*#__PURE__*/function (_Plugin) {
  // [FS] IRAD-1005 2020-07-07
  // Upgrade outdated packages.
  //spec: Object;

  function TableResizePlugin() {
    _classCallCheck(this, TableResizePlugin);
    return _callSuper(this, TableResizePlugin, [{
      key: PLUGIN_KEY,
      state: {
        init: function init(_, state) {
          if (!this.spec.props.nodeViews['table']) {
            this.spec.props.nodeViews[tableNodeTypes(state.schema).table.name] = createTableView;
          }
          return new ResizeState(-1, null);
        },
        apply: function apply(tr, prev) {
          return prev.apply(tr);
        }
      },
      props: {
        attributes: function attributes(state) {
          var resizeState = PLUGIN_KEY.getState(state);
          return resizeState.cellPos > -1 ? {
            "class": 'resize-cursor'
          } : null;
        },
        handleDOMEvents: {
          // Move events should be batched to avoid over-handling the mouse
          // event.
          mousemove: batchMouseHandler(handleMouseMove),
          mouseleave: handleMouseLeave,
          mousedown: handleMouseDown
        },
        decorations: function decorations(state) {
          var resizeState = PLUGIN_KEY.getState(state);
          // [FS] IRAD-1008 2020-07-16
          // Does not allow Table cell Resize in disable mode
          return resizeState.cellPos > -1 && isEnabled ? handleDecorations(state, resizeState) : undefined;
        },
        nodeViews: {}
      }
    }]);
  }
  _inherits(TableResizePlugin, _Plugin);
  return _createClass(TableResizePlugin);
}(Plugin);
export { TableResizePlugin as default };