slate-angular 15.1.3 → 16.1.0-next

package/esm2022/components/editable/editable.component.mjs

@@ -0,0 +1,1179 @@
+import { Component, Input, ViewChild, HostBinding, ElementRef, ChangeDetectionStrategy, forwardRef } from '@angular/core';
+import { NODE_TO_ELEMENT, IS_FOCUSED, EDITOR_TO_ELEMENT, ELEMENT_TO_NODE, IS_READONLY, EDITOR_TO_ON_CHANGE, EDITOR_TO_WINDOW } from '../../utils/weak-maps';
+import { Element, Transforms, Editor, Range, Path, Node } from 'slate';
+import { direction } from 'direction';
+import scrollIntoView from 'scroll-into-view-if-needed';
+import { AngularEditor } from '../../plugins/angular-editor';
+import { isDOMNode, isDOMElement, isPlainTextOnlyPaste, getDefaultView } from '../../utils/dom';
+import { Subject } from 'rxjs';
+import { IS_FIREFOX, IS_SAFARI, IS_CHROME, HAS_BEFORE_INPUT_SUPPORT, IS_ANDROID } from '../../utils/environment';
+import Hotkeys from '../../utils/hotkeys';
+import { extractBeforeInputEvent } from '../../custom-event/BeforeInputEventPlugin';
+import { BEFORE_INPUT_EVENTS } from '../../custom-event/before-input-polyfill';
+import { SlateErrorCode } from '../../types/error';
+import { SlateStringTemplate } from '../string/template.component';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { HistoryEditor } from 'slate-history';
+import { isDecoratorRangeListEqual, check, normalize } from '../../utils';
+import { restoreDom } from '../../utils/restore-dom';
+import { SlateChildren } from '../children/children.component';
+import * as i0 from "@angular/core";
+// not correctly clipboardData on beforeinput
+const forceOnDOMPaste = IS_SAFARI;
+export class SlateEditable {
+    get hasBeforeInputSupport() {
+        return HAS_BEFORE_INPUT_SUPPORT;
+    }
+    constructor(elementRef, renderer2, cdr, ngZone, injector) {
+        this.elementRef = elementRef;
+        this.renderer2 = renderer2;
+        this.cdr = cdr;
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.destroy$ = new Subject();
+        this.isComposing = false;
+        this.isDraggingInternally = false;
+        this.isUpdatingSelection = false;
+        this.latestElement = null;
+        this.manualListeners = [];
+        this.onTouchedCallback = () => { };
+        this.onChangeCallback = () => { };
+        this.decorate = () => [];
+        this.scrollSelectionIntoView = defaultScrollSelectionIntoView;
+        this.isStrictDecorate = true;
+        this.trackBy = () => null;
+        this.readonly = false;
+        //#endregion
+        //#region DOM attr
+        this.spellCheck = false;
+        this.autoCorrect = false;
+        this.autoCapitalize = false;
+        this.dataSlateEditor = true;
+        this.dataSlateNode = 'value';
+        this.dataGramm = false;
+    }
+    ngOnInit() {
+        this.editor.injector = this.injector;
+        this.editor.children = [];
+        let window = getDefaultView(this.elementRef.nativeElement);
+        EDITOR_TO_WINDOW.set(this.editor, window);
+        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);
+        EDITOR_TO_ON_CHANGE.set(this.editor, () => {
+            this.ngZone.run(() => {
+                this.onChange();
+            });
+        });
+        this.ngZone.runOutsideAngular(() => {
+            this.initialize();
+        });
+        this.initializeViewContext();
+        this.initializeContext();
+        // remove unused DOM, just keep templateComponent instance
+        this.templateElementRef.nativeElement.remove();
+        // add browser class
+        let browserClass = IS_FIREFOX ? 'firefox' : IS_SAFARI ? 'safari' : '';
+        browserClass && this.elementRef.nativeElement.classList.add(browserClass);
+    }
+    ngOnChanges(simpleChanges) {
+        if (!this.initialized) {
+            return;
+        }
+        const decorateChange = simpleChanges['decorate'];
+        if (decorateChange) {
+            this.forceFlush();
+        }
+        const placeholderChange = simpleChanges['placeholder'];
+        if (placeholderChange) {
+            this.detectContext();
+        }
+        const readonlyChange = simpleChanges['readonly'];
+        if (readonlyChange) {
+            IS_READONLY.set(this.editor, this.readonly);
+            this.detectContext();
+            this.toSlateSelection();
+        }
+    }
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    writeValue(value) {
+        if (value && value.length) {
+            if (check(value)) {
+                this.editor.children = value;
+            }
+            else {
+                this.editor.onError({
+                    code: SlateErrorCode.InvalidValueError,
+                    name: 'initialize invalid data',
+                    data: value
+                });
+                this.editor.children = normalize(value);
+            }
+            this.initializeContext();
+            this.cdr.markForCheck();
+        }
+    }
+    initialize() {
+        this.initialized = true;
+        const window = AngularEditor.getWindow(this.editor);
+        this.addEventListener('selectionchange', event => {
+            this.toSlateSelection();
+        }, window.document);
+        if (HAS_BEFORE_INPUT_SUPPORT) {
+            this.addEventListener('beforeinput', this.onDOMBeforeInput.bind(this));
+        }
+        this.addEventListener('blur', this.onDOMBlur.bind(this));
+        this.addEventListener('click', this.onDOMClick.bind(this));
+        this.addEventListener('compositionend', this.onDOMCompositionEnd.bind(this));
+        this.addEventListener('compositionupdate', this.onDOMCompositionUpdate.bind(this));
+        this.addEventListener('compositionstart', this.onDOMCompositionStart.bind(this));
+        this.addEventListener('copy', this.onDOMCopy.bind(this));
+        this.addEventListener('cut', this.onDOMCut.bind(this));
+        this.addEventListener('dragover', this.onDOMDragOver.bind(this));
+        this.addEventListener('dragstart', this.onDOMDragStart.bind(this));
+        this.addEventListener('dragend', this.onDOMDragEnd.bind(this));
+        this.addEventListener('drop', this.onDOMDrop.bind(this));
+        this.addEventListener('focus', this.onDOMFocus.bind(this));
+        this.addEventListener('keydown', this.onDOMKeydown.bind(this));
+        this.addEventListener('paste', this.onDOMPaste.bind(this));
+        BEFORE_INPUT_EVENTS.forEach(event => {
+            this.addEventListener(event.name, () => { });
+        });
+    }
+    toNativeSelection() {
+        try {
+            const { selection } = this.editor;
+            const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
+            const { activeElement } = root;
+            const domSelection = root.getSelection();
+            if ((this.isComposing && !IS_ANDROID) || !domSelection || !AngularEditor.isFocused(this.editor)) {
+                return;
+            }
+            const hasDomSelection = domSelection.type !== 'None';
+            // If the DOM selection is properly unset, we're done.
+            if (!selection && !hasDomSelection) {
+                return;
+            }
+            // If the DOM selection is already correct, we're done.
+            // verify that the dom selection is in the editor
+            const editorElement = EDITOR_TO_ELEMENT.get(this.editor);
+            let hasDomSelectionInEditor = false;
+            if (editorElement.contains(domSelection.anchorNode) && editorElement.contains(domSelection.focusNode)) {
+                hasDomSelectionInEditor = true;
+            }
+            // If the DOM selection is in the editor and the editor selection is already correct, we're done.
+            if (hasDomSelection &&
+                hasDomSelectionInEditor &&
+                selection &&
+                hasStringTarget(domSelection) &&
+                Range.equals(AngularEditor.toSlateRange(this.editor, domSelection), selection)) {
+                return;
+            }
+            // prevent updating native selection when active element is void element
+            if (isTargetInsideVoid(this.editor, activeElement)) {
+                return;
+            }
+            // when <Editable/> is being controlled through external value
+            // then its children might just change - DOM responds to it on its own
+            // 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);
+                return;
+            }
+            // Otherwise the DOM selection is out of sync, so update it.
+            const el = AngularEditor.toDOMNode(this.editor, this.editor);
+            this.isUpdatingSelection = true;
+            const newDomRange = selection && AngularEditor.toDOMRange(this.editor, selection);
+            if (newDomRange) {
+                // COMPAT: Since the DOM range has no concept of backwards/forwards
+                // we need to check and do the right thing here.
+                if (Range.isBackward(selection)) {
+                    // eslint-disable-next-line max-len
+                    domSelection.setBaseAndExtent(newDomRange.endContainer, newDomRange.endOffset, newDomRange.startContainer, newDomRange.startOffset);
+                }
+                else {
+                    // eslint-disable-next-line max-len
+                    domSelection.setBaseAndExtent(newDomRange.startContainer, newDomRange.startOffset, newDomRange.endContainer, newDomRange.endOffset);
+                }
+            }
+            else {
+                domSelection.removeAllRanges();
+            }
+            newDomRange && this.scrollSelectionIntoView(this.editor, newDomRange);
+            setTimeout(() => {
+                // COMPAT: In Firefox, it's not enough to create a range, you also need
+                // to focus the contenteditable element too. (2016/11/16)
+                if (newDomRange && IS_FIREFOX) {
+                    el.focus();
+                }
+                this.isUpdatingSelection = false;
+            });
+        }
+        catch (error) {
+            this.editor.onError({
+                code: SlateErrorCode.ToNativeSelectionError,
+                nativeError: error
+            });
+            this.isUpdatingSelection = false;
+        }
+    }
+    onChange() {
+        this.forceFlush();
+        this.onChangeCallback(this.editor.children);
+    }
+    ngAfterViewChecked() { }
+    ngDoCheck() { }
+    forceFlush() {
+        this.detectContext();
+        this.cdr.detectChanges();
+        // repair collaborative editing when Chinese input is interrupted by other users' cursors
+        // when the DOMElement where the selection is located is removed
+        // the compositionupdate and compositionend events will no longer be fired
+        // so isComposing needs to be corrected
+        // need exec after this.cdr.detectChanges() to render HTML
+        // need exec before this.toNativeSelection() to correct native selection
+        if (this.isComposing) {
+            // Composition input text be not rendered when user composition input with selection is expanded
+            // At this time, the following matching conditions are met, assign isComposing to false, and the status is wrong
+            // this time condition is true and isComposiing is assigned false
+            // Therefore, need to wait for the composition input text to be rendered before performing condition matching
+            setTimeout(() => {
+                const textNode = Node.get(this.editor, this.editor.selection.anchor.path);
+                const textDOMNode = AngularEditor.toDOMNode(this.editor, textNode);
+                let textContent = '';
+                // skip decorate text
+                textDOMNode.querySelectorAll('[editable-text]').forEach(stringDOMNode => {
+                    let text = stringDOMNode.textContent;
+                    const zeroChar = '\uFEFF';
+                    // remove zero with char
+                    if (text.startsWith(zeroChar)) {
+                        text = text.slice(1);
+                    }
+                    if (text.endsWith(zeroChar)) {
+                        text = text.slice(0, text.length - 1);
+                    }
+                    textContent += text;
+                });
+                if (Node.string(textNode).endsWith(textContent)) {
+                    this.isComposing = false;
+                }
+            }, 0);
+        }
+        this.toNativeSelection();
+    }
+    initializeContext() {
+        this.context = {
+            parent: this.editor,
+            selection: this.editor.selection,
+            decorations: this.generateDecorations(),
+            decorate: this.decorate,
+            readonly: this.readonly
+        };
+    }
+    initializeViewContext() {
+        this.viewContext = {
+            editor: this.editor,
+            renderElement: this.renderElement,
+            renderLeaf: this.renderLeaf,
+            renderText: this.renderText,
+            trackBy: this.trackBy,
+            isStrictDecorate: this.isStrictDecorate,
+            templateComponent: this.templateComponent
+        };
+    }
+    detectContext() {
+        const decorations = this.generateDecorations();
+        if (this.context.selection !== this.editor.selection ||
+            this.context.decorate !== this.decorate ||
+            this.context.readonly !== this.readonly ||
+            !isDecoratorRangeListEqual(this.context.decorations, decorations)) {
+            this.context = {
+                parent: this.editor,
+                selection: this.editor.selection,
+                decorations: decorations,
+                decorate: this.decorate,
+                readonly: this.readonly
+            };
+        }
+    }
+    composePlaceholderDecorate(editor) {
+        if (this.placeholderDecorate) {
+            return this.placeholderDecorate(editor) || [];
+        }
+        if (this.placeholder && editor.children.length === 1 && Array.from(Node.texts(editor)).length === 1 && Node.string(editor) === '') {
+            const start = Editor.start(editor, []);
+            return [
+                {
+                    placeholder: this.placeholder,
+                    anchor: start,
+                    focus: start
+                }
+            ];
+        }
+        else {
+            return [];
+        }
+    }
+    generateDecorations() {
+        const decorations = this.decorate([this.editor, []]);
+        const placeholderDecorations = this.isComposing ? [] : this.composePlaceholderDecorate(this.editor);
+        decorations.push(...placeholderDecorations);
+        return decorations;
+    }
+    //#region event proxy
+    addEventListener(eventName, listener, target = this.elementRef.nativeElement) {
+        this.manualListeners.push(this.renderer2.listen(target, eventName, (event) => {
+            const beforeInputEvent = extractBeforeInputEvent(event.type, null, event, event.target);
+            if (beforeInputEvent) {
+                this.onFallbackBeforeInput(beforeInputEvent);
+            }
+            listener(event);
+        }));
+    }
+    toSlateSelection() {
+        if ((!this.isComposing || IS_ANDROID) && !this.isUpdatingSelection && !this.isDraggingInternally) {
+            try {
+                const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
+                const { activeElement } = root;
+                const el = AngularEditor.toDOMNode(this.editor, this.editor);
+                const domSelection = root.getSelection();
+                if (activeElement === el) {
+                    this.latestElement = activeElement;
+                    IS_FOCUSED.set(this.editor, true);
+                }
+                else {
+                    IS_FOCUSED.delete(this.editor);
+                }
+                if (!domSelection) {
+                    return Transforms.deselect(this.editor);
+                }
+                const editorElement = EDITOR_TO_ELEMENT.get(this.editor);
+                const hasDomSelectionInEditor = editorElement.contains(domSelection.anchorNode) && editorElement.contains(domSelection.focusNode);
+                if (!hasDomSelectionInEditor) {
+                    Transforms.deselect(this.editor);
+                    return;
+                }
+                // try to get the selection directly, because some terrible case can be normalize for normalizeDOMPoint
+                // for example, double-click the last cell of the table to select a non-editable DOM
+                const range = AngularEditor.toSlateRange(this.editor, domSelection);
+                if (this.editor.selection && Range.equals(range, this.editor.selection) && !hasStringTarget(domSelection)) {
+                    if (!isTargetInsideVoid(this.editor, activeElement)) {
+                        // force adjust DOMSelection
+                        this.toNativeSelection();
+                    }
+                }
+                else {
+                    Transforms.select(this.editor, range);
+                }
+            }
+            catch (error) {
+                this.editor.onError({
+                    code: SlateErrorCode.ToSlateSelectionError,
+                    nativeError: error
+                });
+            }
+        }
+    }
+    onDOMBeforeInput(event) {
+        const editor = this.editor;
+        const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
+        const { activeElement } = root;
+        const { selection } = editor;
+        const { inputType: type } = event;
+        const data = event.dataTransfer || event.data || undefined;
+        if (IS_ANDROID) {
+            let targetRange = null;
+            let [nativeTargetRange] = event.getTargetRanges();
+            if (nativeTargetRange) {
+                targetRange = AngularEditor.toSlateRange(editor, nativeTargetRange);
+            }
+            // 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 = targetRange ?? editor.selection;
+            if (type === 'insertCompositionText') {
+                if (data && data.toString().includes('\n')) {
+                    restoreDom(editor, () => {
+                        Editor.insertBreak(editor);
+                    });
+                }
+                else {
+                    if (targetRange) {
+                        if (data) {
+                            restoreDom(editor, () => {
+                                Transforms.insertText(editor, data.toString(), { at: targetRange });
+                            });
+                        }
+                        else {
+                            restoreDom(editor, () => {
+                                Transforms.delete(editor, { at: targetRange });
+                            });
+                        }
+                    }
+                }
+                return;
+            }
+            if (type === 'deleteContentBackward') {
+                // gboard can not prevent default action, so must use restoreDom,
+                // sougou Keyboard can prevent default action（only in Chinese input mode）.
+                // In order to avoid weird action in Sougou Keyboard, use resotreDom only range's isCollapsed is false (recognize gboard)
+                if (!Range.isCollapsed(targetRange)) {
+                    restoreDom(editor, () => {
+                        Transforms.delete(editor, { at: targetRange });
+                    });
+                    return;
+                }
+            }
+            if (type === 'insertText') {
+                restoreDom(editor, () => {
+                    if (typeof data === 'string') {
+                        Editor.insertText(editor, data);
+                    }
+                });
+                return;
+            }
+        }
+        if (!this.readonly &&
+            hasEditableTarget(editor, event.target) &&
+            !isTargetInsideVoid(editor, activeElement) &&
+            !this.isDOMEventHandled(event, this.beforeInput)) {
+            try {
+                event.preventDefault();
+                // COMPAT: If the selection is expanded, even if the command seems like
+                // a delete forward/backward command it should delete the selection.
+                if (selection && Range.isExpanded(selection) && type.startsWith('delete')) {
+                    const direction = type.endsWith('Backward') ? 'backward' : 'forward';
+                    Editor.deleteFragment(editor, { direction });
+                    return;
+                }
+                switch (type) {
+                    case 'deleteByComposition':
+                    case 'deleteByCut':
+                    case 'deleteByDrag': {
+                        Editor.deleteFragment(editor);
+                        break;
+                    }
+                    case 'deleteContent':
+                    case 'deleteContentForward': {
+                        Editor.deleteForward(editor);
+                        break;
+                    }
+                    case 'deleteContentBackward': {
+                        Editor.deleteBackward(editor);
+                        break;
+                    }
+                    case 'deleteEntireSoftLine': {
+                        Editor.deleteBackward(editor, { unit: 'line' });
+                        Editor.deleteForward(editor, { unit: 'line' });
+                        break;
+                    }
+                    case 'deleteHardLineBackward': {
+                        Editor.deleteBackward(editor, { unit: 'block' });
+                        break;
+                    }
+                    case 'deleteSoftLineBackward': {
+                        Editor.deleteBackward(editor, { unit: 'line' });
+                        break;
+                    }
+                    case 'deleteHardLineForward': {
+                        Editor.deleteForward(editor, { unit: 'block' });
+                        break;
+                    }
+                    case 'deleteSoftLineForward': {
+                        Editor.deleteForward(editor, { unit: 'line' });
+                        break;
+                    }
+                    case 'deleteWordBackward': {
+                        Editor.deleteBackward(editor, { unit: 'word' });
+                        break;
+                    }
+                    case 'deleteWordForward': {
+                        Editor.deleteForward(editor, { unit: 'word' });
+                        break;
+                    }
+                    case 'insertLineBreak':
+                    case 'insertParagraph': {
+                        Editor.insertBreak(editor);
+                        break;
+                    }
+                    case 'insertFromComposition': {
+                        // COMPAT: in safari, `compositionend` event is dispatched after
+                        // the beforeinput event with the inputType "insertFromComposition" has been dispatched.
+                        // https://www.w3.org/TR/input-events-2/
+                        // so the following code is the right logic
+                        // because DOM selection in sync will be exec before `compositionend` event
+                        // isComposing is true will prevent DOM selection being update correctly.
+                        this.isComposing = false;
+                        preventInsertFromComposition(event, this.editor);
+                    }
+                    case 'insertFromDrop':
+                    case 'insertFromPaste':
+                    case 'insertFromYank':
+                    case 'insertReplacementText':
+                    case 'insertText': {
+                        // use a weak comparison instead of 'instanceof' to allow
+                        // programmatic access of paste events coming from external windows
+                        // like cypress where cy.window does not work realibly
+                        if (data?.constructor.name === 'DataTransfer') {
+                            AngularEditor.insertData(editor, data);
+                        }
+                        else if (typeof data === 'string') {
+                            Editor.insertText(editor, data);
+                        }
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                this.editor.onError({
+                    code: SlateErrorCode.OnDOMBeforeInputError,
+                    nativeError: error
+                });
+            }
+        }
+    }
+    onDOMBlur(event) {
+        if (this.readonly ||
+            this.isUpdatingSelection ||
+            !hasEditableTarget(this.editor, event.target) ||
+            this.isDOMEventHandled(event, this.blur)) {
+            return;
+        }
+        const window = AngularEditor.getWindow(this.editor);
+        // COMPAT: If the current `activeElement` is still the previous
+        // one, this is due to the window being blurred when the tab
+        // itself becomes unfocused, so we want to abort early to allow to
+        // editor to stay focused when the tab becomes focused again.
+        const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
+        if (this.latestElement === root.activeElement) {
+            return;
+        }
+        const { relatedTarget } = event;
+        const el = AngularEditor.toDOMNode(this.editor, this.editor);
+        // COMPAT: The event should be ignored if the focus is returning
+        // to the editor from an embedded editable element (eg. an <input>
+        // element inside a void node).
+        if (relatedTarget === el) {
+            return;
+        }
+        // COMPAT: The event should be ignored if the focus is moving from
+        // the editor to inside a void node's spacer element.
+        if (isDOMElement(relatedTarget) && relatedTarget.hasAttribute('data-slate-spacer')) {
+            return;
+        }
+        // COMPAT: The event should be ignored if the focus is moving to a
+        // non- editable section of an element that isn't a void node (eg.
+        // a list item of the check list example).
+        if (relatedTarget != null && isDOMNode(relatedTarget) && AngularEditor.hasDOMNode(this.editor, relatedTarget)) {
+            const node = AngularEditor.toSlateNode(this.editor, relatedTarget);
+            if (Element.isElement(node) && !this.editor.isVoid(node)) {
+                return;
+            }
+        }
+        IS_FOCUSED.delete(this.editor);
+    }
+    onDOMClick(event) {
+        if (!this.readonly &&
+            hasTarget(this.editor, event.target) &&
+            !this.isDOMEventHandled(event, this.click) &&
+            isDOMNode(event.target)) {
+            const node = AngularEditor.toSlateNode(this.editor, event.target);
+            const path = AngularEditor.findPath(this.editor, node);
+            const start = Editor.start(this.editor, path);
+            const end = Editor.end(this.editor, path);
+            const startVoid = Editor.void(this.editor, { at: start });
+            const endVoid = Editor.void(this.editor, { at: end });
+            if (startVoid && endVoid && Path.equals(startVoid[1], endVoid[1])) {
+                const range = Editor.range(this.editor, start);
+                Transforms.select(this.editor, range);
+            }
+        }
+    }
+    onDOMCompositionStart(event) {
+        const { selection } = this.editor;
+        if (selection) {
+            // solve the problem of cross node Chinese input
+            if (Range.isExpanded(selection)) {
+                Editor.deleteFragment(this.editor);
+                this.forceFlush();
+            }
+        }
+        if (hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionStart)) {
+            this.isComposing = true;
+        }
+        this.detectContext();
+        this.cdr.detectChanges();
+    }
+    onDOMCompositionUpdate(event) {
+        this.isDOMEventHandled(event, this.compositionUpdate);
+    }
+    onDOMCompositionEnd(event) {
+        if (!event.data && !Range.isCollapsed(this.editor.selection)) {
+            Transforms.delete(this.editor);
+        }
+        if (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
+            // ends since it will already have been committed to the DOM.
+            if (this.isComposing === true && !IS_SAFARI && !IS_ANDROID && event.data) {
+                preventInsertFromComposition(event, this.editor);
+                Editor.insertText(this.editor, event.data);
+            }
+            // COMPAT: In Firefox 87.0 CompositionEnd fire twice
+            // so we need avoid repeat isnertText by isComposing === true,
+            this.isComposing = false;
+        }
+        this.detectContext();
+        this.cdr.detectChanges();
+    }
+    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)) {
+            event.preventDefault();
+            AngularEditor.setFragmentData(this.editor, event.clipboardData, 'copy');
+        }
+    }
+    onDOMCut(event) {
+        if (!this.readonly && hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.cut)) {
+            event.preventDefault();
+            AngularEditor.setFragmentData(this.editor, event.clipboardData, 'cut');
+            const { selection } = this.editor;
+            if (selection) {
+                AngularEditor.deleteCutData(this.editor);
+            }
+        }
+    }
+    onDOMDragOver(event) {
+        if (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.
+            const node = AngularEditor.toSlateNode(this.editor, event.target);
+            if (Editor.isVoid(this.editor, node)) {
+                event.preventDefault();
+            }
+        }
+    }
+    onDOMDragStart(event) {
+        if (!this.readonly && 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 = Editor.isVoid(this.editor, node) || Editor.void(this.editor, { at: path, voids: true });
+            // If starting a drag on a void node, make sure it is selected
+            // so that it shows up in the selection's fragment.
+            if (voidMatch) {
+                const range = Editor.range(this.editor, path);
+                Transforms.select(this.editor, range);
+            }
+            this.isDraggingInternally = true;
+            AngularEditor.setFragmentData(this.editor, event.dataTransfer, 'drag');
+        }
+    }
+    onDOMDrop(event) {
+        const editor = this.editor;
+        if (!this.readonly && 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;
+            // Find the range where the drop happened
+            const range = AngularEditor.findEventRange(editor, event);
+            const data = event.dataTransfer;
+            Transforms.select(editor, range);
+            if (this.isDraggingInternally) {
+                if (draggedRange) {
+                    Transforms.delete(editor, {
+                        at: draggedRange
+                    });
+                }
+                this.isDraggingInternally = false;
+            }
+            AngularEditor.insertData(editor, data);
+            // When dragging from another source into the editor, it's possible
+            // that the current editor does not have focus.
+            if (!AngularEditor.isFocused(editor)) {
+                AngularEditor.focus(editor);
+            }
+        }
+    }
+    onDOMDragEnd(event) {
+        if (!this.readonly &&
+            this.isDraggingInternally &&
+            hasTarget(this.editor, event.target) &&
+            !this.isDOMEventHandled(event, this.dragEnd)) {
+            this.isDraggingInternally = false;
+        }
+    }
+    onDOMFocus(event) {
+        if (!this.readonly &&
+            !this.isUpdatingSelection &&
+            hasEditableTarget(this.editor, event.target) &&
+            !this.isDOMEventHandled(event, this.focus)) {
+            const el = AngularEditor.toDOMNode(this.editor, this.editor);
+            const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
+            this.latestElement = root.activeElement;
+            // COMPAT: If the editor has nested editable elements, the focus
+            // can go to them. In Firefox, this must be prevented because it
+            // results in issues with keyboard navigation. (2017/03/30)
+            if (IS_FIREFOX && event.target !== el) {
+                el.focus();
+                return;
+            }
+            IS_FOCUSED.set(this.editor, true);
+        }
+    }
+    onDOMKeydown(event) {
+        const editor = this.editor;
+        const root = AngularEditor.findDocumentOrShadowRoot(this.editor);
+        const { activeElement } = root;
+        if (!this.readonly &&
+            hasEditableTarget(editor, event.target) &&
+            !isTargetInsideVoid(editor, activeElement) && // stop fire keydown handle when focus void node
+            !this.isComposing &&
+            !this.isDOMEventHandled(event, this.keydown)) {
+            const nativeEvent = event;
+            const { selection } = editor;
+            const element = editor.children[selection !== null ? selection.focus.path[0] : 0];
+            const isRTL = direction(Node.string(element)) === 'rtl';
+            try {
+                // COMPAT: Since we prevent the default behavior on
+                // `beforeinput` events, the browser doesn't think there's ever
+                // any history stack to undo or redo, so we have to manage these
+                // hotkeys ourselves. (2019/11/06)
+                if (Hotkeys.isRedo(nativeEvent)) {
+                    event.preventDefault();
+                    if (HistoryEditor.isHistoryEditor(editor)) {
+                        editor.redo();
+                    }
+                    return;
+                }
+                if (Hotkeys.isUndo(nativeEvent)) {
+                    event.preventDefault();
+                    if (HistoryEditor.isHistoryEditor(editor)) {
+                        editor.undo();
+                    }
+                    return;
+                }
+                // COMPAT: Certain browsers don't handle the selection updates
+                // properly. In Chrome, the selection isn't properly extended.
+                // And in Firefox, the selection isn't properly collapsed.
+                // (2017/10/17)
+                if (Hotkeys.isMoveLineBackward(nativeEvent)) {
+                    event.preventDefault();
+                    Transforms.move(editor, { unit: 'line', reverse: true });
+                    return;
+                }
+                if (Hotkeys.isMoveLineForward(nativeEvent)) {
+                    event.preventDefault();
+                    Transforms.move(editor, { unit: 'line' });
+                    return;
+                }
+                if (Hotkeys.isExtendLineBackward(nativeEvent)) {
+                    event.preventDefault();
+                    Transforms.move(editor, {
+                        unit: 'line',
+                        edge: 'focus',
+                        reverse: true
+                    });
+                    return;
+                }
+                if (Hotkeys.isExtendLineForward(nativeEvent)) {
+                    event.preventDefault();
+                    Transforms.move(editor, { unit: 'line', edge: 'focus' });
+                    return;
+                }
+                // COMPAT: If a void node is selected, or a zero-width text node
+                // adjacent to an inline is selected, we need to handle these
+                // hotkeys manually because browsers won't be able to skip over
+                // the void node with the zero-width space not being an empty
+                // string.
+                if (Hotkeys.isMoveBackward(nativeEvent)) {
+                    event.preventDefault();
+                    if (selection && Range.isCollapsed(selection)) {
+                        Transforms.move(editor, { reverse: !isRTL });
+                    }
+                    else {
+                        Transforms.collapse(editor, { edge: 'start' });
+                    }
+                    return;
+                }
+                if (Hotkeys.isMoveForward(nativeEvent)) {
+                    event.preventDefault();
+                    if (selection && Range.isCollapsed(selection)) {
+                        Transforms.move(editor, { reverse: isRTL });
+                    }
+                    else {
+                        Transforms.collapse(editor, { edge: 'end' });
+                    }
+                    return;
+                }
+                if (Hotkeys.isMoveWordBackward(nativeEvent)) {
+                    event.preventDefault();
+                    if (selection && Range.isExpanded(selection)) {
+                        Transforms.collapse(editor, { edge: 'focus' });
+                    }
+                    Transforms.move(editor, { unit: 'word', reverse: !isRTL });
+                    return;
+                }
+                if (Hotkeys.isMoveWordForward(nativeEvent)) {
+                    event.preventDefault();
+                    if (selection && Range.isExpanded(selection)) {
+                        Transforms.collapse(editor, { edge: 'focus' });
+                    }
+                    Transforms.move(editor, { unit: 'word', reverse: isRTL });
+                    return;
+                }
+                // COMPAT: Certain browsers don't support the `beforeinput` event, so we
+                // fall back to guessing at the input intention for hotkeys.
+                // COMPAT: In iOS, some of these hotkeys are handled in the
+                if (!HAS_BEFORE_INPUT_SUPPORT) {
+                    // We don't have a core behavior for these, but they change the
+                    // DOM if we don't prevent them, so we have to.
+                    if (Hotkeys.isBold(nativeEvent) || Hotkeys.isItalic(nativeEvent) || Hotkeys.isTransposeCharacter(nativeEvent)) {
+                        event.preventDefault();
+                        return;
+                    }
+                    if (Hotkeys.isSplitBlock(nativeEvent)) {
+                        event.preventDefault();
+                        Editor.insertBreak(editor);
+                        return;
+                    }
+                    if (Hotkeys.isDeleteBackward(nativeEvent)) {
+                        event.preventDefault();
+                        if (selection && Range.isExpanded(selection)) {
+                            Editor.deleteFragment(editor, {
+                                direction: 'backward'
+                            });
+                        }
+                        else {
+                            Editor.deleteBackward(editor);
+                        }
+                        return;
+                    }
+                    if (Hotkeys.isDeleteForward(nativeEvent)) {
+                        event.preventDefault();
+                        if (selection && Range.isExpanded(selection)) {
+                            Editor.deleteFragment(editor, {
+                                direction: 'forward'
+                            });
+                        }
+                        else {
+                            Editor.deleteForward(editor);
+                        }
+                        return;
+                    }
+                    if (Hotkeys.isDeleteLineBackward(nativeEvent)) {
+                        event.preventDefault();
+                        if (selection && Range.isExpanded(selection)) {
+                            Editor.deleteFragment(editor, {
+                                direction: 'backward'
+                            });
+                        }
+                        else {
+                            Editor.deleteBackward(editor, { unit: 'line' });
+                        }
+                        return;
+                    }
+                    if (Hotkeys.isDeleteLineForward(nativeEvent)) {
+                        event.preventDefault();
+                        if (selection && Range.isExpanded(selection)) {
+                            Editor.deleteFragment(editor, {
+                                direction: 'forward'
+                            });
+                        }
+                        else {
+                            Editor.deleteForward(editor, { unit: 'line' });
+                        }
+                        return;
+                    }
+                    if (Hotkeys.isDeleteWordBackward(nativeEvent)) {
+                        event.preventDefault();
+                        if (selection && Range.isExpanded(selection)) {
+                            Editor.deleteFragment(editor, {
+                                direction: 'backward'
+                            });
+                        }
+                        else {
+                            Editor.deleteBackward(editor, { unit: 'word' });
+                        }
+                        return;
+                    }
+                    if (Hotkeys.isDeleteWordForward(nativeEvent)) {
+                        event.preventDefault();
+                        if (selection && Range.isExpanded(selection)) {
+                            Editor.deleteFragment(editor, {
+                                direction: 'forward'
+                            });
+                        }
+                        else {
+                            Editor.deleteForward(editor, { unit: 'word' });
+                        }
+                        return;
+                    }
+                }
+                else {
+                    if (IS_CHROME || IS_SAFARI) {
+                        // COMPAT: Chrome and Safari support `beforeinput` event but do not fire
+                        // an event when deleting backwards in a selected void inline node
+                        if (selection &&
+                            (Hotkeys.isDeleteBackward(nativeEvent) || Hotkeys.isDeleteForward(nativeEvent)) &&
+                            Range.isCollapsed(selection)) {
+                            const currentNode = Node.parent(editor, selection.anchor.path);
+                            if (Element.isElement(currentNode) &&
+                                Editor.isVoid(editor, currentNode) &&
+                                Editor.isInline(editor, currentNode)) {
+                                event.preventDefault();
+                                Editor.deleteBackward(editor, {
+                                    unit: 'block'
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.editor.onError({
+                    code: SlateErrorCode.OnDOMKeydownError,
+                    nativeError: error
+                });
+            }
+        }
+    }
+    onDOMPaste(event) {
+        // COMPAT: Certain browsers don't support the `beforeinput` event, so we
+        // fall back to React's `onPaste` here instead.
+        // COMPAT: Firefox, Chrome and Safari are not emitting `beforeinput` events
+        // when "paste without formatting" option is used.
+        // This unfortunately needs to be handled with paste events instead.
+        if (!this.isDOMEventHandled(event, this.paste) &&
+            (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event) || forceOnDOMPaste) &&
+            !this.readonly &&
+            hasEditableTarget(this.editor, event.target)) {
+            event.preventDefault();
+            AngularEditor.insertData(this.editor, event.clipboardData);
+        }
+    }
+    onFallbackBeforeInput(event) {
+        // COMPAT: Certain browsers don't support the `beforeinput` event, so we
+        // fall back to React's leaky polyfill instead just for it. It
+        // only works for the `insertText` input type.
+        if (!HAS_BEFORE_INPUT_SUPPORT &&
+            !this.readonly &&
+            !this.isDOMEventHandled(event.nativeEvent, this.beforeInput) &&
+            hasEditableTarget(this.editor, event.nativeEvent.target)) {
+            event.nativeEvent.preventDefault();
+            try {
+                const text = event.data;
+                if (!Range.isCollapsed(this.editor.selection)) {
+                    Editor.deleteFragment(this.editor);
+                }
+                // just handle Non-IME input
+                if (!this.isComposing) {
+                    Editor.insertText(this.editor, text);
+                }
+            }
+            catch (error) {
+                this.editor.onError({
+                    code: SlateErrorCode.ToNativeSelectionError,
+                    nativeError: error
+                });
+            }
+        }
+    }
+    isDOMEventHandled(event, handler) {
+        if (!handler) {
+            return false;
+        }
+        handler(event);
+        return event.defaultPrevented;
+    }
+    //#endregion
+    ngOnDestroy() {
+        NODE_TO_ELEMENT.delete(this.editor);
+        this.manualListeners.forEach(manualListener => {
+            manualListener();
+        });
+        this.destroy$.complete();
+        EDITOR_TO_ON_CHANGE.delete(this.editor);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateEditable, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: SlateEditable, isStandalone: true, selector: "slate-editable", inputs: { editor: "editor", renderElement: "renderElement", renderLeaf: "renderLeaf", renderText: "renderText", decorate: "decorate", placeholderDecorate: "placeholderDecorate", scrollSelectionIntoView: "scrollSelectionIntoView", isStrictDecorate: "isStrictDecorate", trackBy: "trackBy", readonly: "readonly", placeholder: "placeholder", beforeInput: "beforeInput", blur: "blur", click: "click", compositionEnd: "compositionEnd", compositionUpdate: "compositionUpdate", compositionStart: "compositionStart", copy: "copy", cut: "cut", dragOver: "dragOver", dragStart: "dragStart", dragEnd: "dragEnd", drop: "drop", focus: "focus", keydown: "keydown", paste: "paste", spellCheck: "spellCheck", autoCorrect: "autoCorrect", autoCapitalize: "autoCapitalize" }, host: { properties: { "attr.contenteditable": "readonly ? undefined : true", "attr.role": "readonly ? undefined : 'textbox'", "attr.spellCheck": "!hasBeforeInputSupport ? false : spellCheck", "attr.autoCorrect": "!hasBeforeInputSupport ? 'false' : autoCorrect", "attr.autoCapitalize": "!hasBeforeInputSupport ? 'false' : autoCapitalize", "attr.data-slate-editor": "this.dataSlateEditor", "attr.data-slate-node": "this.dataSlateNode", "attr.data-gramm": "this.dataGramm" }, classAttribute: "slate-editable-container" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => SlateEditable),
+                multi: true
+            }
+        ], viewQueries: [{ propertyName: "templateComponent", first: true, predicate: ["templateComponent"], descendants: true, static: true }, { propertyName: "templateElementRef", first: true, predicate: ["templateComponent"], descendants: true, read: ElementRef, static: true }], usesOnChanges: true, ngImport: i0, template: "<slate-children [children]=\"editor.children\" [context]=\"context\" [viewContext]=\"viewContext\"></slate-children>\n<slate-string-template #templateComponent></slate-string-template>\n", dependencies: [{ kind: "component", type: SlateChildren, selector: "slate-children", inputs: ["children", "context", "viewContext"] }, { kind: "component", type: SlateStringTemplate, selector: "slate-string-template" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: SlateEditable, decorators: [{
+            type: Component,
+            args: [{ selector: 'slate-editable', host: {
+                        class: 'slate-editable-container',
+                        '[attr.contenteditable]': 'readonly ? undefined : true',
+                        '[attr.role]': `readonly ? undefined : 'textbox'`,
+                        '[attr.spellCheck]': `!hasBeforeInputSupport ? false : spellCheck`,
+                        '[attr.autoCorrect]': `!hasBeforeInputSupport ? 'false' : autoCorrect`,
+                        '[attr.autoCapitalize]': `!hasBeforeInputSupport ? 'false' : autoCapitalize`
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => SlateEditable),
+                            multi: true
+                        }
+                    ], standalone: true, imports: [SlateChildren, SlateStringTemplate], template: "<slate-children [children]=\"editor.children\" [context]=\"context\" [viewContext]=\"viewContext\"></slate-children>\n<slate-string-template #templateComponent></slate-string-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { editor: [{
+                type: Input
+            }], renderElement: [{
+                type: Input
+            }], renderLeaf: [{
+                type: Input
+            }], renderText: [{
+                type: Input
+            }], decorate: [{
+                type: Input
+            }], placeholderDecorate: [{
+                type: Input
+            }], scrollSelectionIntoView: [{
+                type: Input
+            }], isStrictDecorate: [{
+                type: Input
+            }], trackBy: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], beforeInput: [{
+                type: Input
+            }], blur: [{
+                type: Input
+            }], click: [{
+                type: Input
+            }], compositionEnd: [{
+                type: Input
+            }], compositionUpdate: [{
+                type: Input
+            }], compositionStart: [{
+                type: Input
+            }], copy: [{
+                type: Input
+            }], cut: [{
+                type: Input
+            }], dragOver: [{
+                type: Input
+            }], dragStart: [{
+                type: Input
+            }], dragEnd: [{
+                type: Input
+            }], drop: [{
+                type: Input
+            }], focus: [{
+                type: Input
+            }], keydown: [{
+                type: Input
+            }], paste: [{
+                type: Input
+            }], spellCheck: [{
+                type: Input
+            }], autoCorrect: [{
+                type: Input
+            }], autoCapitalize: [{
+                type: Input
+            }], dataSlateEditor: [{
+                type: HostBinding,
+                args: ['attr.data-slate-editor']
+            }], dataSlateNode: [{
+                type: HostBinding,
+                args: ['attr.data-slate-node']
+            }], dataGramm: [{
+                type: HostBinding,
+                args: ['attr.data-gramm']
+            }], templateComponent: [{
+                type: ViewChild,
+                args: ['templateComponent', { static: true }]
+            }], templateElementRef: [{
+                type: ViewChild,
+                args: ['templateComponent', { static: true, read: ElementRef }]
+            }] } });
+export const defaultScrollSelectionIntoView = (editor, domRange) => {
+    // This was affecting the selection of multiple blocks and dragging behavior,
+    // so enabled only if the selection has been collapsed.
+    if (domRange.getBoundingClientRect && (!editor.selection || (editor.selection && Range.isCollapsed(editor.selection)))) {
+        const leafEl = domRange.startContainer.parentElement;
+        leafEl.getBoundingClientRect = domRange.getBoundingClientRect.bind(domRange);
+        scrollIntoView(leafEl, {
+            scrollMode: 'if-needed'
+        });
+        delete leafEl.getBoundingClientRect;
+    }
+};
+/**
+ * Check if the target is editable and in the editor.
+ */
+export 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);
+    return Editor.isVoid(editor, slateNode);
+};
+const hasStringTarget = (domSelection) => {
+    return ((domSelection.anchorNode.parentElement.hasAttribute('data-slate-string') ||
+        domSelection.anchorNode.parentElement.hasAttribute('data-slate-zero-width')) &&
+        (domSelection.focusNode.parentElement.hasAttribute('data-slate-string') ||
+            domSelection.focusNode.parentElement.hasAttribute('data-slate-zero-width')));
+};
+/**
+ * remove default insert from composition
+ * @param text
+ */
+const preventInsertFromComposition = (event, editor) => {
+    const types = ['compositionend', 'insertFromComposition'];
+    if (!types.includes(event.type)) {
+        return;
+    }
+    const insertText = event.data;
+    const window = AngularEditor.getWindow(editor);
+    const domSelection = window.getSelection();
+    // ensure text node insert composition input text
+    if (insertText && domSelection.anchorNode instanceof Text && domSelection.anchorNode.textContent.endsWith(insertText)) {
+        const textNode = domSelection.anchorNode;
+        textNode.splitText(textNode.length - insertText.length).remove();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editable.component.js","sourceRoot":"","sources":["../../../../packages/src/components/editable/editable.component.ts","../../../../packages/src/components/editable/editable.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    OnInit,\n    Input,\n    ViewChild,\n    HostBinding,\n    Renderer2,\n    ElementRef,\n    ChangeDetectionStrategy,\n    OnDestroy,\n    ChangeDetectorRef,\n    NgZone,\n    Injector,\n    forwardRef,\n    OnChanges,\n    SimpleChanges,\n    AfterViewChecked,\n    DoCheck\n} from '@angular/core';\nimport {\n    NODE_TO_ELEMENT,\n    IS_FOCUSED,\n    EDITOR_TO_ELEMENT,\n    ELEMENT_TO_NODE,\n    IS_READONLY,\n    EDITOR_TO_ON_CHANGE,\n    EDITOR_TO_WINDOW\n} from '../../utils/weak-maps';\nimport { Text as SlateText, Element, Transforms, Editor, Range, Path, NodeEntry, Node } from 'slate';\nimport { direction } from 'direction';\nimport scrollIntoView from 'scroll-into-view-if-needed';\nimport { AngularEditor } from '../../plugins/angular-editor';\nimport {\n    DOMElement,\n    DOMNode,\n    isDOMNode,\n    DOMStaticRange,\n    DOMRange,\n    isDOMElement,\n    isPlainTextOnlyPaste,\n    DOMSelection,\n    getDefaultView\n} from '../../utils/dom';\nimport { Subject } from 'rxjs';\nimport { IS_FIREFOX, IS_SAFARI, IS_CHROME, HAS_BEFORE_INPUT_SUPPORT, IS_ANDROID } from '../../utils/environment';\nimport Hotkeys from '../../utils/hotkeys';\nimport { BeforeInputEvent, extractBeforeInputEvent } from '../../custom-event/BeforeInputEventPlugin';\nimport { BEFORE_INPUT_EVENTS } from '../../custom-event/before-input-polyfill';\nimport { SlateErrorCode } from '../../types/error';\nimport { SlateStringTemplate } from '../string/template.component';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { SlateChildrenContext, SlateViewContext } from '../../view/context';\nimport { ViewType } from '../../types/view';\nimport { HistoryEditor } from 'slate-history';\nimport { isDecoratorRangeListEqual, check, normalize } from '../../utils';\nimport { SlatePlaceholder } from '../../types/feature';\nimport { restoreDom } from '../../utils/restore-dom';\nimport { SlateChildren } from '../children/children.component';\n\n// not correctly clipboardData on beforeinput\nconst forceOnDOMPaste = IS_SAFARI;\n\n@Component({\n    selector: 'slate-editable',\n    host: {\n        class: 'slate-editable-container',\n        '[attr.contenteditable]': 'readonly ? undefined : true',\n        '[attr.role]': `readonly ? undefined : 'textbox'`,\n        '[attr.spellCheck]': `!hasBeforeInputSupport ? false : spellCheck`,\n        '[attr.autoCorrect]': `!hasBeforeInputSupport ? 'false' : autoCorrect`,\n        '[attr.autoCapitalize]': `!hasBeforeInputSupport ? 'false' : autoCapitalize`\n    },\n    templateUrl: 'editable.component.html',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => SlateEditable),\n            multi: true\n        }\n    ],\n    standalone: true,\n    imports: [SlateChildren, SlateStringTemplate]\n})\nexport class SlateEditable implements OnInit, OnChanges, OnDestroy, AfterViewChecked, DoCheck {\n    viewContext: SlateViewContext;\n    context: SlateChildrenContext;\n\n    private destroy$ = new Subject();\n\n    isComposing = false;\n    isDraggingInternally = false;\n    isUpdatingSelection = false;\n    latestElement = null as DOMElement | null;\n\n    protected manualListeners: (() => void)[] = [];\n\n    private initialized: boolean;\n\n    private onTouchedCallback: () => void = () => {};\n\n    private onChangeCallback: (_: any) => void = () => {};\n\n    @Input() editor: AngularEditor;\n\n    @Input() renderElement: (element: Element) => ViewType | null;\n\n    @Input() renderLeaf: (text: SlateText) => ViewType | null;\n\n    @Input() renderText: (text: SlateText) => ViewType | null;\n\n    @Input() decorate: (entry: NodeEntry) => Range[] = () => [];\n\n    @Input() placeholderDecorate: (editor: Editor) => SlatePlaceholder[];\n\n    @Input() scrollSelectionIntoView: (editor: AngularEditor, domRange: DOMRange) => void = defaultScrollSelectionIntoView;\n\n    @Input() isStrictDecorate: boolean = true;\n\n    @Input() trackBy: (node: Element) => any = () => null;\n\n    @Input() readonly = false;\n\n    @Input() placeholder: string;\n\n    //#region input event handler\n    @Input() beforeInput: (event: Event) => void;\n    @Input() blur: (event: Event) => void;\n    @Input() click: (event: MouseEvent) => void;\n    @Input() compositionEnd: (event: CompositionEvent) => void;\n    @Input() compositionUpdate: (event: CompositionEvent) => void;\n    @Input() compositionStart: (event: CompositionEvent) => void;\n    @Input() copy: (event: ClipboardEvent) => void;\n    @Input() cut: (event: ClipboardEvent) => void;\n    @Input() dragOver: (event: DragEvent) => void;\n    @Input() dragStart: (event: DragEvent) => void;\n    @Input() dragEnd: (event: DragEvent) => void;\n    @Input() drop: (event: DragEvent) => void;\n    @Input() focus: (event: Event) => void;\n    @Input() keydown: (event: KeyboardEvent) => void;\n    @Input() paste: (event: ClipboardEvent) => void;\n    //#endregion\n\n    //#region DOM attr\n    @Input() spellCheck = false;\n    @Input() autoCorrect = false;\n    @Input() autoCapitalize = false;\n\n    @HostBinding('attr.data-slate-editor') dataSlateEditor = true;\n    @HostBinding('attr.data-slate-node') dataSlateNode = 'value';\n    @HostBinding('attr.data-gramm') dataGramm = false;\n\n    get hasBeforeInputSupport() {\n        return HAS_BEFORE_INPUT_SUPPORT;\n    }\n    //#endregion\n\n    @ViewChild('templateComponent', { static: true })\n    templateComponent: SlateStringTemplate;\n\n    @ViewChild('templateComponent', { static: true, read: ElementRef })\n    templateElementRef: ElementRef<any>;\n\n    constructor(\n        public elementRef: ElementRef,\n        public renderer2: Renderer2,\n        public cdr: ChangeDetectorRef,\n        private ngZone: NgZone,\n        private injector: Injector\n    ) {}\n\n    ngOnInit() {\n        this.editor.injector = this.injector;\n        this.editor.children = [];\n        let window = getDefaultView(this.elementRef.nativeElement);\n        EDITOR_TO_WINDOW.set(this.editor, window);\n        EDITOR_TO_ELEMENT.set(this.editor, this.elementRef.nativeElement);\n        NODE_TO_ELEMENT.set(this.editor, this.elementRef.nativeElement);\n        ELEMENT_TO_NODE.set(this.elementRef.nativeElement, this.editor);\n        IS_READONLY.set(this.editor, this.readonly);\n        EDITOR_TO_ON_CHANGE.set(this.editor, () => {\n            this.ngZone.run(() => {\n                this.onChange();\n            });\n        });\n        this.ngZone.runOutsideAngular(() => {\n            this.initialize();\n        });\n        this.initializeViewContext();\n        this.initializeContext();\n\n        // remove unused DOM, just keep templateComponent instance\n        this.templateElementRef.nativeElement.remove();\n\n        // add browser class\n        let browserClass = IS_FIREFOX ? 'firefox' : IS_SAFARI ? 'safari' : '';\n        browserClass && this.elementRef.nativeElement.classList.add(browserClass);\n    }\n\n    ngOnChanges(simpleChanges: SimpleChanges) {\n        if (!this.initialized) {\n            return;\n        }\n        const decorateChange = simpleChanges['decorate'];\n        if (decorateChange) {\n            this.forceFlush();\n        }\n        const placeholderChange = simpleChanges['placeholder'];\n        if (placeholderChange) {\n            this.detectContext();\n        }\n        const readonlyChange = simpleChanges['readonly'];\n        if (readonlyChange) {\n            IS_READONLY.set(this.editor, this.readonly);\n            this.detectContext();\n            this.toSlateSelection();\n        }\n    }\n\n    registerOnChange(fn: any) {\n        this.onChangeCallback = fn;\n    }\n    registerOnTouched(fn: any) {\n        this.onTouchedCallback = fn;\n    }\n\n    writeValue(value: Element[]) {\n        if (value && value.length) {\n            if (check(value)) {\n                this.editor.children = value;\n            } else {\n                this.editor.onError({\n                    code: SlateErrorCode.InvalidValueError,\n                    name: 'initialize invalid data',\n                    data: value\n                });\n                this.editor.children = normalize(value);\n            }\n            this.initializeContext();\n            this.cdr.markForCheck();\n        }\n    }\n\n    initialize() {\n        this.initialized = true;\n        const window = AngularEditor.getWindow(this.editor);\n        this.addEventListener(\n            'selectionchange',\n            event => {\n                this.toSlateSelection();\n            },\n            window.document\n        );\n        if (HAS_BEFORE_INPUT_SUPPORT) {\n            this.addEventListener('beforeinput', this.onDOMBeforeInput.bind(this));\n        }\n        this.addEventListener('blur', this.onDOMBlur.bind(this));\n        this.addEventListener('click', this.onDOMClick.bind(this));\n        this.addEventListener('compositionend', this.onDOMCompositionEnd.bind(this));\n        this.addEventListener('compositionupdate', this.onDOMCompositionUpdate.bind(this));\n        this.addEventListener('compositionstart', this.onDOMCompositionStart.bind(this));\n        this.addEventListener('copy', this.onDOMCopy.bind(this));\n        this.addEventListener('cut', this.onDOMCut.bind(this));\n        this.addEventListener('dragover', this.onDOMDragOver.bind(this));\n        this.addEventListener('dragstart', this.onDOMDragStart.bind(this));\n        this.addEventListener('dragend', this.onDOMDragEnd.bind(this));\n        this.addEventListener('drop', this.onDOMDrop.bind(this));\n        this.addEventListener('focus', this.onDOMFocus.bind(this));\n        this.addEventListener('keydown', this.onDOMKeydown.bind(this));\n        this.addEventListener('paste', this.onDOMPaste.bind(this));\n        BEFORE_INPUT_EVENTS.forEach(event => {\n            this.addEventListener(event.name, () => {});\n        });\n    }\n\n    toNativeSelection() {\n        try {\n            const { selection } = this.editor;\n            const root = AngularEditor.findDocumentOrShadowRoot(this.editor);\n            const { activeElement } = root;\n            const domSelection = (root as Document).getSelection();\n\n            if ((this.isComposing && !IS_ANDROID) || !domSelection || !AngularEditor.isFocused(this.editor)) {\n                return;\n            }\n\n            const hasDomSelection = domSelection.type !== 'None';\n\n            // If the DOM selection is properly unset, we're done.\n            if (!selection && !hasDomSelection) {\n                return;\n            }\n\n            // If the DOM selection is already correct, we're done.\n            // verify that the dom selection is in the editor\n            const editorElement = EDITOR_TO_ELEMENT.get(this.editor)!;\n            let hasDomSelectionInEditor = false;\n            if (editorElement.contains(domSelection.anchorNode) && editorElement.contains(domSelection.focusNode)) {\n                hasDomSelectionInEditor = true;\n            }\n\n            // If the DOM selection is in the editor and the editor selection is already correct, we're done.\n            if (\n                hasDomSelection &&\n                hasDomSelectionInEditor &&\n                selection &&\n                hasStringTarget(domSelection) &&\n                Range.equals(AngularEditor.toSlateRange(this.editor, domSelection), selection)\n            ) {\n                return;\n            }\n\n            // prevent updating native selection when active element is void element\n            if (isTargetInsideVoid(this.editor, activeElement)) {\n                return;\n            }\n\n            // when <Editable/> is being controlled through external value\n            // then its children might just change - DOM responds to it on its own\n            // but Slate's value is not being updated through any operation\n            // and thus it doesn't transform selection on its own\n            if (selection && !AngularEditor.hasRange(this.editor, selection)) {\n                this.editor.selection = AngularEditor.toSlateRange(this.editor, domSelection);\n                return;\n            }\n\n            // Otherwise the DOM selection is out of sync, so update it.\n            const el = AngularEditor.toDOMNode(this.editor, this.editor);\n            this.isUpdatingSelection = true;\n\n            const newDomRange = selection && AngularEditor.toDOMRange(this.editor, selection);\n\n            if (newDomRange) {\n                // COMPAT: Since the DOM range has no concept of backwards/forwards\n                // we need to check and do the right thing here.\n                if (Range.isBackward(selection)) {\n                    // eslint-disable-next-line max-len\n                    domSelection.setBaseAndExtent(\n                        newDomRange.endContainer,\n                        newDomRange.endOffset,\n                        newDomRange.startContainer,\n                        newDomRange.startOffset\n                    );\n                } else {\n                    // eslint-disable-next-line max-len\n                    domSelection.setBaseAndExtent(\n                        newDomRange.startContainer,\n                        newDomRange.startOffset,\n                        newDomRange.endContainer,\n                        newDomRange.endOffset\n                    );\n                }\n            } else {\n                domSelection.removeAllRanges();\n            }\n\n            newDomRange && this.scrollSelectionIntoView(this.editor, newDomRange);\n\n            setTimeout(() => {\n                // COMPAT: In Firefox, it's not enough to create a range, you also need\n                // to focus the contenteditable element too. (2016/11/16)\n                if (newDomRange && IS_FIREFOX) {\n                    el.focus();\n                }\n\n                this.isUpdatingSelection = false;\n            });\n        } catch (error) {\n            this.editor.onError({\n                code: SlateErrorCode.ToNativeSelectionError,\n                nativeError: error\n            });\n            this.isUpdatingSelection = false;\n        }\n    }\n\n    onChange() {\n        this.forceFlush();\n        this.onChangeCallback(this.editor.children);\n    }\n\n    ngAfterViewChecked() {}\n\n    ngDoCheck() {}\n\n    forceFlush() {\n        this.detectContext();\n        this.cdr.detectChanges();\n        // repair collaborative editing when Chinese input is interrupted by other users' cursors\n        // when the DOMElement where the selection is located is removed\n        // the compositionupdate and compositionend events will no longer be fired\n        // so isComposing needs to be corrected\n        // need exec after this.cdr.detectChanges() to render HTML\n        // need exec before this.toNativeSelection() to correct native selection\n        if (this.isComposing) {\n            // Composition input text be not rendered when user composition input with selection is expanded\n            // At this time, the following matching conditions are met, assign isComposing to false, and the status is wrong\n            // this time condition is true and isComposiing is assigned false\n            // Therefore, need to wait for the composition input text to be rendered before performing condition matching\n            setTimeout(() => {\n                const textNode = Node.get(this.editor, this.editor.selection.anchor.path);\n                const textDOMNode = AngularEditor.toDOMNode(this.editor, textNode);\n                let textContent = '';\n                // skip decorate text\n                textDOMNode.querySelectorAll('[editable-text]').forEach(stringDOMNode => {\n                    let text = stringDOMNode.textContent;\n                    const zeroChar = '\\uFEFF';\n                    // remove zero with char\n                    if (text.startsWith(zeroChar)) {\n                        text = text.slice(1);\n                    }\n                    if (text.endsWith(zeroChar)) {\n                        text = text.slice(0, text.length - 1);\n                    }\n                    textContent += text;\n                });\n                if (Node.string(textNode).endsWith(textContent)) {\n                    this.isComposing = false;\n                }\n            }, 0);\n        }\n        this.toNativeSelection();\n    }\n\n    initializeContext() {\n        this.context = {\n            parent: this.editor,\n            selection: this.editor.selection,\n            decorations: this.generateDecorations(),\n            decorate: this.decorate,\n            readonly: this.readonly\n        };\n    }\n\n    initializeViewContext() {\n        this.viewContext = {\n            editor: this.editor,\n            renderElement: this.renderElement,\n            renderLeaf: this.renderLeaf,\n            renderText: this.renderText,\n            trackBy: this.trackBy,\n            isStrictDecorate: this.isStrictDecorate,\n            templateComponent: this.templateComponent\n        };\n    }\n\n    detectContext() {\n        const decorations = this.generateDecorations();\n        if (\n            this.context.selection !== this.editor.selection ||\n            this.context.decorate !== this.decorate ||\n            this.context.readonly !== this.readonly ||\n            !isDecoratorRangeListEqual(this.context.decorations, decorations)\n        ) {\n            this.context = {\n                parent: this.editor,\n                selection: this.editor.selection,\n                decorations: decorations,\n                decorate: this.decorate,\n                readonly: this.readonly\n            };\n        }\n    }\n\n    composePlaceholderDecorate(editor: Editor) {\n        if (this.placeholderDecorate) {\n            return this.placeholderDecorate(editor) || [];\n        }\n\n        if (this.placeholder && editor.children.length === 1 && Array.from(Node.texts(editor)).length === 1 && Node.string(editor) === '') {\n            const start = Editor.start(editor, []);\n            return [\n                {\n                    placeholder: this.placeholder,\n                    anchor: start,\n                    focus: start\n                }\n            ];\n        } else {\n            return [];\n        }\n    }\n\n    generateDecorations() {\n        const decorations = this.decorate([this.editor, []]);\n        const placeholderDecorations = this.isComposing ? [] : this.composePlaceholderDecorate(this.editor);\n        decorations.push(...placeholderDecorations);\n        return decorations;\n    }\n\n    //#region event proxy\n    private addEventListener(eventName: string, listener: EventListener, target: HTMLElement | Document = this.elementRef.nativeElement) {\n        this.manualListeners.push(\n            this.renderer2.listen(target, eventName, (event: Event) => {\n                const beforeInputEvent = extractBeforeInputEvent(event.type, null, event, event.target);\n                if (beforeInputEvent) {\n                    this.onFallbackBeforeInput(beforeInputEvent);\n                }\n                listener(event);\n            })\n        );\n    }\n\n    private toSlateSelection() {\n        if ((!this.isComposing || IS_ANDROID) && !this.isUpdatingSelection && !this.isDraggingInternally) {\n            try {\n                const root = AngularEditor.findDocumentOrShadowRoot(this.editor);\n                const { activeElement } = root;\n                const el = AngularEditor.toDOMNode(this.editor, this.editor);\n                const domSelection = (root as Document).getSelection();\n\n                if (activeElement === el) {\n                    this.latestElement = activeElement;\n                    IS_FOCUSED.set(this.editor, true);\n                } else {\n                    IS_FOCUSED.delete(this.editor);\n                }\n\n                if (!domSelection) {\n                    return Transforms.deselect(this.editor);\n                }\n\n                const editorElement = EDITOR_TO_ELEMENT.get(this.editor);\n                const hasDomSelectionInEditor =\n                    editorElement.contains(domSelection.anchorNode) && editorElement.contains(domSelection.focusNode);\n                if (!hasDomSelectionInEditor) {\n                    Transforms.deselect(this.editor);\n                    return;\n                }\n\n                // try to get the selection directly, because some terrible case can be normalize for normalizeDOMPoint\n                // for example, double-click the last cell of the table to select a non-editable DOM\n                const range = AngularEditor.toSlateRange(this.editor, domSelection);\n                if (this.editor.selection && Range.equals(range, this.editor.selection) && !hasStringTarget(domSelection)) {\n                    if (!isTargetInsideVoid(this.editor, activeElement)) {\n                        // force adjust DOMSelection\n                        this.toNativeSelection();\n                    }\n                } else {\n                    Transforms.select(this.editor, range);\n                }\n            } catch (error) {\n                this.editor.onError({\n                    code: SlateErrorCode.ToSlateSelectionError,\n                    nativeError: error\n                });\n            }\n        }\n    }\n\n    private onDOMBeforeInput(\n        event: Event & {\n            inputType: string;\n            isComposing: boolean;\n            data: string | null;\n            dataTransfer: DataTransfer | null;\n            getTargetRanges(): DOMStaticRange[];\n        }\n    ) {\n        const editor = this.editor;\n        const root = AngularEditor.findDocumentOrShadowRoot(this.editor);\n        const { activeElement } = root;\n        const { selection } = editor;\n        const { inputType: type } = event;\n        const data = event.dataTransfer || event.data || undefined;\n        if (IS_ANDROID) {\n            let targetRange: Range | null = null;\n            let [nativeTargetRange] = event.getTargetRanges();\n            if (nativeTargetRange) {\n                targetRange = AngularEditor.toSlateRange(editor, nativeTargetRange);\n            }\n            // COMPAT: SelectionChange event is fired after the action is performed, so we\n            // have to manually get the selection here to ensure it's up-to-date.\n            const window = AngularEditor.getWindow(editor);\n            const domSelection = window.getSelection();\n            if (!targetRange && domSelection) {\n                targetRange = AngularEditor.toSlateRange(editor, domSelection);\n            }\n            targetRange = targetRange ?? editor.selection;\n            if (type === 'insertCompositionText') {\n                if (data && data.toString().includes('\\n')) {\n                    restoreDom(editor, () => {\n                        Editor.insertBreak(editor);\n                    });\n                } else {\n                    if (targetRange) {\n                        if (data) {\n                            restoreDom(editor, () => {\n                                Transforms.insertText(editor, data.toString(), { at: targetRange });\n                            });\n                        } else {\n                            restoreDom(editor, () => {\n                                Transforms.delete(editor, { at: targetRange });\n                            });\n                        }\n                    }\n                }\n                return;\n            }\n            if (type === 'deleteContentBackward') {\n                // gboard can not prevent default action, so must use restoreDom,\n                // sougou Keyboard can prevent default action（only in Chinese input mode）.\n                // In order to avoid weird action in Sougou Keyboard, use resotreDom only range's isCollapsed is false (recognize gboard)\n                if (!Range.isCollapsed(targetRange)) {\n                    restoreDom(editor, () => {\n                        Transforms.delete(editor, { at: targetRange });\n                    });\n                    return;\n                }\n            }\n            if (type === 'insertText') {\n                restoreDom(editor, () => {\n                    if (typeof data === 'string') {\n                        Editor.insertText(editor, data);\n                    }\n                });\n                return;\n            }\n        }\n        if (\n            !this.readonly &&\n            hasEditableTarget(editor, event.target) &&\n            !isTargetInsideVoid(editor, activeElement) &&\n            !this.isDOMEventHandled(event, this.beforeInput)\n        ) {\n            try {\n                event.preventDefault();\n\n                // COMPAT: If the selection is expanded, even if the command seems like\n                // a delete forward/backward command it should delete the selection.\n                if (selection && Range.isExpanded(selection) && type.startsWith('delete')) {\n                    const direction = type.endsWith('Backward') ? 'backward' : 'forward';\n                    Editor.deleteFragment(editor, { direction });\n                    return;\n                }\n\n                switch (type) {\n                    case 'deleteByComposition':\n                    case 'deleteByCut':\n                    case 'deleteByDrag': {\n                        Editor.deleteFragment(editor);\n                        break;\n                    }\n\n                    case 'deleteContent':\n                    case 'deleteContentForward': {\n                        Editor.deleteForward(editor);\n                        break;\n                    }\n\n                    case 'deleteContentBackward': {\n                        Editor.deleteBackward(editor);\n                        break;\n                    }\n\n                    case 'deleteEntireSoftLine': {\n                        Editor.deleteBackward(editor, { unit: 'line' });\n                        Editor.deleteForward(editor, { unit: 'line' });\n                        break;\n                    }\n\n                    case 'deleteHardLineBackward': {\n                        Editor.deleteBackward(editor, { unit: 'block' });\n                        break;\n                    }\n\n                    case 'deleteSoftLineBackward': {\n                        Editor.deleteBackward(editor, { unit: 'line' });\n                        break;\n                    }\n\n                    case 'deleteHardLineForward': {\n                        Editor.deleteForward(editor, { unit: 'block' });\n                        break;\n                    }\n\n                    case 'deleteSoftLineForward': {\n                        Editor.deleteForward(editor, { unit: 'line' });\n                        break;\n                    }\n\n                    case 'deleteWordBackward': {\n                        Editor.deleteBackward(editor, { unit: 'word' });\n                        break;\n                    }\n\n                    case 'deleteWordForward': {\n                        Editor.deleteForward(editor, { unit: 'word' });\n                        break;\n                    }\n\n                    case 'insertLineBreak':\n                    case 'insertParagraph': {\n                        Editor.insertBreak(editor);\n                        break;\n                    }\n\n                    case 'insertFromComposition': {\n                        // COMPAT: in safari, `compositionend` event is dispatched after\n                        // the beforeinput event with the inputType \"insertFromComposition\" has been dispatched.\n                        // https://www.w3.org/TR/input-events-2/\n                        // so the following code is the right logic\n                        // because DOM selection in sync will be exec before `compositionend` event\n                        // isComposing is true will prevent DOM selection being update correctly.\n                        this.isComposing = false;\n                        preventInsertFromComposition(event, this.editor);\n                    }\n                    case 'insertFromDrop':\n                    case 'insertFromPaste':\n                    case 'insertFromYank':\n                    case 'insertReplacementText':\n                    case 'insertText': {\n                        // use a weak comparison instead of 'instanceof' to allow\n                        // programmatic access of paste events coming from external windows\n                        // like cypress where cy.window does not work realibly\n                        if (data?.constructor.name === 'DataTransfer') {\n                            AngularEditor.insertData(editor, data as DataTransfer);\n                        } else if (typeof data === 'string') {\n                            Editor.insertText(editor, data);\n                        }\n                        break;\n                    }\n                }\n            } catch (error) {\n                this.editor.onError({\n                    code: SlateErrorCode.OnDOMBeforeInputError,\n                    nativeError: error\n                });\n            }\n        }\n    }\n\n    private onDOMBlur(event: FocusEvent) {\n        if (\n            this.readonly ||\n            this.isUpdatingSelection ||\n            !hasEditableTarget(this.editor, event.target) ||\n            this.isDOMEventHandled(event, this.blur)\n        ) {\n            return;\n        }\n\n        const window = AngularEditor.getWindow(this.editor);\n\n        // COMPAT: If the current `activeElement` is still the previous\n        // one, this is due to the window being blurred when the tab\n        // itself becomes unfocused, so we want to abort early to allow to\n        // editor to stay focused when the tab becomes focused again.\n        const root = AngularEditor.findDocumentOrShadowRoot(this.editor);\n        if (this.latestElement === root.activeElement) {\n            return;\n        }\n\n        const { relatedTarget } = event;\n        const el = AngularEditor.toDOMNode(this.editor, this.editor);\n\n        // COMPAT: The event should be ignored if the focus is returning\n        // to the editor from an embedded editable element (eg. an <input>\n        // element inside a void node).\n        if (relatedTarget === el) {\n            return;\n        }\n\n        // COMPAT: The event should be ignored if the focus is moving from\n        // the editor to inside a void node's spacer element.\n        if (isDOMElement(relatedTarget) && relatedTarget.hasAttribute('data-slate-spacer')) {\n            return;\n        }\n\n        // COMPAT: The event should be ignored if the focus is moving to a\n        // non- editable section of an element that isn't a void node (eg.\n        // a list item of the check list example).\n        if (relatedTarget != null && isDOMNode(relatedTarget) && AngularEditor.hasDOMNode(this.editor, relatedTarget)) {\n            const node = AngularEditor.toSlateNode(this.editor, relatedTarget);\n\n            if (Element.isElement(node) && !this.editor.isVoid(node)) {\n                return;\n            }\n        }\n\n        IS_FOCUSED.delete(this.editor);\n    }\n\n    private onDOMClick(event: MouseEvent) {\n        if (\n            !this.readonly &&\n            hasTarget(this.editor, event.target) &&\n            !this.isDOMEventHandled(event, this.click) &&\n            isDOMNode(event.target)\n        ) {\n            const node = AngularEditor.toSlateNode(this.editor, event.target);\n            const path = AngularEditor.findPath(this.editor, node);\n            const start = Editor.start(this.editor, path);\n            const end = Editor.end(this.editor, path);\n\n            const startVoid = Editor.void(this.editor, { at: start });\n            const endVoid = Editor.void(this.editor, { at: end });\n\n            if (startVoid && endVoid && Path.equals(startVoid[1], endVoid[1])) {\n                const range = Editor.range(this.editor, start);\n                Transforms.select(this.editor, range);\n            }\n        }\n    }\n\n    private onDOMCompositionStart(event: CompositionEvent) {\n        const { selection } = this.editor;\n\n        if (selection) {\n            // solve the problem of cross node Chinese input\n            if (Range.isExpanded(selection)) {\n                Editor.deleteFragment(this.editor);\n                this.forceFlush();\n            }\n        }\n        if (hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionStart)) {\n            this.isComposing = true;\n        }\n        this.detectContext();\n        this.cdr.detectChanges();\n    }\n\n    private onDOMCompositionUpdate(event: CompositionEvent) {\n        this.isDOMEventHandled(event, this.compositionUpdate);\n    }\n\n    private onDOMCompositionEnd(event: CompositionEvent) {\n        if (!event.data && !Range.isCollapsed(this.editor.selection)) {\n            Transforms.delete(this.editor);\n        }\n        if (hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.compositionEnd)) {\n            // COMPAT: In Chrome/Firefox, `beforeinput` events for compositions\n            // aren't correct and never fire the \"insertFromComposition\"\n            // type that we need. So instead, insert whenever a composition\n            // ends since it will already have been committed to the DOM.\n            if (this.isComposing === true && !IS_SAFARI && !IS_ANDROID && event.data) {\n                preventInsertFromComposition(event, this.editor);\n                Editor.insertText(this.editor, event.data);\n            }\n\n            // COMPAT: In Firefox 87.0 CompositionEnd fire twice\n            // so we need avoid repeat isnertText by isComposing === true,\n            this.isComposing = false;\n        }\n        this.detectContext();\n        this.cdr.detectChanges();\n    }\n\n    private onDOMCopy(event: ClipboardEvent) {\n        const window = AngularEditor.getWindow(this.editor);\n        const isOutsideSlate = !hasStringTarget(window.getSelection()) && isTargetInsideVoid(this.editor, event.target);\n        if (!isOutsideSlate && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.copy)) {\n            event.preventDefault();\n            AngularEditor.setFragmentData(this.editor, event.clipboardData, 'copy');\n        }\n    }\n\n    private onDOMCut(event: ClipboardEvent) {\n        if (!this.readonly && hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.cut)) {\n            event.preventDefault();\n            AngularEditor.setFragmentData(this.editor, event.clipboardData, 'cut');\n            const { selection } = this.editor;\n\n            if (selection) {\n                AngularEditor.deleteCutData(this.editor);\n            }\n        }\n    }\n\n    private onDOMDragOver(event: DragEvent) {\n        if (hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragOver)) {\n            // Only when the target is void, call `preventDefault` to signal\n            // that drops are allowed. Editable content is droppable by\n            // default, and calling `preventDefault` hides the cursor.\n            const node = AngularEditor.toSlateNode(this.editor, event.target);\n\n            if (Editor.isVoid(this.editor, node)) {\n                event.preventDefault();\n            }\n        }\n    }\n\n    private onDOMDragStart(event: DragEvent) {\n        if (!this.readonly && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragStart)) {\n            const node = AngularEditor.toSlateNode(this.editor, event.target);\n            const path = AngularEditor.findPath(this.editor, node);\n            const voidMatch = Editor.isVoid(this.editor, node) || Editor.void(this.editor, { at: path, voids: true });\n\n            // If starting a drag on a void node, make sure it is selected\n            // so that it shows up in the selection's fragment.\n            if (voidMatch) {\n                const range = Editor.range(this.editor, path);\n                Transforms.select(this.editor, range);\n            }\n\n            this.isDraggingInternally = true;\n\n            AngularEditor.setFragmentData(this.editor, event.dataTransfer, 'drag');\n        }\n    }\n\n    private onDOMDrop(event: DragEvent) {\n        const editor = this.editor;\n        if (!this.readonly && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.drop)) {\n            event.preventDefault();\n            // Keep a reference to the dragged range before updating selection\n            const draggedRange = editor.selection;\n\n            // Find the range where the drop happened\n            const range = AngularEditor.findEventRange(editor, event);\n            const data = event.dataTransfer;\n\n            Transforms.select(editor, range);\n\n            if (this.isDraggingInternally) {\n                if (draggedRange) {\n                    Transforms.delete(editor, {\n                        at: draggedRange\n                    });\n                }\n\n                this.isDraggingInternally = false;\n            }\n\n            AngularEditor.insertData(editor, data);\n\n            // When dragging from another source into the editor, it's possible\n            // that the current editor does not have focus.\n            if (!AngularEditor.isFocused(editor)) {\n                AngularEditor.focus(editor);\n            }\n        }\n    }\n\n    private onDOMDragEnd(event: DragEvent) {\n        if (\n            !this.readonly &&\n            this.isDraggingInternally &&\n            hasTarget(this.editor, event.target) &&\n            !this.isDOMEventHandled(event, this.dragEnd)\n        ) {\n            this.isDraggingInternally = false;\n        }\n    }\n\n    private onDOMFocus(event: Event) {\n        if (\n            !this.readonly &&\n            !this.isUpdatingSelection &&\n            hasEditableTarget(this.editor, event.target) &&\n            !this.isDOMEventHandled(event, this.focus)\n        ) {\n            const el = AngularEditor.toDOMNode(this.editor, this.editor);\n            const root = AngularEditor.findDocumentOrShadowRoot(this.editor);\n            this.latestElement = root.activeElement;\n\n            // COMPAT: If the editor has nested editable elements, the focus\n            // can go to them. In Firefox, this must be prevented because it\n            // results in issues with keyboard navigation. (2017/03/30)\n            if (IS_FIREFOX && event.target !== el) {\n                el.focus();\n                return;\n            }\n\n            IS_FOCUSED.set(this.editor, true);\n        }\n    }\n\n    private onDOMKeydown(event: KeyboardEvent) {\n        const editor = this.editor;\n        const root = AngularEditor.findDocumentOrShadowRoot(this.editor);\n        const { activeElement } = root;\n        if (\n            !this.readonly &&\n            hasEditableTarget(editor, event.target) &&\n            !isTargetInsideVoid(editor, activeElement) && // stop fire keydown handle when focus void node\n            !this.isComposing &&\n            !this.isDOMEventHandled(event, this.keydown)\n        ) {\n            const nativeEvent = event;\n            const { selection } = editor;\n\n            const element = editor.children[selection !== null ? selection.focus.path[0] : 0];\n            const isRTL = direction(Node.string(element)) === 'rtl';\n\n            try {\n                // COMPAT: Since we prevent the default behavior on\n                // `beforeinput` events, the browser doesn't think there's ever\n                // any history stack to undo or redo, so we have to manage these\n                // hotkeys ourselves. (2019/11/06)\n                if (Hotkeys.isRedo(nativeEvent)) {\n                    event.preventDefault();\n\n                    if (HistoryEditor.isHistoryEditor(editor)) {\n                        editor.redo();\n                    }\n\n                    return;\n                }\n\n                if (Hotkeys.isUndo(nativeEvent)) {\n                    event.preventDefault();\n\n                    if (HistoryEditor.isHistoryEditor(editor)) {\n                        editor.undo();\n                    }\n\n                    return;\n                }\n\n                // COMPAT: Certain browsers don't handle the selection updates\n                // properly. In Chrome, the selection isn't properly extended.\n                // And in Firefox, the selection isn't properly collapsed.\n                // (2017/10/17)\n                if (Hotkeys.isMoveLineBackward(nativeEvent)) {\n                    event.preventDefault();\n                    Transforms.move(editor, { unit: 'line', reverse: true });\n                    return;\n                }\n\n                if (Hotkeys.isMoveLineForward(nativeEvent)) {\n                    event.preventDefault();\n                    Transforms.move(editor, { unit: 'line' });\n                    return;\n                }\n\n                if (Hotkeys.isExtendLineBackward(nativeEvent)) {\n                    event.preventDefault();\n                    Transforms.move(editor, {\n                        unit: 'line',\n                        edge: 'focus',\n                        reverse: true\n                    });\n                    return;\n                }\n\n                if (Hotkeys.isExtendLineForward(nativeEvent)) {\n                    event.preventDefault();\n                    Transforms.move(editor, { unit: 'line', edge: 'focus' });\n                    return;\n                }\n\n                // COMPAT: If a void node is selected, or a zero-width text node\n                // adjacent to an inline is selected, we need to handle these\n                // hotkeys manually because browsers won't be able to skip over\n                // the void node with the zero-width space not being an empty\n                // string.\n                if (Hotkeys.isMoveBackward(nativeEvent)) {\n                    event.preventDefault();\n\n                    if (selection && Range.isCollapsed(selection)) {\n                        Transforms.move(editor, { reverse: !isRTL });\n                    } else {\n                        Transforms.collapse(editor, { edge: 'start' });\n                    }\n\n                    return;\n                }\n\n                if (Hotkeys.isMoveForward(nativeEvent)) {\n                    event.preventDefault();\n\n                    if (selection && Range.isCollapsed(selection)) {\n                        Transforms.move(editor, { reverse: isRTL });\n                    } else {\n                        Transforms.collapse(editor, { edge: 'end' });\n                    }\n\n                    return;\n                }\n\n                if (Hotkeys.isMoveWordBackward(nativeEvent)) {\n                    event.preventDefault();\n\n                    if (selection && Range.isExpanded(selection)) {\n                        Transforms.collapse(editor, { edge: 'focus' });\n                    }\n\n                    Transforms.move(editor, { unit: 'word', reverse: !isRTL });\n                    return;\n                }\n\n                if (Hotkeys.isMoveWordForward(nativeEvent)) {\n                    event.preventDefault();\n\n                    if (selection && Range.isExpanded(selection)) {\n                        Transforms.collapse(editor, { edge: 'focus' });\n                    }\n\n                    Transforms.move(editor, { unit: 'word', reverse: isRTL });\n                    return;\n                }\n\n                // COMPAT: Certain browsers don't support the `beforeinput` event, so we\n                // fall back to guessing at the input intention for hotkeys.\n                // COMPAT: In iOS, some of these hotkeys are handled in the\n                if (!HAS_BEFORE_INPUT_SUPPORT) {\n                    // We don't have a core behavior for these, but they change the\n                    // DOM if we don't prevent them, so we have to.\n                    if (Hotkeys.isBold(nativeEvent) || Hotkeys.isItalic(nativeEvent) || Hotkeys.isTransposeCharacter(nativeEvent)) {\n                        event.preventDefault();\n                        return;\n                    }\n\n                    if (Hotkeys.isSplitBlock(nativeEvent)) {\n                        event.preventDefault();\n                        Editor.insertBreak(editor);\n                        return;\n                    }\n\n                    if (Hotkeys.isDeleteBackward(nativeEvent)) {\n                        event.preventDefault();\n\n                        if (selection && Range.isExpanded(selection)) {\n                            Editor.deleteFragment(editor, {\n                                direction: 'backward'\n                            });\n                        } else {\n                            Editor.deleteBackward(editor);\n                        }\n\n                        return;\n                    }\n\n                    if (Hotkeys.isDeleteForward(nativeEvent)) {\n                        event.preventDefault();\n\n                        if (selection && Range.isExpanded(selection)) {\n                            Editor.deleteFragment(editor, {\n                                direction: 'forward'\n                            });\n                        } else {\n                            Editor.deleteForward(editor);\n                        }\n\n                        return;\n                    }\n\n                    if (Hotkeys.isDeleteLineBackward(nativeEvent)) {\n                        event.preventDefault();\n\n                        if (selection && Range.isExpanded(selection)) {\n                            Editor.deleteFragment(editor, {\n                                direction: 'backward'\n                            });\n                        } else {\n                            Editor.deleteBackward(editor, { unit: 'line' });\n                        }\n\n                        return;\n                    }\n\n                    if (Hotkeys.isDeleteLineForward(nativeEvent)) {\n                        event.preventDefault();\n\n                        if (selection && Range.isExpanded(selection)) {\n                            Editor.deleteFragment(editor, {\n                                direction: 'forward'\n                            });\n                        } else {\n                            Editor.deleteForward(editor, { unit: 'line' });\n                        }\n\n                        return;\n                    }\n\n                    if (Hotkeys.isDeleteWordBackward(nativeEvent)) {\n                        event.preventDefault();\n\n                        if (selection && Range.isExpanded(selection)) {\n                            Editor.deleteFragment(editor, {\n                                direction: 'backward'\n                            });\n                        } else {\n                            Editor.deleteBackward(editor, { unit: 'word' });\n                        }\n\n                        return;\n                    }\n\n                    if (Hotkeys.isDeleteWordForward(nativeEvent)) {\n                        event.preventDefault();\n\n                        if (selection && Range.isExpanded(selection)) {\n                            Editor.deleteFragment(editor, {\n                                direction: 'forward'\n                            });\n                        } else {\n                            Editor.deleteForward(editor, { unit: 'word' });\n                        }\n\n                        return;\n                    }\n                } else {\n                    if (IS_CHROME || IS_SAFARI) {\n                        // COMPAT: Chrome and Safari support `beforeinput` event but do not fire\n                        // an event when deleting backwards in a selected void inline node\n                        if (\n                            selection &&\n                            (Hotkeys.isDeleteBackward(nativeEvent) || Hotkeys.isDeleteForward(nativeEvent)) &&\n                            Range.isCollapsed(selection)\n                        ) {\n                            const currentNode = Node.parent(editor, selection.anchor.path);\n                            if (\n                                Element.isElement(currentNode) &&\n                                Editor.isVoid(editor, currentNode) &&\n                                Editor.isInline(editor, currentNode)\n                            ) {\n                                event.preventDefault();\n                                Editor.deleteBackward(editor, {\n                                    unit: 'block'\n                                });\n                                return;\n                            }\n                        }\n                    }\n                }\n            } catch (error) {\n                this.editor.onError({\n                    code: SlateErrorCode.OnDOMKeydownError,\n                    nativeError: error\n                });\n            }\n        }\n    }\n\n    private onDOMPaste(event: ClipboardEvent) {\n        // COMPAT: Certain browsers don't support the `beforeinput` event, so we\n        // fall back to React's `onPaste` here instead.\n        // COMPAT: Firefox, Chrome and Safari are not emitting `beforeinput` events\n        // when \"paste without formatting\" option is used.\n        // This unfortunately needs to be handled with paste events instead.\n        if (\n            !this.isDOMEventHandled(event, this.paste) &&\n            (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event) || forceOnDOMPaste) &&\n            !this.readonly &&\n            hasEditableTarget(this.editor, event.target)\n        ) {\n            event.preventDefault();\n            AngularEditor.insertData(this.editor, event.clipboardData);\n        }\n    }\n\n    private onFallbackBeforeInput(event: BeforeInputEvent) {\n        // COMPAT: Certain browsers don't support the `beforeinput` event, so we\n        // fall back to React's leaky polyfill instead just for it. It\n        // only works for the `insertText` input type.\n        if (\n            !HAS_BEFORE_INPUT_SUPPORT &&\n            !this.readonly &&\n            !this.isDOMEventHandled(event.nativeEvent, this.beforeInput) &&\n            hasEditableTarget(this.editor, event.nativeEvent.target)\n        ) {\n            event.nativeEvent.preventDefault();\n            try {\n                const text = event.data;\n                if (!Range.isCollapsed(this.editor.selection)) {\n                    Editor.deleteFragment(this.editor);\n                }\n                // just handle Non-IME input\n                if (!this.isComposing) {\n                    Editor.insertText(this.editor, text);\n                }\n            } catch (error) {\n                this.editor.onError({\n                    code: SlateErrorCode.ToNativeSelectionError,\n                    nativeError: error\n                });\n            }\n        }\n    }\n\n    private isDOMEventHandled(event: Event, handler?: (event: Event) => void) {\n        if (!handler) {\n            return false;\n        }\n        handler(event);\n        return event.defaultPrevented;\n    }\n    //#endregion\n\n    ngOnDestroy() {\n        NODE_TO_ELEMENT.delete(this.editor);\n        this.manualListeners.forEach(manualListener => {\n            manualListener();\n        });\n        this.destroy$.complete();\n        EDITOR_TO_ON_CHANGE.delete(this.editor);\n    }\n}\n\nexport const defaultScrollSelectionIntoView = (editor: AngularEditor, domRange: DOMRange) => {\n    // This was affecting the selection of multiple blocks and dragging behavior,\n    // so enabled only if the selection has been collapsed.\n    if (domRange.getBoundingClientRect && (!editor.selection || (editor.selection && Range.isCollapsed(editor.selection)))) {\n        const leafEl = domRange.startContainer.parentElement!;\n        leafEl.getBoundingClientRect = domRange.getBoundingClientRect.bind(domRange);\n        scrollIntoView(leafEl, {\n            scrollMode: 'if-needed'\n        });\n        delete leafEl.getBoundingClientRect;\n    }\n};\n\n/**\n * Check if the target is editable and in the editor.\n */\n\nexport const hasEditableTarget = (editor: AngularEditor, target: EventTarget | null): target is DOMNode => {\n    return isDOMNode(target) && AngularEditor.hasDOMNode(editor, target, { editable: true });\n};\n\n/**\n * Check if two DOM range objects are equal.\n */\nconst isRangeEqual = (a: DOMRange, b: DOMRange) => {\n    return (\n        (a.startContainer === b.startContainer &&\n            a.startOffset === b.startOffset &&\n            a.endContainer === b.endContainer &&\n            a.endOffset === b.endOffset) ||\n        (a.startContainer === b.endContainer &&\n            a.startOffset === b.endOffset &&\n            a.endContainer === b.startContainer &&\n            a.endOffset === b.startOffset)\n    );\n};\n\n/**\n * Check if the target is in the editor.\n */\n\nconst hasTarget = (editor: AngularEditor, target: EventTarget | null): target is DOMNode => {\n    return isDOMNode(target) && AngularEditor.hasDOMNode(editor, target);\n};\n\n/**\n * Check if the target is inside void and in the editor.\n */\n\nconst isTargetInsideVoid = (editor: AngularEditor, target: EventTarget | null): boolean => {\n    const slateNode = hasTarget(editor, target) && AngularEditor.toSlateNode(editor, target);\n    return Editor.isVoid(editor, slateNode);\n};\n\nconst hasStringTarget = (domSelection: DOMSelection) => {\n    return (\n        (domSelection.anchorNode.parentElement.hasAttribute('data-slate-string') ||\n            domSelection.anchorNode.parentElement.hasAttribute('data-slate-zero-width')) &&\n        (domSelection.focusNode.parentElement.hasAttribute('data-slate-string') ||\n            domSelection.focusNode.parentElement.hasAttribute('data-slate-zero-width'))\n    );\n};\n\n/**\n * remove default insert from composition\n * @param text\n */\nconst preventInsertFromComposition = (event: Event, editor: AngularEditor) => {\n    const types = ['compositionend', 'insertFromComposition'];\n    if (!types.includes(event.type)) {\n        return;\n    }\n    const insertText = (event as CompositionEvent).data;\n    const window = AngularEditor.getWindow(editor);\n    const domSelection = window.getSelection();\n    // ensure text node insert composition input text\n    if (insertText && domSelection.anchorNode instanceof Text && domSelection.anchorNode.textContent.endsWith(insertText)) {\n        const textNode = domSelection.anchorNode;\n        textNode.splitText(textNode.length - insertText.length).remove();\n    }\n};\n","<slate-children [children]=\"editor.children\" [context]=\"context\" [viewContext]=\"viewContext\"></slate-children>\n<slate-string-template #templateComponent></slate-string-template>\n"]}