@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/components/nodes/DefaultNodeView.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DefaultNodeView", {
+    enumerable: true,
+    get: function() {
+        return DefaultNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _OutputSpec = require("../OutputSpec.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 DefaultNodeView = /*#__PURE__*/ (0, _react.forwardRef)(function DefaultNodeView(param, ref) {
+    let { nodeProps: { node, contentDOMRef }, children, ...props } = param;
+    const spec = (0, _react.useMemo)(()=>node.type.spec.toDOM?.(node), [
+        node
+    ]);
+    if (!spec) {
+        throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+    }
+    return /*#__PURE__*/ _react.default.createElement(_OutputSpec.OutputSpec, {
+        ...props,
+        outputSpec: spec,
+        ref: ref,
+        contentDOMRef: contentDOMRef
+    }, children);
+});

package/dist/cjs/components/nodes/DocNodeView.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DocNodeView", {
+    enumerable: true,
+    get: function() {
+        return DocNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../../contexts/ChildDescriptionsContext.js");
+const _useNodeViewDescription = require("../../hooks/useNodeViewDescription.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;
+}
+const DocNodeView = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function DocNodeView(param, ref) {
+    let { as, node, getPos, decorations, innerDecorations, setMount, ...elementProps } = param;
+    const innerRef = (0, _react.useRef)(null);
+    (0, _react.useImperativeHandle)(ref, ()=>innerRef.current);
+    (0, _react.useImperativeHandle)(setMount, ()=>innerRef.current);
+    const nodeProps = (0, _react.useMemo)(()=>({
+            node,
+            getPos,
+            decorations,
+            innerDecorations,
+            contentDOMRef: innerRef
+        }), [
+        node,
+        getPos,
+        decorations,
+        innerDecorations
+    ]);
+    const { childContextValue } = (0, _useNodeViewDescription.useNodeViewDescription)(()=>innerRef.current, ()=>innerRef.current, ()=>{
+        const dom = innerRef.current;
+        return {
+            dom,
+            contentDOM: dom,
+            update () {
+                return true;
+            }
+        };
+    }, nodeProps);
+    const children = /*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDecorations
+    }));
+    const props = {
+        ...elementProps,
+        suppressContentEditableWarning: true,
+        ref: innerRef
+    };
+    const element = as ? /*#__PURE__*/ (0, _react.createElement)(as, props, children) : /*#__PURE__*/ (0, _react.createElement)("div", props, children);
+    return nodeProps.decorations.reduce(_ChildNodeViews.wrapInDeco, element);
+}));

package/dist/cjs/components/nodes/NodeView.js

