editate 0.0.0 → 0.5.0

package/lib/index.js

@@ -1,5 +1,830 @@
-'use strict';
+const t = Math.min, {keys: e, is: n} = Object, r = t => "string" == typeof t, o = t => "function" == typeof t, s = o(queueMicrotask) ? queueMicrotask : t => {
+    Promise.resolve().then(t);
+}, c = (t, e = t => y(t) ? t.text : "") => t.children.reduce((t, n, r) => {
+    const o = g(n);
+    return 0 !== r && o && (t += "\n"), t + (o ? n.children.reduce((t, n) => t + e(n), "") : "");
+}, ""), i = (t, e, n) => t.split("\n").map(t => ({
+    ...n,
+    children: [ {
+        ...e,
+        text: t
+    } ]
+})), l = "delete", a = "insert_text", f = "insert_node", u = "set_attr", d = "set_node_attr", h = ({type: t}) => t === f || t === u || t === d;
 
-var index = () => {};
+class p {
+    t;
+    constructor(t) {
+        this.t = t ? t.slice() : [];
+    }
+    get ops() {
+        return this.t;
+    }
+    insertText(t, e) {
+        return this.t.push({
+            type: a,
+            at: t,
+            text: e
+        }), this;
+    }
+    insertFragment(t, e) {
+        return this.t.push({
+            type: f,
+            at: t,
+            fragment: e
+        }), this;
+    }
+    delete(t, e) {
+        return this.t.push({
+            type: l,
+            start: t,
+            end: e
+        }), this;
+    }
+    format(t, e, n, r) {
+        return this.t.push({
+            type: u,
+            start: t,
+            end: e,
+            key: n,
+            value: r
+        }), this;
+    }
+    attr(t, e, n) {
+        return this.t.push({
+            type: d,
+            path: t,
+            key: e,
+            value: n
+        }), this;
+    }
+    transform(t) {
+        return this.t.reduce((t, e) => F(t, e), t);
+    }
+}
 
