@handlewithcare/react-prosemirror 2.0.0

package/dist/cjs/browser.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "browser", {
+    enumerable: true,
+    get: function() {
+        return browser;
+    }
+});
+const nav = typeof navigator != "undefined" ? navigator : null;
+const doc = typeof document != "undefined" ? document : null;
+const agent = nav && nav.userAgent || "";
+const ie_edge = /Edge\/(\d+)/.exec(agent);
+const ie_upto10 = /MSIE \d/.exec(agent);
+const ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(agent);
+const ie = !!(ie_upto10 || ie_11up || ie_edge);
+const ie_version = ie_upto10 ? document.documentMode : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0;
+const gecko = !ie && /gecko\/(\d+)/i.test(agent);
+const gecko_version = gecko && +(/Firefox\/(\d+)/.exec(agent) || [
+    0,
+    0
+])[1];
+const _chrome = !ie && /Chrome\/(\d+)/.exec(agent);
+const chrome = !!_chrome;
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const chrome_version = _chrome ? +_chrome[1] : 0;
+const safari = !ie && !!nav && /Apple Computer/.test(nav.vendor);
+// Is true for both iOS and iPadOS for convenience
+const ios = safari && (/Mobile\/\w+/.test(agent) || !!nav && nav.maxTouchPoints > 2);
+const mac = ios || (nav ? /Mac/.test(nav.platform) : false);
+const windows = nav ? /Win/.test(nav.platform) : false;
+const android = /Android \d/.test(agent);
+const webkit = !!doc && "webkitFontSmoothing" in doc.documentElement.style;
+const webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [
+    0,
+    0
+])[1] : 0;
+const browser = {
+    ie,
+    ie_version,
+    gecko,
+    gecko_version,
+    chrome,
+    chrome_version,
+    safari,
+    ios,
+    mac,
+    windows,
+    android,
+    webkit,
+    webkit_version
+};

package/dist/cjs/components/ChildNodeViews.js

