@handlewithcare/react-prosemirror 2.4.12 → 2.5.1

package/dist/esm/nodeViews/createReactNodeViewConstructor.js

@@ -1,214 +0,0 @@
-import React, { forwardRef, useContext, useImperativeHandle, useState } from "react";
-import { createPortal } from "react-dom";
-import { NodeViewsContext } from "../contexts/NodeViewsContext.js";
-import { useEditorEffect } from "../hooks/useEditorEffect.js";
-import { NodePosProvider } from "../hooks/useNodePos.js";
-import { ROOT_NODE_KEY, createNodeKey, reactPluginKey } from "../plugins/react.js";
-import { phrasingContentTags } from "./phrasingContentTags.js";
-/**
- * Identifies a node view constructor as having been created
- * by @nytimes/react-prosemirror
- */ export const REACT_NODE_VIEW = Symbol("react node view");
-let didWarnReactPlugin = false;
-/**
- * Searches upward for the nearest node with a node key,
- * returning the first node key it finds associated with
- * a React node view.
- *
- * Returns the root key if no ancestor nodes have node keys.
- */ export function findNodeKeyUp(editorView, pos) {
-    const pluginState = reactPluginKey.getState(editorView.state);
-    if (!pluginState) return ROOT_NODE_KEY;
-    const $pos = editorView.state.doc.resolve(pos);
-    for(let d = $pos.depth; d > 0; d--){
-        const ancestorNodeTypeName = $pos.node(d).type.name;
-        const ancestorNodeView = editorView.props.nodeViews?.[ancestorNodeTypeName];
-        if (!ancestorNodeView?.[REACT_NODE_VIEW]) continue;
-        const ancestorPos = $pos.before(d);
-        const ancestorKey = pluginState.posToKey.get(ancestorPos);
-        if (ancestorKey) return ancestorKey;
-    }
-    return ROOT_NODE_KEY;
-}
-/**
- * Factory function for creating nodeViewConstructors that
- * render as React components.
- *
- * `NodeView` can be any React component that takes
- * `NodeViewComponentProps`. It will be passed all of the
- * arguments to the `nodeViewConstructor` except for
- * `editorView`. NodeView components that need access
- * directly to the EditorView should use the
- * `useEditorViewEvent` and `useEditorViewLayoutEffect`
- * hooks to ensure safe access.
- *
- * For contentful Nodes, the NodeView component will also
- * be passed a `children` prop containing an empty element.
- * ProseMirror will render content nodes into this element.
- */ export function createReactNodeViewConstructor(nodeViewConstructor, registerPortal) {
-    function nodeViewConstructorWrapper(node, editorView, getPos, decorations, innerDecorations) {
-        const nodeView = nodeViewConstructor(node, editorView, getPos, decorations, innerDecorations);
-        const { component: NodeView  } = nodeView;
-        if (!NodeView) {
-            return nodeView;
-        }
-        const reactPluginState = reactPluginKey.getState(editorView.state);
-        if (!reactPluginState) {
-            if (!didWarnReactPlugin) {
-                console.error("The React ProseMirror plugin is required to use React node views. " + "Make sure to add it to the ProseMirror editor state.");
-                didWarnReactPlugin = true;
-            }
-            return nodeView;
-        }
-        const { dom , contentDOM  } = nodeView;
-        // Use a span if the provided contentDOM is in the "phrasing" content
-        // category. Otherwise use a div. This is our best attempt at not
-        // breaking the intended content model, for now.
-        //
-        // https://developer.mozilla.org/en-US/docs/Web/HTML/Content_categories#phrasing_content
-        const ContentDOMWrapper = contentDOM && (phrasingContentTags.includes(contentDOM.tagName.toLocaleLowerCase()) ? "span" : "div");
-        const nodeKey = reactPluginState.posToKey.get(getPos()) ?? createNodeKey();
-        /**
-     * Wrapper component to provide some imperative handles for updating
-     * and re-rendering its child. Takes and renders an arbitrary ElementType
-     * that expects NodeViewComponentProps as props.
-     */ const NodeViewWrapper = /*#__PURE__*/ forwardRef(function NodeViewWrapper(param, ref) {
-            let { initialState  } = param;
-            const [node, setNode] = useState(initialState.node);
-            const [decorations, setDecorations] = useState(initialState.decorations);
-            const [isSelected, setIsSelected] = useState(initialState.isSelected);
-            const nodeViews = useContext(NodeViewsContext);
-            const childNodeViews = nodeViews[nodeKey];
-            const [childNodeViewPortals, setChildNodeViewPortals] = useState(childNodeViews?.map((param)=>{
-                let { portal  } = param;
-                return portal;
-            }));
-            // `getPos` is technically derived from the EditorView
-            // state, so it's not safe to call until after the EditorView
-            // has been updated
-            useEditorEffect(()=>{
-                setChildNodeViewPortals(childNodeViews?.sort((a, b)=>a.getPos() - b.getPos()).map((param)=>{
-                    let { portal  } = param;
-                    return portal;
-                }));
-            }, [
-                childNodeViews
-            ]);
-            const [contentDOMWrapper, setContentDOMWrapper] = useState(null);
-            const [contentDOMParent, setContentDOMParent] = useState(null);
-            useImperativeHandle(ref, ()=>({
-                    node,
-                    contentDOMWrapper: contentDOMWrapper,
-                    contentDOMParent: contentDOMParent,
-                    setNode,
-                    setDecorations,
-                    setIsSelected
-                }), [
-                node,
-                contentDOMWrapper,
-                contentDOMParent
-            ]);
-            return /*#__PURE__*/ React.createElement(NodePosProvider, {
-                nodeKey: nodeKey
-            }, /*#__PURE__*/ React.createElement(NodeView, {
-                node: node,
-                decorations: decorations,
-                isSelected: isSelected
-            }, childNodeViewPortals, ContentDOMWrapper && /*#__PURE__*/ React.createElement(ContentDOMWrapper, {
-                style: {
-                    display: "contents"
-                },
-                ref: (nextContentDOMWrapper)=>{
-                    setContentDOMWrapper(nextContentDOMWrapper);
-                    // we preserve a reference to the contentDOMWrapper'
-                    // parent so that later we can reassemble the DOM hierarchy
-                    // React expects when cleaning up the ContentDOMWrapper element
-                    if (nextContentDOMWrapper?.parentNode) {
-                        setContentDOMParent(nextContentDOMWrapper.parentNode);
-                    }
-                }
-            })));
-        });
-        NodeViewWrapper.displayName = `NodeView(${NodeView.displayName ?? NodeView.name})`;
-        let componentRef = null;
-        const element = /*#__PURE__*/ React.createElement(NodeViewWrapper, {
-            initialState: {
-                node,
-                decorations,
-                isSelected: false
-            },
-            ref: (c)=>{
-                componentRef = c;
-                if (!componentRef || componentRef.node.isLeaf) return;
-                const contentDOMWrapper = componentRef.contentDOMWrapper;
-                if (!contentDOMWrapper || !(contentDOMWrapper instanceof HTMLElement)) {
-                    return;
-                }
-                // We always set contentDOM when !node.isLeaf, which is checked above
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                contentDOMWrapper.appendChild(contentDOM);
-                // Synchronize the ProseMirror selection to the DOM, because mounting the
-                // component changes the DOM outside of a ProseMirror update.
-                const { node  } = componentRef;
-                const pos = getPos();
-                const end = pos + node.nodeSize;
-                const { from , to  } = editorView.state.selection;
-                if (editorView.hasFocus() && pos < from && to < end) {
-                    // This call seems like it should be a no-op, given the editor already has
-                    // focus, but it causes ProseMirror to synchronize the DOM selection with
-                    // its state again, placing the DOM selection in a reasonable place within
-                    // the node.
-                    editorView.focus();
-                }
-            }
-        });
-        const portal = /*#__PURE__*/ createPortal(element, dom, nodeKey);
-        const unregisterPortal = registerPortal(editorView, getPos, portal);
-        return {
-            ignoreMutation (record) {
-                return !contentDOM?.contains(record.target);
-            },
-            ...nodeView,
-            selectNode () {
-                componentRef?.setIsSelected(true);
-                nodeView.selectNode?.();
-            },
-            deselectNode () {
-                componentRef?.setIsSelected(false);
-                nodeView.deselectNode?.();
-            },
-            update (node, decorations, innerDecorations) {
-                // If this node view's parent has been removed from the registry, we
-                // need to rebuild it and its children with new registry keys
-                const positionRegistry = reactPluginKey.getState(editorView.state);
-                if (positionRegistry && nodeKey !== positionRegistry.posToKey.get(getPos())) {
-                    return false;
-                }
-                if (nodeView.update?.(node, decorations, innerDecorations) === false) {
-                    return false;
-                }
-                if (node.type === componentRef?.node.type) {
-                    componentRef?.setNode(node);
-                    componentRef?.setDecorations(decorations);
-                    return true;
-                }
-                return false;
-            },
-            destroy () {
-                // React expects the contentDOMParent to be a child of the
-                // DOM element where the portal was mounted, but in some situations
-                // contenteditable may have already detached the contentDOMParent
-                // from the DOM. Here we attempt to reassemble the DOM that React
-                // expects when cleaning up the portal.
-                if (componentRef?.contentDOMParent) {
-                    this.dom.appendChild(componentRef.contentDOMParent);
-                }
-                unregisterPortal();
-                nodeView.destroy?.();
-            }
-        };
-    }
-    return Object.assign(nodeViewConstructorWrapper, {
-        [REACT_NODE_VIEW]: true
-    });
-}