-module.exports = index;
+const y = t => "text" in t, g = t => "children" in t, k = (t, r) => {
+    const o = e(t);
+    return o.length === e(r).length && o.every(e => e in r && ("text" === e || n(t[e], r[e])));
+}, m = new WeakMap, b = ({children: t}, e = 0, n = t.length) => {
+    let r = 0, o = 0;
+    for (let s = e; s < n; s++) {
+        const e = t[s];
+        r += w(e), 0 !== o && g(e) && r++, o++;
+    }
+    return r;
+}, w = t => {
+    if (g(t)) {
+        let e = m.get(t);
+        return null == e && m.set(t, e = b(t)), e;
+    }
+    return y(t) ? t.text.length : 1;
+}, x = (t, [e, n]) => {
+    let r = 0;
+    for (const n of e) r += b(t, 0, n), 0 !== n && r++, t = t.children[n];
+    return r + n;
+}, _ = (t, e) => {
+    const n = [];
+    for (;t; ) {
+        const r = C(t, e);
+        if (!r) break;
+        const o = r.o, s = r.i;
+        if (!g(s)) break;
+        e = r.l, n.push(o), t = s;
+    }
+    return [ n, e ];
+}, v = (t, [e, n]) => [ x(t, e), x(t, n) ], M = (t, [e, n]) => [ _(t, e), _(t, n) ], D = (t, e = 0, n = t.length - 1) => {
+    let r = e + 1;
+    for (;r <= n; ) {
+        const e = t[r - 1], o = t[r];
+        y(e) && y(o) && k(e, o) ? (t[r - 1] = {
+            ...e,
+            text: e.text + o.text
+        }, t.splice(r, 1), n--) : r++;
+    }
+    for (r = e; r <= n; ) {
+        const e = t[r];
+        y(e) && !e.text && t.length > 1 ? (t.splice(r, 1), n--) : r++;
+    }
+}, E = (t, e = 0, n = t.length - 1) => {
+    let r = e + 1;
+    for (;r <= n; ) {
+        const e = t[r - 1], o = t[r];
+        t[r - 1] = S(e, o), t.splice(r, 1), n--;
+    }
+}, O = (t, e, n) => {
+    if (e.length) {
+        const r = t.length;
+        t.push(...e), r && n(t, r - 1, r);
+    }
+}, S = (...t) => ({
+    ...t[0],
+    children: t.reduce((t, e) => (O(t, e.children, D), t), [])
+}), C = ({children: t}, e) => {
+    for (let n = 0; n < t.length; n++) {
+        const r = t[n];
+        let o = w(r);
+        if (g(r) && o++, o > e) return {
+            i: r,
+            o: n,
+            l: e
+        };
+        e -= o;
+    }
+    return null;
+}, I = (t, e) => {
+    const n = t.children, r = C(t, e);
+    if (r) {
+        const {i: e, l: o, o: s} = r;
+        if (g(e)) {
+            const [r, c] = I(e, o), i = n.slice(0, s), l = n.slice(s + 1);
+            return i.push(r), l.unshift(c), [ {
+                ...t,
+                children: i
+            }, {
+                ...t,
+                children: l
+            } ];
+        }
+        {
+            const r = n.slice(0, s), c = n.slice(s + 1);
+            if (y(e)) {
+                const t = e.text.slice(0, o), n = e.text.slice(o);
+                !t && r.length || r.push({
+                    ...e,
+                    text: t
+                }), !n && c.length || c.unshift({
+                    ...e,
+                    text: n
+                });
+            } else c.unshift(e);
+            return [ {
+                ...t,
+                children: r
+            }, {
+                ...t,
+                children: c
+            } ];
+        }
+    }
+    return [ t, {
+        ...t,
+        children: []
+    } ];
+}, A = (t, e) => {
+    for (let n = 0; n < e.length; n++) t = t.children[e[n]];
+    return t;
+}, H = (t, e, n, r = 0) => {
+    if (r < e.length) {
+        const o = e[r];
+        return ((t, e, n, r) => {
+            const o = t.children.slice();
+            return o.splice(e, n - e + 1, ...r), {
+                ...t,
+                children: o
+            };
+        })(t, o, o, [ H(t.children[o], e, n, r + 1) ]);
+    }
+    return n;
+}, P = (t, e, n, r) => {
+    const [o, s] = I(t, e), c = e < n ? I(t, n)[1] : s, i = o.children.slice();
+    return O(i, r, E), O(i, c.children, E), {
+        ...t,
+        children: i
+    };
+}, R = (t, e, n) => e >= n ? [] : I(I(t, n)[0], e)[1].children, B = (t, e) => e >= 0 && e <= w(t), F = (t, e) => {
+    switch (e.type) {
+      case l:
+        {
+            const {start: n, end: r} = e;
+            if (t >= n) return r >= t ? n : t + n - r;
+            break;
+        }
+
+      case a:
+        {
+            const {at: n, text: r} = e;
+            if (t >= n) return t + r.length;
+            break;
+        }
+
+      case f:
+        {
+            const {at: n, fragment: r} = e;
+            if (t >= n) return t + w({
+                children: r
+            });
+            break;
+        }
+    }
+    return t;
+}, T = ([t, e], n) => [ F(t, n), F(e, n) ], V = (t, e, n) => {
+    switch (n.type) {
+      case l:
+        {
+            const {start: r, end: o} = n;
+            B(t, r) && B(t, o) && r < o && (t = P(t, r, o, []), e = T(e, n));
+            break;
+        }
+
+      case a:
+        {
+            const {at: r, text: o} = n;
+            if (B(t, r) && o) {
+                const [s, c] = _(t, r), l = A(t, s), a = C(l, c - 1);
+                let f;
+                if (a) {
+                    const t = a.i;
+                    y(t) && (f = t);
+                }
+                t = P(t, r, r, i(o, f, l)), e = T(e, n);
+            }
+            break;
+        }
+
+      case f:
+        {
+            const {at: r, fragment: o} = n;
+            B(t, r) && o.length && (t = P(t, r, r, o), e = T(e, n));
+            break;
+        }
+
+      case u:
+        {
+            const {start: e, end: r, key: o, value: s} = n;
+            B(t, e) && B(t, r) && e < r && (t = P(t, e, r, R(t, e, r).map(t => ({
+                ...t,
+                children: t.children.map(t => y(t) ? {
+                    ...t,
+                    [o]: s
+                } : t)
+            }))));
+            break;
+        }
+
+      case d:
+        {
+            const {path: e, key: r, value: o} = n, s = A(t, e);
+            s && (t = H(t, e, {
+                ...s,
+                [r]: o
+            }));
+            break;
+        }
+    }
+    return [ t, e ];
+}, L = ([t, e]) => t > e ? [ e, t ] : [ t, e ], N = ([t, e]) => t === e;
+
+function q(t, e = L(t.selection)) {
+    t.apply((new p).delete(...e));
+}
+
+function z(t, e, n = t.selection[0]) {
+    t.apply((new p).insertText(n, e));
+}
+
+function J(t, e, n = t.selection[0]) {
+    t.apply((new p).insertFragment(n, [ {
+        children: [ e ]
+    } ]));
+}
+
+function U(t, e) {
+    const [n, r] = L(t.selection);
+    t.apply((new p).delete(n, r).insertText(n, e));
+}
+
+function G(t, e) {
+    t.apply((new p).delete(0, w(t.doc)).insertFragment(0, e));
+}
+
+function W(t, e, n, r = L(t.selection)) {
+    t.apply((new p).format(...r, e, n));
+}
+
+function j(t, e, n = L(t.selection)) {
+    const r = R(t.doc, ...n).flatMap(t => t.children.filter(y));
+    r.length && t.apply((new p).format(...n, e, !!r.some(t => !t[e])));
+}
+
+function X(t, e, n, r = _(t.doc, t.selection[0])[0]) {
+    t.apply((new p).attr(r, e, n));
+}
+
+function Y(t, e, n, r, o = _(t.doc, t.selection[0])[0]) {
+    const s = A(t.doc, o);
+    t.apply((new p).attr(o, e, s[e] === n ? r : n));
+}
+
+let K = null, Q = null, Z = null, $ = null, tt = null;
+
+const et = t => 1 === t.nodeType, nt = t => 8 === t.nodeType, rt = () => Q, ot = () => {
+    const t = st();
+    return 1 === t ? Q.data.length : 2 === t ? 1 : 0;
+}, st = () => {
+    if (null != Z) return Z;
+    if (Q) if ((t => 3 === t.nodeType)(Q)) {
+        const t = Q.data;
+        if (t) return Z = "\n" === t ? at() ? 3 : 6 : 1;
+    } else if (et(Q)) {
+        if ("BR" === Q.tagName) return Z = at() ? 3 : 5;
+        if ($.u(Q)) return Z = 2;
+        if ($.h(Q)) return Z = 4;
+    }
+    return Z = 0;
+}, ct = () => (Z = null, Q = K.nextNode()), it = () => {
+    for (;(Z = null) || (Q = K.nextSibling()); ) if (4 === st()) return;
+}, lt = () => {
+    for (;(Z = null) || (Q = K.parentNode()); ) if (4 === st()) return;
+}, at = () => {
+    const t = Q.parentNode;
+    return tt(() => {
+        for (;ct(); ) {
+            if (st()) return !0;
+            if (!t.contains(Q)) break;
+        }
+        return !1;
+    });
+}, ft = () => {
+    for (;;) {
+        if (2 === st()) {
+            const t = Q;
+            for (;ct() && t.contains(Q); ) ;
+        } else ct();
+        if (!Q) break;
+        const t = st();
+        if (t) return t;
+    }
+}, ut = new Set([ "DIV", "H1", "H2", "H3", "H4", "H5", "H6", "P", "PRE", "LI", "DT", "DD", "TR" ]), dt = t => ut.has(t.tagName), ht = new Set([ "EMBED", "IMG", "PICTURE", "AUDIO", "VIDEO", "SVG", "CANVAS", "MATH", "IFRAME", "OBJECT" ]), pt = t => "false" === t.contentEditable || ht.has(t.tagName), yt = (t, e) => t.compareDocumentPosition(e), gt = t => t.ownerDocument, kt = t => gt(t).getSelection(), mt = (t, e) => {
+    if (t.rangeCount) {
+        const n = t.getRangeAt(0);
+        if (e.contains(n.commonAncestorContainer)) return n;
+    }
+}, bt = (t, e, n, r) => {
+    const o = kt(t);
+    (n || mt(o, t)) && (o.removeAllRanges(), o.addRange(e), r && (o.collapseToEnd(), 
+    o.extend(e.startContainer, e.startOffset)));
+}, wt = (t, e, [n, r], o, s, c) => {
+    const i = 0 === o, l = o > 0, a = l ? r : n, f = l ? n : r;
+    if (0 === a[0].length && 0 === a[1] && i && !e.hasChildNodes()) {
+        const n = t.createRange();
+        return n.setStart(e, 0), n.setEnd(e, 0), bt(e, n, c);
+    }
+    const u = xt(e, a, s);
+    if (!u) return;
+    const d = i ? u : xt(e, f, s);
+    if (!d) return;
+    const h = t.createRange(), [p, y] = u, [g, k] = d;
+    et(p) ? y < 1 ? h.setStartBefore(p) : h.setStartAfter(p) : h.setStart(p, y), et(g) ? k < 1 ? h.setEndBefore(g) : h.setEndAfter(g) : h.setEnd(g, k), 
+    bt(e, h, c, l);
+}, xt = (t, [e, n], r) => r(() => {
+    let t, r = 0;
+    for (;t = ft(); ) if (4 === t) {
+        if (r < e.length) for (let t = e[r++]; t > 0; t--) it();
+    } else {
+        const t = ot();
+        if (n <= t) return [ rt(), n ];
+        n -= t;
+    }
+}, t), _t = (e, n, r, o) => {
+    let s = !0;
+    if (e === n && !n.hasChildNodes()) return [ [ 0 ], 0 ];
+    if (et(n) && n.hasChildNodes()) {
+        const e = t(r, n.childNodes.length - 1);
+        n = n.childNodes[e], s = e === r, r = 0;
+    }
+    return o(() => {
+        4 !== st() && lt();
+        const t = o(() => {
+            const t = [];
+            let n;
+            for (;(n = rt()) && n !== e; ) t.unshift(n), lt();
+            if (!t.length) return [ 0 ];
+            let r = 0, o = t[t.length - 1];
+            for (;o = o.previousElementSibling; ) r++;
+            return [ r ];
+        });
+        let c = 0;
+        for (;ft(); ) {
+            const t = yt(n, rt());
+            if (0 === t || 16 & t) {
+                if (s) break;
+            } else if (4 & t) break;
+            c += ot();
+        }
+        return [ t, c + r ];
+    }, e, n);
+}, vt = (t, e, {startOffset: n, startContainer: r, endOffset: o, endContainer: s}) => {
+    const c = _t(t, r, n, e);
+    return [ c, r === s && n === o ? c : _t(t, s, o, e) ];
+}, Mt = t => (e, n) => {
+    e.setData("text/plain", c({
+        children: n
+    }, t));
+}, Dt = () => (t, e, n) => {
+    const r = document.createElement("div");
+    r.appendChild(mt(kt(n), n).cloneContents()), t.setData("text/html", r.innerHTML);
+}, Et = "application/x-editate-editor", Ot = ({key: t = Et} = {}) => (e, n) => {
+    e.setData(t, JSON.stringify(n));
+}, St = t => e => {
+    for (const n of e.items) if ("file" === n.kind) {
+        const e = t[n.type];
+        if (e) {
+            const t = n.getAsFile();
+            if (t) return [ {
+                children: [ e(t) ]
+            } ];
+        }
+    }
+    return null;
+}, Ct = () => t => t.getData("text/plain"), It = (t, e = []) => (n, r) => {
+    const o = n.getData("text/html");
+    if (o) {
+        let n = (new DOMParser).parseFromString(o, "text/html").body, s = !1;
+        for (const t of [ ...n.childNodes ]) nt(t) ? "StartFragment" === t.data ? (s = !0, 
+        n = new DocumentFragment) : "EndFragment" === t.data && (s = !1) : s && n.appendChild(t);
+        return ((t, e, n, r) => e(() => {
+            let t, e = null, o = "", s = !1;
+            const c = [], i = () => {
+                o && (e || (e = []), e.push(n(o)), o = "");
+            }, l = () => {
+                i(), !e && s && (e = []), e && c.push({
+                    children: e
+                }), e = null, s = !1;
+            };
+            for (;t = ft(); ) if (4 === t) l(); else if (s = !0, 1 === t) o += rt().data; else if (2 === t) {
+                i();
+                const t = r(rt());
+                t && e.push(t);
+            } else 3 === t && l();
+            return l(), c.length || c.push({
+                children: []
+            }), c;
+        }, t))(n, r, t, t => {
+            for (const n of e) {
+                const e = n(t);
+                if (e) return e;
+            }
+        });
+    }
+    return null;
+}, At = ({key: t = Et} = {}) => e => {
+    try {
+        return JSON.parse(e.getData(t));
+    } catch (t) {
+        return null;
+    }
+}, Ht = (t, e, {mod: n, shift: r = !1, alt: o = !1} = {}) => (t = t.toLowerCase(), 
+s => {
+    if (s.key.toLowerCase() === t && (!n || s.ctrlKey || s.metaKey) && r === s.shiftKey && o === s.altKey) return e(s), 
+    !0;
+});
+
+function Pt(t) {
+    let e = 0, r = 0, o = !1;
+    const s = Date.now, c = [ [ t.doc, t.selection, [] ] ], i = () => c[e];
+    t.hook("apply", (i, l) => {
+        if (o) return;
+        const a = t.doc, f = t.selection;
+        l(i);
+        const u = t.doc;
+        if (!n(a, u)) {
+            const t = s();
+            if (0 === e || t - r >= 500) {
+                e++;
+                const t = [ a, f, [] ];
+                e >= c.length ? c.push(t) : c[e] = t;
+            }
+            r = t, c[e][0] = u, c[e][2].push(i), c.splice(e + 1), e > 500 && (e--, c.shift());
+        }
+    }), t.hook("keyboard", Ht("z", () => {
+        if (e > 0) {
+            const r = i()[1];
+            e--;
+            const s = t.doc;
+            o = !0, t.exec(G, i()[0].children), o = !1, n(s, t.doc) || (t.selection = r);
+        }
+    }, {
+        mod: !0
+    })), t.hook("keyboard", Ht("z", () => {
+        if (e < c.length - 1) {
+            e++;
+            const [r, s, c] = i(), l = t.doc;
+            o = !0, t.exec(G, r.children), o = !1, n(l, t.doc) || (t.selection = c.reduce((t, e) => T(t, e), s));
+        }
+    }, {
+        mod: !0,
+        shift: !0
+    }));
+}
+
+const Rt = [], Bt = () => {}, Ft = ({doc: t, readonly: e = !1, schema: c, keyboard: i, copy: l = [ Mt() ], paste: a = [ t => t.getData("text/plain") ], isBlock: f = dt, onChange: u, onError: d = console.error}) => {
+    let y = [ 0, 0 ];
+    const g = (t, e) => {
+        if (!c) return e("An unsafe operation was detected. We recommend using schema option."), 
+        !0;
+        const n = c["~standard"].validate(t);
+        if (n instanceof Promise) e("async validate is not supported."); else {
+            if (!n.issues) return !0;
+            e(n.issues.map(t => t.message).join("\n"));
+        }
+        return !1;
+    };
+    let k;
+    if (!g(t, t => {
+        k = t;
+    }) && k) throw Error(k);
+    const m = new Map, b = t => m.get(t) || Rt, w = new Map, _ = t => {
+        const e = w.get(t);
+        e && !e[1] && (e[1] = !0, s(() => {
+            e[1] = !1, e[0].forEach(t => {
+                t();
+            });
+        }));
+    }, D = r => {
+        if (!e) {
+            const e = t, o = b("apply"), s = o.length;
+            for (let e of r.ops) {
+                let n = 0;
+                const r = () => {
+                    if (n < s) {
+                        const t = n;
+                        o[n](e, c), t === n && c();
+                    } else if (n === s) {
+                        n++;
+                        try {
+                            const [n, r] = V(t, y, e);
+                            h(e) && !g(n, d) || (t = n, y = r);
+                        } catch (t) {
+                            d("rollback operation: " + t);
+                        }
+                    }
+                }, c = t => {
+                    t && (e = t), n++, r();
+                };
+                r();
+            }
+            n(e, t) || _("change");
+        }
+    }, E = e => {
+        !((t, [e, n]) => B(t, e) && B(t, n))(t, e) || y[0] === e[0] && y[1] === e[1] || (y = e, 
+        _("selectionchange"));
+    }, O = {
+        get doc() {
+            return t;
+        },
+        get selection() {
+            return y;
+        },
+        set selection(t) {
+            E(t);
+        },
+        get readonly() {
+            return e;
+        },
+        set readonly(t) {
+            e = t, _("readonly");
+        },
+        apply: t => (D(t), O),
+        on: (t, e) => {
+            let n = w.get(t);
+            n || w.set(t, n = [ new Set, !1 ]);
+            const r = n[0];
+            return r.add(e), () => {
+                r.delete(e);
+            };
+        },
+        hook: (t, e) => {
+            let n = m.get(t);
+            return n || m.set(t, n = []), n.push(e), () => {
+                const t = n.indexOf(e);
+                -1 !== t && n.splice(t, 1);
+            };
+        },
+        exec: (t, ...e) => {
+            const n = t(O, ...e);
+            return void 0 === n ? O : n;
+        },
+        input: n => {
+            if (!window.InputEvent || !o(InputEvent.prototype.getTargetRanges)) return d("beforeinput event is not supported."), 
+            Bt;
+            const {contentEditable: s, role: c, ariaMultiLine: i, ariaReadOnly: u} = n, h = n.style.whiteSpace;
+            n.role = "textbox", n.style.whiteSpace = "pre-wrap", n.ariaMultiLine = "true";
+            let g = !1, k = null, m = !1, w = !1, _ = !1;
+            const S = gt(n), C = (t => {
+                const e = (n, r, o) => {
+                    const s = $, c = tt, i = K, l = Q, a = Z;
+                    try {
+                        return K || ($ = t, tt = e, K = $.p.createTreeWalker(r, 5)), o && (K.currentNode = Q = o), 
+                        n();
+                    } finally {
+                        $ = s, tt = c, K = i, Q = l, Z = a, K && l && (K.currentNode = l);
+                    }
+                };
+                return e;
+            })({
+                p: S,
+                h: f,
+                u: pt
+            }), I = () => {
+                n.contentEditable = e ? "false" : "true", n.ariaReadOnly = e ? "true" : null;
+            };
+            I();
+            const A = O.on("change", () => {
+                w || requestAnimationFrame(() => {
+                    w || n.focus({
+                        preventScroll: !0
+                    });
+                });
+            }), H = O.on("readonly", I), P = t => {
+                for (const e of a) {
+                    const n = e(t, C);
+                    if (n) return n;
+                }
+                d("failed to serialize pasted data");
+            }, B = ((t, e) => {
+                let n = !1;
+                const r = [], o = t => {
+                    n && r.push(...t);
+                }, s = new MutationObserver(t => {
+                    o(t), n || e();
+                }), c = () => {
+                    o(s.takeRecords());
+                }, i = () => (c(), r.splice(0));
+                return s.observe(t, {
+                    characterData: !0,
+                    characterDataOldValue: !0,
+                    childList: !0,
+                    subtree: !0
+                }), {
+                    k: t => {
+                        let e;
+                        for (;e = t.pop(); ) if ("childList" === e.type) {
+                            const {target: t, removedNodes: n, addedNodes: r, nextSibling: o} = e;
+                            for (let e = n.length - 1; e >= 0; e--) t.insertBefore(n[e], o);
+                            for (let e = r.length - 1; e >= 0; e--) t.removeChild(r[e]);
+                        } else e.target.data = e.oldValue;
+                        i();
+                    },
+                    m: t => {
+                        !n && t && c(), n = t;
+                    },
+                    _: i,
+                    v: () => {
+                        r.splice(0), s.disconnect();
+                    }
+                };
+            })(n, () => {
+                wt(S, n, M(t, y), y[0] - y[1], C);
+            }), F = () => {
+                E(v(t, ((t, e) => {
+                    const n = kt(t), r = mt(n, t);
+                    if (!r) return [ [ [ 0 ], 0 ], [ [ 0 ], 0 ] ];
+                    const o = vt(t, e, r), s = yt(n.anchorNode, n.focusNode);
+                    return (0 === s ? n.anchorOffset > n.focusOffset : 2 & s) ? [ o[1], o[0] ] : o;
+                })(n, C)));
+            }, T = () => {
+                const e = B._();
+                B.m(!1), e.length && (B.k(e), S.removeEventListener("selectionchange", j), wt(S, n, M(t, y), y[0] - y[1], C, !0), 
+                S.addEventListener("selectionchange", j)), k && (E(k[1]), D(k[0]), k = null), m = !1;
+            }, V = t => {
+                if (!m) for (const e of b("keyboard")) if (e(t)) return t.preventDefault(), void B.m(!1);
+            }, q = () => {
+                m || T();
+            }, z = e => {
+                e.preventDefault();
+                const r = e.inputType;
+                if (r.startsWith("format")) return;
+                if ("historyUndo" === r || "historyRedo" === r) return;
+                m ? B.m(!0) : F();
+                const o = e.getTargetRanges()[0];
+                if (o) {
+                    const s = v(t, vt(n, C, o));
+                    let c, i = "insertParagraph" === r || "insertLineBreak" === r ? "\n" : e.data;
+                    if (null == i) {
+                        const t = e.dataTransfer;
+                        t && (i = t.getData("text/plain"));
+                    }
+                    k || (k = [ new p, y ]), c = k[0], N(s) || c.delete(...s), i && c.insertText(s[0], i);
+                }
+                m || T();
+            }, J = () => {
+                m || F(), m = !0;
+            }, U = () => {
+                T();
+            }, G = () => {
+                w = !0, F();
+            }, W = () => {
+                w = !1;
+            }, j = () => {
+                !w || m || _ || F();
+            }, X = e => {
+                if (F(), !N(y)) {
+                    const r = R(t, ...L(y));
+                    for (const t of l) t(e, r, n);
+                }
+            }, Y = t => {
+                t.preventDefault(), X(t.clipboardData);
+            }, et = t => {
+                t.preventDefault(), e || (X(t.clipboardData), D((new p).delete(...L(y))));
+            }, nt = t => {
+                t.preventDefault();
+                const e = P(t.clipboardData);
+                if (e) {
+                    const [t, n] = L(y), o = (new p).delete(t, n);
+                    r(e) ? o.insertText(t, e) : o.insertFragment(t, e), D(o);
+                }
+            }, rt = e => {
+                e.preventDefault();
+                const o = e.dataTransfer, s = ((t, e, {clientX: n, clientY: r}, o) => {
+                    if (t.caretPositionFromPoint) {
+                        const s = t.caretPositionFromPoint(n, r);
+                        if (s) return _t(e, s.offsetNode, s.offset, o);
+                    } else if (t.caretRangeFromPoint) {
+                        const s = t.caretRangeFromPoint(n, r);
+                        if (s) return _t(e, s.startContainer, s.startOffset, o);
+                    }
+                })(S, n, e, C);
+                if (o && s) {
+                    let e;
+                    const n = new p;
+                    _ && n.delete(...L(y));
+                    const c = P(o);
+                    if (c) {
+                        const o = x(t, s), i = n.transform(o);
+                        r(c) ? n.insertText(i, c) : n.insertFragment(i, c), e = [ i, n.transform(o) ];
+                    }
+                    D(n), e && E(e);
+                }
+            }, ot = t => {
+                _ = !0, X(t.dataTransfer);
+            }, st = () => {
+                _ = !1;
+            };
+            S.addEventListener("selectionchange", j), n.addEventListener("keydown", V), n.addEventListener("input", q), 
+            n.addEventListener("beforeinput", z), n.addEventListener("compositionstart", J), 
+            n.addEventListener("compositionend", U), n.addEventListener("focus", G), n.addEventListener("blur", W), 
+            n.addEventListener("copy", Y), n.addEventListener("cut", et), n.addEventListener("paste", nt), 
+            n.addEventListener("drop", rt), n.addEventListener("dragstart", ot), n.addEventListener("dragend", st);
+            const ct = b("mount"), it = [];
+            return ct.forEach(t => {
+                const e = t(n);
+                e && it.push(e);
+            }), () => {
+                g || (g = !0, A(), H(), n.contentEditable = s, n.role = c, n.ariaMultiLine = i, 
+                n.ariaReadOnly = u, n.style.whiteSpace = h, B.v(), S.removeEventListener("selectionchange", j), 
+                n.removeEventListener("keydown", V), n.removeEventListener("input", q), n.removeEventListener("beforeinput", z), 
+                n.removeEventListener("compositionstart", J), n.removeEventListener("compositionend", U), 
+                n.removeEventListener("focus", G), n.removeEventListener("blur", W), n.removeEventListener("copy", Y), 
+                n.removeEventListener("cut", et), n.removeEventListener("paste", nt), n.removeEventListener("drop", rt), 
+                n.removeEventListener("dragstart", ot), n.removeEventListener("dragend", st), it.forEach(t => {
+                    t();
+                }));
+            };
+        }
+    };
+    return O.exec(Pt), O.on("change", () => {
+        u(t);
+    }), i && i.forEach(t => {
+        O.hook("keyboard", t);
+    }), O;
+};
+
+function Tt(t) {
+    t.hook("apply", t => {
+        console.log("apply", t);
+    }), t.on("change", () => {
+        console.log("change", t.doc);
+    }), t.on("selectionchange", () => {
+        console.log("selectionchange", t.selection);
+    });
+}
+
+function Vt(t) {
+    t.hook("mount", t => {
+        t.ariaMultiLine = null;
+    }), t.hook("apply", (t, e) => {
+        "insert_text" === t.type ? t = {
+            ...t,
+            text: t.text.replaceAll("\n", "")
+        } : "insert_node" === t.type && (t = {
+            ...t,
+            fragment: [ S(...t.fragment) ]
+        }), e(t);
+    });
+}
+
+const Lt = ({text: t, singleline: e, onChange: n, ...r}) => {
+    const o = Ft({
+        ...r,
+        doc: {
+            children: i(t)
+        },
+        onChange: t => {
+            n(c(t));
+        }
+    });
+    return e && o.exec(Vt), o;
+};
+
+export { q as Delete, W as Format, J as InsertNode, z as InsertText, G as ReplaceDoc, U as ReplaceText, X as SetBlockAttr, Y as ToggleBlockAttr, j as ToggleFormat, p as Transaction, Ft as createEditor, Lt as createPlainEditor, Tt as debugPlugin, St as filePaste, Ht as hotkey, Dt as htmlCopy, It as htmlPaste, Ot as internalCopy, At as internalPaste, Mt as plainCopy, Ct as plainPaste, Vt as singlelinePlugin };
+//# sourceMappingURL=index.js.map