@contentful/field-editor-rich-text 2.0.0-next.1 → 2.0.0-next.2

package/dist/field-editor-rich-text.cjs.development.js

@@ -17,23 +17,14 @@ var f36Components = require('@contentful/f36-components');
 var Slate = require('slate-react');
 var f36Icons = require('@contentful/f36-icons');
 var slate = require('slate');
-var plateCore = require('@udecode/plate-core');
-var plateCommon = require('@udecode/plate-common');
+var plate = require('@udecode/plate');
 var constate = _interopDefault(require('constate'));
 var find = _interopDefault(require('lodash/find'));
 var flow = _interopDefault(require('lodash/flow'));
 var get = _interopDefault(require('lodash/get'));
-var plateList = require('@udecode/plate-list');
-var richTextPlainTextRenderer = require('@contentful/rich-text-plain-text-renderer');
 var fieldEditorShared = require('@contentful/field-editor-shared');
 var mimetype = _interopDefault(require('@contentful/mimetype'));
-var plateTable = require('@udecode/plate-table');
-var plateAstSerializer = require('@udecode/plate-ast-serializer');
-var plateHtmlSerializer = require('@udecode/plate-html-serializer');
-var plateParagraph = require('@udecode/plate-paragraph');
-var plateBreak = require('@udecode/plate-break');
 var values = _interopDefault(require('lodash/values'));
