@contentful/field-editor-rich-text 3.16.8 → 3.16.11

package/dist/esm/plugins/Table/components/ToolbarButton.js

@@ -14,12 +14,11 @@ export function ToolbarTableButton(props) {
         focus(editor);
     }
     if (!editor) return null;
-    return /*#__PURE__*/ React.createElement(ToolbarButton, {
+    return React.createElement(ToolbarButton, {
         title: "Table",
         testId: "table-toolbar-button",
         onClick: handleClick,
-        // TODO: active state looks off since the button will be disabled. Do we still need it?
         isActive: !!isActive,
         isDisabled: props.isDisabled
-    }, /*#__PURE__*/ React.createElement(TableIcon, null));
+    }, React.createElement(TableIcon, null));
 }

package/dist/esm/plugins/Table/createTablePlugin.js

@@ -15,15 +15,11 @@ import { addTableTrackingEvents, withInvalidCellChildrenTracking } from './table
 export const createTablePlugin = ()=>createDefaultTablePlugin({
         type: BLOCKS.TABLE,
         handlers: {
-            // @ts-expect-error
             onKeyDown: onKeyDownTable
         },
         withOverrides: (editor, plugin)=>{
-            const { normalizeNode } = editor;
-            // injects important fixes from plate's original table plugin
+            const { normalizeNode  } = editor;
             withTable(editor, plugin);
-            // Resets all normalization rules added by @udecode/plate-table as
-            // they conflict with our own
             editor.normalizeNode = normalizeNode;
             addTableTrackingEvents(editor);
             editor.insertFragment = insertTableFragment(editor);
@@ -38,10 +34,7 @@ export const createTablePlugin = ()=>createDefaultTablePlugin({
                         validNode: isNotEmpty
                     },
                     {
-                        // Move to root level unless nested
                         validNode: (editor, [, path])=>{
-                            // Nested tables are handled by another normalization
-                            // rule in a the table cell level
                             const isNestedTable = !!getBlockAbove(editor, {
                                 at: path,
                                 match: {
@@ -69,11 +62,9 @@ export const createTablePlugin = ()=>createDefaultTablePlugin({
                         transform: transformWrapIn(BLOCKS.TABLE_CELL)
                     },
                     {
-                        // Remove empty rows
                         validNode: isNotEmpty
                     },
                     {
-                        // Parent must be a table
                         validNode: (editor, [, path])=>{
                             const parent = getParentNode(editor, path)?.[0];
                             return parent && parent.type === BLOCKS.TABLE;
@@ -81,7 +72,6 @@ export const createTablePlugin = ()=>createDefaultTablePlugin({
                         transform: transformWrapIn(BLOCKS.TABLE)
                     },
                     {
-                        // ensure consistent number of cells in each row
                         validNode: (editor, entry)=>{
                             return getNoOfMissingTableCellsInRow(editor, entry) === 0;
                         },

package/dist/esm/plugins/Table/helpers.js

@@ -71,30 +71,21 @@ export function replaceEmptyParagraphWithTable(editor) {
     const [previousNode] = nodes;
     const isPreviousNodeTextEmpty = isAncestorEmpty(editor, previousNode);
     if (isPreviousNodeTextEmpty) {
-        // Switch table with previous empty paragraph
         moveNodes(editor, {
             at: tablePath,
             to: previousPath
         });
-        // Remove previous paragraph that now is under the table
         removeNodes(editor, {
             at: tablePath
         });
     }
 }
-/**
- * Returns the number of cells in a given row vs the table width
- *
- * Note: We should only get different table rows cell counts in between
- * normalization cycles.
- */ export const getNoOfMissingTableCellsInRow = (editor, rowEntry)=>{
+export const getNoOfMissingTableCellsInRow = (editor, rowEntry)=>{
     const [, rowPath] = rowEntry;
     const parent = getParentNode(editor, rowPath);
-    // This is ensured by normalization. The error is here just in case
     if (!parent) {
         throw new Error('table rows must be wrapped in a table node');
     }
-    // The longest table row determines its width
     const tableWidth = Math.max(...getChildren(parent).map((entry)=>getChildren(entry).length));
     const rowWidth = getChildren(rowEntry).length;
     return tableWidth - rowWidth;

package/dist/esm/plugins/Table/insertTableFragment.js

@@ -2,29 +2,18 @@ import { BLOCKS } from '@contentful/rich-text-types';
 import { insertEmptyParagraph } from '../../helpers/editor';
 import { getText, isElement } from '../../internal/queries';
 import { isTable } from './helpers';
-/**
- * Removes table wrappers when pasting a single table cell
- *
- * In Plate/Slate, copying the content of a table cell wraps
- * it in a <table><tr><td>{content}</td></tr></table> even
- * when copying partial cell content.
- *
- * That's really annoying as there is no way to remove the table
- * wrappers in that case.
- */ const trimUnnecessaryTableWrapper = (node)=>{
+const trimUnnecessaryTableWrapper = (node)=>{
     if (!isElement(node)) {
         return [
             node
         ];
     }
-    // must be a table with a single row
     if (node.type !== BLOCKS.TABLE || node.children?.length !== 1) {
         return [
             node
         ];
     }
     const row = node.children[0];
-    // the row must contain a single cell
     if (row?.children?.length !== 1) {
         return [
             node
@@ -34,14 +23,12 @@ import { isTable } from './helpers';
     return cell.children;
 };
 export const insertTableFragment = (editor)=>{
-    const { insertFragment } = editor;
+    const { insertFragment  } = editor;
     return (fragments)=>{
         if (!editor.selection) {
             return;
         }
         fragments = fragments.flatMap(trimUnnecessaryTableWrapper);
-        // We need to make sure we have a new, empty and clean paragraph in order to paste tables as-is due to how Slate behaves
-        // More info: https://github.com/ianstormtaylor/slate/pull/4489 and https://github.com/ianstormtaylor/slate/issues/4542
         const isInsertingTable = fragments.some((fragment)=>isTable(fragment));
         const isTableFirstFragment = fragments.findIndex((fragment)=>isTable(fragment)) === 0;
         const currentLineHasText = getText(editor, editor.selection?.focus.path) !== '';

package/dist/esm/plugins/Table/onKeyDownTable.js

@@ -7,13 +7,8 @@ import { addRowBelow } from './actions';
 export const onKeyDownTable = (editor, plugin)=>{
     const defaultHandler = defaultKeyDownTable(editor, plugin);
     return (event)=>{
-        // This fixes `Cannot resolve a Slate point from DOM point:
-        // [object HTMLDivElement]` when typing while the cursor is before table
         const windowSelection = window.getSelection();
-        // @ts-expect-error
-        // this attribute comes from `plugins/Table/components/Table.tsx`
         if (windowSelection?.anchorNode?.attributes) {
-            // @ts-expect-error
             const blockType = windowSelection.anchorNode.attributes?.['data-block-type']?.value;
             const isBeforeTable = blockType === BLOCKS.TABLE;
             if (isBeforeTable) {
@@ -35,11 +30,10 @@ export const onKeyDownTable = (editor, plugin)=>{
                 return;
             }
         }
-        // TODO clean this up
         if (event.key === 'Backspace') {
             const entry = getTableEntries(editor, {});
             if (entry) {
-                const { table, row, cell } = entry;
+                const { table , row , cell  } = entry;
                 const cellText = getText(editor, cell[1]);
                 const isFirstCell = isFirstChild(row[1]);
                 const isFirstRow = isFirstChild(table[1]);
@@ -50,18 +44,15 @@ export const onKeyDownTable = (editor, plugin)=>{
                 }
             }
         }
-        // Pressing Tab on the last cell creates a new row
-        // Otherwise, jumping between cells is handled in the defaultKeyDownTable
         if (event.key === 'Tab' && !event.shiftKey) {
             event.preventDefault();
             const entry = getTableEntries(editor, {});
             if (entry) {
-                const { table, row, cell } = entry;
+                const { table , row , cell  } = entry;
                 const isLastCell = isLastChildPath(row, cell[1]);
                 const isLastRow = isLastChildPath(table, row[1]);
                 if (isLastRow && isLastCell) {
                     addRowBelow(editor);
-                    // skip default handler
                     return;
                 } else {
                     defaultHandler(event);

package/dist/esm/plugins/Table/tableTracking.js

@@ -2,22 +2,22 @@ import { BLOCKS } from '@contentful/rich-text-types';
 import { isElement } from '../../internal/queries';
 import { getPastingSource } from '../../plugins/Tracking';
 function hasTables(nodes) {
-    return nodes.some(({ type })=>{
+    return nodes.some(({ type  })=>{
         return type === BLOCKS.TABLE;
     });
 }
-const isTableHeaderCell = ({ type })=>type === BLOCKS.TABLE_HEADER_CELL;
+const isTableHeaderCell = ({ type  })=>type === BLOCKS.TABLE_HEADER_CELL;
 function hasHeadersOutsideFirstRow(nodes) {
-    return nodes.filter(({ type })=>type === BLOCKS.TABLE).flatMap(({ children })=>children.slice(1)).some(({ children })=>children.some(isTableHeaderCell));
+    return nodes.filter(({ type  })=>type === BLOCKS.TABLE).flatMap(({ children  })=>children.slice(1)).some(({ children  })=>children.some(isTableHeaderCell));
 }
 export function addTableTrackingEvents(editor) {
-    const { insertData } = editor;
+    const { insertData  } = editor;
     editor.insertData = (data)=>{
         const html = data.getData('text/html');
         if (html) {
-            const { children: markupBefore } = editor;
+            const { children: markupBefore  } = editor;
             insertData(data);
-            const { children: markupAfter } = editor;
+            const { children: markupAfter  } = editor;
             setTimeout(()=>{
                 if (hasTables(markupBefore)) return;
                 if (hasTables(markupAfter)) {

package/dist/esm/plugins/Text/__tests__/createTextPlugin.test.js

@@ -1,24 +1,23 @@
-/** @jsx jsx */ import { jsx, assertOutput, createTestEditor } from '../../../test-utils';
+import { jsx, assertOutput, createTestEditor } from '../../../test-utils';
 describe('delete backward', ()=>{
     const tests = [
         {
             title: 'deletes a character of the text inside li',
-            input: /*#__PURE__*/ jsx("hul", null, /*#__PURE__*/ jsx("hli", null, /*#__PURE__*/ jsx("hp", null, "p1", /*#__PURE__*/ jsx("cursor", null)))),
-            expected: /*#__PURE__*/ jsx("hul", null, /*#__PURE__*/ jsx("hli", null, /*#__PURE__*/ jsx("hp", null, "p", /*#__PURE__*/ jsx("cursor", null))))
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1", jsx("cursor", null)))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, "p", jsx("cursor", null))))
         },
         {
             title: 'does not delete the very first paragraph',
-            input: /*#__PURE__*/ jsx("fragment", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null)), /*#__PURE__*/ jsx("hp", null, "text")),
-            expected: /*#__PURE__*/ jsx("fragment", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null)), /*#__PURE__*/ jsx("hp", null, "text"))
+            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text")),
+            expected: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text"))
         }
     ];
-    const render = (children)=>/*#__PURE__*/ jsx("editor", null, children, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", null)));
+    const render = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
     for (const t of tests){
         test(t.title, ()=>{
-            const { editor } = createTestEditor({
+            const { editor  } = createTestEditor({
                 input: render(t.input)
             });
-            // Equivalent of pressing backspace
             editor.deleteBackward('character');
             assertOutput({
                 editor,
@@ -31,32 +30,31 @@ describe('delete forward', ()=>{
     const tests = [
         {
             title: 'deletes a character of the text inside li',
-            input: /*#__PURE__*/ jsx("hul", null, /*#__PURE__*/ jsx("hli", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null), "p1"))),
-            expected: /*#__PURE__*/ jsx("hul", null, /*#__PURE__*/ jsx("hli", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null), "1")))
+            input: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1"))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "1")))
         },
         {
             title: 'deletes the first paragraph when followed by another paragraph',
-            input: /*#__PURE__*/ jsx("fragment", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null)), /*#__PURE__*/ jsx("hp", null, "text")),
-            expected: /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null), "text")
+            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hp", null, "text")),
+            expected: jsx("hp", null, jsx("cursor", null), "text")
         },
         {
             title: 'deletes the first paragraph when followed by li',
-            input: /*#__PURE__*/ jsx("fragment", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null)), /*#__PURE__*/ jsx("hul", null, /*#__PURE__*/ jsx("hli", null, /*#__PURE__*/ jsx("hp", null, "p1")))),
-            expected: /*#__PURE__*/ jsx("hul", null, /*#__PURE__*/ jsx("hli", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null), "p1")))
+            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hul", null, jsx("hli", null, jsx("hp", null, "p1")))),
+            expected: jsx("hul", null, jsx("hli", null, jsx("hp", null, jsx("cursor", null), "p1")))
         },
         {
             title: 'deletes the first paragraph when followed by a blockquote',
-            input: /*#__PURE__*/ jsx("fragment", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null)), /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, "p1"))),
-            expected: /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("cursor", null), "p1"))
+            input: jsx("fragment", null, jsx("hp", null, jsx("cursor", null)), jsx("hquote", null, jsx("hp", null, "p1"))),
+            expected: jsx("hquote", null, jsx("hp", null, jsx("cursor", null), "p1"))
         }
     ];
-    const render = (children)=>/*#__PURE__*/ jsx("editor", null, children, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", null)));
+    const render = (children)=>jsx("editor", null, children, jsx("hp", null, jsx("htext", null)));
     for (const t of tests){
         test(t.title, ()=>{
-            const { editor } = createTestEditor({
+            const { editor  } = createTestEditor({
                 input: render(t.input)
             });
-            // Equivalent of pressing backspace
             editor.deleteForward('character');
             assertOutput({
                 editor,

package/dist/esm/plugins/Text/createTextPlugin.js

@@ -5,9 +5,6 @@ export function createTextPlugin(restrictedMarks = []) {
     return {
         key: 'TextPlugin',
         handlers: {
-            // Triple selection in a non-Firefox browser undesirably selects
-            // the start of the next block. Editor.unhangRange helps removing
-            // the extra block at the end.
             onMouseUp: (editor)=>()=>{
                     if (!editor.selection) {
                         return;
@@ -16,16 +13,9 @@ export function createTextPlugin(restrictedMarks = []) {
                 }
         },
         withOverrides: (editor)=>{
-            // Reverts the change made upstream that caused the cursor
-            // to be trapped inside inline elements.
-            //
-            // Reverts https://github.com/ianstormtaylor/slate/pull/4578/
-            // Related https://github.com/ianstormtaylor/slate/issues/4704
-            const { insertText } = editor;
+            const { insertText  } = editor;
             editor.insertText = (text)=>{
-                const { selection } = editor;
-                // If the cursor is at the end of an inline, move it outside
-                // before inserting
+                const { selection  } = editor;
                 if (selection && isRangeCollapsed(selection)) {
                     const inlinePath = getAboveNode(editor, {
                         match: (n)=>isInline(editor, n),
@@ -41,8 +31,7 @@ export function createTextPlugin(restrictedMarks = []) {
                 }
                 return insertText(text);
             };
-            // When pressing delete instead of backspace
-            const { deleteForward, deleteBackward } = editor;
+            const { deleteForward , deleteBackward  } = editor;
             editor.deleteBackward = (unit)=>{
                 deleteEmptyParagraph(unit, editor, deleteBackward);
             };
@@ -78,9 +67,8 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
     if (entry) {
         const [paragraphOrHeading, path] = entry;
         const isTextEmpty = isAncestorEmpty(editor, paragraphOrHeading);
-        // We ignore paragraphs/headings that are children of ul, ol, blockquote, tables, etc
         const isRootLevel = path.length === 1;
-        const hasSiblings = editor.children.length > 1; // prevent editor from losing focus
+        const hasSiblings = editor.children.length > 1;
         if (isTextEmpty && isRootLevel && hasSiblings) {
             removeNodes(editor, {
                 at: path
@@ -114,11 +102,7 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
         deleteFunction(unit);
     }
 }
-/**
- * To be compatible with the old behavior we need to treat each 2 consecutive
- * line breaks as a new paragraph when pasting as plain text (also known as
- * paste and match style in macOS)
- */ function fixPasteAsPlainText(editor) {
+function fixPasteAsPlainText(editor) {
     editor.insertTextData = (data)=>{
         const text = data.getData('text/plain');
         if (!text) {
@@ -127,7 +111,6 @@ function deleteEmptyParagraph(unit, editor, deleteFunction) {
         const lines = text.split(/\n{2}/);
         let split = false;
         for (const line of lines){
-            // empty lines
             if (/^(\r\n?|\n)$/.test(line)) {
                 continue;
             }

package/dist/esm/plugins/Tracking/createTrackingPlugin.js

@@ -21,7 +21,6 @@ export function getPastingSource(data) {
     if (doc.querySelector('meta[content*="Microsoft Word"]')) {
         return 'Microsoft Word';
     }
-    // TODO: MS Word Online doesn't give us specific tags, we might need to have a closer look at its tracking result since we are using generic values to identify it
     if (doc.querySelector('[style*="Arial_MSFontService"]') && (doc.querySelector('.TextRun') || doc.querySelector('.OutlineElement'))) {
         return 'Microsoft Word Online';
     }
@@ -59,7 +58,7 @@ export const createTrackingPlugin = (onAction)=>{
     return {
         key: 'TrackingPlugin',
         withOverrides: (editor)=>{
-            const { insertData } = editor;
+            const { insertData  } = editor;
             editor.tracking = trackingActions;
             editor.insertData = (data)=>{
                 const isCopyAndPaste = data.types.length !== 0;

package/dist/esm/plugins/Tracking/utils.js

@@ -3,7 +3,6 @@ import { documentToPlainTextString } from '@contentful/rich-text-plain-text-rend
 import Schema from '../../constants/Schema';
 export function getCharacterCount(editor) {
     const document = contentfulSlateJSAdapter.toContentfulDocument({
-        // eslint-disable-next-line -- parameter type is not exported @typescript-eslint/no-explicit-any
         document: editor.children,
         schema: Schema
     });

package/dist/esm/plugins/Voids/createVoidsPlugin.js

@@ -4,8 +4,6 @@ export const createVoidsPlugin = ()=>({
         key: 'VoidsPlugin',
         exitBreak: [
             {
-                // Inserts a new paragraph *before* a void element if it's the very first
-                // node on the editor
                 hotkey: 'enter',
                 before: true,
                 query: {
@@ -13,10 +11,7 @@ export const createVoidsPlugin = ()=>({
                 }
             },
             {
-                // Inserts a new paragraph on enter when a void element is focused
                 hotkey: 'enter',
-                // exploit the internal use of Array.slice(0, level + 1) by the exitBreak plugin
-                // to stay in the parent element
                 level: -2,
                 query: {
                     filter: ([node, path])=>!(isRootLevel(path) && isFirstChildPath(path)) && !!node.isVoid

package/dist/esm/plugins/Voids/transformVoid.js

@@ -1,7 +1,5 @@
 import { insertNodes, removeNodes } from '../../internal/transforms';
-/**
- * Re-creates a void node with valid children.
- */ export const transformVoid = (editor, [node, path])=>{
+export const transformVoid = (editor, [node, path])=>{
     const validVoid = {
         ...node,
         children: [
@@ -10,7 +8,6 @@ import { insertNodes, removeNodes } from '../../internal/transforms';
             }
         ]
     };
-    // A workaround because Slate doesn't allow adjusting void nodes children
     removeNodes(editor, {
         at: path
     });

package/dist/esm/plugins/index.js

@@ -24,15 +24,11 @@ import { createTrailingParagraphPlugin } from './TrailingParagraph';
 import { createVoidsPlugin } from './Voids';
 export const getPlugins = (sdk, onAction, restrictedMarks)=>[
         createDeserializeDocxPlugin(),
-        // Tracking - This should come first so all plugins below will have access to `editor.tracking`
         createTrackingPlugin(onAction),
-        // Global / Global shortcuts
         createDragAndDropPlugin(),
-        // Enable command palette plugin only, if at least action type is allowed
         ...Object.values(isCommandPromptPluginEnabled(sdk)).some(Boolean) ? [
             createCommandPalettePlugin()
         ] : [],
-        // Block Elements
         createParagraphPlugin(),
         createListPlugin(),
         createHrPlugin(),
@@ -42,28 +38,20 @@ export const getPlugins = (sdk, onAction, restrictedMarks)=>[
         createEmbeddedEntryBlockPlugin(sdk),
         createEmbeddedAssetBlockPlugin(sdk),
         createEmbeddedResourceBlockPlugin(sdk),
-        // Inline elements
         createHyperlinkPlugin(sdk),
         createEmbeddedEntityInlinePlugin(sdk),
         createEmbeddedResourceInlinePlugin(sdk),
-        // Marks
         createMarksPlugin(),
-        // Other
         createTrailingParagraphPlugin(),
         createTextPlugin(restrictedMarks),
         createVoidsPlugin(),
         createSelectOnBackspacePlugin(),
-        // Pasting content from other sources
         createPasteHTMLPlugin(),
-        // These plugins drive their configurations from the list of plugins
-        // above. They MUST come last.
         createSoftBreakPlugin(),
         createExitBreakPlugin(),
         createResetNodePlugin(),
         createNormalizerPlugin()
     ];
 export const disableCorePlugins = {
-    // Note: Enabled by default since v9.0.0 but it causes Cypress's
-    // .click() command to fail
     eventEditor: true
 };

package/dist/esm/plugins/shared/EmbeddedBlockToolbarIcon.js

@@ -12,7 +12,7 @@ export const styles = {
         marginRight: '10px'
     })
 };
-export function EmbeddedBlockToolbarIcon({ isDisabled, nodeType, onClose }) {
+export function EmbeddedBlockToolbarIcon({ isDisabled , nodeType , onClose  }) {
     const editor = useContentfulEditor();
     const sdk = useSdkContext();
     const handleClick = async (event)=>{
@@ -29,19 +29,19 @@ export function EmbeddedBlockToolbarIcon({ isDisabled, nodeType, onClose }) {
     };
     const type = getEntityTypeFromNodeType(nodeType);
     const baseClass = `rich-text__${nodeType}`;
-    return /*#__PURE__*/ React.createElement(Menu.Item, {
+    return React.createElement(Menu.Item, {
         disabled: isDisabled,
         className: `${baseClass}-list-item`,
         onClick: handleClick,
         testId: `toolbar-toggle-${nodeType}`
-    }, /*#__PURE__*/ React.createElement(Flex, {
+    }, React.createElement(Flex, {
         alignItems: "center",
         flexDirection: "row"
-    }, /*#__PURE__*/ React.createElement(Icon, {
+    }, React.createElement(Icon, {
         as: type === 'Asset' ? AssetIcon : EmbeddedEntryBlockIcon,
         className: `rich-text__embedded-entry-list-icon ${styles.icon}`,
         variant: "secondary"
-    }), /*#__PURE__*/ React.createElement("span", null, type, nodeType == BLOCKS.EMBEDDED_RESOURCE && /*#__PURE__*/ React.createElement(ResourceNewBadge, null))));
+    }), React.createElement("span", null, type, nodeType == BLOCKS.EMBEDDED_RESOURCE && React.createElement(ResourceNewBadge, null))));
 }
 function getEntityTypeFromNodeType(nodeType) {
     const words = nodeType.toLowerCase().split('-');

package/dist/esm/plugins/shared/EmbeddedBlockUtil.js

@@ -5,7 +5,7 @@ import { focus, getNodeEntryFromSelection, insertEmptyParagraph, moveToTheNextCh
 import { watchCurrentSlide } from '../../helpers/sdkNavigatorSlideIn';
 import { getText, getAboveNode, getLastNodeByLevel, insertNodes, setNodes, select, removeNodes } from '../../internal';
 export function getWithEmbeddedBlockEvents(nodeType, sdk) {
-    return (editor, { options: { hotkey } })=>(event)=>{
+    return (editor, { options: { hotkey  }  })=>(event)=>{
             const [, pathToSelectedElement] = getNodeEntryFromSelection(editor, nodeType);
             if (pathToSelectedElement) {
                 const isDelete = event.key === 'Delete';
@@ -31,14 +31,14 @@ export async function selectEntityAndInsert(nodeType, sdk, editor, logAction) {
     logAction('openCreateEmbedDialog', {
         nodeType
     });
-    const { field, dialogs } = sdk;
+    const { field , dialogs  } = sdk;
     const baseConfig = newEntitySelectorConfigFromRichTextField(field, nodeType);
     const selectEntity = baseConfig.entityType === 'Asset' ? dialogs.selectSingleAsset : dialogs.selectSingleEntry;
     const config = {
         ...baseConfig,
         withCreate: true
     };
-    const { selection } = editor;
+    const { selection  } = editor;
     const rteSlide = watchCurrentSlide(sdk.navigator);
     const entity = await selectEntity(config);
     if (!entity) {
@@ -46,8 +46,6 @@ export async function selectEntityAndInsert(nodeType, sdk, editor, logAction) {
             nodeType
         });
     } else {
-        // Selection prevents incorrect position of inserted ref when RTE doesn't have focus
-        // (i.e. when using hotkeys and slide-in)
         select(editor, selection);
         insertBlock(editor, nodeType, entity);
         ensureFollowingParagraph(editor, [
@@ -58,8 +56,6 @@ export async function selectEntityAndInsert(nodeType, sdk, editor, logAction) {
             nodeType
         });
     }
-    // If user chose to create a new entity, this might open slide-in to edit the
-    // entity. In this case, no point in focusing RTE which is now in the slide below.
     rteSlide.onActive(()=>{
         rteSlide.unwatch();
         focus(editor);
@@ -69,17 +65,15 @@ export async function selectResourceEntityAndInsert(sdk, editor, logAction) {
     logAction('openCreateEmbedDialog', {
         nodeType: BLOCKS.EMBEDDED_RESOURCE
     });
-    const { field, dialogs } = sdk;
+    const { field , dialogs  } = sdk;
     const config = newResourceEntitySelectorConfigFromRichTextField(field, BLOCKS.EMBEDDED_RESOURCE);
-    const { selection } = editor;
+    const { selection  } = editor;
     const entity = await dialogs.selectSingleResourceEntry(config);
     if (!entity) {
         logAction('cancelCreateEmbedDialog', {
             nodeType: BLOCKS.EMBEDDED_RESOURCE
         });
     } else {
-        // Selection prevents incorrect position of inserted ref when RTE doesn't have focus
-        // (i.e. when using hotkeys and slide-in)
         select(editor, selection);
         insertBlock(editor, BLOCKS.EMBEDDED_RESOURCE, entity);
         ensureFollowingParagraph(editor, [
@@ -90,7 +84,6 @@ export async function selectResourceEntityAndInsert(sdk, editor, logAction) {
         });
     }
 }
-// TODO: incorporate this logic inside the trailingParagraph plugin instead
 function ensureFollowingParagraph(editor, nodeTypes) {
     const entityBlock = getAboveNode(editor, {
         match: {
@@ -103,8 +96,6 @@ function ensureFollowingParagraph(editor, nodeTypes) {
     const level = entityBlock[1].length - 1;
     const lastNode = getLastNodeByLevel(editor, level);
     const isTextContainer = TEXT_CONTAINERS.includes(lastNode?.[0].type ?? '');
-    // If the new block isn't followed by a sibling text container (e.g. paragraph)
-    // we insert a new empty one. Level 0 is handled by the trailingParagraph plugin
     if (level !== 0 && !isTextContainer) {
         insertEmptyParagraph(editor);
     }
@@ -140,7 +131,6 @@ const createNode = (nodeType, entity)=>{
         isVoid: true
     };
 };
-// TODO: DRY up copied code from HR
 function insertBlock(editor, nodeType, entity) {
     if (!editor?.selection) return;
     const linkedEntityBlock = createNode(nodeType, entity);

package/dist/esm/plugins/shared/EmbeddedInlineToolbarIcon.js

@@ -22,7 +22,7 @@ const styles = {
         }
     })
 };
-export function EmbeddedInlineToolbarIcon({ onClose, nodeType, isDisabled }) {
+export function EmbeddedInlineToolbarIcon({ onClose , nodeType , isDisabled  }) {
     const editor = useContentfulEditor();
     const sdk = useSdkContext();
     async function handleClick(event) {
@@ -36,16 +36,16 @@ export function EmbeddedInlineToolbarIcon({ onClose, nodeType, isDisabled }) {
         }
         moveToTheNextChar(editor);
     }
-    return /*#__PURE__*/ React.createElement(Menu.Item, {
+    return React.createElement(Menu.Item, {
         disabled: isDisabled,
         className: "rich-text__entry-link-block-button",
         testId: `toolbar-toggle-${nodeType}`,
         onClick: handleClick
-    }, /*#__PURE__*/ React.createElement(Flex, {
+    }, React.createElement(Flex, {
         alignItems: "center",
         flexDirection: "row"
-    }, /*#__PURE__*/ React.createElement(EmbeddedEntryInlineIcon, {
+    }, React.createElement(EmbeddedEntryInlineIcon, {
         variant: "secondary",
         className: `rich-text__embedded-entry-list-icon ${styles.icon}`
-    }), /*#__PURE__*/ React.createElement("span", null, "Inline entry", nodeType == INLINES.EMBEDDED_RESOURCE && /*#__PURE__*/ React.createElement(ResourceNewBadge, null))));
+    }), React.createElement("span", null, "Inline entry", nodeType == INLINES.EMBEDDED_RESOURCE && React.createElement(ResourceNewBadge, null))));
 }