@@ -0,0 +1,129 @@
+"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, {
+    GetPosContext: function() {
+        return GetPosContext;
+    },
+    NodeView: function() {
+        return NodeView;
+    },
+    RemountableNodeView: function() {
+        return RemountableNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _NodeViewContext = require("../../contexts/NodeViewContext.js");
+const _useEditorStateSelector = require("../../hooks/useEditorStateSelector.js");
+const _reactKeys = require("../../plugins/reactKeys.js");
+const _DefaultNodeView = require("./DefaultNodeView.js");
+const _NodeViewConstructorView = require("./NodeViewConstructorView.js");
+const _ReactNodeView = require("./ReactNodeView.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 NodeView = /*#__PURE__*/ (0, _react.memo)(function NodeView(param) {
+    let { forceRemount, ...props } = param;
+    const renderRef = (0, _react.useRef)(null);
+    const frozen = (0, _useEditorStateSelector.useEditorStateSelector)((state)=>_reactKeys.reactKeysPluginKey.getState(state)?.freezeFrom === props.getPos());
+    const { components, constructors } = (0, _react.useContext)(_NodeViewContext.NodeViewContext);
+    const committedFrozenRef = (0, _react.useRef)(false);
+    const component = components[props.node.type.name] ?? _DefaultNodeView.DefaultNodeView;
+    const constructor = constructors[props.node.type.name];
+    // Construct a wrapper component so that the node view remounts when either
+    // its component or constructor changes. A React node view would remount if
+    // its underlying component changed without this wrapper, but a custom node
+    // view otherwise uses the same React components for all custom node views.
+    const Component = (0, _react.useMemo)(()=>{
+        if (constructor) {
+            return function NodeView(props) {
+                return /*#__PURE__*/ _react.default.createElement(_NodeViewConstructorView.NodeViewConstructorView, {
+                    constructor: constructor,
+                    ...props
+                });
+            };
+        } else {
+            return function NodeView(props) {
+                return /*#__PURE__*/ _react.default.createElement(_ReactNodeView.ReactNodeView, {
+                    component: component,
+                    ...props
+                });
+            };
+        }
+    }, [
+        constructor,
+        component
+    ]);
+    // Protect content while frozen, and also through the single render where we
+    // leave the frozen state: `committedFrozenRef` still reflects the previous
+    // commit, so we keep returning the exact same cached element reference.
+    const protecting = (frozen || committedFrozenRef.current) && renderRef.current != null;
+    if (!protecting) {
+        renderRef.current = /*#__PURE__*/ _react.default.createElement(GetPosContext.Provider, {
+            value: props.getPos
+        }, /*#__PURE__*/ _react.default.createElement(Component, props));
+    }
+    (0, _react.useLayoutEffect)(()=>{
+        const wasFrozen = committedFrozenRef.current;
+        committedFrozenRef.current = frozen;
+        if (wasFrozen && !frozen) forceRemount();
+    }, [
+        frozen,
+        forceRemount
+    ]);
+    return renderRef.current;
+});
+const GetPosContext = /*#__PURE__*/ (0, _react.createContext)(null);
+function RemountableNodeView(props) {
+    const [key, forceRemount] = (0, _react.useReducer)((x)=>x + 1, 0);
+    return /*#__PURE__*/ _react.default.createElement(NodeView, {
+        key: key.toString(),
+        ...props,
+        forceRemount: forceRemount
+    });
+}

package/dist/cjs/components/nodes/NodeViewComponentProps.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/cjs/components/nodes/NodeViewConstructorView.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NodeViewConstructorView", {
+    enumerable: true,
+    get: function() {
+        return NodeViewConstructorView;
+    }
+});
+const _prosemirrormodel = require("prosemirror-model");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _ChildDescriptionsContext = require("../../contexts/ChildDescriptionsContext.js");
+const _useForceUpdate = require("../../hooks/useForceUpdate.js");
+const _useNodeViewDescription = require("../../hooks/useNodeViewDescription.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;
+}
+const NodeViewConstructorView = /*#__PURE__*/ (0, _react.memo)(function NodeViewConstructorView(param) {
+    let { constructor, node, getPos, innerDeco, outerDeco } = param;
+    const ref = (0, _react.useRef)(null);
+    const innerRef = (0, _react.useRef)(null);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const nodeProps = (0, _react.useMemo)(()=>({
+            node,
+            getPos,
+            decorations: outerDeco,
+            innerDecorations: innerDeco,
+            contentDOMRef: {
+                current: null
+            }
+        }), [
+        node,
+        getPos,
+        outerDeco,
+        innerDeco
+    ]);
+    const createNodeView = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = constructor(...args);
+        if (!nodeView || !nodeView.dom) {
+            const spec = node.type.spec.toDOM?.(node);
+            if (!spec) {
+                throw new Error(`Node spec for ${node.type.name} is missing toDOM`);
+            }
+            return _prosemirrormodel.DOMSerializer.renderSpec(document, spec, null);
+        }
+        return nodeView;
+    };
+    const { childContextValue, contentDOM } = (0, _useNodeViewDescription.useNodeViewDescription)(()=>ref.current, (source)=>source?.contentDOM ?? null, function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const nodeView = createNodeView(...args);
+        const contentDOM = nodeView.contentDOM;
+        const nodeDOM = nodeView.dom;
+        const wrapperDOM = innerRef.current ?? ref.current;
+        wrapperDOM.appendChild(nodeDOM);
+        if (!contentDOM && nodeDOM instanceof HTMLElement && nodeDOM.tagName !== "BR") {
+            if (!nodeDOM.hasAttribute("contenteditable")) {
+                nodeDOM.contentEditable = "false";
+            }
+            if (node.type.spec.draggable) {
+                nodeDOM.draggable = true;
+            }
+        }
+        if (contentDOM) {
+            // Force a re-render if we have a contentDOM,
+            // so that we properly create a portal into it
+            forceUpdate();
+        }
+        return {
+            destroy () {
+                if (nodeView.destroy) {
+                    nodeView.destroy();
+                }
+                wrapperDOM.removeChild(nodeDOM);
+            },
+            dom: nodeView.dom,
+            contentDOM: nodeView.contentDOM,
+            multiType: nodeView.multiType,
+            update: nodeView.update?.bind(nodeView),
+            selectNode: nodeView.selectNode?.bind(nodeView),
+            deselectNode: nodeView.deselectNode?.bind(nodeView),
+            stopEvent: nodeView.stopEvent?.bind(nodeView),
+            ignoreMutation: nodeView.ignoreMutation?.bind(nodeView)
+        };
+    }, nodeProps);
+    const Component = node.isInline ? "span" : "div";
+    const props = {
+        ref: innerRef
+    };
+    const children = !node.isLeaf && contentDOM ? /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    })), contentDOM) : null;
+    return /*#__PURE__*/ (0, _react.cloneElement)(outerDeco.reduce(_ChildNodeViews.wrapInDeco, /*#__PURE__*/ _react.default.createElement(Component, props, children)), {
+        ref
+    });
+});