-var plateTrailingBlock = require('@udecode/plate-trailing-block');
 var PropTypes = _interopDefault(require('prop-types'));
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -569,7 +560,7 @@ function unwrapFromRoot(editor) {
 var isAtEndOfTextSelection = function isAtEndOfTextSelection(editor) {
   var _editor$selection, _editor$selection2;
 
-  return ((_editor$selection = editor.selection) == null ? void 0 : _editor$selection.focus.offset) === plateCommon.getText(editor, (_editor$selection2 = editor.selection) == null ? void 0 : _editor$selection2.focus.path).length;
+  return ((_editor$selection = editor.selection) == null ? void 0 : _editor$selection.focus.offset) === plate.getText(editor, (_editor$selection2 = editor.selection) == null ? void 0 : _editor$selection2.focus.path).length;
 };
 function currentSelectionStartsTableCell(editor) {
   var _editor$selection3;
@@ -578,7 +569,7 @@ function currentSelectionStartsTableCell(editor) {
       tableCellNode = _getNodeEntryFromSele2[0],
       path = _getNodeEntryFromSele2[1];
 
-  return !!tableCellNode && (!plateCommon.getText(editor, path) || ((_editor$selection3 = editor.selection) == null ? void 0 : _editor$selection3.focus.offset) === 0);
+  return !!tableCellNode && (!plate.getText(editor, path) || ((_editor$selection3 = editor.selection) == null ? void 0 : _editor$selection3.focus.offset) === 0);
 }
 /**
  * This traversal strategy is unfortunately necessary because Slate doesn't
@@ -617,12 +608,39 @@ function currentSelectionPrecedesTableCell(editor) {
   var nextNode = getNextNode(editor);
   return !!nextNode && Contentful.TABLE_BLOCKS.includes(nextNode.type) && isAtEndOfTextSelection(editor);
 }
+var replaceNode = function replaceNode(editor, path, replacement) {
+  slate.Transforms.removeNodes(editor, {
+    at: path
+  });
+  slate.Transforms.insertNodes(editor, replacement, {
+    at: path
+  });
+};
+/**
+ * It filters out all paragraphs and headings from a path and convert them into paragraphs.
+ */
+
+function extractParagraphsAt(editor, path) {
+  var paragraphs = Array.from(slate.Editor.nodes(editor, {
+    at: path,
+    match: function match(node) {
+      return Contentful.TEXT_CONTAINERS.includes(node.type);
+    },
+    mode: 'all'
+  })).map(function (_ref2) {
+    var node = _ref2[0];
+    return _extends({}, node, {
+      type: Contentful.BLOCKS.PARAGRAPH
+    });
+  });
+  return paragraphs;
+}
 
 function deserializeLeaf(type, rules) {
   return function (editor) {
-    var pluginOptions = plateCore.getPlatePluginOptions(editor, type);
+    var pluginOptions = plate.getPlatePluginOptions(editor, type);
     return {
-      leaf: plateCommon.getLeafDeserializer(_extends({
+      leaf: plate.getLeafDeserializer(_extends({
         type: type,
         rules: rules
       }, pluginOptions.deserialize))
@@ -631,9 +649,9 @@ function deserializeLeaf(type, rules) {
 }
 function deserializeElement(type, rules) {
   return function (editor) {
-    var pluginOptions = plateCore.getPlatePluginOptions(editor, type);
+    var pluginOptions = plate.getPlatePluginOptions(editor, type);
     return {
-      element: plateCommon.getElementDeserializer(_extends({
+      element: plate.getElementDeserializer(_extends({
         type: type,
         rules: rules
       }, pluginOptions.deserialize))
@@ -651,7 +669,7 @@ function getContentfulEditorId(sdk) {
 function useContentfulEditorHook(_ref) {
   var sdk = _ref.sdk;
   var editorId = getContentfulEditorId(sdk);
-  var editor = plateCore.usePlateEditorRef(editorId);
+  var editor = plate.usePlateEditorRef(editorId);
   return editor;
 }
 
@@ -708,8 +726,8 @@ function ToolbarHrButton(props) {
       }],
       isVoid: true
     };
-    var hasText = !!plateCommon.getText(editor, editor.selection.focus.path);
-    hasText ? slate.Transforms.insertNodes(editor, hr) : plateCommon.setNodes(editor, hr); // Move focus to the next paragraph (added by TrailingParagraph plugin)
+    var hasText = !!plate.getText(editor, editor.selection.focus.path);
+    hasText ? slate.Transforms.insertNodes(editor, hr) : plate.setNodes(editor, hr); // Move focus to the next paragraph (added by TrailingParagraph plugin)
 
     moveToTheNextLine(editor);
     Slate.ReactEditor.focus(editor);
@@ -737,10 +755,10 @@ function Hr(props) {
 }
 function createHrPlugin() {
   return {
-    renderElement: plateCore.getRenderElement(Contentful.BLOCKS.HR),
+    renderElement: plate.getRenderElement(Contentful.BLOCKS.HR),
     pluginKeys: Contentful.BLOCKS.HR,
     onKeyDown: withHrEvents,
-    voidTypes: plateCore.getPlatePluginTypes(Contentful.BLOCKS.HR),
+    voidTypes: plate.getPlatePluginTypes(Contentful.BLOCKS.HR),
     deserialize: deserializeElement(Contentful.BLOCKS.HR, [{
       nodeNames: ['HR']
     }])
@@ -842,19 +860,19 @@ function withHeadingEvents(editor) {
         var cursorIsAtTheEnd = currentTextLength === currentOffset;
 
         if (cursorIsAtTheBeginning) {
-          plateCommon.insertNodes(editor, paragraph, {
+          plate.insertNodes(editor, paragraph, {
             at: editor.selection
           });
         } else if (cursorIsAtTheEnd) {
-          plateCommon.insertNodes(editor, paragraph);
+          plate.insertNodes(editor, paragraph);
         } else {
           // Otherwise the cursor is in the middle
           slate.Transforms.splitNodes(editor);
-          plateCommon.setNodes(editor, paragraph);
+          plate.setNodes(editor, paragraph);
         }
       } else {
-        plateCommon.setNodes(editor, paragraph);
-        plateCommon.insertNodes(editor, heading);
+        plate.setNodes(editor, paragraph);
+        plate.insertNodes(editor, heading);
       }
     } // Toggle heading blocks when pressing cmd/ctrl+alt+1|2|3|4|5|6
 
@@ -878,7 +896,7 @@ function withHeadingEvents(editor) {
         unwrapFromRoot(editor);
       }
 
-      plateCommon.toggleNodeType(editor, {
+      plate.toggleNodeType(editor, {
         activeType: headingKey,
         inactiveType: Contentful.BLOCKS.PARAGRAPH
       });
@@ -929,7 +947,7 @@ function ToolbarHeadingButton(props) {
         unwrapFromRoot(editor);
       }
 
-      plateCommon.toggleNodeType(editor, {
+      plate.toggleNodeType(editor, {
         activeType: type,
         inactiveType: type
       }); // TODO: Figure out why focus only works with timeout here.
@@ -979,18 +997,18 @@ var H1 = /*#__PURE__*/createHeading('h1', Contentful.BLOCKS.HEADING_1);
 var H2 = /*#__PURE__*/createHeading('h2', Contentful.BLOCKS.HEADING_2);
 var H3 = /*#__PURE__*/createHeading('h3', Contentful.BLOCKS.HEADING_3);
 var H4 = /*#__PURE__*/createHeading('h4', Contentful.BLOCKS.HEADING_4);
-var H5 = /*#__PURE__*/createHeading('h1', Contentful.BLOCKS.HEADING_5);
-var H6 = /*#__PURE__*/createHeading('h1', Contentful.BLOCKS.HEADING_6);
+var H5 = /*#__PURE__*/createHeading('h5', Contentful.BLOCKS.HEADING_5);
+var H6 = /*#__PURE__*/createHeading('h6', Contentful.BLOCKS.HEADING_6);
 function createHeadingPlugin() {
   var headings = [Contentful.BLOCKS.HEADING_1, Contentful.BLOCKS.HEADING_2, Contentful.BLOCKS.HEADING_3, Contentful.BLOCKS.HEADING_4, Contentful.BLOCKS.HEADING_5, Contentful.BLOCKS.HEADING_6];
   return {
-    renderElement: plateCore.getRenderElement(headings),
+    renderElement: plate.getRenderElement(headings),
     pluginKeys: headings,
     onKeyDown: withHeadingEvents,
     deserialize: function deserialize(editor) {
       return {
         element: headings.map(function (headingType, index) {
-          var options = plateCore.getPlatePluginOptions(editor, headingType);
+          var options = plate.getPlatePluginOptions(editor, headingType);
           return _extends({
             type: headingType,
             deserialize: function deserialize(element) {
@@ -1132,7 +1150,7 @@ function Quote(props) {
 function createQuotePlugin() {
   return {
     pluginKeys: Contentful.BLOCKS.QUOTE,
-    renderElement: plateCore.getRenderElement(Contentful.BLOCKS.QUOTE),
+    renderElement: plate.getRenderElement(Contentful.BLOCKS.QUOTE),
     onKeyDown: withQuoteEvents,
     deserialize: deserializeElement(Contentful.BLOCKS.QUOTE, [{
       nodeNames: 'BLOCKQUOTE'
@@ -1148,20 +1166,11 @@ var withQuoteOptions = (_withQuoteOptions = {}, _withQuoteOptions[Contentful.BLO
  * A copy of Plate's list plugin with a few adjustments
  * to fix pasting text inside lists.
  */
-
-var slateNodesToText = function slateNodesToText(nodes) {
-  var contentfulNode = contentfulSlatejsAdapter.toContentfulDocument({
-    document: nodes,
-    schema: schema
-  });
-  return richTextPlainTextRenderer.documentToPlainTextString(contentfulNode);
-};
-
 var getListInsertFragment = function getListInsertFragment(editor) {
   var insertFragment = editor.insertFragment;
-  var li = plateCore.getPlatePluginOptions(editor, plateList.ELEMENT_LI);
-  var ul = plateCore.getPlatePluginOptions(editor, plateList.ELEMENT_UL);
-  var ol = plateCore.getPlatePluginOptions(editor, plateList.ELEMENT_OL);
+  var li = plate.getPlatePluginOptions(editor, plate.ELEMENT_LI);
+  var ul = plate.getPlatePluginOptions(editor, plate.ELEMENT_UL);
+  var ol = plate.getPlatePluginOptions(editor, plate.ELEMENT_OL);
 
   var isListRoot = function isListRoot(node) {
     return [ul.type, ol.type].includes(node.type);
@@ -1198,7 +1207,7 @@ var getListInsertFragment = function getListInsertFragment(editor) {
   };
 
   return function (fragment) {
-    var liEntry = plateCommon.findNode(editor, {
+    var liEntry = plate.findNode(editor, {
       match: {
         type: li.type
       },
@@ -1212,10 +1221,7 @@ var getListInsertFragment = function getListInsertFragment(editor) {
       var nodes = fragment.flatMap(function (node) {
         return trimList(node);
       });
-      var text = slateNodesToText(nodes);
-      return slate.Transforms.insertNodes(editor, [{
-        text: text
-      }], {
+      return slate.Transforms.insertNodes(editor, nodes, {
         at: editor.selection || slate.Path.next(liPath),
         select: true
       });
@@ -1241,7 +1247,7 @@ function ToolbarListButton(props) {
         unwrapFromRoot(editor);
       }
 
-      plateList.toggleList(editor, {
+      plate.toggleList(editor, {
         type: type
       });
       Slate.ReactEditor.focus(editor);
@@ -1275,21 +1281,103 @@ function createList(Tag, block) {
 var UL = /*#__PURE__*/createList('ul', Contentful.BLOCKS.UL_LIST);
 var OL = /*#__PURE__*/createList('ol', Contentful.BLOCKS.OL_LIST);
 var LI = /*#__PURE__*/createList('li', Contentful.BLOCKS.LIST_ITEM);
-var withListOptions = (_withListOptions = {}, _withListOptions[plateList.ELEMENT_LIC] = {
+var withListOptions = (_withListOptions = {}, _withListOptions[plate.ELEMENT_LIC] = {
   type: Contentful.BLOCKS.PARAGRAPH
-}, _withListOptions[plateList.ELEMENT_LI] = {
+}, _withListOptions[plate.ELEMENT_LI] = {
   type: Contentful.BLOCKS.LIST_ITEM,
   component: LI
-}, _withListOptions[plateList.ELEMENT_UL] = {
+}, _withListOptions[plate.ELEMENT_UL] = {
   type: Contentful.BLOCKS.UL_LIST,
   component: UL
-}, _withListOptions[plateList.ELEMENT_OL] = {
+}, _withListOptions[plate.ELEMENT_OL] = {
   type: Contentful.BLOCKS.OL_LIST,
   component: OL
 }, _withListOptions);
 
+var emptyNodeOfType = function emptyNodeOfType(type) {
+  return {
+    type: type,
+    children: [],
+    data: {}
+  };
+};
+
+var isList = function isList(node) {
+  return [Contentful.BLOCKS.OL_LIST, Contentful.BLOCKS.UL_LIST].includes(node.type);
+};
+
+var isListItem = function isListItem(node) {
+  return node.type === Contentful.BLOCKS.LIST_ITEM;
+};
+
+var hasListAsDirectParent = function hasListAsDirectParent(editor, path) {
+  var _ref = plate.getParent(editor, path) || [],
+      parentNode = _ref[0];
+
+  return isList(parentNode);
+};
+
+var isValidInsideListItem = function isValidInsideListItem(node) {
+  return slate.Text.isText(node) || Contentful.LIST_ITEM_BLOCKS.concat(Object.values(Contentful.INLINES)).includes(node.type);
+};
+
+var replaceInvalidListItemWithText = function replaceInvalidListItemWithText(editor, path) {
+  var textFromEntry = extractParagraphsAt(editor, path);
+  replaceNode(editor, path, textFromEntry);
+};
+/**
+ * Ensures each list item follows the list schema.
+ * Returns true if the list needed to have been normalized.
+ */
+
+
+var normalizeList = function normalizeList(editor, path) {
+  for (var _iterator = _createForOfIteratorHelperLoose(slate.Node.children(editor, path)), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        child = _step$value[0],
+        childPath = _step$value[1];
+
+    if (slate.Element.isElement(child) && !isListItem(child)) {
+      slate.Transforms.wrapNodes(editor, emptyNodeOfType(Contentful.BLOCKS.LIST_ITEM), {
+        at: childPath
+      });
+      return true;
+    }
+  }
+
+  return false;
+};
+
+var getNearestListAncestor = function getNearestListAncestor(editor, path) {
+  return plate.getAbove(editor, {
+    at: path,
+    mode: 'lowest',
+    match: isList
+  }) || [];
+};
+/**
+ * Places orphaned list items in a list. If there's a list somewhere
+ * in the node's ancestors, defaults to that list type, else places
+ * the list item in an unordered list.
+ */
+
+
+var normalizeOrphanedListItem = function normalizeOrphanedListItem(editor, path) {
+  var _getNearestListAncest = getNearestListAncestor(editor, path),
+      parentList = _getNearestListAncest[0];
+
+  var parentListType = parentList == null ? void 0 : parentList.type;
+  slate.Transforms.wrapNodes(editor, {
+    type: parentListType || Contentful.BLOCKS.UL_LIST,
+    children: [],
+    data: {}
+  }, {
+    at: path
+  });
+};
+
 var withCustomList = function withCustomList(options) {
-  var withDefaultOverrides = plateList.withList(options);
+  var withDefaultOverrides = plate.withList(options);
   return function (editor) {
     var insertFragment = editor.insertFragment;
     withDefaultOverrides(editor); // Reverts any overrides to insertFragment
@@ -1297,6 +1385,52 @@ var withCustomList = function withCustomList(options) {
     editor.insertFragment = insertFragment; // Use our custom getListInsertFragment
 
     editor.insertFragment = getListInsertFragment(editor);
+    var normalizeNode = editor.normalizeNode;
+
+    editor.normalizeNode = function (entry) {
+      var node = entry[0],
+          path = entry[1];
+
+      if (isList(node)) {
+        if (normalizeList(editor, path)) {
+          return;
+        }
+      } else if (isListItem(node)) {
+        if (!hasListAsDirectParent(editor, path)) {
+          normalizeOrphanedListItem(editor, path);
+          return;
+        }
+
+        var listItemChildren = Array.from(slate.Node.children(editor, path)); // Handle list items with no paragraph/text
+
+        if (listItemChildren.length === 0) {
+          slate.Transforms.insertNodes(editor, [{
+            type: Contentful.BLOCKS.PARAGRAPH,
+            data: {},
+            children: [{
+              text: ''
+            }]
+          }], {
+            at: path.concat([0])
+          });
+          return;
+        }
+
+        for (var _i = 0, _listItemChildren = listItemChildren; _i < _listItemChildren.length; _i++) {
+          var _listItemChildren$_i = _listItemChildren[_i],
+              child = _listItemChildren$_i[0],
+              childPath = _listItemChildren$_i[1];
+
+          if (slate.Element.isElement(child) && !isValidInsideListItem(child)) {
+            replaceInvalidListItemWithText(editor, childPath);
+            return;
+          }
+        }
+      }
+
+      normalizeNode(entry);
+    };
+
     return editor;
   };
 };
@@ -1305,7 +1439,7 @@ var createListPlugin = function createListPlugin() {
   var options = {
     validLiChildrenTypes: Contentful.LIST_ITEM_BLOCKS
   };
-  var plugin = plateList.createListPlugin(options);
+  var plugin = plate.createListPlugin(options);
   plugin.withOverrides = withCustomList(options);
   return plugin;
 };
@@ -1316,7 +1450,7 @@ function ToolbarBoldButton(props) {
 
   function handleClick() {
     if (!(editor != null && editor.selection)) return;
-    plateCommon.toggleMark(editor, Contentful.MARKS.BOLD);
+    plate.toggleMark(editor, Contentful.MARKS.BOLD);
     Slate.ReactEditor.focus(editor);
   }
 
@@ -1325,7 +1459,7 @@ function ToolbarBoldButton(props) {
     title: "Bold",
     testId: "bold-toolbar-button",
     onClick: handleClick,
-    isActive: plateCommon.isMarkActive(editor, Contentful.MARKS.BOLD),
+    isActive: plate.isMarkActive(editor, Contentful.MARKS.BOLD),
     isDisabled: props.isDisabled
   }, /*#__PURE__*/React.createElement(f36Icons.FormatBoldIcon, null));
 }
@@ -1342,8 +1476,8 @@ function Bold(props) {
 function createBoldPlugin() {
   return {
     pluginKeys: Contentful.MARKS.BOLD,
-    renderLeaf: plateCore.getRenderLeaf(Contentful.MARKS.BOLD),
-    onKeyDown: plateCommon.getToggleMarkOnKeyDown(Contentful.MARKS.BOLD),
+    renderLeaf: plate.getRenderLeaf(Contentful.MARKS.BOLD),
+    onKeyDown: plate.getToggleMarkOnKeyDown(Contentful.MARKS.BOLD),
     deserialize: function deserialize() {
       return {
         leaf: [{
@@ -1374,7 +1508,7 @@ function ToolbarCodeButton(props) {
 
   function handleClick() {
     if (!(editor != null && editor.selection)) return;
-    plateCommon.toggleMark(editor, Contentful.MARKS.CODE);
+    plate.toggleMark(editor, Contentful.MARKS.CODE);
     Slate.ReactEditor.focus(editor);
   }
 
@@ -1383,7 +1517,7 @@ function ToolbarCodeButton(props) {
     title: "Code",
     testId: "code-toolbar-button",
     onClick: handleClick,
-    isActive: plateCommon.isMarkActive(editor, Contentful.MARKS.CODE),
+    isActive: plate.isMarkActive(editor, Contentful.MARKS.CODE),
     isDisabled: props.isDisabled
   }, /*#__PURE__*/React.createElement(f36Icons.CodeIcon, null));
 }
@@ -1408,8 +1542,8 @@ function createCodePlugin() {
   }];
   return {
     pluginKeys: Contentful.MARKS.CODE,
-    renderLeaf: plateCore.getRenderLeaf(Contentful.MARKS.CODE),
-    onKeyDown: plateCommon.getToggleMarkOnKeyDown(Contentful.MARKS.CODE),
+    renderLeaf: plate.getRenderLeaf(Contentful.MARKS.CODE),
+    onKeyDown: plate.getToggleMarkOnKeyDown(Contentful.MARKS.CODE),
     deserialize: deserializeLeaf(Contentful.MARKS.CODE, deserializeRule)
   };
 }
@@ -1425,7 +1559,7 @@ function ToolbarItalicButton(props) {
 
   function handleClick() {
     if (!(editor != null && editor.selection)) return;
-    plateCommon.toggleMark(editor, Contentful.MARKS.ITALIC);
+    plate.toggleMark(editor, Contentful.MARKS.ITALIC);
     Slate.ReactEditor.focus(editor);
   }
 
@@ -1434,7 +1568,7 @@ function ToolbarItalicButton(props) {
     title: "Italic",
     testId: "italic-toolbar-button",
     onClick: handleClick,
-    isActive: plateCommon.isMarkActive(editor, Contentful.MARKS.ITALIC),
+    isActive: plate.isMarkActive(editor, Contentful.MARKS.ITALIC),
     isDisabled: props.isDisabled
   }, /*#__PURE__*/React.createElement(f36Icons.FormatItalicIcon, null));
 }
@@ -1458,8 +1592,8 @@ function createItalicPlugin() {
   }];
   return {
     pluginKeys: Contentful.MARKS.ITALIC,
-    renderLeaf: plateCore.getRenderLeaf(Contentful.MARKS.ITALIC),
-    onKeyDown: plateCommon.getToggleMarkOnKeyDown(Contentful.MARKS.ITALIC),
+    renderLeaf: plate.getRenderLeaf(Contentful.MARKS.ITALIC),
+    onKeyDown: plate.getToggleMarkOnKeyDown(Contentful.MARKS.ITALIC),
     deserialize: deserializeLeaf(Contentful.MARKS.ITALIC, deserializeRules)
   };
 }
@@ -1475,7 +1609,7 @@ function ToolbarUnderlineButton(props) {
 
   function handleClick() {
     if (!(editor != null && editor.selection)) return;
-    plateCommon.toggleMark(editor, Contentful.MARKS.UNDERLINE);
+    plate.toggleMark(editor, Contentful.MARKS.UNDERLINE);
     Slate.ReactEditor.focus(editor);
   }
 
@@ -1484,7 +1618,7 @@ function ToolbarUnderlineButton(props) {
     title: "Underline",
     testId: "underline-toolbar-button",
     onClick: handleClick,
-    isActive: plateCommon.isMarkActive(editor, Contentful.MARKS.UNDERLINE),
+    isActive: plate.isMarkActive(editor, Contentful.MARKS.UNDERLINE),
     isDisabled: props.isDisabled
   }, /*#__PURE__*/React.createElement(f36Icons.FormatUnderlinedIcon, null));
 }
@@ -1501,8 +1635,8 @@ function createUnderlinePlugin() {
   }];
   return {
     pluginKeys: Contentful.MARKS.UNDERLINE,
-    renderLeaf: plateCore.getRenderLeaf(Contentful.MARKS.UNDERLINE),
-    onKeyDown: plateCommon.getToggleMarkOnKeyDown(Contentful.MARKS.UNDERLINE),
+    renderLeaf: plate.getRenderLeaf(Contentful.MARKS.UNDERLINE),
+    onKeyDown: plate.getToggleMarkOnKeyDown(Contentful.MARKS.UNDERLINE),
     deserialize: deserializeLeaf(Contentful.MARKS.UNDERLINE, deserializeRules)
   };
 }
@@ -2897,7 +3031,7 @@ function HyperlinkModal(props) {
 
   return /*#__PURE__*/React.createElement(fieldEditorReference.EntityProvider, {
     sdk: props.sdk
-  }, /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(f36Components.ModalContent, null, /*#__PURE__*/React.createElement(f36Components.Form, null, /*#__PURE__*/React.createElement(f36Components.FormControl, {
+  }, /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(f36Components.ModalContent, null, /*#__PURE__*/React.createElement(f36Components.Form, null, !props.linkType && /*#__PURE__*/React.createElement(f36Components.FormControl, {
     id: "link-text",
     isRequired: true
   }, /*#__PURE__*/React.createElement(f36Components.FormControl.Label, null, "Link text"), /*#__PURE__*/React.createElement(f36Components.TextInput, {
@@ -3096,14 +3230,14 @@ var styles$d = {
 };
 function createHyperlinkPlugin(sdk) {
   return {
-    renderElement: plateCore.getRenderElement(LINK_TYPES),
+    renderElement: plate.getRenderElement(LINK_TYPES),
     pluginKeys: LINK_TYPES,
-    inlineTypes: plateCore.getPlatePluginTypes(LINK_TYPES),
+    inlineTypes: plate.getPlatePluginTypes(LINK_TYPES),
     onKeyDown: buildHyperlinkEventHandler(sdk),
     deserialize: function deserialize(editor) {
-      var hyperlinkOptions = plateCore.getPlatePluginOptions(editor, Contentful.INLINES.HYPERLINK);
-      var entryHyperlinkOptions = plateCore.getPlatePluginOptions(editor, Contentful.INLINES.ENTRY_HYPERLINK);
-      var assetHyperlinkOptions = plateCore.getPlatePluginOptions(editor, Contentful.INLINES.ASSET_HYPERLINK);
+      var hyperlinkOptions = plate.getPlatePluginOptions(editor, Contentful.INLINES.HYPERLINK);
+      var entryHyperlinkOptions = plate.getPlatePluginOptions(editor, Contentful.INLINES.ENTRY_HYPERLINK);
+      var assetHyperlinkOptions = plate.getPlatePluginOptions(editor, Contentful.INLINES.ASSET_HYPERLINK);
 
       var isAnchor = function isAnchor(element) {
         return element.nodeName === 'A' && !!element.getAttribute('href') && element.getAttribute('href') !== '#';
@@ -3389,19 +3523,20 @@ function moveToFirstCellFromSelectedTable(editor) {
 function insertTableAndFocusFirstCell(editor) {
   // FIXME: a table should only be allowed at root level. Currently this
   // code adds it at any level
-  plateTable.insertTable(editor, {
+  plate.insertTable(editor, {
     header: true
   });
   moveToFirstCellFromSelectedTable(editor);
+  replaceEmptyParagraphWithTable(editor);
 }
 function isTableActive(editor) {
-  var tableElements = [plateTable.ELEMENT_TABLE, plateTable.ELEMENT_TH, plateTable.ELEMENT_TR, plateTable.ELEMENT_TD];
+  var tableElements = [plate.ELEMENT_TABLE, plate.ELEMENT_TH, plate.ELEMENT_TR, plate.ELEMENT_TD];
   return tableElements.some(function (el) {
     return isBlockSelected(editor, el);
   });
 }
 function isTableHeaderEnabled(editor) {
-  var tableItem = plateCommon.getAbove(editor, {
+  var tableItem = plate.getAbove(editor, {
     match: {
       type: Contentful.BLOCKS.TABLE
     }
@@ -3411,17 +3546,47 @@ function isTableHeaderEnabled(editor) {
     return false;
   }
 
-  var firstRow = plateCommon.getChildren(tableItem)[0];
+  var firstRow = plate.getChildren(tableItem)[0];
 
   if (!firstRow) {
     return false;
   }
 
-  return plateCommon.getChildren(firstRow).every(function (_ref) {
+  return plate.getChildren(firstRow).every(function (_ref) {
     var node = _ref[0];
     return node.type === Contentful.BLOCKS.TABLE_HEADER_CELL;
   });
 }
+function replaceEmptyParagraphWithTable(editor) {
+  var tablePath = getAncestorPathFromSelection(editor);
+  if (!tablePath || plate.isFirstChild(tablePath)) return;
+  var previousPath = slate.Path.previous(tablePath);
+  if (!previousPath) return;
+
+  var _Editor$nodes = slate.Editor.nodes(editor, {
+    at: previousPath,
+    match: function match(node) {
+      return node.type === Contentful.BLOCKS.PARAGRAPH;
+    }
+  }),
+      nodes = _Editor$nodes[0];
+
+  if (!nodes) return;
+  var previousNode = nodes[0];
+  var isPreviousNodeTextEmpty = plate.isAncestorEmpty(editor, previousNode);
+
+  if (isPreviousNodeTextEmpty) {
+    // Switch table with previous empty paragraph
+    slate.Transforms.moveNodes(editor, {
+      at: tablePath,
+      to: previousPath
+    }); // Remove previous paragraph that now is under the table
+
+    slate.Transforms.removeNodes(editor, {
+      at: tablePath
+    });
+  }
+}
 
 function useTracking(_ref) {
   var onAction = _ref.onAction;
@@ -3447,14 +3612,14 @@ var _constate$2 = /*#__PURE__*/constate(useTracking),
     useTrackingContext = _constate$2[1];
 
 var addRow = function addRow(editor, getNextRowPath) {
-  if (plateCommon.someNode(editor, {
+  if (plate.someNode(editor, {
     match: {
-      type: plateCore.getPlatePluginType(editor, plateTable.ELEMENT_TABLE)
+      type: plate.getPlatePluginType(editor, plate.ELEMENT_TABLE)
     }
   })) {
-    var currentRowItem = plateCommon.getAbove(editor, {
+    var currentRowItem = plate.getAbove(editor, {
       match: {
-        type: plateCore.getPlatePluginType(editor, plateTable.ELEMENT_TR)
+        type: plate.getPlatePluginType(editor, plate.ELEMENT_TR)
       }
     });
 
@@ -3462,8 +3627,8 @@ var addRow = function addRow(editor, getNextRowPath) {
       var currentRowElem = currentRowItem[0],
           currentRowPath = currentRowItem[1];
       var nextRowPath = getNextRowPath(currentRowPath);
-      plateCommon.insertNodes(editor, // @ts-expect-error
-      plateTable.getEmptyRowNode(editor, {
+      plate.insertNodes(editor, // @ts-expect-error
+      plate.getEmptyRowNode(editor, {
         header: false,
         colCount: currentRowElem.children.length
       }), {
@@ -3492,19 +3657,19 @@ var addRowAbove = function addRowAbove(editor) {
 var addColumn = function addColumn(editor, _ref, getNextCellPath) {
   var header = _ref.header;
 
-  if (plateCommon.someNode(editor, {
+  if (plate.someNode(editor, {
     match: {
-      type: plateCore.getPlatePluginType(editor, plateTable.ELEMENT_TABLE)
+      type: plate.getPlatePluginType(editor, plate.ELEMENT_TABLE)
     }
   })) {
-    var currentCellItem = plateCommon.getAbove(editor, {
+    var currentCellItem = plate.getAbove(editor, {
       match: {
-        type: [plateCore.getPlatePluginType(editor, plateTable.ELEMENT_TD), plateCore.getPlatePluginType(editor, plateTable.ELEMENT_TH)]
+        type: [plate.getPlatePluginType(editor, plate.ELEMENT_TD), plate.getPlatePluginType(editor, plate.ELEMENT_TH)]
       }
     });
-    var currentTableItem = plateCommon.getAbove(editor, {
+    var currentTableItem = plate.getAbove(editor, {
       match: {
-        type: plateCore.getPlatePluginType(editor, plateTable.ELEMENT_TABLE)
+        type: plate.getPlatePluginType(editor, plate.ELEMENT_TABLE)
       }
     });
 
@@ -3514,8 +3679,8 @@ var addColumn = function addColumn(editor, _ref, getNextCellPath) {
       var replacePathPos = newCellPath.length - 2;
       currentTableItem[0].children.forEach(function (_, rowIdx) {
         newCellPath[replacePathPos] = rowIdx;
-        plateCommon.insertNodes(editor, // @ts-expect-error
-        plateTable.getEmptyCellNode(editor, {
+        plate.insertNodes(editor, // @ts-expect-error
+        plate.getEmptyCellNode(editor, {
           header: header && rowIdx === 0
         }), {
           at: newCellPath,
@@ -3539,7 +3704,7 @@ var addColumnLeft = function addColumnLeft(editor, options) {
 };
 
 var setHeader = function setHeader(editor, enable) {
-  var tableItem = plateCommon.getAbove(editor, {
+  var tableItem = plate.getAbove(editor, {
     match: {
       type: Contentful.BLOCKS.TABLE
     }
@@ -3549,15 +3714,15 @@ var setHeader = function setHeader(editor, enable) {
     return;
   }
 
-  var firstRow = plateCommon.getChildren(tableItem)[0];
+  var firstRow = plate.getChildren(tableItem)[0];
 
   if (!firstRow) {
     return;
   }
 
-  plateCommon.getChildren(firstRow).forEach(function (_ref) {
+  plate.getChildren(firstRow).forEach(function (_ref) {
     var path = _ref[1];
-    plateCommon.setNodes(editor, {
+    plate.setNodes(editor, {
       type: enable ? Contentful.BLOCKS.TABLE_HEADER_CELL : Contentful.BLOCKS.TABLE_CELL
     }, {
       at: path
@@ -3609,7 +3774,7 @@ var TableActions = function TableActions() {
       return false;
     }
 
-    var headerCell = plateCommon.getAbove(editor, {
+    var headerCell = plate.getAbove(editor, {
       match: {
         type: Contentful.BLOCKS.TABLE_HEADER_CELL
       }
@@ -3669,25 +3834,125 @@ var TableActions = function TableActions() {
   }, "Add column right"), /*#__PURE__*/React__default.createElement(f36Components.Menu.Divider, null), /*#__PURE__*/React__default.createElement(f36Components.Menu.Item, {
     onClick: toggleHeader
   }, isHeaderEnabled ? 'Disable table header' : 'Enable table header'), /*#__PURE__*/React__default.createElement(f36Components.Menu.Divider, null), /*#__PURE__*/React__default.createElement(f36Components.Menu.Item, {
-    onClick: action(plateTable.deleteRow, 'remove', 'Row')
+    onClick: action(plate.deleteRow, 'remove', 'Row')
   }, "Delete row"), /*#__PURE__*/React__default.createElement(f36Components.Menu.Item, {
-    onClick: action(plateTable.deleteColumn, 'remove', 'Column')
+    onClick: action(plate.deleteColumn, 'remove', 'Column')
   }, "Delete column"), /*#__PURE__*/React__default.createElement(f36Components.Menu.Item, {
-    onClick: action(plateTable.deleteTable, 'remove', 'Table')
+    onClick: action(plate.deleteTable, 'remove', 'Table')
   }, "Delete table")));
 };
 
-var _templateObject$4, _templateObject2$3, _templateObject3$3, _templateObject4$1, _styles$1, _withTableOptions;
-var styles$f = (_styles$1 = {}, _styles$1[Contentful.BLOCKS.TABLE] = /*#__PURE__*/emotion.css(_templateObject$4 || (_templateObject$4 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    margin-bottom: 1.5em;\n    border-collapse: collapse;\n    border-radius: 5px;\n    border-style: hidden;\n    box-shadow: 0 0 0 1px ", ";\n    width: 100%;\n    table-layout: fixed;\n    overflow: hidden;\n  "])), tokens.gray400), _styles$1[Contentful.BLOCKS.TABLE_ROW] = /*#__PURE__*/emotion.css(_templateObject2$3 || (_templateObject2$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n    &:hover td {\n      background-color: transparent !important;\n    }\n  "])), tokens.gray400), _styles$1[Contentful.BLOCKS.TABLE_HEADER_CELL] = /*#__PURE__*/emotion.css(_templateObject3$3 || (_templateObject3$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    background-color: ", ";\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    font-weight: ", ";\n    text-align: left;\n    min-width: 48px;\n    position: relative;\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray200, tokens.gray400, tokens.fontWeightMedium), _styles$1[Contentful.BLOCKS.TABLE_CELL] = /*#__PURE__*/emotion.css(_templateObject4$1 || (_templateObject4$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    min-width: 48px;\n    position: relative;\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray400), _styles$1);
+/**
+ * Injects a custom element normalization handler.
+ *
+ * Handlers must explicity return "true" to indicate a pass.
+ * A pass is when a handler didn't encounter any normalization
+ * paths (i.e. all nodes were valid)
+ *
+ * Important read:
+ * https://docs.slatejs.org/concepts/11-normalizing#multi-pass-normalizing
+ */
 
-var slateNodeToText = function slateNodeToText(node) {
-  var contentfulNode = contentfulSlatejsAdapter.toContentfulDocument({
-    document: [node],
-    schema: schema
-  });
-  return richTextPlainTextRenderer.documentToPlainTextString(contentfulNode);
+var withNormalizer = function withNormalizer(editor, handler) {
+  var normalizeNode = editor.normalizeNode;
+
+  editor.normalizeNode = function (entry) {
+    var node = entry[0];
+    var passed = false;
+
+    if (slate.Element.isElement(node)) {
+      passed = handler(editor, entry) === true;
+    }
+
+    if (passed) {
+      normalizeNode(entry);
+    }
+  };
 };
 
+var isTable = function isTable(node) {
+  return node.type === Contentful.BLOCKS.TABLE;
+};
+
+var isTableCell = function isTableCell(node) {
+  return node.type === Contentful.BLOCKS.TABLE_CELL || node.type === Contentful.BLOCKS.TABLE_HEADER_CELL;
+};
+/**
+ * Normalizes TABLE_CELL & TABLE_HEADER_CELL nodes
+ */
+
+
+var normalizeTableCell = function normalizeTableCell(editor, entry) {
+  var node = entry[0],
+      path = entry[1];
+
+  if (!isTableCell(node)) {
+    return true;
+  }
+
+  for (var _iterator = _createForOfIteratorHelperLoose(slate.Node.children(editor, path)), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        child = _step$value[0],
+        childPath = _step$value[1];
+
+    if (!slate.Element.isElement(child)) {
+      continue;
+    }
+
+    var isValidTableCellItem = Contentful.CONTAINERS[node.type].includes(child.type);
+
+    if (!isValidTableCellItem) {
+      var text = extractParagraphsAt(editor, childPath);
+      replaceNode(editor, childPath, text);
+      return;
+    }
+  }
+
+  return true;
+};
+/**
+ * Normalizes TABLE nodes
+ */
+
+
+var normalizeTable = function normalizeTable(editor, entry) {
+  var node = entry[0],
+      path = entry[1];
+
+  if (!isTable(node)) {
+    return true;
+  } // All direct children must be of type TABLE_ROW
+
+
+  for (var _iterator2 = _createForOfIteratorHelperLoose(slate.Node.children(editor, path)), _step2; !(_step2 = _iterator2()).done;) {
+    var _step2$value = _step2.value,
+        child = _step2$value[0],
+        childPath = _step2$value[1];
+
+    if (!slate.Element.isElement(child)) {
+      continue;
+    }
+
+    var isValidTableChild = Contentful.CONTAINERS[Contentful.BLOCKS.TABLE].includes(child.type);
+
+    if (!isValidTableChild) {
+      slate.Transforms.removeNodes(editor, {
+        at: childPath
+      });
+      return;
+    }
+  }
+
+  return true;
+};
+
+var addTableNormalizers = function addTableNormalizers(editor) {
+  withNormalizer(editor, normalizeTable);
+  withNormalizer(editor, normalizeTableCell);
+};
+
+var _templateObject$4, _templateObject2$3, _templateObject3$3, _templateObject4$1, _styles$1, _withTableOptions;
+var styles$f = (_styles$1 = {}, _styles$1[Contentful.BLOCKS.TABLE] = /*#__PURE__*/emotion.css(_templateObject$4 || (_templateObject$4 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    margin-bottom: 1.5em;\n    border-collapse: collapse;\n    border-radius: 5px;\n    border-style: hidden;\n    box-shadow: 0 0 0 1px ", ";\n    width: 100%;\n    table-layout: fixed;\n    overflow: hidden;\n  "])), tokens.gray400), _styles$1[Contentful.BLOCKS.TABLE_ROW] = /*#__PURE__*/emotion.css(_templateObject2$3 || (_templateObject2$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n\n    &:hover td {\n      background-color: transparent !important;\n    }\n  "])), tokens.gray400), _styles$1[Contentful.BLOCKS.TABLE_HEADER_CELL] = /*#__PURE__*/emotion.css(_templateObject3$3 || (_templateObject3$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    background-color: ", ";\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    font-weight: ", ";\n    text-align: left;\n    min-width: 48px;\n    position: relative;\n\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray200, tokens.gray400, tokens.fontWeightMedium), _styles$1[Contentful.BLOCKS.TABLE_CELL] = /*#__PURE__*/emotion.css(_templateObject4$1 || (_templateObject4$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n    border: 1px solid ", ";\n    padding: 10px 12px;\n    min-width: 48px;\n    position: relative;\n\n    div:last-child {\n      margin-bottom: 0;\n    }\n  "])), tokens.gray400), _styles$1);
 var Table = function Table(props) {
   return /*#__PURE__*/React.createElement("table", Object.assign({}, props.attributes, {
     className: styles$f[Contentful.BLOCKS.TABLE]
@@ -3710,16 +3975,16 @@ var TD = function TD(props) {
     className: styles$f[Contentful.BLOCKS.TABLE_CELL]
   }), isSelected && /*#__PURE__*/React.createElement(TableActions, null), props.children);
 };
-var withTableOptions = (_withTableOptions = {}, _withTableOptions[plateTable.ELEMENT_TABLE] = {
+var withTableOptions = (_withTableOptions = {}, _withTableOptions[plate.ELEMENT_TABLE] = {
   type: Contentful.BLOCKS.TABLE,
   component: Table
-}, _withTableOptions[plateTable.ELEMENT_TR] = {
+}, _withTableOptions[plate.ELEMENT_TR] = {
   type: Contentful.BLOCKS.TABLE_ROW,
   component: TR
-}, _withTableOptions[plateTable.ELEMENT_TH] = {
+}, _withTableOptions[plate.ELEMENT_TH] = {
   type: Contentful.BLOCKS.TABLE_HEADER_CELL,
   component: TH
-}, _withTableOptions[plateTable.ELEMENT_TD] = {
+}, _withTableOptions[plate.ELEMENT_TD] = {
   type: Contentful.BLOCKS.TABLE_CELL,
   component: TD
 }, _withTableOptions);
@@ -3751,56 +4016,6 @@ function addTableTrackingEvents(editor, _ref) {
   };
 }
 
-var paragraph = function paragraph() {
-  return {
-    type: Contentful.BLOCKS.PARAGRAPH,
-    data: {},
-    children: []
-  };
-};
-
-function addTableNormalization(editor) {
-  var normalizeNode = editor.normalizeNode;
-
-  editor.normalizeNode = function (entry) {
-    var node = entry[0],
-        path = entry[1]; // TODO: This should be enforced by sanitizeSlateDoc() but the internal
-    // editor value can be different.
-    // cf. https://github.com/ianstormtaylor/slate/issues/2206
-
-    var cellTypes = [Contentful.BLOCKS.TABLE_CELL, Contentful.BLOCKS.TABLE_HEADER_CELL];
-
-    if (slate.Element.isElement(node) && cellTypes.includes(node.type)) {
-      for (var _iterator = _createForOfIteratorHelperLoose(slate.Node.children(editor, path)), _step; !(_step = _iterator()).done;) {
-        var _step$value = _step.value,
-            child = _step$value[0],
-            childPath = _step$value[1];
-
-        if (slate.Text.isText(child)) {
-          slate.Transforms.wrapNodes(editor, paragraph(), {
-            at: childPath
-          });
-        } else if (!Contentful.CONTAINERS[node.type].includes(child.type)) {
-          var paragraphWithTextFromNode = _extends({}, paragraph(), {
-            children: [{
-              text: slateNodeToText(child)
-            }]
-          });
-
-          slate.Transforms.removeNodes(editor, {
-            at: childPath
-          });
-          slate.Transforms.insertNodes(editor, paragraphWithTextFromNode, {
-            at: childPath
-          });
-        }
-      }
-    }
-
-    normalizeNode(entry);
-  };
-}
-
 function hasTables(nodes) {
   return nodes.some(function (_ref2) {
     var type = _ref2.type;
@@ -3826,11 +4041,9 @@ function hasHeadersOutsideFirstRow(nodes) {
   });
 }
 
-function createWithTableEvents(tracking) {
+function createTableOnKeyDown() {
   return function withTableEvents(editor) {
-    addTableTrackingEvents(editor, tracking);
-    addTableNormalization(editor);
-    var handleKeyDownFromPlateUdecode = plateTable.getTableOnKeyDown()(editor);
+    var handleKeyDownFromPlateUdecode = plate.getTableOnKeyDown()(editor);
     return function handleKeyDown(event) {
       if (event.key === 'Backspace' && currentSelectionStartsTableCell(editor) || event.key === 'Delete' && currentSelectionPrecedesTableCell(editor)) {
         // The default behavior here would be to delete the preceding or forthcoming
@@ -3847,9 +4060,11 @@ function createWithTableEvents(tracking) {
 }
 
 var createTablePlugin = function createTablePlugin(tracking) {
-  return _extends({}, plateTable.createTablePlugin(), {
-    onKeyDown: createWithTableEvents(tracking),
+  return _extends({}, plate.createTablePlugin(), {
+    onKeyDown: createTableOnKeyDown(),
     withOverrides: function withOverrides(editor) {
+      addTableTrackingEvents(editor, tracking);
+      addTableNormalizers(editor);
       var insertFragment = editor.insertFragment;
 
       editor.insertFragment = function (fragments) {
@@ -4149,7 +4364,7 @@ var createNode = function createNode(nodeType, entity) {
 function insertBlock(editor, nodeType, entity) {
   if (!(editor != null && editor.selection)) return;
   var linkedEntityBlock = createNode(nodeType, entity);
-  var hasText = editor.selection && !!plateCommon.getText(editor, editor.selection.focus.path);
+  var hasText = editor.selection && !!plate.getText(editor, editor.selection.focus.path);
 
   if (hasText) {
     slate.Transforms.insertNodes(editor, linkedEntityBlock);
@@ -4224,14 +4439,14 @@ var _withEmbeddedEntryBlo, _withEmbeddedAssetBlo;
 var createEmbeddedEntityPlugin = function createEmbeddedEntityPlugin(nodeType) {
   return function (sdk) {
     return {
-      renderElement: plateCore.getRenderElement(nodeType),
+      renderElement: plate.getRenderElement(nodeType),
       pluginKeys: nodeType,
       onKeyDown: getWithEmbeddedEntityEvents(nodeType, sdk),
-      voidTypes: plateCore.getPlatePluginTypes(nodeType),
+      voidTypes: plate.getPlatePluginTypes(nodeType),
       deserialize: function deserialize(editor) {
         var _entityTypes;
 
-        var options = plateCore.getPlatePluginOptions(editor, nodeType);
+        var options = plate.getPlatePluginOptions(editor, nodeType);
         var entityTypes = (_entityTypes = {}, _entityTypes[Contentful.BLOCKS.EMBEDDED_ENTRY] = 'Entry', _entityTypes[Contentful.BLOCKS.EMBEDDED_ASSET] = 'Asset', _entityTypes);
         return {
           element: [_extends({
@@ -4302,16 +4517,15 @@ function getWithEmbeddedEntityEvents(nodeType, sdk) {
     // TODO: Dry up copied code from HR
     return function handleEvent(event) {
       if (!editor) return;
-      var isEnter = event.keyCode === 13;
 
       var _getNodeEntryFromSele = getNodeEntryFromSelection(editor, nodeType),
           pathToSelectedElement = _getNodeEntryFromSele[1];
 
       if (pathToSelectedElement) {
-        if (isEnter) {
-          event.preventDefault();
-          moveToTheNextLine(editor);
-        } else if (event.key === 'Backspace') {
+        var isDelete = event.key === 'Delete';
+        var isBackspace = event.key === 'Backspace';
+
+        if (isDelete || isBackspace) {
           event.preventDefault();
           slate.Transforms.removeNodes(editor, {
             at: pathToSelectedElement
@@ -4603,13 +4817,13 @@ function ToolbarEmbeddedEntityInlineButton(props) {
 }
 function createEmbeddedEntityInlinePlugin(sdk) {
   return {
-    renderElement: plateCore.getRenderElement(Contentful.INLINES.EMBEDDED_ENTRY),
+    renderElement: plate.getRenderElement(Contentful.INLINES.EMBEDDED_ENTRY),
     pluginKeys: Contentful.INLINES.EMBEDDED_ENTRY,
-    inlineTypes: plateCore.getPlatePluginTypes(Contentful.INLINES.EMBEDDED_ENTRY),
-    voidTypes: plateCore.getPlatePluginTypes(Contentful.INLINES.EMBEDDED_ENTRY),
+    inlineTypes: plate.getPlatePluginTypes(Contentful.INLINES.EMBEDDED_ENTRY),
+    voidTypes: plate.getPlatePluginTypes(Contentful.INLINES.EMBEDDED_ENTRY),
     onKeyDown: getWithEmbeddedEntryInlineEvents(sdk),
     deserialize: function deserialize(editor) {
-      var options = plateCore.getPlatePluginOptions(editor, Contentful.INLINES.EMBEDDED_ENTRY);
+      var options = plate.getPlatePluginOptions(editor, Contentful.INLINES.EMBEDDED_ENTRY);
       return {
         element: [_extends({
           type: Contentful.INLINES.EMBEDDED_ENTRY,
@@ -4760,6 +4974,9 @@ var Toolbar = function Toolbar(_ref) {
   var validationInfo = React__default.useMemo(function () {
     return getValidationInfo(sdk.field);
   }, [sdk.field]);
+  var isListSelected = isNodeTypeSelected(editor, Contentful.BLOCKS.UL_LIST) || isNodeTypeSelected(editor, Contentful.BLOCKS.OL_LIST);
+  var isBlockquoteSelected = isNodeTypeSelected(editor, Contentful.BLOCKS.QUOTE);
+  var shouldDisableTables = isDisabled || !canInsertBlocks || isListSelected || isBlockquoteSelected;
   return /*#__PURE__*/React__default.createElement(f36Components.Flex, {
     testId: "toolbar",
     className: styles$k.toolbar,
@@ -4791,7 +5008,7 @@ var Toolbar = function Toolbar(_ref) {
   }), isNodeTypeEnabled(sdk.field, Contentful.BLOCKS.HR) && /*#__PURE__*/React__default.createElement(ToolbarHrButton, {
     isDisabled: isDisabled || !canInsertBlocks
   }), isNodeTypeEnabled(sdk.field, Contentful.BLOCKS.TABLE) && /*#__PURE__*/React__default.createElement(ToolbarTableButton, {
-    isDisabled: isDisabled || !canInsertBlocks
+    isDisabled: shouldDisableTables
   })), /*#__PURE__*/React__default.createElement("div", {
     className: styles$k.embedActionsWrapper
   }, /*#__PURE__*/React__default.createElement(EmbedEntityWidget, {
@@ -4830,6 +5047,99 @@ var StickyToolbarWrapper = function StickyToolbarWrapper(_ref) {
   }, children);
 };
 
+var TEXT_PARENT_NODES = /*#__PURE__*/Contentful.VOID_BLOCKS.concat(values(Contentful.INLINES)).concat(Contentful.BLOCKS.PARAGRAPH, Contentful.BLOCKS.HEADING_1, Contentful.BLOCKS.HEADING_2, Contentful.BLOCKS.HEADING_3, Contentful.BLOCKS.HEADING_4, Contentful.BLOCKS.HEADING_5, Contentful.BLOCKS.HEADING_6);
+
+var isTextElement = function isTextElement(node) {
+  return 'text' in node;
+};
+
+var wrapNode = function wrapNode(type, node) {
+  return {
+    type: type,
+    data: {},
+    children: [node]
+  };
+};
+
+function wrapOrphanedTextNode(parentNodeType, node) {
+  var paragraph = wrapNode(Contentful.BLOCKS.PARAGRAPH, node);
+
+  switch (parentNodeType) {
+    case Contentful.BLOCKS.OL_LIST:
+    case Contentful.BLOCKS.UL_LIST:
+      return wrapNode(Contentful.BLOCKS.LIST_ITEM, paragraph);
+
+    case Contentful.BLOCKS.TABLE_ROW:
+      return wrapNode(Contentful.BLOCKS.TABLE_CELL, paragraph);
+
+    case Contentful.BLOCKS.TABLE:
+      return wrapNode(Contentful.BLOCKS.TABLE_ROW, wrapNode(Contentful.BLOCKS.TABLE_CELL, paragraph));
+
+    default:
+      return paragraph;
+  }
+}
+/**
+ * Ensures "orphaned" text node elements (those without a parent capable of
+ * validly rendering a text child node) are wrapped with a suitable parent
+ * element to prevent failures on the validation layer.
+ *
+ * It is commonplace for third party plugins (including udecode) to reconcile
+ * deletion events by inserting such nodes into their schema. This
+ * subprocedure is intended as a guard against such cases.
+ */
+
+
+function sanitizeSlateDoc(nodes, parentNodeType) {
+  if (nodes === void 0) {
+    nodes = [];
+  }
+
+  if (parentNodeType === void 0) {
+    parentNodeType = Contentful.BLOCKS.DOCUMENT;
+  }
+
+  return nodes.map(function (node) {
+    if (isTextElement(node)) {
+      return TEXT_PARENT_NODES.includes(parentNodeType) ? node : wrapOrphanedTextNode(parentNodeType, node);
+    }
+
+    return _extends({}, node, {
+      children: sanitizeSlateDoc(node.children, node.type)
+    });
+  });
+}
+/**
+ * Ensures incoming void nodes have a child leaf text element.
+ */
+
+function sanitizeIncomingSlateDoc(nodes) {
+  if (nodes === void 0) {
+    nodes = [];
+  }
+
+  return nodes.map(function (node) {
+    var _node$children;
+
+    if (isTextElement(node)) {
+      return node;
+    }
+
+    if (node.isVoid && ((_node$children = node.children) == null ? void 0 : _node$children.length) === 0) {
+      return _extends({}, node, {
+        children: [{
+          text: '',
+          data: {}
+        }]
+      });
+    }
+
+    return _extends({}, node, {
+      children: sanitizeIncomingSlateDoc(node.children)
+    });
+  });
+}
+
 var isHTMLElement = function isHTMLElement(node) {
   return node.nodeType === Node.ELEMENT_NODE;
 };
@@ -4980,28 +5290,25 @@ var htmlToDataTransfer = function htmlToDataTransfer(html) {
   return data;
 };
 
-function withPasteHandling(editor) {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  return function (_event) {
-    var insertData = editor.insertData;
+var createPastePlugin = function createPastePlugin() {
+  return {
+    withOverrides: function withOverrides(editor) {
+      var insertData = editor.insertData;
 
-    editor.insertData = function (data) {
-      var html = data.getData(MIME_TYPE_HTML);
+      editor.insertData = function (data) {
+        var html = data.getData(MIME_TYPE_HTML);
 
-      if (html) {
-        var sanitized = sanitizeHtml(html, editor);
-        var newData = htmlToDataTransfer(sanitized);
-        insertData(newData);
-      } else {
-        insertData(data);
-      }
-    };
-  };
-}
+        if (html) {
+          var sanitized = sanitizeHtml(html, editor);
+          var newData = htmlToDataTransfer(sanitized);
+          insertData(newData);
+        } else {
+          insertData(data);
+        }
+      };
 
-var createPastePlugin = function createPastePlugin() {
-  return {
-    onKeyDown: withPasteHandling
+      return editor;
+    }
   };
 };
 
@@ -5024,14 +5331,14 @@ function isEmpty(element) {
 }
 
 function createParagraphPlugin() {
-  var elementKeys = [plateParagraph.ELEMENT_PARAGRAPH, Contentful.BLOCKS.PARAGRAPH];
+  var elementKeys = [plate.ELEMENT_PARAGRAPH, Contentful.BLOCKS.PARAGRAPH];
   var deserializer = deserializeElement(Contentful.BLOCKS.PARAGRAPH, [{
     nodeNames: ['P', 'DIV']
   }]);
   return {
-    renderElement: plateCore.getRenderElement(elementKeys),
+    renderElement: plate.getRenderElement(elementKeys),
     pluginKeys: elementKeys,
-    onKeyDown: plateCommon.getToggleElementOnKeyDown(Contentful.BLOCKS.PARAGRAPH),
+    onKeyDown: plate.getToggleElementOnKeyDown(Contentful.BLOCKS.PARAGRAPH),
     deserialize: function deserialize(editor) {
       var _deserializer = deserializer(editor),
           element = _deserializer.element,
@@ -5081,7 +5388,7 @@ function createParagraphPlugin() {
     }
   };
 }
-var withParagraphOptions = (_withParagraphOptions = {}, _withParagraphOptions[plateParagraph.ELEMENT_PARAGRAPH] = {
+var withParagraphOptions = (_withParagraphOptions = {}, _withParagraphOptions[plate.ELEMENT_PARAGRAPH] = {
   // We convert the default slate plugin `p` to Contentful `BLOCKS.PARAGRAPH`
   type: Contentful.BLOCKS.PARAGRAPH,
   component: Paragraph
@@ -5133,104 +5440,11 @@ function createInsertBeforeFirstVoidBlockPlugin() {
       }
     }]
   };
-  return plateBreak.createExitBreakPlugin(optionsExitBreakPlugin);
-}
-
-var TEXT_PARENT_NODES = /*#__PURE__*/Contentful.VOID_BLOCKS.concat(values(Contentful.INLINES)).concat(Contentful.BLOCKS.PARAGRAPH, Contentful.BLOCKS.HEADING_1, Contentful.BLOCKS.HEADING_2, Contentful.BLOCKS.HEADING_3, Contentful.BLOCKS.HEADING_4, Contentful.BLOCKS.HEADING_5, Contentful.BLOCKS.HEADING_6);
-
-var isTextElement = function isTextElement(node) {
-  return 'text' in node;
-};
-
-var wrapNode = function wrapNode(type, node) {
-  return {
-    type: type,
-    data: {},
-    children: [node]
-  };
-};
-
-function wrapOrphanedTextNode(parentNodeType, node) {
-  var paragraph = wrapNode(Contentful.BLOCKS.PARAGRAPH, node);
-
-  switch (parentNodeType) {
-    case Contentful.BLOCKS.OL_LIST:
-    case Contentful.BLOCKS.UL_LIST:
-      return wrapNode(Contentful.BLOCKS.LIST_ITEM, paragraph);
-
-    case Contentful.BLOCKS.TABLE_ROW:
-      return wrapNode(Contentful.BLOCKS.TABLE_CELL, paragraph);
-
-    case Contentful.BLOCKS.TABLE:
-      return wrapNode(Contentful.BLOCKS.TABLE_ROW, wrapNode(Contentful.BLOCKS.TABLE_CELL, paragraph));
-
-    default:
-      return paragraph;
-  }
-}
-/**
- * Ensures "orphaned" text node elements (those without a parent capable of
- * validly rendering a text child node) are wrapped with a suitable parent
- * element to prevent failures on the validation layer.
- *
- * It is commonplace for third party plugins (including udecode) to reconcile
- * deletion events by inserting such nodes into their schema. This
- * subprocedure is intended as a guard against such cases.
- */
-
-
-function sanitizeSlateDoc(nodes, parentNodeType) {
-  if (nodes === void 0) {
-    nodes = [];
-  }
-
-  if (parentNodeType === void 0) {
-    parentNodeType = Contentful.BLOCKS.DOCUMENT;
-  }
-
-  return nodes.map(function (node) {
-    if (isTextElement(node)) {
-      return TEXT_PARENT_NODES.includes(parentNodeType) ? node : wrapOrphanedTextNode(parentNodeType, node);
-    }
-
-    return _extends({}, node, {
-      children: sanitizeSlateDoc(node.children, node.type)
-    });
-  });
-}
-/**
- * Ensures incoming void nodes have a child leaf text element.
- */
-
-function sanitizeIncomingSlateDoc(nodes) {
-  if (nodes === void 0) {
-    nodes = [];
-  }
-
-  return nodes.map(function (node) {
-    var _node$children;
-
-    if (isTextElement(node)) {
-      return node;
-    }
-
-    if (node.isVoid && ((_node$children = node.children) == null ? void 0 : _node$children.length) === 0) {
-      return _extends({}, node, {
-        children: [{
-          text: '',
-          data: {}
-        }]
-      });
-    }
-
-    return _extends({}, node, {
-      children: sanitizeIncomingSlateDoc(node.children)
-    });
-  });
+  return plate.createExitBreakPlugin(optionsExitBreakPlugin);
 }
 
 var createTrailingParagraphPlugin = function createTrailingParagraphPlugin() {
-  return plateTrailingBlock.createTrailingBlockPlugin({
+  return plate.createTrailingBlockPlugin({
     type: Contentful.BLOCKS.PARAGRAPH,
     level: 0
   });
@@ -5240,7 +5454,7 @@ function createDragAndDropPlugin() {
   var _DND_BLOCKED_ELEMENTS;
 
   // Elements that don't allow other elements to be dragged into them and which callback should be used
-  var DND_BLOCKED_ELEMENTS = (_DND_BLOCKED_ELEMENTS = {}, _DND_BLOCKED_ELEMENTS[Contentful.BLOCKS.TABLE] = slate.Transforms.removeNodes, _DND_BLOCKED_ELEMENTS[Contentful.BLOCKS.QUOTE] = slate.Transforms.liftNodes, _DND_BLOCKED_ELEMENTS);
+  var DND_BLOCKED_ELEMENTS = (_DND_BLOCKED_ELEMENTS = {}, _DND_BLOCKED_ELEMENTS[Contentful.BLOCKS.QUOTE] = slate.Transforms.liftNodes, _DND_BLOCKED_ELEMENTS);
   var DRAGGABLE_TYPES = [Contentful.BLOCKS.EMBEDDED_ENTRY, Contentful.BLOCKS.EMBEDDED_ASSET, Contentful.INLINES.EMBEDDED_ENTRY];
   /**
    * HTML node names where dropping should be allowed
@@ -5290,7 +5504,7 @@ function createDragAndDropPlugin() {
     // If true, the next handlers will be skipped.
     onDrop: function onDrop(editor) {
       return function (event) {
-        var _Array$from = Array.from(plateCommon.getNodes(editor, {
+        var _Array$from = Array.from(plate.getNodes(editor, {
           match: function match(node) {
             return slate.Editor.isBlock(editor, node) && DRAGGABLE_TYPES.includes(node.type);
           }
@@ -5323,26 +5537,64 @@ function getParents(el) {
   return parents;
 }
 
-var _excluded$1 = ["sdk", "isInitiallyDisabled", "onAction"];
+function createTextPlugin() {
+  return {
+    withOverrides: function withOverrides(editor) {
+      var deleteForward = editor.deleteForward; // When pressing delete instead of backspace
+
+      editor.deleteForward = function (unit) {
+        var _editor$selection;
+
+        var _Editor$nodes = slate.Editor.nodes(editor, {
+          at: (_editor$selection = editor.selection) == null ? void 0 : _editor$selection.focus.path,
+          match: function match(node) {
+            return Contentful.TEXT_CONTAINERS.includes(node.type);
+          }
+        }),
+            nodes = _Editor$nodes[0];
+
+        if (nodes) {
+          var paragraphOrHeading = nodes[0],
+              path = nodes[1];
+          var isTextEmpty = plate.isAncestorEmpty(editor, paragraphOrHeading); // We ignore paragraphs/headings that are children of ul, ol, blockquote, tables, etc
+
+          var isRootLevel = path.length === 1;
+
+          if (isTextEmpty && isRootLevel) {
+            slate.Transforms.removeNodes(editor, {
+              at: path
+            });
+          } else {
+            deleteForward(unit);
+          }
+        } else {
+          deleteForward(unit);
+        }
+      };
+
+      return editor;
+    }
+  };
+}
 
 var getPlugins = function getPlugins(sdk, tracking) {
   var plugins = [// Core
-  plateCore.createReactPlugin(), plateCore.createHistoryPlugin(), // Behavior
+  plate.createReactPlugin(), plate.createHistoryPlugin(), // Behavior
   createPastePlugin(), // Global shortcuts
   createNewLinePlugin(), createInsertBeforeFirstVoidBlockPlugin(), createDragAndDropPlugin(), // Block Elements
   createParagraphPlugin(), createListPlugin(), createHrPlugin(), createHeadingPlugin(), createQuotePlugin(), createTablePlugin(tracking), createEmbeddedEntryBlockPlugin(sdk), createEmbeddedAssetBlockPlugin(sdk), // Inline elements
   createHyperlinkPlugin(sdk), createEmbeddedEntityInlinePlugin(sdk), // Marks
   createBoldPlugin(), createCodePlugin(), createItalicPlugin(), createUnderlinePlugin(), // Other
-  createTrailingParagraphPlugin()];
-  return plugins.concat([plateHtmlSerializer.createDeserializeHTMLPlugin({
+  createTrailingParagraphPlugin(), createTextPlugin()];
+  return plugins.concat([plate.createDeserializeHTMLPlugin({
     plugins: plugins
-  }), plateAstSerializer.createDeserializeAstPlugin({
+  }), plate.createDeserializeAstPlugin({
     plugins: plugins
   })]);
 };
+var pluginOptions = /*#__PURE__*/_extends({}, withParagraphOptions, withListOptions, withHrOptions, withHeadingOptions, withQuoteOptions, withTableOptions, withEmbeddedEntryBlockOptions, withEmbeddedAssetBlockOptions, withHyperlinkOptions, withEmbeddedEntityInlineOptions, withBoldOptions, withCodeOptions, withItalicOptions, withUnderlineOptions);
 
-var options = /*#__PURE__*/_extends({}, withParagraphOptions, withListOptions, withHrOptions, withHeadingOptions, withQuoteOptions, withTableOptions, withEmbeddedEntryBlockOptions, withEmbeddedAssetBlockOptions, withHyperlinkOptions, withEmbeddedEntityInlineOptions, withBoldOptions, withCodeOptions, withItalicOptions, withUnderlineOptions);
-
+var _excluded$1 = ["sdk", "isInitiallyDisabled", "onAction"];
 var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
   var tracking = useTrackingContext();
   var docFromAdapter = contentfulSlatejsAdapter.toSlatejsDocument({
@@ -5364,7 +5616,7 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
   return /*#__PURE__*/React__default.createElement("div", {
     className: styles.root,
     "data-test-id": "rich-text-editor"
-  }, /*#__PURE__*/React__default.createElement(plateCore.Plate, {
+  }, /*#__PURE__*/React__default.createElement(plate.Plate, {
     id: getContentfulEditorId(props.sdk),
     initialValue: value,
     plugins: plugins,
@@ -5382,7 +5634,7 @@ var ConnectedRichTextEditor = function ConnectedRichTextEditor(props) {
       props.onChange == null ? void 0 : props.onChange(contentfulDoc);
     },
     // @ts-expect-error
-    options: options
+    options: pluginOptions
   }, !props.isToolbarHidden && /*#__PURE__*/React__default.createElement(StickyToolbarWrapper, {
     isDisabled: props.isDisabled
   }, /*#__PURE__*/React__default.createElement(Toolbar, {