slate-angular 19.0.0 → 19.1.0-next.1

package/fesm2022/slate-angular.mjs

@@ -1,4 +1,5 @@
-import { Editor, Transforms, Element, Range, Text as Text$1, Path, Node } from 'slate';
+import { Editor, Range, Element, Transforms, Text as Text$1, Node, Path } from 'slate';
+import { EDITOR_TO_ELEMENT, NODE_TO_ELEMENT, DOMEditor, normalizeDOMPoint, isDOMSelection, IS_CHROME as IS_CHROME$1, hasShadowRoot, isDOMElement, NODE_TO_PARENT, NODE_TO_INDEX, isDOMNode, withDOM, NODE_TO_KEY, ELEMENT_TO_NODE, getDefaultView, EDITOR_TO_WINDOW, IS_READ_ONLY, EDITOR_TO_ON_CHANGE, IS_FOCUSED, TRIPLE_CLICK, isPlainTextOnlyPaste } from 'slate-dom';
 import { isKeyHotkey } from 'is-hotkey';
 import * as i0 from '@angular/core';
 import { TemplateRef, ViewChild, ChangeDetectionStrategy, Component, InjectionToken, ComponentRef, IterableDiffers, inject, ElementRef, ChangeDetectorRef, Input, Directive, HostBinding, ViewContainerRef, forwardRef, Inject, NgModule } from '@angular/core';
@@ -9,258 +10,6 @@ import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { HistoryEditor } from 'slate-history';
 import { CommonModule } from '@angular/common';
 
