@atlaskit/editor-core 153.1.5 → 157.0.0

package/dist/esm/plugins/paste/util/tinyMCE.js

@@ -0,0 +1,195 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import chunk from 'lodash/chunk';
+
+var isPastedFromTinyMCE = function isPastedFromTinyMCE(pasteEvent) {
+  var _pasteEvent$clipboard, _pasteEvent$clipboard2, _pasteEvent$clipboard3;
+
+  return (_pasteEvent$clipboard = pasteEvent === null || pasteEvent === void 0 ? void 0 : (_pasteEvent$clipboard2 = pasteEvent.clipboardData) === null || _pasteEvent$clipboard2 === void 0 ? void 0 : (_pasteEvent$clipboard3 = _pasteEvent$clipboard2.types) === null || _pasteEvent$clipboard3 === void 0 ? void 0 : _pasteEvent$clipboard3.some(function (mimeType) {
+    return mimeType === 'x-tinymce/html';
+  })) !== null && _pasteEvent$clipboard !== void 0 ? _pasteEvent$clipboard : false;
+};
+
+export var isPastedFromTinyMCEConfluence = function isPastedFromTinyMCEConfluence(pasteEvent, html) {
+  return isPastedFromTinyMCE(pasteEvent) && !!html && !!html.match(/class=\"\s?(confluenceTd|confluenceTh|confluenceTable).+"/gim);
+};
+/**
+ * Wraps html markup with a `<table>` and uses `DOMParser` to generate
+ * and return both the table-wrapped and non-table-wrapped DOM document
+ * instances.
+ */
+
+export var wrapWithTable = function wrapWithTable(html) {
+  var parser = new DOMParser();
+  var nonTableWrappedDoc = parser.parseFromString(html, 'text/html');
+  var tableWrappedDoc = parser.parseFromString("<table>".concat(html, "</table>"), 'text/html');
+  tableWrappedDoc.body.querySelectorAll('meta').forEach(function (meta) {
+    tableWrappedDoc.head.prepend(meta);
+  });
+  return {
+    tableWrappedDoc: tableWrappedDoc,
+    nonTableWrappedDoc: nonTableWrappedDoc
+  };
+};
+
+var exactlyDivisible = function exactlyDivisible(larger, smaller) {
+  return larger % smaller === 0;
+};
+
+var getTableElementsInfo = function getTableElementsInfo(doc) {
+  var cellCount = doc.querySelectorAll('td').length;
+  var thCount = doc.querySelectorAll('th').length;
+  var mergedCellCount = doc.querySelectorAll('td[colspan]:not([colspan="1"])').length;
+  var hasThAfterTd = false;
+  var thsAndCells = doc.querySelectorAll('th,td');
+
+  for (var i = 0, cellFound = false; i < thsAndCells.length; i++) {
+    if (cellFound && thsAndCells[i].nodeName === 'TH') {
+      hasThAfterTd = true;
+      break;
+    }
+
+    if (thsAndCells[i].nodeName === 'TD') {
+      cellFound = true;
+    }
+  }
+
+  var onlyTh = thCount > 0 && cellCount === 0;
+  var onlyCells = cellCount > 0 && thCount === 0;
+  var hasCompleteRow = // we take header-only and cell-only tables to be
+  // row-complete
+  onlyTh || onlyCells || // if headers and cells can "fit" against each other,
+  // then we assume a complete row exists
+  (exactlyDivisible(thCount, cellCount) || exactlyDivisible(cellCount, thCount)) && // all numbers are divisible by 1, so we carve out a specific
+  // check for when there is only 1 table cell, and more than 1
+  // table header.
+  !(thCount > 1 && cellCount === 1);
+  return {
+    cellCount: cellCount,
+    thCount: thCount,
+    mergedCellCount: mergedCellCount,
+    hasThAfterTd: hasThAfterTd,
+    hasIncompleteRow: !hasCompleteRow
+  };
+};
+
+var configureTableRows = function configureTableRows(doc, colsInRow) {
+  var _Array$from;
+
+  var tableHeadersAndCells = Array.from(doc.body.querySelectorAll('th,td'));
+  var evenlySplitChunks = chunk(tableHeadersAndCells, colsInRow);
+  var tableBody = doc.body.querySelector('tbody');
+  evenlySplitChunks.forEach(function (chunk) {
+    var tr = doc.createElement('tr');
+    tableBody === null || tableBody === void 0 ? void 0 : tableBody.append(tr);
+    tr.append.apply(tr, _toConsumableArray(chunk));
+  }); // We remove any leftover empty rows which may cause fabric editor
+  // to no-op when parsing the table
+
+  var emptyRows = (_Array$from = Array.from(tableBody.querySelectorAll('tr'))) === null || _Array$from === void 0 ? void 0 : _Array$from.filter(function (row) {
+    return row.innerHTML.trim().length === 0;
+  });
+  emptyRows.forEach(function (row) {
+    return row.remove();
+  });
+  return doc.body.innerHTML;
+};
+
+var fillIncompleteRowWithEmptyCells = function fillIncompleteRowWithEmptyCells(doc, thCount, cellCount) {
+  var _lastCell$parentEleme;
+
+  var extraCellsCount = 0;
+
+  while (!exactlyDivisible(cellCount + extraCellsCount, thCount)) {
+    extraCellsCount++;
+  }
+
+  var extraEmptyCells = Array.from(Array(extraCellsCount)).map(function () {
+    return doc.createElement('td');
+  });
+  var lastCell = doc.body.querySelector('td:last-of-type');
+  lastCell === null || lastCell === void 0 ? void 0 : (_lastCell$parentEleme = lastCell.parentElement) === null || _lastCell$parentEleme === void 0 ? void 0 : _lastCell$parentEleme.append.apply(_lastCell$parentEleme, _toConsumableArray(extraEmptyCells));
+  return {
+    updatedCellCount: cellCount + extraCellsCount
+  };
+};
+/**
+ * Given a DOM document, it will try to rebuild table rows by using the
+ * table headers count as an initial starting point for the assumed
+ * number of columns that make up a row (`colsInRow`). It will slowly
+ * decrease that `colsInRow` count until it finds exact fit for table
+ * headers and cells with `colsInRow` else it returns the original
+ * document's markup.
+ *
+ * NOTE: It will NOT try to rebuild table rows if it encounters merged cells
+ * or compex table configurations (where table headers exist after normal
+ * table cells). It will build a single column table if NO table
+ * headers exist.
+ */
+
+
+export var tryReconstructTableRows = function tryReconstructTableRows(doc) {
+  var _getTableElementsInfo = getTableElementsInfo(doc),
+      cellCount = _getTableElementsInfo.cellCount,
+      thCount = _getTableElementsInfo.thCount,
+      mergedCellCount = _getTableElementsInfo.mergedCellCount,
+      hasThAfterTd = _getTableElementsInfo.hasThAfterTd,
+      hasIncompleteRow = _getTableElementsInfo.hasIncompleteRow;
+
+  if (mergedCellCount || hasThAfterTd) {
+    // bail out to avoid handling more complex table structures
+    return doc.body.innerHTML;
+  }
+
+  if (!thCount) {
+    // if no table headers exist for reference, fallback to a single column table structure
+    return configureTableRows(doc, 1);
+  }
+
+  if (hasIncompleteRow) {
+    // if shift-click selection copies a partial table row to the clipboard,
+    // and we do have table headers for reference, then we add empty table cells
+    // to fill out the partial row
+    var _fillIncompleteRowWit = fillIncompleteRowWithEmptyCells(doc, thCount, cellCount),
+        updatedCellCount = _fillIncompleteRowWit.updatedCellCount;
+
+    cellCount = updatedCellCount;
+  }
+
+  for (var possibleColsInRow = thCount; possibleColsInRow > 0; possibleColsInRow--) {
+    if (exactlyDivisible(thCount, possibleColsInRow) && exactlyDivisible(cellCount, possibleColsInRow)) {
+      return configureTableRows(doc, possibleColsInRow);
+    }
+  }
+
+  return doc.body.innerHTML;
+};
+export var htmlHasIncompleteTable = function htmlHasIncompleteTable(html) {
+  return !html.includes('<table ') && (html.includes('<td ') || html.includes('<th '));
+};
+/**
+ * Strictly for ED-7331. Given incomplete table html from tinyMCE, it will try to rebuild
+ * a whole valid table. If it rebuilds the table, it may first rebuild it as a single
+ * row table, so this also then tries to reconstruct the table rows/columns if
+ * possible (best effort).
+ */
+
+export var tryRebuildCompleteTableHtml = function tryRebuildCompleteTableHtml(incompleteTableHtml) {
+  // first we try wrapping the table elements with <table> and let DOMParser try to rebuild
+  // a valid DOM tree. we also keep the non-wrapped table for comparison purposes.
+  var _wrapWithTable = wrapWithTable(incompleteTableHtml),
+      nonTableWrappedDoc = _wrapWithTable.nonTableWrappedDoc,
+      tableWrappedDoc = _wrapWithTable.tableWrappedDoc;
+
+  var didPreserveTableElements = Boolean(!nonTableWrappedDoc.body.querySelector('th, td') && tableWrappedDoc.body.querySelector('th, td'));
+  var isExpectedStructure = tableWrappedDoc.querySelectorAll('body > table:only-child') && !tableWrappedDoc.querySelector("body > table > tbody > tr > :not(th,td)"); // if DOMParser saves table elements that we would otherwise lose, and
+  // if the table html is what we'd expect (a single table, with no extraneous
+  // elements in table rows other than th, td), then we can now also try to
+  // rebuild table rows/columns.
+
+  if (didPreserveTableElements && isExpectedStructure) {
+    var completeTableHtml = tryReconstructTableRows(tableWrappedDoc);
+    return completeTableHtml;
+  }
+
+  return null;
+};