package/dist/cjs/components/nodes/ReactNodeView.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactNodeView", {
+    enumerable: true,
+    get: function() {
+        return ReactNodeView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../../contexts/ChildDescriptionsContext.js");
+const _IgnoreMutationContext = require("../../contexts/IgnoreMutationContext.js");
+const _SelectNodeContext = require("../../contexts/SelectNodeContext.js");
+const _StopEventContext = require("../../contexts/StopEventContext.js");
+const _useForceUpdate = require("../../hooks/useForceUpdate.js");
+const _useNodeViewDescription = require("../../hooks/useNodeViewDescription.js");
+const _useSetDom = require("../../hooks/useSetDom.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;
+}
+const ReactNodeView = /*#__PURE__*/ (0, _react.memo)(function ReactNodeView(param) {
+    let { component: Component, outerDeco, getPos, node, innerDeco } = param;
+    const [hasCustomSelectNode, setHasCustomSelectNode] = (0, _react.useState)(false);
+    const [selected, setSelected] = (0, _react.useState)(false);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const domRef = (0, _react.useRef)(null);
+    const nodeDOMRef = (0, _react.useRef)(null);
+    const contentDOMRef = (0, _react.useRef)(null);
+    const selectNodeRef = (0, _react.useRef)(null);
+    const deselectNodeRef = (0, _react.useRef)(null);
+    const stopEventRef = (0, _react.useRef)(null);
+    const ignoreMutationRef = (0, _react.useRef)(null);
+    const setSelectNode = (0, _react.useCallback)((selectHandler, deselectHandler)=>{
+        selectNodeRef.current = selectHandler;
+        deselectNodeRef.current = deselectHandler;
+        setHasCustomSelectNode(true);
+        return ()=>{
+            selectNodeRef.current = null;
+            deselectNodeRef.current = null;
+            setHasCustomSelectNode(false);
+        };
+    }, []);
+    const setStopEvent = (0, _react.useCallback)((handler)=>{
+        stopEventRef.current = handler;
+        return ()=>{
+            stopEventRef.current = null;
+        };
+    }, []);
+    const setIgnoreMutation = (0, _react.useCallback)((handler)=>{
+        ignoreMutationRef.current = handler;
+        return ()=>{
+            ignoreMutationRef.current = null;
+            return ()=>{
+                ignoreMutationRef.current = null;
+            };
+        };
+    }, []);
+    const nodeViewDescProps = (0, _react.useMemo)(()=>({
+            node: node,
+            getPos: getPos,
+            decorations: outerDeco,
+            innerDecorations: innerDeco
+        }), [
+        getPos,
+        innerDeco,
+        node,
+        outerDeco
+    ]);
+    const { childContextValue, refUpdated, isMounted } = (0, _useNodeViewDescription.useNodeViewDescription)(()=>domRef.current, ()=>contentDOMRef.current, ()=>{
+        setSelected(false);
+        return {
+            dom: nodeDOMRef.current ?? domRef.current,
+            contentDOM: contentDOMRef.current,
+            update () {
+                return true;
+            },
+            multiType: true,
+            selectNode () {
+                const selectNode = selectNodeRef.current;
+                if (selectNode) {
+                    selectNode.call(this);
+                }
+                setSelected(true);
+            },
+            deselectNode () {
+                const deselectNode = deselectNodeRef.current;
+                if (deselectNode) {
+                    deselectNode.call(this);
+                }
+                setSelected(false);
+            },
+            stopEvent (event) {
+                const stopEvent = stopEventRef.current;
+                if (stopEvent) {
+                    return stopEvent.call(this, event);
+                }
+                return false;
+            },
+            ignoreMutation (mutation) {
+                const ignoreMutation = ignoreMutationRef.current;
+                if (ignoreMutation) {
+                    return ignoreMutation.call(this, mutation);
+                }
+                return false;
+            }
+        };
+    }, nodeViewDescProps);
+    const setDOM = (0, _useSetDom.useSetDom)(domRef, refUpdated, isMounted, forceUpdate);
+    const setNodeDOM = (0, _useSetDom.useSetDom)(nodeDOMRef, refUpdated, isMounted, forceUpdate);
+    const setContentDOM = (0, _useSetDom.useSetDom)(contentDOMRef, refUpdated, isMounted, forceUpdate);
+    const nodeProps = (0, _react.useMemo)(()=>({
+            ...nodeViewDescProps,
+            contentDOMRef: setContentDOM
+        }), [
+        nodeViewDescProps,
+        setContentDOM
+    ]);
+    const props = {
+        nodeProps,
+        ...!contentDOMRef.current && !nodeProps.node.isText && nodeDOMRef.current?.nodeName !== "BR" ? {
+            contentEditable: false,
+            suppressContentEditableWarning: true
+        } : null,
+        ...!hasCustomSelectNode && selected ? {
+            className: "ProseMirror-selectednode"
+        } : null,
+        ...!hasCustomSelectNode && selected || !contentDOMRef.current && !nodeProps.node.isText && domRef.current?.nodeName !== "BR" && node.type.spec.draggable ? {
+            draggable: true
+        } : null,
+        ref: setNodeDOM
+    };
+    const children = !node.isLeaf ? /*#__PURE__*/ _react.default.createElement(_ChildNodeViews.ChildNodeViews, {
+        getPos: getPos,
+        node: node,
+        innerDecorations: innerDeco
+    }) : null;
+    const element = /*#__PURE__*/ (0, _react.cloneElement)(outerDeco.reduce(_ChildNodeViews.wrapInDeco, /*#__PURE__*/ _react.default.createElement(Component, props, children)), {
+        ref: setDOM
+    });
+    return /*#__PURE__*/ _react.default.createElement(_SelectNodeContext.SelectNodeContext.Provider, {
+        value: setSelectNode
+    }, /*#__PURE__*/ _react.default.createElement(_StopEventContext.StopEventContext.Provider, {
+        value: setStopEvent
+    }, /*#__PURE__*/ _react.default.createElement(_IgnoreMutationContext.IgnoreMutationContext.Provider, {
+        value: setIgnoreMutation
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, element))));
+});

package/dist/cjs/constants.js

@@ -0,0 +1,33 @@
+"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, {
+    EMPTY_SCHEMA: function() {
+        return EMPTY_SCHEMA;
+    },
+    EMPTY_STATE: function() {
+        return EMPTY_STATE;
+    }
+});
+const _prosemirrormodel = require("prosemirror-model");
+const _prosemirrorstate = require("prosemirror-state");
+const EMPTY_SCHEMA = new _prosemirrormodel.Schema({
+    nodes: {
+        doc: {
+            content: "text*"
+        },
+        text: {
+            inline: true
+        }
+    }
+});
+const EMPTY_STATE = _prosemirrorstate.EditorState.create({
+    schema: EMPTY_SCHEMA
+});

package/dist/cjs/contexts/ChildDescriptionsContext.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ChildDescriptionsContext", {
+    enumerable: true,
+    get: function() {
+        return ChildDescriptionsContext;
+    }
+});
+const _react = require("react");
+const ChildDescriptionsContext = (0, _react.createContext)({
+    parentRef: {
+        current: undefined
+    },
+    siblingsRef: {
+        current: []
+    }
+});