-/**
- * Two weak maps that allow us rebuild a path given a node. They are populated
- * at render time such that after a render occurs we can always backtrack.
- */
-const EDITOR_TO_WINDOW = new WeakMap();
-const NODE_TO_INDEX = new WeakMap();
-const NODE_TO_PARENT = new WeakMap();
-/**
- * Weak maps that allow us to go between Slate nodes and DOM nodes. These
- * are used to resolve DOM event-related logic into Slate actions.
- */
-const EDITOR_TO_ELEMENT = new WeakMap();
-const EDITOR_TO_PLACEHOLDER = new WeakMap();
-const ELEMENT_TO_NODE = new WeakMap();
-// Deprecated
-const KEY_TO_ELEMENT = new WeakMap();
-const NODE_TO_ELEMENT = new WeakMap();
-const NODE_TO_KEY = new WeakMap();
-/**
- * Weak maps for storing editor-related state.
- */
-const IS_READONLY = new WeakMap();
-const IS_FOCUSED = new WeakMap();
-const IS_DRAGGING = new WeakMap();
-const IS_CLICKING = new WeakMap();
-/**
- * Weak map for associating the context `onChange` context with the plugin.
- */
-const EDITOR_TO_ON_CHANGE = new WeakMap();
-// export const NODE_TO_VIEWNODE = new WeakMap<Node, ViewNode>();
-/**
- * Symbols.
- */
-const PLACEHOLDER_SYMBOL = Symbol('placeholder');
-/**
- * Weak map for associating the html element with the component.
- */
-const ELEMENT_TO_COMPONENT = new WeakMap();
-const EDITOR_TO_AFTER_VIEW_INIT_QUEUE = new WeakMap();
-
-/**
- * Types.
- */
-// COMPAT: This is required to prevent TypeScript aliases from doing some very
-// weird things for Slate's types with the same name as globals. (2019/11/27)
-// https://github.com/microsoft/TypeScript/issues/35002
-var DOMNode = globalThis.Node;
-var DOMComment = globalThis.Comment;
-var DOMElement = globalThis.Element;
-var DOMText = globalThis.Text;
-var DOMRange = globalThis.Range;
-var DOMSelection = globalThis.Selection;
-var DOMStaticRange = globalThis.StaticRange;
-/**
- * Returns the host window of a DOM node
- */
-const getDefaultView = (value) => {
-    return (value && value.ownerDocument && value.ownerDocument.defaultView) || null;
-};
-/**
- * Check if a DOM node is a comment node.
- */
-const isDOMComment = (value) => {
-    return isDOMNode(value) && value.nodeType === 8;
-};
-/**
- * Check if a DOM node is an element node.
- */
-const isDOMElement = (value) => {
-    return isDOMNode(value) && value.nodeType === 1;
-};
-/**
- * Check if a value is a DOM node.
- */
-const isDOMNode = (value) => {
-    const window = getDefaultView(value);
-    return !!window && value instanceof window.Node;
-};
-/**
- * Check if a value is a DOM selection.
- */
-const isDOMSelection = (value) => {
-    const window = value && value.anchorNode && getDefaultView(value.anchorNode);
-    return !!window && value instanceof window.Selection;
-};
-/**
- * Check if a DOM node is an element node.
- */
-const isDOMText = (value) => {
-    return isDOMNode(value) && value.nodeType === 3;
-};
-/**
- * Checks whether a paste event is a plaintext-only event.
- */
-const isPlainTextOnlyPaste = (event) => {
-    return event.clipboardData && event.clipboardData.getData('text/plain') !== '' && event.clipboardData.types.length === 1;
-};
-/**
- * Normalize a DOM point so that it always refers to a text node.
- */
-const normalizeDOMPoint = (domPoint) => {
-    let [node, offset] = domPoint;
-    // If it's an element node, its offset refers to the index of its children
-    // including comment nodes, so try to find the right text child node.
-    if (isDOMElement(node) && node.childNodes.length) {
-        let isLast = offset === node.childNodes.length;
-        let index = isLast ? offset - 1 : offset;
-        [node, index] = getEditableChildAndIndex(node, index, isLast ? 'backward' : 'forward');
-        // If the editable child found is in front of input offset, we instead seek to its end
-        isLast = index < offset;
-        // If the node has children, traverse until we have a leaf node. Leaf nodes
-        // can be either text nodes, or other void DOM nodes.
-        while (isDOMElement(node) && node.childNodes.length) {
-            const i = isLast ? node.childNodes.length - 1 : 0;
-            node = getEditableChild(node, i, isLast ? 'backward' : 'forward');
-        }
-        // Determine the new offset inside the text node.
-        offset = isLast && node.textContent != null ? node.textContent.length : 0;
-    }
-    // Return the node and offset.
-    return [node, offset];
-};
-/**
- * Determines wether the active element is nested within a shadowRoot
- */
-const hasShadowRoot = () => {
-    return !!(window.document.activeElement && window.document.activeElement.shadowRoot);
-};
-/**
- * Get the nearest editable child and index at `index` in a `parent`, preferring
- * `direction`.
- */
-const getEditableChildAndIndex = (parent, index, direction) => {
-    const { childNodes } = parent;
-    let child = childNodes[index];
-    let i = index;
-    let triedForward = false;
-    let triedBackward = false;
-    // While the child is a comment node, or an element node with no children,
-    // keep iterating to find a sibling non-void, non-comment node.
-    while (isDOMComment(child) ||
-        (isDOMElement(child) && child.childNodes.length === 0) ||
-        (isDOMElement(child) && child.getAttribute('contenteditable') === 'false')) {
-        if (triedForward && triedBackward) {
-            break;
-        }
-        if (i >= childNodes.length) {
-            triedForward = true;
-            i = index - 1;
-            direction = 'backward';
-            continue;
-        }
-        if (i < 0) {
-            triedBackward = true;
-            i = index + 1;
-            direction = 'forward';
-            continue;
-        }
-        child = childNodes[i];
-        index = i;
-        i += direction === 'forward' ? 1 : -1;
-    }
-    return [child, index];
-};
-/**
- * Get the nearest editable child at `index` in a `parent`, preferring
- * `direction`.
- */
-const getEditableChild = (parent, index, direction) => {
-    const [child] = getEditableChildAndIndex(parent, index, direction);
-    return child;
-};
-/**
- * Get a plaintext representation of the content of a node, accounting for block
- * elements which get a newline appended.
- *
- * The domNode must be attached to the DOM.
- */
-const getPlainText = (domNode) => {
-    let text = '';
-    if (isDOMText(domNode) && domNode.nodeValue) {
-        return domNode.nodeValue;
-    }
-    if (isDOMElement(domNode)) {
-        for (const childNode of Array.from(domNode.childNodes)) {
-            text += getPlainText(childNode);
-        }
-        const display = getComputedStyle(domNode).getPropertyValue('display');
-        if (display === 'block' || display === 'list' || domNode.tagName === 'BR') {
-            text += '\n';
-        }
-    }
-    return text;
-};
-const SlateFragmentAttributeKey = 'data-slate-angular-fragment';
-/**
- * Get x-slate-fragment attribute from data-slate-angular-fragment
- */
-const catchSlateFragment = /data-slate-angular-fragment="(.+?)"/m;
-const getSlateFragmentAttribute = (htmlData) => {
-    const [, fragment] = htmlData.match(catchSlateFragment) || [];
-    return fragment;
-};
-
-/**
- * An auto-incrementing identifier for keys.
- */
-let n = 0;
-/**
- * A class that keeps track of a key string. We use a full class here because we
- * want to be able to use them as keys in `WeakMap` objects.
- */
-class Key {
-    constructor() {
-        this.id = `${n++}`;
-    }
-}
-
-const IS_IOS = typeof navigator !== 'undefined' &&
-    typeof window !== 'undefined' &&
-    /iPad|iPhone|iPod/.test(navigator.userAgent) &&
-    !window.MSStream;
-const IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);
-const IS_ANDROID = typeof navigator !== 'undefined' && /Android/.test(navigator.userAgent);
-const IS_FIREFOX = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
-const IS_SAFARI = typeof navigator !== 'undefined' && /Version\/[\d\.]+.*Safari/.test(navigator.userAgent);
-// "modern" Edge was released at 79.x
-const IS_EDGE_LEGACY = typeof navigator !== 'undefined' && /Edge?\/(?:[0-6][0-9]|[0-7][0-8])(?:\.)/i.test(navigator.userAgent);
-const IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent);
-// Native beforeInput events don't work well with react on Chrome 75 and older, Chrome 76+ can use beforeInput
-const IS_CHROME_LEGACY = typeof navigator !== 'undefined' &&
-    /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])/i.test(navigator.userAgent) &&
-    // Exclude Chrome version greater than 3 bits，Chrome releases v100 on 2022.03.29
-    !/Chrome?\/(?:\d{3,})/i.test(navigator.userAgent);
-// Firefox did not support `beforeInput` until `v87`.
-const IS_FIREFOX_LEGACY = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox\/(?:[0-7][0-9]|[0-8][0-6])(?:\.)).*/i.test(navigator.userAgent);
-// qq browser
-const IS_QQBROWSER = typeof navigator !== 'undefined' && /.*QQBrowser/.test(navigator.userAgent);
-// UC mobile browser
-const IS_UC_MOBILE = typeof navigator !== 'undefined' && /.*UCBrowser/.test(navigator.userAgent);
-// Wechat browser
-const IS_WECHATBROWSER = typeof navigator !== 'undefined' && /.*Wechat/.test(navigator.userAgent);
-// COMPAT: Firefox/Edge Legacy don't support the `beforeinput` event
-// Chrome Legacy doesn't support `beforeinput` correctly
-const HAS_BEFORE_INPUT_SUPPORT = !IS_CHROME_LEGACY &&
-    !IS_EDGE_LEGACY &&
-    // globalThis is undefined in older browsers
-    typeof globalThis !== 'undefined' &&
-    globalThis.InputEvent &&
-    // @ts-ignore The `getTargetRanges` property isn't recognized.
-    typeof globalThis.InputEvent.prototype.getTargetRanges === 'function';
-
 const FAKE_LEFT_BLOCK_CARD_OFFSET = -1;
 const FAKE_RIGHT_BLOCK_CARD_OFFSET = -2;
 function hasBlockCardWithNode(node) {
@@ -286,61 +35,251 @@ function isCardCenterByTargetAttr(targetAttr) {
     return targetAttr && targetAttr.nodeValue === 'card-center';
 }
 
-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');
+const customToDOMNode = (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;
+};
+DOMEditor.toDOMNode = customToDOMNode;
+const toDOMPointForBlockCard = (editor, point) => {
+    const [node] = Editor.node(editor, point.path);
+    const [parentNode] = Editor.parent(editor, point.path);
+    if (editor.isBlockCard(parentNode) || editor.isBlockCard(node)) {
+        if (point.offset < 0) {
+            if (point.offset === FAKE_LEFT_BLOCK_CARD_OFFSET) {
+                const cursorNode = CustomDOMEditor.getCardCursorNode(editor, node, { direction: 'left' });
+                return [cursorNode, 1];
+            }
+            else {
+                const cursorNode = CustomDOMEditor.getCardCursorNode(editor, node, { direction: 'right' });
+                return [cursorNode, 1];
+            }
         }
-        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);
+        if (editor.selection && Range.isExpanded(editor.selection)) {
+            const [start, end] = Range.edges(editor.selection);
+            if (start === point) {
+                const cursorNode = CustomDOMEditor.getCardCursorNode(editor, parentNode, { direction: 'left' });
+                return [cursorNode, 1];
+            }
+            else {
+                const cursorNode = CustomDOMEditor.getCardCursorNode(editor, parentNode, { direction: 'right' });
+                return [cursorNode, 1];
+            }
         }
-        return key;
-    },
-    /**
-     * handle editor error.
-     */
-    onError(errorData) {
-        if (errorData.nativeError) {
-            throw errorData.nativeError;
+    }
+};
+const customToDOMPoint = (editor, point) => {
+    const [node] = Editor.node(editor, point.path);
+    const el = customToDOMNode(editor, node);
+    let domPoint;
+    const domPointForBlackCard = toDOMPointForBlockCard(editor, point);
+    if (domPointForBlackCard) {
+        return domPointForBlackCard;
+    }
+    // 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;
         }
-    },
-    /**
-     * 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) && child === editor) {
-                    return path;
-                }
-                else {
-                    break;
-                }
+        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];
             }
-            const i = NODE_TO_INDEX.get(child);
-            if (i == null) {
-                break;
+            break;
+        }
+        start = end;
+    }
+    if (!domPoint) {
+        throw new Error(`Cannot resolve a DOM point from Slate point: ${JSON.stringify(point)}`);
+    }
+    return domPoint;
+};
+DOMEditor.toDOMPoint = customToDOMPoint;
+const toSlatePointForBlockCard = (editor, domPoint, nearestNode) => {
+    const [domNode] = domPoint;
+    const cardTargetAttr = getCardTargetAttribute(domNode);
+    if (cardTargetAttr) {
+        const domSelection = window.getSelection();
+        const blockCardEntry = CustomDOMEditor.toSlateCardEntry(editor, domNode) || CustomDOMEditor.toSlateCardEntry(editor, nearestNode);
+        const [, blockPath] = blockCardEntry;
+        if (domSelection.isCollapsed) {
+            if (isCardLeftByTargetAttr(cardTargetAttr)) {
+                return { path: blockPath, offset: -1 };
+            }
+            else {
+                return { path: blockPath, offset: -2 };
             }
-            path.unshift(i);
-            child = parent;
         }
-        throw new Error(`Unable to find the path for Slate node: ${JSON.stringify(node)}`);
-    },
+        if (isCardLeftByTargetAttr(cardTargetAttr)) {
+            return Editor.start(editor, blockPath);
+        }
+        else {
+            return Editor.end(editor, blockPath);
+        }
+    }
+};
+const customToSlatePoint = (editor, domPoint, options) => {
+    const { exactMatch, suppressThrow } = options;
+    const [nearestNode, nearestOffset] = normalizeDOMPoint(domPoint);
+    let parentNode = nearestNode.parentNode;
+    let textNode = null;
+    let offset = 0;
+    const slatePointForBlockCard = toSlatePointForBlockCard(editor, domPoint, nearestNode);
+    if (slatePointForBlockCard) {
+        return slatePointForBlockCard;
+    }
+    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 && CustomDOMEditor.isLeafInEditor(editor, leafNode)) {
+            textNode = leafNode.closest('[data-slate-node="text"]');
+            const window = DOMEditor.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.
+            const spacer = voidNode.querySelector('[data-slate-spacer="true"]');
+            leafNode = spacer.firstElementChild;
+            parentNode = leafNode.firstElementChild;
+            textNode = spacer;
+            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) {
+        if (suppressThrow) {
+            return null;
+        }
+        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)
+    let slateNode = null;
+    try {
+        slateNode = CustomDOMEditor.toSlateNode(editor, textNode);
+    }
+    catch (error) {
+        if (!suppressThrow) {
+            throw error;
+        }
+    }
+    if (!slateNode && suppressThrow) {
+        return null;
+    }
+    const path = CustomDOMEditor.findPath(editor, slateNode);
+    return { path, offset };
+};
+DOMEditor.toSlatePoint = customToSlatePoint;
+const customToSlateRange = (editor, domRange, options) => {
+    const { exactMatch, suppressThrow } = options || {};
+    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$1 && hasShadowRoot(anchorNode)) {
+                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 = DOMEditor.toSlatePoint(editor, [anchorNode, anchorOffset], { suppressThrow, exactMatch });
+    if (!anchor) {
+        return null;
+    }
+    const focus = isCollapsed ? anchor : DOMEditor.toSlatePoint(editor, [focusNode, focusOffset], { suppressThrow, exactMatch });
+    if (!focus) {
+        return null;
+    }
+    let range = { anchor: anchor, focus: focus };
+    // if the selection is a hanging range that ends in a void
+    // and the DOM focus is an Element
+    // (meaning that the selection ends before the element)
+    // unhang the range to avoid mistakenly including the void
+    if (Range.isExpanded(range) &&
+        Range.isForward(range) &&
+        isDOMElement(focusNode) &&
+        Editor.void(editor, { at: range.focus, mode: 'highest' })) {
+        range = Editor.unhangRange(editor, range, { voids: true });
+    }
+    return range;
+};
+DOMEditor.toSlateRange = customToSlateRange;
+const CustomDOMEditor = {
+    ...DOMEditor,
     isNodeInEditor(editor, node) {
         let child = node;
         while (true) {
@@ -361,321 +300,14 @@ const AngularEditor = {
         }
         return false;
     },
-    /**
-     * 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 => Element.isElement(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
+    isLeafInEditor(editor, leafNode) {
+        const textNode = leafNode.closest('[data-slate-node="text"]');
+        let node = null;
         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, options) {
-        const [node] = Editor.node(editor, point.path);
-        const el = AngularEditor.toDOMNode(editor, node);
-        let domPoint;
-        // block card
-        const [parentNode] = Editor.parent(editor, point.path);
-        if (editor.isBlockCard(parentNode) || editor.isBlockCard(node)) {
-            if (point.offset < 0) {
-                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 (Range.isExpanded(options.range)) {
-                const [start, end] = Range.edges(options.range);
-                if (start === point) {
-                    const cursorNode = AngularEditor.getCardCursorNode(editor, parentNode, { direction: 'left' });
-                    return [cursorNode, 1];
-                }
-                else {
-                    const cursorNode = AngularEditor.getCardCursorNode(editor, parentNode, { 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, { range });
-        const domFocus = Range.isCollapsed(range) ? domAnchor : AngularEditor.toDOMPoint(editor, focus, { range });
-        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, options) {
-        const { suppressThrow } = options || { suppressThrow: false };
-        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) {
-            if (suppressThrow) {
-                return null;
-            }
-            throw new Error(`Cannot resolve a Slate node from DOM node: ${domEl}`);
+            node = CustomDOMEditor.toSlateNode(editor, textNode);
         }
-        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, { suppressThrow: false });
-        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 (Element.isElement(node) && 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, { suppressThrow: false });
-        return range;
-    },
-    isLeafInEditor(editor, leafNode, options) {
-        const { suppressThrow } = options;
-        const textNode = leafNode.closest('[data-slate-node="text"]');
-        const node = AngularEditor.toSlateNode(editor, textNode, { suppressThrow });
-        if (node && AngularEditor.isNodeInEditor(editor, node)) {
+        catch (error) { }
+        if (node && CustomDOMEditor.isNodeInEditor(editor, node)) {
             return true;
         }
         else {
@@ -683,162 +315,22 @@ const AngularEditor = {
         }
     },
     /**
-     * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
-     */
-    toSlatePoint(editor, domPoint, options) {
-        const { exactMatch, suppressThrow } = options;
-        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 };
-                }
-            }
-            if (isCardLeftByTargetAttr(cardTargetAttr)) {
-                return Editor.start(editor, blockPath);
-            }
-            else {
-                return Editor.end(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 && AngularEditor.isLeafInEditor(editor, leafNode, { suppressThrow: true })) {
-                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.
-                const spacer = voidNode.querySelector('[data-slate-spacer="true"]');
-                leafNode = spacer.firstElementChild;
-                parentNode = leafNode.firstElementChild;
-                textNode = spacer;
-                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) {
-            if (suppressThrow) {
-                return null;
-            }
-            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, { suppressThrow });
-        if (!slateNode && suppressThrow) {
-            return null;
-        }
-        const path = AngularEditor.findPath(editor, slateNode);
-        return { path, offset };
-    },
-    /**
-     * Find a Slate range from a DOM range or selection.
+     * Check if the editor is hanging right.
      */
