@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/cjs/components/LayoutGroup.js

@@ -0,0 +1,112 @@
+/* Copyright (c) The New York Times Company */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LayoutGroup", {
+    enumerable: true,
+    get: function() {
+        return LayoutGroup;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _LayoutGroupContext = require("../contexts/LayoutGroupContext.js");
+const _useClientLayoutEffect = require("../hooks/useClientLayoutEffect.js");
+const _useForceUpdate = require("../hooks/useForceUpdate.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 LayoutGroup(param) {
+    let { children } = param;
+    const createQueue = (0, _react.useRef)(new Set()).current;
+    const destroyQueue = (0, _react.useRef)(new Set()).current;
+    const isMounted = (0, _react.useRef)(false);
+    const forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+    const isUpdatePending = (0, _react.useRef)(true);
+    const ensureFlush = (0, _react.useCallback)(()=>{
+        if (!isUpdatePending.current) {
+            forceUpdate();
+            isUpdatePending.current = true;
+        }
+    }, [
+        forceUpdate
+    ]);
+    const register = (0, _react.useCallback)((effect)=>{
+        let destroy;
+        const create = ()=>{
+            destroy = effect();
+        };
+        createQueue.add(create);
+        ensureFlush();
+        return ()=>{
+            createQueue.delete(create);
+            if (destroy) {
+                if (isMounted.current) {
+                    destroyQueue.add(destroy);
+                    ensureFlush();
+                } else {
+                    destroy();
+                }
+            }
+        };
+    }, [
+        createQueue,
+        destroyQueue,
+        ensureFlush
+    ]);
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        isUpdatePending.current = false;
+        createQueue.forEach((create)=>create());
+        createQueue.clear();
+        return ()=>{
+            destroyQueue.forEach((destroy)=>destroy());
+            destroyQueue.clear();
+        };
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        isMounted.current = true;
+        return ()=>{
+            isMounted.current = false;
+        };
+    }, []);
+    return /*#__PURE__*/ _react.default.createElement(_LayoutGroupContext.LayoutGroupContext.Provider, {
+        value: register
+    }, children);
+}

package/dist/cjs/components/NativeWidgetView.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NativeWidgetView", {
+    enumerable: true,
+    get: function() {
+        return NativeWidgetView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _useClientLayoutEffect = require("../hooks/useClientLayoutEffect.js");
+const _useEditorEffect = require("../hooks/useEditorEffect.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 NativeWidgetView(param) {
+    let { widget, getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptionsContext.ChildDescriptionsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const rootDomRef = (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, _useEditorEffect.useEditorEffect)((view)=>{
+        if (!rootDomRef.current) return;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const toDOM = widget.type.toDOM;
+        let dom = typeof toDOM === "function" ? toDOM(view, getPos) : toDOM;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!widget.type.spec.raw) {
+            if (dom.nodeType != 1) {
+                const wrap = document.createElement("span");
+                wrap.appendChild(dom);
+                dom = wrap;
+            }
+            if (!dom.hasAttribute("contenteditable")) {
+                dom.contentEditable = "false";
+            }
+            dom.classList.add("ProseMirror-widget");
+        }
+        if (rootDomRef.current.firstElementChild === dom) return;
+        rootDomRef.current.replaceChildren(dom);
+    });
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        if (!rootDomRef.current) return;
+        if (!viewDescRef.current) {
+            viewDescRef.current = new _viewdesc.WidgetViewDesc(parentRef.current, getPos, widget, rootDomRef.current);
+        } else {
+            viewDescRef.current.parent = parentRef.current;
+            viewDescRef.current.widget = widget;
+            viewDescRef.current.dom = rootDomRef.current;
+        }
+        (0, _viewdesc.placeViewDesc)(siblingsRef.current, viewDescRef.current);
+    });
+    return /*#__PURE__*/ _react.default.createElement("span", {
+        ref: rootDomRef
+    });
+}