package/dist/esm/plugins/placeholder/index.js

@@ -1,4 +1,5 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import { DecorationSet, Decoration } from 'prosemirror-view';
 import { isInEmptyLine, isEmptyDocument, bracketTyped } from '../../utils/document';
 import { pluginKey as alignmentPluginKey } from '../alignment/pm-plugins/main';
@@ -93,7 +94,7 @@ export function createPlugin(defaultPlaceholderText, placeholderHints, bracketPl
   }
 
   var getPlaceholderHintMessage = createGetPlaceholderHintMessage(placeholderHints);
-  return new Plugin({
+  return new SafePlugin({
     key: pluginKey,
     state: {
       init: function init(_, state) {

package/dist/esm/plugins/placeholder-text/index.js

@@ -1,5 +1,6 @@
 import React from 'react';
-import { NodeSelection, Plugin, TextSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { placeholder } from '@atlaskit/adf-schema';
 import MediaServicesTextIcon from '@atlaskit/icon/glyph/media-services/text';
 import WithPluginState from '../../ui/WithPluginState';
@@ -13,7 +14,7 @@ import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, addAnalytics, EVENT_TYPE, IN
 import { messages } from '../insert-block/ui/ToolbarInsertBlock/messages';
 export function createPlugin(dispatch, options) {
   var allowInserting = !!options.allowInserting;
-  return new Plugin({
+  return new SafePlugin({
     key: pluginKey,
     state: {
       init: function init() {

package/dist/esm/plugins/quick-insert/index.js

@@ -7,7 +7,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import React from 'react';
-import { Plugin } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import memoizeOne from 'memoize-one';
 import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
 import { pluginKey } from './plugin-key';
@@ -115,7 +115,7 @@ var setProviderState = function setProviderState(providerState) {
 };
 
 function quickInsertPluginFactory(quickInsertItems, providerFactory, getIntl, dispatch, emptyStateHandler) {
-  return new Plugin({
+  return new SafePlugin({
     key: pluginKey,
     state: {
       init: function init() {

package/dist/esm/plugins/rank.js

@@ -11,6 +11,6 @@ export default {
   marks: [// Fragment mark is both for inline and block elements
   'fragment', // Inline marks
   'link', 'em', 'strong', 'textColor', 'strike', 'subsup', 'underline', 'code', 'typeAheadQuery', // Block marks
-  'alignment', 'breakout', 'indentation', 'annotation', //Unsupported mark
+  'alignment', 'breakout', 'indentation', 'annotation', 'dataConsumer', // Unsupported mark
   'unsupportedMark', 'unsupportedNodeAttribute']
 };

package/dist/esm/plugins/scroll-into-view/index.js

@@ -1,4 +1,5 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import { TEXT_INPUT_RULE_TRANSACTION_KEY } from '@atlaskit/prosemirror-input-rules';
 /**
  * Plugin to scroll the user's selection into view whenever the user updates
@@ -13,7 +14,7 @@ import { TEXT_INPUT_RULE_TRANSACTION_KEY } from '@atlaskit/prosemirror-input-rul
 export var scrollIntoViewPluginKey = new PluginKey('scrollIntoViewPlugin');
 
 var createPlugin = function createPlugin() {
-  return new Plugin({
+  return new SafePlugin({
     key: scrollIntoViewPluginKey,
     appendTransaction: function appendTransaction(transactions, oldState, newState) {
       if (!transactions.length) {

package/dist/esm/plugins/selection/pm-plugins/gap-cursor-main.js

@@ -1,4 +1,5 @@
-import { Plugin, NodeSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection } from 'prosemirror-state';
 import { Decoration, DecorationSet } from 'prosemirror-view';
 import { findPositionOfNodeBefore } from 'prosemirror-utils';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
@@ -9,7 +10,7 @@ import { toDOM } from '../gap-cursor/utils/place-gap-cursor';
 import { deleteNode, setGapCursorAtPos } from '../gap-cursor/actions';
 import { Direction } from '../gap-cursor/direction';
 import { gapCursorPluginKey } from './gap-cursor-plugin-key';
-var plugin = new Plugin({
+var plugin = new SafePlugin({
   key: gapCursorPluginKey,
   state: {
     init: function init() {

package/dist/esm/plugins/selection/pm-plugins/selection-main.js

@@ -1,4 +1,5 @@
-import { Plugin, NodeSelection, TextSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { browser } from '@atlaskit/editor-common/utils';
 import { createPluginState, getPluginState } from '../plugin-factory';
 import { selectionPluginKey } from '../types';
@@ -35,7 +36,7 @@ var toggleContentEditable = function toggleContentEditable(node) {
 
 export var createPlugin = function createPlugin(dispatch, dispatchAnalyticsEvent) {
   var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  return new Plugin({
+  return new SafePlugin({
     key: selectionPluginKey,
     state: createPluginState(dispatch, getInitialState),
     view: function view() {

package/dist/esm/plugins/status/nodeviews/status.js

@@ -20,7 +20,6 @@ import styled from 'styled-components';
 import { ZERO_WIDTH_SPACE } from '@atlaskit/editor-common/utils';
 import { Status } from '@atlaskit/status/element';
 import { ReactNodeView } from '../../../nodeviews';
-import InlineNodeWrapper, { createMobileInlineDomRef } from '../../../ui/InlineNodeWrapper';
 import { messages } from './messages';
 export var StyledStatus = styled.span(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  opacity: ", ";\n"])), function (props) {
   return props.placeholderStyle ? 0.5 : 1;
@@ -90,10 +89,6 @@ export var StatusNodeView = /*#__PURE__*/function (_ReactNodeView) {
   _createClass(StatusNodeView, [{
     key: "createDomRef",
     value: function createDomRef() {
-      if (this.reactComponentProps.options && this.reactComponentProps.options.useInlineWrapper) {
-        return createMobileInlineDomRef();
-      }
-
       return _get(_getPrototypeOf(StatusNodeView.prototype), "createDomRef", this).call(this);
     }
   }, {
@@ -116,9 +111,7 @@ export var StatusNodeView = /*#__PURE__*/function (_ReactNodeView) {
           color = _this$node$attrs.color,
           localId = _this$node$attrs.localId,
           style = _this$node$attrs.style;
-      return /*#__PURE__*/React.createElement(InlineNodeWrapper, {
-        useInlineWrapper: options && options.useInlineWrapper
-      }, options && options.allowZeroWidthSpaceAfter && ZERO_WIDTH_SPACE, /*#__PURE__*/React.createElement(IntlStatusContainerView, {
+      return /*#__PURE__*/React.createElement(React.Fragment, null, options && options.allowZeroWidthSpaceAfter && ZERO_WIDTH_SPACE, /*#__PURE__*/React.createElement(IntlStatusContainerView, {
         view: this.view,
         text: text,
         color: color,

package/dist/esm/plugins/status/plugin.js

@@ -4,14 +4,15 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-import { NodeSelection, Plugin, TextSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from 'prosemirror-state';
 import statusNodeView from './nodeviews/status';
 import { pluginKey } from './plugin-key';
 import { isEmptyStatus, mayGetStatusAtSelection } from './utils';
 export { pluginKey, pluginKeyName } from './plugin-key';
 
 var createPlugin = function createPlugin(dispatch, portalProviderAPI, eventDispatcher, options) {
-  return new Plugin({
+  return new SafePlugin({
     state: {
       init: function init() {
         return {

package/dist/esm/plugins/status/ui/statusPicker.js

@@ -227,8 +227,7 @@ export var StatusPickerWithoutAnalytcs = /*#__PURE__*/function (_React$Component
           target = _this$props.target;
       var _this$state3 = this.state,
           color = _this$state3.color,
-          text = _this$state3.text,
-          localId = _this$state3.localId;
+          text = _this$state3.text;
       return target && /*#__PURE__*/React.createElement(PopupWithListeners, {
         target: target,
         offset: [0, 8],
@@ -245,8 +244,7 @@ export var StatusPickerWithoutAnalytcs = /*#__PURE__*/function (_React$Component
         onColorClick: this.onColorClick,
         onColorHover: this.onColorHover,
         onTextChanged: this.onTextChanged,
-        onEnter: this.onEnter,
-        localId: localId
+        onEnter: this.onEnter
       })));
     }
   }]);

package/dist/esm/plugins/table/commands/misc.js

@@ -259,8 +259,19 @@ export var moveCursorBackward = function moveCursorBackward(state, dispatch) {
   // it doesn't join node before (last cell) with node after (content after the cursor)
   // due to ridiculous amount of PM code that would have been required to overwrite
 
+  tr.setSelection(new TextSelection(state.doc.resolve(pos))); // if we are inside an empty paragraph not at the end of the doc we delete it
+
+  var cursorNode = $cursor.node();
+  var docEnd = state.doc.content.size;
+  var paragraphWrapStart = $cursor.pos - 1;
+  var paragraphWrapEnd = $cursor.pos + 1;
+
+  if (cursorNode.content.size === 0 && $cursor.pos + 1 !== docEnd) {
+    tr.delete(paragraphWrapStart, paragraphWrapEnd);
+  }
+
   if (dispatch) {
-    dispatch(tr.setSelection(new TextSelection(state.doc.resolve(pos))));
+    dispatch(tr);
   }
 
   return true;

package/dist/esm/plugins/table/index.js

@@ -222,7 +222,8 @@ var tablesPlugin = function tablesPlugin(options) {
             targetRef: tableWrapperTarget,
             layout: layout,
             isResizing: !!resizingPluginState && !!resizingPluginState.dragging,
-            tableWidth: tableRenderOptimization ? tableWidth : undefined
+            tableWidth: tableRenderOptimization ? tableWidth : undefined,
+            stickyHeader: stickyHeader
           }));
         }
       }));

package/dist/esm/plugins/table/nodeviews/TableComponent.js

@@ -43,24 +43,6 @@ var NOOP = function NOOP() {
   return undefined;
 };
 
-// in Chrome, if none of the parent elements
-// have content, then it will auto-scroll the container
-// which interferes with us applying padding to the
-// sticky header to make up for us taking it out of
-// the layout flow.
-//
-// this is only an issue when scrolling down the
-// page without row controls active, and doesn't
-// occur in other browsers afaik
-var FloatingPlaceholder = function FloatingPlaceholder() {
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      position: 'absolute',
-      top: '30px'
-    }
-  }, ' ');
-};
-
 var TableComponent = /*#__PURE__*/function (_React$Component) {
   _inherits(TableComponent, _React$Component);
 
@@ -562,7 +544,7 @@ var TableComponent = /*#__PURE__*/function (_React$Component) {
         "data-layout": node.attrs.layout
       }, stickyHeadersOptimization && /*#__PURE__*/React.createElement("div", {
         className: ClassName.TABLE_STICKY_SENTINEL_TOP
-      }), /*#__PURE__*/React.createElement(FloatingPlaceholder, null), allowControls && (!isLoading || initialRenderOptimization) && rowControls, /*#__PURE__*/React.createElement("div", {
+      }), allowControls && (!isLoading || initialRenderOptimization) && rowControls, /*#__PURE__*/React.createElement("div", {
         style: shadowStyle(showBeforeShadow),
         className: ClassName.TABLE_LEFT_SHADOW
       }), this.state.stickyHeader && /*#__PURE__*/React.createElement("div", {

package/dist/esm/plugins/table/pm-plugins/decorations/plugin.js

@@ -1,4 +1,5 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { DecorationSet } from 'prosemirror-view';
 import { pluginKey as tablePluginKey } from '../plugin-factory';
@@ -27,7 +28,7 @@ export var handleDocOrSelectionChanged = function handleDocOrSelectionChanged(tr
   return decorationSet;
 };
 export var createPlugin = function createPlugin() {
-  return new Plugin({
+  return new SafePlugin({
     state: {
       init: function init() {
         return DecorationSet.empty;

package/dist/esm/plugins/table/pm-plugins/main.js

@@ -4,7 +4,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-import { Plugin } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { findParentDomRefOfType, findParentNodeOfType } from 'prosemirror-utils';
 import { findTable } from '@atlaskit/editor-tables/utils';
 import { browser } from '@atlaskit/editor-common/utils';
@@ -59,7 +59,7 @@ export var createPlugin = function createPlugin(dispatchAnalyticsEvent, dispatch
   } : {}; // Used to prevent invalid table cell spans being reported more than once per editor/document
 
   var invalidTableIds = [];
-  return new Plugin({
+  return new SafePlugin({
     state: state,
     key: pluginKey,
     appendTransaction: function appendTransaction(transactions, oldState, newState) {

package/dist/esm/plugins/table/pm-plugins/safari-delayed-dom-selection-syncing-workaround.js

@@ -1,4 +1,5 @@
-import { PluginKey, Plugin } from 'prosemirror-state';
+import { PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 export var tableSafariDelayedDomSelectionSyncingWorkaroundKey = new PluginKey('tableSafariDelayedDomSelectionSyncingWorkaround');
 export var createPlugin = function createPlugin() {
   // From a review of the prosemirror-view source code,
@@ -11,7 +12,7 @@ export var createPlugin = function createPlugin() {
   // Because we are manually wiping the view.mouseDown,
   // we manage this custom cleanup ourselves
   var prevMouseDownDone = null;
-  return new Plugin({
+  return new SafePlugin({
     key: tableSafariDelayedDomSelectionSyncingWorkaroundKey,
     props: {
       handleDOMEvents: {