slate-angular 1.9.1 → 13.0.0

package/esm2020/plugins/angular-editor.mjs

@@ -0,0 +1,565 @@
+import { Editor, Path, Range, Transforms, Element } from 'slate';
+import { EDITOR_TO_ELEMENT, ELEMENT_TO_NODE, IS_FOCUSED, IS_READONLY, NODE_TO_INDEX, NODE_TO_PARENT, NODE_TO_ELEMENT, NODE_TO_KEY, EDITOR_TO_WINDOW } from '../utils/weak-maps';
+import { hasShadowRoot, isDOMElement, isDOMSelection, normalizeDOMPoint } from '../utils/dom';
+import { Key } from '../utils/key';
+import { IS_CHROME } from '../utils/environment';
+import { FAKE_LEFT_BLOCK_CARD_OFFSET, FAKE_RIGHT_BLOCK_CARD_OFFSET, getCardTargetAttribute, isCardCenterByTargetAttr, isCardLeftByTargetAttr, isCardRightByTargetAttr } from '../utils/block-card';
+export const AngularEditor = {
+    /**
+     * Return the host window of the current editor.
+     */
+    getWindow(editor) {
+        const window = EDITOR_TO_WINDOW.get(editor);
+        if (!window) {
+            throw new Error('Unable to find a host window element for this editor');
+        }
+        return window;
+    },
+    /**
+     * Find a key for a Slate node.
+     */
+    findKey(editor, node) {
+        let key = NODE_TO_KEY.get(node);
+        if (!key) {
+            key = new Key();
+            NODE_TO_KEY.set(node, key);
+        }
+        return key;
+    },
+    /**
+     * handle editor error.
+     */
+    onError(errorData) {
+        if (errorData.nativeError) {
+            throw errorData.nativeError;
+        }
+    },
+    /**
+     * Find the path of Slate node.
+     */
+    findPath(editor, node) {
+        const path = [];
+        let child = node;
+        while (true) {
+            const parent = NODE_TO_PARENT.get(child);
+            if (parent == null) {
+                if (Editor.isEditor(child)) {
+                    return path;
+                }
+                else {
+                    break;
+                }
+            }
+            const i = NODE_TO_INDEX.get(child);
+            if (i == null) {
+                break;
+            }
+            path.unshift(i);
+            child = parent;
+        }
+        throw new Error(`Unable to find the path for Slate node: ${JSON.stringify(node)}`);
+    },
+    /**
+     * Find the DOM node that implements DocumentOrShadowRoot for the editor.
+     */
+    findDocumentOrShadowRoot(editor) {
+        const el = AngularEditor.toDOMNode(editor, editor);
+        const root = el.getRootNode();
+        if ((root instanceof Document || root instanceof ShadowRoot) &&
+            root.getSelection != null) {
+            return root;
+        }
+        return el.ownerDocument;
+    },
+    /**
+     * Check if the editor is focused.
+     */
+    isFocused(editor) {
+        return !!IS_FOCUSED.get(editor);
+    },
+    /**
+     * Check if the editor is in read-only mode.
+     */
+    isReadonly(editor) {
+        return !!IS_READONLY.get(editor);
+    },
+    /**
+     * Check if the editor is hanging right.
+     */
+    isBlockHangingRight(editor) {
+        const { selection } = editor;
+        if (!selection) {
+            return false;
+        }
+        if (Range.isCollapsed(selection)) {
+            return false;
+        }
+        const [start, end] = Range.edges(selection);
+        const endBlock = Editor.above(editor, { at: end, match: (node) => Editor.isBlock(editor, node) });
+        return Editor.isStart(editor, end, endBlock[1]);
+    },
+    /**
+     * Blur the editor.
+     */
+    blur(editor) {
+        const el = AngularEditor.toDOMNode(editor, editor);
+        const root = AngularEditor.findDocumentOrShadowRoot(editor);
+        IS_FOCUSED.set(editor, false);
+        if (root.activeElement === el) {
+            el.blur();
+        }
+    },
+    /**
+     * Focus the editor.
+     */
+    focus(editor) {
+        const el = AngularEditor.toDOMNode(editor, editor);
+        IS_FOCUSED.set(editor, true);
+        const window = AngularEditor.getWindow(editor);
+        if (window.document.activeElement !== el) {
+            el.focus({ preventScroll: true });
+        }
+    },
+    /**
+     * Deselect the editor.
+     */
+    deselect(editor) {
+        const { selection } = editor;
+        const root = AngularEditor.findDocumentOrShadowRoot(editor);
+        const domSelection = root.getSelection();
+        if (domSelection && domSelection.rangeCount > 0) {
+            domSelection.removeAllRanges();
+        }
+        if (selection) {
+            Transforms.deselect(editor);
+        }
+    },
+    /**
+     * Check if a DOM node is within the editor.
+     */
+    hasDOMNode(editor, target, options = {}) {
+        const { editable = false } = options;
+        const editorEl = AngularEditor.toDOMNode(editor, editor);
+        let targetEl;
+        // COMPAT: In Firefox, reading `target.nodeType` will throw an error if
+        // target is originating from an internal "restricted" element (e.g. a
+        // stepper arrow on a number input). (2018/05/04)
+        // https://github.com/ianstormtaylor/slate/issues/1819
+        try {
+            targetEl = (isDOMElement(target) ? target : target.parentElement);
+        }
+        catch (err) {
+            if (!err.message.includes('Permission denied to access property "nodeType"')) {
+                throw err;
+            }
+        }
+        if (!targetEl) {
+            return false;
+        }
+        return targetEl.closest(`[data-slate-editor]`) === editorEl &&
+            (!editable || targetEl.isContentEditable ||
+                !!targetEl.getAttribute('data-slate-zero-width'));
+    },
+    /**
+     * Insert data from a `DataTransfer` into the editor.
+     */
+    insertData(editor, data) {
+        editor.insertData(data);
+    },
+    /**
+   * Insert fragment data from a `DataTransfer` into the editor.
+   */
+    insertFragmentData(editor, data) {
+        return editor.insertFragmentData(data);
+    },
+    /**
+     * Insert text data from a `DataTransfer` into the editor.
+     */
+    insertTextData(editor, data) {
+        return editor.insertTextData(data);
+    },
+    /**
+     * onKeydown hook.
+     */
+    onKeydown(editor, data) {
+        editor.onKeydown(data);
+    },
+    /**
+    * onClick hook.
+    */
+    onClick(editor, data) {
+        editor.onClick(data);
+    },
+    /**
+     * Sets data from the currently selected fragment on a `DataTransfer`.
+     */
+    setFragmentData(editor, data, originEvent) {
+        editor.setFragmentData(data, originEvent);
+    },
+    deleteCutData(editor) {
+        editor.deleteCutData();
+    },
+    /**
+     * Find the native DOM element from a Slate node.
+     */
+    toDOMNode(editor, node) {
+        const domNode = Editor.isEditor(node)
+            ? EDITOR_TO_ELEMENT.get(editor)
+            : NODE_TO_ELEMENT.get(node);
+        if (!domNode) {
+            throw new Error(`Cannot resolve a DOM node from Slate node: ${JSON.stringify(node)}`);
+        }
+        return domNode;
+    },
+    /**
+     * Find a native DOM selection point from a Slate point.
+     */
+    toDOMPoint(editor, point) {
+        const [node] = Editor.node(editor, point.path);
+        const el = AngularEditor.toDOMNode(editor, node);
+        let domPoint;
+        // block card
+        const cardTargetAttr = getCardTargetAttribute(el);
+        if (cardTargetAttr) {
+            if (point.offset === FAKE_LEFT_BLOCK_CARD_OFFSET) {
+                const cursorNode = AngularEditor.getCardCursorNode(editor, node, { direction: 'left' });
+                return [cursorNode, 1];
+            }
+            else {
+                const cursorNode = AngularEditor.getCardCursorNode(editor, node, { direction: 'right' });
+                return [cursorNode, 1];
+            }
+        }
+        // If we're inside a void node, force the offset to 0, otherwise the zero
+        // width spacing character will result in an incorrect offset of 1
+        if (Editor.void(editor, { at: point })) {
+            point = { path: point.path, offset: 0 };
+        }
+        // For each leaf, we need to isolate its content, which means filtering
+        // to its direct text and zero-width spans. (We have to filter out any
+        // other siblings that may have been rendered alongside them.)
+        const selector = `[data-slate-string], [data-slate-zero-width]`;
+        const texts = Array.from(el.querySelectorAll(selector));
+        let start = 0;
+        for (const text of texts) {
+            const domNode = text.childNodes[0];
+            if (domNode == null || domNode.textContent == null) {
+                continue;
+            }
+            const { length } = domNode.textContent;
+            const attr = text.getAttribute('data-slate-length');
+            const trueLength = attr == null ? length : parseInt(attr, 10);
+            const end = start + trueLength;
+            if (point.offset <= end) {
+                const offset = Math.min(length, Math.max(0, point.offset - start));
+                domPoint = [domNode, offset];
+                // fixed cursor position after zero width char
+                if (offset === 0 && length === 1 && domNode.textContent === '\uFEFF') {
+                    domPoint = [domNode, offset + 1];
+                }
+                break;
+            }
+            start = end;
+        }
+        if (!domPoint) {
+            throw new Error(`Cannot resolve a DOM point from Slate point: ${JSON.stringify(point)}`);
+        }
+        return domPoint;
+    },
+    /**
+     * Find a native DOM range from a Slate `range`.
+     */
+    toDOMRange(editor, range) {
+        const { anchor, focus } = range;
+        const isBackward = Range.isBackward(range);
+        const domAnchor = AngularEditor.toDOMPoint(editor, anchor);
+        const domFocus = Range.isCollapsed(range) ? domAnchor : AngularEditor.toDOMPoint(editor, focus);
+        const window = AngularEditor.getWindow(editor);
+        const domRange = window.document.createRange();
+        const [startNode, startOffset] = isBackward ? domFocus : domAnchor;
+        const [endNode, endOffset] = isBackward ? domAnchor : domFocus;
+        // A slate Point at zero-width Leaf always has an offset of 0 but a native DOM selection at
+        // zero-width node has an offset of 1 so we have to check if we are in a zero-width node and
+        // adjust the offset accordingly.
+        const startEl = (isDOMElement(startNode)
+            ? startNode
+            : startNode.parentElement);
+        const isStartAtZeroWidth = !!startEl.getAttribute('data-slate-zero-width');
+        const endEl = (isDOMElement(endNode)
+            ? endNode
+            : endNode.parentElement);
+        const isEndAtZeroWidth = !!endEl.getAttribute('data-slate-zero-width');
+        domRange.setStart(startNode, isStartAtZeroWidth ? 1 : startOffset);
+        domRange.setEnd(endNode, isEndAtZeroWidth ? 1 : endOffset);
+        return domRange;
+    },
+    /**
+     * Find a Slate node from a native DOM `element`.
+     */
+    toSlateNode(editor, domNode) {
+        let domEl = isDOMElement(domNode) ? domNode : domNode.parentElement;
+        if (domEl && !domEl.hasAttribute('data-slate-node')) {
+            domEl = domEl.closest(`[data-slate-node]`);
+        }
+        const node = domEl ? ELEMENT_TO_NODE.get(domEl) : null;
+        if (!node) {
+            throw new Error(`Cannot resolve a Slate node from DOM node: ${domEl}`);
+        }
+        return node;
+    },
+    /**
+     * Get the target range from a DOM `event`.
+     */
+    findEventRange(editor, event) {
+        if ('nativeEvent' in event) {
+            event = event.nativeEvent;
+        }
+        const { clientX: x, clientY: y, target } = event;
+        if (x == null || y == null) {
+            throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);
+        }
+        const node = AngularEditor.toSlateNode(editor, event.target);
+        const path = AngularEditor.findPath(editor, node);
+        // If the drop target is inside a void node, move it into either the
+        // next or previous node, depending on which side the `x` and `y`
+        // coordinates are closest to.
+        if (Editor.isVoid(editor, node)) {
+            const rect = target.getBoundingClientRect();
+            const isPrev = editor.isInline(node)
+                ? x - rect.left < rect.left + rect.width - x
+                : y - rect.top < rect.top + rect.height - y;
+            const edge = Editor.point(editor, path, {
+                edge: isPrev ? 'start' : 'end'
+            });
+            const point = isPrev ? Editor.before(editor, edge) : Editor.after(editor, edge);
+            if (point) {
+                return Editor.range(editor, point);
+            }
+        }
+        // Else resolve a range from the caret position where the drop occured.
+        let domRange;
+        const window = AngularEditor.getWindow(editor);
+        const { document } = window;
+        // COMPAT: In Firefox, `caretRangeFromPoint` doesn't exist. (2016/07/25)
+        if (document.caretRangeFromPoint) {
+            domRange = document.caretRangeFromPoint(x, y);
+        }
+        else {
+            const position = document.caretPositionFromPoint(x, y);
+            if (position) {
+                domRange = document.createRange();
+                domRange.setStart(position.offsetNode, position.offset);
+                domRange.setEnd(position.offsetNode, position.offset);
+            }
+        }
+        if (!domRange) {
+            throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);
+        }
+        // Resolve a Slate range from the DOM range.
+        const range = AngularEditor.toSlateRange(editor, domRange);
+        return range;
+    },
+    /**
+     * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
+     */
+    toSlatePoint(editor, domPoint) {
+        const [domNode] = domPoint;
+        const [nearestNode, nearestOffset] = normalizeDOMPoint(domPoint);
+        let parentNode = nearestNode.parentNode;
+        let textNode = null;
+        let offset = 0;
+        // block card
+        const cardTargetAttr = getCardTargetAttribute(domNode);
+        if (cardTargetAttr) {
+            const domSelection = window.getSelection();
+            const isBackward = editor.selection && Range.isBackward(editor.selection);
+            const blockCardEntry = AngularEditor.toSlateCardEntry(editor, domNode) || AngularEditor.toSlateCardEntry(editor, nearestNode);
+            const [, blockPath] = blockCardEntry;
+            if (domSelection.isCollapsed) {
+                if (isCardLeftByTargetAttr(cardTargetAttr)) {
+                    return { path: blockPath, offset: -1 };
+                }
+                else {
+                    return { path: blockPath, offset: -2 };
+                }
+            }
+            // forward
+            // and to the end of previous node
+            if (isCardLeftByTargetAttr(cardTargetAttr) && !isBackward) {
+                const endPath = blockPath[blockPath.length - 1] <= 0
+                    ? blockPath
+                    : Path.previous(blockPath);
+                return Editor.end(editor, endPath);
+            }
+            // to the of current node
+            if ((isCardCenterByTargetAttr(cardTargetAttr) ||
+                isCardRightByTargetAttr(cardTargetAttr)) &&
+                !isBackward) {
+                return Editor.end(editor, blockPath);
+            }
+            // backward
+            // and to the start of next node
+            if (isCardRightByTargetAttr(cardTargetAttr) && isBackward) {
+                return Editor.start(editor, Path.next(blockPath));
+            }
+            // and to the start of current node
+            if ((isCardCenterByTargetAttr(cardTargetAttr) ||
+                isCardLeftByTargetAttr(cardTargetAttr)) &&
+                isBackward) {
+                return Editor.start(editor, blockPath);
+            }
+        }
+        if (parentNode) {
+            const voidNode = parentNode.closest('[data-slate-void="true"]');
+            let leafNode = parentNode.closest('[data-slate-leaf]');
+            let domNode = null;
+            // Calculate how far into the text node the `nearestNode` is, so that we
+            // can determine what the offset relative to the text node is.
+            if (leafNode) {
+                textNode = leafNode.closest('[data-slate-node="text"]');
+                const window = AngularEditor.getWindow(editor);
+                const range = window.document.createRange();
+                range.setStart(textNode, 0);
+                range.setEnd(nearestNode, nearestOffset);
+                const contents = range.cloneContents();
+                const removals = [
+                    ...Array.prototype.slice.call(contents.querySelectorAll('[data-slate-zero-width]')),
+                    ...Array.prototype.slice.call(contents.querySelectorAll('[contenteditable=false]')),
+                ];
+                removals.forEach(el => {
+                    el.parentNode.removeChild(el);
+                });
+                // COMPAT: Edge has a bug where Range.prototype.toString() will
+                // convert \n into \r\n. The bug causes a loop when slate-react
+                // attempts to reposition its cursor to match the native position. Use
+                // textContent.length instead.
+                // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10291116/
+                offset = contents.textContent.length;
+                domNode = textNode;
+            }
+            else if (voidNode) {
+                // For void nodes, the element with the offset key will be a cousin, not an
+                // ancestor, so find it by going down from the nearest void parent.
+                leafNode = voidNode.querySelector('[data-slate-leaf]');
+                parentNode = voidNode.querySelector('[data-slate-length="0"]');
+                textNode = leafNode.closest('[data-slate-node="text"]');
+                domNode = leafNode;
+                offset = domNode.textContent.length;
+            }
+            // COMPAT: If the parent node is a Slate zero-width space, editor is
+            // because the text node should have no characters. However, during IME
+            // composition the ASCII characters will be prepended to the zero-width
+            // space, so subtract 1 from the offset to account for the zero-width
+            // space character.
+            if (domNode &&
+                offset === domNode.textContent.length &&
+                (parentNode && parentNode.hasAttribute('data-slate-zero-width'))) {
+                offset--;
+            }
+        }
+        if (!textNode) {
+            throw new Error(`Cannot resolve a Slate point from DOM point: ${domPoint}`);
+        }
+        // COMPAT: If someone is clicking from one Slate editor into another,
+        // the select event fires twice, once for the old editor's `element`
+        // first, and then afterwards for the correct `element`. (2017/03/03)
+        const slateNode = AngularEditor.toSlateNode(editor, textNode);
+        const path = AngularEditor.findPath(editor, slateNode);
+        return { path, offset };
+    },
+    /**
+     * Find a Slate range from a DOM range or selection.
+     */
+    toSlateRange(editor, domRange) {
+        const el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer;
+        let anchorNode;
+        let anchorOffset;
+        let focusNode;
+        let focusOffset;
+        let isCollapsed;
+        if (el) {
+            if (isDOMSelection(domRange)) {
+                anchorNode = domRange.anchorNode;
+                anchorOffset = domRange.anchorOffset;
+                focusNode = domRange.focusNode;
+                focusOffset = domRange.focusOffset;
+                // COMPAT: There's a bug in chrome that always returns `true` for
+                // `isCollapsed` for a Selection that comes from a ShadowRoot.
+                // (2020/08/08)
+                // https://bugs.chromium.org/p/chromium/issues/detail?id=447523
+                if (IS_CHROME && hasShadowRoot()) {
+                    isCollapsed =
+                        domRange.anchorNode === domRange.focusNode &&
+                            domRange.anchorOffset === domRange.focusOffset;
+                }
+                else {
+                    isCollapsed = domRange.isCollapsed;
+                }
+            }
+            else {
+                anchorNode = domRange.startContainer;
+                anchorOffset = domRange.startOffset;
+                focusNode = domRange.endContainer;
+                focusOffset = domRange.endOffset;
+                isCollapsed = domRange.collapsed;
+            }
+        }
+        if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {
+            throw new Error(`Cannot resolve a Slate range from DOM range: ${domRange}`);
+        }
+        const anchor = AngularEditor.toSlatePoint(editor, [anchorNode, anchorOffset]);
+        const focus = isCollapsed ? anchor : AngularEditor.toSlatePoint(editor, [focusNode, focusOffset]);
+        return { anchor, focus };
+    },
+    isLeafBlock(editor, node) {
+        return Element.isElement(node) && !editor.isInline(node) && Editor.hasInlines(editor, node);
+    },
+    isBlockCardLeftCursor(editor) {
+        return editor.selection.anchor.offset === FAKE_LEFT_BLOCK_CARD_OFFSET && editor.selection.focus.offset === FAKE_LEFT_BLOCK_CARD_OFFSET;
+    },
+    isBlockCardRightCursor(editor) {
+        return editor.selection.anchor.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET && editor.selection.focus.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET;
+    },
+    getCardCursorNode(editor, blockCardNode, options) {
+        const blockCardElement = AngularEditor.toDOMNode(editor, blockCardNode);
+        const cardCenter = blockCardElement.parentElement;
+        return options.direction === 'left'
+            ? cardCenter.previousElementSibling
+            : cardCenter.nextElementSibling;
+    },
+    toSlateCardEntry(editor, node) {
+        const element = node.parentElement
+            .closest('.slate-block-card')?.querySelector('[card-target="card-center"]')
+            .firstElementChild;
+        const slateNode = AngularEditor.toSlateNode(editor, element);
+        const path = AngularEditor.findPath(editor, slateNode);
+        return [slateNode, path];
+    },
+    /**
+     * move native selection to card-left or card-right
+     * @param editor
+     * @param blockCardNode
+     * @param options
+     */
+    moveBlockCard(editor, blockCardNode, options) {
+        const cursorNode = AngularEditor.getCardCursorNode(editor, blockCardNode, options);
+        const window = AngularEditor.getWindow(editor);
+        const domSelection = window.getSelection();
+        domSelection.setBaseAndExtent(cursorNode, 1, cursorNode, 1);
+    },
+    /**
+     * move slate selection to card-left or card-right
+     * @param editor
+     * @param path
+     * @param options
+     */
+    moveBlockCardCursor(editor, path, options) {
+        const cursor = { path, offset: options.direction === 'left' ? FAKE_LEFT_BLOCK_CARD_OFFSET : FAKE_RIGHT_BLOCK_CARD_OFFSET };
+        Transforms.select(editor, { anchor: cursor, focus: cursor });
+    },
+    hasRange(editor, range) {
+        const { anchor, focus } = range;
+        return (Editor.hasPath(editor, anchor.path) && Editor.hasPath(editor, focus.path));
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-editor.js","sourceRoot":"","sources":["../../../packages/src/plugins/angular-editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Editor, Node, Path, Point, Range, Transforms, Element, BaseEditor } from 'slate';\nimport {\n    EDITOR_TO_ELEMENT,\n    ELEMENT_TO_NODE,\n    IS_FOCUSED,\n    IS_READONLY,\n    NODE_TO_INDEX,\n    NODE_TO_PARENT,\n    NODE_TO_ELEMENT,\n    NODE_TO_KEY,\n    EDITOR_TO_WINDOW\n} from '../utils/weak-maps';\nimport {\n    DOMElement,\n    DOMNode,\n    DOMPoint,\n    DOMRange,\n    DOMSelection,\n    DOMStaticRange,\n    hasShadowRoot,\n    isDOMElement,\n    isDOMSelection,\n    normalizeDOMPoint\n} from '../utils/dom';\nimport { Injector } from '@angular/core';\nimport { NodeEntry } from 'slate';\nimport { SlateError } from '../types/error';\nimport { Key } from '../utils/key';\nimport { IS_CHROME, IS_FIREFOX } from '../utils/environment';\nimport { FAKE_LEFT_BLOCK_CARD_OFFSET, FAKE_RIGHT_BLOCK_CARD_OFFSET, getCardTargetAttribute, isCardCenterByTargetAttr, isCardLeftByTargetAttr, isCardRightByTargetAttr } from '../utils/block-card';\nimport { SafeAny } from '../types';\n\n/**\n * An Angular and DOM-specific version of the `Editor` interface.\n */\n\nexport interface AngularEditor extends BaseEditor {\n    insertData: (data: DataTransfer) => void;\n    insertFragmentData: (data: DataTransfer) => boolean\n    insertTextData: (data: DataTransfer) => boolean\n    setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;\n    deleteCutData: () => void;\n    onKeydown: (event: KeyboardEvent) => void;\n    onClick: (event: MouseEvent) => void;\n    injector: Injector;\n    isBlockCard: (node: Node) => boolean;\n    onError: (errorData: SlateError) => void;\n    hasRange: (editor: AngularEditor, range: Range) => boolean;\n}\n\nexport const AngularEditor = {\n    /**\n     * Return the host window of the current editor.\n     */\n\n    getWindow(editor: AngularEditor): Window {\n        const window = EDITOR_TO_WINDOW.get(editor);\n        if (!window) {\n            throw new Error('Unable to find a host window element for this editor');\n        }\n        return window;\n    },\n    /**\n     * Find a key for a Slate node.\n     */\n\n    findKey(editor: AngularEditor, node: Node): Key {\n        let key = NODE_TO_KEY.get(node);\n\n        if (!key) {\n            key = new Key();\n            NODE_TO_KEY.set(node, key);\n        }\n\n        return key;\n    },\n\n    /**\n     * handle editor error.\n     */\n\n    onError(errorData: SlateError) {\n        if (errorData.nativeError) {\n            throw errorData.nativeError;\n        }\n    },\n\n    /**\n     * Find the path of Slate node.\n     */\n\n    findPath(editor: AngularEditor, node: Node): Path {\n        const path: Path = [];\n        let child = node;\n\n        while (true) {\n            const parent = NODE_TO_PARENT.get(child);\n\n            if (parent == null) {\n                if (Editor.isEditor(child)) {\n                    return path;\n                } else {\n                    break;\n                }\n            }\n\n            const i = NODE_TO_INDEX.get(child);\n\n            if (i == null) {\n                break;\n            }\n\n            path.unshift(i);\n            child = parent;\n        }\n        throw new Error(`Unable to find the path for Slate node: ${JSON.stringify(node)}`);\n    },\n\n    /**\n     * Find the DOM node that implements DocumentOrShadowRoot for the editor.\n     */\n\n    findDocumentOrShadowRoot(editor: AngularEditor): Document | ShadowRoot {\n        const el = AngularEditor.toDOMNode(editor, editor)\n        const root = el.getRootNode()\n        if (\n            (root instanceof Document || root instanceof ShadowRoot) &&\n            (root as Document).getSelection != null\n        ) {\n            return root\n        }\n\n        return el.ownerDocument\n    },\n\n    /**\n     * Check if the editor is focused.\n     */\n\n    isFocused(editor: AngularEditor): boolean {\n        return !!IS_FOCUSED.get(editor);\n    },\n\n    /**\n     * Check if the editor is in read-only mode.\n     */\n\n    isReadonly(editor: AngularEditor): boolean {\n        return !!IS_READONLY.get(editor);\n    },\n\n    /**\n     * Check if the editor is hanging right.\n     */\n    isBlockHangingRight(editor: AngularEditor): boolean {\n        const { selection } = editor;\n        if (!selection) {\n            return false;\n        }\n        if (Range.isCollapsed(selection)) {\n            return false;\n        }\n        const [start, end] = Range.edges(selection);\n        const endBlock = Editor.above(editor, { at: end, match: (node) => Editor.isBlock(editor, node) });\n        return Editor.isStart(editor, end, endBlock[1]);\n    },\n\n    /**\n     * Blur the editor.\n     */\n\n    blur(editor: AngularEditor): void {\n        const el = AngularEditor.toDOMNode(editor, editor);\n        const root = AngularEditor.findDocumentOrShadowRoot(editor);\n        IS_FOCUSED.set(editor, false);\n\n        if (root.activeElement === el) {\n            el.blur();\n        }\n    },\n\n    /**\n     * Focus the editor.\n     */\n\n    focus(editor: AngularEditor): void {\n        const el = AngularEditor.toDOMNode(editor, editor);\n        IS_FOCUSED.set(editor, true);\n\n        const window = AngularEditor.getWindow(editor);\n        if (window.document.activeElement !== el) {\n            el.focus({ preventScroll: true });\n        }\n    },\n\n    /**\n     * Deselect the editor.\n     */\n\n    deselect(editor: AngularEditor): void {\n        const { selection } = editor;\n        const root = AngularEditor.findDocumentOrShadowRoot(editor);\n        const domSelection = (root as Document).getSelection();\n\n        if (domSelection && domSelection.rangeCount > 0) {\n            domSelection.removeAllRanges();\n        }\n\n        if (selection) {\n            Transforms.deselect(editor);\n        }\n    },\n\n    /**\n     * Check if a DOM node is within the editor.\n     */\n\n    hasDOMNode(editor: AngularEditor, target: DOMNode, options: { editable?: boolean } = {}): boolean {\n        const { editable = false } = options;\n        const editorEl = AngularEditor.toDOMNode(editor, editor);\n        let targetEl;\n\n        // COMPAT: In Firefox, reading `target.nodeType` will throw an error if\n        // target is originating from an internal \"restricted\" element (e.g. a\n        // stepper arrow on a number input). (2018/05/04)\n        // https://github.com/ianstormtaylor/slate/issues/1819\n        try {\n            targetEl = (isDOMElement(target) ? target : target.parentElement) as HTMLElement;\n        } catch (err) {\n            if (!err.message.includes('Permission denied to access property \"nodeType\"')) {\n                throw err;\n            }\n        }\n\n        if (!targetEl) {\n            return false;\n        }\n\n        return targetEl.closest(`[data-slate-editor]`) === editorEl &&\n            (!editable || targetEl.isContentEditable ||\n                !!targetEl.getAttribute('data-slate-zero-width'));\n    },\n\n    /**\n     * Insert data from a `DataTransfer` into the editor.\n     */\n\n    insertData(editor: AngularEditor, data: DataTransfer): void {\n        editor.insertData(data);\n    },\n\n    /**\n   * Insert fragment data from a `DataTransfer` into the editor.\n   */\n\n    insertFragmentData(editor: AngularEditor, data: DataTransfer): boolean {\n        return editor.insertFragmentData(data)\n    },\n\n    /**\n     * Insert text data from a `DataTransfer` into the editor.\n     */\n\n    insertTextData(editor: AngularEditor, data: DataTransfer): boolean {\n        return editor.insertTextData(data)\n    },\n\n    /**\n     * onKeydown hook.\n     */\n    onKeydown(editor: AngularEditor, data: KeyboardEvent): void {\n        editor.onKeydown(data);\n    },\n\n    /**\n    * onClick hook.\n    */\n    onClick(editor: AngularEditor, data: MouseEvent): void {\n        editor.onClick(data);\n    },\n\n    /**\n     * Sets data from the currently selected fragment on a `DataTransfer`.\n     */\n\n    setFragmentData(editor: AngularEditor, data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut'): void {\n        editor.setFragmentData(data, originEvent);\n    },\n\n    deleteCutData(editor: AngularEditor): void {\n        editor.deleteCutData();\n    },\n\n    /**\n     * Find the native DOM element from a Slate node.\n     */\n\n    toDOMNode(editor: AngularEditor, node: Node): HTMLElement {\n        const domNode = Editor.isEditor(node)\n            ? EDITOR_TO_ELEMENT.get(editor)\n            : NODE_TO_ELEMENT.get(node);\n\n        if (!domNode) {\n            throw new Error(`Cannot resolve a DOM node from Slate node: ${JSON.stringify(node)}`);\n        }\n\n        return domNode;\n    },\n\n    /**\n     * Find a native DOM selection point from a Slate point.\n     */\n\n    toDOMPoint(editor: AngularEditor, point: Point): DOMPoint {\n        const [node] = Editor.node(editor, point.path);\n        const el = AngularEditor.toDOMNode(editor, node);\n        let domPoint: DOMPoint | undefined;\n\n        // block card\n        const cardTargetAttr = getCardTargetAttribute(el);\n        if (cardTargetAttr) {\n            if (point.offset === FAKE_LEFT_BLOCK_CARD_OFFSET) {\n                const cursorNode = AngularEditor.getCardCursorNode(editor, node, { direction: 'left' });\n                return [cursorNode, 1];\n            } else {\n                const cursorNode = AngularEditor.getCardCursorNode(editor, node, { direction: 'right' });\n                return [cursorNode, 1];\n            }\n        }\n\n        // If we're inside a void node, force the offset to 0, otherwise the zero\n        // width spacing character will result in an incorrect offset of 1\n        if (Editor.void(editor, { at: point })) {\n            point = { path: point.path, offset: 0 };\n        }\n\n        // For each leaf, we need to isolate its content, which means filtering\n        // to its direct text and zero-width spans. (We have to filter out any\n        // other siblings that may have been rendered alongside them.)\n        const selector = `[data-slate-string], [data-slate-zero-width]`;\n        const texts = Array.from(el.querySelectorAll(selector));\n        let start = 0;\n\n        for (const text of texts) {\n            const domNode = text.childNodes[0] as HTMLElement;\n\n            if (domNode == null || domNode.textContent == null) {\n                continue;\n            }\n\n            const { length } = domNode.textContent;\n            const attr = text.getAttribute('data-slate-length');\n            const trueLength = attr == null ? length : parseInt(attr, 10);\n            const end = start + trueLength;\n\n            if (point.offset <= end) {\n                const offset = Math.min(length, Math.max(0, point.offset - start));\n                domPoint = [domNode, offset];\n                // fixed cursor position after zero width char\n                if (offset === 0 && length === 1 && domNode.textContent === '\\uFEFF') {\n                    domPoint = [domNode, offset + 1];\n                }\n                break;\n            }\n\n            start = end;\n        }\n\n        if (!domPoint) {\n            throw new Error(`Cannot resolve a DOM point from Slate point: ${JSON.stringify(point)}`);\n        }\n\n        return domPoint;\n    },\n\n    /**\n     * Find a native DOM range from a Slate `range`.\n     */\n\n    toDOMRange(editor: AngularEditor, range: Range): DOMRange {\n        const { anchor, focus } = range;\n        const isBackward = Range.isBackward(range);\n        const domAnchor = AngularEditor.toDOMPoint(editor, anchor);\n        const domFocus = Range.isCollapsed(range) ? domAnchor : AngularEditor.toDOMPoint(editor, focus);\n\n        const window = AngularEditor.getWindow(editor);\n        const domRange = window.document.createRange();\n        const [startNode, startOffset] = isBackward ? domFocus : domAnchor;\n        const [endNode, endOffset] = isBackward ? domAnchor : domFocus;\n\n        // A slate Point at zero-width Leaf always has an offset of 0 but a native DOM selection at\n        // zero-width node has an offset of 1 so we have to check if we are in a zero-width node and\n        // adjust the offset accordingly.\n        const startEl = (isDOMElement(startNode)\n            ? startNode\n            : startNode.parentElement) as HTMLElement;\n        const isStartAtZeroWidth = !!startEl.getAttribute('data-slate-zero-width');\n        const endEl = (isDOMElement(endNode)\n            ? endNode\n            : endNode.parentElement) as HTMLElement;\n        const isEndAtZeroWidth = !!endEl.getAttribute('data-slate-zero-width');\n\n        domRange.setStart(startNode, isStartAtZeroWidth ? 1 : startOffset);\n        domRange.setEnd(endNode, isEndAtZeroWidth ? 1 : endOffset);\n        return domRange;\n    },\n\n    /**\n     * Find a Slate node from a native DOM `element`.\n     */\n\n    toSlateNode(editor: AngularEditor, domNode: DOMNode): Node {\n        let domEl = isDOMElement(domNode) ? domNode : domNode.parentElement;\n\n        if (domEl && !domEl.hasAttribute('data-slate-node')) {\n            domEl = domEl.closest(`[data-slate-node]`);\n        }\n\n        const node = domEl ? ELEMENT_TO_NODE.get(domEl as HTMLElement) : null;\n\n        if (!node) {\n            throw new Error(`Cannot resolve a Slate node from DOM node: ${domEl}`);\n        }\n\n        return node;\n    },\n\n    /**\n     * Get the target range from a DOM `event`.\n     */\n\n    findEventRange(editor: AngularEditor, event: any): Range {\n        if ('nativeEvent' in event) {\n            event = event.nativeEvent;\n        }\n\n        const { clientX: x, clientY: y, target } = event;\n\n        if (x == null || y == null) {\n            throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);\n        }\n\n        const node = AngularEditor.toSlateNode(editor, event.target);\n        const path = AngularEditor.findPath(editor, node);\n\n        // If the drop target is inside a void node, move it into either the\n        // next or previous node, depending on which side the `x` and `y`\n        // coordinates are closest to.\n        if (Editor.isVoid(editor, node)) {\n            const rect = target.getBoundingClientRect();\n            const isPrev = editor.isInline(node)\n                ? x - rect.left < rect.left + rect.width - x\n                : y - rect.top < rect.top + rect.height - y;\n\n            const edge = Editor.point(editor, path, {\n                edge: isPrev ? 'start' : 'end'\n            });\n            const point = isPrev ? Editor.before(editor, edge) : Editor.after(editor, edge);\n\n            if (point) {\n                return Editor.range(editor, point);\n            }\n        }\n\n        // Else resolve a range from the caret position where the drop occured.\n        let domRange: DOMRange;\n        const window = AngularEditor.getWindow(editor);\n        const { document } = window;\n\n        // COMPAT: In Firefox, `caretRangeFromPoint` doesn't exist. (2016/07/25)\n        if (document.caretRangeFromPoint) {\n            domRange = document.caretRangeFromPoint(x, y);\n        } else {\n            const position = (document as SafeAny).caretPositionFromPoint(x, y);\n\n            if (position) {\n                domRange = document.createRange();\n                domRange.setStart(position.offsetNode, position.offset);\n                domRange.setEnd(position.offsetNode, position.offset);\n            }\n        }\n\n        if (!domRange) {\n            throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);\n        }\n\n        // Resolve a Slate range from the DOM range.\n        const range = AngularEditor.toSlateRange(editor, domRange);\n        return range;\n    },\n\n    /**\n     * Find a Slate point from a DOM selection's `domNode` and `domOffset`.\n     */\n\n    toSlatePoint(editor: AngularEditor, domPoint: DOMPoint): Point {\n        const [domNode] = domPoint;\n        const [nearestNode, nearestOffset] = normalizeDOMPoint(domPoint);\n        let parentNode = nearestNode.parentNode as DOMElement;\n        let textNode: DOMElement | null = null;\n        let offset = 0;\n\n        // block card\n        const cardTargetAttr = getCardTargetAttribute(domNode);\n        if (cardTargetAttr) {\n            const domSelection = window.getSelection();\n            const isBackward = editor.selection && Range.isBackward(editor.selection);\n            const blockCardEntry = AngularEditor.toSlateCardEntry(editor, domNode) || AngularEditor.toSlateCardEntry(editor, nearestNode);\n            const [, blockPath] = blockCardEntry;\n            if (domSelection.isCollapsed) {\n                if (isCardLeftByTargetAttr(cardTargetAttr)) {\n                    return { path: blockPath, offset: -1 };\n                }\n                else {\n                    return { path: blockPath, offset: -2 };\n                }\n            }\n            // forward\n            // and to the end of previous node\n            if (isCardLeftByTargetAttr(cardTargetAttr) && !isBackward) {\n                const endPath =\n                    blockPath[blockPath.length - 1] <= 0\n                        ? blockPath\n                        : Path.previous(blockPath);\n                return Editor.end(editor, endPath);\n            }\n            // to the of current node\n            if (\n                (isCardCenterByTargetAttr(cardTargetAttr) ||\n                    isCardRightByTargetAttr(cardTargetAttr)) &&\n                !isBackward\n            ) {\n                return Editor.end(editor, blockPath);\n            }\n            // backward\n            // and to the start of next node\n            if (isCardRightByTargetAttr(cardTargetAttr) && isBackward) {\n                return Editor.start(editor, Path.next(blockPath));\n            }\n            // and to the start of current node\n            if (\n                (isCardCenterByTargetAttr(cardTargetAttr) ||\n                    isCardLeftByTargetAttr(cardTargetAttr)) &&\n                isBackward\n            ) {\n                return Editor.start(editor, blockPath);\n            }\n        }\n\n        if (parentNode) {\n            const voidNode = parentNode.closest('[data-slate-void=\"true\"]');\n            let leafNode = parentNode.closest('[data-slate-leaf]');\n            let domNode: DOMElement | null = null;\n\n            // Calculate how far into the text node the `nearestNode` is, so that we\n            // can determine what the offset relative to the text node is.\n            if (leafNode) {\n                textNode = leafNode.closest('[data-slate-node=\"text\"]')!;\n                const window = AngularEditor.getWindow(editor);\n                const range = window.document.createRange();\n                range.setStart(textNode, 0);\n                range.setEnd(nearestNode, nearestOffset);\n                const contents = range.cloneContents();\n                const removals = [\n                    ...Array.prototype.slice.call(\n                        contents.querySelectorAll('[data-slate-zero-width]')\n                    ),\n                    ...Array.prototype.slice.call(\n                        contents.querySelectorAll('[contenteditable=false]')\n                    ),\n                ];\n\n                removals.forEach(el => {\n                    el!.parentNode!.removeChild(el);\n                });\n\n                // COMPAT: Edge has a bug where Range.prototype.toString() will\n                // convert \\n into \\r\\n. The bug causes a loop when slate-react\n                // attempts to reposition its cursor to match the native position. Use\n                // textContent.length instead.\n                // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10291116/\n                offset = contents.textContent!.length;\n                domNode = textNode;\n            } else if (voidNode) {\n                // For void nodes, the element with the offset key will be a cousin, not an\n                // ancestor, so find it by going down from the nearest void parent.\n\n                leafNode = voidNode.querySelector('[data-slate-leaf]')!;\n                parentNode = voidNode.querySelector('[data-slate-length=\"0\"]');\n                textNode = leafNode.closest('[data-slate-node=\"text\"]')!;\n                domNode = leafNode;\n                offset = domNode.textContent!.length;\n            }\n\n            // COMPAT: If the parent node is a Slate zero-width space, editor is\n            // because the text node should have no characters. However, during IME\n            // composition the ASCII characters will be prepended to the zero-width\n            // space, so subtract 1 from the offset to account for the zero-width\n            // space character.\n            if (domNode &&\n                offset === domNode.textContent!.length &&\n                (parentNode && parentNode.hasAttribute('data-slate-zero-width'))\n            ) {\n                offset--;\n            }\n        }\n\n        if (!textNode) {\n            throw new Error(`Cannot resolve a Slate point from DOM point: ${domPoint}`);\n        }\n\n        // COMPAT: If someone is clicking from one Slate editor into another,\n        // the select event fires twice, once for the old editor's `element`\n        // first, and then afterwards for the correct `element`. (2017/03/03)\n        const slateNode = AngularEditor.toSlateNode(editor, textNode!);\n        const path = AngularEditor.findPath(editor, slateNode);\n        return { path, offset };\n    },\n\n    /**\n     * Find a Slate range from a DOM range or selection.\n     */\n\n    toSlateRange(editor: AngularEditor, domRange: DOMRange | DOMStaticRange | DOMSelection): Range {\n        const el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer;\n        let anchorNode;\n        let anchorOffset;\n        let focusNode;\n        let focusOffset;\n        let isCollapsed;\n\n        if (el) {\n            if (isDOMSelection(domRange)) {\n                anchorNode = domRange.anchorNode;\n                anchorOffset = domRange.anchorOffset;\n                focusNode = domRange.focusNode;\n                focusOffset = domRange.focusOffset;\n                // COMPAT: There's a bug in chrome that always returns `true` for\n                // `isCollapsed` for a Selection that comes from a ShadowRoot.\n                // (2020/08/08)\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=447523\n                if (IS_CHROME && hasShadowRoot()) {\n                    isCollapsed =\n                        domRange.anchorNode === domRange.focusNode &&\n                        domRange.anchorOffset === domRange.focusOffset;\n                } else {\n                    isCollapsed = domRange.isCollapsed;\n                }\n            } else {\n                anchorNode = domRange.startContainer;\n                anchorOffset = domRange.startOffset;\n                focusNode = domRange.endContainer;\n                focusOffset = domRange.endOffset;\n                isCollapsed = domRange.collapsed;\n            }\n        }\n\n        if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {\n            throw new Error(`Cannot resolve a Slate range from DOM range: ${domRange}`);\n        }\n\n        const anchor = AngularEditor.toSlatePoint(editor, [anchorNode, anchorOffset]);\n        const focus = isCollapsed ? anchor : AngularEditor.toSlatePoint(editor, [focusNode, focusOffset]);\n\n        return { anchor, focus };\n    },\n\n    isLeafBlock(editor: AngularEditor, node: Node): boolean {\n        return Element.isElement(node) && !editor.isInline(node) && Editor.hasInlines(editor, node);\n    },\n\n    isBlockCardLeftCursor(editor: AngularEditor) {\n        return editor.selection.anchor.offset === FAKE_LEFT_BLOCK_CARD_OFFSET && editor.selection.focus.offset === FAKE_LEFT_BLOCK_CARD_OFFSET;\n    },\n\n    isBlockCardRightCursor(editor: AngularEditor) {\n        return editor.selection.anchor.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET && editor.selection.focus.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET;\n    },\n\n    getCardCursorNode(editor: AngularEditor, blockCardNode: Node, options: {\n        direction: 'left' | 'right' | 'center'\n    }) {\n        const blockCardElement = AngularEditor.toDOMNode(editor, blockCardNode);\n        const cardCenter = blockCardElement.parentElement;\n        return options.direction === 'left'\n            ? cardCenter.previousElementSibling\n            : cardCenter.nextElementSibling;\n    },\n\n    toSlateCardEntry(editor: AngularEditor, node: DOMNode): NodeEntry {\n        const element = node.parentElement\n            .closest('.slate-block-card')?.querySelector('[card-target=\"card-center\"]')\n            .firstElementChild;\n        const slateNode = AngularEditor.toSlateNode(editor, element);\n        const path = AngularEditor.findPath(editor, slateNode);\n        return [slateNode, path];\n    },\n\n    /**\n     * move native selection to card-left or card-right\n     * @param editor \n     * @param blockCardNode \n     * @param options \n     */\n    moveBlockCard(editor: AngularEditor, blockCardNode: Node, options: {\n        direction: 'left' | 'right'\n    }) {\n        const cursorNode = AngularEditor.getCardCursorNode(editor, blockCardNode, options);\n        const window = AngularEditor.getWindow(editor);\n        const domSelection = window.getSelection();\n        domSelection.setBaseAndExtent(cursorNode, 1, cursorNode, 1);\n    },\n\n    /**\n     * move slate selection to card-left or card-right\n     * @param editor \n     * @param path \n     * @param options \n     */\n    moveBlockCardCursor(editor: AngularEditor, path: Path, options: {\n        direction: 'left' | 'right'\n    }) {\n        const cursor = { path, offset: options.direction === 'left' ? FAKE_LEFT_BLOCK_CARD_OFFSET : FAKE_RIGHT_BLOCK_CARD_OFFSET };\n        Transforms.select(editor, { anchor: cursor, focus: cursor });\n    },\n\n    hasRange(editor: AngularEditor, range: Range): boolean {\n        const { anchor, focus } = range;\n        return (\n            Editor.hasPath(editor, anchor.path) && Editor.hasPath(editor, focus.path)\n        );\n    },\n};\n"]}