package/dist/cjs/components/OutputSpec.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "OutputSpec", {
+    enumerable: true,
+    get: function() {
+        return ForwardedOutputSpec;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _props = require("../props.js");
+const _refs = require("../refs.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;
+}
+/**
+ * Whether an output spec contains a hole
+ */ function hasHole(outputSpec) {
+    if (!Array.isArray(outputSpec)) {
+        throw new Error("@handlewithcare/react-prosemirror only supports strings and arrays in toDOM");
+    }
+    const attrs = outputSpec[1];
+    let start = 1;
+    if (attrs && typeof attrs === "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+        start = 2;
+    }
+    for(let i = start; i < outputSpec.length; i++){
+        const child = outputSpec[i];
+        if (child === 0) {
+            return true;
+        }
+        if (hasHole(child)) return true;
+    }
+    return false;
+}
+const ForwardedOutputSpec = /*#__PURE__*/ (0, _react.memo)(/*#__PURE__*/ (0, _react.forwardRef)(function OutputSpec(param, ref) {
+    let { outputSpec, isMark, contentDOMRef, children, ...propOverrides } = param;
+    const mergedRef = (0, _refs.useMergedDOMRefs)(ref, contentDOMRef);
+    if (typeof outputSpec === "string") {
+        return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, outputSpec);
+    }
+    if (!Array.isArray(outputSpec)) {
+        throw new Error("@handlewithcare/react-prosemirror only supports strings and arrays in toDOM");
+    }
+    const tagSpec = outputSpec[0];
+    const tagName = tagSpec.replace(" ", ":");
+    const attrs = outputSpec[1];
+    let props = {
+        ref,
+        ...propOverrides
+    };
+    let start = 1;
+    if (attrs && typeof attrs === "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+        start = 2;
+        props = (0, _props.mergeReactProps)((0, _props.htmlAttrsToReactProps)(attrs), props);
+    }
+    const content = [];
+    for(let i = start; i < outputSpec.length; i++){
+        const child = outputSpec[i];
+        if (child === 0) {
+            if (i < outputSpec.length - 1 || i > start) {
+                throw new RangeError("Content hole must be the only child of its parent node");
+            }
+            return /*#__PURE__*/ (0, _react.createElement)(tagName, {
+                ...props,
+                ref: ref ? mergedRef : contentDOMRef
+            }, children);
+        }
+        content.push(/*#__PURE__*/ _react.default.createElement(ForwardedOutputSpec, {
+            outputSpec: child,
+            contentDOMRef: contentDOMRef
+        }, children));
+    }
+    // https://prosemirror.net/docs/ref/#model.MarkSpec.toDOM
+    // When the resulting spec contains a hole, that is where the
+    // marked content is placed. Otherwise, it is appended to the top node.
+    if (isMark && !hasHole(outputSpec)) {
+        content.push(children);
+        props.ref = mergedRef;
+    }
+    return /*#__PURE__*/ (0, _react.createElement)(tagName, props, ...content);
+}));

package/dist/cjs/components/ProseMirror.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ProseMirror", {
+    enumerable: true,
+    get: function() {
+        return ProseMirror;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _ChildDescriptionsContext = require("../contexts/ChildDescriptionsContext.js");
+const _EditorContext = require("../contexts/EditorContext.js");
+const _EditorStateContext = require("../contexts/EditorStateContext.js");
+const _NodeViewContext = require("../contexts/NodeViewContext.js");
+const _RenderStoreContext = require("../contexts/RenderStoreContext.js");
+const _computeDocDeco = require("../decorations/computeDocDeco.js");
+const _viewDecorations = require("../decorations/viewDecorations.js");
+const _useEditor = require("../hooks/useEditor.js");
+const _EditorStateSelectorsProvider = require("./EditorStateSelectorsProvider.js");
+const _LayoutGroup = require("./LayoutGroup.js");
+const _ProseMirrorDoc = require("./ProseMirrorDoc.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 getPos() {
+    return -1;
+}
+const rootChildDescriptionsContextValue = {
+    parentRef: {
+        current: undefined
+    },
+    siblingsRef: {
+        current: []
+    }
+};
+function ProseMirrorInner(param) {
+    let { children, nodeViewComponents, markViewComponents, ...props } = param;
+    const [mount, setMount] = (0, _react.useState)(null);
+    const { editor, state, renderStore } = (0, _useEditor.useEditor)(mount, props);
+    const nodeViewConstructors = editor.view.nodeViews;
+    const nodeViewContextValue = (0, _react.useMemo)(()=>{
+        return {
+            components: {
+                ...nodeViewComponents,
+                ...markViewComponents
+            },
+            constructors: nodeViewConstructors
+        };
+    }, [
+        markViewComponents,
+        nodeViewComponents,
+        nodeViewConstructors
+    ]);
+    const node = state.doc;
+    const decorations = (0, _computeDocDeco.computeDocDeco)(editor.view);
+    const innerDecorations = (0, _viewDecorations.viewDecorations)(editor.view);
+    const docNodeViewContextValue = (0, _react.useMemo)(()=>({
+            setMount,
+            node,
+            getPos,
+            decorations,
+            innerDecorations
+        }), [
+        node,
+        decorations,
+        innerDecorations
+    ]);
+    // An announced render keeps the previous context values: the consumers
+    // re-render through the store in this pass anyway. The flag is consumed
+    // here, so that a render the announcement did not cover (a transaction
+    // dispatched from a layout effect, say) changes the contexts again.
+    const contextValuesRef = (0, _react.useRef)({
+        state,
+        doc: docNodeViewContextValue
+    });
+    if (renderStore) {
+        renderStore.state = state;
+        renderStore.doc = docNodeViewContextValue;
+        if (!renderStore.announced) {
+            contextValuesRef.current = {
+                state,
+                doc: docNodeViewContextValue
+            };
+        }
+        renderStore.announced = false;
+    }
+    const contextValues = renderStore ? contextValuesRef.current : {
+        state,
+        doc: docNodeViewContextValue
+    };
+    return /*#__PURE__*/ _react.default.createElement(_EditorContext.EditorContext.Provider, {
+        value: editor
+    }, /*#__PURE__*/ _react.default.createElement(_RenderStoreContext.RenderStoreContext.Provider, {
+        value: renderStore
+    }, /*#__PURE__*/ _react.default.createElement(_EditorStateContext.EditorStateContext.Provider, {
+        value: contextValues.state
+    }, /*#__PURE__*/ _react.default.createElement(_EditorStateSelectorsProvider.EditorStateSelectorsProvider, null, /*#__PURE__*/ _react.default.createElement(_NodeViewContext.NodeViewContext.Provider, {
+        value: nodeViewContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ChildDescriptionsContext.ChildDescriptionsContext.Provider, {
+        value: rootChildDescriptionsContextValue
+    }, /*#__PURE__*/ _react.default.createElement(_ProseMirrorDoc.DocNodeViewContext.Provider, {
+        value: contextValues.doc
+    }, children)))))));
+}
+function ProseMirror(props) {
+    return /*#__PURE__*/ _react.default.createElement(_LayoutGroup.LayoutGroup, null, /*#__PURE__*/ _react.default.createElement(_EditorStateSelectorsProvider.EditorStateSelectorsRegistrar, null, /*#__PURE__*/ _react.default.createElement(ProseMirrorInner, props)));
+}

package/dist/cjs/components/ProseMirrorDoc.js

@@ -0,0 +1,74 @@
+"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, {
+    DocNodeViewContext: function() {
+        return DocNodeViewContext;
+    },
+    ProseMirrorDoc: function() {
+        return ProseMirrorDoc;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _RenderStoreContext = require("../contexts/RenderStoreContext.js");
+const _DocNodeView = require("./nodes/DocNodeView.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 DocNodeViewContext = /*#__PURE__*/ (0, _react.createContext)(null);
+const ProseMirrorDoc = /*#__PURE__*/ (0, _react.forwardRef)(function ProseMirrorDoc(param, ref) {
+    let { as, ...props } = param;
+    const docProps = (0, _react.useContext)(DocNodeViewContext);
+    const store = (0, _RenderStoreContext.useRenderStore)();
+    return /*#__PURE__*/ _react.default.createElement(_DocNodeView.DocNodeView, {
+        ref: ref,
+        ...props,
+        ...store?.doc ?? docProps,
+        as: as
+    });
+});

package/dist/cjs/components/SeparatorHackView.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SeparatorHackView", {
+    enumerable: true,
+    get: function() {
+        return SeparatorHackView;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _browser = require("../browser.js");
+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 SeparatorHackView(param) {
+    let { getPos } = param;
+    const { siblingsRef, parentRef } = (0, _react.useContext)(_ChildDescriptionsContext.ChildDescriptionsContext);
+    const viewDescRef = (0, _react.useRef)(null);
+    const ref = (0, _react.useRef)(null);
+    const [shouldRender, setShouldRender] = (0, _react.useState)(false);
+    (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
+    ]);
+    // There's no risk of an infinite loop here, because
+    // we call setShouldRender conditionally
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, _useClientLayoutEffect.useClientLayoutEffect)(()=>{
+        const nonHackSiblings = siblingsRef.current.filter((viewdesc)=>!(viewdesc instanceof _viewdesc.TrailingHackViewDesc));
+        const lastSibling = nonHackSiblings[nonHackSiblings.length - 1];
+        if (!shouldRender && (_browser.browser.safari || _browser.browser.chrome) && lastSibling?.dom?.contentEditable == "false") {
+            setShouldRender(true);
+            return;
+        }
+        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 shouldRender ? /*#__PURE__*/ _react.default.createElement("img", {
+        ref: ref,
+        className: "ProseMirror-separator",
+        alt: ""
+    }) : null;
+}