@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/components/TextNodeView.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TextNodeView", {
+    enumerable: true,
+    get: function() {
+        return TextNodeView;
+    }
+});
+const _prosemirrorview = require("prosemirror-view");
+const _react = require("react");
+const _ReactEditorView = require("../ReactEditorView.js");
+const _findDOMNode = require("../findDOMNode.js");
+const _viewdesc = require("../viewdesc.js");
+const _ChildNodeViews = require("./ChildNodeViews.js");
+function shallowEqual(objA, objB) {
+    if (objA === objB) {
+        return true;
+    }
+    if (!objA || !objB) {
+        return false;
+    }
+    const aKeys = Object.keys(objA);
+    const bKeys = Object.keys(objB);
+    const len = aKeys.length;
+    if (bKeys.length !== len) {
+        return false;
+    }
+    for(let i = 0; i < len; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const key = aKeys[i];
+        if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+let TextNodeView = class TextNodeView extends _react.Component {
+    viewDescRef = createMutRef();
+    create() {
+        const { view, decorations, siblingsRef, parentRef, getPos, node } = this.props;
+        const dom = (0, _findDOMNode.findDOMNode)(this);
+        if (!dom && !view.composing) return null;
+        let textNode = dom;
+        while(textNode?.firstChild){
+            textNode = textNode.firstChild;
+        }
+        if (!(textNode instanceof Text)) {
+            textNode = null;
+        }
+        if (!dom || !textNode) return null;
+        const viewDesc = new _viewdesc.TextViewDesc(parentRef.current, [], getPos, node, decorations, _prosemirrorview.DecorationSet.empty, dom, textNode);
+        (0, _viewdesc.placeViewDesc)(siblingsRef.current, viewDesc);
+        return viewDesc;
+    }
+    update() {
+        const { view, node, decorations } = this.props;
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) return false;
+        const viewDesc = this.viewDescRef.current;
+        if (!viewDesc) return false;
+        const dom = (0, _findDOMNode.findDOMNode)(this);
+        if (!dom || dom !== viewDesc.dom) return false;
+        if (!dom.contains(viewDesc.nodeDOM)) return false;
+        return viewDesc.matchesNode(node, decorations, _prosemirrorview.DecorationSet.empty) || viewDesc.update(node, decorations, _prosemirrorview.DecorationSet.empty, view);
+    }
+    destroy() {
+        const viewDesc = this.viewDescRef.current;
+        if (!viewDesc) return;
+        viewDesc.destroy();
+        const siblings = this.props.siblingsRef.current;
+        if (siblings.includes(viewDesc)) {
+            const index = siblings.indexOf(viewDesc);
+            siblings.splice(index, 1);
+        }
+    }
+    updateEffect() {
+        if (!this.update()) {
+            this.destroy();
+            this.viewDescRef.current = this.create();
+        }
+    }
+    shouldComponentUpdate(nextProps) {
+        return !shallowEqual(this.props, nextProps);
+    }
+    constructor(props){
+        super(props);
+        this.viewDescRef.current = null;
+    }
+    componentDidMount() {
+        this.viewDescRef.current = this.create();
+        this.updateEffect();
+    }
+    componentDidUpdate() {
+        this.updateEffect();
+        const { view } = this.props;
+        if (!(view instanceof _ReactEditorView.ReactEditorView)) return;
+    }
+    componentWillUnmount() {
+        this.destroy();
+    }
+    render() {
+        const { node, decorations } = this.props;
+        return decorations.reduce(_ChildNodeViews.wrapInDeco, node.text);
+    }
+};
+/**
+ * createRef returns a RefObject, even though the docs
+ * say that it's acceptible to manage the ref's value
+ * yourself.
+ */ function createMutRef() {
+    return /*#__PURE__*/ (0, _react.createRef)();
+}

package/dist/cjs/components/TrailingHackView.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TrailingHackView", {
+    enumerable: true,
+    get: function() {
+        return TrailingHackView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _useClientLayoutEffect = require("../hooks/useClientLayoutEffect.js");
+const _viewdesc = require("../viewdesc.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 TrailingHackView(param) {
+    let { getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptionsContext.ChildDescriptionsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const ref = (0, _react.useRef)(null);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        const siblings = siblingsRef.current;
+        return ()=>{
+            if (!viewDescRef.current) return;
+            if (siblings.includes(viewDescRef.current)) {
+                const index = siblings.indexOf(viewDescRef.current);
+                siblings.splice(index, 1);
+            }
+        };
+    }, [
+        siblingsRef
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!ref.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.TrailingHackViewDesc(parentRef.current, [], getPos, ref.current, null);
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.dom = ref.current;
+        }
+        (0, _viewdesc.placeViewDesc)(siblingsRef.current, viewDescRef.current);
+    });
+    return /*#__PURE__*/ _react.default.createElement("br", {
+        ref: ref,
+        className: "ProseMirror-trailingBreak"
+    });
+}