-    toSlateRange(editor, domRange, options) {
-        const { exactMatch, suppressThrow } = options || {};
-        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], { suppressThrow, exactMatch });
-        if (!anchor) {
-            return null;
+    isBlockHangingRight(editor) {
+        const { selection } = editor;
+        if (!selection) {
+            return false;
         }
-        const focus = isCollapsed ? anchor : AngularEditor.toSlatePoint(editor, [focusNode, focusOffset], { suppressThrow, exactMatch });
-        if (!focus) {
-            return null;
+        if (Range.isCollapsed(selection)) {
+            return false;
         }
-        let range = { anchor: anchor, focus: focus };
-        // if the selection is a hanging range that ends in a void
-        // and the DOM focus is an Element
-        // (meaning that the selection ends before the element)
-        // unhang the range to avoid mistakenly including the void
-        if (Range.isExpanded(range) &&
-            Range.isForward(range) &&
-            isDOMElement(focusNode) &&
-            Editor.void(editor, { at: range.focus, mode: 'highest' })) {
-            range = Editor.unhangRange(editor, range, { voids: true });
-        }
-        return range;
-    },
-    isLeafBlock(editor, node) {
-        return Element.isElement(node) && !editor.isInline(node) && Editor.hasInlines(editor, node);
+        const [start, end] = Range.edges(selection);
+        const endBlock = Editor.above(editor, {
+            at: end,
+            match: node => Element.isElement(node) && Editor.isBlock(editor, node)
+        });
+        return Editor.isStart(editor, end, endBlock[1]);
     },
     isBlockCardLeftCursor(editor) {
         return (editor.selection?.anchor?.offset === FAKE_LEFT_BLOCK_CARD_OFFSET &&
@@ -849,15 +341,45 @@ const AngularEditor = {
             editor.selection?.focus?.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET);
     },
     getCardCursorNode(editor, blockCardNode, options) {
-        const blockCardElement = AngularEditor.toDOMNode(editor, blockCardNode);
+        const blockCardElement = DOMEditor.toDOMNode(editor, blockCardNode);
         const cardCenter = blockCardElement.parentElement;
         return options.direction === 'left' ? cardCenter.previousElementSibling.firstChild : cardCenter.nextElementSibling.firstChild;
     },
     toSlateCardEntry(editor, node) {
         const element = node.parentElement.closest('.slate-block-card')?.querySelector('[card-target="card-center"]').firstElementChild;
-        const slateNode = AngularEditor.toSlateNode(editor, element, { suppressThrow: false });
-        const path = AngularEditor.findPath(editor, slateNode);
+        const slateNode = DOMEditor.toSlateNode(editor, element);
+        const path = DOMEditor.findPath(editor, slateNode);
         return [slateNode, path];
+    }
+};
+
+const AngularEditor = {
+    ...CustomDOMEditor,
+    /**
+     * handle editor error.
+     */
+    onError(errorData) {
+        if (errorData.nativeError) {
+            throw errorData.nativeError;
+        }
+    },
+    /**
+     * onKeydown hook.
+     */
+    onKeydown(editor, data) {
+        editor.onKeydown(data);
+    },
+    /**
+     * onClick hook.
+     */
+    onClick(editor, data) {
+        editor.onClick(data);
+    },
+    deleteCutData(editor) {
+        editor.deleteCutData();
+    },
+    isLeafBlock(editor, node) {
+        return Element.isElement(node) && !editor.isInline(node) && Editor.hasInlines(editor, node);
     },
     /**
      * move native selection to card-left or card-right
@@ -883,13 +405,53 @@ const AngularEditor = {
             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);
     }
 };
 
+/**
+ * Symbols.
+ */
+const PLACEHOLDER_SYMBOL = Symbol('placeholder');
+/**
+ * Weak map for associating the html element with the component.
+ */
+const ELEMENT_TO_COMPONENT = new WeakMap();
+const EDITOR_TO_AFTER_VIEW_INIT_QUEUE = new WeakMap();
+
+const IS_IOS = typeof navigator !== 'undefined' &&
+    typeof window !== 'undefined' &&
+    /iPad|iPhone|iPod/.test(navigator.userAgent) &&
+    !window.MSStream;
+const IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);
+const IS_ANDROID = typeof navigator !== 'undefined' && /Android/.test(navigator.userAgent);
+const IS_FIREFOX = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
+const IS_SAFARI = typeof navigator !== 'undefined' && /Version\/[\d\.]+.*Safari/.test(navigator.userAgent);
+// "modern" Edge was released at 79.x
+const IS_EDGE_LEGACY = typeof navigator !== 'undefined' && /Edge?\/(?:[0-6][0-9]|[0-7][0-8])(?:\.)/i.test(navigator.userAgent);
+const IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent);
+// Native beforeInput events don't work well with react on Chrome 75 and older, Chrome 76+ can use beforeInput
+const IS_CHROME_LEGACY = typeof navigator !== 'undefined' &&
+    /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])/i.test(navigator.userAgent) &&
+    // Exclude Chrome version greater than 3 bits，Chrome releases v100 on 2022.03.29
+    !/Chrome?\/(?:\d{3,})/i.test(navigator.userAgent);
+// Firefox did not support `beforeInput` until `v87`.
+const IS_FIREFOX_LEGACY = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox\/(?:[0-7][0-9]|[0-8][0-6])(?:\.)).*/i.test(navigator.userAgent);
+// qq browser
+const IS_QQBROWSER = typeof navigator !== 'undefined' && /.*QQBrowser/.test(navigator.userAgent);
+// UC mobile browser
+const IS_UC_MOBILE = typeof navigator !== 'undefined' && /.*UCBrowser/.test(navigator.userAgent);
+// Wechat browser
+const IS_WECHATBROWSER = typeof navigator !== 'undefined' && /.*Wechat/.test(navigator.userAgent);
+// COMPAT: Firefox/Edge Legacy don't support the `beforeinput` event
+// Chrome Legacy doesn't support `beforeinput` correctly
+const HAS_BEFORE_INPUT_SUPPORT = !IS_CHROME_LEGACY &&
+    !IS_EDGE_LEGACY &&
+    // globalThis is undefined in older browsers
+    typeof globalThis !== 'undefined' &&
+    globalThis.InputEvent &&
+    // @ts-ignore The `getTargetRanges` property isn't recognized.
+    typeof globalThis.InputEvent.prototype.getTargetRanges === 'function';
+
 /**
  * Hotkey mappings for each platform.
  */
