slate-angular 1.9.3 → 13.0.2

package/bundles/slate-angular.umd.js

@@ -1,4298 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('slate'), require('is-hotkey'), require('@angular/core'), require('direction'), require('rxjs'), require('debug'), require('@angular/forms'), require('slate-history'), require('@angular/common')) :
-    typeof define === 'function' && define.amd ? define('slate-angular', ['exports', 'slate', 'is-hotkey', '@angular/core', 'direction', 'rxjs', 'debug', '@angular/forms', 'slate-history', '@angular/common'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["slate-angular"] = {}, global.slate, global.isHotkey, global.ng.core, global.getDirection, global.rxjs, global.Debug, global.ng.forms, global.slateHistory, global.ng.common));
-})(this, (function (exports, slate, isHotkey, i0, getDirection, rxjs, Debug, forms, slateHistory, i2) { 'use strict';
-
-    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-    function _interopNamespace(e) {
-        if (e && e.__esModule) return e;
-        var n = Object.create(null);
-        if (e) {
-            Object.keys(e).forEach(function (k) {
-                if (k !== 'default') {
-                    var d = Object.getOwnPropertyDescriptor(e, k);
-                    Object.defineProperty(n, k, d.get ? d : {
-                        enumerable: true,
-                        get: function () { return e[k]; }
-                    });
-                }
-            });
-        }
-        n["default"] = e;
-        return Object.freeze(n);
-    }
-
-    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
-    var getDirection__default = /*#__PURE__*/_interopDefaultLegacy(getDirection);
-    var Debug__default = /*#__PURE__*/_interopDefaultLegacy(Debug);
-    var i2__namespace = /*#__PURE__*/_interopNamespace(i2);
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b)
-                if (Object.prototype.hasOwnProperty.call(b, p))
-                    d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-    var __assign = function () {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s)
-                    if (Object.prototype.hasOwnProperty.call(s, p))
-                        t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-    function __rest(s, e) {
-        var t = {};
-        for (var p in s)
-            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-                t[p] = s[p];
-        if (s != null && typeof Object.getOwnPropertySymbols === "function")
-            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                    t[p[i]] = s[p[i]];
-            }
-        return t;
-    }
-    function __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-            r = Reflect.decorate(decorators, target, key, desc);
-        else
-            for (var i = decorators.length - 1; i >= 0; i--)
-                if (d = decorators[i])
-                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-    function __param(paramIndex, decorator) {
-        return function (target, key) { decorator(target, key, paramIndex); };
-    }
-    function __metadata(metadataKey, metadataValue) {
-        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-            return Reflect.metadata(metadataKey, metadataValue);
-    }
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try {
-                step(generator.next(value));
-            }
-            catch (e) {
-                reject(e);
-            } }
-            function rejected(value) { try {
-                step(generator["throw"](value));
-            }
-            catch (e) {
-                reject(e);
-            } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function () { if (t[0] & 1)
-                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f)
-                throw new TypeError("Generator is already executing.");
-            while (_)
-                try {
-                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-                        return t;
-                    if (y = 0, t)
-                        op = [op[0] & 2, t.value];
-                    switch (op[0]) {
-                        case 0:
-                        case 1:
-                            t = op;
-                            break;
-                        case 4:
-                            _.label++;
-                            return { value: op[1], done: false };
-                        case 5:
-                            _.label++;
-                            y = op[1];
-                            op = [0];
-                            continue;
-                        case 7:
-                            op = _.ops.pop();
-                            _.trys.pop();
-                            continue;
-                        default:
-                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                                _ = 0;
-                                continue;
-                            }
-                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
-                                _.label = op[1];
-                                break;
-                            }
-                            if (op[0] === 6 && _.label < t[1]) {
-                                _.label = t[1];
-                                t = op;
-                                break;
-                            }
-                            if (t && _.label < t[2]) {
-                                _.label = t[2];
-                                _.ops.push(op);
-                                break;
-                            }
-                            if (t[2])
-                                _.ops.pop();
-                            _.trys.pop();
-                            continue;
-                    }
-                    op = body.call(thisArg, _);
-                }
-                catch (e) {
-                    op = [6, e];
-                    y = 0;
-                }
-                finally {
-                    f = t = 0;
-                }
-            if (op[0] & 5)
-                throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-    var __createBinding = Object.create ? (function (o, m, k, k2) {
-        if (k2 === undefined)
-            k2 = k;
-        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
-    }) : (function (o, m, k, k2) {
-        if (k2 === undefined)
-            k2 = k;
-        o[k2] = m[k];
-    });
-    function __exportStar(m, o) {
-        for (var p in m)
-            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
-                __createBinding(o, m, p);
-    }
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m)
-            return m.call(o);
-        if (o && typeof o.length === "number")
-            return {
-                next: function () {
-                    if (o && i >= o.length)
-                        o = void 0;
-                    return { value: o && o[i++], done: !o };
-                }
-            };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m)
-            return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
-                ar.push(r.value);
-        }
-        catch (error) {
-            e = { error: error };
-        }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"]))
-                    m.call(i);
-            }
-            finally {
-                if (e)
-                    throw e.error;
-            }
-        }
-        return ar;
-    }
-    /** @deprecated */
-    function __spread() {
-        for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read(arguments[i]));
-        return ar;
-    }
-    /** @deprecated */
-    function __spreadArrays() {
-        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
-            s += arguments[i].length;
-        for (var r = Array(s), k = 0, i = 0; i < il; i++)
-            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-                r[k] = a[j];
-        return r;
-    }
-    function __spreadArray(to, from) {
-        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-            to[j] = from[i];
-        return to;
-    }
-    function __await(v) {
-        return this instanceof __await ? (this.v = v, this) : new __await(v);
-    }
-    function __asyncGenerator(thisArg, _arguments, generator) {
-        if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-        var g = generator.apply(thisArg, _arguments || []), i, q = [];
-        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-        function verb(n) { if (g[n])
-            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-        function resume(n, v) { try {
-            step(g[n](v));
-        }
-        catch (e) {
-            settle(q[0][3], e);
-        } }
-        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-        function fulfill(value) { resume("next", value); }
-        function reject(value) { resume("throw", value); }
-        function settle(f, v) { if (f(v), q.shift(), q.length)
-            resume(q[0][0], q[0][1]); }
-    }
-    function __asyncDelegator(o) {
-        var i, p;
-        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-    }
-    function __asyncValues(o) {
-        if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-        var m = o[Symbol.asyncIterator], i;
-        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
-    }
-    function __makeTemplateObject(cooked, raw) {
-        if (Object.defineProperty) {
-            Object.defineProperty(cooked, "raw", { value: raw });
-        }
-        else {
-            cooked.raw = raw;
-        }
-        return cooked;
-    }
-    ;
-    var __setModuleDefault = Object.create ? (function (o, v) {
-        Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function (o, v) {
-        o["default"] = v;
-    };
-    function __importStar(mod) {
-        if (mod && mod.__esModule)
-            return mod;
-        var result = {};
-        if (mod != null)
-            for (var k in mod)
-                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-                    __createBinding(result, mod, k);
-        __setModuleDefault(result, mod);
-        return result;
-    }
-    function __importDefault(mod) {
-        return (mod && mod.__esModule) ? mod : { default: mod };
-    }
-    function __classPrivateFieldGet(receiver, state, kind, f) {
-        if (kind === "a" && !f)
-            throw new TypeError("Private accessor was defined without a getter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-            throw new TypeError("Cannot read private member from an object whose class did not declare it");
-        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-    }
-    function __classPrivateFieldSet(receiver, state, value, kind, f) {
-        if (kind === "m")
-            throw new TypeError("Private method is not writable");
-        if (kind === "a" && !f)
-            throw new TypeError("Private accessor was defined without a setter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
-            throw new TypeError("Cannot write private member to an object whose class did not declare it");
-        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-    }
-
-    /**
-     * Two weak maps that allow us rebuild a path given a node. They are populated
-     * at render time such that after a render occurs we can always backtrack.
-     */
-    var EDITOR_TO_WINDOW = new WeakMap();
-    var NODE_TO_INDEX = new WeakMap();
-    var NODE_TO_PARENT = new WeakMap();
-    /**
-     * Weak maps that allow us to go between Slate nodes and DOM nodes. These
-     * are used to resolve DOM event-related logic into Slate actions.
-     */
-    var EDITOR_TO_ELEMENT = new WeakMap();
-    var EDITOR_TO_PLACEHOLDER = new WeakMap();
-    var ELEMENT_TO_NODE = new WeakMap();
-    // Deprecated
-    var KEY_TO_ELEMENT = new WeakMap();
-    var NODE_TO_ELEMENT = new WeakMap();
-    var NODE_TO_KEY = new WeakMap();
-    /**
-     * Weak maps for storing editor-related state.
-     */
-    var IS_READONLY = new WeakMap();
-    var IS_FOCUSED = new WeakMap();
-    var IS_DRAGGING = new WeakMap();
-    var IS_CLICKING = new WeakMap();
-    /**
-     * Weak map for associating the context `onChange` context with the plugin.
-     */
-    var EDITOR_TO_ON_CHANGE = new WeakMap();
-    // export const NODE_TO_VIEWNODE = new WeakMap<Node, ViewNode>();
-    /**
-     * Symbols.
-     */
-    var PLACEHOLDER_SYMBOL = Symbol('placeholder');
-    /**
-     * Weak map for associating the html element with the component.
-     */
-    var ELEMENT_TO_COMPONENT = new WeakMap();
-
-    /**
-     * Types.
-     */
-    // COMPAT: This is required to prevent TypeScript aliases from doing some very
-    // weird things for Slate's types with the same name as globals. (2019/11/27)
-    // https://github.com/microsoft/TypeScript/issues/35002
-    var DOMNode = globalThis.Node;
-    var DOMComment = globalThis.Comment;
-    var DOMElement = globalThis.Element;
-    var DOMText = globalThis.Text;
-    var DOMRange = globalThis.Range;
-    var DOMSelection = globalThis.Selection;
-    var DOMStaticRange = globalThis.StaticRange;
-    /**
-     * Returns the host window of a DOM node
-     */
-    var getDefaultView = function (value) {
-        return ((value && value.ownerDocument && value.ownerDocument.defaultView) || null);
-    };
-    /**
-     * Check if a DOM node is a comment node.
-     */
-    var isDOMComment = function (value) {
-        return isDOMNode(value) && value.nodeType === 8;
-    };
-    /**
-     * Check if a DOM node is an element node.
-     */
-    var isDOMElement = function (value) {
-        return isDOMNode(value) && value.nodeType === 1;
-    };
-    /**
-     * Check if a value is a DOM node.
-     */
-    var isDOMNode = function (value) {
-        var window = getDefaultView(value);
-        return !!window && value instanceof window.Node;
-    };
-    /**
-     * Check if a value is a DOM selection.
-     */
-    var isDOMSelection = function (value) {
-        var window = value && value.anchorNode && getDefaultView(value.anchorNode);
-        return !!window && value instanceof window.Selection;
-    };
-    /**
-     * Check if a DOM node is an element node.
-     */
-    var isDOMText = function (value) {
-        return isDOMNode(value) && value.nodeType === 3;
-    };
-    /**
-     * Checks whether a paste event is a plaintext-only event.
-     */
-    var isPlainTextOnlyPaste = function (event) {
-        return (event.clipboardData &&
-            event.clipboardData.getData('text/plain') !== '' &&
-            event.clipboardData.types.length === 1);
-    };
-    /**
-     * Normalize a DOM point so that it always refers to a text node.
-     */
-    var normalizeDOMPoint = function (domPoint) {
-        var _a;
-        var _b = __read(domPoint, 2), node = _b[0], offset = _b[1];
-        // If it's an element node, its offset refers to the index of its children
-        // including comment nodes, so try to find the right text child node.
-        if (isDOMElement(node) && node.childNodes.length) {
-            var isLast = offset === node.childNodes.length;
-            var index = isLast ? offset - 1 : offset;
-            ;
-            _a = __read(getEditableChildAndIndex(node, index, isLast ? 'backward' : 'forward'), 2), node = _a[0], index = _a[1];
-            // If the editable child found is in front of input offset, we instead seek to its end
-            isLast = index < offset;
-            // If the node has children, traverse until we have a leaf node. Leaf nodes
-            // can be either text nodes, or other void DOM nodes.
-            while (isDOMElement(node) && node.childNodes.length) {
-                var i = isLast ? node.childNodes.length - 1 : 0;
-                node = getEditableChild(node, i, isLast ? 'backward' : 'forward');
-            }
-            // Determine the new offset inside the text node.
-            offset =
-                isLast && node.textContent != null ? node.textContent.length : 0;
-        }
-        // Return the node and offset.
-        return [node, offset];
-    };
-    /**
-     * Determines wether the active element is nested within a shadowRoot
-     */
-    var hasShadowRoot = function () {
-        return !!(window.document.activeElement && window.document.activeElement.shadowRoot);
-    };
-    /**
-     * Get the nearest editable child and index at `index` in a `parent`, preferring
-     * `direction`.
-     */
-    var getEditableChildAndIndex = function (parent, index, direction) {
-        var childNodes = parent.childNodes;
-        var child = childNodes[index];
-        var i = index;
-        var triedForward = false;
-        var triedBackward = false;
-        // While the child is a comment node, or an element node with no children,
-        // keep iterating to find a sibling non-void, non-comment node.
-        while (isDOMComment(child) ||
-            (isDOMElement(child) && child.childNodes.length === 0) ||
-            (isDOMElement(child) && child.getAttribute('contenteditable') === 'false')) {
-            if (triedForward && triedBackward) {
-                break;
-            }
-            if (i >= childNodes.length) {
-                triedForward = true;
-                i = index - 1;
-                direction = 'backward';
-                continue;
-            }
-            if (i < 0) {
-                triedBackward = true;
-                i = index + 1;
-                direction = 'forward';
-                continue;
-            }
-            child = childNodes[i];
-            index = i;
-            i += direction === 'forward' ? 1 : -1;
-        }
-        return [child, index];
-    };
-    /**
-     * Get the nearest editable child at `index` in a `parent`, preferring
-     * `direction`.
-     */
-    var getEditableChild = function (parent, index, direction) {
-        var _a = __read(getEditableChildAndIndex(parent, index, direction), 1), child = _a[0];
-        return child;
-    };
-    /**
-     * Get a plaintext representation of the content of a node, accounting for block
-     * elements which get a newline appended.
-     *
-     * The domNode must be attached to the DOM.
-     */
-    var getPlainText = function (domNode) {
-        var e_1, _a;
-        var text = '';
-        if (isDOMText(domNode) && domNode.nodeValue) {
-            return domNode.nodeValue;
-        }
-        if (isDOMElement(domNode)) {
-            try {
-                for (var _b = __values(Array.from(domNode.childNodes)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var childNode = _c.value;
-                    text += getPlainText(childNode);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            var display = getComputedStyle(domNode).getPropertyValue('display');
-            if (display === 'block' || display === 'list' || domNode.tagName === 'BR') {
-                text += '\n';
-            }
-        }
-        return text;
-    };
-    /**
-     * Get x-slate-fragment attribute from data-slate-fragment
-     */
-    var catchSlateFragment = /data-slate-fragment="(.+?)"/m;
-    var getSlateFragmentAttribute = function (dataTransfer) {
-        var htmlData = dataTransfer.getData('text/html');
-        var _a = __read(htmlData.match(catchSlateFragment) || [], 2), fragment = _a[1];
-        return fragment;
-    };
-    /**
-     * Get the x-slate-fragment attribute that exist in text/html data
-     * and append it to the DataTransfer object
-     */
-    var getClipboardData = function (dataTransfer, clipboardFormatKey) {
-        if (clipboardFormatKey === void 0) { clipboardFormatKey = 'x-slate-fragment'; }
-        if (!dataTransfer.getData("application/" + clipboardFormatKey)) {
-            var fragment = getSlateFragmentAttribute(dataTransfer);
-            if (fragment) {
-                var clipboardData_1 = new DataTransfer();
-                dataTransfer.types.forEach(function (type) {
-                    clipboardData_1.setData(type, dataTransfer.getData(type));
-                });
-                clipboardData_1.setData("application/" + clipboardFormatKey, fragment);
-                return clipboardData_1;
-            }
-        }
-        return dataTransfer;
-    };
-
-    /**
-     * An auto-incrementing identifier for keys.
-     */
-    var n = 0;
-    /**
-     * A class that keeps track of a key string. We use a full class here because we
-     * want to be able to use them as keys in `WeakMap` objects.
-     */
-    var Key = /** @class */ (function () {
-        function Key() {
-            this.id = "" + n++;
-        }
-        return Key;
-    }());
-
-    var IS_IOS = typeof navigator !== 'undefined' &&
-        typeof window !== 'undefined' &&
-        /iPad|iPhone|iPod/.test(navigator.userAgent) &&
-        !window.MSStream;
-    var IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);
-    var IS_ANDROID = typeof navigator !== 'undefined' && /Android/.test(navigator.userAgent);
-    var IS_FIREFOX = typeof navigator !== 'undefined' &&
-        /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
-    var IS_SAFARI = typeof navigator !== 'undefined' &&
-        /Version\/[\d\.]+.*Safari/.test(navigator.userAgent);
-    // "modern" Edge was released at 79.x
-    var IS_EDGE_LEGACY = typeof navigator !== 'undefined' &&
-        /Edge?\/(?:[0-6][0-9]|[0-7][0-8])/i.test(navigator.userAgent);
-    var IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent);
-    // Native beforeInput events don't work well with react on Chrome 75 and older, Chrome 76+ can use beforeInput
-    var IS_CHROME_LEGACY = typeof navigator !== 'undefined' &&
-        /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])/i.test(navigator.userAgent) &&
-        // Exclude Chrome version greater than 3 bits，Chrome releases v100 on 2022.03.29
-        !/Chrome?\/(?:\d{3,})/i.test(navigator.userAgent);
-    // Firefox did not support `beforeInput` until `v87`.
-    var IS_FIREFOX_LEGACY = typeof navigator !== 'undefined' &&
-        /^(?!.*Seamonkey)(?=.*Firefox\/(?:[0-7][0-9]|[0-8][0-6])).*/i.test(navigator.userAgent);
-    // qq browser
-    var IS_QQBROWSER = typeof navigator !== 'undefined' && /.*QQBrowser/.test(navigator.userAgent);
-    // UC mobile browser
-    var IS_UC_MOBILE = typeof navigator !== 'undefined' && /.*UCBrowser/.test(navigator.userAgent);
-    // Wechat browser
-    var IS_WECHATBROWSER = typeof navigator !== 'undefined' && /.*Wechat/.test(navigator.userAgent);
-    // COMPAT: Firefox/Edge Legacy don't support the `beforeinput` event
-    // Chrome Legacy doesn't support `beforeinput` correctly
-    var HAS_BEFORE_INPUT_SUPPORT = !IS_CHROME_LEGACY &&
-        !IS_EDGE_LEGACY &&
-        // globalThis is undefined in older browsers
-        typeof globalThis !== 'undefined' &&
-        globalThis.InputEvent &&
-        // @ts-ignore The `getTargetRanges` property isn't recognized.
-        typeof globalThis.InputEvent.prototype.getTargetRanges === 'function';
-
-    var FAKE_LEFT_BLOCK_CARD_OFFSET = -1;
-    var FAKE_RIGHT_BLOCK_CARD_OFFSET = -2;
-    function hasBlockCardWithNode(node) {
-        return node && (node.parentElement.hasAttribute('card-target') || (node instanceof HTMLElement && node.hasAttribute('card-target')));
-    }
-    function hasBlockCard(selection) {
-        return hasBlockCardWithNode(selection === null || selection === void 0 ? void 0 : selection.anchorNode) || hasBlockCardWithNode(selection === null || selection === void 0 ? void 0 : selection.focusNode);
-    }
-    function getCardTargetAttribute(node) {
-        return node.parentElement.attributes['card-target'] || (node instanceof HTMLElement && node.attributes['card-target']);
-    }
-    function isCardLeft(node) {
-        var cardTarget = getCardTargetAttribute(node);
-        return cardTarget && cardTarget.nodeValue === 'card-left';
-    }
-    function isCardLeftByTargetAttr(targetAttr) {
-        return targetAttr && targetAttr.nodeValue === 'card-left';
-    }
-    function isCardRightByTargetAttr(targetAttr) {
-        return targetAttr && targetAttr.nodeValue === 'card-right';
-    }
-    function isCardCenterByTargetAttr(targetAttr) {
-        return targetAttr && targetAttr.nodeValue === 'card-center';
-    }
-
-    var AngularEditor = {
-        /**
-         * Return the host window of the current editor.
-         */
-        getWindow: function (editor) {
-            var window = EDITOR_TO_WINDOW.get(editor);
-            if (!window) {
-                throw new Error('Unable to find a host window element for this editor');
-            }
-            return window;
-        },
-        /**
-         * Find a key for a Slate node.
-         */
-        findKey: function (editor, node) {
-            var key = NODE_TO_KEY.get(node);
-            if (!key) {
-                key = new Key();
-                NODE_TO_KEY.set(node, key);
-            }
-            return key;
-        },
-        /**
-         * handle editor error.
-         */
-        onError: function (errorData) {
-            if (errorData.nativeError) {
-                throw errorData.nativeError;
-            }
-        },
-        /**
-         * Find the path of Slate node.
-         */
-        findPath: function (editor, node) {
-            var path = [];
-            var child = node;
-            while (true) {
-                var parent = NODE_TO_PARENT.get(child);
-                if (parent == null) {
-                    if (slate.Editor.isEditor(child)) {
-                        return path;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                var i = NODE_TO_INDEX.get(child);
-                if (i == null) {
-                    break;
-                }
-                path.unshift(i);
-                child = parent;
-            }
-            throw new Error("Unable to find the path for Slate node: " + JSON.stringify(node));
-        },
-        /**
-         * Find the DOM node that implements DocumentOrShadowRoot for the editor.
-         */
-        findDocumentOrShadowRoot: function (editor) {
-            var el = AngularEditor.toDOMNode(editor, editor);
-            var root = el.getRootNode();
-            if ((root instanceof Document || root instanceof ShadowRoot) &&
-                root.getSelection != null) {
-                return root;
-            }
-            return el.ownerDocument;
-        },
-        /**
-         * Check if the editor is focused.
-         */
-        isFocused: function (editor) {
-            return !!IS_FOCUSED.get(editor);
-        },
-        /**
-         * Check if the editor is in read-only mode.
-         */
-        isReadonly: function (editor) {
-            return !!IS_READONLY.get(editor);
-        },
-        /**
-         * Check if the editor is hanging right.
-         */
-        isBlockHangingRight: function (editor) {
-            var selection = editor.selection;
-            if (!selection) {
-                return false;
-            }
-            if (slate.Range.isCollapsed(selection)) {
-                return false;
-            }
-            var _b = __read(slate.Range.edges(selection), 2), start = _b[0], end = _b[1];
-            var endBlock = slate.Editor.above(editor, { at: end, match: function (node) { return slate.Editor.isBlock(editor, node); } });
-            return slate.Editor.isStart(editor, end, endBlock[1]);
-        },
-        /**
-         * Blur the editor.
-         */
-        blur: function (editor) {
-            var el = AngularEditor.toDOMNode(editor, editor);
-            var root = AngularEditor.findDocumentOrShadowRoot(editor);
-            IS_FOCUSED.set(editor, false);
-            if (root.activeElement === el) {
-                el.blur();
-            }
-        },
-        /**
-         * Focus the editor.
-         */
-        focus: function (editor) {
-            var el = AngularEditor.toDOMNode(editor, editor);
-            IS_FOCUSED.set(editor, true);
-            var window = AngularEditor.getWindow(editor);
-            if (window.document.activeElement !== el) {
-                el.focus({ preventScroll: true });
-            }
-        },
-        /**
-         * Deselect the editor.
-         */
-        deselect: function (editor) {
-            var selection = editor.selection;
-            var root = AngularEditor.findDocumentOrShadowRoot(editor);
-            var domSelection = root.getSelection();
-            if (domSelection && domSelection.rangeCount > 0) {
-                domSelection.removeAllRanges();
-            }
-            if (selection) {
-                slate.Transforms.deselect(editor);
-            }
-        },
-        /**
-         * Check if a DOM node is within the editor.
-         */
-        hasDOMNode: function (editor, target, options) {
-            if (options === void 0) { options = {}; }
-            var _b = options.editable, editable = _b === void 0 ? false : _b;
-            var editorEl = AngularEditor.toDOMNode(editor, editor);
-            var targetEl;
-            // COMPAT: In Firefox, reading `target.nodeType` will throw an error if
-            // target is originating from an internal "restricted" element (e.g. a
-            // stepper arrow on a number input). (2018/05/04)
-            // https://github.com/ianstormtaylor/slate/issues/1819
-            try {
-                targetEl = (isDOMElement(target) ? target : target.parentElement);
-            }
-            catch (err) {
-                if (!err.message.includes('Permission denied to access property "nodeType"')) {
-                    throw err;
-                }
-            }
-            if (!targetEl) {
-                return false;
-            }
-            return targetEl.closest("[data-slate-editor]") === editorEl &&
-                (!editable || targetEl.isContentEditable ||
-                    !!targetEl.getAttribute('data-slate-zero-width'));
-        },
-        /**
-         * Insert data from a `DataTransfer` into the editor.
-         */
-        insertData: function (editor, data) {
-            editor.insertData(data);
-        },
-        /**
-       * Insert fragment data from a `DataTransfer` into the editor.
-       */
-        insertFragmentData: function (editor, data) {
-            return editor.insertFragmentData(data);
-        },
-        /**
-         * Insert text data from a `DataTransfer` into the editor.
-         */
-        insertTextData: function (editor, data) {
-            return editor.insertTextData(data);
-        },
-        /**
-         * onKeydown hook.
-         */
-        onKeydown: function (editor, data) {
-            editor.onKeydown(data);
-        },
-        /**
-        * onClick hook.
-        */
-        onClick: function (editor, data) {
-            editor.onClick(data);
-        },
-        /**
-         * Sets data from the currently selected fragment on a `DataTransfer`.
-         */
-        setFragmentData: function (editor, data, originEvent) {
-            editor.setFragmentData(data, originEvent);
-        },
-        deleteCutData: function (editor) {
-            editor.deleteCutData();
-        },
-        /**
-         * Find the native DOM element from a Slate node.
-         */
-        toDOMNode: function (editor, node) {
-            var domNode = slate.Editor.isEditor(node)
-                ? EDITOR_TO_ELEMENT.get(editor)
-                : NODE_TO_ELEMENT.get(node);
-            if (!domNode) {
-                throw new Error("Cannot resolve a DOM node from Slate node: " + JSON.stringify(node));
-            }
-            return domNode;
-        },
-        /**
-         * Find a native DOM selection point from a Slate point.
-         */
-        toDOMPoint: function (editor, point) {
-            var e_1, _b;
-            var _c = __read(slate.Editor.node(editor, point.path), 1), node = _c[0];
-            var el = AngularEditor.toDOMNode(editor, node);
-            var domPoint;
-            // block card
-            var cardTargetAttr = getCardTargetAttribute(el);
-            if (cardTargetAttr) {
-                if (point.offset === FAKE_LEFT_BLOCK_CARD_OFFSET) {
-                    var cursorNode = AngularEditor.getCardCursorNode(editor, node, { direction: 'left' });
-                    return [cursorNode, 1];
-                }
-                else {
-                    var cursorNode = AngularEditor.getCardCursorNode(editor, node, { direction: 'right' });
-                    return [cursorNode, 1];
-                }
-            }
-            // If we're inside a void node, force the offset to 0, otherwise the zero
-            // width spacing character will result in an incorrect offset of 1
-            if (slate.Editor.void(editor, { at: point })) {
-                point = { path: point.path, offset: 0 };
-            }
-            // For each leaf, we need to isolate its content, which means filtering
-            // to its direct text and zero-width spans. (We have to filter out any
-            // other siblings that may have been rendered alongside them.)
-            var selector = "[data-slate-string], [data-slate-zero-width]";
-            var texts = Array.from(el.querySelectorAll(selector));
-            var start = 0;
-            try {
-                for (var texts_1 = __values(texts), texts_1_1 = texts_1.next(); !texts_1_1.done; texts_1_1 = texts_1.next()) {
-                    var text = texts_1_1.value;
-                    var domNode = text.childNodes[0];
-                    if (domNode == null || domNode.textContent == null) {
-                        continue;
-                    }
-                    var length = domNode.textContent.length;
-                    var attr = text.getAttribute('data-slate-length');
-                    var trueLength = attr == null ? length : parseInt(attr, 10);
-                    var end = start + trueLength;
-                    if (point.offset <= end) {
-                        var offset = Math.min(length, Math.max(0, point.offset - start));
-                        domPoint = [domNode, offset];
-                        // fixed cursor position after zero width char
-                        if (offset === 0 && length === 1 && domNode.textContent === '\uFEFF') {
-                            domPoint = [domNode, offset + 1];
-                        }
-                        break;
-                    }
-                    start = end;
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (texts_1_1 && !texts_1_1.done && (_b = texts_1.return)) _b.call(texts_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            if (!domPoint) {
-                throw new Error("Cannot resolve a DOM point from Slate point: " + JSON.stringify(point));
-            }
-            return domPoint;
-        },
-        /**
-         * Find a native DOM range from a Slate `range`.
-         */
-        toDOMRange: function (editor, range) {
-            var anchor = range.anchor, focus = range.focus;
-            var isBackward = slate.Range.isBackward(range);
-            var domAnchor = AngularEditor.toDOMPoint(editor, anchor);
-            var domFocus = slate.Range.isCollapsed(range) ? domAnchor : AngularEditor.toDOMPoint(editor, focus);
-            var window = AngularEditor.getWindow(editor);
-            var domRange = window.document.createRange();
-            var _b = __read(isBackward ? domFocus : domAnchor, 2), startNode = _b[0], startOffset = _b[1];
-            var _c = __read(isBackward ? domAnchor : domFocus, 2), endNode = _c[0], endOffset = _c[1];
-            // A slate Point at zero-width Leaf always has an offset of 0 but a native DOM selection at
-            // zero-width node has an offset of 1 so we have to check if we are in a zero-width node and
-            // adjust the offset accordingly.
-            var startEl = (isDOMElement(startNode)
-                ? startNode
-                : startNode.parentElement);
-            var isStartAtZeroWidth = !!startEl.getAttribute('data-slate-zero-width');
-            var endEl = (isDOMElement(endNode)
-                ? endNode
-                : endNode.parentElement);
-            var isEndAtZeroWidth = !!endEl.getAttribute('data-slate-zero-width');
-            domRange.setStart(startNode, isStartAtZeroWidth ? 1 : startOffset);
-            domRange.setEnd(endNode, isEndAtZeroWidth ? 1 : endOffset);
-            return domRange;
-        },
-        /**
-         * Find a Slate node from a native DOM `element`.
-         */
-        toSlateNode: function (editor, domNode) {
-            var domEl = isDOMElement(domNode) ? domNode : domNode.parentElement;
-            if (domEl && !domEl.hasAttribute('data-slate-node')) {
-                domEl = domEl.closest("[data-slate-node]");
-            }
-            var node = domEl ? ELEMENT_TO_NODE.get(domEl) : null;
-            if (!node) {
-                throw new Error("Cannot resolve a Slate node from DOM node: " + domEl);
-            }
-            return node;
-        },
-        /**
-         * Get the target range from a DOM `event`.
-         */
-        findEventRange: function (editor, event) {
-            if ('nativeEvent' in event) {
-                event = event.nativeEvent;
-            }
-            var x = event.clientX, y = event.clientY, target = event.target;
-            if (x == null || y == null) {
-                throw new Error("Cannot resolve a Slate range from a DOM event: " + event);
-            }
-            var node = AngularEditor.toSlateNode(editor, event.target);
-            var path = AngularEditor.findPath(editor, node);
-            // If the drop target is inside a void node, move it into either the
-            // next or previous node, depending on which side the `x` and `y`
-            // coordinates are closest to.
-            if (slate.Editor.isVoid(editor, node)) {
-                var rect = target.getBoundingClientRect();
-                var isPrev = editor.isInline(node)
-                    ? x - rect.left < rect.left + rect.width - x
-                    : y - rect.top < rect.top + rect.height - y;
-                var edge = slate.Editor.point(editor, path, {
-                    edge: isPrev ? 'start' : 'end'
-                });
-                var point = isPrev ? slate.Editor.before(editor, edge) : slate.Editor.after(editor, edge);
-                if (point) {
-                    return slate.Editor.range(editor, point);
-                }
-            }
-            // Else resolve a range from the caret position where the drop occured.
-            var domRange;
-            var window = AngularEditor.getWindow(editor);
-            var document = window.document;
-            // COMPAT: In Firefox, `caretRangeFromPoint` doesn't exist. (2016/07/25)
-            if (document.caretRangeFromPoint) {
-                domRange = document.caretRangeFromPoint(x, y);
-            }
-            else {
-                var position = document.caretPositionFromPoint(x, y);
-                if (position) {
-                    domRange = document.createRange();
-                    domRange.setStart(position.offsetNode, position.offset);
-                    domRange.setEnd(position.offsetNode, position.offset);
-                }
-            }
-            if (!domRange) {
-                throw new Error("Cannot resolve a Slate range from a DOM event: " + event);
-            }
-            // Resolve a Slate range from the DOM range.
-            var range = AngularEditor.toSlateRange(editor, domRange);
-            return range;
-        },
-        /**
-         * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
-         */
-        toSlatePoint: function (editor, domPoint) {
-            var _b = __read(domPoint, 1), domNode = _b[0];
-            var _c = __read(normalizeDOMPoint(domPoint), 2), nearestNode = _c[0], nearestOffset = _c[1];
-            var parentNode = nearestNode.parentNode;
-            var textNode = null;
-            var offset = 0;
-            // block card
-            var cardTargetAttr = getCardTargetAttribute(domNode);
-            if (cardTargetAttr) {
-                var domSelection = window.getSelection();
-                var isBackward = editor.selection && slate.Range.isBackward(editor.selection);
-                var blockCardEntry = AngularEditor.toSlateCardEntry(editor, domNode) || AngularEditor.toSlateCardEntry(editor, nearestNode);
-                var _d = __read(blockCardEntry, 2), blockPath = _d[1];
-                if (domSelection.isCollapsed) {
-                    if (isCardLeftByTargetAttr(cardTargetAttr)) {
-                        return { path: blockPath, offset: -1 };
-                    }
-                    else {
-                        return { path: blockPath, offset: -2 };
-                    }
-                }
-                // forward
-                // and to the end of previous node
-                if (isCardLeftByTargetAttr(cardTargetAttr) && !isBackward) {
-                    var endPath = blockPath[blockPath.length - 1] <= 0
-                        ? blockPath
-                        : slate.Path.previous(blockPath);
-                    return slate.Editor.end(editor, endPath);
-                }
-                // to the of current node
-                if ((isCardCenterByTargetAttr(cardTargetAttr) ||
-                    isCardRightByTargetAttr(cardTargetAttr)) &&
-                    !isBackward) {
-                    return slate.Editor.end(editor, blockPath);
-                }
-                // backward
-                // and to the start of next node
-                if (isCardRightByTargetAttr(cardTargetAttr) && isBackward) {
-                    return slate.Editor.start(editor, slate.Path.next(blockPath));
-                }
-                // and to the start of current node
-                if ((isCardCenterByTargetAttr(cardTargetAttr) ||
-                    isCardLeftByTargetAttr(cardTargetAttr)) &&
-                    isBackward) {
-                    return slate.Editor.start(editor, blockPath);
-                }
-            }
-            if (parentNode) {
-                var voidNode = parentNode.closest('[data-slate-void="true"]');
-                var leafNode = parentNode.closest('[data-slate-leaf]');
-                var domNode_1 = null;
-                // Calculate how far into the text node the `nearestNode` is, so that we
-                // can determine what the offset relative to the text node is.
-                if (leafNode) {
-                    textNode = leafNode.closest('[data-slate-node="text"]');
-                    var window = AngularEditor.getWindow(editor);
-                    var range = window.document.createRange();
-                    range.setStart(textNode, 0);
-                    range.setEnd(nearestNode, nearestOffset);
-                    var contents = range.cloneContents();
-                    var removals = __spreadArray(__spreadArray([], __read(Array.prototype.slice.call(contents.querySelectorAll('[data-slate-zero-width]')))), __read(Array.prototype.slice.call(contents.querySelectorAll('[contenteditable=false]'))));
-                    removals.forEach(function (el) {
-                        el.parentNode.removeChild(el);
-                    });
-                    // COMPAT: Edge has a bug where Range.prototype.toString() will
-                    // convert \n into \r\n. The bug causes a loop when slate-react
-                    // attempts to reposition its cursor to match the native position. Use
-                    // textContent.length instead.
-                    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/10291116/
-                    offset = contents.textContent.length;
-                    domNode_1 = textNode;
-                }
-                else if (voidNode) {
-                    // For void nodes, the element with the offset key will be a cousin, not an
-                    // ancestor, so find it by going down from the nearest void parent.
-                    leafNode = voidNode.querySelector('[data-slate-leaf]');
-                    parentNode = voidNode.querySelector('[data-slate-length="0"]');
-                    textNode = leafNode.closest('[data-slate-node="text"]');
-                    domNode_1 = leafNode;
-                    offset = domNode_1.textContent.length;
-                }
-                // COMPAT: If the parent node is a Slate zero-width space, editor is
-                // because the text node should have no characters. However, during IME
-                // composition the ASCII characters will be prepended to the zero-width
-                // space, so subtract 1 from the offset to account for the zero-width
-                // space character.
-                if (domNode_1 &&
-                    offset === domNode_1.textContent.length &&
-                    (parentNode && parentNode.hasAttribute('data-slate-zero-width'))) {
-                    offset--;
-                }
-            }
-            if (!textNode) {
-                throw new Error("Cannot resolve a Slate point from DOM point: " + domPoint);
-            }
-            // COMPAT: If someone is clicking from one Slate editor into another,
-            // the select event fires twice, once for the old editor's `element`
-            // first, and then afterwards for the correct `element`. (2017/03/03)
-            var slateNode = AngularEditor.toSlateNode(editor, textNode);
-            var path = AngularEditor.findPath(editor, slateNode);
-            return { path: path, offset: offset };
-        },
-        /**
-         * Find a Slate range from a DOM range or selection.
-         */
-        toSlateRange: function (editor, domRange) {
-            var el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer;
-            var anchorNode;
-            var anchorOffset;
-            var focusNode;
-            var focusOffset;
-            var isCollapsed;
-            if (el) {
-                if (isDOMSelection(domRange)) {
-                    anchorNode = domRange.anchorNode;
-                    anchorOffset = domRange.anchorOffset;
-                    focusNode = domRange.focusNode;
-                    focusOffset = domRange.focusOffset;
-                    // COMPAT: There's a bug in chrome that always returns `true` for
-                    // `isCollapsed` for a Selection that comes from a ShadowRoot.
-                    // (2020/08/08)
-                    // https://bugs.chromium.org/p/chromium/issues/detail?id=447523
-                    if (IS_CHROME && hasShadowRoot()) {
-                        isCollapsed =
-                            domRange.anchorNode === domRange.focusNode &&
-                                domRange.anchorOffset === domRange.focusOffset;
-                    }
-                    else {
-                        isCollapsed = domRange.isCollapsed;
-                    }
-                }
-                else {
-                    anchorNode = domRange.startContainer;
-                    anchorOffset = domRange.startOffset;
-                    focusNode = domRange.endContainer;
-                    focusOffset = domRange.endOffset;
-                    isCollapsed = domRange.collapsed;
-                }
-            }
-            if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {
-                throw new Error("Cannot resolve a Slate range from DOM range: " + domRange);
-            }
-            var anchor = AngularEditor.toSlatePoint(editor, [anchorNode, anchorOffset]);
-            var focus = isCollapsed ? anchor : AngularEditor.toSlatePoint(editor, [focusNode, focusOffset]);
-            return { anchor: anchor, focus: focus };
-        },
-        isLeafBlock: function (editor, node) {
-            return slate.Element.isElement(node) && !editor.isInline(node) && slate.Editor.hasInlines(editor, node);
-        },
-        isBlockCardLeftCursor: function (editor) {
-            return editor.selection.anchor.offset === FAKE_LEFT_BLOCK_CARD_OFFSET && editor.selection.focus.offset === FAKE_LEFT_BLOCK_CARD_OFFSET;
-        },
-        isBlockCardRightCursor: function (editor) {
-            return editor.selection.anchor.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET && editor.selection.focus.offset === FAKE_RIGHT_BLOCK_CARD_OFFSET;
-        },
-        getCardCursorNode: function (editor, blockCardNode, options) {
-            var blockCardElement = AngularEditor.toDOMNode(editor, blockCardNode);
-            var cardCenter = blockCardElement.parentElement;
-            return options.direction === 'left'
-                ? cardCenter.previousElementSibling
-                : cardCenter.nextElementSibling;
-        },
-        toSlateCardEntry: function (editor, node) {
-            var _a;
-            var element = (_a = node.parentElement
-                .closest('.slate-block-card')) === null || _a === void 0 ? void 0 : _a.querySelector('[card-target="card-center"]').firstElementChild;
-            var slateNode = AngularEditor.toSlateNode(editor, element);
-            var path = AngularEditor.findPath(editor, slateNode);
-            return [slateNode, path];
-        },
-        /**
-         * move native selection to card-left or card-right
-         * @param editor
-         * @param blockCardNode
-         * @param options
-         */
-        moveBlockCard: function (editor, blockCardNode, options) {
-            var cursorNode = AngularEditor.getCardCursorNode(editor, blockCardNode, options);
-            var window = AngularEditor.getWindow(editor);
-            var domSelection = window.getSelection();
-            domSelection.setBaseAndExtent(cursorNode, 1, cursorNode, 1);
-        },
-        /**
-         * move slate selection to card-left or card-right
-         * @param editor
-         * @param path
-         * @param options
-         */
-        moveBlockCardCursor: function (editor, path, options) {
-            var cursor = { path: path, offset: options.direction === 'left' ? FAKE_LEFT_BLOCK_CARD_OFFSET : FAKE_RIGHT_BLOCK_CARD_OFFSET };
-            slate.Transforms.select(editor, { anchor: cursor, focus: cursor });
-        },
-        hasRange: function (editor, range) {
-            var anchor = range.anchor, focus = range.focus;
-            return (slate.Editor.hasPath(editor, anchor.path) && slate.Editor.hasPath(editor, focus.path));
-        },
-    };
-
-    /**
-     * Hotkey mappings for each platform.
-     */
-    var HOTKEYS = {
-        bold: 'mod+b',
-        compose: ['down', 'left', 'right', 'up', 'backspace', 'enter'],
-        moveBackward: 'left',
-        moveForward: 'right',
-        moveUp: 'up',
-        moveDown: 'down',
-        moveWordBackward: 'ctrl+left',
-        moveWordForward: 'ctrl+right',
-        deleteBackward: 'shift?+backspace',
-        deleteForward: 'shift?+delete',
-        extendBackward: 'shift+left',
-        extendForward: 'shift+right',
-        italic: 'mod+i',
-        splitBlock: 'shift?+enter',
-        undo: 'mod+z'
-    };
-    var APPLE_HOTKEYS = {
-        moveLineBackward: 'opt+up',
-        moveLineForward: 'opt+down',
-        moveWordBackward: 'opt+left',
-        moveWordForward: 'opt+right',
-        deleteBackward: ['ctrl+backspace', 'ctrl+h'],
-        deleteForward: ['ctrl+delete', 'ctrl+d'],
-        deleteLineBackward: 'cmd+shift?+backspace',
-        deleteLineForward: ['cmd+shift?+delete', 'ctrl+k'],
-        deleteWordBackward: 'opt+shift?+backspace',
-        deleteWordForward: 'opt+shift?+delete',
-        extendLineBackward: 'opt+shift+up',
-        extendLineForward: 'opt+shift+down',
-        redo: 'cmd+shift+z',
-        transposeCharacter: 'ctrl+t'
-    };
-    var WINDOWS_HOTKEYS = {
-        deleteWordBackward: 'ctrl+shift?+backspace',
-        deleteWordForward: 'ctrl+shift?+delete',
-        redo: ['ctrl+y', 'ctrl+shift+z']
-    };
-    /**
-     * Create a platform-aware hotkey checker.
-     */
-    var create = function (key) {
-        var generic = HOTKEYS[key];
-        var apple = APPLE_HOTKEYS[key];
-        var windows = WINDOWS_HOTKEYS[key];
-        var isGeneric = generic && isHotkey.isKeyHotkey(generic);
-        var isApple = apple && isHotkey.isKeyHotkey(apple);
-        var isWindows = windows && isHotkey.isKeyHotkey(windows);
-        return function (event) {
-            if (isGeneric && isGeneric(event)) {
-                return true;
-            }
-            if (IS_APPLE && isApple && isApple(event)) {
-                return true;
-            }
-            if (!IS_APPLE && isWindows && isWindows(event)) {
-                return true;
-            }
-            return false;
-        };
-    };
-    /**
-     * Hotkeys.
-     */
-    var hotkeys = {
-        isBold: create('bold'),
-        isCompose: create('compose'),
-        isMoveBackward: create('moveBackward'),
-        isMoveForward: create('moveForward'),
-        isMoveUp: create('moveUp'),
-        isMoveDown: create('moveDown'),
-        isDeleteBackward: create('deleteBackward'),
-        isDeleteForward: create('deleteForward'),
-        isDeleteLineBackward: create('deleteLineBackward'),
-        isDeleteLineForward: create('deleteLineForward'),
-        isDeleteWordBackward: create('deleteWordBackward'),
-        isDeleteWordForward: create('deleteWordForward'),
-        isExtendBackward: create('extendBackward'),
-        isExtendForward: create('extendForward'),
-        isExtendLineBackward: create('extendLineBackward'),
-        isExtendLineForward: create('extendLineForward'),
-        isItalic: create('italic'),
-        isMoveLineBackward: create('moveLineBackward'),
-        isMoveLineForward: create('moveLineForward'),
-        isMoveWordBackward: create('moveWordBackward'),
-        isMoveWordForward: create('moveWordForward'),
-        isRedo: create('redo'),
-        isSplitBlock: create('splitBlock'),
-        isTransposeCharacter: create('transposeCharacter'),
-        isUndo: create('undo')
-    };
-
-    function isTemplateRef(value) {
-        return value && value instanceof i0.TemplateRef;
-    }
-    function isComponentType(value) {
-        return !isTemplateRef(value);
-    }
-
-    var shallowCompare = function (obj1, obj2) { return Object.keys(obj1).length === Object.keys(obj2).length &&
-        Object.keys(obj1).every(function (key) { return obj2.hasOwnProperty(key) && obj1[key] === obj2[key]; }); };
-    /**
-     * Check if a list of decorator ranges are equal to another.
-     *
-     * PERF: this requires the two lists to also have the ranges inside them in the
-     * same order, but this is an okay constraint for us since decorations are
-     * kept in order, and the odd case where they aren't is okay to re-render for.
-     */
-    var isDecoratorRangeListEqual = function (list, another) {
-        if (list.length !== another.length) {
-            return false;
-        }
-        for (var i = 0; i < list.length; i++) {
-            var range = list[i];
-            var other = another[i];
-            var rangeAnchor = range.anchor, rangeFocus = range.focus, rangeOwnProps = __rest(range, ["anchor", "focus"]);
-            var otherAnchor = other.anchor, otherFocus = other.focus, otherOwnProps = __rest(other, ["anchor", "focus"]);
-            if (!slate.Range.equals(range, other) ||
-                range[PLACEHOLDER_SYMBOL] !== other[PLACEHOLDER_SYMBOL] ||
-                !shallowCompare(rangeOwnProps, otherOwnProps)) {
-                return false;
-            }
-        }
-        return true;
-    };
-
-    var isValid = function (value) { return (slate.Element.isElement(value) &&
-        value.children.length > 0 &&
-        value.children.every(function (child) { return isValid(child); })) ||
-        slate.Text.isText(value); };
-    var check = function (document) {
-        return document.every(function (value) { return slate.Element.isElement(value) && isValid(value); });
-        ;
-    };
-    function normalize(document) {
-        return document.filter(function (value) { return slate.Element.isElement(value) && isValid(value); });
-    }
-
-    /**
-     * Utilities for single-line deletion
-     */
-    var doRectsIntersect = function (rect, compareRect) {
-        var middle = (compareRect.top + compareRect.bottom) / 2;
-        return rect.top <= middle && rect.bottom >= middle;
-    };
-    var areRangesSameLine = function (editor, range1, range2) {
-        var rect1 = AngularEditor.toDOMRange(editor, range1).getBoundingClientRect();
-        var rect2 = AngularEditor.toDOMRange(editor, range2).getBoundingClientRect();
-        return doRectsIntersect(rect1, rect2) && doRectsIntersect(rect2, rect1);
-    };
-    /**
-     * A helper utility that returns the end portion of a `Range`
-     * which is located on a single line.
-     *
-     * @param {Editor} editor The editor object to compare against
-     * @param {Range} parentRange The parent range to compare against
-     * @returns {Range} A valid portion of the parentRange which is one a single line
-     */
-    var findCurrentLineRange = function (editor, parentRange) {
-        var parentRangeBoundary = slate.Editor.range(editor, slate.Range.end(parentRange));
-        var positions = Array.from(slate.Editor.positions(editor, { at: parentRange }));
-        var left = 0;
-        var right = positions.length;
-        var middle = Math.floor(right / 2);
-        if (areRangesSameLine(editor, slate.Editor.range(editor, positions[left]), parentRangeBoundary)) {
-            return slate.Editor.range(editor, positions[left], parentRangeBoundary);
-        }
-        if (positions.length < 2) {
-            return slate.Editor.range(editor, positions[positions.length - 1], parentRangeBoundary);
-        }
-        while (middle !== positions.length && middle !== left) {
-            if (areRangesSameLine(editor, slate.Editor.range(editor, positions[middle]), parentRangeBoundary)) {
-                right = middle;
-            }
-            else {
-                left = middle;
-            }
-            middle = Math.floor((left + right) / 2);
-        }
-        return slate.Editor.range(editor, positions[right], parentRangeBoundary);
-    };
-
-    var withAngular = function (editor, clipboardFormatKey) {
-        if (clipboardFormatKey === void 0) { clipboardFormatKey = 'x-slate-fragment'; }
-        var e = editor;
-        var apply = e.apply, onChange = e.onChange, deleteBackward = e.deleteBackward;
-        e.deleteBackward = function (unit) {
-            if (unit !== 'line') {
-                return deleteBackward(unit);
-            }
-            if (editor.selection && slate.Range.isCollapsed(editor.selection)) {
-                var parentBlockEntry = slate.Editor.above(editor, {
-                    match: function (n) { return slate.Editor.isBlock(editor, n); },
-                    at: editor.selection,
-                });
-                if (parentBlockEntry) {
-                    var _a = __read(parentBlockEntry, 2), parentBlockPath = _a[1];
-                    var parentElementRange = slate.Editor.range(editor, parentBlockPath, editor.selection.anchor);
-                    var currentLineRange = findCurrentLineRange(e, parentElementRange);
-                    if (!slate.Range.isCollapsed(currentLineRange)) {
-                        slate.Transforms.delete(editor, { at: currentLineRange });
-                    }
-                }
-            }
-        };
-        e.apply = function (op) {
-            var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e;
-            var matches = [];
-            switch (op.type) {
-                case 'insert_text':
-                case 'remove_text':
-                case 'set_node': {
-                    try {
-                        for (var _f = __values(slate.Editor.levels(e, { at: op.path })), _g = _f.next(); !_g.done; _g = _f.next()) {
-                            var _h = __read(_g.value, 2), node = _h[0], path = _h[1];
-                            var key = AngularEditor.findKey(e, node);
-                            matches.push([path, key]);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    break;
-                }
-                case 'insert_node':
-                case 'remove_node':
-                case 'merge_node':
-                case 'split_node': {
-                    try {
-                        for (var _j = __values(slate.Editor.levels(e, {
-                            at: slate.Path.parent(op.path),
-                        })), _k = _j.next(); !_k.done; _k = _j.next()) {
-                            var _l = __read(_k.value, 2), node = _l[0], path = _l[1];
-                            var key = AngularEditor.findKey(e, node);
-                            matches.push([path, key]);
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    break;
-                }
-                case 'move_node': {
-                    var commonPath = slate.Path.common(slate.Path.parent(op.path), slate.Path.parent(op.newPath));
-                    try {
-                        for (var _m = __values(slate.Editor.levels(e, { at: slate.Path.parent(op.path) })), _o = _m.next(); !_o.done; _o = _m.next()) {
-                            var _p = __read(_o.value, 2), node = _p[0], path = _p[1];
-                            var key = AngularEditor.findKey(e, node);
-                            matches.push([slate.Editor.pathRef(editor, path), key]);
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    try {
-                        for (var _q = __values(slate.Editor.levels(e, { at: slate.Path.parent(op.newPath) })), _r = _q.next(); !_r.done; _r = _q.next()) {
-                            var _s = __read(_r.value, 2), node = _s[0], path = _s[1];
-                            if (path.length > commonPath.length) {
-                                var key = AngularEditor.findKey(e, node);
-                                matches.push([slate.Editor.pathRef(editor, path), key]);
-                            }
-                        }
-                    }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
-                        try {
-                            if (_r && !_r.done && (_d = _q.return)) _d.call(_q);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                    }
-                    break;
-                }
-            }
-            apply(op);
-            try {
-                for (var matches_1 = __values(matches), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
-                    var _t = __read(matches_1_1.value, 2), source = _t[0], key = _t[1];
-                    var _u = __read(slate.Editor.node(e, slate.Path.isPath(source) ? source : source.current), 1), node = _u[0];
-                    NODE_TO_KEY.set(node, key);
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (matches_1_1 && !matches_1_1.done && (_e = matches_1.return)) _e.call(matches_1);
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-        };
-        e.onChange = function () {
-            var onContextChange = EDITOR_TO_ON_CHANGE.get(e);
-            if (onContextChange) {
-                onContextChange();
-            }
-            onChange();
-        };
-        e.setFragmentData = function (data) {
-            var selection = e.selection;
-            if (!selection) {
-                return;
-            }
-            var _a = __read(slate.Range.edges(selection), 2), start = _a[0], end = _a[1];
-            var startVoid = slate.Editor.void(e, { at: start.path });
-            var endVoid = slate.Editor.void(e, { at: end.path });
-            if (slate.Range.isCollapsed(selection) && !startVoid) {
-                return;
-            }
-            // Create a fake selection so that we can add a Base64-encoded copy of the
-            // fragment to the HTML, to decode on future pastes.
-            var domRange = AngularEditor.toDOMRange(e, selection);
-            var contents = domRange.cloneContents();
-            var attach = contents.childNodes[0];
-            // Make sure attach is non-empty, since empty nodes will not get copied.
-            var contentsArray = Array.from(contents.children);
-            contentsArray.forEach(function (node) {
-                if (node.textContent && node.textContent.trim() !== '') {
-                    attach = node;
-                }
-            });
-            // COMPAT: If the end node is a void node, we need to move the end of the
-            // range from the void node's spacer span, to the end of the void node's
-            // content, since the spacer is before void's content in the DOM.
-            if (endVoid) {
-                var _b = __read(endVoid, 1), voidNode = _b[0];
-                var r = domRange.cloneRange();
-                var domNode = AngularEditor.toDOMNode(e, voidNode);
-                r.setEndAfter(domNode);
-                contents = r.cloneContents();
-            }
-            // COMPAT: If the start node is a void node, we need to attach the encoded
-            // fragment to the void node's content node instead of the spacer, because
-            // attaching it to empty `<div>/<span>` nodes will end up having it erased by
-            // most browsers. (2018/04/27)
-            if (startVoid) {
-                attach = contents.querySelector('[data-slate-spacer]');
-            }
-            // Remove any zero-width space spans from the cloned DOM so that they don't
-            // show up elsewhere when pasted.
-            Array.from(contents.querySelectorAll('[data-slate-zero-width]')).forEach(function (zw) {
-                var isNewline = zw.getAttribute('data-slate-zero-width') === 'n';
-                zw.textContent = isNewline ? '\n' : '';
-            });
-            // Set a `data-slate-fragment` attribute on a non-empty node, so it shows up
-            // in the HTML, and can be used for intra-Slate pasting. If it's a text
-            // node, wrap it in a `<span>` so we have something to set an attribute on.
-            if (isDOMText(attach)) {
-                var span = attach.ownerDocument.createElement('span');
-                // COMPAT: In Chrome and Safari, if we don't add the `white-space` style
-                // then leading and trailing spaces will be ignored. (2017/09/21)
-                span.style.whiteSpace = 'pre';
-                span.appendChild(attach);
-                contents.appendChild(span);
-                attach = span;
-            }
-            var fragment = e.getFragment();
-            var stringObj = JSON.stringify(fragment);
-            var encoded = window.btoa(encodeURIComponent(stringObj));
-            attach.setAttribute('data-slate-fragment', encoded);
-            data.setData("application/" + clipboardFormatKey, encoded);
-            // Add the content to a <div> so that we can get its inner HTML.
-            var div = contents.ownerDocument.createElement('div');
-            div.appendChild(contents);
-            div.setAttribute('hidden', 'true');
-            contents.ownerDocument.body.appendChild(div);
-            data.setData('text/html', div.innerHTML);
-            data.setData('text/plain', getPlainText(div));
-            contents.ownerDocument.body.removeChild(div);
-            return data;
-        };
-        e.deleteCutData = function () {
-            var selection = editor.selection;
-            if (selection) {
-                if (slate.Range.isExpanded(selection)) {
-                    slate.Editor.deleteFragment(editor);
-                }
-                else {
-                    var node = slate.Node.parent(editor, selection.anchor.path);
-                    if (slate.Editor.isVoid(editor, node)) {
-                        slate.Transforms.delete(editor);
-                    }
-                }
-            }
-        };
-        e.insertData = function (data) {
-            if (!e.insertFragmentData(data)) {
-                e.insertTextData(data);
-            }
-        };
-        e.insertFragmentData = function (data) {
-            /**
-             * Checking copied fragment from application/x-slate-fragment or data-slate-fragment
-             */
-            var fragment = data.getData("application/" + clipboardFormatKey) ||
-                getSlateFragmentAttribute(data);
-            if (fragment) {
-                var decoded = decodeURIComponent(window.atob(fragment));
-                var parsed = JSON.parse(decoded);
-                e.insertFragment(parsed);
-                return true;
-            }
-            return false;
-        };
-        e.insertTextData = function (data) {
-            var e_6, _a;
-            var text = data.getData('text/plain');
-            if (text) {
-                var lines = text.split(/\r\n|\r|\n/);
-                var split = false;
-                try {
-                    for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                        var line = lines_1_1.value;
-                        if (split) {
-                            slate.Transforms.splitNodes(e, { always: true });
-                        }
-                        e.insertText(line);
-                        split = true;
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
-                    }
-                    finally { if (e_6) throw e_6.error; }
-                }
-                return true;
-            }
-            return false;
-        };
-        e.onKeydown = function () { };
-        e.onClick = function () { };
-        e.isBlockCard = function (element) { return false; };
-        e.onError = function (errorData) {
-            if (errorData.nativeError) {
-                console.error(errorData.nativeError);
-            }
-            else {
-                console.error(errorData);
-            }
-        };
-        return e;
-    };
-
-    var TOP_BLUR = 'blur';
-    var TOP_COMPOSITION_END = 'compositionend';
-    var TOP_COMPOSITION_START = 'compositionstart';
-    var TOP_COMPOSITION_UPDATE = 'compositionupdate';
-    var TOP_KEY_DOWN = 'keydown';
-    var TOP_KEY_PRESS = 'keypress';
-    var TOP_KEY_UP = 'keyup';
-    var TOP_MOUSE_DOWN = 'mousedown';
-    var TOP_MOUSE_MOVE = 'mousemove';
-    var TOP_MOUSE_OUT = 'mouseout';
-    var TOP_TEXT_INPUT = 'textInput';
-    var TOP_PASTE = 'paste';
-
-    /**
-     * Copyright (c) Facebook, Inc. and its affiliates.
-     *
-     * This source code is licensed under the MIT license found in the
-     * LICENSE file in the root directory of this source tree.
-     */
-    /**
-     * These variables store information about text content of a target node,
-     * allowing comparison of content before and after a given event.
-     *
-     * Identify the node where selection currently begins, then observe
-     * both its text content and its current position in the DOM. Since the
-     * browser may natively replace the target node during composition, we can
-     * use its position to find its replacement.
-     *
-     *
-     */
-    var root = null;
-    var startText = null;
-    var fallbackText = null;
-    function initialize(nativeEventTarget) {
-        root = nativeEventTarget;
-        startText = getText();
-        return true;
-    }
-    function reset() {
-        root = null;
-        startText = null;
-        fallbackText = null;
-    }
-    function getData() {
-        if (fallbackText) {
-            return fallbackText;
-        }
-        var start;
-        var startValue = startText;
-        var startLength = startValue.length;
-        var end;
-        var endValue = getText();
-        var endLength = endValue.length;
-        for (start = 0; start < startLength; start++) {
-            if (startValue[start] !== endValue[start]) {
-                break;
-            }
-        }
-        var minEnd = startLength - start;
-        for (end = 1; end <= minEnd; end++) {
-            if (startValue[startLength - end] !== endValue[endLength - end]) {
-                break;
-            }
-        }
-        var sliceTail = end > 1 ? 1 - end : undefined;
-        fallbackText = endValue.slice(start, sliceTail);
-        return fallbackText;
-    }
-    function getText() {
-        if ('value' in root) {
-            return root.value;
-        }
-        return root.textContent;
-    }
-
-    /**
-     * Copyright (c) Facebook, Inc. and its affiliates.
-     *
-     * This source code is licensed under the MIT license found in the
-     * LICENSE file in the root directory of this source tree.
-     */
-    var canUseDOM = !!(typeof window !== 'undefined' &&
-        typeof window.document !== 'undefined' &&
-        typeof window.document.createElement !== 'undefined');
-    var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
-    var START_KEYCODE = 229;
-    var canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;
-    var documentMode = null;
-    if (canUseDOM && 'documentMode' in document) {
-        documentMode = document.documentMode;
-    }
-    // Webkit offers a very useful `textInput` event that can be used to
-    // directly represent `beforeInput`. The IE `textinput` event is not as
-    // useful, so we don't use it.
-    var canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode;
-    // In IE9+, we have access to composition events, but the data supplied
-    // by the native compositionend event may be incorrect. Japanese ideographic
-    // spaces, for instance (\u3000) are not recorded correctly.
-    var useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || (documentMode && documentMode > 8 && documentMode <= 11));
-    var SPACEBAR_CODE = 32;
-    var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
-    // Events and their corresponding property names.
-    var eventTypes = {
-        beforeInput: {
-            phasedRegistrationNames: {
-                bubbled: 'onBeforeInput',
-                captured: 'onBeforeInputCapture'
-            },
-            dependencies: [TOP_COMPOSITION_END, TOP_KEY_PRESS, TOP_TEXT_INPUT, TOP_PASTE]
-        }
-    };
-    // Track whether we've ever handled a keypress on the space key.
-    var hasSpaceKeypress = false;
-    /**
-     * Return whether a native keypress event is assumed to be a command.
-     * This is required because Firefox fires `keypress` events for key commands
-     * (cut, copy, select-all, etc.) even though no character is inserted.
-     */
-    function isKeypressCommand(nativeEvent) {
-        return ((nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
-            // ctrlKey && altKey is equivalent to AltGr, and is not a command.
-            !(nativeEvent.ctrlKey && nativeEvent.altKey));
-    }
-    /**
-     * Does our fallback mode think that this event is the end of composition?
-     *
-     */
-    function isFallbackCompositionEnd(topLevelType, nativeEvent) {
-        switch (topLevelType) {
-            case TOP_KEY_UP:
-                // Command keys insert or clear IME input.
-                return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
-            case TOP_KEY_DOWN:
-                // Expect IME keyCode on each keydown. If we get any other
-                // code we must have exited earlier.
-                return nativeEvent.keyCode !== START_KEYCODE;
-            case TOP_KEY_PRESS:
-            case TOP_MOUSE_DOWN:
-            case TOP_BLUR:
-                // Events are not possible without cancelling IME.
-                return true;
-            default:
-                return false;
-        }
-    }
-    /**
-     * Google Input Tools provides composition data via a CustomEvent,
-     * with the `data` property populated in the `detail` object. If this
-     * is available on the event object, use it. If not, this is a plain
-     * composition event and we have nothing special to extract.
-     *
-     */
-    function getDataFromCustomEvent(nativeEvent) {
-        var detail = nativeEvent.detail;
-        if (typeof detail === 'object' && 'data' in detail) {
-            return detail.data;
-        }
-        return null;
-    }
-    /**
-     * Check if a composition event was triggered by Korean IME.
-     * Our fallback mode does not work well with IE's Korean IME,
-     * so just use native composition events when Korean IME is used.
-     * Although CompositionEvent.locale property is deprecated,
-     * it is available in IE, where our fallback mode is enabled.
-     *
-     */
-    function isUsingKoreanIME(nativeEvent) {
-        return nativeEvent.locale === 'ko';
-    }
-    // Track the current IME composition status, if any.
-    var isComposing = false;
-    function getNativeBeforeInputChars(topLevelType, nativeEvent) {
-        switch (topLevelType) {
-            case TOP_COMPOSITION_END:
-                return getDataFromCustomEvent(nativeEvent);
-            case TOP_KEY_PRESS:
-                /**
-                 * If native `textInput` events are available, our goal is to make
-                 * use of them. However, there is a special case: the spacebar key.
-                 * In Webkit, preventing default on a spacebar `textInput` event
-                 * cancels character insertion, but it *also* causes the browser
-                 * to fall back to its default spacebar behavior of scrolling the
-                 * page.
-                 *
-                 * Tracking at:
-                 * https://code.google.com/p/chromium/issues/detail?id=355103
-                 *
-                 * To avoid this issue, use the keypress event as if no `textInput`
-                 * event is available.
-                 */
-                var which = nativeEvent.which;
-                if (which !== SPACEBAR_CODE) {
-                    return null;
-                }
-                hasSpaceKeypress = true;
-                return SPACEBAR_CHAR;
-            case TOP_TEXT_INPUT:
-                // Record the characters to be added to the DOM.
-                var chars = nativeEvent.data;
-                // If it's a spacebar character, assume that we have already handled
-                // it at the keypress level and bail immediately. Android Chrome
-                // doesn't give us keycodes, so we need to ignore it.
-                if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
-                    return null;
-                }
-                return chars;
-            default:
-                // For other native event types, do nothing.
-                return null;
-        }
-    }
-    /**
-     * For browsers that do not provide the `textInput` event, extract the
-     * appropriate string to use for SyntheticInputEvent.
-     *
-     */
-    function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
-        // If we are currently composing (IME) and using a fallback to do so,
-        // try to extract the composed characters from the fallback object.
-        // If composition event is available, we extract a string only at
-        // compositionevent, otherwise extract it at fallback events.
-        if (isComposing) {
-            if (topLevelType === TOP_COMPOSITION_END || (!canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent))) {
-                var chars = getData();
-                reset();
-                isComposing = false;
-                return chars;
-            }
-            return null;
-        }
-        switch (topLevelType) {
-            case TOP_PASTE:
-                // If a paste event occurs after a keypress, throw out the input
-                // chars. Paste events should not lead to BeforeInput events.
-                return null;
-            case TOP_KEY_PRESS:
-                /**
-                 * As of v27, Firefox may fire keypress events even when no character
-                 * will be inserted. A few possibilities:
-                 *
-                 * - `which` is `0`. Arrow keys, Esc key, etc.
-                 *
-                 * - `which` is the pressed key code, but no char is available.
-                 *   Ex: 'AltGr + d` in Polish. There is no modified character for
-                 *   this key combination and no character is inserted into the
-                 *   document, but FF fires the keypress for char code `100` anyway.
-                 *   No `input` event will occur.
-                 *
-                 * - `which` is the pressed key code, but a command combination is
-                 *   being used. Ex: `Cmd+C`. No character is inserted, and no
-                 *   `input` event will occur.
-                 */
-                if (!isKeypressCommand(nativeEvent)) {
-                    // IE fires the `keypress` event when a user types an emoji via
-                    // Touch keyboard of Windows.  In such a case, the `char` property
-                    // holds an emoji character like `\uD83D\uDE0A`.  Because its length
-                    // is 2, the property `which` does not represent an emoji correctly.
-                    // In such a case, we directly return the `char` property instead of
-                    // using `which`.
-                    if (nativeEvent.char && nativeEvent.char.length > 1) {
-                        return nativeEvent.char;
-                    }
-                    else if (nativeEvent.which) {
-                        return String.fromCharCode(nativeEvent.which);
-                    }
-                }
-                return null;
-            case TOP_COMPOSITION_END:
-                return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;
-            default:
-                return null;
-        }
-    }
-    /**
-     * Extract a SyntheticInputEvent for `beforeInput`, based on either native
-     * `textInput` or fallback behavior.
-     *
-     */
-    function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        var chars;
-        if (canUseTextInputEvent) {
-            chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
-        }
-        else {
-            chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
-        }
-        // If no characters are being inserted, no BeforeInput event should
-        // be fired.
-        if (!chars) {
-            return null;
-        }
-        var beforeInputEvent = new BeforeInputEvent();
-        beforeInputEvent.data = chars;
-        beforeInputEvent.nativeEvent = nativeEvent;
-        return beforeInputEvent;
-    }
-    /**
-     * Create an `onBeforeInput` event to match
-     * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
-     *
-     * This event plugin is based on the native `textInput` event
-     * available in Chrome, Safari, Opera, and IE. This event fires after
-     * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
-     *
-     * `beforeInput` is spec'd but not implemented in any browsers, and
-     * the `input` event does not provide any useful information about what has
-     * actually been added, contrary to the spec. Thus, `textInput` is the best
-     * available event to identify the characters that have actually been inserted
-     * into the target node.
-     *
-     * This plugin is also responsible for emitting `composition` events, thus
-     * allowing us to share composition fallback code for both `beforeInput` and
-     * `composition` event types.
-     */
-    var BeforeInputEventPlugin = {
-        extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-            return extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-        }
-    };
-    var BeforeInputEvent = /** @class */ (function () {
-        function BeforeInputEvent() {
-        }
-        return BeforeInputEvent;
-    }());
-
-    var BEFORE_INPUT_EVENTS = [
-        // { name: 'blur', handler: 'onBlur', isTriggerBeforeInput: true },
-        // { name: 'compositionstart', handler: 'onCompositionStart', isTriggerBeforeInput: true },
-        { name: 'compositionupdate', handler: null, isTriggerBeforeInput: true },
-        // { name: 'compositionend', handler: 'onCompositionEnd', isTriggerBeforeInput: false },
-        // { name: 'keydown', handler: 'onKeyDown', isTriggerBeforeInput: true },
-        { name: 'keypress', handler: null, isTriggerBeforeInput: true },
-        { name: 'keyup', handler: 'onKeyUp', isTriggerBeforeInput: true },
-        { name: 'mousedown', handler: 'onMouseDown', isTriggerBeforeInput: true },
-        { name: 'textInput', handler: null, isTriggerBeforeInput: true },
-        // { name: 'paste', handler: 'onPaste', isTriggerBeforeInput: true }
-    ];
-
-    exports.SlateErrorCode = void 0;
-    (function (SlateErrorCode) {
-        SlateErrorCode[SlateErrorCode["ToNativeSelectionError"] = 2100] = "ToNativeSelectionError";
-        SlateErrorCode[SlateErrorCode["ToSlateSelectionError"] = 2101] = "ToSlateSelectionError";
-        SlateErrorCode[SlateErrorCode["OnDOMBeforeInputError"] = 2102] = "OnDOMBeforeInputError";
-        SlateErrorCode[SlateErrorCode["OnSyntheticBeforeInputError"] = 2103] = "OnSyntheticBeforeInputError";
-        SlateErrorCode[SlateErrorCode["OnDOMKeydownError"] = 2104] = "OnDOMKeydownError";
-        SlateErrorCode[SlateErrorCode["GetStartPointError"] = 2105] = "GetStartPointError";
-        SlateErrorCode[SlateErrorCode["NotFoundPreviousRootNodeError"] = 3100] = "NotFoundPreviousRootNodeError";
-        SlateErrorCode[SlateErrorCode["InvalidValueError"] = 4100] = "InvalidValueError";
-    })(exports.SlateErrorCode || (exports.SlateErrorCode = {}));
-
-    var SlateBlockCardComponent = /** @class */ (function () {
-        function SlateBlockCardComponent(elementRef) {
-            this.elementRef = elementRef;
-        }
-        Object.defineProperty(SlateBlockCardComponent.prototype, "nativeElement", {
-            get: function () {
-                return this.elementRef.nativeElement;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(SlateBlockCardComponent.prototype, "centerContainerElement", {
-            get: function () {
-                return this.centerContianer.nativeElement;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        SlateBlockCardComponent.prototype.ngOnInit = function () {
-            this.append();
-            this.nativeElement.classList.add("slate-block-card");
-        };
-        SlateBlockCardComponent.prototype.append = function () {
-            var _this = this;
-            this.centerRootNodes.forEach(function (rootNode) { return !_this.centerContainerElement.contains(rootNode) && _this.centerContainerElement.appendChild(rootNode); });
-        };
-        SlateBlockCardComponent.prototype.initializeCenter = function (rootNodes) {
-            this.centerRootNodes = rootNodes;
-        };
-        return SlateBlockCardComponent;
-    }());
-    SlateBlockCardComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateBlockCardComponent, deps: [{ token: i0__namespace.ElementRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateBlockCardComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateBlockCardComponent, selector: "slate-block-card, [slateBlockCard]", viewQueries: [{ propertyName: "centerContianer", first: true, predicate: ["centerContianer"], descendants: true, static: true }], ngImport: i0__namespace, template: "<span card-target=\"card-left\" class=\"card-left\">{{  '\\uFEFF' }}</span>\n<div card-target=\"card-center\" #centerContianer></div>\n<span card-target=\"card-right\" class=\"card-right\">{{  '\\uFEFF' }}</span>" });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateBlockCardComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'slate-block-card, [slateBlockCard]',
-                        templateUrl: 'block-card.component.html'
-                    }]
-            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }]; }, propDecorators: { centerContianer: [{
-                    type: i0.ViewChild,
-                    args: ['centerContianer', { static: true }]
-                }] } });
-
-    /**
-     * Dynamically create/update components or templates
-     * Provide rootNodes for the view container
-     * If the dynamically created component uses onpush mode, then it must call markForCheck when setting the context
-     */
-    var ViewContainerItem = /** @class */ (function () {
-        function ViewContainerItem(viewContainerRef, componentFactoryResolver) {
-            this.viewContainerRef = viewContainerRef;
-            this.componentFactoryResolver = componentFactoryResolver;
-            this.initialized = false;
-        }
-        Object.defineProperty(ViewContainerItem.prototype, "rootNodes", {
-            get: function () {
-                return this.getRootNodes();
-            },
-            enumerable: false,
-            configurable: true
-        });
-        ViewContainerItem.prototype.getRootNodes = function () {
-            if (this.embeddedViewRef) {
-                return this.embeddedViewRef.rootNodes.filter(function (rootNode) { return isDOMElement(rootNode); });
-            }
-            if (this.componentRef) {
-                return [this.componentRef.instance.nativeElement];
-            }
-            return [];
-        };
-        ViewContainerItem.prototype.destroyView = function () {
-            if (this.embeddedViewRef) {
-                this.embeddedViewRef.destroy();
-                this.embeddedViewRef = null;
-            }
-            if (this.componentRef) {
-                this.componentRef.destroy();
-                this.componentRef = null;
-            }
-        };
-        ViewContainerItem.prototype.createView = function () {
-            this.initialized = true;
-            this.viewType = this.getViewType();
-            var context = this.getContext();
-            if (isTemplateRef(this.viewType)) {
-                this.embeddedViewContext = { context: context, viewContext: this.viewContext };
-                var embeddedViewRef = this.viewContainerRef.createEmbeddedView(this.viewType, this.embeddedViewContext);
-                this.embeddedViewRef = embeddedViewRef;
-            }
-            if (isComponentType(this.viewType)) {
-                var componentFactory = this.componentFactoryResolver.resolveComponentFactory(this.viewType);
-                var componentRef = this.viewContainerRef.createComponent(componentFactory);
-                componentRef.instance.context = context;
-                componentRef.instance.viewContext = this.viewContext;
-                this.componentRef = componentRef;
-            }
-        };
-        ViewContainerItem.prototype.updateView = function () {
-            var viewType = this.getViewType();
-            var context = this.getContext();
-            if (this.viewType === viewType) {
-                if (this.componentRef) {
-                    if (this.memoizedContext(this.componentRef.instance.context, context)) {
-                        return;
-                    }
-                    this.componentRef.instance.context = context;
-                }
-                if (this.embeddedViewRef) {
-                    if (this.memoizedContext(this.embeddedViewContext.context, context)) {
-                        return;
-                    }
-                    this.embeddedViewContext.context = context;
-                }
-            }
-            else {
-                this.viewType = viewType;
-                var firstRootNode = this.rootNodes[0];
-                if (isTemplateRef(this.viewType)) {
-                    this.embeddedViewContext = { context: context, viewContext: this.viewContext };
-                    var embeddedViewRef = this.viewContainerRef.createEmbeddedView(this.viewType, this.embeddedViewContext);
-                    firstRootNode.replaceWith.apply(firstRootNode, __spreadArray([], __read(embeddedViewRef.rootNodes.filter(function (rootNode) { return isDOMElement(rootNode); }))));
-                    this.destroyView();
-                    this.embeddedViewRef = embeddedViewRef;
-                }
-                if (isComponentType(this.viewType)) {
-                    var componentFactory = this.componentFactoryResolver.resolveComponentFactory(this.viewType);
-                    var componentRef = this.viewContainerRef.createComponent(componentFactory);
-                    componentRef.instance.context = context;
-                    componentRef.instance.viewContext = this.viewContext;
-                    firstRootNode.replaceWith(componentRef.instance.nativeElement);
-                    this.destroyView();
-                    this.componentRef = componentRef;
-                }
-            }
-        };
-        ViewContainerItem.prototype.appendBlockCardElement = function () {
-            if (this.blockCardComponentRef) {
-                this.blockCardComponentRef.instance.append();
-            }
-        };
-        return ViewContainerItem;
-    }());
-    ViewContainerItem.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: ViewContainerItem, deps: [{ token: i0__namespace.ViewContainerRef }, { token: i0__namespace.ComponentFactoryResolver }], target: i0__namespace.ɵɵFactoryTarget.Directive });
-    ViewContainerItem.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.7", type: ViewContainerItem, inputs: { viewContext: "viewContext" }, ngImport: i0__namespace });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: ViewContainerItem, decorators: [{
-                type: i0.Directive
-            }], ctorParameters: function () { return [{ type: i0__namespace.ViewContainerRef }, { type: i0__namespace.ComponentFactoryResolver }]; }, propDecorators: { viewContext: [{
-                    type: i0.Input
-                }] } });
-
-    function hasBeforeContextChange(value) {
-        if (value.beforeContextChange) {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * base class for custom element component or text component
-     */
-    var BaseComponent = /** @class */ (function () {
-        function BaseComponent(elementRef, cdr) {
-            this.elementRef = elementRef;
-            this.cdr = cdr;
-        }
-        Object.defineProperty(BaseComponent.prototype, "context", {
-            get: function () {
-                return this._context;
-            },
-            set: function (value) {
-                if (hasBeforeContextChange(this)) {
-                    this.beforeContextChange(value);
-                }
-                this._context = value;
-                this.onContextChange();
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseComponent.prototype, "editor", {
-            get: function () {
-                return this.viewContext && this.viewContext.editor;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseComponent.prototype, "nativeElement", {
-            get: function () {
-                return this.elementRef.nativeElement;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return BaseComponent;
-    }());
-    BaseComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.ChangeDetectorRef }], target: i0__namespace.ɵɵFactoryTarget.Directive });
-    BaseComponent.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.7", type: BaseComponent, inputs: { context: "context", viewContext: "viewContext" }, ngImport: i0__namespace });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseComponent, decorators: [{
-                type: i0.Directive
-            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.ChangeDetectorRef }]; }, propDecorators: { context: [{
-                    type: i0.Input
-                }], viewContext: [{
-                    type: i0.Input
-                }] } });
-    /**
-     * base class for custom leaf component
-     */
-    var BaseLeafComponent = /** @class */ (function (_super) {
-        __extends(BaseLeafComponent, _super);
-        function BaseLeafComponent() {
-            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this.initialized = false;
-            _this.isSlateLeaf = true;
-            return _this;
-        }
-        Object.defineProperty(BaseLeafComponent.prototype, "text", {
-            get: function () {
-                return this.context && this.context.text;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseLeafComponent.prototype, "leaf", {
-            get: function () {
-                return this.context && this.context.leaf;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        BaseLeafComponent.prototype.ngOnInit = function () {
-            this.initialized = true;
-        };
-        BaseLeafComponent.prototype.onContextChange = function () {
-            if (!this.initialized) {
-                return;
-            }
-            this.cdr.markForCheck();
-        };
-        BaseLeafComponent.prototype.renderPlaceholder = function () {
-            // issue-1: IME input was interrupted
-            // issue-2: IME input focus jumping
-            // Issue occurs when the span node of the placeholder is before the slateString span node
-            if (this.context.leaf['placeholder']) {
-                if (!this.placeholderElement) {
-                    this.placeholderElement = document.createElement('span');
-                    this.placeholderElement.innerText = this.context.leaf['placeholder'];
-                    this.placeholderElement.contentEditable = 'false';
-                    this.placeholderElement.setAttribute('data-slate-placeholder', 'true');
-                    this.nativeElement.classList.add('leaf-with-placeholder');
-                    this.nativeElement.appendChild(this.placeholderElement);
-                }
-            }
-            else {
-                this.destroyPlaceholder();
-            }
-        };
-        BaseLeafComponent.prototype.destroyPlaceholder = function () {
-            if (this.placeholderElement) {
-                this.placeholderElement.remove();
-                this.placeholderElement = null;
-                this.nativeElement.classList.remove('leaf-with-placeholder');
-            }
-        };
-        return BaseLeafComponent;
-    }(BaseComponent));
-    BaseLeafComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseLeafComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Directive });
-    BaseLeafComponent.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.7", type: BaseLeafComponent, host: { properties: { "attr.data-slate-leaf": "this.isSlateLeaf" } }, usesInheritance: true, ngImport: i0__namespace });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseLeafComponent, decorators: [{
-                type: i0.Directive
-            }], propDecorators: { isSlateLeaf: [{
-                    type: i0.HostBinding,
-                    args: ['attr.data-slate-leaf']
-                }] } });
-    /**
-     * base class for custom element component
-     */
-    var BaseElementComponent = /** @class */ (function (_super) {
-        __extends(BaseElementComponent, _super);
-        function BaseElementComponent() {
-            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this.initialized = false;
-            return _this;
-        }
-        Object.defineProperty(BaseElementComponent.prototype, "element", {
-            get: function () {
-                return this._context && this._context.element;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseElementComponent.prototype, "selection", {
-            get: function () {
-                return this._context && this._context.selection;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseElementComponent.prototype, "decorations", {
-            get: function () {
-                return this._context && this._context.decorations;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseElementComponent.prototype, "children", {
-            get: function () {
-                return this._context && this._context.element.children;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseElementComponent.prototype, "isCollapsed", {
-            get: function () {
-                return this.selection && slate.Range.isCollapsed(this.editor.selection);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(BaseElementComponent.prototype, "readonly", {
-            get: function () {
-                return this._context && this._context.readonly;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        BaseElementComponent.prototype.ngOnInit = function () {
-            this.updateWeakMap();
-            for (var key in this._context.attributes) {
-                this.nativeElement.setAttribute(key, this._context.attributes[key]);
-            }
-            this.initialized = true;
-        };
-        BaseElementComponent.prototype.updateWeakMap = function () {
-            NODE_TO_ELEMENT.set(this.element, this.nativeElement);
-            ELEMENT_TO_NODE.set(this.nativeElement, this.element);
-            ELEMENT_TO_COMPONENT.set(this.element, this);
-        };
-        BaseElementComponent.prototype.ngOnDestroy = function () {
-            if (NODE_TO_ELEMENT.get(this.element) === this.nativeElement) {
-                NODE_TO_ELEMENT.delete(this.element);
-            }
-            if (ELEMENT_TO_COMPONENT.get(this.element) === this) {
-                ELEMENT_TO_COMPONENT.delete(this.element);
-            }
-        };
-        BaseElementComponent.prototype.onContextChange = function () {
-            this.childrenContext = this.getChildrenContext();
-            if (!this.initialized) {
-                return;
-            }
-            this.cdr.markForCheck();
-            this.updateWeakMap();
-        };
-        BaseElementComponent.prototype.getChildrenContext = function () {
-            return {
-                parent: this._context.element,
-                selection: this._context.selection,
-                decorations: this._context.decorations,
-                decorate: this._context.decorate,
-                readonly: this._context.readonly
-            };
-        };
-        return BaseElementComponent;
-    }(BaseComponent));
-    BaseElementComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseElementComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Directive });
-    BaseElementComponent.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.7", type: BaseElementComponent, usesInheritance: true, ngImport: i0__namespace });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseElementComponent, decorators: [{
-                type: i0.Directive
-            }] });
-    /**
-     * base class for custom text component
-     */
-    var BaseTextComponent = /** @class */ (function (_super) {
-        __extends(BaseTextComponent, _super);
-        function BaseTextComponent() {
-            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this.initialized = false;
-            return _this;
-        }
-        Object.defineProperty(BaseTextComponent.prototype, "text", {
-            get: function () {
-                return this._context && this._context.text;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        BaseTextComponent.prototype.ngOnInit = function () {
-            this.updateWeakMap();
-            this.initialized = true;
-        };
-        BaseTextComponent.prototype.updateWeakMap = function () {
-            ELEMENT_TO_NODE.set(this.nativeElement, this.text);
-            NODE_TO_ELEMENT.set(this.text, this.nativeElement);
-        };
-        BaseTextComponent.prototype.ngOnDestroy = function () {
-            if (NODE_TO_ELEMENT.get(this.text) === this.nativeElement) {
-                NODE_TO_ELEMENT.delete(this.text);
-            }
-        };
-        BaseTextComponent.prototype.onContextChange = function () {
-            if (!this.initialized) {
-                return;
-            }
-            this.cdr.markForCheck();
-            this.updateWeakMap();
-        };
-        return BaseTextComponent;
-    }(BaseComponent));
-    BaseTextComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseTextComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Directive });
-    BaseTextComponent.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.7", type: BaseTextComponent, usesInheritance: true, ngImport: i0__namespace });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: BaseTextComponent, decorators: [{
-                type: i0.Directive
-            }] });
-
-    /**
-     * the sepcial container for angular template
-     * Add the rootNodes of each child component to the parentElement
-     * Remove useless DOM elements, eg: comment...
-     */
-    var ViewContainer = /** @class */ (function () {
-        function ViewContainer(elementRef, differs) {
-            this.elementRef = elementRef;
-            this.differs = differs;
-        }
-        ViewContainer.prototype.ngAfterViewInit = function () {
-            var _this = this;
-            var differ = this.differs.find(this.childrenComponent).create(function (index, item) {
-                return item;
-            });
-            // first diff
-            differ.diff(this.childrenComponent);
-            var parentElement = this.elementRef.nativeElement.parentElement;
-            if (this.childrenComponent.length > 0) {
-                parentElement.insertBefore(this.createFragment(), this.elementRef.nativeElement);
-                this.elementRef.nativeElement.remove();
-            }
-            this.childrenComponent.changes.subscribe(function (value) {
-                var iterableChanges = differ.diff(_this.childrenComponent);
-                if (iterableChanges) {
-                    iterableChanges.forEachOperation(function (record, previousIndex, currentIndex) {
-                        // removed
-                        if (currentIndex === null) {
-                            return;
-                        }
-                        // added or moved
-                        _this.handleContainerItemChange(record, parentElement);
-                    });
-                }
-            });
-        };
-        ViewContainer.prototype.getPreviousRootNode = function (currentIndex) {
-            if (currentIndex === 0) {
-                return null;
-            }
-            var previousComponent = this.childrenComponent.find(function (item, index) { return index === currentIndex - 1; });
-            var previousRootNode = previousComponent.rootNodes[previousComponent.rootNodes.length - 1];
-            if (previousRootNode) {
-                return previousRootNode;
-            }
-            else {
-                return this.getPreviousRootNode(currentIndex - 1);
-            }
-        };
-        ViewContainer.prototype.createFragment = function () {
-            var fragment = document.createDocumentFragment();
-            this.childrenComponent.forEach(function (component, index) {
-                fragment.append.apply(fragment, __spreadArray([], __read(component.rootNodes)));
-            });
-            return fragment;
-        };
-        ViewContainer.prototype.handleContainerItemChange = function (record, parentElement) {
-            // first insert
-            if (this.elementRef.nativeElement.parentElement && this.elementRef.nativeElement.parentElement === parentElement) {
-                var fragment = document.createDocumentFragment();
-                fragment.append.apply(fragment, __spreadArray([], __read(record.item.rootNodes)));
-                parentElement.insertBefore(fragment, this.elementRef.nativeElement);
-                this.elementRef.nativeElement.remove();
-                return;
-            }
-            // insert at start location
-            if (record.currentIndex === 0) {
-                var fragment = document.createDocumentFragment();
-                fragment.append.apply(fragment, __spreadArray([], __read(record.item.rootNodes)));
-                parentElement.prepend(fragment);
-            }
-            else {
-                // insert afterend of previous component end
-                var previousRootNode_1 = this.getPreviousRootNode(record.currentIndex);
-                if (previousRootNode_1) {
-                    record.item.rootNodes.forEach(function (rootNode) {
-                        previousRootNode_1.insertAdjacentElement('afterend', rootNode);
-                        previousRootNode_1 = rootNode;
-                    });
-                }
-                else {
-                    this.viewContext.editor.onError({
-                        code: exports.SlateErrorCode.NotFoundPreviousRootNodeError,
-                        name: 'not found previous rootNode',
-                        nativeError: null
-                    });
-                }
-            }
-            // Solve the block-card DOMElement loss when moving nodes
-            record.item.appendBlockCardElement();
-        };
-        return ViewContainer;
-    }());
-    ViewContainer.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: ViewContainer, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.IterableDiffers }], target: i0__namespace.ɵɵFactoryTarget.Directive });
-    ViewContainer.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.7", type: ViewContainer, inputs: { viewContext: "viewContext" }, ngImport: i0__namespace });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: ViewContainer, decorators: [{
-                type: i0.Directive
-            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.IterableDiffers }]; }, propDecorators: { viewContext: [{
-                    type: i0.Input
-                }] } });
-
-    var SlateStringComponent = /** @class */ (function (_super) {
-        __extends(SlateStringComponent, _super);
-        function SlateStringComponent(elementRef, viewContainerRef) {
-            var _this = _super.call(this, viewContainerRef, null) || this;
-            _this.elementRef = elementRef;
-            _this.viewContainerRef = viewContainerRef;
-            return _this;
-        }
-        SlateStringComponent.prototype.ngOnInit = function () {
-            this.createView();
-        };
-        SlateStringComponent.prototype.ngOnChanges = function () {
-            if (!this.initialized) {
-                return;
-            }
-            this.updateView();
-        };
-        SlateStringComponent.prototype.ngAfterViewInit = function () {
-            this.elementRef.nativeElement.remove();
-        };
-        SlateStringComponent.prototype.getViewType = function () {
-            var path = AngularEditor.findPath(this.viewContext.editor, this.context.text);
-            var parentPath = slate.Path.parent(path);
-            // COMPAT: Render text inside void nodes with a zero-width space.
-            // So the node can contain selection but the text is not visible.
-            if (this.viewContext.editor.isVoid(this.context.parent)) {
-                return this.viewContext.templateComponent.emptyStringTemplate;
-            }
-            // COMPAT: If this is the last text node in an empty block, render a zero-
-            // width space that will convert into a line break when copying and pasting
-            // to support expected plain text.
-            if (this.context.leaf.text === '' &&
-                this.context.parent.children[this.context.parent.children.length - 1] === this.context.text &&
-                !this.viewContext.editor.isInline(this.context.parent) &&
-                slate.Editor.string(this.viewContext.editor, parentPath) === '') {
-                return this.viewContext.templateComponent.lineBreakEmptyStringTemplate;
-            }
-            // COMPAT: If the text is empty, it's because it's on the edge of an inline
-            // node, so we render a zero-width space so that the selection can be
-            // inserted next to it still.
-            if (this.context.leaf.text === '') {
-                return this.viewContext.templateComponent.emptyTextTemplate;
-            }
-            // COMPAT: Browsers will collapse trailing new lines at the end of blocks,
-            // so we need to add an extra trailing new lines to prevent that.
-            if (this.context.isLast && this.context.leaf.text.slice(-1) === '\n') {
-                return this.viewContext.templateComponent.compatStringTemplate;
-            }
-            return this.viewContext.templateComponent.stringTemplate;
-        };
-        SlateStringComponent.prototype.getContext = function () {
-            return { text: this.context.leaf.text, elementStringLength: slate.Node.string(this.context.parent).length };
-        };
-        SlateStringComponent.prototype.memoizedContext = function (prev, next) {
-            return false;
-        };
-        return SlateStringComponent;
-    }(ViewContainerItem));
-    SlateStringComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateStringComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.ViewContainerRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateStringComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateStringComponent, selector: "span[slateString]", inputs: { context: "context" }, usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: '', isInline: true, changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateStringComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'span[slateString]',
-                        template: '',
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.ViewContainerRef }]; }, propDecorators: { context: [{
-                    type: i0.Input
-                }] } });
-
-    var SlateDefaultLeafComponent = /** @class */ (function (_super) {
-        __extends(SlateDefaultLeafComponent, _super);
-        function SlateDefaultLeafComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        SlateDefaultLeafComponent.prototype.onContextChange = function () {
-            _super.prototype.onContextChange.call(this);
-            this.renderPlaceholder();
-        };
-        SlateDefaultLeafComponent.prototype.ngOnDestroy = function () {
-            // Because the placeholder span is not in the current component, it is destroyed along with the current component
-            this.destroyPlaceholder();
-        };
-        return SlateDefaultLeafComponent;
-    }(BaseLeafComponent));
-    SlateDefaultLeafComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDefaultLeafComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateDefaultLeafComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateDefaultLeafComponent, selector: "span[slateDefaultLeaf]", host: { attributes: { "data-slate-leaf": "true" } }, usesInheritance: true, ngImport: i0__namespace, template: "<span slateString [context]=\"context\" [viewContext]=\"viewContext\"><span>", isInline: true, components: [{ type: SlateStringComponent, selector: "span[slateString]", inputs: ["context"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDefaultLeafComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'span[slateDefaultLeaf]',
-                        template: "<span slateString [context]=\"context\" [viewContext]=\"viewContext\"><span>",
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
-                        host: {
-                            'data-slate-leaf': 'true'
-                        }
-                    }]
-            }] });
-
-    var SlateLeafComponent = /** @class */ (function (_super) {
-        __extends(SlateLeafComponent, _super);
-        function SlateLeafComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        SlateLeafComponent.prototype.ngOnInit = function () {
-            this.createView();
-        };
-        SlateLeafComponent.prototype.getContext = function () {
-            return this.context;
-        };
-        SlateLeafComponent.prototype.getViewType = function () {
-            return this.viewContext.renderLeaf && this.viewContext.renderLeaf(this.context.leaf) || SlateDefaultLeafComponent;
-        };
-        SlateLeafComponent.prototype.memoizedContext = function (prev, next) {
-            return false;
-        };
-        SlateLeafComponent.prototype.ngOnChanges = function (simpleChanges) {
-            if (!this.initialized) {
-                return;
-            }
-            this.updateView();
-        };
-        return SlateLeafComponent;
-    }(ViewContainerItem));
-    SlateLeafComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateLeafComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateLeafComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateLeafComponent, selector: "slate-leaf", inputs: { context: "context" }, usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: '', isInline: true, changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateLeafComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'slate-leaf',
-                        template: '',
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
-                    }]
-            }], propDecorators: { context: [{
-                    type: i0.Input
-                }] } });
-
-    var SlateLeavesComponent = /** @class */ (function (_super) {
-        __extends(SlateLeavesComponent, _super);
-        function SlateLeavesComponent() {
-            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this.initialized = false;
-            return _this;
-        }
-        SlateLeavesComponent.prototype.ngOnInit = function () {
-            this.leaves = slate.Text.decorations(this.context.text, this.context.decorations);
-            this.leafContexts = this.getLeafCotexts();
-            this.initialized = true;
-        };
-        SlateLeavesComponent.prototype.getLeafCotexts = function () {
-            var _this = this;
-            return this.leaves.map(function (leaf, index) {
-                return {
-                    leaf: leaf,
-                    text: _this.context.text,
-                    parent: _this.context.parent,
-                    index: index,
-                    isLast: _this.context.isLast && index === _this.leaves.length - 1
-                };
-            });
-        };
-        SlateLeavesComponent.prototype.ngOnChanges = function (simpleChanges) {
-            if (!this.initialized) {
-                return;
-            }
-            var context = simpleChanges['context'];
-            var previousValue = context.previousValue;
-            var currentValue = context.currentValue;
-            if (previousValue.text !== currentValue.text || !isDecoratorRangeListEqual(previousValue.decorations, currentValue.decorations)) {
-                this.leaves = slate.Text.decorations(this.context.text, this.context.decorations);
-            }
-            this.leafContexts = this.getLeafCotexts();
-        };
-        SlateLeavesComponent.prototype.trackBy = function (index, item) {
-            return index;
-        };
-        return SlateLeavesComponent;
-    }(ViewContainer));
-    SlateLeavesComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateLeavesComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateLeavesComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateLeavesComponent, selector: "slate-leaves", inputs: { context: "context" }, viewQueries: [{ propertyName: "childrenComponent", predicate: SlateLeafComponent, descendants: true, read: SlateLeafComponent }], usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: "<slate-leaf\n                    [context]=\"context\" [viewContext]=\"viewContext\"\n                    [viewContext]=\"viewContext\"\n                    *ngFor=\"let context of leafContexts; trackBy: trackBy\"></slate-leaf>\n    ", isInline: true, components: [{ type: SlateLeafComponent, selector: "slate-leaf", inputs: ["context"] }], directives: [{ type: i2__namespace.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateLeavesComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'slate-leaves',
-                        template: "<slate-leaf\n                    [context]=\"context\" [viewContext]=\"viewContext\"\n                    [viewContext]=\"viewContext\"\n                    *ngFor=\"let context of leafContexts; trackBy: trackBy\"></slate-leaf>\n    ",
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }], propDecorators: { context: [{
-                    type: i0.Input
-                }], childrenComponent: [{
-                    type: i0.ViewChildren,
-                    args: [SlateLeafComponent, { read: SlateLeafComponent }]
-                }] } });
-
-    var SlateDefaultTextComponent = /** @class */ (function (_super) {
-        __extends(SlateDefaultTextComponent, _super);
-        function SlateDefaultTextComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return SlateDefaultTextComponent;
-    }(BaseTextComponent));
-    SlateDefaultTextComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDefaultTextComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateDefaultTextComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateDefaultTextComponent, selector: "span[slateDefaultText]", host: { attributes: { "data-slate-node": "text" } }, usesInheritance: true, ngImport: i0__namespace, template: "<slate-leaves [context]=\"context\" [viewContext]=\"viewContext\" [viewContext]=\"viewContext\"></slate-leaves>", isInline: true, components: [{ type: SlateLeavesComponent, selector: "slate-leaves", inputs: ["context"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDefaultTextComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'span[slateDefaultText]',
-                        template: "<slate-leaves [context]=\"context\" [viewContext]=\"viewContext\" [viewContext]=\"viewContext\"></slate-leaves>",
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
-                        host: {
-                            'data-slate-node': 'text'
-                        }
-                    }]
-            }] });
-
-    var SlateVoidTextComponent = /** @class */ (function (_super) {
-        __extends(SlateVoidTextComponent, _super);
-        function SlateVoidTextComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        SlateVoidTextComponent.prototype.ngOnInit = function () {
-            this.isLeafBlock = AngularEditor.isLeafBlock(this.viewContext.editor, this.context.parent);
-            _super.prototype.ngOnInit.call(this);
-        };
-        SlateVoidTextComponent.prototype.ngOnChanges = function () {
-            if (!this.initialized) {
-                return;
-            }
-            this.isLeafBlock = AngularEditor.isLeafBlock(this.viewContext.editor, this.context.parent);
-        };
-        return SlateVoidTextComponent;
-    }(BaseTextComponent));
-    SlateVoidTextComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateVoidTextComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateVoidTextComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateVoidTextComponent, selector: "span[slateVoidText]", host: { attributes: { "data-slate-spacer": "true", "data-slate-node": "text" }, properties: { "attr.contenteditable": "isLeafBlock" }, classAttribute: "slate-spacer" }, usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: "<slate-leaves [context]=\"context\" [viewContext]=\"viewContext\" [viewContext]=\"viewContext\"></slate-leaves>", isInline: true, components: [{ type: SlateLeavesComponent, selector: "slate-leaves", inputs: ["context"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateVoidTextComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'span[slateVoidText]',
-                        template: "<slate-leaves [context]=\"context\" [viewContext]=\"viewContext\" [viewContext]=\"viewContext\"></slate-leaves>",
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
-                        host: {
-                            '[attr.contenteditable]': 'isLeafBlock',
-                            'data-slate-spacer': "true",
-                            'class': 'slate-spacer',
-                            'data-slate-node': 'text'
-                        }
-                    }]
-            }] });
-
-    var SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN = new i0.InjectionToken('slate-default-element-token');
-
-    var SlateDescendantComponent = /** @class */ (function (_super) {
-        __extends(SlateDescendantComponent, _super);
-        function SlateDescendantComponent(viewContainerRef, componentFactoryResolver, defaultElementComponentType) {
-            var _this = _super.call(this, viewContainerRef, componentFactoryResolver) || this;
-            _this.viewContainerRef = viewContainerRef;
-            _this.componentFactoryResolver = componentFactoryResolver;
-            _this.defaultElementComponentType = defaultElementComponentType;
-            return _this;
-        }
-        Object.defineProperty(SlateDescendantComponent.prototype, "rootNodes", {
-            get: function () {
-                if (this.blockCardComponentRef) {
-                    return [this.blockCardComponentRef.instance.nativeElement];
-                }
-                return _super.prototype.getRootNodes.call(this);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(SlateDescendantComponent.prototype, "isBlockCard", {
-            get: function () {
-                return this.viewContext.editor.isBlockCard(this.descendant);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        SlateDescendantComponent.prototype.ngOnInit = function () {
-            NODE_TO_INDEX.set(this.descendant, this.index);
-            NODE_TO_PARENT.set(this.descendant, this.context.parent);
-            this.createView();
-            if (this.isBlockCard) {
-                this.createBlockCard();
-            }
-        };
-        SlateDescendantComponent.prototype.destroyView = function () {
-            _super.prototype.destroyView.call(this);
-            this.destroyBlockCard();
-        };
-        SlateDescendantComponent.prototype.ngOnChanges = function () {
-            if (!this.initialized) {
-                return;
-            }
-            NODE_TO_INDEX.set(this.descendant, this.index);
-            NODE_TO_PARENT.set(this.descendant, this.context.parent);
-            this.updateView();
-            if (this.isBlockCard) {
-                this.updateBlockCard();
-            }
-        };
-        SlateDescendantComponent.prototype.destroyBlockCard = function () {
-            if (this.blockCardComponentRef) {
-                this.blockCardComponentRef.destroy();
-                this.blockCardComponentRef = null;
-            }
-        };
-        SlateDescendantComponent.prototype.createBlockCard = function () {
-            var rootNodes = this.rootNodes;
-            var componentFactory = this.componentFactoryResolver.resolveComponentFactory(SlateBlockCardComponent);
-            this.blockCardComponentRef = this.viewContainerRef.createComponent(componentFactory, null, null);
-            this.blockCardComponentRef.instance.initializeCenter(rootNodes);
-        };
-        SlateDescendantComponent.prototype.updateBlockCard = function () {
-            if (this.blockCardComponentRef) {
-                return;
-            }
-            var rootNodes = this.rootNodes;
-            this.createBlockCard();
-            var firstRootNode = rootNodes[0];
-            firstRootNode.replaceWith(this.blockCardComponentRef.instance.nativeElement);
-        };
-        SlateDescendantComponent.prototype.getCommonContext = function () {
-            var e_1, _a;
-            var path = AngularEditor.findPath(this.viewContext.editor, this.context.parent);
-            var p = path.concat(this.index);
-            try {
-                var range = slate.Editor.range(this.viewContext.editor, p);
-                var sel = this.context.selection && slate.Range.intersection(range, this.context.selection);
-                var ds = this.context.decorate([this.descendant, p]);
-                try {
-                    for (var _b = __values(this.context.decorations), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var dec = _c.value;
-                        var d = slate.Range.intersection(dec, range);
-                        if (d) {
-                            ds.push(d);
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                return { selection: sel, decorations: ds };
-            }
-            catch (error) {
-                this.viewContext.editor.onError({ code: exports.SlateErrorCode.GetStartPointError, nativeError: error });
-                return { selection: null, decorations: [] };
-            }
-        };
-        SlateDescendantComponent.prototype.getContext = function () {
-            if (slate.Element.isElement(this.descendant)) {
-                var computedContext = this.getCommonContext();
-                var key = AngularEditor.findKey(this.viewContext.editor, this.descendant);
-                var isInline = this.viewContext.editor.isInline(this.descendant);
-                var isVoid = this.viewContext.editor.isVoid(this.descendant);
-                var elementContext = Object.assign(Object.assign({ element: this.descendant }, computedContext), { attributes: {
-                        'data-slate-node': 'element',
-                        'data-slate-key': key.id
-                    }, decorate: this.context.decorate, readonly: this.context.readonly });
-                if (isInline) {
-                    elementContext.attributes['data-slate-inline'] = true;
-                }
-                if (isVoid) {
-                    elementContext.attributes['data-slate-void'] = true;
-                    elementContext.attributes.contenteditable = false;
-                }
-                return elementContext;
-            }
-            else {
-                var computedContext = this.getCommonContext();
-                var isLeafBlock = AngularEditor.isLeafBlock(this.viewContext.editor, this.context.parent);
-                var textContext = {
-                    decorations: computedContext.decorations,
-                    isLast: isLeafBlock && this.index === this.context.parent.children.length - 1,
-                    parent: this.context.parent,
-                    text: this.descendant
-                };
-                return textContext;
-            }
-        };
-        SlateDescendantComponent.prototype.getViewType = function () {
-            if (slate.Element.isElement(this.descendant)) {
-                return (this.viewContext.renderElement && this.viewContext.renderElement(this.descendant)) || this.defaultElementComponentType;
-            }
-            else {
-                var isVoid = this.viewContext.editor.isVoid(this.context.parent);
-                return isVoid ? SlateVoidTextComponent : (this.viewContext.renderText && this.viewContext.renderText(this.descendant)) || SlateDefaultTextComponent;
-            }
-        };
-        SlateDescendantComponent.prototype.memoizedElementContext = function (prev, next) {
-            return (prev.element === next.element &&
-                (!this.viewContext.isStrictDecorate || prev.decorate === next.decorate) &&
-                prev.readonly === next.readonly &&
-                isDecoratorRangeListEqual(prev.decorations, next.decorations) &&
-                (prev.selection === next.selection ||
-                    (!!prev.selection &&
-                        !!next.selection &&
-                        slate.Range.equals(prev.selection, next.selection))));
-        };
-        SlateDescendantComponent.prototype.memoizedTextContext = function (prev, next) {
-            return (next.parent === prev.parent &&
-                next.isLast === prev.isLast &&
-                next.text === prev.text &&
-                isDecoratorRangeListEqual(next.decorations, prev.decorations));
-        };
-        SlateDescendantComponent.prototype.memoizedContext = function (prev, next) {
-            if (slate.Element.isElement(this.descendant)) {
-                return this.memoizedElementContext(prev, next);
-            }
-            else {
-                return this.memoizedTextContext(prev, next);
-            }
-        };
-        return SlateDescendantComponent;
-    }(ViewContainerItem));
-    SlateDescendantComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDescendantComponent, deps: [{ token: i0__namespace.ViewContainerRef }, { token: i0__namespace.ComponentFactoryResolver }, { token: SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN }], target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateDescendantComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateDescendantComponent, selector: "slate-descendant", inputs: { descendant: "descendant", context: "context", viewContext: "viewContext", index: "index" }, usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: '', isInline: true, changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDescendantComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'slate-descendant',
-                        template: '',
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }], ctorParameters: function () {
-            return [{ type: i0__namespace.ViewContainerRef }, { type: i0__namespace.ComponentFactoryResolver }, { type: undefined, decorators: [{
-                            type: i0.Inject,
-                            args: [SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN]
-                        }] }];
-        }, propDecorators: { descendant: [{
-                    type: i0.Input
-                }], context: [{
-                    type: i0.Input
-                }], viewContext: [{
-                    type: i0.Input
-                }], index: [{
-                    type: i0.Input
-                }] } });
-
-    var SlateChildrenComponent = /** @class */ (function (_super) {
-        __extends(SlateChildrenComponent, _super);
-        function SlateChildrenComponent() {
-            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this.trackBy = function (index, node) {
-                return _this.viewContext.trackBy(node) || AngularEditor.findKey(_this.viewContext.editor, node);
-            };
-            return _this;
-        }
-        SlateChildrenComponent.prototype.ngOnInit = function () {
-        };
-        return SlateChildrenComponent;
-    }(ViewContainer));
-    SlateChildrenComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateChildrenComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateChildrenComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateChildrenComponent, selector: "slate-children", inputs: { children: "children", context: "context", viewContext: "viewContext" }, viewQueries: [{ propertyName: "childrenComponent", predicate: SlateDescendantComponent, descendants: true, read: SlateDescendantComponent }], usesInheritance: true, ngImport: i0__namespace, template: "<slate-descendant \n                    [descendant]=\"descendant\"\n                    [context]=\"context\" [viewContext]=\"viewContext\"\n                    [viewContext]=\"viewContext\"\n                    [index]=\"index\"\n                    *ngFor=\"let descendant of children;let index = index; trackBy: trackBy\"></slate-descendant>", isInline: true, components: [{ type: SlateDescendantComponent, selector: "slate-descendant", inputs: ["descendant", "context", "viewContext", "index"] }], directives: [{ type: i2__namespace.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateChildrenComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'slate-children',
-                        template: "<slate-descendant \n                    [descendant]=\"descendant\"\n                    [context]=\"context\" [viewContext]=\"viewContext\"\n                    [viewContext]=\"viewContext\"\n                    [index]=\"index\"\n                    *ngFor=\"let descendant of children;let index = index; trackBy: trackBy\"></slate-descendant>",
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }], propDecorators: { children: [{
-                    type: i0.Input
-                }], context: [{
-                    type: i0.Input
-                }], viewContext: [{
-                    type: i0.Input
-                }], childrenComponent: [{
-                    type: i0.ViewChildren,
-                    args: [SlateDescendantComponent, { read: SlateDescendantComponent }]
-                }] } });
-
-    var SlateStringTemplateComponent = /** @class */ (function () {
-        function SlateStringTemplateComponent() {
-        }
-        return SlateStringTemplateComponent;
-    }());
-    SlateStringTemplateComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateStringTemplateComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateStringTemplateComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateStringTemplateComponent, selector: "slate-string-template", viewQueries: [{ propertyName: "stringTemplate", first: true, predicate: ["stringTemplate"], descendants: true, read: i0.TemplateRef, static: true }, { propertyName: "compatStringTemplate", first: true, predicate: ["compatStringTemplate"], descendants: true, read: i0.TemplateRef, static: true }, { propertyName: "emptyStringTemplate", first: true, predicate: ["emptyStringTemplate"], descendants: true, read: i0.TemplateRef, static: true }, { propertyName: "emptyTextTemplate", first: true, predicate: ["emptyTextTemplate"], descendants: true, read: i0.TemplateRef, static: true }, { propertyName: "lineBreakEmptyStringTemplate", first: true, predicate: ["lineBreakEmptyStringTemplate"], descendants: true, read: i0.TemplateRef, static: true }], ngImport: i0__namespace, template: "<ng-template #stringTemplate let-context=\"context\" let-viewContext=\"viewContext\">\n    <span editable-text data-slate-string=\"true\">{{ context.text }}</span>\n</ng-template>\n<ng-template #compatStringTemplate let-context=\"context\" let-viewContext=\"viewContext\">\n    <!-- Compatible with Chinese input in Chrome with \\n -->\n    <span editable-text data-slate-string=\"true\">{{ context.text }}<span data-slate-zero-width>{{'\\uFEFF'}}</span></span>\n</ng-template>\n<ng-template #emptyStringTemplate let-context=\"context\" let-viewContext=\"viewContext\">\n    <span editable-text data-slate-zero-width=\"z\" attr.data-slate-length=\"{{ context.elementStringLength }}\">{{ '\\uFEFF' }}</span>\n</ng-template>\n<ng-template #emptyTextTemplate let-context=\"context\" let-viewContext=\"viewContext\">\n    <span editable-text data-slate-zero-width=\"z\" data-slate-length=\"0\">{{ '\\uFEFF' }}</span>\n</ng-template>\n<ng-template #lineBreakEmptyStringTemplate let-context=\"context\" let-viewContext=\"viewContext\">\n    <span editable-text data-slate-zero-width=\"n\" attr.data-slate-length=\"{{ context.elementStringLength }}\">{{ '\\uFEFF'\n        }}<br /></span>\n</ng-template>", changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateStringTemplateComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'slate-string-template',
-                        templateUrl: 'template.component.html',
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }], propDecorators: { stringTemplate: [{
-                    type: i0.ViewChild,
-                    args: ['stringTemplate', { read: i0.TemplateRef, static: true }]
-                }], compatStringTemplate: [{
-                    type: i0.ViewChild,
-                    args: ['compatStringTemplate', { read: i0.TemplateRef, static: true }]
-                }], emptyStringTemplate: [{
-                    type: i0.ViewChild,
-                    args: ['emptyStringTemplate', { read: i0.TemplateRef, static: true }]
-                }], emptyTextTemplate: [{
-                    type: i0.ViewChild,
-                    args: ['emptyTextTemplate', { read: i0.TemplateRef, static: true }]
-                }], lineBreakEmptyStringTemplate: [{
-                    type: i0.ViewChild,
-                    args: ['lineBreakEmptyStringTemplate', { read: i0.TemplateRef, static: true }]
-                }] } });
-
-    var timeDebug = Debug__default["default"]('slate-angular-time');
-    // not correctly clipboardData on beforeinput
-    var forceOnDOMPaste = IS_SAFARI;
-    var SlateEditableComponent = /** @class */ (function () {
-        function SlateEditableComponent(elementRef, renderer2, cdr, ngZone, injector) {
-            this.elementRef = elementRef;
-            this.renderer2 = renderer2;
-            this.cdr = cdr;
-            this.ngZone = ngZone;
-            this.injector = injector;
-            this.destroy$ = new rxjs.Subject();
-            this.isComposing = false;
-            this.isDraggingInternally = false;
-            this.isUpdatingSelection = false;
-            this.latestElement = null;
-            this.manualListeners = [];
-            this.onTouchedCallback = function () { };
-            this.onChangeCallback = function () { };
-            this.decorate = function () { return []; };
-            this.isStrictDecorate = true;
-            this.trackBy = function () { return 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;
-        }
-        Object.defineProperty(SlateEditableComponent.prototype, "hasBeforeInputSupport", {
-            get: function () {
-                return HAS_BEFORE_INPUT_SUPPORT;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        SlateEditableComponent.prototype.ngOnInit = function () {
-            var _this = this;
-            this.editor.injector = this.injector;
-            this.editor.children = [];
-            var 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, function () {
-                _this.ngZone.run(function () {
-                    _this.onChange();
-                });
-            });
-            this.ngZone.runOutsideAngular(function () {
-                _this.initialize();
-            });
-            this.initializeViewContext();
-            this.initializeContext();
-            // remove unused DOM, just keep templateComponent instance
-            this.templateElementRef.nativeElement.remove();
-            // add browser class
-            var browserClass = IS_FIREFOX ? 'firefox' : (IS_SAFARI ? 'safari' : '');
-            browserClass && this.elementRef.nativeElement.classList.add(browserClass);
-        };
-        SlateEditableComponent.prototype.ngOnChanges = function (simpleChanges) {
-            if (!this.initialized) {
-                return;
-            }
-            var decorateChange = simpleChanges['decorate'];
-            if (decorateChange) {
-                this.forceFlush();
-            }
-            var readonlyChange = simpleChanges['readonly'];
-            if (readonlyChange) {
-                IS_READONLY.set(this.editor, this.readonly);
-                this.detectContext();
-                this.toSlateSelection();
-            }
-        };
-        SlateEditableComponent.prototype.registerOnChange = function (fn) {
-            this.onChangeCallback = fn;
-        };
-        SlateEditableComponent.prototype.registerOnTouched = function (fn) {
-            this.onTouchedCallback = fn;
-        };
-        SlateEditableComponent.prototype.writeValue = function (value) {
-            if (value && value.length) {
-                if (check(value)) {
-                    this.editor.children = value;
-                }
-                else {
-                    this.editor.onError({
-                        code: exports.SlateErrorCode.InvalidValueError,
-                        name: 'initialize invalid data',
-                        data: value
-                    });
-                    this.editor.children = normalize(value);
-                }
-                this.initializeContext();
-                this.cdr.markForCheck();
-            }
-        };
-        SlateEditableComponent.prototype.initialize = function () {
-            var _this = this;
-            this.initialized = true;
-            var window = AngularEditor.getWindow(this.editor);
-            this.addEventListener('selectionchange', function (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('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(function (event) {
-                _this.addEventListener(event.name, function () { });
-            });
-        };
-        SlateEditableComponent.prototype.toNativeSelection = function () {
-            var _this = this;
-            try {
-                var selection = this.editor.selection;
-                var root = AngularEditor.findDocumentOrShadowRoot(this.editor);
-                var domSelection = root.getSelection();
-                if (this.isComposing || !domSelection || !AngularEditor.isFocused(this.editor)) {
-                    return;
-                }
-                var 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
-                var editorElement = EDITOR_TO_ELEMENT.get(this.editor);
-                var 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) &&
-                    slate.Range.equals(AngularEditor.toSlateRange(this.editor, domSelection), selection)) {
-                    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.
-                var el_1 = AngularEditor.toDOMNode(this.editor, this.editor);
-                this.isUpdatingSelection = true;
-                var newDomRange_1 = selection && AngularEditor.toDOMRange(this.editor, selection);
-                if (newDomRange_1) {
-                    // COMPAT: Since the DOM range has no concept of backwards/forwards
-                    // we need to check and do the right thing here.
-                    if (slate.Range.isBackward(selection)) {
-                        // eslint-disable-next-line max-len
-                        domSelection.setBaseAndExtent(newDomRange_1.endContainer, newDomRange_1.endOffset, newDomRange_1.startContainer, newDomRange_1.startOffset);
-                    }
-                    else {
-                        // eslint-disable-next-line max-len
-                        domSelection.setBaseAndExtent(newDomRange_1.startContainer, newDomRange_1.startOffset, newDomRange_1.endContainer, newDomRange_1.endOffset);
-                    }
-                }
-                else {
-                    domSelection.removeAllRanges();
-                }
-                setTimeout(function () {
-                    // 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_1 && IS_FIREFOX) {
-                        el_1.focus();
-                    }
-                    _this.isUpdatingSelection = false;
-                });
-            }
-            catch (error) {
-                this.editor.onError({ code: exports.SlateErrorCode.ToNativeSelectionError, nativeError: error });
-            }
-        };
-        SlateEditableComponent.prototype.onChange = function () {
-            this.forceFlush();
-            this.onChangeCallback(this.editor.children);
-        };
-        SlateEditableComponent.prototype.ngAfterViewChecked = function () {
-            timeDebug('editable ngAfterViewChecked');
-        };
-        SlateEditableComponent.prototype.ngDoCheck = function () {
-            timeDebug('editable ngDoCheck');
-        };
-        SlateEditableComponent.prototype.forceFlush = function () {
-            var _this = this;
-            timeDebug('start data sync');
-            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(function () {
-                    var textNode = slate.Node.get(_this.editor, _this.editor.selection.anchor.path);
-                    var textDOMNode = AngularEditor.toDOMNode(_this.editor, textNode);
-                    var textContent = '';
-                    // skip decorate text
-                    textDOMNode.querySelectorAll('[editable-text]').forEach(function (stringDOMNode) {
-                        var text = stringDOMNode.textContent;
-                        var 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 (slate.Node.string(textNode).endsWith(textContent)) {
-                        _this.isComposing = false;
-                    }
-                }, 0);
-            }
-            this.toNativeSelection();
-            timeDebug('end data sync');
-        };
-        SlateEditableComponent.prototype.initializeContext = function () {
-            this.context = {
-                parent: this.editor,
-                selection: this.editor.selection,
-                decorations: this.generateDecorations(),
-                decorate: this.decorate,
-                readonly: this.readonly
-            };
-        };
-        SlateEditableComponent.prototype.initializeViewContext = function () {
-            this.viewContext = {
-                editor: this.editor,
-                renderElement: this.renderElement,
-                renderLeaf: this.renderLeaf,
-                renderText: this.renderText,
-                trackBy: this.trackBy,
-                isStrictDecorate: this.isStrictDecorate,
-                templateComponent: this.templateComponent
-            };
-        };
-        SlateEditableComponent.prototype.detectContext = function () {
-            var 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
-                };
-            }
-        };
-        SlateEditableComponent.prototype.composePlaceholderDecorate = function (editor) {
-            if (this.placeholderDecorate) {
-                return this.placeholderDecorate(editor) || [];
-            }
-            if (this.placeholder &&
-                editor.children.length === 1 &&
-                Array.from(slate.Node.texts(editor)).length === 1 &&
-                slate.Node.string(editor) === '') {
-                var start = slate.Editor.start(editor, []);
-                return [
-                    {
-                        placeholder: this.placeholder,
-                        anchor: start,
-                        focus: start,
-                    },
-                ];
-            }
-            else {
-                return [];
-            }
-        };
-        SlateEditableComponent.prototype.generateDecorations = function () {
-            var decorations = this.decorate([this.editor, []]);
-            var placeholderDecorations = this.isComposing
-                ? []
-                : this.composePlaceholderDecorate(this.editor);
-            decorations.push.apply(decorations, __spreadArray([], __read(placeholderDecorations)));
-            return decorations;
-        };
-        //#region event proxy
-        SlateEditableComponent.prototype.addEventListener = function (eventName, listener, target) {
-            var _this = this;
-            if (target === void 0) { target = this.elementRef.nativeElement; }
-            this.manualListeners.push(this.renderer2.listen(target, eventName, function (event) {
-                var beforeInputEvent = extractBeforeInputEvent(event.type, null, event, event.target);
-                if (beforeInputEvent) {
-                    _this.onFallbackBeforeInput(beforeInputEvent);
-                }
-                listener(event);
-            }));
-        };
-        SlateEditableComponent.prototype.toSlateSelection = function () {
-            if (!this.readonly && !this.isComposing && !this.isUpdatingSelection && !this.isDraggingInternally) {
-                try {
-                    var root = AngularEditor.findDocumentOrShadowRoot(this.editor);
-                    var activeElement = root.activeElement;
-                    var el = AngularEditor.toDOMNode(this.editor, this.editor);
-                    var domSelection = root.getSelection();
-                    if (activeElement === el || hasEditableTarget(this.editor, activeElement)) {
-                        this.latestElement = activeElement;
-                        IS_FOCUSED.set(this.editor, true);
-                    }
-                    else {
-                        IS_FOCUSED.delete(this.editor);
-                    }
-                    if (!domSelection) {
-                        return slate.Transforms.deselect(this.editor);
-                    }
-                    var editorElement = EDITOR_TO_ELEMENT.get(this.editor);
-                    var hasDomSelectionInEditor = editorElement.contains(domSelection.anchorNode) && editorElement.contains(domSelection.focusNode);
-                    if (!hasDomSelectionInEditor) {
-                        slate.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
-                    var range = AngularEditor.toSlateRange(this.editor, domSelection);
-                    if (this.editor.selection && slate.Range.equals(range, this.editor.selection) && !hasStringTarget(domSelection)) {
-                        // force adjust DOMSelection
-                        this.toNativeSelection();
-                    }
-                    else {
-                        slate.Transforms.select(this.editor, range);
-                    }
-                }
-                catch (error) {
-                    this.editor.onError({ code: exports.SlateErrorCode.ToSlateSelectionError, nativeError: error });
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMBeforeInput = function (event) {
-            var editor = this.editor;
-            if (!this.readonly && hasEditableTarget(editor, event.target) && !this.isDOMEventHandled(event, this.beforeInput)) {
-                try {
-                    var selection = editor.selection;
-                    var type = event.inputType;
-                    var data = event.dataTransfer || event.data || undefined;
-                    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 && slate.Range.isExpanded(selection) && type.startsWith('delete')) {
-                        var direction = type.endsWith('Backward') ? 'backward' : 'forward';
-                        slate.Editor.deleteFragment(editor, { direction: direction });
-                        return;
-                    }
-                    switch (type) {
-                        case 'deleteByComposition':
-                        case 'deleteByCut':
-                        case 'deleteByDrag': {
-                            slate.Editor.deleteFragment(editor);
-                            break;
-                        }
-                        case 'deleteContent':
-                        case 'deleteContentForward': {
-                            slate.Editor.deleteForward(editor);
-                            break;
-                        }
-                        case 'deleteContentBackward': {
-                            slate.Editor.deleteBackward(editor);
-                            break;
-                        }
-                        case 'deleteEntireSoftLine': {
-                            slate.Editor.deleteBackward(editor, { unit: 'line' });
-                            slate.Editor.deleteForward(editor, { unit: 'line' });
-                            break;
-                        }
-                        case 'deleteHardLineBackward': {
-                            slate.Editor.deleteBackward(editor, { unit: 'block' });
-                            break;
-                        }
-                        case 'deleteSoftLineBackward': {
-                            slate.Editor.deleteBackward(editor, { unit: 'line' });
-                            break;
-                        }
-                        case 'deleteHardLineForward': {
-                            slate.Editor.deleteForward(editor, { unit: 'block' });
-                            break;
-                        }
-                        case 'deleteSoftLineForward': {
-                            slate.Editor.deleteForward(editor, { unit: 'line' });
-                            break;
-                        }
-                        case 'deleteWordBackward': {
-                            slate.Editor.deleteBackward(editor, { unit: 'word' });
-                            break;
-                        }
-                        case 'deleteWordForward': {
-                            slate.Editor.deleteForward(editor, { unit: 'word' });
-                            break;
-                        }
-                        case 'insertLineBreak':
-                        case 'insertParagraph': {
-                            slate.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 === null || data === void 0 ? void 0 : data.constructor.name) === 'DataTransfer') {
-                                AngularEditor.insertData(editor, data);
-                            }
-                            else if (typeof data === 'string') {
-                                slate.Editor.insertText(editor, data);
-                            }
-                            break;
-                        }
-                    }
-                }
-                catch (error) {
-                    this.editor.onError({ code: exports.SlateErrorCode.OnDOMBeforeInputError, nativeError: error });
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMBlur = function (event) {
-            if (this.readonly ||
-                this.isUpdatingSelection ||
-                !hasEditableTarget(this.editor, event.target) ||
-                this.isDOMEventHandled(event, this.blur)) {
-                return;
-            }
-            var 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.
-            var root = AngularEditor.findDocumentOrShadowRoot(this.editor);
-            if (this.latestElement === root.activeElement) {
-                return;
-            }
-            var relatedTarget = event.relatedTarget;
-            var 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)) {
-                var node = AngularEditor.toSlateNode(this.editor, relatedTarget);
-                if (slate.Element.isElement(node) && !this.editor.isVoid(node)) {
-                    return;
-                }
-            }
-            IS_FOCUSED.delete(this.editor);
-        };
-        SlateEditableComponent.prototype.onDOMClick = function (event) {
-            if (!this.readonly &&
-                hasTarget(this.editor, event.target) &&
-                !this.isDOMEventHandled(event, this.click) &&
-                isDOMNode(event.target)) {
-                var node = AngularEditor.toSlateNode(this.editor, event.target);
-                var path = AngularEditor.findPath(this.editor, node);
-                var start = slate.Editor.start(this.editor, path);
-                var end = slate.Editor.end(this.editor, path);
-                var startVoid = slate.Editor.void(this.editor, { at: start });
-                var endVoid = slate.Editor.void(this.editor, { at: end });
-                if (startVoid && endVoid && slate.Path.equals(startVoid[1], endVoid[1])) {
-                    var range = slate.Editor.range(this.editor, start);
-                    slate.Transforms.select(this.editor, range);
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMCompositionEnd = function (event) {
-            if (!event.data && !slate.Range.isCollapsed(this.editor.selection)) {
-                slate.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 && event.data) {
-                    preventInsertFromComposition(event, this.editor);
-                    slate.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();
-        };
-        SlateEditableComponent.prototype.onDOMCompositionStart = function (event) {
-            var selection = this.editor.selection;
-            if (selection) {
-                // solve the problem of cross node Chinese input
-                if (slate.Range.isExpanded(selection)) {
-                    slate.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();
-        };
-        SlateEditableComponent.prototype.onDOMCopy = function (event) {
-            var window = AngularEditor.getWindow(this.editor);
-            var isOutsideSlate = !hasStringTarget(window.getSelection()) && isTargetInsideVoid(this.editor, event.target);
-            if (!isOutsideSlate && hasTarget(this.editor, event.target) && !this.readonly && !this.isDOMEventHandled(event, this.copy)) {
-                event.preventDefault();
-                AngularEditor.setFragmentData(this.editor, event.clipboardData, 'copy');
-            }
-        };
-        SlateEditableComponent.prototype.onDOMCut = function (event) {
-            if (!this.readonly && hasEditableTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.cut)) {
-                event.preventDefault();
-                AngularEditor.setFragmentData(this.editor, event.clipboardData, 'cut');
-                var selection = this.editor.selection;
-                if (selection) {
-                    AngularEditor.deleteCutData(this.editor);
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMDragOver = function (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.
-                var node = AngularEditor.toSlateNode(this.editor, event.target);
-                if (slate.Editor.isVoid(this.editor, node)) {
-                    event.preventDefault();
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMDragStart = function (event) {
-            if (!this.readonly && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragStart)) {
-                var node = AngularEditor.toSlateNode(this.editor, event.target);
-                var path = AngularEditor.findPath(this.editor, node);
-                var voidMatch = slate.Editor.isVoid(this.editor, node) ||
-                    slate.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) {
-                    var range = slate.Editor.range(this.editor, path);
-                    slate.Transforms.select(this.editor, range);
-                }
-                this.isDraggingInternally = true;
-                AngularEditor.setFragmentData(this.editor, event.dataTransfer, 'drag');
-            }
-        };
-        SlateEditableComponent.prototype.onDOMDrop = function (event) {
-            var 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
-                var draggedRange = editor.selection;
-                // Find the range where the drop happened
-                var range = AngularEditor.findEventRange(editor, event);
-                var data = event.dataTransfer;
-                slate.Transforms.select(editor, range);
-                if (this.isDraggingInternally) {
-                    if (draggedRange) {
-                        slate.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);
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMDragEnd = function (event) {
-            if (!this.readonly && this.isDraggingInternally && hasTarget(this.editor, event.target) && !this.isDOMEventHandled(event, this.dragEnd)) {
-                this.isDraggingInternally = false;
-            }
-        };
-        SlateEditableComponent.prototype.onDOMFocus = function (event) {
-            if (!this.readonly &&
-                !this.isUpdatingSelection &&
-                hasEditableTarget(this.editor, event.target) &&
-                !this.isDOMEventHandled(event, this.focus)) {
-                var el = AngularEditor.toDOMNode(this.editor, this.editor);
-                var 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);
-            }
-        };
-        SlateEditableComponent.prototype.onDOMKeydown = function (event) {
-            var editor = this.editor;
-            if (!this.readonly &&
-                hasEditableTarget(editor, event.target) &&
-                !this.isComposing &&
-                !this.isDOMEventHandled(event, this.keydown)) {
-                var nativeEvent = event;
-                var selection = editor.selection;
-                var element = editor.children[selection !== null ? selection.focus.path[0] : 0];
-                var isRTL = getDirection__default["default"](slate.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 (slateHistory.HistoryEditor.isHistoryEditor(editor)) {
-                            editor.redo();
-                        }
-                        return;
-                    }
-                    if (hotkeys.isUndo(nativeEvent)) {
-                        event.preventDefault();
-                        if (slateHistory.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();
-                        slate.Transforms.move(editor, { unit: 'line', reverse: true });
-                        return;
-                    }
-                    if (hotkeys.isMoveLineForward(nativeEvent)) {
-                        event.preventDefault();
-                        slate.Transforms.move(editor, { unit: 'line' });
-                        return;
-                    }
-                    if (hotkeys.isExtendLineBackward(nativeEvent)) {
-                        event.preventDefault();
-                        slate.Transforms.move(editor, {
-                            unit: 'line',
-                            edge: 'focus',
-                            reverse: true
-                        });
-                        return;
-                    }
-                    if (hotkeys.isExtendLineForward(nativeEvent)) {
-                        event.preventDefault();
-                        slate.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 && slate.Range.isCollapsed(selection)) {
-                            slate.Transforms.move(editor, { reverse: !isRTL });
-                        }
-                        else {
-                            slate.Transforms.collapse(editor, { edge: 'start' });
-                        }
-                        return;
-                    }
-                    if (hotkeys.isMoveForward(nativeEvent)) {
-                        event.preventDefault();
-                        if (selection && slate.Range.isCollapsed(selection)) {
-                            slate.Transforms.move(editor, { reverse: isRTL });
-                        }
-                        else {
-                            slate.Transforms.collapse(editor, { edge: 'end' });
-                        }
-                        return;
-                    }
-                    if (hotkeys.isMoveWordBackward(nativeEvent)) {
-                        event.preventDefault();
-                        if (selection && slate.Range.isExpanded(selection)) {
-                            slate.Transforms.collapse(editor, { edge: 'focus' });
-                        }
-                        slate.Transforms.move(editor, { unit: 'word', reverse: !isRTL });
-                        return;
-                    }
-                    if (hotkeys.isMoveWordForward(nativeEvent)) {
-                        event.preventDefault();
-                        if (selection && slate.Range.isExpanded(selection)) {
-                            slate.Transforms.collapse(editor, { edge: 'focus' });
-                        }
-                        slate.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();
-                            slate.Editor.insertBreak(editor);
-                            return;
-                        }
-                        if (hotkeys.isDeleteBackward(nativeEvent)) {
-                            event.preventDefault();
-                            if (selection && slate.Range.isExpanded(selection)) {
-                                slate.Editor.deleteFragment(editor, { direction: 'backward' });
-                            }
-                            else {
-                                slate.Editor.deleteBackward(editor);
-                            }
-                            return;
-                        }
-                        if (hotkeys.isDeleteForward(nativeEvent)) {
-                            event.preventDefault();
-                            if (selection && slate.Range.isExpanded(selection)) {
-                                slate.Editor.deleteFragment(editor, { direction: 'forward' });
-                            }
-                            else {
-                                slate.Editor.deleteForward(editor);
-                            }
-                            return;
-                        }
-                        if (hotkeys.isDeleteLineBackward(nativeEvent)) {
-                            event.preventDefault();
-                            if (selection && slate.Range.isExpanded(selection)) {
-                                slate.Editor.deleteFragment(editor, { direction: 'backward' });
-                            }
-                            else {
-                                slate.Editor.deleteBackward(editor, { unit: 'line' });
-                            }
-                            return;
-                        }
-                        if (hotkeys.isDeleteLineForward(nativeEvent)) {
-                            event.preventDefault();
-                            if (selection && slate.Range.isExpanded(selection)) {
-                                slate.Editor.deleteFragment(editor, { direction: 'forward' });
-                            }
-                            else {
-                                slate.Editor.deleteForward(editor, { unit: 'line' });
-                            }
-                            return;
-                        }
-                        if (hotkeys.isDeleteWordBackward(nativeEvent)) {
-                            event.preventDefault();
-                            if (selection && slate.Range.isExpanded(selection)) {
-                                slate.Editor.deleteFragment(editor, { direction: 'backward' });
-                            }
-                            else {
-                                slate.Editor.deleteBackward(editor, { unit: 'word' });
-                            }
-                            return;
-                        }
-                        if (hotkeys.isDeleteWordForward(nativeEvent)) {
-                            event.preventDefault();
-                            if (selection && slate.Range.isExpanded(selection)) {
-                                slate.Editor.deleteFragment(editor, { direction: 'forward' });
-                            }
-                            else {
-                                slate.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)) &&
-                                slate.Range.isCollapsed(selection)) {
-                                var currentNode = slate.Node.parent(editor, selection.anchor.path);
-                                if (slate.Element.isElement(currentNode) &&
-                                    slate.Editor.isVoid(editor, currentNode) &&
-                                    slate.Editor.isInline(editor, currentNode)) {
-                                    event.preventDefault();
-                                    slate.Editor.deleteBackward(editor, { unit: 'block' });
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    this.editor.onError({ code: exports.SlateErrorCode.OnDOMKeydownError, nativeError: error });
-                }
-            }
-        };
-        SlateEditableComponent.prototype.onDOMPaste = function (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);
-            }
-        };
-        SlateEditableComponent.prototype.onFallbackBeforeInput = function (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 {
-                    var text = event.data;
-                    if (!slate.Range.isCollapsed(this.editor.selection)) {
-                        slate.Editor.deleteFragment(this.editor);
-                    }
-                    // just handle Non-IME input
-                    if (!this.isComposing) {
-                        slate.Editor.insertText(this.editor, text);
-                    }
-                }
-                catch (error) {
-                    this.editor.onError({ code: exports.SlateErrorCode.ToNativeSelectionError, nativeError: error });
-                }
-            }
-        };
-        SlateEditableComponent.prototype.isDOMEventHandled = function (event, handler) {
-            if (!handler) {
-                return false;
-            }
-            handler(event);
-            return event.defaultPrevented;
-        };
-        //#endregion
-        SlateEditableComponent.prototype.ngOnDestroy = function () {
-            NODE_TO_ELEMENT.delete(this.editor);
-            this.manualListeners.forEach(function (manualListener) {
-                manualListener();
-            });
-            this.destroy$.complete();
-            EDITOR_TO_ON_CHANGE.delete(this.editor);
-        };
-        return SlateEditableComponent;
-    }());
-    SlateEditableComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateEditableComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.Renderer2 }, { token: i0__namespace.ChangeDetectorRef }, { token: i0__namespace.NgZone }, { token: i0__namespace.Injector }], target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateEditableComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateEditableComponent, selector: "slate-editable", inputs: { editor: "editor", renderElement: "renderElement", renderLeaf: "renderLeaf", renderText: "renderText", decorate: "decorate", placeholderDecorate: "placeholderDecorate", isStrictDecorate: "isStrictDecorate", trackBy: "trackBy", readonly: "readonly", placeholder: "placeholder", beforeInput: "beforeInput", blur: "blur", click: "click", compositionEnd: "compositionEnd", 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: forms.NG_VALUE_ACCESSOR,
-                useExisting: i0.forwardRef(function () { return SlateEditableComponent; }),
-                multi: true
-            }], viewQueries: [{ propertyName: "templateComponent", first: true, predicate: ["templateComponent"], descendants: true, static: true }, { propertyName: "templateElementRef", first: true, predicate: ["templateComponent"], descendants: true, read: i0.ElementRef, static: true }], usesOnChanges: true, ngImport: i0__namespace, template: "<slate-children [children]=\"editor.children\" [context]=\"context\" [viewContext]=\"viewContext\"></slate-children>\n<slate-string-template #templateComponent></slate-string-template>", components: [{ type: SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }, { type: SlateStringTemplateComponent, selector: "slate-string-template" }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateEditableComponent, decorators: [{
-                type: i0.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"
-                        },
-                        templateUrl: 'editable.component.html',
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
-                        providers: [{
-                                provide: forms.NG_VALUE_ACCESSOR,
-                                useExisting: i0.forwardRef(function () { return SlateEditableComponent; }),
-                                multi: true
-                            }]
-                    }]
-            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.Renderer2 }, { type: i0__namespace.ChangeDetectorRef }, { type: i0__namespace.NgZone }, { type: i0__namespace.Injector }]; }, propDecorators: { editor: [{
-                    type: i0.Input
-                }], renderElement: [{
-                    type: i0.Input
-                }], renderLeaf: [{
-                    type: i0.Input
-                }], renderText: [{
-                    type: i0.Input
-                }], decorate: [{
-                    type: i0.Input
-                }], placeholderDecorate: [{
-                    type: i0.Input
-                }], isStrictDecorate: [{
-                    type: i0.Input
-                }], trackBy: [{
-                    type: i0.Input
-                }], readonly: [{
-                    type: i0.Input
-                }], placeholder: [{
-                    type: i0.Input
-                }], beforeInput: [{
-                    type: i0.Input
-                }], blur: [{
-                    type: i0.Input
-                }], click: [{
-                    type: i0.Input
-                }], compositionEnd: [{
-                    type: i0.Input
-                }], compositionStart: [{
-                    type: i0.Input
-                }], copy: [{
-                    type: i0.Input
-                }], cut: [{
-                    type: i0.Input
-                }], dragOver: [{
-                    type: i0.Input
-                }], dragStart: [{
-                    type: i0.Input
-                }], dragEnd: [{
-                    type: i0.Input
-                }], drop: [{
-                    type: i0.Input
-                }], focus: [{
-                    type: i0.Input
-                }], keydown: [{
-                    type: i0.Input
-                }], paste: [{
-                    type: i0.Input
-                }], spellCheck: [{
-                    type: i0.Input
-                }], autoCorrect: [{
-                    type: i0.Input
-                }], autoCapitalize: [{
-                    type: i0.Input
-                }], dataSlateEditor: [{
-                    type: i0.HostBinding,
-                    args: ['attr.data-slate-editor']
-                }], dataSlateNode: [{
-                    type: i0.HostBinding,
-                    args: ['attr.data-slate-node']
-                }], dataGramm: [{
-                    type: i0.HostBinding,
-                    args: ['attr.data-gramm']
-                }], templateComponent: [{
-                    type: i0.ViewChild,
-                    args: ['templateComponent', { static: true }]
-                }], templateElementRef: [{
-                    type: i0.ViewChild,
-                    args: ['templateComponent', { static: true, read: i0.ElementRef }]
-                }] } });
-    /**
-     * Check if the target is editable and in the editor.
-     */
-    var hasEditableTarget = function (editor, target) {
-        return isDOMNode(target) && AngularEditor.hasDOMNode(editor, target, { editable: true });
-    };
-    /**
-     * Check if two DOM range objects are equal.
-     */
-    var isRangeEqual = function (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.
-     */
-    var hasTarget = function (editor, target) {
-        return isDOMNode(target) && AngularEditor.hasDOMNode(editor, target);
-    };
-    /**
-     * Check if the target is inside void and in the editor.
-     */
-    var isTargetInsideVoid = function (editor, target) {
-        var slateNode = hasTarget(editor, target) && AngularEditor.toSlateNode(editor, target);
-        return slate.Editor.isVoid(editor, slateNode);
-    };
-    var hasStringTarget = function (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
-     */
-    var preventInsertFromComposition = function (event, editor) {
-        var types = ['compositionend', 'insertFromComposition'];
-        if (!types.includes(event.type)) {
-            return;
-        }
-        var insertText = event.data;
-        var window = AngularEditor.getWindow(editor);
-        var domSelection = window.getSelection();
-        // ensure text node insert composition input text
-        if (insertText && domSelection.anchorNode instanceof Text && domSelection.anchorNode.textContent.endsWith(insertText)) {
-            var textNode = domSelection.anchorNode;
-            textNode.splitText(textNode.length - insertText.length).remove();
-        }
-    };
-
-    var SlateElementComponent = /** @class */ (function (_super) {
-        __extends(SlateElementComponent, _super);
-        function SlateElementComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return SlateElementComponent;
-    }(BaseElementComponent));
-    SlateElementComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateElementComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateElementComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateElementComponent, selector: "[slateElement]", usesInheritance: true, ngImport: i0__namespace, template: '<slate-children [children]="children" [context]="childrenContext" [viewContext]="viewContext"></slate-children><ng-content></ng-content>', isInline: true, components: [{ type: SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateElementComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: '[slateElement]',
-                        template: '<slate-children [children]="children" [context]="childrenContext" [viewContext]="viewContext"></slate-children><ng-content></ng-content>',
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }] });
-
-    var SlateDefaultElementComponent = /** @class */ (function (_super) {
-        __extends(SlateDefaultElementComponent, _super);
-        function SlateDefaultElementComponent() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return SlateDefaultElementComponent;
-    }(BaseElementComponent));
-    SlateDefaultElementComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDefaultElementComponent, deps: null, target: i0__namespace.ɵɵFactoryTarget.Component });
-    SlateDefaultElementComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.7", type: SlateDefaultElementComponent, selector: "div[slateDefaultElement]", usesInheritance: true, ngImport: i0__namespace, template: "<slate-children [children]=\"children\" [context]=\"childrenContext\" [viewContext]=\"viewContext\"></slate-children>", isInline: true, components: [{ type: SlateChildrenComponent, selector: "slate-children", inputs: ["children", "context", "viewContext"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateDefaultElementComponent, decorators: [{
-                type: i0.Component,
-                args: [{
-                        selector: 'div[slateDefaultElement]',
-                        template: "<slate-children [children]=\"children\" [context]=\"childrenContext\" [viewContext]=\"viewContext\"></slate-children>",
-                        changeDetection: i0.ChangeDetectionStrategy.OnPush
-                    }]
-            }] });
-
-    var SlateModule = /** @class */ (function () {
-        function SlateModule() {
-        }
-        return SlateModule;
-    }());
-    SlateModule.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateModule, deps: [], target: i0__namespace.ɵɵFactoryTarget.NgModule });
-    SlateModule.ɵmod = i0__namespace.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateModule, declarations: [SlateEditableComponent,
-            SlateDefaultElementComponent,
-            SlateElementComponent,
-            SlateVoidTextComponent,
-            SlateDefaultTextComponent,
-            SlateStringComponent,
-            SlateStringTemplateComponent,
-            SlateDescendantComponent,
-            SlateChildrenComponent,
-            SlateBlockCardComponent,
-            SlateLeafComponent,
-            SlateLeavesComponent,
-            SlateDefaultLeafComponent], imports: [i2.CommonModule], exports: [SlateEditableComponent, SlateChildrenComponent, SlateElementComponent, SlateLeavesComponent, SlateStringComponent] });
-    SlateModule.ɵinj = i0__namespace.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateModule, providers: [
-            {
-                provide: SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN,
-                useValue: SlateDefaultElementComponent
-            },
-        ], imports: [[i2.CommonModule]] });
-    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0__namespace, type: SlateModule, decorators: [{
-                type: i0.NgModule,
-                args: [{
-                        declarations: [
-                            SlateEditableComponent,
-                            SlateDefaultElementComponent,
-                            SlateElementComponent,
-                            SlateVoidTextComponent,
-                            SlateDefaultTextComponent,
-                            SlateStringComponent,
-                            SlateStringTemplateComponent,
-                            SlateDescendantComponent,
-                            SlateChildrenComponent,
-                            SlateBlockCardComponent,
-                            SlateLeafComponent,
-                            SlateLeavesComponent,
-                            SlateDefaultLeafComponent
-                        ],
-                        imports: [i2.CommonModule],
-                        entryComponents: [SlateBlockCardComponent, SlateStringComponent, SlateDefaultElementComponent, SlateDefaultLeafComponent, SlateVoidTextComponent, SlateDefaultTextComponent],
-                        exports: [SlateEditableComponent, SlateChildrenComponent, SlateElementComponent, SlateLeavesComponent, SlateStringComponent],
-                        providers: [
-                            {
-                                provide: SLATE_DEFAULT_ELEMENT_COMPONENT_TOKEN,
-                                useValue: SlateDefaultElementComponent
-                            },
-                        ]
-                    }]
-            }] });
-
-    /*
-     * Public API Surface of slate-angular
-     */
-
-    /**
-     * Generated bundle index. Do not edit.
-     */
-
-    exports.AngularEditor = AngularEditor;
-    exports.BaseComponent = BaseComponent;
-    exports.BaseElementComponent = BaseElementComponent;
-    exports.BaseLeafComponent = BaseLeafComponent;
-    exports.BaseTextComponent = BaseTextComponent;
-    exports.DOMComment = DOMComment;
-    exports.DOMElement = DOMElement;
-    exports.DOMNode = DOMNode;
-    exports.DOMRange = DOMRange;
-    exports.DOMSelection = DOMSelection;
-    exports.DOMStaticRange = DOMStaticRange;
-    exports.DOMText = DOMText;
-    exports.EDITOR_TO_ELEMENT = EDITOR_TO_ELEMENT;
-    exports.EDITOR_TO_ON_CHANGE = EDITOR_TO_ON_CHANGE;
-    exports.EDITOR_TO_PLACEHOLDER = EDITOR_TO_PLACEHOLDER;
-    exports.EDITOR_TO_WINDOW = EDITOR_TO_WINDOW;
-    exports.ELEMENT_TO_COMPONENT = ELEMENT_TO_COMPONENT;
-    exports.ELEMENT_TO_NODE = ELEMENT_TO_NODE;
-    exports.FAKE_LEFT_BLOCK_CARD_OFFSET = FAKE_LEFT_BLOCK_CARD_OFFSET;
-    exports.FAKE_RIGHT_BLOCK_CARD_OFFSET = FAKE_RIGHT_BLOCK_CARD_OFFSET;
-    exports.HAS_BEFORE_INPUT_SUPPORT = HAS_BEFORE_INPUT_SUPPORT;
-    exports.IS_ANDROID = IS_ANDROID;
-    exports.IS_APPLE = IS_APPLE;
-    exports.IS_CHROME = IS_CHROME;
-    exports.IS_CHROME_LEGACY = IS_CHROME_LEGACY;
-    exports.IS_CLICKING = IS_CLICKING;
-    exports.IS_DRAGGING = IS_DRAGGING;
-    exports.IS_EDGE_LEGACY = IS_EDGE_LEGACY;
-    exports.IS_FIREFOX = IS_FIREFOX;
-    exports.IS_FIREFOX_LEGACY = IS_FIREFOX_LEGACY;
-    exports.IS_FOCUSED = IS_FOCUSED;
-    exports.IS_IOS = IS_IOS;
-    exports.IS_QQBROWSER = IS_QQBROWSER;
-    exports.IS_READONLY = IS_READONLY;
-    exports.IS_SAFARI = IS_SAFARI;
-    exports.IS_UC_MOBILE = IS_UC_MOBILE;
-    exports.IS_WECHATBROWSER = IS_WECHATBROWSER;
-    exports.KEY_TO_ELEMENT = KEY_TO_ELEMENT;
-    exports.Key = Key;
-    exports.NODE_TO_ELEMENT = NODE_TO_ELEMENT;
-    exports.NODE_TO_INDEX = NODE_TO_INDEX;
-    exports.NODE_TO_KEY = NODE_TO_KEY;
-    exports.NODE_TO_PARENT = NODE_TO_PARENT;
-    exports.PLACEHOLDER_SYMBOL = PLACEHOLDER_SYMBOL;
-    exports.SlateChildrenComponent = SlateChildrenComponent;
-    exports.SlateEditableComponent = SlateEditableComponent;
-    exports.SlateElementComponent = SlateElementComponent;
-    exports.SlateLeavesComponent = SlateLeavesComponent;
-    exports.SlateModule = SlateModule;
-    exports.SlateStringComponent = SlateStringComponent;
-    exports.check = check;
-    exports.getCardTargetAttribute = getCardTargetAttribute;
-    exports.getClipboardData = getClipboardData;
-    exports.getDefaultView = getDefaultView;
-    exports.getEditableChild = getEditableChild;
-    exports.getEditableChildAndIndex = getEditableChildAndIndex;
-    exports.getPlainText = getPlainText;
-    exports.getSlateFragmentAttribute = getSlateFragmentAttribute;
-    exports.hasBeforeContextChange = hasBeforeContextChange;
-    exports.hasBlockCard = hasBlockCard;
-    exports.hasBlockCardWithNode = hasBlockCardWithNode;
-    exports.hasShadowRoot = hasShadowRoot;
-    exports.hotkeys = hotkeys;
-    exports.isCardCenterByTargetAttr = isCardCenterByTargetAttr;
-    exports.isCardLeft = isCardLeft;
-    exports.isCardLeftByTargetAttr = isCardLeftByTargetAttr;
-    exports.isCardRightByTargetAttr = isCardRightByTargetAttr;
-    exports.isComponentType = isComponentType;
-    exports.isDOMComment = isDOMComment;
-    exports.isDOMElement = isDOMElement;
-    exports.isDOMNode = isDOMNode;
-    exports.isDOMSelection = isDOMSelection;
-    exports.isDOMText = isDOMText;
-    exports.isDecoratorRangeListEqual = isDecoratorRangeListEqual;
-    exports.isPlainTextOnlyPaste = isPlainTextOnlyPaste;
-    exports.isTemplateRef = isTemplateRef;
-    exports.isValid = isValid;
-    exports.normalize = normalize;
-    exports.normalizeDOMPoint = normalizeDOMPoint;
-    exports.shallowCompare = shallowCompare;
-    exports.withAngular = withAngular;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=slate-angular.umd.js.map