package/dist/cjs/components/WidgetView.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WidgetView", {
+    enumerable: true,
+    get: function() {
+        return WidgetView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _useClientLayoutEffect = require("../hooks/useClientLayoutEffect.js");
+const _viewdesc = require("../viewdesc.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 WidgetView(param) {
+    let { widget, getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptionsContext.ChildDescriptionsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const domRef = (0, _react.useRef)(null);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        const siblings = siblingsRef.current;
+        return ()=>{
+            if (!viewDescRef.current) return;
+            if (siblings.includes(viewDescRef.current)) {
+                const index = siblings.indexOf(viewDescRef.current);
+                siblings.splice(index, 1);
+            }
+        };
+    }, [
+        siblingsRef
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!domRef.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.WidgetViewDesc(parentRef.current, getPos, widget, domRef.current);
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.widget = widget;
+            viewDescRef.current.dom = domRef.current;
+            viewDescRef.current.dom.pmViewDesc = viewDescRef.current;
+        }
+        (0, _viewdesc.placeViewDesc)(siblingsRef.current, viewDescRef.current);
+    });
+    const { Component } = widget.type;
+    return Component && /*#__PURE__*/ _react.default.createElement(Component, {
+        ref: domRef,
+        widget: widget,
+        getPos: getPos,
+        ...!widget.type.spec.raw && {
+            contentEditable: false
+        }
+    });
+}

package/dist/cjs/components/WidgetViewComponentProps.js

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

package/dist/cjs/components/marks/DefaultMarkView.js

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

package/dist/cjs/components/marks/MarkView.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkView", {
+    enumerable: true,
+    get: function() {
+        return MarkView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _NodeViewContext = require("../../contexts/NodeViewContext.js");
+const _DefaultMarkView = require("./DefaultMarkView.js");
+const _MarkViewConstructorView = require("./MarkViewConstructorView.js");
+const _ReactMarkView = require("./ReactMarkView.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 MarkView = /*#__PURE__*/ (0, _react.memo)(function MarkView(props) {
+    const { components, constructors } = (0, _react.useContext)(_NodeViewContext.NodeViewContext);
+    const component = components[props.mark.type.name] ?? _DefaultMarkView.DefaultMarkView;
+    const constructor = constructors[props.mark.type.name];
+    // Construct a wrapper component so that the mark view remounts when either
+    // its component or constructor changes. A React mark view would remount
+    // if its underlying component changed without this wrapper, but a custom
+    // mark view otherwise uses the same React components for all custom mark views.
+    const Component = (0, _react.useMemo)(()=>{
+        if (constructor) {
+            return function MarkView(props) {
+                return /*#__PURE__*/ _react.default.createElement(_MarkViewConstructorView.MarkViewConstructorView, {
+                    constructor: constructor,
+                    ...props
+                });
+            };
+        }
+        return function NodeView(props) {
+            return /*#__PURE__*/ _react.default.createElement(_ReactMarkView.ReactMarkView, {
+                component: component,
+                ...props
+            });
+        };
+    }, [
+        component,
+        constructor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(Component, props);
+});

package/dist/cjs/components/marks/MarkViewComponentProps.js

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

package/dist/cjs/components/marks/MarkViewConstructorView.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkViewConstructorView", {
+    enumerable: true,
+    get: function() {
+        return MarkViewConstructorView;
+    }
+});
+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 _useMarkViewDescription = require("../../hooks/useMarkViewDescription.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 MarkViewConstructorView = /*#__PURE__*/ (0, _react.memo)(function MarkViewConstructorView(param) {
+    let { constructor, mark, inline, getPos, children } = param;
+    const ref = (0, _react.useRef)(null);
+    const innerRef = (0, _react.useRef)(null);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const markProps = (0, _react.useMemo)(()=>({
+            mark,
+            inline,
+            getPos,
+            contentDOMRef: {
+                current: null
+            }
+        }), [
+        mark,
+        inline,
+        getPos
+    ]);
+    const createMarkView = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const markView = constructor(...args);
+        if (!markView || !markView.dom) {
+            const spec = mark.type.spec.toDOM?.(mark, inline);
+            if (!spec) {
+                throw new Error(`Mark spec for ${mark.type.name} is missing toDOM`);
+            }
+            return _prosemirrormodel.DOMSerializer.renderSpec(document, spec, null);
+        }
+        return markView;
+    };
+    const { childContextValue, contentDOM } = (0, _useMarkViewDescription.useMarkViewDescription)(()=>ref.current, (markView)=>markView?.contentDOM ?? null, function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        const markView = createMarkView(...args);
+        const dom = markView.dom;
+        const wrapperDOM = innerRef.current ?? ref.current;
+        wrapperDOM.appendChild(dom);
+        // Force a re-render so that we properly create
+        // a portal into the contentDOM/dom
+        forceUpdate();
+        return {
+            ...markView,
+            destroy () {
+                markView.destroy?.();
+                wrapperDOM.removeChild(dom);
+            },
+            ignoreMutation: markView.ignoreMutation
+        };
+    }, markProps);
+    const Component = inline ? "span" : "div";
+    const props = {
+        ref: innerRef
+    };
+    return /*#__PURE__*/ _react.default.createElement(Component, props, contentDOM ? /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, children), contentDOM) : null);
+});