@@ -1188,6 +750,44 @@ const getNavigatorClipboard = async () => {
     return clipboardData;
 };
 
+const SlateFragmentAttributeKey = 'data-slate-angular-fragment';
+/**
+ * Get x-slate-fragment attribute from data-slate-angular-fragment
+ */
+const catchSlateFragment = /data-slate-angular-fragment="(.+?)"/m;
+const getSlateFragmentAttribute = (htmlData) => {
+    const [, fragment] = htmlData.match(catchSlateFragment) || [];
+    return fragment;
+};
+/**
+ * Check if a DOM node is an element node.
+ */
+const isDOMText = (value) => {
+    return isDOMNode(value) && value.nodeType === 3;
+};
+/**
+ * Get a plaintext representation of the content of a node, accounting for block
+ * elements which get a newline appended.
+ *
+ * The domNode must be attached to the DOM.
+ */
+const getPlainText = (domNode) => {
+    let text = '';
+    if (isDOMText(domNode) && domNode.nodeValue) {
+        return domNode.nodeValue;
+    }
+    if (isDOMElement(domNode)) {
+        for (const childNode of Array.from(domNode.childNodes)) {
+            text += getPlainText(childNode);
+        }
+        const display = getComputedStyle(domNode).getPropertyValue('display');
+        if (display === 'block' || display === 'list' || domNode.tagName === 'BR') {
+            text += '\n';
+        }
+    }
+    return text;
+};
+
 const buildHTMLText = (wrapper, attach, data) => {
     const stringObj = JSON.stringify(data);
     const encoded = window.btoa(encodeURIComponent(stringObj));
@@ -1262,128 +862,10 @@ const setClipboardData = async (clipboardData, wrapper, attach, dataTransfer) =>
     }
 };
 