package/dist/esm/nodeViews/phrasingContentTags.js

@@ -1,49 +0,0 @@
-export const phrasingContentTags = [
-    "abbr",
-    "audio",
-    "b",
-    "bdo",
-    "br",
-    "button",
-    "canvas",
-    "cite",
-    "code",
-    "data",
-    "datalist",
-    "dfn",
-    "em",
-    "embed",
-    "i",
-    "iframe",
-    "img",
-    "input",
-    "kbd",
-    "keygen",
-    "label",
-    "mark",
-    "math",
-    "meter",
-    "noscript",
-    "object",
-    "output",
-    "picture",
-    "progress",
-    "q",
-    "ruby",
-    "s",
-    "samp",
-    "script",
-    "select",
-    "small",
-    "span",
-    "strong",
-    "sub",
-    "sup",
-    "svg",
-    "textarea",
-    "time",
-    "u",
-    "var",
-    "video",
-    "wbr"
-];

package/dist/esm/plugins/__tests__/react.test.js

@@ -1,135 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ import { Schema } from "prosemirror-model";
-import { EditorState } from "prosemirror-state";
-import { findWrapping } from "prosemirror-transform";
-import { react, reactPluginKey } from "../react.js";
-const schema = new Schema({
-    nodes: {
-        doc: {
-            content: "block+"
-        },
-        paragraph: {
-            group: "block",
-            content: "inline*"
-        },
-        list: {
-            group: "block",
-            content: "list_item+"
-        },
-        list_item: {
-            content: "paragraph+"
-        },
-        text: {
-            group: "inline"
-        }
-    }
-});
-describe("reactNodeViewPlugin", ()=>{
-    it("should create a unique key for each node", ()=>{
-        const editorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create()
-            ]),
-            plugins: [
-                react()
-            ]
-        });
-        const pluginState = reactPluginKey.getState(editorState);
-        expect(pluginState.posToKey.size).toBe(3);
-    });
-    it("should maintain key stability when possible", ()=>{
-        const initialEditorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create()
-            ]),
-            plugins: [
-                react()
-            ]
-        });
-        const initialPluginState = reactPluginKey.getState(initialEditorState);
-        const nextEditorState = initialEditorState.apply(initialEditorState.tr.insertText("Hello, world!", 1));
-        const nextPluginState = reactPluginKey.getState(nextEditorState);
-        expect(Array.from(nextPluginState.keyToPos.keys())).toEqual(Array.from(initialPluginState.keyToPos.keys()));
-    });
-    it("should create unique keys for new nodes", ()=>{
-        const initialEditorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create(),
-                schema.nodes.paragraph.create()
-            ]),
-            plugins: [
-                react()
-            ]
-        });
-        const initialPluginState = reactPluginKey.getState(initialEditorState);
-        const nextEditorState = initialEditorState.apply(initialEditorState.tr.insert(0, schema.nodes.list.createAndFill()));
-        const nextPluginState = reactPluginKey.getState(nextEditorState);
-        // Adds new keys for new nodes
-        expect(nextPluginState.keyToPos.size).toBe(6);
-        // Maintains keys for previous nodes that are still there
-        Array.from(initialPluginState.keyToPos.keys()).forEach((key)=>{
-            expect(Array.from(nextPluginState.keyToPos.keys())).toContain(key);
-        });
-    });
-    it("should maintain key stability when splitting a node", ()=>{
-        const initialEditorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.list.create(null, [
-                    schema.nodes.list_item.create(null, [
-                        schema.nodes.paragraph.create(null, [
-                            schema.text("first")
-                        ])
-                    ])
-                ])
-            ]),
-            plugins: [
-                react()
-            ]
-        });
-        const initialPluginState = reactPluginKey.getState(initialEditorState);
-        const nextEditorState = initialEditorState.apply(initialEditorState.tr.insert(1, schema.nodes.list_item.create(null, [
-            schema.nodes.paragraph.create(null, [
-                schema.text("second")
-            ])
-        ])));
-        const nextPluginState = reactPluginKey.getState(nextEditorState);
-        // The new list item was inserted before the original one,
-        // pushing it further into the document. The original list
-        // item should keep its original key, and the new list item
-        // should be assigned a new one
-        expect(nextPluginState.posToKey.get(11)).toBe(initialPluginState.posToKey.get(1));
-        expect(nextPluginState.posToKey.get(1)).not.toBe(initialPluginState.posToKey.get(1));
-    });
-    it("should maintain key stability when wrapping a node", ()=>{
-        const initialEditorState = EditorState.create({
-            doc: schema.topNodeType.create(null, [
-                schema.nodes.paragraph.create(null, [
-                    schema.text("content")
-                ])
-            ]),
-            plugins: [
-                react()
-            ]
-        });
-        const initialPluginState = reactPluginKey.getState(initialEditorState);
-        const start = 1;
-        const end = 9;
-        const tr = initialEditorState.tr.delete(start, end);
-        const $start = tr.doc.resolve(start);
-        const range = $start.blockRange();
-        const wrapping = range && findWrapping(range, schema.nodes.list, null);
-        tr.wrap(range, wrapping);
-        const nextEditorState = initialEditorState.apply(tr);
-        const nextPluginState = reactPluginKey.getState(nextEditorState);
-        // The new list and list item nodes were wrapped around the
-        // paragraph, pushing it further into the document. The paragraph
-        // should keep its original key, and the new nodes
-        // should be assigned a new one
-        expect(nextPluginState.posToKey.get(2)).toBe(initialPluginState.posToKey.get(0));
-        expect(nextPluginState.posToKey.get(0)).not.toBe(initialPluginState.posToKey.get(0));
-    });
-});