package/dist/cjs/components/marks/ReactMarkView.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactMarkView", {
+    enumerable: true,
+    get: function() {
+        return ReactMarkView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../../contexts/ChildDescriptionsContext.js");
+const _IgnoreMutationContext = require("../../contexts/IgnoreMutationContext.js");
+const _useMarkViewDescription = require("../../hooks/useMarkViewDescription.js");
+const _useSetDom = require("../../hooks/useSetDom.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 ReactMarkView = /*#__PURE__*/ (0, _react.memo)(function ReactMarkView(param) {
+    let { component: Component, mark, inline, getPos, children } = param;
+    const ref = (0, _react.useRef)(null);
+    const contentDOMRef = (0, _react.useRef)(null);
+    const ignoreMutationRef = (0, _react.useRef)(null);
+    const setIgnoreMutation = (0, _react.useCallback)((handler)=>{
+        ignoreMutationRef.current = handler;
+        return ()=>{
+            ignoreMutationRef.current = null;
+            return ()=>{
+                ignoreMutationRef.current = null;
+            };
+        };
+    }, []);
+    const markViewDescProps = (0, _react.useMemo)(()=>({
+            mark,
+            getPos,
+            inline
+        }), [
+        getPos,
+        inline,
+        mark
+    ]);
+    const { childContextValue, refUpdated } = (0, _useMarkViewDescription.useMarkViewDescription)(()=>ref.current, ()=>contentDOMRef.current ?? ref.current, ()=>({
+            dom: ref.current,
+            contentDOM: contentDOMRef.current ?? ref.current,
+            ignoreMutation (mutation) {
+                const ignoreMutation = ignoreMutationRef.current;
+                if (ignoreMutation) {
+                    return ignoreMutation.call(this, mutation);
+                }
+                return false;
+            }
+        }), markViewDescProps);
+    const setDOM = (0, _useSetDom.useSetDom)(ref, refUpdated);
+    const setContentDOM = (0, _useSetDom.useSetDom)(contentDOMRef, refUpdated);
+    const markProps = (0, _react.useMemo)(()=>({
+            ...markViewDescProps,
+            contentDOMRef: setContentDOM
+        }), [
+        markViewDescProps,
+        setContentDOM
+    ]);
+    const props = {
+        markProps,
+        ref: setDOM
+    };
+    return /*#__PURE__*/ _react.default.createElement(_IgnoreMutationContext.IgnoreMutationContext.Provider, {
+        value: setIgnoreMutation
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: childContextValue
+    }, /*#__PURE__*/ _react.default.createElement(Component, props, children)));
+});