-/**
- * Utilities for single-line deletion
- */
-const doRectsIntersect = (rect, compareRect) => {
-    const middle = (compareRect.top + compareRect.bottom) / 2;
-    return rect.top <= middle && rect.bottom >= middle;
-};
-const areRangesSameLine = (editor, range1, range2) => {
-    const rect1 = AngularEditor.toDOMRange(editor, range1).getBoundingClientRect();
-    const rect2 = AngularEditor.toDOMRange(editor, range2).getBoundingClientRect();
-    return doRectsIntersect(rect1, rect2) && doRectsIntersect(rect2, rect1);
-};
-/**
- * A helper utility that returns the end portion of a `Range`
- * which is located on a single line.
- *
- * @param {Editor} editor The editor object to compare against
- * @param {Range} parentRange The parent range to compare against
- * @returns {Range} A valid portion of the parentRange which is one a single line
- */
-const findCurrentLineRange = (editor, parentRange) => {
-    const parentRangeBoundary = Editor.range(editor, Range.end(parentRange));
-    const positions = Array.from(Editor.positions(editor, { at: parentRange }));
-    let left = 0;
-    let right = positions.length;
-    let middle = Math.floor(right / 2);
-    if (areRangesSameLine(editor, Editor.range(editor, positions[left]), parentRangeBoundary)) {
-        return Editor.range(editor, positions[left], parentRangeBoundary);
-    }
-    if (positions.length < 2) {
-        return Editor.range(editor, positions[positions.length - 1], parentRangeBoundary);
-    }
-    while (middle !== positions.length && middle !== left) {
-        if (areRangesSameLine(editor, Editor.range(editor, positions[middle]), parentRangeBoundary)) {
-            right = middle;
-        }
-        else {
-            left = middle;
-        }
-        middle = Math.floor((left + right) / 2);
-    }
-    return Editor.range(editor, positions[right], parentRangeBoundary);
-};
-
 const withAngular = (editor, clipboardFormatKey = 'x-slate-fragment') => {
-    const e = editor;
-    const { apply, onChange, deleteBackward } = e;
-    e.deleteBackward = unit => {
-        if (unit !== 'line') {
-            return deleteBackward(unit);
-        }
-        if (editor.selection && Range.isCollapsed(editor.selection)) {
-            const parentBlockEntry = Editor.above(editor, {
-                match: n => Element.isElement(n) && Editor.isBlock(editor, n),
-                at: editor.selection
-            });
-            if (parentBlockEntry) {
-                const [, parentBlockPath] = parentBlockEntry;
-                const parentElementRange = Editor.range(editor, parentBlockPath, editor.selection.anchor);
-                const currentLineRange = findCurrentLineRange(e, parentElementRange);
-                if (!Range.isCollapsed(currentLineRange)) {
-                    Transforms.delete(editor, { at: currentLineRange });
-                }
-            }
-        }
-    };
-    e.apply = (op) => {
-        const matches = [];
-        switch (op.type) {
-            case 'insert_text':
-            case 'remove_text':
-            case 'set_node': {
-                for (const [node, path] of Editor.levels(e, { at: op.path })) {
-                    const key = AngularEditor.findKey(e, node);
-                    matches.push([path, key]);
-                }
-                break;
-            }
-            case 'insert_node':
-            case 'remove_node':
-            case 'merge_node':
-            case 'split_node': {
-                for (const [node, path] of Editor.levels(e, {
-                    at: Path.parent(op.path)
-                })) {
-                    const key = AngularEditor.findKey(e, node);
-                    matches.push([path, key]);
-                }
-                break;
-            }
-            case 'move_node': {
-                const commonPath = Path.common(Path.parent(op.path), Path.parent(op.newPath));
-                for (const [node, path] of Editor.levels(e, {
-                    at: Path.parent(op.path)
-                })) {
-                    const key = AngularEditor.findKey(e, node);
-                    matches.push([Editor.pathRef(editor, path), key]);
-                }
-                for (const [node, path] of Editor.levels(e, {
-                    at: Path.parent(op.newPath)
-                })) {
-                    if (path.length > commonPath.length) {
-                        const key = AngularEditor.findKey(e, node);
-                        matches.push([Editor.pathRef(editor, path), key]);
-                    }
-                }
-                break;
-            }
-        }
-        apply(op);
-        for (const [source, key] of matches) {
-            const [node] = Editor.node(e, Path.isPath(source) ? source : source.current);
-            NODE_TO_KEY.set(node, key);
-        }
-    };
-    e.onChange = () => {
-        const onContextChange = EDITOR_TO_ON_CHANGE.get(e);
-        if (onContextChange) {
-            onContextChange();
-        }
-        onChange();
-    };
+    let e = editor;
+    let { apply } = e;
+    e = withDOM(e, clipboardFormatKey);
     e.setFragmentData = (dataTransfer, originEvent) => {
         const { selection } = e;
         if (!selection) {
@@ -1472,11 +954,11 @@ const withAngular = (editor, clipboardFormatKey = 'x-slate-fragment') => {
         }
     };
     e.insertData = async (data) => {
-        if (!(await e.insertFragmentData(data))) {
+        if (!(await e.customInsertFragmentData(data))) {
             e.insertTextData(data);
         }
     };
-    e.insertFragmentData = async (data) => {
+    e.customInsertFragmentData = async (data) => {
         /**
          * Checking copied fragment from application/x-slate-fragment or data-slate-fragment
          */
@@ -1487,7 +969,7 @@ const withAngular = (editor, clipboardFormatKey = 'x-slate-fragment') => {
         }
         return false;
     };
-    e.insertTextData = async (data) => {
+    e.customInsertTextData = async (data) => {
         const clipboardData = await getClipboardData(data);
         if (clipboardData && clipboardData.text) {
             const lines = clipboardData.text.split(/\r\n|\r|\n/);
@@ -1515,6 +997,56 @@ const withAngular = (editor, clipboardFormatKey = 'x-slate-fragment') => {
             console.error(errorData);
         }
     };
+    // exist issue for move operation in withDOM
+    e.apply = (op) => {
+        const matches = [];
+        switch (op.type) {
+            case 'insert_text':
+            case 'remove_text':
+            case 'set_node': {
+                for (const [node, path] of Editor.levels(e, { at: op.path })) {
+                    const key = AngularEditor.findKey(e, node);
+                    matches.push([path, key]);
+                }
+                break;
+            }
+            case 'insert_node':
+            case 'remove_node':
+            case 'merge_node':
+            case 'split_node': {
+                for (const [node, path] of Editor.levels(e, {
+                    at: Path.parent(op.path)
+                })) {
+                    const key = AngularEditor.findKey(e, node);
+                    matches.push([path, key]);
+                }
+                break;
+            }
+            case 'move_node': {
+                const commonPath = Path.common(Path.parent(op.path), Path.parent(op.newPath));
+                for (const [node, path] of Editor.levels(e, {
+                    at: Path.parent(op.path)
+                })) {
+                    const key = AngularEditor.findKey(e, node);
+                    matches.push([Editor.pathRef(editor, path), key]);
+                }
+                for (const [node, path] of Editor.levels(e, {
+                    at: Path.parent(op.newPath)
+                })) {
+                    if (path.length > commonPath.length) {
+                        const key = AngularEditor.findKey(e, node);
+                        matches.push([Editor.pathRef(editor, path), key]);
+                    }
+                }
+                break;
+            }
+        }
+        apply(op);
+        for (const [source, key] of matches) {
+            const [node] = Editor.node(e, Path.isPath(source) ? source : source.current);
+            NODE_TO_KEY.set(node, key);
+        }
+    };
     return e;
 };
 
@@ -3118,8 +2650,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImpor
 
 const SLATE_DEFAULT_LEAF_COMPONENT_TOKEN = new InjectionToken('slate-default-leaf-token');
 
-const TRIPLE_CLICK = 3;
-
 // not correctly clipboardData on beforeinput
 const forceOnDOMPaste = IS_SAFARI;
 class SlateEditable {
@@ -3170,7 +2700,7 @@ class SlateEditable {
         EDITOR_TO_ELEMENT.set(this.editor, this.elementRef.nativeElement);
         NODE_TO_ELEMENT.set(this.editor, this.elementRef.nativeElement);
         ELEMENT_TO_NODE.set(this.elementRef.nativeElement, this.editor);
-        IS_READONLY.set(this.editor, this.readonly);
+        IS_READ_ONLY.set(this.editor, this.readonly);
         EDITOR_TO_ON_CHANGE.set(this.editor, () => {
             this.ngZone.run(() => {
                 this.onChange();
@@ -3202,7 +2732,7 @@ class SlateEditable {
         }
         const readonlyChange = simpleChanges['readonly'];
         if (readonlyChange) {
-            IS_READONLY.set(this.editor, this.readonly);
+            IS_READ_ONLY.set(this.editor, this.readonly);
             this.render();
             this.toSlateSelection();
         }
@@ -3276,7 +2806,10 @@ class SlateEditable {
             }
             // If the DOM selection is in the editor and the editor selection is already correct, we're done.
             if (hasDomSelection && hasDomSelectionInEditor && selection && hasStringTarget(domSelection)) {
-                const rangeFromDOMSelection = AngularEditor.toSlateRange(this.editor, domSelection, { suppressThrow: true });
+                const rangeFromDOMSelection = AngularEditor.toSlateRange(this.editor, domSelection, {
+                    exactMatch: false,
+                    suppressThrow: true
+                });
                 if (rangeFromDOMSelection && Range.equals(rangeFromDOMSelection, selection)) {
                     return;
                 }
@@ -3290,7 +2823,7 @@ class SlateEditable {
             // but Slate's value is not being updated through any operation
             // and thus it doesn't transform selection on its own
             if (selection && !AngularEditor.hasRange(this.editor, selection)) {
-                this.editor.selection = AngularEditor.toSlateRange(this.editor, domSelection, { suppressThrow: false });
+                this.editor.selection = AngularEditor.toSlateRange(this.editor, domSelection, { exactMatch: false, suppressThrow: false });
                 return;
             }
             // Otherwise the DOM selection is out of sync, so update it.
@@ -3514,14 +3047,14 @@ class SlateEditable {
             let targetRange = null;
             let [nativeTargetRange] = event.getTargetRanges();
             if (nativeTargetRange) {
-                targetRange = AngularEditor.toSlateRange(editor, nativeTargetRange);
+                targetRange = AngularEditor.toSlateRange(editor, nativeTargetRange, { exactMatch: false, suppressThrow: false });
             }
             // COMPAT: SelectionChange event is fired after the action is performed, so we
             // have to manually get the selection here to ensure it's up-to-date.
             const window = AngularEditor.getWindow(editor);
             const domSelection = window.getSelection();
             if (!targetRange && domSelection) {
-                targetRange = AngularEditor.toSlateRange(editor, domSelection);
+                targetRange = AngularEditor.toSlateRange(editor, domSelection, { exactMatch: false, suppressThrow: false });
             }
             targetRange = targetRange ?? editor.selection;
             if (type === 'insertCompositionText') {
@@ -3567,7 +3100,7 @@ class SlateEditable {
             }
         }
         if (!this.readonly &&
-            hasEditableTarget(editor, event.target) &&
+            AngularEditor.hasEditableTarget(editor, event.target) &&
             !isTargetInsideVoid(editor, activeElement) &&
             !this.isDOMEventHandled(event, this.beforeInput)) {
             try {
@@ -3668,7 +3201,7 @@ class SlateEditable {
     onDOMBlur(event) {
         if (this.readonly ||
             this.isUpdatingSelection ||
-            !hasEditableTarget(this.editor, event.target) ||
+            !AngularEditor.hasEditableTarget(this.editor, event.target) ||
             this.isDOMEventHandled(event, this.blur)) {
             return;
         }
@@ -3707,7 +3240,7 @@ class SlateEditable {
     }
     onDOMClick(event) {
         if (!this.readonly &&
-            hasTarget(this.editor, event.target) &&
+            AngularEditor.hasTarget(this.editor, event.target) &&
             !this.isDOMEventHandled(event, this.click) &&
             isDOMNode(event.target)) {
             const node = AngularEditor.toSlateNode(this.editor, event.target);
@@ -3747,7 +3280,7 @@ class SlateEditable {
                 this.forceRender();
             }
         }
-        if (hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionStart)) {
+        if (AngularEditor.hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionStart)) {
             this.isComposing = true;
         }
         this.render();
@@ -3759,7 +3292,7 @@ class SlateEditable {
         if (!event.data && !Range.isCollapsed(this.editor.selection)) {
             Transforms.delete(this.editor);
         }
-        if (hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionEnd)) {
+        if (AngularEditor.hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionEnd)) {
             // COMPAT: In Chrome/Firefox, `beforeinput` events for compositions
             // aren't correct and never fire the "insertFromComposition"
             // type that we need. So instead, insert whenever a composition
@@ -3777,13 +3310,13 @@ class SlateEditable {
     onDOMCopy(event) {
         const window = AngularEditor.getWindow(this.editor);
         const isOutsideSlate = !hasStringTarget(window.getSelection()) && isTargetInsideVoid(this.editor, event.target);
-        if (!isOutsideSlate && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.copy)) {
+        if (!isOutsideSlate && AngularEditor.hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.copy)) {
             event.preventDefault();
             AngularEditor.setFragmentData(this.editor, event.clipboardData, 'copy');
         }
     }
     onDOMCut(event) {
-        if (!this.readonly && hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.cut)) {
+        if (!this.readonly && AngularEditor.hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.cut)) {
             event.preventDefault();
             AngularEditor.setFragmentData(this.editor, event.clipboardData, 'cut');
             const { selection } = this.editor;
@@ -3793,7 +3326,7 @@ class SlateEditable {
         }
     }
     onDOMDragOver(event) {
-        if (hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragOver)) {
+        if (AngularEditor.hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragOver)) {
             // Only when the target is void, call `preventDefault` to signal
             // that drops are allowed. Editable content is droppable by
             // default, and calling `preventDefault` hides the cursor.
@@ -3804,7 +3337,7 @@ class SlateEditable {
         }
     }
     onDOMDragStart(event) {
-        if (!this.readonly && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragStart)) {
+        if (!this.readonly && AngularEditor.hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragStart)) {
             const node = AngularEditor.toSlateNode(this.editor, event.target);
             const path = AngularEditor.findPath(this.editor, node);
             const voidMatch = Element.isElement(node) && (Editor.isVoid(this.editor, node) || Editor.void(this.editor, { at: path, voids: true }));
@@ -3820,7 +3353,7 @@ class SlateEditable {
     }
     onDOMDrop(event) {
         const editor = this.editor;
-        if (!this.readonly && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.drop)) {
+        if (!this.readonly && AngularEditor.hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.drop)) {
             event.preventDefault();
             // Keep a reference to the dragged range before updating selection
             const draggedRange = editor.selection;
@@ -3847,7 +3380,7 @@ class SlateEditable {
     onDOMDragEnd(event) {
         if (!this.readonly &&
             this.isDraggingInternally &&
-            hasTarget(this.editor, event.target) &&
+            AngularEditor.hasTarget(this.editor, event.target) &&
             !this.isDOMEventHandled(event, this.dragEnd)) {
             this.isDraggingInternally = false;
         }
@@ -3855,7 +3388,7 @@ class SlateEditable {
     onDOMFocus(event) {
         if (!this.readonly &&
             !this.isUpdatingSelection &&
-            hasEditableTarget(this.editor, event.target) &&
+            AngularEditor.hasEditableTarget(this.editor, event.target) &&
             !this.isDOMEventHandled(event, this.focus)) {
             const el = AngularEditor.toDOMNode(this.editor, this.editor);
             const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
@@ -3875,7 +3408,7 @@ class SlateEditable {
         const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
         const { activeElement } = root;
         if (!this.readonly &&
-            hasEditableTarget(editor, event.target) &&
+            AngularEditor.hasEditableTarget(editor, event.target) &&
             !isTargetInsideVoid(editor, activeElement) && // stop fire keydown handle when focus void node
             !this.isComposing &&
             !this.isDOMEventHandled(event, this.keydown)) {
@@ -4097,7 +3630,7 @@ class SlateEditable {
         if (!this.isDOMEventHandled(event, this.paste) &&
             (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event) || forceOnDOMPaste) &&
             !this.readonly &&
-            hasEditableTarget(this.editor, event.target)) {
+            AngularEditor.hasEditableTarget(this.editor, event.target)) {
             event.preventDefault();
             AngularEditor.insertData(this.editor, event.clipboardData);
         }
@@ -4109,7 +3642,7 @@ class SlateEditable {
         if (!HAS_BEFORE_INPUT_SUPPORT &&
             !this.readonly &&
             !this.isDOMEventHandled(event.nativeEvent, this.beforeInput) &&
-            hasEditableTarget(this.editor, event.nativeEvent.target)) {
+            AngularEditor.hasEditableTarget(this.editor, event.nativeEvent.target)) {
             event.nativeEvent.preventDefault();
             try {
                 const text = event.data;
@@ -4300,36 +3833,15 @@ const defaultScrollSelectionIntoView = (editor, domRange) => {
         delete leafEl.getBoundingClientRect;
     }
 };
-/**
- * Check if the target is editable and in the editor.
- */
-const hasEditableTarget = (editor, target) => {
-    return isDOMNode(target) && AngularEditor.hasDOMNode(editor, target, { editable: true });
-};
-/**
- * Check if two DOM range objects are equal.
- */
-const isRangeEqual = (a, b) => {
-    return ((a.startContainer === b.startContainer &&
-        a.startOffset === b.startOffset &&
-        a.endContainer === b.endContainer &&
-        a.endOffset === b.endOffset) ||
-        (a.startContainer === b.endContainer &&
-            a.startOffset === b.endOffset &&
-            a.endContainer === b.startContainer &&
-            a.endOffset === b.startOffset));
-};
-/**
- * Check if the target is in the editor.
- */
-const hasTarget = (editor, target) => {
-    return isDOMNode(target) && AngularEditor.hasDOMNode(editor, target);
-};
 /**
  * Check if the target is inside void and in the editor.
  */
 const isTargetInsideVoid = (editor, target) => {
-    const slateNode = hasTarget(editor, target) && AngularEditor.toSlateNode(editor, target, { suppressThrow: true });
+    let slateNode = null;
+    try {
+        slateNode = AngularEditor.hasTarget(editor, target) && AngularEditor.toSlateNode(editor, target);
+    }
+    catch (error) { }
     return slateNode && Element.isElement(slateNode) && Editor.isVoid(editor, slateNode);
 };
 const hasStringTarget = (domSelection) => {
@@ -4490,5 +4002,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.2", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AngularEditor, BaseComponent, BaseElementComponent, BaseLeafComponent, BaseTextComponent, DOMComment, DOMElement, DOMNode, DOMRange, DOMSelection, DOMStaticRange, DOMText, EDITOR_TO_AFTER_VIEW_INIT_QUEUE, EDITOR_TO_ELEMENT, EDITOR_TO_ON_CHANGE, EDITOR_TO_PLACEHOLDER, EDITOR_TO_WINDOW, ELEMENT_TO_COMPONENT, ELEMENT_TO_NODE, FAKE_LEFT_BLOCK_CARD_OFFSET, FAKE_RIGHT_BLOCK_CARD_OFFSET, HAS_BEFORE_INPUT_SUPPORT, IS_ANDROID, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_CLICKING, IS_DRAGGING, IS_EDGE_LEGACY, IS_FIREFOX, IS_FIREFOX_LEGACY, IS_FOCUSED, IS_IOS, IS_QQBROWSER, IS_READONLY, IS_SAFARI, IS_UC_MOBILE, IS_WECHATBROWSER, KEY_TO_ELEMENT, Key, NODE_TO_ELEMENT, NODE_TO_INDEX, NODE_TO_KEY, NODE_TO_PARENT, PLACEHOLDER_SYMBOL, SlateChildren, SlateChildrenOutlet, SlateDefaultString, SlateEditable, SlateElement, SlateErrorCode, SlateFragmentAttributeKey, SlateLeaves, SlateModule, SlateString, blobAsString, buildHTMLText, check, completeTable, createClipboardData, createThrottleRAF, defaultScrollSelectionIntoView, getCardTargetAttribute, getClipboardData, getClipboardFromHTMLText, getDataTransferClipboard, getDataTransferClipboardText, getDefaultView, getEditableChild, getEditableChildAndIndex, getNavigatorClipboard, getPlainText, getSlateFragmentAttribute, hasAfterContextChange, hasBeforeContextChange, hasBlockCard, hasBlockCardWithNode, hasEditableTarget, hasShadowRoot, hotkeys, isCardCenterByTargetAttr, isCardLeft, isCardLeftByTargetAttr, isCardRightByTargetAttr, isClipboardFile, isClipboardReadSupported, isClipboardWriteSupported, isClipboardWriteTextSupported, isComponentType, isDOMComment, isDOMElement, isDOMNode, isDOMSelection, isDOMText, isDecoratorRangeListEqual, isEmpty, isInvalidTable, isPlainTextOnlyPaste, isTemplateRef, isValid, normalize, normalizeDOMPoint, setClipboardData, setDataTransferClipboard, setDataTransferClipboardText, setNavigatorClipboard, shallowCompare, stripHtml, withAngular };
+export { AngularEditor, BaseComponent, BaseElementComponent, BaseLeafComponent, BaseTextComponent, EDITOR_TO_AFTER_VIEW_INIT_QUEUE, ELEMENT_TO_COMPONENT, FAKE_LEFT_BLOCK_CARD_OFFSET, FAKE_RIGHT_BLOCK_CARD_OFFSET, HAS_BEFORE_INPUT_SUPPORT, IS_ANDROID, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_EDGE_LEGACY, IS_FIREFOX, IS_FIREFOX_LEGACY, IS_IOS, IS_QQBROWSER, IS_SAFARI, IS_UC_MOBILE, IS_WECHATBROWSER, PLACEHOLDER_SYMBOL, SlateChildren, SlateChildrenOutlet, SlateDefaultString, SlateEditable, SlateElement, SlateErrorCode, SlateFragmentAttributeKey, SlateLeaves, SlateModule, SlateString, blobAsString, buildHTMLText, check, completeTable, createClipboardData, createThrottleRAF, defaultScrollSelectionIntoView, getCardTargetAttribute, getClipboardData, getClipboardFromHTMLText, getDataTransferClipboard, getDataTransferClipboardText, getNavigatorClipboard, getPlainText, getSlateFragmentAttribute, hasAfterContextChange, hasBeforeContextChange, hasBlockCard, hasBlockCardWithNode, hotkeys, isCardCenterByTargetAttr, isCardLeft, isCardLeftByTargetAttr, isCardRightByTargetAttr, isClipboardFile, isClipboardReadSupported, isClipboardWriteSupported, isClipboardWriteTextSupported, isComponentType, isDOMText, isDecoratorRangeListEqual, isEmpty, isInvalidTable, isTemplateRef, isValid, normalize, setClipboardData, setDataTransferClipboard, setDataTransferClipboardText, setNavigatorClipboard, shallowCompare, stripHtml, withAngular };
 //# sourceMappingURL=slate-angular.mjs.map