@@ -0,0 +1,376 @@
+"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, {
+    ChildNodeViews: function() {
+        return ChildNodeViews;
+    },
+    wrapInDeco: function() {
+        return wrapInDeco;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptorsContext = require("../contexts/ChildDescriptorsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _iterDeco = require("../decorations/iterDeco.js");
+const _useReactKeys = require("../hooks/useReactKeys.js");
+const _props = require("../props.js");
+const _MarkView = require("./MarkView.js");
+const _NativeWidgetView = require("./NativeWidgetView.js");
+const _NodeView = require("./NodeView.js");
+const _SeparatorHackView = require("./SeparatorHackView.js");
+const _TextNodeView = require("./TextNodeView.js");
+const _TrailingHackView = require("./TrailingHackView.js");
+const _WidgetView = require("./WidgetView.js");
+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 = {
+        __proto__: null
+    };
+    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 wrapInDeco(reactNode, deco) {
+    const { nodeName, ...attrs } = deco.type.attrs;
+    const props = (0, _props.htmlAttrsToReactProps)(attrs);
+    // We auto-wrap text nodes in spans so that we can apply attributes
+    // and styles, but we want to avoid double-wrapping the same
+    // text node
+    if (nodeName || typeof reactNode === "string") {
+        return /*#__PURE__*/ (0, _react.createElement)(nodeName ?? "span", props, reactNode);
+    }
+    return /*#__PURE__*/ (0, _react.cloneElement)(reactNode, (0, _props.mergeReactProps)(reactNode.props, props));
+}
+function areChildrenEqual(a, b) {
+    return a.type === b.type && a.marks.every((mark)=>mark.isInSet(b.marks)) && b.marks.every((mark)=>mark.isInSet(a.marks)) && a.key === b.key && (a.type === "node" ? a.outerDeco?.length === b.outerDeco?.length && a.outerDeco?.every((prevDeco)=>b.outerDeco?.some((nextDeco)=>prevDeco.from === nextDeco.from && prevDeco.to && nextDeco.to && prevDeco.type.eq(nextDeco.type))) && a.innerDeco.eq(b.innerDeco) : true) && a.node === b.node && a.widget === b.widget;
+}
+const ChildView = /*#__PURE__*/ (0, _react.memo)(function ChildView(param) {
+    let { child, getInnerPos } = param;
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const getChildPos = (0, _react.useRef)(()=>getInnerPos.current() + child.offset);
+    getChildPos.current = ()=>getInnerPos.current() + child.offset;
+    return child.type === "widget" ? /*#__PURE__*/ _react.default.createElement(_WidgetView.WidgetView, {
+        key: child.key,
+        widget: child.widget,
+        getPos: getChildPos
+    }) : child.type === "native-widget" ? /*#__PURE__*/ _react.default.createElement(_NativeWidgetView.NativeWidgetView, {
+        key: child.key,
+        widget: child.widget,
+        getPos: getChildPos
+    }) : child.node.isText ? /*#__PURE__*/ _react.default.createElement(_ChildDescriptorsContext.ChildDescriptorsContext.Consumer, {
+        key: child.key
+    }, (param)=>{
+        let { siblingsRef, parentRef } = param;
+        return /*#__PURE__*/ _react.default.createElement(_TextNodeView.TextNodeView, {
+            view: view,
+            node: child.node,
+            getPos: getChildPos,
+            siblingsRef: siblingsRef,
+            parentRef: parentRef,
+            decorations: child.outerDeco
+        });
+    }) : /*#__PURE__*/ _react.default.createElement(_NodeView.NodeView, {
+        key: child.key,
+        node: child.node,
+        getPos: getChildPos,
+        outerDeco: child.outerDeco,
+        innerDeco: child.innerDeco
+    });
+});
+const InlinePartition = /*#__PURE__*/ (0, _react.memo)(function InlinePartition(param) {
+    let { childViews, getInnerPos } = param;
+    const firstChild = childViews[0];
+    const getFirstChildPos = (0, _react.useRef)(()=>getInnerPos.current() + firstChild.offset);
+    getFirstChildPos.current = ()=>getInnerPos.current() + firstChild.offset;
+    const firstMark = firstChild.marks[0];
+    if (!firstMark) {
+        return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, childViews.map((child)=>{
+            return /*#__PURE__*/ _react.default.createElement(ChildView, {
+                key: child.key,
+                child: child,
+                getInnerPos: getInnerPos
+            });
+        }));
+    }
+    return /*#__PURE__*/ _react.default.createElement(_MarkView.MarkView, {
+        getPos: getFirstChildPos,
+        key: firstChild.key,
+        mark: firstMark
+    }, /*#__PURE__*/ _react.default.createElement(InlineView, {
+        key: firstChild.key,
+        getInnerPos: getInnerPos,
+        childViews: childViews.map((child)=>({
+                ...child,
+                marks: child.marks.slice(1)
+            }))
+    }));
+});
+const InlineView = /*#__PURE__*/ (0, _react.memo)(function InlineView(param) {
+    let { getInnerPos, childViews } = param;
+    // const editorState = useEditorState();
+    const partitioned = childViews.reduce((acc, child)=>{
+        const lastPartition = acc[acc.length - 1];
+        if (!lastPartition) {
+            return [
+                [
+                    child
+                ]
+            ];
+        }
+        const lastChild = lastPartition[lastPartition.length - 1];
+        if (!lastChild) {
+            return [
+                ...acc.slice(0, acc.length),
+                [
+                    child
+                ]
+            ];
+        }
+        if (!child.marks.length && !lastChild.marks.length || child.marks.length && lastChild.marks.length && // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        child.marks[0]?.eq(lastChild.marks[0])) {
+            return [
+                ...acc.slice(0, acc.length - 1),
+                [
+                    ...lastPartition.slice(0, lastPartition.length),
+                    child
+                ]
+            ];
+        }
+        return [
+            ...acc,
+            [
+                child
+            ]
+        ];
+    }, []);
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, partitioned.map((childViews)=>{
+        const firstChild = childViews[0];
+        if (!firstChild) return null;
+        return /*#__PURE__*/ _react.default.createElement(InlinePartition, {
+            key: firstChild.key,
+            childViews: childViews,
+            getInnerPos: getInnerPos
+        });
+    }));
+});
+function createKey(innerPos, offset, type, posToKey, widget, index) {
+    const pos = innerPos + offset;
+    const key = posToKey?.get(pos);
+    if (type === "widget" || type === "native-widget") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (widget.type.spec.key) // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return widget.type.spec.key;
+        // eslint-disable-next-line no-console
+        console.warn(`Widget at position ${pos} doesn't have a key specified. This may cause issues.`);
+        return `${key}-${index}`;
+    }
+    if (key) return key;
+    // if (!doc) return pos;
+    const parentPos = innerPos - 1;
+    const parentKey = posToKey?.get(parentPos);
+    if (parentKey) return `${parentKey}-${offset}`;
+    return pos;
+}
+function adjustWidgetMarksForward(lastNodeChild, widgetChild) {
+    if (!widgetChild || // Using internal Decoration property, "type"
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    widgetChild.widget.type.side >= 0) return;
+    if (!lastNodeChild || !lastNodeChild.node.isInline) return;
+    const marksToSpread = lastNodeChild.marks;
+    widgetChild.marks = widgetChild.marks.reduce((acc, mark)=>mark.addToSet(acc), marksToSpread);
+}
+function adjustWidgetMarksBack(widgetChildren, nodeChild) {
+    if (!nodeChild.node.isInline) return;
+    const marksToSpread = nodeChild.marks;
+    for(let i = widgetChildren.length - 1; i >= 0; i--){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const child = widgetChildren[i];
+        if (// Using internal Decoration property, "type"
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        child.widget.type.side < 0) {
+            continue;
+        }
+        child.marks = child.marks.reduce((acc, mark)=>mark.addToSet(acc), marksToSpread);
+    }
+}
+const ChildElement = /*#__PURE__*/ (0, _react.memo)(function ChildElement(param) {
+    let { child, getInnerPos } = param;
+    const getNodePos = (0, _react.useRef)(()=>getInnerPos.current() + child.offset);
+    getNodePos.current = ()=>getInnerPos.current() + child.offset;
+    if (child.type === "node") {
+        return child.marks.reduce((element, mark)=>/*#__PURE__*/ _react.default.createElement(_MarkView.MarkView, {
+                getPos: getNodePos,
+                mark: mark
+            }, element), /*#__PURE__*/ _react.default.createElement(_NodeView.NodeView, {
+            key: child.key,
+            outerDeco: child.outerDeco,
+            node: child.node,
+            innerDeco: child.innerDeco,
+            getPos: getNodePos
+        }));
+    } else {
+        return /*#__PURE__*/ _react.default.createElement(InlineView, {
+            key: child.key,
+            childViews: [
+                child
+            ],
+            getInnerPos: getInnerPos
+        });
+    }
+});
+function createChildElements(children, getInnerPos) {
+    if (!children.length) return [];
+    if (children.every((child)=>child.type !== "node" || child.node.isInline)) {
+        return [
+            /*#__PURE__*/ _react.default.createElement(InlineView, {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                key: children[0].key,
+                childViews: children,
+                getInnerPos: getInnerPos
+            })
+        ];
+    }
+    return children.map((child)=>{
+        return /*#__PURE__*/ _react.default.createElement(ChildElement, {
+            key: child.key,
+            child: child,
+            getInnerPos: getInnerPos
+        });
+    });
+}
+const ChildNodeViews = /*#__PURE__*/ (0, _react.memo)(function ChildNodeViews(param) {
+    let { getPos, node, innerDecorations } = param;
+    // const editorState = useEditorState();
+    const reactKeys = (0, _useReactKeys.useReactKeys)();
+    const getInnerPos = (0, _react.useRef)(()=>getPos.current() + 1);
+    const childMap = (0, _react.useRef)(new Map()).current;
+    if (!node) return null;
+    const keysSeen = new Set();
+    let widgetChildren = [];
+    let lastNodeChild = null;
+    (0, _iterDeco.iterDeco)(node, innerDecorations, (widget, isNative, offset, index)=>{
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const widgetMarks = widget.type.spec.marks ?? [];
+        let key;
+        if (isNative) {
+            key = createKey(getInnerPos.current(), offset, "native-widget", reactKeys?.posToKey, widget, index);
+            const child = {
+                type: "native-widget",
+                widget,
+                marks: widgetMarks,
+                offset,
+                index,
+                key
+            };
+            const prevChild = childMap.get(key);
+            if (prevChild && areChildrenEqual(prevChild, child)) {
+                prevChild.offset = offset;
+            } else {
+                childMap.set(key, child);
+            }
+            keysSeen.add(key);
+        } else {
+            key = createKey(getInnerPos.current(), offset, "widget", reactKeys?.posToKey, widget, index);
+            const child = {
+                type: "widget",
+                widget: widget,
+                marks: widgetMarks,
+                offset,
+                index,
+                key
+            };
+            const prevChild = childMap.get(key);
+            if (prevChild && areChildrenEqual(prevChild, child)) {
+                prevChild.offset = offset;
+            } else {
+                childMap.set(key, child);
+            }
+            keysSeen.add(key);
+        }
+        const child = childMap.get(key);
+        widgetChildren.push(child);
+        adjustWidgetMarksForward(lastNodeChild, childMap.get(key));
+    }, (childNode, outerDeco, innerDeco, offset)=>{
+        const key = createKey(getInnerPos.current(), offset, "node", reactKeys?.posToKey);
+        const child = {
+            type: "node",
+            node: childNode,
+            marks: childNode.marks,
+            innerDeco,
+            outerDeco,
+            offset,
+            key
+        };
+        const prevChild = childMap.get(key);
+        if (prevChild && areChildrenEqual(prevChild, child)) {
+            prevChild.offset = offset;
+            lastNodeChild = prevChild;
+        } else {
+            childMap.set(key, child);
+            lastNodeChild = child;
+        }
+        keysSeen.add(key);
+        adjustWidgetMarksBack(widgetChildren, lastNodeChild);
+        widgetChildren = [];
+    });
+    for (const key of childMap.keys()){
+        if (!keysSeen.has(key)) {
+            childMap.delete(key);
+        }
+    }
+    const children = Array.from(childMap.values()).sort((a, b)=>a.offset - b.offset);
+    const childElements = createChildElements(children, getInnerPos);
+    const lastChild = children[children.length - 1];
+    if (!lastChild || lastChild.type !== "node" || lastChild.node.isInline && !lastChild.node.isText || // RegExp.test actually handles undefined just fine
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    /\n$/.test(lastChild.node.text)) {
+        childElements.push(/*#__PURE__*/ _react.default.createElement(_SeparatorHackView.SeparatorHackView, {
+            getPos: getInnerPos,
+            key: "trailing-hack-img"
+        }), /*#__PURE__*/ _react.default.createElement(_TrailingHackView.TrailingHackView, {
+            getPos: getInnerPos,
+            key: "trailing-hack-br"
+        }));
+    }
+    return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, childElements);
+});

