@contentful/field-editor-rich-text 3.4.21 → 3.5.0

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "onKeyDownTable", {
+    enumerable: true,
+    get: function() {
+        return onKeyDownTable;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetable = require("@udecode/plate-table");
+const _editor = require("../../helpers/editor");
+const _misc = require("../../internal/misc");
+const _queries = require("../../internal/queries");
+const _actions = require("./actions");
+const onKeyDownTable = (editor, plugin)=>{
+    const defaultHandler = (0, _platetable.onKeyDownTable)(editor, plugin);
+    return (event)=>{
+        const windowSelection = window.getSelection();
+        if (windowSelection) {
+            const blockType = windowSelection.anchorNode.attributes?.['data-block-type']?.value;
+            const isBeforeTable = blockType === _richtexttypes.BLOCKS.TABLE;
+            if (isBeforeTable) {
+                if (event.key === 'Enter') {
+                    const above = (0, _queries.getAboveNode)(editor, {
+                        match: {
+                            type: _richtexttypes.BLOCKS.TABLE
+                        }
+                    });
+                    if (!above) return;
+                    const [, tablePath] = above;
+                    (0, _editor.insertEmptyParagraph)(editor, {
+                        at: tablePath,
+                        select: true
+                    });
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
+        }
+        if (event.key === 'Tab' && !event.shiftKey) {
+            event.preventDefault();
+            const entry = (0, _platetable.getTableEntries)(editor, {});
+            if (entry) {
+                const { table , row , cell  } = entry;
+                const isLastCell = (0, _queries.isLastChildPath)(row, cell[1]);
+                const isLastRow = (0, _queries.isLastChildPath)(table, row[1]);
+                if (isLastRow && isLastCell) {
+                    (0, _actions.addRowBelow)(editor);
+                    return;
+                } else {
+                    defaultHandler(event);
+                }
+            }
+        }
+        if (event.key === 'Escape') {
+            (0, _misc.blurEditor)(editor);
+        }
+    };
+};

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addTableTrackingEvents: function() {
+        return addTableTrackingEvents;
+    },
+    withInvalidCellChildrenTracking: function() {
+        return withInvalidCellChildrenTracking;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _queries = require("../../internal/queries");
+const _Tracking = require("../../plugins/Tracking");
+function hasTables(nodes) {
+    return nodes.some(({ type  })=>{
+        return type === _richtexttypes.BLOCKS.TABLE;
+    });
+}
+const isTableHeaderCell = ({ type  })=>type === _richtexttypes.BLOCKS.TABLE_HEADER_CELL;
+function hasHeadersOutsideFirstRow(nodes) {
+    return nodes.filter(({ type  })=>type === _richtexttypes.BLOCKS.TABLE).flatMap(({ children  })=>children.slice(1)).some(({ children  })=>children.some(isTableHeaderCell));
+}
+function addTableTrackingEvents(editor) {
+    const { insertData  } = editor;
+    editor.insertData = (data)=>{
+        const html = data.getData('text/html');
+        if (html) {
+            const { children: markupBefore  } = editor;
+            insertData(data);
+            const { children: markupAfter  } = editor;
+            setTimeout(()=>{
+                if (hasTables(markupBefore)) return;
+                if (hasTables(markupAfter)) {
+                    editor.tracking.onViewportAction('paste', {
+                        tablePasted: true,
+                        source: (0, _Tracking.getPastingSource)(data),
+                        hasHeadersOutsideFirstRow: hasHeadersOutsideFirstRow(markupAfter)
+                    });
+                }
+            }, 1);
+        } else {
+            insertData(data);
+        }
+    };
+}
+const withInvalidCellChildrenTracking = (transformer)=>{
+    return (editor, childEntry)=>{
+        const [node] = childEntry;
+        if ((0, _queries.isElement)(node)) {
+            editor.tracking?.onViewportAction('invalidTablePaste', {
+                nodeType: node.type
+            });
+        }
+        return transformer(editor, childEntry);
+    };
+};

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testutils = require("../../../test-utils");
+describe('delete backward', ()=>{
+    const tests = [
+        {
+            title: 'deletes a character of the text inside li',
+            input: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p1", (0, _testutils.jsx)("cursor", null)))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p", (0, _testutils.jsx)("cursor", null))))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hp", null, "text")),
+            expected: (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "text")
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p1")))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1")))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, "p1"))),
+            expected: (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1"))
+        }
+    ];
+    const render = (children)=>(0, _testutils.jsx)("editor", null, children, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", null)));
+    for (const t of tests){
+        test(t.title, ()=>{
+            const { editor  } = (0, _testutils.createTestEditor)({
+                input: render(t.input)
+            });
+            editor.deleteBackward('character');
+            (0, _testutils.assertOutput)({
+                editor,
+                expected: render(t.expected)
+            });
+        });
+    }
+});
+describe('delete forward', ()=>{
+    const tests = [
+        {
+            title: 'deletes a character of the text inside li',
+            input: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1"))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "1")))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hp", null, "text")),
+            expected: (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "text")
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p1")))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1")))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, "p1"))),
+            expected: (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1"))
+        }
+    ];
+    const render = (children)=>(0, _testutils.jsx)("editor", null, children, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", null)));
+    for (const t of tests){
+        test(t.title, ()=>{
+            const { editor  } = (0, _testutils.createTestEditor)({
+                input: render(t.input)
+            });
+            editor.deleteForward('character');
+            (0, _testutils.assertOutput)({
+                editor,
+                expected: render(t.expected)
+            });
+        });
+    }
+});

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTextPlugin", {
+    enumerable: true,
+    get: function() {
+        return createTextPlugin;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _queries = require("../../internal/queries");
+const _transforms = require("../../internal/transforms");
+function createTextPlugin(restrictedMarks = []) {
+    return {
+        key: 'TextPlugin',
+        handlers: {
+            onMouseUp: (editor)=>()=>{
+                    if (!editor.selection) {
+                        return;
+                    }
+                    (0, _transforms.setSelection)(editor, (0, _transforms.unhangRange)(editor, editor.selection));
+                }
+        },
+        withOverrides: (editor)=>{
+            const { insertText  } = editor;
+            editor.insertText = (text)=>{
+                const { selection  } = editor;
+                if (selection && (0, _queries.isRangeCollapsed)(selection)) {
+                    const inlinePath = (0, _queries.getAboveNode)(editor, {
+                        match: (n)=>(0, _queries.isInline)(editor, n),
+                        mode: 'highest'
+                    })?.[1];
+                    if (inlinePath && (0, _queries.isEndPoint)(editor, selection.anchor, inlinePath)) {
+                        const point = (0, _queries.getPointAfter)(editor, inlinePath);
+                        (0, _transforms.setSelection)(editor, {
+                            anchor: point,
+                            focus: point
+                        });
+                    }
+                }
+                return insertText(text);
+            };
+            const { deleteForward , deleteBackward  } = editor;
+            editor.deleteBackward = (unit)=>{
+                deleteEmptyParagraph(unit, editor, deleteBackward);
+            };
+            editor.deleteForward = (unit)=>{
+                deleteEmptyParagraph(unit, editor, deleteForward);
+            };
+            fixPasteAsPlainText(editor);
+            return editor;
+        },
+        normalizer: [
+            {
+                match: _queries.isText,
+                transform: (editor, [, path])=>{
+                    (0, _transforms.unsetNodes)(editor, restrictedMarks, {
+                        at: path
+                    });
+                },
+                validNode: (_editor, [node])=>{
+                    return !restrictedMarks.some((mark)=>{
+                        return mark in node;
+                    });
+                }
+            }
+        ]
+    };
+}
+function deleteEmptyParagraph(unit, editor, deleteFunction) {
+    const entry = (0, _queries.getAboveNode)(editor, {
+        match: {
+            type: _richtexttypes.TEXT_CONTAINERS
+        }
+    });
+    if (entry) {
+        const [paragraphOrHeading, path] = entry;
+        const isTextEmpty = (0, _queries.isAncestorEmpty)(editor, paragraphOrHeading);
+        const isRootLevel = path.length === 1;
+        const hasSiblings = editor.children.length > 1;
+        if (isTextEmpty && isRootLevel && hasSiblings) {
+            (0, _transforms.removeNodes)(editor, {
+                at: path
+            });
+            const prevNode = (0, _queries.getPointBefore)(editor, editor.selection, {
+                unit
+            });
+            if (prevNode) {
+                const [prevCell] = (0, _queries.getNodeEntries)(editor, {
+                    match: (node)=>(0, _queries.queryNode)([
+                            node,
+                            prevNode.path
+                        ], {
+                            allow: [
+                                _richtexttypes.BLOCKS.EMBEDDED_ASSET,
+                                _richtexttypes.BLOCKS.EMBEDDED_ENTRY,
+                                _richtexttypes.BLOCKS.HR
+                            ]
+                        }),
+                    at: prevNode
+                });
+                if (prevCell) {
+                    (0, _transforms.select)(editor, prevNode);
+                }
+            }
+        } else {
+            deleteFunction(unit);
+        }
+    } else {
+        deleteFunction(unit);
+    }
+}
+function fixPasteAsPlainText(editor) {
+    editor.insertTextData = (data)=>{
+        const text = data.getData('text/plain');
+        if (!text) {
+            return false;
+        }
+        const lines = text.split(/\n{2}/);
+        let split = false;
+        for (const line of lines){
+            if (/^(\r\n?|\n)$/.test(line)) {
+                continue;
+            }
+            if (split) {
+                (0, _transforms.splitNodes)(editor, {
+                    always: true
+                });
+            }
+            editor.insertText(line);
+            split = true;
+        }
+        return true;
+    };
+}

package/dist/cjs/plugins/Text/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createTextPlugin"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getPastingSource: function() {
+        return getPastingSource;
+    },
+    createTrackingPlugin: function() {
+        return createTrackingPlugin;
+    }
+});
+const _utils = require("./utils");
+const actionOrigin = {
+    TOOLBAR: 'toolbar-icon',
+    SHORTCUT: 'shortcut',
+    VIEWPORT: 'viewport-interaction',
+    SHORTCUT_OR_VIEWPORT: 'shortcut-or-viewport',
+    COMMAND_PALETTE: 'command-palette'
+};
+function getPastingSource(data) {
+    const textHtml = data.getData('text/html');
+    const doc = new DOMParser().parseFromString(textHtml, 'text/html');
+    if (doc.querySelector('[id*="docs-internal-guid"]')) {
+        return 'Google Docs';
+    }
+    if (doc.querySelector('google-sheets-html-origin') || doc.querySelector('[data-sheets-value]')) {
+        return 'Google Spreadsheets';
+    }
+    if (doc.querySelector('meta[content*="Microsoft Excel"]')) {
+        return 'Microsoft Excel';
+    }
+    if (doc.querySelector('meta[content*="Microsoft Word"]')) {
+        return 'Microsoft Word';
+    }
+    if (doc.querySelector('[style*="Arial_MSFontService"]') && (doc.querySelector('.TextRun') || doc.querySelector('.OutlineElement'))) {
+        return 'Microsoft Word Online';
+    }
+    if (doc.querySelector('meta[content="Cocoa HTML Writer"]')) {
+        return 'Apple Notes';
+    }
+    if (doc.querySelector('[style*="Slack-Lato, Slack-Fractions"]')) {
+        return 'Slack';
+    }
+    return 'Unknown';
+}
+const createTrackingPlugin = (onAction)=>{
+    const trackingActions = {
+        onViewportAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.VIEWPORT,
+                ...data
+            }),
+        onShortcutAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.SHORTCUT,
+                ...data
+            }),
+        onShortcutOrViewportAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.SHORTCUT_OR_VIEWPORT,
+                ...data
+            }),
+        onToolbarAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.TOOLBAR,
+                ...data
+            }),
+        onCommandPaletteAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.COMMAND_PALETTE,
+                ...data
+            })
+    };
+    return {
+        key: 'TrackingPlugin',
+        withOverrides: (editor)=>{
+            const { insertData  } = editor;
+            editor.tracking = trackingActions;
+            editor.insertData = (data)=>{
+                const isCopyAndPaste = data.types.length !== 0;
+                if (isCopyAndPaste) {
+                    const characterCountSelection = window.getSelection()?.toString().length;
+                    const characterCountBefore = (0, _utils.getCharacterCount)(editor);
+                    setTimeout(()=>{
+                        const characterCountAfter = (0, _utils.getCharacterCount)(editor);
+                        trackingActions.onShortcutOrViewportAction('paste', {
+                            characterCountAfter,
+                            characterCountBefore,
+                            characterCountSelection,
+                            source: getPastingSource(data)
+                        });
+                    });
+                }
+                insertData(data);
+            };
+            return editor;
+        }
+    };
+};