package/dist/esm/plugins/react.js

@@ -1,64 +0,0 @@
-import { Plugin, PluginKey } from "prosemirror-state";
-/**
- * This is a stand-in for the doc node itself, which doesn't have a
- * unique position to map to.
- */ export const ROOT_NODE_KEY = Symbol("@nytimes/react-prosemirror/root-node-key");
-export function createNodeKey() {
-    return Math.floor(Math.random() * 0xffffff).toString(16);
-}
-export const reactPluginKey = new PluginKey("@nytimes/react-prosemirror/react");
-/**
- * Tracks a unique key for each (non-text) node in the
- * document, identified by its current position. Keys are
- * (mostly) stable across transaction applications. The
- * key for a given node can be accessed by that node's
- * current position in the document, and vice versa.
- */ export function react() {
-    return new Plugin({
-        key: reactPluginKey,
-        state: {
-            init (_, state) {
-                const next = {
-                    posToKey: new Map(),
-                    keyToPos: new Map()
-                };
-                state.doc.descendants((node, pos)=>{
-                    if (node.isText) return false;
-                    const key = createNodeKey();
-                    next.posToKey.set(pos, key);
-                    next.keyToPos.set(key, pos);
-                    return true;
-                });
-                return next;
-            },
-            /**
-       * Keeps node keys (mostly) stable across transactions.
-       *
-       * To accomplish this, we map each node position backwards
-       * through the transaction to identify its previous position,
-       * and thereby retrieve its previous key.
-       */ apply (tr, value, _, newState) {
-                if (!tr.docChanged) return value;
-                const next = {
-                    posToKey: new Map(),
-                    keyToPos: new Map()
-                };
-                for (const [pos, key] of value.posToKey.entries()){
-                    const { pos: newPos , deleted  } = tr.mapping.mapResult(pos);
-                    if (deleted) continue;
-                    next.posToKey.set(newPos, key);
-                    next.keyToPos.set(key, newPos);
-                }
-                newState.doc.descendants((node, pos)=>{
-                    if (node.isText) return false;
-                    if (next.posToKey.has(pos)) return true;
-                    const key = createNodeKey();
-                    next.posToKey.set(pos, key);
-                    next.keyToPos.set(key, pos);
-                    return true;
-                });
-                return next;
-            }
-        }
-    });
-}