package/dist/cjs/components/CursorWrapper.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CursorWrapper", {
+    enumerable: true,
+    get: function() {
+        return CursorWrapper;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _dom = require("../dom.js");
+const _useEditorEffect = require("../hooks/useEditorEffect.js");
+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 = {
+        __proto__: null
+    };
+    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;
+}
+const CursorWrapper = /*#__PURE__*/ (0, _react.forwardRef)(function CursorWrapper(param, ref) {
+    let { widget, getPos, ...props } = param;
+    const [shouldRender, setShouldRender] = (0, _react.useState)(true);
+    const innerRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>{
+        return innerRef.current;
+    }, []);
+    (0, _useEditorEffect.useEditorEffect)((view)=>{
+        if (!view || !innerRef.current) return;
+        // @ts-expect-error Internal property - domObserver
+        view.domObserver.disconnectSelection();
+        // @ts-expect-error Internal property - domSelection
+        const domSel = view.domSelection();
+        const range = document.createRange();
+        const node = innerRef.current;
+        const img = node.nodeName == "IMG";
+        if (img && node.parentNode) {
+            range.setEnd(node.parentNode, (0, _dom.domIndex)(node) + 1);
+        } else {
+            range.setEnd(node, 0);
+        }
+        range.collapse(false);
+        domSel.removeAllRanges();
+        domSel.addRange(range);
+        setShouldRender(false);
+        // @ts-expect-error Internal property - domObserver
+        view.domObserver.connectSelection();
+    }, []);
+    return shouldRender ? /*#__PURE__*/ _react.default.createElement("img", {
+        ref: innerRef,
+        className: "ProseMirror-separator",
+        // eslint-disable-next-line react/no-unknown-property
+        "mark-placeholder": "true",
+        alt: "",
+        ...props
+    }) : null;
+});