package/dist/cjs/plugins/Tracking/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createTrackingPlugin"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCharacterCount", {
+    enumerable: true,
+    get: function() {
+        return getCharacterCount;
+    }
+});
+const _contentfulslatejsadapter = _interop_require_wildcard(require("@contentful/contentful-slatejs-adapter"));
+const _richtextplaintextrenderer = require("@contentful/rich-text-plain-text-renderer");
+const _Schema = _interop_require_default(require("../../constants/Schema"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function getCharacterCount(editor) {
+    const document = _contentfulslatejsadapter.toContentfulDocument({
+        document: editor.children,
+        schema: _Schema.default
+    });
+    return (0, _richtextplaintextrenderer.documentToPlainTextString)(document).length;
+}

package/dist/cjs/plugins/TrailingParagraph/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTrailingParagraphPlugin", {
+    enumerable: true,
+    get: function() {
+        return createTrailingParagraphPlugin;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetrailingblock = require("@udecode/plate-trailing-block");
+const createTrailingParagraphPlugin = ()=>{
+    return (0, _platetrailingblock.createTrailingBlockPlugin)({
+        options: {
+            type: _richtexttypes.BLOCKS.PARAGRAPH,
+            level: 0
+        }
+    });
+};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createVoidsPlugin", {
+    enumerable: true,
+    get: function() {
+        return createVoidsPlugin;
+    }
+});
+const _editor = require("../../helpers/editor");
+const _queries = require("../../internal/queries");
+const createVoidsPlugin = ()=>({
+        key: 'VoidsPlugin',
+        exitBreak: [
+            {
+                hotkey: 'enter',
+                before: true,
+                query: {
+                    filter: ([node, path])=>(0, _editor.isRootLevel)(path) && (0, _queries.isFirstChildPath)(path) && !!node.isVoid
+                }
+            },
+            {
+                hotkey: 'enter',
+                level: -2,
+                query: {
+                    filter: ([node, path])=>!((0, _editor.isRootLevel)(path) && (0, _queries.isFirstChildPath)(path)) && !!node.isVoid
+                }
+            }
+        ]
+    });

package/dist/cjs/plugins/Voids/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createVoidsPlugin"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformVoid", {
+    enumerable: true,
+    get: function() {
+        return transformVoid;
+    }
+});
+const _transforms = require("../../internal/transforms");
+const transformVoid = (editor, [node, path])=>{
+    const validVoid = {
+        ...node,
+        children: [
+            {
+                text: ''
+            }
+        ]
+    };
+    (0, _transforms.removeNodes)(editor, {
+        at: path
+    });
+    (0, _transforms.insertNodes)(editor, [
+        validVoid
+    ], {
+        at: path
+    });
+};