package/dist/esm/selection/SelectionDOMObserver.js

@@ -1,161 +0,0 @@
-import { Selection } from "prosemirror-state";
-import { browser } from "../browser.js";
-import { parentNode, selectionCollapsed } from "../dom.js";
-import { hasFocusAndSelection } from "./hasFocusAndSelection.js";
-import { selectionFromDOM } from "./selectionFromDOM.js";
-import { isEquivalentPosition, selectionToDOM } from "./selectionToDOM.js";
-let SelectionState = class SelectionState {
-    anchorNode = null;
-    anchorOffset = 0;
-    focusNode = null;
-    focusOffset = 0;
-    set(sel) {
-        this.anchorNode = sel.anchorNode;
-        this.anchorOffset = sel.anchorOffset;
-        this.focusNode = sel.focusNode;
-        this.focusOffset = sel.focusOffset;
-    }
-    clear() {
-        this.anchorNode = this.focusNode = null;
-    }
-    eq(sel) {
-        return sel.anchorNode == this.anchorNode && sel.anchorOffset == this.anchorOffset && sel.focusNode == this.focusNode && sel.focusOffset == this.focusOffset;
-    }
-};
-export class SelectionDOMObserver {
-    view;
-    flushingSoon;
-    currentSelection;
-    suppressingSelectionUpdates;
-    constructor(view){
-        this.view = view;
-        this.flushingSoon = -1;
-        this.currentSelection = new SelectionState();
-        this.suppressingSelectionUpdates = false;
-        this.view = view;
-        this.onSelectionChange = this.onSelectionChange.bind(this);
-    }
-    connectSelection() {
-        this.view.dom.ownerDocument.addEventListener("selectionchange", this.onSelectionChange);
-    }
-    disconnectSelection() {
-        this.view.dom.ownerDocument.removeEventListener("selectionchange", this.onSelectionChange);
-    }
-    stop() {
-        this.disconnectSelection();
-    }
-    start() {
-        this.connectSelection();
-    }
-    suppressSelectionUpdates() {
-        this.suppressingSelectionUpdates = true;
-        setTimeout(()=>this.suppressingSelectionUpdates = false, 50);
-    }
-    setCurSelection() {
-        // @ts-expect-error Internal method
-        this.currentSelection.set(this.view.domSelectionRange());
-    }
-    ignoreSelectionChange(sel) {
-        if (!sel.focusNode) return true;
-        const ancestors = new Set();
-        let container;
-        for(let scan = sel.focusNode; scan; scan = parentNode(scan))ancestors.add(scan);
-        for(let scan = sel.anchorNode; scan; scan = parentNode(scan))if (ancestors.has(scan)) {
-            container = scan;
-            break;
-        }
-        // @ts-expect-error Internal property (docView)
-        const desc = container && this.view.docView.nearestDesc(container);
-        if (desc && desc.ignoreMutation({
-            type: "selection",
-            target: container?.nodeType == 3 ? container?.parentNode : container
-        })) {
-            this.setCurSelection();
-            return true;
-        }
-        return;
-    }
-    registerMutation() {
-    // pass
-    }
-    flushSoon() {
-        if (this.flushingSoon < 0) this.flushingSoon = window.setTimeout(()=>{
-            this.flushingSoon = -1;
-            this.flush();
-        }, 20);
-    }
-    updateSelection() {
-        const { view } = this;
-        const compositionID = // @ts-expect-error Internal property (input)
-        view.input.compositionPendingChanges || // @ts-expect-error Internal property (input)
-        (view.composing ? view.input.compositionID : 0);
-        // @ts-expect-error Internal property (input)
-        view.input.compositionPendingChanges = 0;
-        const origin = // @ts-expect-error Internal property (input)
-        view.input.lastSelectionTime > Date.now() - 50 ? view.input.lastSelectionOrigin : null;
-        const newSel = selectionFromDOM(view, origin);
-        if (newSel && !view.state.selection.eq(newSel)) {
-            const tr = view.state.tr.setSelection(newSel);
-            if (origin == "pointer") tr.setMeta("pointer", true);
-            else if (origin == "key") tr.scrollIntoView();
-            if (compositionID) tr.setMeta("composition", compositionID);
-            view.dispatch(tr);
-        }
-    }
-    selectionToDOM() {
-        const { view } = this;
-        selectionToDOM(view);
-        // @ts-expect-error Internal property (domSelectionRange)
-        const sel = view.domSelectionRange();
-        this.currentSelection.set(sel);
-    }
-    flush() {
-        const { view } = this;
-        // @ts-expect-error Internal property (docView)
-        if (!view.docView || this.flushingSoon > -1) return;
-        // @ts-expect-error Internal property (domSelectionRange)
-        const sel = view.domSelectionRange();
-        const newSel = !this.suppressingSelectionUpdates && !this.currentSelection.eq(sel) && hasFocusAndSelection(view) && !this.ignoreSelectionChange(sel);
-        let readSel = null;
-        // If it looks like the browser has reset the selection to the
-        // start of the document after focus, restore the selection from
-        // the state
-        if (newSel && // @ts-expect-error Internal property (input)
-        view.input.lastFocus > Date.now() - 200 && // @ts-expect-error Internal property (input)
-        Math.max(view.input.lastTouch, view.input.lastClick.time) < Date.now() - 300 && selectionCollapsed(sel) && (readSel = selectionFromDOM(view)) && readSel.eq(Selection.near(view.state.doc.resolve(0), 1))) {
-            // @ts-expect-error Internal property (input)
-            view.input.lastFocus = 0;
-            selectionToDOM(view);
-            this.currentSelection.set(sel);
-            // @ts-expect-error Internal property (scrollToSelection)
-            view.scrollToSelection();
-        } else if (newSel) {
-            this.updateSelection();
-            if (!this.currentSelection.eq(sel)) selectionToDOM(view);
-            this.currentSelection.set(sel);
-        }
-    }
-    forceFlush() {
-        if (this.flushingSoon > -1) {
-            window.clearTimeout(this.flushingSoon);
-            this.flushingSoon = -1;
-            this.flush();
-        }
-    }
-    onSelectionChange() {
-        if (!hasFocusAndSelection(this.view)) return;
-        if (this.view.composing) return;
-        if (this.suppressingSelectionUpdates) return selectionToDOM(this.view);
-        // Deletions on IE11 fire their events in the wrong order, giving
-        // us a selection change event before the DOM changes are
-        // reported.
-        if (browser.ie && browser.ie_version <= 11 && !this.view.state.selection.empty) {
-            // @ts-expect-error Internal method
-            const sel = this.view.domSelectionRange();
-            // Selection.isCollapsed isn't reliable on IE
-            if (sel.focusNode && isEquivalentPosition(sel.focusNode, sel.focusOffset, // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            sel.anchorNode, sel.anchorOffset)) return this.flushSoon();
-        }
-        this.flush();
-    }
-}

package/dist/esm/selection/hasFocusAndSelection.js

@@ -1,17 +0,0 @@
-export function hasFocusAndSelection(view) {
-    if (view.editable && !view.hasFocus()) return false;
-    return hasSelection(view);
-}
-export function hasSelection(view) {
-    // @ts-expect-error Internal method
-    const sel = view.domSelectionRange();
-    if (!sel.anchorNode) return false;
-    try {
-        // Firefox will raise 'permission denied' errors when accessing
-        // properties of `sel.anchorNode` when it's in a generated CSS
-        // element.
-        return view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode) && (view.editable || view.dom.contains(sel.focusNode?.nodeType == 3 ? sel.focusNode?.parentNode : sel.focusNode));
-    } catch (_) {
-        return false;
-    }
-}