package/dist/cjs/components/CustomNodeView.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CustomNodeView", {
+    enumerable: true,
+    get: function() {
+        return CustomNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _useClientOnly = require("../hooks/useClientOnly.js");
+const _ChildNodeViews = require("./ChildNodeViews.js");
+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 = {
+        __proto__: null
+    };
+    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 CustomNodeView(param) {
+    let { contentDomRef, customNodeViewRef, customNodeViewRootRef, customNodeView, initialNode, node, getPos, initialOuterDeco, initialInnerDeco, innerDeco } = param;
+    const { view } = (0, _react.useContext)(_EditorContext.EditorContext);
+    const shouldRender = (0, _useClientOnly.useClientOnly)();
+    if (!shouldRender) return null;
+    if (!customNodeViewRef.current) {
+        customNodeViewRef.current = customNodeView(initialNode.current, // customNodeView will only be set if view is set, and we can only reach
+        // this line if customNodeView is set
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        view, ()=>getPos.current(), initialOuterDeco.current, initialInnerDeco.current);
+    }
+    const { contentDOM } = customNodeViewRef.current;
+    contentDomRef.current = contentDOM ?? null;
+    return /*#__PURE__*/ (0, _react.createElement)(node.isInline ? "span" : "div", {
+        ref: customNodeViewRootRef,
+        contentEditable: !!contentDOM,
+        suppressContentEditableWarning: true
+    }, contentDOM && /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    }), contentDOM));
+}