@unicom-cloud/ui 0.8.109 → 0.8.110

package/chunk/BDMqvmVH.js

@@ -0,0 +1,4239 @@
+import it from "lodash/merge";
+import { RICH_TEXT_CLASS_NAME_PREFIX as L } from "../rich-text/constant.js";
+import lt from "@unicom-cloud/utils/diff";
+import W from "lodash/cloneDeep";
+import X from "lodash/isEqual";
+import ue from "@unicom-cloud/utils/mitt";
+import { isMacOS as fe } from "@unicom-cloud/utils/constant/platform";
+var kt;
+((r) => {
+  function t(n = {}, o = {}, l = !1) {
+    typeof n != "object" && (n = {}), typeof o != "object" && (o = {});
+    let a = W(o);
+    l || (a = Object.keys(a).reduce((c, h) => (a[h] != null && (c[h] = a[h]), c), {}));
+    for (const c in n)
+      n[c] !== void 0 && o[c] === void 0 && (a[c] = n[c]);
+    return Object.keys(a).length > 0 ? a : void 0;
+  }
+  r.compose = t;
+  function e(n = {}, o = {}) {
+    typeof n != "object" && (n = {}), typeof o != "object" && (o = {});
+    const l = Object.keys(n).concat(Object.keys(o)).reduce((a, c) => (X(n[c], o[c]) || (a[c] = o[c] === void 0 ? null : o[c]), a), {});
+    return Object.keys(l).length > 0 ? l : void 0;
+  }
+  r.diff = e;
+  function s(n = {}, o = {}) {
+    n = n || {};
+    const l = Object.keys(o).reduce((a, c) => (o[c] !== n[c] && n[c] !== void 0 && (a[c] = o[c]), a), {});
+    return Object.keys(n).reduce((a, c) => (n[c] !== o[c] && o[c] === void 0 && (a[c] = null), a), l);
+  }
+  r.invert = s;
+  function i(n, o, l = !1) {
+    if (typeof n != "object")
+      return o;
+    if (typeof o != "object")
+      return;
+    if (!l)
+      return o;
+    const a = Object.keys(o).reduce((c, h) => (n[h] === void 0 && (c[h] = o[h]), c), {});
+    return Object.keys(a).length > 0 ? a : void 0;
+  }
+  r.transform = i;
+})(kt || (kt = {}));
+const C = kt;
+var Ot;
+((r) => {
+  function t(e) {
+    return typeof e.delete == "number" ? e.delete : typeof e.retain == "number" ? e.retain : typeof e.retain == "object" && e.retain !== null ? 1 : typeof e.insert == "string" ? e.insert.length : 1;
+  }
+  r.length = t;
+})(Ot || (Ot = {}));
+const k = Ot;
+class R {
+  constructor(t) {
+    this.ops = t, this.index = 0, this.offset = 0;
+  }
+  hasNext() {
+    return this.peekLength() < 1 / 0;
+  }
+  next(t) {
+    t || (t = 1 / 0);
+    const e = this.ops[this.index];
+    if (e) {
+      const s = this.offset, i = k.length(e);
+      if (t >= i - s ? (t = i - s, this.index += 1, this.offset = 0) : this.offset += t, typeof e.delete == "number")
+        return { delete: t };
+      {
+        const n = {};
+        return e.attributes && (n.attributes = e.attributes), typeof e.retain == "number" ? n.retain = t : typeof e.retain == "object" && e.retain !== null ? n.retain = e.retain : typeof e.insert == "string" ? n.insert = e.insert.substr(s, t) : n.insert = e.insert, n;
+      }
+    } else
+      return { retain: 1 / 0 };
+  }
+  peek() {
+    return this.ops[this.index];
+  }
+  peekLength() {
+    return this.ops[this.index] ? k.length(this.ops[this.index]) - this.offset : 1 / 0;
+  }
+  peekType() {
+    const t = this.ops[this.index];
+    return t ? typeof t.delete == "number" ? "delete" : typeof t.retain == "number" || typeof t.retain == "object" && t.retain !== null ? "retain" : "insert" : "retain";
+  }
+  rest() {
+    if (this.hasNext()) {
+      if (this.offset === 0)
+        return this.ops.slice(this.index);
+      {
+        const t = this.offset, e = this.index, s = this.next(), i = this.ops.slice(this.index);
+        return this.offset = t, this.index = e, [s].concat(i);
+      }
+    } else return [];
+  }
+}
+const de = "\0", jt = (r, t) => {
+  if (typeof r != "object" || r === null)
+    throw new Error(`cannot retain a ${typeof r}`);
+  if (typeof t != "object" || t === null)
+    throw new Error(`cannot retain a ${typeof t}`);
+  const e = Object.keys(r)[0];
+  if (!e || e !== Object.keys(t)[0])
+    throw new Error(
+      `embed types not matched: ${e} != ${Object.keys(t)[0]}`
+    );
+  return [e, r[e], t[e]];
+};
+class f {
+  static {
+    this.Op = k;
+  }
+  static {
+    this.OpIterator = R;
+  }
+  static {
+    this.AttributeMap = C;
+  }
+  static {
+    this.handlers = {};
+  }
+  static registerEmbed(t, e) {
+    this.handlers[t] = e;
+  }
+  static unregisterEmbed(t) {
+    delete this.handlers[t];
+  }
+  static getHandler(t) {
+    const e = this.handlers[t];
+    if (!e)
+      throw new Error(`no handlers for embed type "${t}"`);
+    return e;
+  }
+  constructor(t) {
+    Array.isArray(t) ? this.ops = t : t != null && Array.isArray(t.ops) ? this.ops = t.ops : this.ops = [];
+  }
+  insert(t, e) {
+    const s = {};
+    return typeof t == "string" && t.length === 0 ? this : (s.insert = t, e != null && typeof e == "object" && Object.keys(e).length > 0 && (s.attributes = e), this.push(s));
+  }
+  delete(t) {
+    return t <= 0 ? this : this.push({ delete: t });
+  }
+  retain(t, e) {
+    if (typeof t == "number" && t <= 0)
+      return this;
+    const s = { retain: t };
+    return e != null && typeof e == "object" && Object.keys(e).length > 0 && (s.attributes = e), this.push(s);
+  }
+  push(t) {
+    let e = this.ops.length, s = this.ops[e - 1];
+    if (t = W(t), typeof s == "object") {
+      if (typeof t.delete == "number" && typeof s.delete == "number")
+        return this.ops[e - 1] = { delete: s.delete + t.delete }, this;
+      if (typeof s.delete == "number" && t.insert != null && (e -= 1, s = this.ops[e - 1], typeof s != "object"))
+        return this.ops.unshift(t), this;
+      if (X(t.attributes, s.attributes)) {
+        if (typeof t.insert == "string" && typeof s.insert == "string")
+          return this.ops[e - 1] = { insert: s.insert + t.insert }, typeof t.attributes == "object" && (this.ops[e - 1].attributes = t.attributes), this;
+        if (typeof t.retain == "number" && typeof s.retain == "number")
+          return this.ops[e - 1] = { retain: s.retain + t.retain }, typeof t.attributes == "object" && (this.ops[e - 1].attributes = t.attributes), this;
+      }
+    }
+    return e === this.ops.length ? this.ops.push(t) : this.ops.splice(e, 0, t), this;
+  }
+  chop() {
+    const t = this.ops[this.ops.length - 1];
+    return t && typeof t.retain == "number" && !t.attributes && this.ops.pop(), this;
+  }
+  filter(t) {
+    return this.ops.filter(t);
+  }
+  forEach(t) {
+    this.ops.forEach(t);
+  }
+  map(t) {
+    return this.ops.map(t);
+  }
+  partition(t) {
+    const e = [], s = [];
+    return this.forEach((i) => {
+      (t(i) ? e : s).push(i);
+    }), [e, s];
+  }
+  reduce(t, e) {
+    return this.ops.reduce(t, e);
+  }
+  changeLength() {
+    return this.reduce((t, e) => e.insert ? t + k.length(e) : e.delete ? t - e.delete : t, 0);
+  }
+  length() {
+    return this.reduce((t, e) => t + k.length(e), 0);
+  }
+  slice(t = 0, e = 1 / 0) {
+    const s = [], i = new R(this.ops);
+    let n = 0;
+    for (; n < e && i.hasNext(); ) {
+      let o;
+      n < t ? o = i.next(t - n) : (o = i.next(e - n), s.push(o)), n += k.length(o);
+    }
+    return new f(s);
+  }
+  compose(t) {
+    const e = new R(this.ops), s = new R(t.ops), i = [], n = s.peek();
+    if (n != null && typeof n.retain == "number" && n.attributes == null) {
+      let l = n.retain;
+      for (; e.peekType() === "insert" && e.peekLength() <= l; )
+        l -= e.peekLength(), i.push(e.next());
+      n.retain - l > 0 && s.next(n.retain - l);
+    }
+    const o = new f(i);
+    for (; e.hasNext() || s.hasNext(); )
+      if (s.peekType() === "insert")
+        o.push(s.next());
+      else if (e.peekType() === "delete")
+        o.push(e.next());
+      else {
+        const l = Math.min(e.peekLength(), s.peekLength()), a = e.next(l), c = s.next(l);
+        if (c.retain) {
+          const h = {};
+          if (typeof a.retain == "number")
+            h.retain = typeof c.retain == "number" ? l : c.retain;
+          else if (typeof c.retain == "number")
+            a.retain == null ? h.insert = a.insert : h.retain = a.retain;
+          else {
+            const g = a.retain == null ? "insert" : "retain", [b, N, E] = jt(
+              a[g],
+              c.retain
+            ), w = f.getHandler(b);
+            h[g] = {
+              [b]: w.compose(
+                N,
+                E,
+                g === "retain"
+              )
+            };
+          }
+          const d = C.compose(
+            a.attributes,
+            c.attributes,
+            typeof a.retain == "number"
+          );
+          if (d && (h.attributes = d), o.push(h), !s.hasNext() && X(o.ops[o.ops.length - 1], h)) {
+            const g = new f(e.rest());
+            return o.concat(g).chop();
+          }
+        } else typeof c.delete == "number" && (typeof a.retain == "number" || typeof a.retain == "object" && a.retain !== null) && o.push(c);
+      }
+    return o.chop();
+  }
+  concat(t) {
+    const e = new f(this.ops.slice());
+    return t.ops.length > 0 && (e.push(t.ops[0]), e.ops = e.ops.concat(t.ops.slice(1))), e;
+  }
+  diff(t, e) {
+    if (this.ops === t.ops)
+      return new f();
+    const s = [this, t].map((a) => a.map((c) => {
+      if (c.insert != null)
+        return typeof c.insert == "string" ? c.insert : de;
+      const h = a === t ? "on" : "with";
+      throw new Error("diff() called " + h + " non-document");
+    }).join("")), i = new f(), n = lt(s[0], s[1], e, !0), o = new R(this.ops), l = new R(t.ops);
+    return n.forEach((a) => {
+      let c = a[1].length;
+      for (; c > 0; ) {
+        let h = 0;
+        switch (a[0]) {
+          case lt.INSERT:
+            h = Math.min(l.peekLength(), c), i.push(l.next(h));
+            break;
+          case lt.DELETE:
+            h = Math.min(c, o.peekLength()), o.next(h), i.delete(h);
+            break;
+          case lt.EQUAL:
+            h = Math.min(
+              o.peekLength(),
+              l.peekLength(),
+              c
+            );
+            const d = o.next(h), g = l.next(h);
+            X(d.insert, g.insert) ? i.retain(
+              h,
+              C.diff(d.attributes, g.attributes)
+            ) : i.push(g).delete(h);
+            break;
+        }
+        c -= h;
+      }
+    }), i.chop();
+  }
+  eachLine(t, e = `
+`) {
+    const s = new R(this.ops);
+    let i = new f(), n = 0;
+    for (; s.hasNext(); ) {
+      if (s.peekType() !== "insert")
+        return;
+      const o = s.peek(), l = k.length(o) - s.peekLength(), a = typeof o.insert == "string" ? o.insert.indexOf(e, l) - l : -1;
+      if (a < 0)
+        i.push(s.next());
+      else if (a > 0)
+        i.push(s.next(a));
+      else {
+        if (t(i, s.next(1).attributes || {}, n) === !1)
+          return;
+        n += 1, i = new f();
+      }
+    }
+    i.length() > 0 && t(i, {}, n);
+  }
+  invert(t) {
+    const e = new f();
+    return this.reduce((s, i) => {
+      if (i.insert)
+        e.delete(k.length(i));
+      else {
+        if (typeof i.retain == "number" && i.attributes == null)
+          return e.retain(i.retain), s + i.retain;
+        if (i.delete || typeof i.retain == "number") {
+          const n = i.delete || i.retain;
+          return t.slice(s, s + n).forEach((l) => {
+            i.delete ? e.push(l) : i.retain && i.attributes && e.retain(
+              k.length(l),
+              C.invert(i.attributes, l.attributes)
+            );
+          }), s + n;
+        } else if (typeof i.retain == "object" && i.retain !== null) {
+          const n = t.slice(s, s + 1), o = new R(n.ops).next(), [l, a, c] = jt(
+            i.retain,
+            o.insert
+          ), h = f.getHandler(l);
+          return e.retain(
+            { [l]: h.invert(a, c) },
+            C.invert(i.attributes, o.attributes)
+          ), s + 1;
+        }
+      }
+      return s;
+    }, 0), e.chop();
+  }
+  transform(t, e = !1) {
+    if (e = !!e, typeof t == "number")
+      return this.transformPosition(t, e);
+    const s = t, i = new R(this.ops), n = new R(s.ops), o = new f();
+    for (; i.hasNext() || n.hasNext(); )
+      if (i.peekType() === "insert" && (e || n.peekType() !== "insert"))
+        o.retain(k.length(i.next()));
+      else if (n.peekType() === "insert")
+        o.push(n.next());
+      else {
+        const l = Math.min(i.peekLength(), n.peekLength()), a = i.next(l), c = n.next(l);
+        if (a.delete)
+          continue;
+        if (c.delete)
+          o.push(c);
+        else {
+          const h = a.retain, d = c.retain;
+          let g = typeof d == "object" && d !== null ? d : l;
+          if (typeof h == "object" && h !== null && typeof d == "object" && d !== null) {
+            const b = Object.keys(h)[0];
+            if (b === Object.keys(d)[0]) {
+              const N = f.getHandler(b);
+              N && (g = {
+                [b]: N.transform(
+                  h[b],
+                  d[b],
+                  e
+                )
+              });
+            }
+          }
+          o.retain(
+            g,
+            C.transform(
+              a.attributes,
+              c.attributes,
+              e
+            )
+          );
+        }
+      }
+    return o.chop();
+  }
+  transformPosition(t, e = !1) {
+    e = !!e;
+    const s = new R(this.ops);
+    let i = 0;
+    for (; s.hasNext() && i <= t; ) {
+      const n = s.peekLength(), o = s.peekType();
+      if (s.next(), o === "delete") {
+        t -= Math.min(n, t - i);
+        continue;
+      } else o === "insert" && (i < t || !e) && (t += n);
+      i += n;
+    }
+    return t;
+  }
+}
+var p = /* @__PURE__ */ ((r) => (r[r.TYPE = 3] = "TYPE", r[r.LEVEL = 12] = "LEVEL", r[r.ATTRIBUTE = 13] = "ATTRIBUTE", r[r.BLOT = 14] = "BLOT", r[r.INLINE = 7] = "INLINE", r[r.BLOCK = 11] = "BLOCK", r[r.BLOCK_BLOT = 10] = "BLOCK_BLOT", r[r.INLINE_BLOT = 6] = "INLINE_BLOT", r[r.BLOCK_ATTRIBUTE = 9] = "BLOCK_ATTRIBUTE", r[r.INLINE_ATTRIBUTE = 5] = "INLINE_ATTRIBUTE", r[r.ANY = 15] = "ANY", r))(p || {});
+class pe {
+  constructor() {
+    this.head = null, this.tail = null, this.length = 0;
+  }
+  append(...t) {
+    if (this.insertBefore(t[0], null), t.length > 1) {
+      const e = t.slice(1);
+      this.append(...e);
+    }
+  }
+  at(t) {
+    const e = this.iterator();
+    let s = e();
+    for (; s && t > 0; )
+      t -= 1, s = e();
+    return s;
+  }
+  contains(t) {
+    const e = this.iterator();
+    let s = e();
+    for (; s; ) {
+      if (s === t)
+        return !0;
+      s = e();
+    }
+    return !1;
+  }
+  indexOf(t) {
+    const e = this.iterator();
+    let s = e(), i = 0;
+    for (; s; ) {
+      if (s === t)
+        return i;
+      i += 1, s = e();
+    }
+    return -1;
+  }
+  insertBefore(t, e) {
+    t != null && (this.remove(t), t.next = e, e != null ? (t.prev = e.prev, e.prev != null && (e.prev.next = t), e.prev = t, e === this.head && (this.head = t)) : this.tail != null ? (this.tail.next = t, t.prev = this.tail, this.tail = t) : (t.prev = null, this.head = this.tail = t), this.length += 1);
+  }
+  offset(t) {
+    let e = 0, s = this.head;
+    for (; s != null; ) {
+      if (s === t)
+        return e;
+      e += s.length(), s = s.next;
+    }
+    return -1;
+  }
+  remove(t) {
+    this.contains(t) && (t.prev != null && (t.prev.next = t.next), t.next != null && (t.next.prev = t.prev), t === this.head && (this.head = t.next), t === this.tail && (this.tail = t.prev), this.length -= 1);
+  }
+  iterator(t = this.head) {
+    return () => {
+      const e = t;
+      return t != null && (t = t.next), e;
+    };
+  }
+  find(t, e = !1) {
+    const s = this.iterator();
+    let i = s();
+    for (; i; ) {
+      const n = i.length();
+      if (t < n || e && t === n && (i.next == null || i.next.length() !== 0))
+        return [i, t];
+      t -= n, i = s();
+    }
+    return [null, 0];
+  }
+  forEach(t) {
+    const e = this.iterator();
+    let s = e();
+    for (; s; )
+      t(s), s = e();
+  }
+  forEachAt(t, e, s) {
+    if (e <= 0)
+      return;
+    const [i, n] = this.find(t);
+    let o = t - n;
+    const l = this.iterator(i);
+    let a = l();
+    for (; a && o < t + e; ) {
+      const c = a.length();
+      t > o ? s(
+        a,
+        t - o,
+        Math.min(e, o + c - t)
+      ) : s(a, 0, Math.min(c, t + e - o)), o += c, a = l();
+    }
+  }
+  map(t) {
+    return this.reduce((e, s) => (e.push(t(s)), e), []);
+  }
+  reduce(t, e) {
+    const s = this.iterator();
+    let i = s();
+    for (; i; )
+      e = t(e, i), i = s();
+    return e;
+  }
+}
+class J extends Error {
+  constructor(t) {
+    t = "[Parchment] " + t, super(t), this.message = t, this.name = this.constructor.name;
+  }
+}
+class K {
+  constructor() {
+    this.attributes = {}, this.classes = {}, this.tags = {}, this.types = {};
+  }
+  static {
+    this.blots = /* @__PURE__ */ new WeakMap();
+  }
+  static find(t, e = !1) {
+    if (t == null)
+      return null;
+    if (this.blots.has(t))
+      return this.blots.get(t) || null;
+    if (e) {
+      let s = null;
+      try {
+        s = t.parentNode;
+      } catch {
+        return null;
+      }
+      return this.find(s, e);
+    }
+    return null;
+  }
+  create(t, e, s) {
+    const i = this.query(e);
+    if (i == null)
+      throw new J(`Unable to create ${e} blot`);
+    const n = i, o = e instanceof Node || e.nodeType === Node.TEXT_NODE ? e : n.create(s), l = new n(t, o, s);
+    return K.blots.set(l.domNode, l), l;
+  }
+  find(t, e = !1) {
+    return K.find(t, e);
+  }
+  query(t, e = p.ANY) {
+    let s;
+    return typeof t == "string" ? s = this.types[t] || this.attributes[t] : t instanceof Text || t.nodeType === Node.TEXT_NODE ? s = this.types.text : typeof t == "number" ? t & p.LEVEL & p.BLOCK ? s = this.types.block : t & p.LEVEL & p.INLINE && (s = this.types.inline) : t instanceof Element && ((t.getAttribute("class") || "").split(/\s+/).some((n) => (s = this.classes[n], !!s)), s = s || this.tags[t.tagName]), s == null ? null : "scope" in s && e & p.LEVEL & s.scope && e & p.TYPE & s.scope ? s : null;
+  }
+  register(...t) {
+    return t.map((e) => {
+      const s = "blotName" in e, i = "attrName" in e;
+      if (!s && !i)
+        throw new J("Invalid definition");
+      if (s && e.blotName === "abstract")
+        throw new J("Cannot register abstract class");
+      const n = s ? e.blotName : i ? e.attrName : void 0;
+      return this.types[n] = e, i ? typeof e.keyName == "string" && (this.attributes[e.keyName] = e) : s && (e.className && (this.classes[e.className] = e), e.tagName && (Array.isArray(e.tagName) ? e.tagName = e.tagName.map((l) => l.toUpperCase()) : e.tagName = e.tagName.toUpperCase(), (Array.isArray(e.tagName) ? e.tagName : [e.tagName]).forEach((l) => {
+        (this.tags[l] == null || e.className == null) && (this.tags[l] = e);
+      }))), e;
+    });
+  }
+}
+class ee {
+  constructor(t, e) {
+    this.scroll = t, this.domNode = e, K.blots.set(e, this), this.prev = null, this.next = null;
+  }
+  static {
+    this.blotName = "abstract";
+  }
+  static create(t) {
+    if (this.tagName == null)
+      throw new J("Blot definition missing tagName");
+    let e, s;
+    return Array.isArray(this.tagName) ? (typeof t == "string" ? (s = t.toUpperCase(), parseInt(s, 10).toString() === s && (s = parseInt(s, 10))) : typeof t == "number" && (s = t), typeof s == "number" ? e = document.createElement(this.tagName[s - 1]) : s && this.tagName.indexOf(s) > -1 ? e = document.createElement(s) : e = document.createElement(this.tagName[0])) : e = document.createElement(this.tagName), this.className && e.classList.add(this.className), e;
+  }
+  // Hack for accessing inherited static methods
+  get statics() {
+    return this.constructor;
+  }
+  attach() {
+  }
+  clone() {
+    const t = this.domNode.cloneNode(!1);
+    return this.scroll.create(t);
+  }
+  detach() {
+    this.parent != null && this.parent.removeChild(this), K.blots.delete(this.domNode);
+  }
+  deleteAt(t, e) {
+    this.isolate(t, e).remove();
+  }
+  formatAt(t, e, s, i) {
+    const n = this.isolate(t, e);
+    if (this.scroll.query(s, p.BLOT) != null && i)
+      n.wrap(s, i);
+    else if (this.scroll.query(s, p.ATTRIBUTE) != null) {
+      const o = this.scroll.create(this.statics.scope);
+      n.wrap(o), o.format(s, i);
+    }
+  }
+  insertAt(t, e, s) {
+    const i = s == null ? this.scroll.create("text", e) : this.scroll.create(e, s), n = this.split(t);
+    this.parent.insertBefore(i, n || void 0);
+  }
+  isolate(t, e) {
+    const s = this.split(t);
+    if (s == null)
+      throw new Error("Attempt to isolate at end");
+    return s.split(e), s;
+  }
+  length() {
+    return 1;
+  }
+  offset(t = this.parent) {
+    return this.parent == null || this === t ? 0 : this.parent.children.offset(this) + this.parent.offset(t);
+  }
+  optimize(t) {
+    this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer) && this.wrap(this.statics.requiredContainer.blotName);
+  }
+  remove() {
+    this.domNode.parentNode != null && this.domNode.parentNode.removeChild(this.domNode), this.detach();
+  }
+  replaceWith(t, e) {
+    const s = typeof t == "string" ? this.scroll.create(t, e) : t;
+    return this.parent != null && (this.parent.insertBefore(s, this.next || void 0), this.remove()), s;
+  }
+  split(t, e) {
+    return t === 0 ? this : this.next;
+  }
+  update(t, e) {
+  }
+  wrap(t, e) {
+    const s = typeof t == "string" ? this.scroll.create(t, e) : t;
+    if (this.parent != null && this.parent.insertBefore(s, this.next || void 0), typeof s.appendChild != "function")
+      throw new J(`Cannot wrap ${t}`);
+    return s.appendChild(this), s;
+  }
+}
+function $t(r, t) {
+  const e = t.find(r);
+  if (e) return e;
+  try {
+    return t.create(r);
+  } catch {
+    const i = t.create(p.INLINE);
+    return Array.from(r.childNodes).forEach((n) => {
+      i.domNode.appendChild(n);
+    }), r.parentNode && r.parentNode.replaceChild(i.domNode, r), i.attach(), i;
+  }
+}
+class T extends ee {
+  constructor(t, e) {
+    super(t, e), this.uiNode = null, this.build();
+  }
+  static {
+    this.uiClass = "";
+  }
+  appendChild(t) {
+    this.insertBefore(t);
+  }
+  attach() {
+    super.attach(), this.children.forEach((t) => {
+      t.attach();
+    });
+  }
+  attachUI(t) {
+    this.uiNode != null && this.uiNode.remove(), this.uiNode = t, T.uiClass && this.uiNode.classList.add(T.uiClass), this.uiNode.setAttribute("contenteditable", "false"), this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
+  }
+  /**
+   * Called during construction, should fill its own children LinkedList.
+   */
+  build() {
+    this.children = new pe(), Array.from(this.domNode.childNodes).filter((t) => t !== this.uiNode).reverse().forEach((t) => {
+      try {
+        const e = $t(t, this.scroll);
+        this.insertBefore(e, this.children.head || void 0);
+      } catch (e) {
+        if (e instanceof J)
+          return;
+        throw e;
+      }
+    });
+  }
+  deleteAt(t, e) {
+    if (t === 0 && e === this.length())
+      return this.remove();
+    this.children.forEachAt(t, e, (s, i, n) => {
+      s.deleteAt(i, n);
+    });
+  }
+  descendant(t, e = 0) {
+    const [s, i] = this.children.find(e);
+    return t.blotName == null && t(s) || t.blotName != null && s instanceof t ? [s, i] : s instanceof T ? s.descendant(t, i) : [null, -1];
+  }
+  descendants(t, e = 0, s = Number.MAX_VALUE) {
+    let i = [], n = s;
+    return this.children.forEachAt(
+      e,
+      s,
+      (o, l, a) => {
+        (t.blotName == null && t(o) || t.blotName != null && o instanceof t) && i.push(o), o instanceof T && (i = i.concat(
+          o.descendants(t, l, n)
+        )), n -= a;
+      }
+    ), i;
+  }
+  detach() {
+    this.children.forEach((t) => {
+      t.detach();
+    }), super.detach();
+  }
+  enforceAllowedChildren() {
+    let t = !1;
+    this.children.forEach((e) => {
+      t || this.statics.allowedChildren.some(
+        (i) => e instanceof i
+      ) || (e.statics.scope === p.BLOCK_BLOT ? (e.next != null && this.splitAfter(e), e.prev != null && this.splitAfter(e.prev), e.parent.unwrap(), t = !0) : e instanceof T ? e.unwrap() : e.remove());
+    });
+  }
+  formatAt(t, e, s, i) {
+    this.children.forEachAt(t, e, (n, o, l) => {
+      n.formatAt(o, l, s, i);
+    });
+  }
+  insertAt(t, e, s) {
+    const [i, n] = this.children.find(t);
+    if (i)
+      i.insertAt(n, e, s);
+    else {
+      const o = s == null ? this.scroll.create("text", e) : this.scroll.create(e, s);
+      this.appendChild(o);
+    }
+  }
+  insertBefore(t, e) {
+    t.parent != null && t.parent.children.remove(t);
+    let s = null;
+    this.children.insertBefore(t, e || null), t.parent = this, e != null && (s = e.domNode), (this.domNode.parentNode !== t.domNode || this.domNode.nextSibling !== s) && this.domNode.insertBefore(t.domNode, s), t.attach();
+  }
+  length() {
+    return this.children.reduce((t, e) => t + e.length(), 0);
+  }
+  moveChildren(t, e) {
+    this.children.forEach((s) => {
+      t.insertBefore(s, e);
+    });
+  }
+  optimize(t) {
+    if (super.optimize(t), this.enforceAllowedChildren(), this.uiNode != null && this.uiNode !== this.domNode.firstChild && this.domNode.insertBefore(this.uiNode, this.domNode.firstChild), this.children.length === 0)
+      if (this.statics.defaultChild != null) {
+        const e = this.scroll.create(this.statics.defaultChild.blotName);
+        this.appendChild(e);
+      } else
+        this.remove();
+  }
+  path(t, e = !1) {
+    const [s, i] = this.children.find(t, e), n = [[this, t]];
+    return s instanceof T ? n.concat(s.path(i, e)) : (s != null && n.push([s, i]), n);
+  }
+  removeChild(t) {
+    this.children.remove(t);
+  }
+  replaceWith(t, e) {
+    const s = typeof t == "string" ? this.scroll.create(t, e) : t;
+    return s instanceof T && this.moveChildren(s), super.replaceWith(s);
+  }
+  split(t, e = !1) {
+    if (!e) {
+      if (t === 0)
+        return this;
+      if (t === this.length())
+        return this.next;
+    }
+    const s = this.clone();
+    return this.parent && this.parent.insertBefore(s, this.next || void 0), this.children.forEachAt(t, this.length(), (i, n, o) => {
+      const l = i.split(n, e);
+      l != null && s.appendChild(l);
+    }), s;
+  }
+  splitAfter(t) {
+    const e = this.clone();
+    for (; t.next != null; )
+      e.appendChild(t.next);
+    return this.parent && this.parent.insertBefore(e, this.next || void 0), e;
+  }
+  unwrap() {
+    this.parent && this.moveChildren(this.parent, this.next || void 0), this.remove();
+  }
+  update(t, e) {
+    const s = [], i = [];
+    t.forEach((n) => {
+      n.target === this.domNode && n.type === "childList" && (s.push(...n.addedNodes), i.push(...n.removedNodes));
+    }), i.forEach((n) => {
+      if (n.parentNode != null && n.tagName !== "IFRAME" && document.body.compareDocumentPosition(n) & Node.DOCUMENT_POSITION_CONTAINED_BY)
+        return;
+      const o = this.scroll.find(n);
+      o != null && (o.domNode.parentNode == null || o.domNode.parentNode === this.domNode) && o.detach();
+    }), s.filter((n) => n.parentNode === this.domNode && n !== this.uiNode).sort((n, o) => n === o ? 0 : n.compareDocumentPosition(o) & Node.DOCUMENT_POSITION_FOLLOWING ? 1 : -1).forEach((n) => {
+      let o = null;
+      n.nextSibling != null && (o = this.scroll.find(n.nextSibling));
+      const l = $t(n, this.scroll);
+      (l.next !== o || l.next == null) && (l.parent != null && l.parent.removeChild(this), this.insertBefore(l, o || void 0));
+    }), this.enforceAllowedChildren();
+  }
+}
+class dt extends T {
+  static {
+    this.blotName = "container";
+  }
+  static {
+    this.scope = p.BLOCK_BLOT;
+  }
+  checkMerge() {
+    return this.next !== null && this.next.statics.blotName === this.statics.blotName;
+  }
+  deleteAt(t, e) {
+    super.deleteAt(t, e), this.enforceAllowedChildren();
+  }
+  formatAt(t, e, s, i) {
+    super.formatAt(t, e, s, i), this.enforceAllowedChildren();
+  }
+  insertAt(t, e, s) {
+    super.insertAt(t, e, s), this.enforceAllowedChildren();
+  }
+  optimize(t) {
+    super.optimize(t), this.children.length > 0 && this.next != null && this.checkMerge() && (this.next.moveChildren(this), this.next.remove());
+  }
+}
+class A extends ee {
+  static {
+    this.scope = p.INLINE_BLOT;
+  }
+  /**
+   * Returns the value represented by domNode if it is this Blot's type
+   * No checking that domNode can represent this Blot type is required so
+   * applications needing it should check externally before calling.
+   */
+  static value(t) {
+    return !0;
+  }
+  /**
+   * Given location represented by node and offset from DOM Selection Range,
+   * return index to that location.
+   */
+  index(t, e) {
+    return this.domNode === t || this.domNode.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_CONTAINED_BY ? Math.min(e, 1) : -1;
+  }
+  /**
+   * Given index to location within blot, return node and offset representing
+   * that location, consumable by DOM Selection Range
+   */
+  position(t, e) {
+    let i = Array.from(this.parent.domNode.childNodes).indexOf(this.domNode);
+    return t > 0 && (i += 1), [this.parent.domNode, i];
+  }
+  /**
+   * Return value represented by this blot
+   * Should not change without interaction from API or
+   * user change detectable by update()
+   */
+  value() {
+    return {
+      [this.statics.blotName]: this.statics.value(this.domNode) || !0
+    };
+  }
+}
+class j {
+  constructor(t, e, s = {}) {
+    this.attrName = t, this.keyName = e;
+    const i = p.TYPE & p.ATTRIBUTE;
+    this.scope = s.scope != null ? (
+      // Ignore type bits, force attribute bit
+      s.scope & p.LEVEL | i
+    ) : p.ATTRIBUTE, s.whitelist != null && (this.whitelist = s.whitelist);
+  }
+  static keys(t) {
+    return Array.from(t.attributes).map((e) => e.name);
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (t.setAttribute(this.keyName, e), !0) : !1;
+  }
+  canAdd(t, e) {
+    return this.whitelist == null ? !0 : typeof e == "string" ? this.whitelist.indexOf(e.replace(/["']/g, "")) > -1 : this.whitelist.indexOf(e) > -1;
+  }
+  remove(t) {
+    t.removeAttribute(this.keyName);
+  }
+  value(t) {
+    const e = t.getAttribute(this.keyName);
+    return this.canAdd(t, e) && e ? e : "";
+  }
+}
+function Ft(r, t) {
+  return (r.getAttribute("class") || "").split(/\s+/).filter((s) => s.indexOf(`${t}-`) === 0);
+}
+class q extends j {
+  static keys(t) {
+    return (t.getAttribute("class") || "").split(/\s+/).map((e) => e.split("-").slice(0, -1).join("-"));
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (this.remove(t), t.classList.add(`${this.keyName}-${e}`), !0) : !1;
+  }
+  remove(t) {
+    Ft(t, this.keyName).forEach((s) => {
+      t.classList.remove(s);
+    }), t.classList.length === 0 && t.removeAttribute("class");
+  }
+  value(t) {
+    const s = (Ft(t, this.keyName)[0] || "").slice(this.keyName.length + 1);
+    return this.canAdd(t, s) ? s : "";
+  }
+}
+function bt(r) {
+  const t = r.split("-"), e = t.slice(1).map((s) => s[0].toUpperCase() + s.slice(1)).join("");
+  return t[0] + e;
+}
+class V extends j {
+  static keys(t) {
+    return (t.getAttribute("style") || "").split(";").map((e) => e.split(":")[0].trim());
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (t.style[bt(this.keyName)] = e, !0) : !1;
+  }
+  remove(t) {
+    t.style[bt(this.keyName)] = "", t.getAttribute("style") || t.removeAttribute("style");
+  }
+  value(t) {
+    const e = t.style[bt(this.keyName)];
+    return this.canAdd(t, e) ? e : "";
+  }
+}
+class pt {
+  constructor(t) {
+    this.attributes = {}, this.domNode = t, this.build();
+  }
+  attribute(t, e) {
+    e ? t.add(this.domNode, e) && (t.value(this.domNode) != null ? this.attributes[t.attrName] = t : delete this.attributes[t.attrName]) : (t.remove(this.domNode), delete this.attributes[t.attrName]);
+  }
+  build() {
+    this.attributes = {};
+    const t = K.find(this.domNode);
+    if (t == null)
+      return;
+    const e = j.keys(this.domNode), s = q.keys(this.domNode), i = V.keys(this.domNode);
+    e.concat(s).concat(i).forEach((n) => {
+      const o = t.scroll.query(n, p.ATTRIBUTE);
+      o instanceof j && (this.attributes[o.attrName] = o);
+    });
+  }
+  copy(t) {
+    Object.keys(this.attributes).forEach((e) => {
+      const s = this.attributes[e].value(this.domNode);
+      t.format(e, s);
+    });
+  }
+  move(t) {
+    this.copy(t), Object.keys(this.attributes).forEach((e) => {
+      this.attributes[e].remove(this.domNode);
+    }), this.attributes = {};
+  }
+  values() {
+    return Object.keys(this.attributes).reduce(
+      (t, e) => (t[e] = this.attributes[e].value(this.domNode), t),
+      {}
+    );
+  }
+}
+function me(r, t) {
+  if (Object.keys(r).length !== Object.keys(t).length)
+    return !1;
+  for (const e in r)
+    if (r[e] !== t[e])
+      return !1;
+  return !0;
+}
+class D extends T {
+  static {
+    this.allowedChildren = [D, A];
+  }
+  static {
+    this.blotName = "inline";
+  }
+  static {
+    this.scope = p.INLINE_BLOT;
+  }
+  static {
+    this.tagName = "SPAN";
+  }
+  static create(t) {
+    return super.create(t);
+  }
+  static formats(t, e) {
+    const s = e.query(D.blotName);
+    if (!(s != null && t.tagName === s.tagName)) {
+      if (typeof this.tagName == "string")
+        return !0;
+      if (Array.isArray(this.tagName))
+        return t.tagName.toLowerCase();
+    }
+  }
+  constructor(t, e) {
+    super(t, e), this.attributes = new pt(this.domNode);
+  }
+  format(t, e) {
+    if (t === this.statics.blotName && !e)
+      this.children.forEach((s) => {
+        s instanceof D || (s = s.wrap(D.blotName, !0)), this.attributes.copy(s);
+      }), this.unwrap();
+    else {
+      const s = this.scroll.query(t, p.INLINE);
+      if (s == null)
+        return;
+      s instanceof j ? this.attributes.attribute(s, e) : e && (t !== this.statics.blotName || this.formats()[t] !== e) && this.replaceWith(t, e);
+    }
+  }
+  formats() {
+    const t = this.attributes.values(), e = this.statics.formats(this.domNode, this.scroll);
+    return e != null && (t[this.statics.blotName] = e), t;
+  }
+  formatAt(t, e, s, i) {
+    this.formats()[s] != null || this.scroll.query(s, p.ATTRIBUTE) ? this.isolate(t, e).format(s, i) : super.formatAt(t, e, s, i);
+  }
+  optimize(t) {
+    super.optimize(t);
+    const e = this.formats();
+    if (Object.keys(e).length === 0)
+      return this.unwrap();
+    const s = this.next;
+    s instanceof D && s.prev === this && me(e, s.formats()) && (s.moveChildren(this), s.remove());
+  }
+  replaceWith(t, e) {
+    const s = super.replaceWith(t, e);
+    return this.attributes.copy(s), s;
+  }
+  update(t, e) {
+    super.update(t, e), t.some(
+      (i) => i.target === this.domNode && i.type === "attributes"
+    ) && this.attributes.build();
+  }
+  wrap(t, e) {
+    const s = super.wrap(t, e);
+    return s instanceof D && this.attributes.move(s), s;
+  }
+}
+class _ extends T {
+  static {
+    this.blotName = "block";
+  }
+  static {
+    this.scope = p.BLOCK_BLOT;
+  }
+  static {
+    this.tagName = "P";
+  }
+  static {
+    this.allowedChildren = [
+      D,
+      _,
+      A
+    ];
+  }
+  static create(t) {
+    return super.create(t);
+  }
+  static formats(t, e) {
+    const s = e.query(_.blotName);
+    if (!(s != null && t.tagName === s.tagName)) {
+      if (typeof this.tagName == "string")
+        return !0;
+      if (Array.isArray(this.tagName))
+        return t.tagName.toLowerCase();
+    }
+  }
+  constructor(t, e) {
+    super(t, e), this.attributes = new pt(this.domNode);
+  }
+  format(t, e) {
+    const s = this.scroll.query(t, p.BLOCK);
+    s != null && (s instanceof j ? this.attributes.attribute(s, e) : t === this.statics.blotName && !e ? this.replaceWith(_.blotName) : e && (t !== this.statics.blotName || this.formats()[t] !== e) && this.replaceWith(t, e));
+  }
+  formats() {
+    const t = this.attributes.values(), e = this.statics.formats(this.domNode, this.scroll);
+    return e != null && (t[this.statics.blotName] = e), t;
+  }
+  formatAt(t, e, s, i) {
+    this.scroll.query(s, p.BLOCK) != null ? this.format(s, i) : super.formatAt(t, e, s, i);
+  }
+  insertAt(t, e, s) {
+    if (s == null || this.scroll.query(e, p.INLINE) != null)
+      super.insertAt(t, e, s);
+    else {
+      const i = this.split(t);
+      if (i != null) {
+        const n = this.scroll.create(e, s);
+        i.parent.insertBefore(n, i);
+      } else
+        throw new Error("Attempt to insertAt after block boundaries");
+    }
+  }
+  replaceWith(t, e) {
+    const s = super.replaceWith(t, e);
+    return this.attributes.copy(s), s;
+  }
+  update(t, e) {
+    super.update(t, e), t.some(
+      (i) => i.target === this.domNode && i.type === "attributes"
+    ) && this.attributes.build();
+  }
+}
+class B extends A {
+  static formats(t, e) {
+  }
+  format(t, e) {
+    super.formatAt(0, this.length(), t, e);
+  }
+  formatAt(t, e, s, i) {
+    t === 0 && e === this.length() ? this.format(s, i) : super.formatAt(t, e, s, i);
+  }
+  formats() {
+    return this.statics.formats(this.domNode, this.scroll);
+  }
+}
+const ge = {
+  attributes: !0,
+  characterData: !0,
+  characterDataOldValue: !0,
+  childList: !0,
+  subtree: !0
+}, be = 100;
+class It extends T {
+  constructor(t, e) {
+    super(null, e), this.registry = t, this.scroll = this, this.build(), this.observer = new MutationObserver((s) => {
+      this.update(s);
+    }), this.observer.observe(this.domNode, ge), this.attach();
+  }
+  static {
+    this.blotName = "scroll";
+  }
+  static {
+    this.defaultChild = _;
+  }
+  static {
+    this.allowedChildren = [_, dt];
+  }
+  static {
+    this.scope = p.BLOCK_BLOT;
+  }
+  static {
+    this.tagName = "DIV";
+  }
+  create(t, e) {
+    return this.registry.create(this, t, e);
+  }
+  find(t, e = !1) {
+    const s = this.registry.find(t, e);
+    return s ? s.scroll === this ? s : e ? this.find(s.scroll.domNode.parentNode, !0) : null : null;
+  }
+  query(t, e = p.ANY) {
+    return this.registry.query(t, e);
+  }
+  register(...t) {
+    return this.registry.register(...t);
+  }
+  build() {
+    this.scroll != null && super.build();
+  }
+  detach() {
+    super.detach(), this.observer.disconnect();
+  }
+  deleteAt(t, e) {
+    this.update(), t === 0 && e === this.length() ? this.children.forEach((s) => {
+      s.remove();
+    }) : super.deleteAt(t, e);
+  }
+  formatAt(t, e, s, i) {
+    this.update(), super.formatAt(t, e, s, i);
+  }
+  insertAt(t, e, s) {
+    this.update(), super.insertAt(t, e, s);
+  }
+  optimize(t = [], e = {}) {
+    super.optimize(e);
+    const s = e.mutationsMap || /* @__PURE__ */ new WeakMap();
+    let i = Array.from(this.observer.takeRecords());
+    for (; i.length > 0; )
+      t.push(i.pop());
+    const n = (a, c = !0) => {
+      a == null || a === this || a.domNode.parentNode != null && (s.has(a.domNode) || s.set(a.domNode, []), c && n(a.parent));
+    }, o = (a) => {
+      s.has(a.domNode) && (a instanceof T && a.children.forEach(o), s.delete(a.domNode), a.optimize(e));
+    };
+    let l = t;
+    for (let a = 0; l.length > 0; a += 1) {
+      if (a >= be)
+        throw new Error("[Parchment] Maximum optimize iterations reached");
+      for (l.forEach((c) => {
+        const h = this.find(c.target, !0);
+        h != null && (h.domNode === c.target && (c.type === "childList" ? (n(this.find(c.previousSibling, !1)), Array.from(c.addedNodes).forEach((d) => {
+          const g = this.find(d, !1);
+          n(g, !1), g instanceof T && g.children.forEach((b) => {
+            n(b, !1);
+          });
+        })) : c.type === "attributes" && n(h.prev)), n(h));
+      }), this.children.forEach(o), l = Array.from(this.observer.takeRecords()), i = l.slice(); i.length > 0; )
+        t.push(i.pop());
+    }
+  }
+  update(t, e = {}) {
+    t = t || this.observer.takeRecords();
+    const s = /* @__PURE__ */ new WeakMap();
+    t.map((i) => {
+      const n = this.find(i.target, !0);
+      return n == null ? null : s.has(n.domNode) ? (s.get(n.domNode).push(i), null) : (s.set(n.domNode, [i]), n);
+    }).forEach((i) => {
+      i != null && i !== this && s.has(i.domNode) && i.update(s.get(i.domNode) || [], e);
+    }), e.mutationsMap = s, s.has(this.domNode) && super.update(s.get(this.domNode), e), this.optimize(t, e);
+  }
+}
+class et extends A {
+  static {
+    this.blotName = "text";
+  }
+  static {
+    this.scope = p.INLINE_BLOT;
+  }
+  static create(t) {
+    return document.createTextNode(t);
+  }
+  static value(t) {
+    return t.data;
+  }
+  constructor(t, e) {
+    super(t, e), this.text = this.statics.value(this.domNode);
+  }
+  deleteAt(t, e) {
+    this.domNode.data = this.text = this.text.slice(0, t) + this.text.slice(t + e);
+  }
+  index(t, e) {
+    return this.domNode === t ? e : -1;
+  }
+  insertAt(t, e, s) {
+    s == null ? (this.text = this.text.slice(0, t) + e + this.text.slice(t), this.domNode.data = this.text) : super.insertAt(t, e, s);
+  }
+  length() {
+    return this.text.length;
+  }
+  optimize(t) {
+    super.optimize(t), this.text = this.statics.value(this.domNode), this.text.length === 0 ? this.remove() : this.next instanceof et && this.next.prev === this && (this.insertAt(this.length(), this.next.value()), this.next.remove());
+  }
+  position(t, e = !1) {
+    return [this.domNode, t];
+  }
+  split(t, e = !1) {
+    if (!e) {
+      if (t === 0)
+        return this;
+      if (t === this.length())
+        return this.next;
+    }
+    const s = this.scroll.create(this.domNode.splitText(t));
+    return this.parent.insertBefore(s, this.next || void 0), this.text = this.statics.value(this.domNode), s;
+  }
+  update(t, e) {
+    t.some((s) => s.type === "characterData" && s.target === this.domNode) && (this.text = this.statics.value(this.domNode));
+  }
+  value() {
+    return this.text;
+  }
+}
+const Ne = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Attributor: j,
+  AttributorStore: pt,
+  BlockBlot: _,
+  ClassAttributor: q,
+  ContainerBlot: dt,
+  EmbedBlot: B,
+  InlineBlot: D,
+  LeafBlot: A,
+  ParentBlot: T,
+  Registry: K,
+  Scope: p,
+  ScrollBlot: It,
+  StyleAttributor: V,
+  TextBlot: et
+}, Symbol.toStringTag, { value: "Module" }));
+let $ = class extends et {
+};
+const ye = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function se(r) {
+  return r.replace(/[&<>"']/g, (t) => ye[t]);
+}
+const at = "\uFEFF";
+class ie extends B {
+  constructor(t, e) {
+    super(t, e), this.contentNode = document.createElement("span"), this.contentNode.setAttribute("contenteditable", "false"), Array.from(this.domNode.childNodes).forEach((s) => {
+      this.contentNode.appendChild(s);
+    }), this.leftGuard = document.createTextNode(at), this.rightGuard = document.createTextNode(at), this.domNode.appendChild(this.leftGuard), this.domNode.appendChild(this.contentNode), this.domNode.appendChild(this.rightGuard);
+  }
+  index(t, e) {
+    return t === this.leftGuard ? 0 : t === this.rightGuard ? 1 : super.index(t, e);
+  }
+  restore(t) {
+    let e = null, s;
+    const i = t.data.split(at).join("");
+    if (t === this.leftGuard)
+      if (this.prev instanceof $) {
+        const n = this.prev.length();
+        this.prev.insertAt(n, i), e = {
+          startNode: this.prev.domNode,
+          startOffset: n + i.length
+        };
+      } else
+        s = document.createTextNode(i), this.parent.insertBefore(this.scroll.create(s), this), e = {
+          startNode: s,
+          startOffset: i.length
+        };
+    else t === this.rightGuard && (this.next instanceof $ ? (this.next.insertAt(0, i), e = {
+      startNode: this.next.domNode,
+      startOffset: i.length
+    }) : (s = document.createTextNode(i), this.parent.insertBefore(this.scroll.create(s), this.next), e = {
+      startNode: s,
+      startOffset: i.length
+    }));
+    return t.data = at, e;
+  }
+  update(t, e) {
+    t.forEach((s) => {
+      if (s.type === "characterData" && (s.target === this.leftGuard || s.target === this.rightGuard)) {
+        const i = this.restore(s.target);
+        i && (e.range = i);
+      }
+    });
+  }
+}
+const vt = /* @__PURE__ */ new WeakMap(), xt = ["error", "warn", "log", "info"];
+let Rt = "warn";
+function re(r, ...t) {
+  Rt && xt.indexOf(r) <= xt.indexOf(Rt) && console[r](...t);
+}
+function G(r) {
+  return xt.reduce(
+    (t, e) => (t[e] = re.bind(console, e, r), t),
+    {}
+  );
+}
+G.level = (r) => {
+  Rt = r;
+};
+re.level = G.level;
+const Nt = G("rich:events"), Ee = ["selectionchange", "mousedown", "mouseup", "click"];
+Ee.forEach((r) => {
+  document.addEventListener(r, (...t) => {
+    Array.from(
+      document.querySelectorAll(`.${L}-container`)
+    ).forEach((e) => {
+      const s = vt.get(e);
+      s && s.emitter && s.emitter.handleDOM(...t);
+    });
+  });
+});
+class m {
+  constructor() {
+    this.emitter = ue(), this.domListeners = {}, this.on("error", Nt.error);
+  }
+  static {
+    this.events = {
+      EDITOR_CHANGE: "editor-change",
+      SCROLL_BEFORE_UPDATE: "scroll-before-update",
+      SCROLL_BLOT_MOUNT: "scroll-blot-mount",
+      SCROLL_BLOT_UNMOUNT: "scroll-blot-unmount",
+      SCROLL_OPTIMIZE: "scroll-optimize",
+      SCROLL_UPDATE: "scroll-update",
+      SCROLL_EMBED_UPDATE: "scroll-embed-update",
+      SELECTION_CHANGE: "selection-change",
+      TEXT_CHANGE: "text-change",
+      COMPOSITION_BEFORE_START: "composition-before-start",
+      COMPOSITION_START: "composition-start",
+      COMPOSITION_BEFORE_END: "composition-before-end",
+      COMPOSITION_END: "composition-end"
+    };
+  }
+  static {
+    this.sources = {
+      API: "api",
+      SILENT: "silent",
+      USER: "user"
+    };
+  }
+  on(...t) {
+    return this.emitter.on(...t);
+  }
+  once(...t) {
+    return this.emitter.once(...t);
+  }
+  emit(...t) {
+    return Nt.log.call(Nt, ...t), this.emitter.emit(...t);
+  }
+  off(...t) {
+    return this.emitter.off(...t);
+  }
+  offAll(...t) {
+    return this.emitter.offAll(...t);
+  }
+  handleDOM(t, ...e) {
+    (this.domListeners[t.type] || []).forEach(({ node: s, handler: i }) => {
+      (t.target === s || s.contains(t.target)) && i(t, ...e);
+    });
+  }
+  listenDOM(t, e, s) {
+    this.domListeners[t] || (this.domListeners[t] = []), this.domListeners[t].push({ node: e, handler: s });
+  }
+}
+class Te {
+  constructor(t, e) {
+    this.scroll = t, this.emitter = e, this.isComposing = !1, this.setupListeners();
+  }
+  setupListeners() {
+    this.scroll.domNode.addEventListener("compositionstart", (t) => {
+      this.isComposing || this.handleCompositionStart(t);
+    }), this.scroll.domNode.addEventListener("compositionend", (t) => {
+      this.isComposing && queueMicrotask(() => {
+        this.handleCompositionEnd(t);
+      });
+    });
+  }
+  handleCompositionStart(t) {
+    const e = t.target instanceof Node ? this.scroll.find(t.target, !0) : null;
+    e && !(e instanceof ie) && (this.emitter.emit(m.events.COMPOSITION_BEFORE_START, t), this.scroll.batchStart(), this.emitter.emit(m.events.COMPOSITION_START, t), this.isComposing = !0);
+  }
+  handleCompositionEnd(t) {
+    this.emitter.emit(m.events.COMPOSITION_BEFORE_END, t), this.scroll.batchEnd(), this.emitter.emit(m.events.COMPOSITION_END, t), this.isComposing = !1;
+  }
+}
+class F extends B {
+  static value() {
+  }
+  optimize() {
+    (this.prev || this.next) && this.remove();
+  }
+  length() {
+    return 0;
+  }
+  value() {
+    return "";
+  }
+}
+F.blotName = "break";
+F.tagName = "BR";
+class M extends D {
+  static {
+    this.allowedChildren = [M, F, B, $];
+  }
+  static {
+    this.order = [
+      "cursor",
+      "inline",
+      // Must be lower
+      "link",
+      // Chrome wants <a> to be lower
+      "underline",
+      "strike",
+      "italic",
+      "bold",
+      "script",
+      "code"
+      // Must be higher
+    ];
+  }
+  static compare(t, e) {
+    const s = M.order.indexOf(t), i = M.order.indexOf(e);
+    return s >= 0 || i >= 0 ? s - i : t === e ? 0 : t < e ? -1 : 1;
+  }
+  formatAt(t, e, s, i) {
+    if (M.compare(this.statics.blotName, s) < 0 && this.scroll.query(s, p.BLOT)) {
+      const n = this.isolate(t, e);
+      i && n.wrap(s, i);
+    } else
+      super.formatAt(t, e, s, i);
+  }
+  optimize(t) {
+    if (super.optimize(t), this.parent instanceof M && M.compare(this.statics.blotName, this.parent.statics.blotName) > 0) {
+      const e = this.parent.isolate(this.offset(), this.length());
+      this.moveChildren(e), e.wrap(this);
+    }
+  }
+}
+const Pt = 1;
+class O extends _ {
+  constructor() {
+    super(...arguments), this.cache = {};
+  }
+  delta() {
+    return this.cache.delta == null && (this.cache.delta = Le(this)), this.cache.delta;
+  }
+  deleteAt(t, e) {
+    super.deleteAt(t, e), this.cache = {};
+  }
+  formatAt(t, e, s, i) {
+    e <= 0 || (this.scroll.query(s, p.BLOCK) ? t + e === this.length() && this.format(s, i) : super.formatAt(
+      t,
+      Math.min(e, this.length() - t - 1),
+      s,
+      i
+    ), this.cache = {});
+  }
+  insertAt(t, e, s) {
+    if (s != null) {
+      super.insertAt(t, e, s), this.cache = {};
+      return;
+    }
+    if (e.length === 0) return;
+    const i = e.split(`
+`), n = i.shift();
+    n.length > 0 && (t < this.length() - 1 || this.children.tail == null ? super.insertAt(Math.min(t, this.length() - 1), n) : this.children.tail.insertAt(this.children.tail.length(), n), this.cache = {});
+    let o = this;
+    i.reduce((l, a) => (o = o.split(l, !0), o.insertAt(0, a), a.length), t + n.length);
+  }
+  insertBefore(t, e) {
+    const { head: s } = this.children;
+    super.insertBefore(t, e), s instanceof F && s.remove(), this.cache = {};
+  }
+  length() {
+    return this.cache.length == null && (this.cache.length = super.length() + Pt), this.cache.length;
+  }
+  moveChildren(t, e) {
+    super.moveChildren(t, e), this.cache = {};
+  }
+  optimize(t) {
+    super.optimize(t), this.cache = {};
+  }
+  path(t) {
+    return super.path(t, !0);
+  }
+  removeChild(t) {
+    super.removeChild(t), this.cache = {};
+  }
+  split(t, e = !1) {
+    if (e && (t === 0 || t >= this.length() - Pt)) {
+      const i = this.clone();
+      return t === 0 ? (this.parent.insertBefore(i, this), this) : (this.parent.insertBefore(i, this.next), i);
+    }
+    const s = super.split(t, e);
+    return this.cache = {}, s;
+  }
+}
+O.blotName = "block";
+O.tagName = "P";
+O.defaultChild = F;
+O.allowedChildren = [F, M, B, $];
+class I extends B {
+  attach() {
+    super.attach(), this.attributes = new pt(this.domNode);
+  }
+  delta() {
+    return new f().insert(this.value(), {
+      ...this.formats(),
+      ...this.attributes.values()
+    });
+  }
+  format(t, e) {
+    const s = this.scroll.query(t, p.BLOCK_ATTRIBUTE);
+    s != null && this.attributes.attribute(s, e);
+  }
+  formatAt(t, e, s, i) {
+    this.format(s, i);
+  }
+  insertAt(t, e, s) {
+    if (s != null) {
+      super.insertAt(t, e, s);
+      return;
+    }
+    const i = e.split(`
+`), n = i.pop(), o = i.map((a) => {
+      const c = this.scroll.create(O.blotName);
+      return c.insertAt(0, a), c;
+    }), l = this.split(t);
+    o.forEach((a) => {
+      this.parent.insertBefore(a, l);
+    }), n && this.parent.insertBefore(this.scroll.create("text", n), l);
+  }
+}
+I.scope = p.BLOCK_BLOT;
+function Le(r, t = !0) {
+  return r.descendants(A).reduce((e, s) => s.length() === 0 ? e : e.insert(s.value(), x(s, {}, t)), new f()).insert(`
+`, x(r));
+}
+function x(r, t = {}, e = !0) {
+  return r == null || ("formats" in r && typeof r.formats == "function" && (t = {
+    ...t,
+    ...r.formats()
+  }, e && delete t["code-token"]), r.parent == null || r.parent.statics.blotName === "scroll" || r.parent.statics.scope !== r.statics.scope) ? t : x(r.parent, t, e);
+}
+class U extends B {
+  static {
+    this.blotName = "cursor";
+  }
+  static {
+    this.className = `${L}-cursor`;
+  }
+  static {
+    this.tagName = "span";
+  }
+  static {
+    this.CONTENTS = "\uFEFF";
+  }
+  // Zero width no break space
+  static value() {
+  }
+  constructor(t, e, s) {
+    super(t, e), this.selection = s, this.textNode = document.createTextNode(U.CONTENTS), this.domNode.appendChild(this.textNode), this.savedLength = 0;
+  }
+  detach() {
+    this.parent != null && this.parent.removeChild(this);
+  }
+  format(t, e) {
+    if (this.savedLength !== 0) {
+      super.format(t, e);
+      return;
+    }
+    let s = this, i = 0;
+    for (; s != null && s.statics.scope !== p.BLOCK_BLOT; )
+      i += s.offset(s.parent), s = s.parent;
+    s != null && (this.savedLength = U.CONTENTS.length, s.optimize(), s.formatAt(i, U.CONTENTS.length, t, e), this.savedLength = 0);
+  }
+  index(t, e) {
+    return t === this.textNode ? 0 : super.index(t, e);
+  }
+  length() {
+    return this.savedLength;
+  }
+  position() {
+    return [this.textNode, this.textNode.data.length];
+  }
+  remove() {
+    super.remove(), this.parent = null;
+  }
+  restore() {
+    if (this.selection.composing || this.parent == null) return null;
+    const t = this.selection.getNativeRange();
+    for (; this.domNode.lastChild != null && this.domNode.lastChild !== this.textNode; )
+      this.domNode.parentNode.insertBefore(
+        this.domNode.lastChild,
+        this.domNode
+      );
+    const e = this.prev instanceof $ ? this.prev : null, s = e ? e.length() : 0, i = this.next instanceof $ ? this.next : null, n = i ? i.text : "", { textNode: o } = this, l = o.data.split(U.CONTENTS).join("");
+    o.data = U.CONTENTS;
+    let a;
+    if (e)
+      a = e, (l || i) && (e.insertAt(e.length(), l + n), i && i.remove());
+    else if (i)
+      a = i, i.insertAt(0, l);
+    else {
+      const c = document.createTextNode(l);
+      a = this.scroll.create(c), this.parent.insertBefore(a, this);
+    }
+    if (this.remove(), t) {
+      const c = (g, b) => e && g === e.domNode ? b : g === o ? s + b - 1 : i && g === i.domNode ? s + l.length + b : null, h = c(t.start.node, t.start.offset), d = c(t.end.node, t.end.offset);
+      if (h !== null && d !== null)
+        return {
+          startNode: a.domNode,
+          startOffset: h,
+          endNode: a.domNode,
+          endOffset: d
+        };
+    }
+    return null;
+  }
+  update(t, e) {
+    if (t.some((s) => s.type === "characterData" && s.target === this.textNode)) {
+      const s = this.restore();
+      s && (e.range = s);
+    }
+  }
+  // Avoid .${RICH_TEXT_CLASS_NAME_PREFIX}-cursor being a descendant of `<a/>`.
+  // The reason is Safari pushes down `<a/>` on text insertion.
+  // That will cause DOM nodes not sync with the model.
+  //
+  // For example ({I} is the caret), given the markup:
+  //    <a><span class=`${RICH_TEXT_CLASS_NAME_PREFIX}-cursor`>\uFEFF{I}</span></a>
+  // When typing a char "x", `<a/>` will be pushed down inside the `<span>` first:
+  //    <span class=`${RICH_TEXT_CLASS_NAME_PREFIX}-cursor`><a>\uFEFF{I}</a></span>
+  // And then "x" will be inserted after `<a/>`:
+  //    <span class=`${RICH_TEXT_CLASS_NAME_PREFIX}-cursor`><a>\uFEFF</a>d{I}</span>
+  optimize(t) {
+    super.optimize(t);
+    let { parent: e } = this;
+    for (; e; ) {
+      if (e.domNode.tagName === "A") {
+        this.savedLength = U.CONTENTS.length, e.isolate(this.offset(e), this.length()).unwrap(), this.savedLength = 0;
+        break;
+      }
+      e = e.parent;
+    }
+  }
+  value() {
+    return "";
+  }
+}
+const yt = G("rich:selection");
+class rt {
+  constructor(t, e = 0) {
+    this.index = t, this.length = e;
+  }
+}
+class Ae {
+  constructor(t, e) {
+    this.emitter = e, this.scroll = t, this.composing = !1, this.mouseDown = !1, this.root = this.scroll.domNode, this.cursor = this.scroll.create("cursor", this), this.savedRange = new rt(0, 0), this.lastRange = this.savedRange, this.lastNative = null, this.handleComposition(), this.handleDragging(), this.emitter.listenDOM("selectionchange", document, () => {
+      !this.mouseDown && !this.composing && setTimeout(this.update.bind(this, m.sources.USER), 1);
+    }), this.emitter.on(m.events.SCROLL_BEFORE_UPDATE, () => {
+      if (!this.hasFocus()) return;
+      const s = this.getNativeRange();
+      s != null && s.start.node !== this.cursor.textNode && this.emitter.once(
+        m.events.SCROLL_UPDATE,
+        (i, n) => {
+          try {
+            this.root.contains(s.start.node) && this.root.contains(s.end.node) && this.setNativeRange(
+              s.start.node,
+              s.start.offset,
+              s.end.node,
+              s.end.offset
+            );
+            const o = n.some(
+              (l) => l.type === "characterData" || l.type === "childList" || l.type === "attributes" && l.target === this.root
+            );
+            this.update(o ? m.sources.SILENT : i);
+          } catch {
+          }
+        }
+      );
+    }), this.emitter.on(m.events.SCROLL_OPTIMIZE, (s, i) => {
+      if (i.range) {
+        const { startNode: n, startOffset: o, endNode: l, endOffset: a } = i.range;
+        this.setNativeRange(n, o, l, a), this.update(m.sources.SILENT);
+      }
+    }), this.update(m.sources.SILENT);
+  }
+  handleComposition() {
+    this.emitter.on(m.events.COMPOSITION_BEFORE_START, () => {
+      this.composing = !0;
+    }), this.emitter.on(m.events.COMPOSITION_END, () => {
+      if (this.composing = !1, this.cursor.parent) {
+        const t = this.cursor.restore();
+        if (!t) return;
+        setTimeout(() => {
+          this.setNativeRange(
+            t.startNode,
+            t.startOffset,
+            t.endNode,
+            t.endOffset
+          );
+        }, 1);
+      }
+    });
+  }
+  handleDragging() {
+    this.emitter.listenDOM("mousedown", document.body, () => {
+      this.mouseDown = !0;
+    }), this.emitter.listenDOM("mouseup", document.body, () => {
+      this.mouseDown = !1, this.update(m.sources.USER);
+    });
+  }
+  focus() {
+    this.hasFocus() || (this.root.focus({ preventScroll: !0 }), this.setRange(this.savedRange));
+  }
+  format(t, e) {
+    this.scroll.update();
+    const s = this.getNativeRange();
+    if (!(s == null || !s.native.collapsed || this.scroll.query(t, p.BLOCK))) {
+      if (s.start.node !== this.cursor.textNode) {
+        const i = this.scroll.find(s.start.node, !1);
+        if (i == null) return;
+        if (i instanceof A) {
+          const n = i.split(s.start.offset);
+          i.parent.insertBefore(this.cursor, n);
+        } else
+          i.insertBefore(this.cursor, s.start.node);
+        this.cursor.attach();
+      }
+      this.cursor.format(t, e), this.scroll.optimize(), this.setNativeRange(this.cursor.textNode, this.cursor.textNode.data.length), this.update();
+    }
+  }
+  getBounds(t, e = 0) {
+    const s = this.scroll.length();
+    t = Math.min(t, s - 1), e = Math.min(t + e, s - 1) - t;
+    let i, [n, o] = this.scroll.leaf(t);
+    if (n == null) return null;
+    if (e > 0 && o === n.length()) {
+      const [h] = this.scroll.leaf(t + 1);
+      if (h) {
+        const [d] = this.scroll.line(t), [g] = this.scroll.line(t + 1);
+        d === g && (n = h, o = 0);
+      }
+    }
+    [i, o] = n.position(o, !0);
+    const l = document.createRange();
+    if (e > 0)
+      return l.setStart(i, o), [n, o] = this.scroll.leaf(t + e), n == null ? null : ([i, o] = n.position(o, !0), l.setEnd(i, o), l.getBoundingClientRect());
+    let a = "left", c;
+    if (i instanceof Text) {
+      if (!i.data.length)
+        return null;
+      o < i.data.length ? (l.setStart(i, o), l.setEnd(i, o + 1)) : (l.setStart(i, o - 1), l.setEnd(i, o), a = "right"), c = l.getBoundingClientRect();
+    } else {
+      if (!(n.domNode instanceof Element)) return null;
+      c = n.domNode.getBoundingClientRect(), o > 0 && (a = "right");
+    }
+    return {
+      bottom: c.top + c.height,
+      height: c.height,
+      left: c[a],
+      right: c[a],
+      top: c.top,
+      width: 0
+    };
+  }
+  getNativeRange() {
+    const t = document.getSelection();
+    if (t == null || t.rangeCount <= 0) return null;
+    const e = t.getRangeAt(0);
+    if (e == null) return null;
+    const s = this.normalizeNative(e);
+    return yt.info("getNativeRange", s), s;
+  }
+  getRange() {
+    const t = this.scroll.domNode;
+    if ("isConnected" in t && !t.isConnected)
+      return [null, null];
+    const e = this.getNativeRange();
+    return e == null ? [null, null] : [this.normalizedToRange(e), e];
+  }
+  hasFocus() {
+    return document.activeElement === this.root || document.activeElement != null && Et(this.root, document.activeElement);
+  }
+  normalizedToRange(t) {
+    const e = [
+      [t.start.node, t.start.offset]
+    ];
+    t.native.collapsed || e.push([t.end.node, t.end.offset]);
+    const s = e.map((o) => {
+      const [l, a] = o, c = this.scroll.find(l, !0), h = c.offset(this.scroll);
+      return a === 0 ? h : c instanceof A ? h + c.index(l, a) : h + c.length();
+    }), i = Math.min(Math.max(...s), this.scroll.length() - 1), n = Math.min(i, ...s);
+    return new rt(n, i - n);
+  }
+  normalizeNative(t) {
+    if (!Et(this.root, t.startContainer) || !t.collapsed && !Et(this.root, t.endContainer))
+      return null;
+    const e = {
+      start: {
+        node: t.startContainer,
+        offset: t.startOffset
+      },
+      end: { node: t.endContainer, offset: t.endOffset },
+      native: t
+    };
+    return [e.start, e.end].forEach((s) => {
+      let { node: i, offset: n } = s;
+      for (; !(i instanceof Text) && i.childNodes.length > 0; )
+        if (i.childNodes.length > n)
+          i = i.childNodes[n], n = 0;
+        else if (i.childNodes.length === n)
+          i = i.lastChild, i instanceof Text ? n = i.data.length : i.childNodes.length > 0 ? n = i.childNodes.length : n = i.childNodes.length + 1;
+        else
+          break;
+      s.node = i, s.offset = n;
+    }), e;
+  }
+  rangeToNative(t) {
+    const e = this.scroll.length(), s = (i, n) => {
+      i = Math.min(e - 1, i);
+      const [o, l] = this.scroll.leaf(i);
+      return o ? o.position(l, n) : [null, -1];
+    };
+    return [
+      ...s(t.index, !1),
+      ...s(t.index + t.length, !0)
+    ];
+  }
+  setNativeRange(t, e, s = t, i = e, n = !1) {
+    if (yt.info("setNativeRange", t, e, s, i), t != null && (this.root.parentNode == null || t.parentNode == null || s.parentNode == null))
+      return;
+    const o = document.getSelection();
+    if (o != null)
+      if (t != null) {
+        this.hasFocus() || this.root.focus({ preventScroll: !0 });
+        const { native: l } = this.getNativeRange() || {};
+        if (l == null || n || t !== l.startContainer || e !== l.startOffset || s !== l.endContainer || i !== l.endOffset) {
+          t instanceof Element && t.tagName === "BR" && (e = Array.from(t.parentNode.childNodes).indexOf(
+            t
+          ), t = t.parentNode), s instanceof Element && s.tagName === "BR" && (i = Array.from(s.parentNode.childNodes).indexOf(
+            s
+          ), s = s.parentNode);
+          const a = document.createRange();
+          a.setStart(t, e), a.setEnd(s, i), o.removeAllRanges(), o.addRange(a);
+        }
+      } else
+        o.removeAllRanges(), this.root.blur();
+  }
+  setRange(t, e = !1, s = m.sources.API) {
+    if (typeof e == "string" && (s = e, e = !1), yt.info("setRange", t), t != null) {
+      const i = this.rangeToNative(t);
+      this.setNativeRange(...i, e);
+    } else
+      this.setNativeRange(null);
+    this.update(s);
+  }
+  update(t = m.sources.USER) {
+    const e = this.lastRange, [s, i] = this.getRange();
+    if (this.lastRange = s, this.lastNative = i, this.lastRange != null && (this.savedRange = this.lastRange), !X(e, this.lastRange)) {
+      if (!this.composing && i != null && i.native.collapsed && i.start.node !== this.cursor.textNode) {
+        const o = this.cursor.restore();
+        o && this.setNativeRange(
+          o.startNode,
+          o.startOffset,
+          o.endNode,
+          o.endOffset
+        );
+      }
+      const n = [
+        m.events.SELECTION_CHANGE,
+        W(this.lastRange),
+        W(e),
+        t
+      ];
+      this.emitter.emit(m.events.EDITOR_CHANGE, ...n), t !== m.sources.SILENT && this.emitter.emit(...n);
+    }
+  }
+}
+function Et(r, t) {
+  try {
+    t.parentNode;
+  } catch {
+    return !1;
+  }
+  return r.contains(t);
+}
+const we = /^[ -~]*$/;
+class Ce {
+  constructor(t) {
+    this.scroll = t, this.delta = this.getDelta();
+  }
+  applyDelta(t) {
+    this.scroll.update();
+    let e = this.scroll.length();
+    this.scroll.batchStart();
+    const s = _t(t), i = new f();
+    return Oe(s.ops.slice()).reduce((o, l) => {
+      const a = k.length(l);
+      let c = l.attributes || {}, h = !1, d = !1;
+      if (l.insert != null) {
+        if (i.retain(a), typeof l.insert == "string") {
+          const N = l.insert;
+          d = !N.endsWith(`
+`) && (e <= o || !!this.scroll.descendant(I, o)[0]), this.scroll.insertAt(o, N);
+          const [E, w] = this.scroll.line(o);
+          let y = it({}, x(E));
+          if (E instanceof O) {
+            const [v] = E.descendant(A, w);
+            v && (y = it(y, x(v)));
+          }
+          c = C.diff(y, c) || {};
+        } else if (typeof l.insert == "object") {
+          const N = Object.keys(l.insert)[0];
+          if (N == null) return o;
+          const E = this.scroll.query(N, p.INLINE) != null;
+          if (E)
+            (e <= o || this.scroll.descendant(I, o)[0]) && (d = !0);
+          else if (o > 0) {
+            const [w, y] = this.scroll.descendant(A, o - 1);
+            w instanceof $ ? w.value()[y] !== `
+` && (h = !0) : w instanceof B && w.statics.scope === p.INLINE_BLOT && (h = !0);
+          }
+          if (this.scroll.insertAt(o, N, l.insert[N]), E) {
+            const [w] = this.scroll.descendant(A, o);
+            if (w) {
+              const y = it({}, x(w));
+              c = C.diff(y, c) || {};
+            }
+          }
+        }
+        e += a;
+      } else if (i.push(l), l.retain !== null && typeof l.retain == "object") {
+        const N = Object.keys(l.retain)[0];
+        if (N == null) return o;
+        this.scroll.updateEmbedAt(o, N, l.retain[N]);
+      }
+      Object.keys(c).forEach((N) => {
+        this.scroll.formatAt(o, a, N, c[N]);
+      });
+      const g = h ? 1 : 0, b = d ? 1 : 0;
+      return e += g + b, i.retain(g), i.delete(b), o + a + g + b;
+    }, 0), i.reduce((o, l) => typeof l.delete == "number" ? (this.scroll.deleteAt(o, l.delete), o) : o + k.length(l), 0), this.scroll.batchEnd(), this.scroll.optimize(), this.update(s);
+  }
+  deleteText(t, e) {
+    return this.scroll.deleteAt(t, e), this.update(new f().retain(t).delete(e));
+  }
+  formatLine(t, e, s = {}) {
+    this.scroll.update(), Object.keys(s).forEach((n) => {
+      this.scroll.lines(t, Math.max(e, 1)).forEach((o) => {
+        o.format(n, s[n]);
+      });
+    }), this.scroll.optimize();
+    const i = new f().retain(t).retain(e, W(s));
+    return this.update(i);
+  }
+  formatText(t, e, s = {}) {
+    Object.keys(s).forEach((n) => {
+      this.scroll.formatAt(t, e, n, s[n]);
+    });
+    const i = new f().retain(t).retain(e, W(s));
+    return this.update(i);
+  }
+  getContents(t, e) {
+    return this.delta.slice(t, t + e);
+  }
+  getDelta() {
+    return this.scroll.lines().reduce((t, e) => t.concat(e.delta()), new f());
+  }
+  getFormat(t, e = 0) {
+    let s = [], i = [];
+    e === 0 ? this.scroll.path(t).forEach((l) => {
+      const [a] = l;
+      a instanceof O ? s.push(a) : a instanceof A && i.push(a);
+    }) : (s = this.scroll.lines(t, e), i = this.scroll.descendants(A, t, e));
+    const [n, o] = [s, i].map((l) => {
+      const a = l.shift();
+      if (a == null) return {};
+      let c = x(a);
+      for (; Object.keys(c).length > 0; ) {
+        const h = l.shift();
+        if (h == null) return c;
+        c = ke(x(h), c);
+      }
+      return c;
+    });
+    return { ...n, ...o };
+  }
+  getHTML(t, e) {
+    const [s, i] = this.scroll.line(t);
+    if (s) {
+      const n = s.length();
+      return s.length() >= i + e && !(i === 0 && e === n) ? nt(s, i, e, !0) : nt(this.scroll, t, e, !0);
+    }
+    return "";
+  }
+  getText(t, e) {
+    return this.getContents(t, e).filter((s) => typeof s.insert == "string").map((s) => s.insert).join("");
+  }
+  insertContents(t, e) {
+    const s = _t(e), i = new f().retain(t).concat(s);
+    return this.scroll.insertContents(t, s), this.update(i);
+  }
+  insertEmbed(t, e, s) {
+    return this.scroll.insertAt(t, e, s), this.update(new f().retain(t).insert({ [e]: s }));
+  }
+  insertText(t, e, s = {}) {
+    return e = e.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`), this.scroll.insertAt(t, e), Object.keys(s).forEach((i) => {
+      this.scroll.formatAt(t, e.length, i, s[i]);
+    }), this.update(
+      new f().retain(t).insert(e, W(s))
+    );
+  }
+  isBlank() {
+    if (this.scroll.children.length === 0) return !0;
+    if (this.scroll.children.length > 1) return !1;
+    const t = this.scroll.children.head;
+    if (t?.statics.blotName !== O.blotName) return !1;
+    const e = t;
+    return e.children.length > 1 ? !1 : e.children.head instanceof F;
+  }
+  removeFormat(t, e) {
+    const s = this.getText(t, e), [i, n] = this.scroll.line(t + e);
+    let o = 0, l = new f();
+    i != null && (o = i.length() - n, l = i.delta().slice(n, n + o - 1).insert(`
+`));
+    const c = this.getContents(t, e + o).diff(new f().insert(s).concat(l)), h = new f().retain(t).concat(c);
+    return this.applyDelta(h);
+  }
+  update(t, e = [], s = void 0) {
+    const i = this.delta;
+    if (e.length === 1 && e[0].type === "characterData" && e[0].target.data.match(we) && this.scroll.find(e[0].target)) {
+      const n = this.scroll.find(e[0].target), o = x(n), l = n.offset(this.scroll), a = e[0].oldValue.replace(U.CONTENTS, ""), c = new f().insert(a), h = new f().insert(n.value()), d = s && {
+        oldRange: zt(s.oldRange, -l),
+        newRange: zt(s.newRange, -l)
+      };
+      t = new f().retain(l).concat(c.diff(h, d)).reduce((b, N) => N.insert ? b.insert(N.insert, o) : b.push(N), new f()), this.delta = i.compose(t);
+    } else
+      this.delta = this.getDelta(), (!t || !X(i.compose(t), this.delta)) && (t = i.diff(this.delta, s));
+    return t;
+  }
+}
+function Q(r, t, e) {
+  if (r.length === 0) {
+    const [b] = Tt(e.pop());
+    return t <= 0 ? `</li></${b}>` : `</li></${b}>${Q([], t - 1, e)}`;
+  }
+  const [{ child: s, offset: i, length: n, indent: o, type: l }, ...a] = r, [c, h] = Tt(l);
+  if (o > t)
+    return e.push(l), o === t + 1 ? `<${c}><li${h}>${nt(
+      s,
+      i,
+      n
+    )}${Q(a, o, e)}` : `<${c}><li>${Q(r, t + 1, e)}`;
+  const d = e[e.length - 1];
+  if (o === t && l === d)
+    return `</li><li${h}>${nt(
+      s,
+      i,
+      n
+    )}${Q(a, o, e)}`;
+  const [g] = Tt(e.pop());
+  return `</li></${g}>${Q(r, t - 1, e)}`;
+}
+function nt(r, t, e, s = !1) {
+  if ("html" in r && typeof r.html == "function")
+    return r.html(t, e);
+  if (r instanceof $)
+    return se(r.value().slice(t, t + e)).replaceAll(" ", "&nbsp;");
+  if (r instanceof T) {
+    if (r.statics.blotName === "list-container") {
+      const c = [];
+      return r.children.forEachAt(t, e, (h, d, g) => {
+        const b = "formats" in h && typeof h.formats == "function" ? h.formats() : {};
+        c.push({
+          child: h,
+          offset: d,
+          length: g,
+          indent: b.indent || 0,
+          type: b.list
+        });
+      }), Q(c, -1, []);
+    }
+    const i = [];
+    if (r.children.forEachAt(t, e, (c, h, d) => {
+      i.push(nt(c, h, d));
+    }), s || r.statics.blotName === "list")
+      return i.join("");
+    const { outerHTML: n, innerHTML: o } = r.domNode, [l, a] = n.split(`>${o}<`);
+    return l === "<table" ? `<table style="border: 1px solid #000;">${i.join("")}<${a}` : `${l}>${i.join("")}<${a}`;
+  }
+  return r.domNode instanceof Element ? r.domNode.outerHTML : "";
+}
+function ke(r, t) {
+  return Object.keys(t).reduce(
+    (e, s) => {
+      if (r[s] == null) return e;
+      const i = t[s];
+      return i === r[s] ? e[s] = i : Array.isArray(i) ? i.indexOf(r[s]) < 0 ? e[s] = i.concat([r[s]]) : e[s] = i : e[s] = [i, r[s]], e;
+    },
+    {}
+  );
+}
+function Tt(r) {
+  const t = r === "ordered" ? "ol" : "ul";
+  switch (r) {
+    case "checked":
+      return [t, ' data-list="checked"'];
+    case "unchecked":
+      return [t, ' data-list="unchecked"'];
+    default:
+      return [t, ""];
+  }
+}
+function _t(r) {
+  return r.reduce((t, e) => {
+    if (typeof e.insert == "string") {
+      const s = e.insert.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+      return t.insert(s, e.attributes);
+    }
+    return t.push(e);
+  }, new f());
+}
+function zt({ index: r, length: t }, e) {
+  return new rt(r + e, t);
+}
+function Oe(r) {
+  const t = [];
+  return r.forEach((e) => {
+    typeof e.insert == "string" ? e.insert.split(`
+`).forEach((i, n) => {
+      n && t.push({ insert: `
+`, attributes: e.attributes }), i && t.push({ insert: i, attributes: e.attributes });
+    }) : t.push(e);
+  }), t;
+}
+class Y {
+  constructor(t, e = {}) {
+    this.rich = t, this.options = e;
+  }
+  static {
+    this.DEFAULTS = {};
+  }
+}
+class mt {
+  constructor(t, e) {
+    this.rich = t, this.options = e, this.modules = {};
+  }
+  static {
+    this.DEFAULTS = {
+      modules: {}
+    };
+  }
+  static {
+    this.themes = {
+      default: mt
+    };
+  }
+  init() {
+    Object.keys(this.options.modules).forEach((t) => {
+      this.modules[t] == null && this.addModule(t);
+    });
+  }
+  addModule(t) {
+    const e = this.rich.constructor.import(`modules/${t}`);
+    return this.modules[t] = new e(
+      this.rich,
+      this.options.modules[t] || {}
+    ), this.modules[t];
+  }
+}
+const ve = 100, xe = ["block", "break", "cursor", "inline", "scroll", "text"], Re = (r, t, e) => {
+  const s = new K();
+  return xe.forEach((i) => {
+    const n = t.query(i);
+    n && s.register(n);
+  }), r.forEach((i) => {
+    let n = t.query(i);
+    n || e.error(
+      `Cannot register "${i}" specified in "formats" config. Are you sure it was registered?`
+    );
+    let o = 0;
+    for (; n; )
+      if (s.register(n), n = "blotName" in n ? n.requiredContainer ?? null : null, o += 1, o > ve) {
+        e.error(
+          `Cycle detected in registering blot requiredContainer: "${i}"`
+        );
+        break;
+      }
+  }), s;
+}, Se = (r) => r.parentElement || r.getRootNode().host || null, Ie = (r) => {
+  const t = r.getBoundingClientRect(), e = "offsetWidth" in r && Math.abs(t.width) / r.offsetWidth || 1, s = "offsetHeight" in r && Math.abs(t.height) / r.offsetHeight || 1;
+  return {
+    top: t.top,
+    right: t.left + r.clientWidth * e,
+    bottom: t.top + r.clientHeight * s,
+    left: t.left
+  };
+}, ct = (r) => {
+  const t = parseInt(r, 10);
+  return Number.isNaN(t) ? 0 : t;
+}, Kt = (r, t, e, s, i, n) => r < e && t > s ? 0 : r < e ? -(e - r + i) : t > s ? t - r > s - e ? r + i - e : t - s + n : 0, Be = (r, t, e = {}) => {
+  const s = r.ownerDocument;
+  let i = t;
+  const n = [];
+  let o = r;
+  for (; o; ) {
+    const l = o === s.body, a = l ? {
+      top: 0,
+      right: window.visualViewport?.width ?? s.documentElement.clientWidth,
+      bottom: window.visualViewport?.height ?? s.documentElement.clientHeight,
+      left: 0
+    } : Ie(o), c = getComputedStyle(o), h = Kt(
+      i.left,
+      i.right,
+      a.left,
+      a.right,
+      ct(c.scrollPaddingLeft),
+      ct(c.scrollPaddingRight)
+    ), d = Kt(
+      i.top,
+      i.bottom,
+      a.top,
+      a.bottom,
+      ct(c.scrollPaddingTop),
+      ct(c.scrollPaddingBottom)
+    );
+    if (h || d)
+      if (l)
+        s.defaultView && (n.push({
+          element: s.defaultView,
+          left: h,
+          top: d
+        }), s.defaultView.scrollBy(h, d));
+      else {
+        const { scrollLeft: g, scrollTop: b } = o;
+        d && (o.scrollTop += d), h && (o.scrollLeft += h), n.push({
+          element: o,
+          left: h,
+          top: d
+        });
+        const N = o.scrollLeft - g, E = o.scrollTop - b;
+        i = {
+          left: i.left - N,
+          top: i.top - E,
+          right: i.right - N,
+          bottom: i.bottom - E
+        };
+      }
+    o = l || c.position === "fixed" ? null : Se(o);
+  }
+  e.smooth && n.forEach(({ element: l, top: a, left: c }) => {
+    l.scrollBy({ top: -a, left: -c, behavior: "instant" }), l.scrollBy({ top: a, left: c, behavior: "smooth" });
+  });
+}, tt = G("rich"), ht = new K();
+T.uiClass = `${L}-ui`;
+class u {
+  static {
+    this.DEFAULTS = {
+      bounds: null,
+      modules: {
+        clipboard: !0,
+        keyboard: !0,
+        history: !0,
+        uploader: !0
+      },
+      placeholder: "",
+      readOnly: !1,
+      registry: ht,
+      theme: "default"
+    };
+  }
+  static {
+    this.events = m.events;
+  }
+  static {
+    this.sources = m.sources;
+  }
+  static {
+    this.imports = {
+      delta: f,
+      parchment: Ne,
+      "core/module": Y,
+      "core/theme": mt
+    };
+  }
+  static debug(t) {
+    t === !0 && (t = "log"), G.level(t);
+  }
+  static find(t, e = !1) {
+    return vt.get(t) || ht.find(t, e);
+  }
+  static import(t) {
+    return this.imports[t] == null && tt.error(`Cannot import ${t}. Are you sure it was registered?`), this.imports[t];
+  }
+  static register(...t) {
+    if (typeof t[0] != "string") {
+      const e = t[0], s = !!t[1], i = "attrName" in e ? e.attrName : e.blotName;
+      typeof i == "string" ? this.register(`formats/${i}`, e, s) : Object.keys(e).forEach((n) => {
+        this.register(n, e[n], s);
+      });
+    } else {
+      const e = t[0], s = t[1], i = !!t[2];
+      this.imports[e] != null && !i && tt.warn(`Overwriting ${e} with`, s), this.imports[e] = s, (e.startsWith("blots/") || e.startsWith("formats/")) && s && typeof s != "boolean" && s.blotName !== "abstract" && ht.register(s), typeof s.register == "function" && s.register(ht);
+    }
+  }
+  constructor(t, e = {}) {
+    if (this.options = De(t, e), this.container = this.options.container, this.container == null) {
+      tt.error("Invalid Rich container", t);
+      return;
+    }
+    this.options.debug && u.debug(this.options.debug);
+    const s = this.container.innerHTML.trim();
+    this.container.classList.add(`${L}-container`), this.container.innerHTML = "", vt.set(this.container, this), this.root = this.addContainer(`${L}-editor`), this.root.classList.add(`${L}-blank`), this.emitter = new m();
+    const i = It.blotName, n = this.options.registry.query(i);
+    if (!n || !("blotName" in n))
+      throw new Error(
+        `Cannot initialize Rich without "${i}" blot`
+      );
+    if (this.scroll = new n(this.options.registry, this.root, {
+      emitter: this.emitter
+    }), this.editor = new Ce(this.scroll), this.selection = new Ae(this.scroll, this.emitter), this.composition = new Te(this.scroll, this.emitter), this.theme = new this.options.theme(this, this.options), this.keyboard = this.theme.addModule("keyboard"), this.clipboard = this.theme.addModule("clipboard"), this.history = this.theme.addModule("history"), this.uploader = this.theme.addModule("uploader"), this.theme.addModule("input"), this.theme.addModule("uiNode"), this.theme.init(), this.emitter.on(m.events.EDITOR_CHANGE, (o) => {
+      o === m.events.TEXT_CHANGE && this.root.classList.toggle(
+        `${L}-blank`,
+        this.editor.isBlank()
+      );
+    }), this.emitter.on(m.events.SCROLL_UPDATE, (o, l) => {
+      const a = this.selection.lastRange, [c] = this.selection.getRange(), h = a && c ? { oldRange: a, newRange: c } : void 0;
+      S.call(
+        this,
+        () => this.editor.update(null, l, h),
+        o
+      );
+    }), this.emitter.on(m.events.SCROLL_EMBED_UPDATE, (o, l) => {
+      const a = this.selection.lastRange, [c] = this.selection.getRange(), h = a && c ? { oldRange: a, newRange: c } : void 0;
+      S.call(
+        this,
+        () => {
+          const d = new f().retain(o.offset(this)).retain({ [o.statics.blotName]: l });
+          return this.editor.update(d, [], h);
+        },
+        u.sources.USER
+      );
+    }), s) {
+      const o = this.clipboard.convert({
+        html: `${s}<p><br></p>`,
+        text: `
+`
+      });
+      this.setContents(o);
+    }
+    this.history.clear(), this.options.placeholder && this.root.setAttribute("data-placeholder", this.options.placeholder), this.options.readOnly && this.disable(), this.allowReadOnlyEdits = !1;
+  }
+  addContainer(t, e = null) {
+    if (typeof t == "string") {
+      const s = t;
+      t = document.createElement("div"), t.classList.add(s);
+    }
+    return this.container.insertBefore(t, e), t;
+  }
+  blur() {
+    this.selection.setRange(null);
+  }
+  deleteText(t, e, s) {
+    return [t, e, , s] = P(t, e, s), S.call(
+      this,
+      () => this.editor.deleteText(t, e),
+      s,
+      t,
+      -1 * e
+    );
+  }
+  disable() {
+    this.enable(!1);
+  }
+  editReadOnly(t) {
+    this.allowReadOnlyEdits = !0;
+    const e = t();
+    return this.allowReadOnlyEdits = !1, e;
+  }
+  enable(t = !0) {
+    this.scroll.enable(t), this.container.classList.toggle(
+      `${L}-disabled`,
+      !t
+    );
+  }
+  focus(t = {}) {
+    this.selection.focus(), t.preventScroll || this.scrollSelectionIntoView();
+  }
+  format(t, e, s = m.sources.API) {
+    return S.call(
+      this,
+      () => {
+        const i = this.getSelection(!0);
+        let n = new f();
+        if (i == null) return n;
+        if (this.scroll.query(t, p.BLOCK))
+          n = this.editor.formatLine(i.index, i.length, {
+            [t]: e
+          });
+        else {
+          if (i.length === 0)
+            return this.selection.format(t, e), n;
+          n = this.editor.formatText(i.index, i.length, {
+            [t]: e
+          });
+        }
+        return this.setSelection(i, m.sources.SILENT), n;
+      },
+      s
+    );
+  }
+  formatLine(t, e, s, i, n) {
+    let o;
+    return [t, e, o, n] = P(
+      t,
+      e,
+      s,
+      i,
+      n
+    ), S.call(
+      this,
+      () => this.editor.formatLine(t, e, o),
+      n,
+      t,
+      0
+    );
+  }
+  formatText(t, e, s, i, n) {
+    let o;
+    return [t, e, o, n] = P(
+      t,
+      e,
+      s,
+      i,
+      n
+    ), S.call(
+      this,
+      () => this.editor.formatText(t, e, o),
+      n,
+      t,
+      0
+    );
+  }
+  getBounds(t, e = 0) {
+    let s = null;
+    if (typeof t == "number" ? s = this.selection.getBounds(t, e) : s = this.selection.getBounds(t.index, t.length), !s) return null;
+    const i = this.container.getBoundingClientRect();
+    return {
+      bottom: s.bottom - i.top,
+      height: s.height,
+      left: s.left - i.left,
+      right: s.right - i.left,
+      top: s.top - i.top,
+      width: s.width
+    };
+  }
+  getContents(t = 0, e = this.getLength() - t) {
+    return [t, e] = P(t, e), this.editor.getContents(t, e);
+  }
+  getFormat(t = this.getSelection(!0), e = 0) {
+    return typeof t == "number" ? this.editor.getFormat(t, e) : this.editor.getFormat(t.index, t.length);
+  }
+  getIndex(t) {
+    return t.offset(this.scroll);
+  }
+  getLength() {
+    return this.scroll.length();
+  }
+  getLeaf(t) {
+    return this.scroll.leaf(t);
+  }
+  getLine(t) {
+    return this.scroll.line(t);
+  }
+  getLines(t = 0, e = Number.MAX_VALUE) {
+    return typeof t != "number" ? this.scroll.lines(t.index, t.length) : this.scroll.lines(t, e);
+  }
+  getModule(t) {
+    return this.theme.modules[t];
+  }
+  getSelection(t = !1) {
+    return t && this.focus(), this.update(), this.selection.getRange()[0];
+  }
+  getSemanticHTML(t = 0, e) {
+    return typeof t == "number" && (e = e ?? this.getLength() - t), [t, e] = P(t, e), this.editor.getHTML(t, e);
+  }
+  getText(t = 0, e) {
+    return typeof t == "number" && (e = e ?? this.getLength() - t), [t, e] = P(t, e), this.editor.getText(t, e);
+  }
+  hasFocus() {
+    return this.selection.hasFocus();
+  }
+  insertEmbed(t, e, s, i = u.sources.API) {
+    return S.call(
+      this,
+      () => this.editor.insertEmbed(t, e, s),
+      i,
+      t
+    );
+  }
+  insertText(t, e, s, i, n) {
+    let o;
+    return [t, , o, n] = P(t, 0, s, i, n), S.call(
+      this,
+      () => this.editor.insertText(t, e, o),
+      n,
+      t,
+      e.length
+    );
+  }
+  isEnabled() {
+    return this.scroll.isEnabled();
+  }
+  off(...t) {
+    return this.emitter.off(...t);
+  }
+  on(...t) {
+    return this.emitter.on(...t);
+  }
+  once(...t) {
+    return this.emitter.once(...t);
+  }
+  removeFormat(t, e, s) {
+    return [t, e, , s] = P(t, e, s), S.call(
+      this,
+      () => this.editor.removeFormat(t, e),
+      s,
+      t
+    );
+  }
+  scrollRectIntoView(t, e = {}) {
+    Be(this.root, t, e);
+  }
+  /**
+   * @deprecated Use Rich#scrollSelectionIntoView() instead.
+   */
+  scrollIntoView() {
+    console.warn(
+      "Rich#scrollIntoView() has been deprecated and will be removed in the near future. Please use Rich#scrollSelectionIntoView() instead."
+    ), this.scrollSelectionIntoView();
+  }
+  /**
+   * Scroll the current selection into the visible area.
+   * If the selection is already visible, no scrolling will occur.
+   */
+  scrollSelectionIntoView(t = {}) {
+    const e = this.selection.lastRange, s = e && this.selection.getBounds(e.index, e.length);
+    s && this.scrollRectIntoView(s, t);
+  }
+  setContents(t, e = m.sources.API) {
+    return S.call(
+      this,
+      () => {
+        t = new f(t);
+        const s = this.getLength(), i = this.editor.deleteText(0, s), n = this.editor.insertContents(0, t), o = this.editor.deleteText(this.getLength() - 1, 1);
+        return i.compose(n).compose(o);
+      },
+      e
+    );
+  }
+  setSelection(t, e, s) {
+    t == null ? this.selection.setRange(null, e || u.sources.API) : ([t, e, , s] = P(t, e, s), this.selection.setRange(new rt(Math.max(0, t), e), s), s !== m.sources.SILENT && this.scrollSelectionIntoView());
+  }
+  setText(t, e = m.sources.API) {
+    const s = new f().insert(t);
+    return this.setContents(s, e);
+  }
+  update(t = m.sources.USER) {
+    const e = this.scroll.update(t);
+    return this.selection.update(t), e;
+  }
+  updateContents(t, e = m.sources.API) {
+    return S.call(
+      this,
+      () => (t = new f(t), this.editor.applyDelta(t)),
+      e,
+      !0
+    );
+  }
+}
+function qt(r) {
+  return typeof r == "string" ? document.querySelector(r) : r;
+}
+function Lt(r) {
+  return Object.entries(r ?? {}).reduce(
+    (t, [e, s]) => ({
+      ...t,
+      [e]: s === !0 ? {} : s
+    }),
+    {}
+  );
+}
+function Ht(r) {
+  return Object.fromEntries(
+    Object.entries(r).filter((t) => t[1] !== void 0)
+  );
+}
+function De(r, t) {
+  const e = qt(r);
+  if (!e)
+    throw new Error("Invalid Rich container");
+  const i = !t.theme || t.theme === u.DEFAULTS.theme ? mt : u.import(`themes/${t.theme}`);
+  if (!i)
+    throw new Error(`Invalid theme ${t.theme}. Did you register it?`);
+  const { modules: n, ...o } = u.DEFAULTS, { modules: l, ...a } = i.DEFAULTS;
+  let c = Lt(t.modules);
+  c != null && c.toolbar && c.toolbar.constructor !== Object && (c = {
+    ...c,
+    toolbar: { container: c.toolbar }
+  });
+  const h = it(
+    {},
+    Lt(n),
+    Lt(l),
+    c
+  ), d = {
+    ...o,
+    ...Ht(a),
+    ...Ht(t)
+  };
+  let g = t.registry;
+  return g ? t.formats && tt.warn('Ignoring "formats" option because "registry" is specified') : g = t.formats ? Re(t.formats, d.registry, tt) : d.registry, {
+    ...d,
+    registry: g,
+    container: e,
+    theme: i,
+    modules: Object.entries(h).reduce(
+      (b, [N, E]) => {
+        if (!E) return b;
+        const w = u.import(`modules/${N}`);
+        return w == null ? (tt.error(
+          `Cannot load ${N} module. Are you sure you registered it?`
+        ), b) : {
+          ...b,
+          [N]: it({}, w.DEFAULTS || {}, E)
+        };
+      },
+      {}
+    ),
+    bounds: qt(d.bounds)
+  };
+}
+function S(r, t, e, s) {
+  if (!this.isEnabled() && t === m.sources.USER && !this.allowReadOnlyEdits)
+    return new f();
+  let i = e == null ? null : this.getSelection();
+  const n = this.editor.delta, o = r();
+  if (i != null && (e === !0 && (e = i.index), s == null ? i = Wt(i, o, t) : s !== 0 && (i = Wt(i, e, s, t)), this.setSelection(i, m.sources.SILENT)), o.length() > 0) {
+    const l = [m.events.TEXT_CHANGE, o, n, t];
+    this.emitter.emit(m.events.EDITOR_CHANGE, ...l), t !== m.sources.SILENT && this.emitter.emit(...l);
+  }
+  return o;
+}
+function P(r, t, e, s, i) {
+  let n = {};
+  return typeof r.index == "number" && typeof r.length == "number" ? typeof t != "number" ? (i = s, s = e, e = t, t = r.length, r = r.index) : (t = r.length, r = r.index) : typeof t != "number" && (i = s, s = e, e = t, t = 0), typeof e == "object" ? (n = e, i = s) : typeof e == "string" && (s != null ? n[e] = s : i = e), i = i || m.sources.API, [r, t, n, i];
+}
+function Wt(r, t, e, s) {
+  const i = typeof e == "number" ? e : 0;
+  if (r == null) return null;
+  let n, o;
+  return t && typeof t.transformPosition == "function" ? [n, o] = [r.index, r.index + r.length].map(
+    (l) => t.transformPosition(l, s !== m.sources.USER)
+  ) : [n, o] = [r.index, r.index + r.length].map((l) => l < t || l === t && s === m.sources.USER ? l : i >= 0 ? l + i : Math.max(t, l + i)), new rt(n, o - n);
+}
+class Bt extends dt {
+}
+function Vt(r) {
+  return r instanceof O || r instanceof I;
+}
+function Gt(r) {
+  return typeof r.updateContent == "function";
+}
+class Me extends It {
+  static {
+    this.blotName = "scroll";
+  }
+  static {
+    this.className = `${L}-editor`;
+  }
+  static {
+    this.tagName = "DIV";
+  }
+  static {
+    this.defaultChild = O;
+  }
+  static {
+    this.allowedChildren = [O, I, Bt];
+  }
+  constructor(t, e, { emitter: s }) {
+    super(t, e), this.emitter = s, this.batch = !1, this.optimize(), this.enable(), this.domNode.addEventListener("dragstart", (i) => this.handleDragStart(i));
+  }
+  batchStart() {
+    Array.isArray(this.batch) || (this.batch = []);
+  }
+  batchEnd() {
+    if (!this.batch) return;
+    const t = this.batch;
+    this.batch = !1, this.update(t);
+  }
+  emitMount(t) {
+    this.emitter.emit(m.events.SCROLL_BLOT_MOUNT, t);
+  }
+  emitUnmount(t) {
+    this.emitter.emit(m.events.SCROLL_BLOT_UNMOUNT, t);
+  }
+  emitEmbedUpdate(t, e) {
+    this.emitter.emit(m.events.SCROLL_EMBED_UPDATE, t, e);
+  }
+  deleteAt(t, e) {
+    const [s, i] = this.line(t), [n] = this.line(t + e);
+    if (super.deleteAt(t, e), n != null && s !== n && i > 0) {
+      if (s instanceof I || n instanceof I) {
+        this.optimize();
+        return;
+      }
+      const o = n.children.head instanceof F ? null : n.children.head;
+      s.moveChildren(n, o), s.remove();
+    }
+    this.optimize();
+  }
+  enable(t = !0) {
+    this.domNode.setAttribute("contenteditable", t ? "true" : "false");
+  }
+  formatAt(t, e, s, i) {
+    super.formatAt(t, e, s, i), this.optimize();
+  }
+  insertAt(t, e, s) {
+    if (t >= this.length())
+      if (s == null || this.scroll.query(e, p.BLOCK) == null) {
+        const i = this.scroll.create(this.statics.defaultChild.blotName);
+        this.appendChild(i), s == null && e.endsWith(`
+`) ? i.insertAt(0, e.slice(0, -1), s) : i.insertAt(0, e, s);
+      } else {
+        const i = this.scroll.create(e, s);
+        this.appendChild(i);
+      }
+    else
+      super.insertAt(t, e, s);
+    this.optimize();
+  }
+  insertBefore(t, e) {
+    if (t.statics.scope === p.INLINE_BLOT) {
+      const s = this.scroll.create(
+        this.statics.defaultChild.blotName
+      );
+      s.appendChild(t), super.insertBefore(s, e);
+    } else
+      super.insertBefore(t, e);
+  }
+  insertContents(t, e) {
+    const s = this.deltaToRenderBlocks(
+      e.concat(new f().insert(`
+`))
+    ), i = s.pop();
+    if (i == null) return;
+    this.batchStart();
+    const n = s.shift();
+    if (n) {
+      const a = n.type === "block" && (n.delta.length() === 0 || !this.descendant(I, t)[0] && t < this.length()), c = n.type === "block" ? n.delta : new f().insert({ [n.key]: n.value });
+      At(this, t, c);
+      const h = n.type === "block" ? 1 : 0, d = t + c.length() + h;
+      a && this.insertAt(d - 1, `
+`);
+      const g = x(this.line(t)[0]), b = C.diff(g, n.attributes) || {};
+      Object.keys(b).forEach((N) => {
+        this.formatAt(d - 1, 1, N, b[N]);
+      }), t = d;
+    }
+    let [o, l] = this.children.find(t);
+    if (s.length && (o && (o = o.split(l), l = 0), s.forEach((a) => {
+      if (a.type === "block") {
+        const c = this.createBlock(
+          a.attributes,
+          o || void 0
+        );
+        At(c, 0, a.delta);
+      } else {
+        const c = this.create(
+          a.key,
+          a.value
+        );
+        this.insertBefore(c, o || void 0), Object.keys(a.attributes).forEach((h) => {
+          c.format(h, a.attributes[h]);
+        });
+      }
+    })), i.type === "block" && i.delta.length()) {
+      const a = o ? o.offset(o.scroll) + l : this.length();
+      At(this, a, i.delta);
+    }
+    this.batchEnd(), this.optimize();
+  }
+  isEnabled() {
+    return this.domNode.getAttribute("contenteditable") === "true";
+  }
+  leaf(t) {
+    const e = this.path(t).pop();
+    if (!e)
+      return [null, -1];
+    const [s, i] = e;
+    return s instanceof A ? [s, i] : [null, -1];
+  }
+  line(t) {
+    return t === this.length() ? this.line(t - 1) : this.descendant(Vt, t);
+  }
+  lines(t = 0, e = Number.MAX_VALUE) {
+    const s = (i, n, o) => {
+      let l = [], a = o;
+      return i.children.forEachAt(
+        n,
+        o,
+        (c, h, d) => {
+          Vt(c) ? l.push(c) : c instanceof dt && (l = l.concat(s(c, h, a))), a -= d;
+        }
+      ), l;
+    };
+    return s(this, t, e);
+  }
+  optimize(t = [], e = {}) {
+    this.batch || (super.optimize(t, e), t.length > 0 && this.emitter.emit(m.events.SCROLL_OPTIMIZE, t, e));
+  }
+  path(t) {
+    return super.path(t).slice(1);
+  }
+  remove() {
+  }
+  update(t) {
+    if (this.batch) {
+      Array.isArray(t) && (this.batch = this.batch.concat(t));
+      return;
+    }
+    let e = m.sources.USER;
+    typeof t == "string" && (e = t), Array.isArray(t) || (t = this.observer.takeRecords()), t = t.filter(({ target: s }) => {
+      const i = this.find(s, !0);
+      return i && !Gt(i);
+    }), t.length > 0 && this.emitter.emit(m.events.SCROLL_BEFORE_UPDATE, e, t), super.update(t.concat([])), t.length > 0 && this.emitter.emit(m.events.SCROLL_UPDATE, e, t);
+  }
+  updateEmbedAt(t, e, s) {
+    const [i] = this.descendant((n) => n instanceof I, t);
+    i && i.statics.blotName === e && Gt(i) && i.updateContent(s);
+  }
+  handleDragStart(t) {
+    t.preventDefault();
+  }
+  deltaToRenderBlocks(t) {
+    const e = [];
+    let s = new f();
+    return t.forEach((i) => {
+      const n = i?.insert;
+      if (n)
+        if (typeof n == "string") {
+          const o = n.split(`
+`);
+          o.slice(0, -1).forEach((a) => {
+            s.insert(a, i.attributes), e.push({
+              type: "block",
+              delta: s,
+              attributes: i.attributes ?? {}
+            }), s = new f();
+          });
+          const l = o[o.length - 1];
+          l && s.insert(l, i.attributes);
+        } else {
+          const o = Object.keys(n)[0];
+          if (!o) return;
+          this.query(o, p.INLINE) ? s.push(i) : (s.length() && e.push({
+            type: "block",
+            delta: s,
+            attributes: {}
+          }), s = new f(), e.push({
+            type: "blockEmbed",
+            key: o,
+            value: n[o],
+            attributes: i.attributes ?? {}
+          }));
+        }
+    }), s.length() && e.push({
+      type: "block",
+      delta: s,
+      attributes: {}
+    }), e;
+  }
+  createBlock(t, e) {
+    let s;
+    const i = {};
+    Object.entries(t).forEach(([l, a]) => {
+      this.query(l, p.BLOCK & p.BLOT) != null ? s = l : i[l] = a;
+    });
+    const n = this.create(
+      s || this.statics.defaultChild.blotName,
+      s ? t[s] : void 0
+    );
+    this.insertBefore(n, e || void 0);
+    const o = n.length();
+    return Object.entries(i).forEach(([l, a]) => {
+      n.formatAt(0, o, l, a);
+    }), n;
+  }
+}
+function At(r, t, e) {
+  e.reduce((s, i) => {
+    const n = k.length(i);
+    let o = i.attributes || {};
+    if (i.insert != null) {
+      if (typeof i.insert == "string") {
+        const l = i.insert;
+        r.insertAt(s, l);
+        const [a] = r.descendant(A, s), c = x(a);
+        o = C.diff(c, o) || {};
+      } else if (typeof i.insert == "object") {
+        const l = Object.keys(i.insert)[0];
+        if (l == null) return s;
+        if (r.insertAt(s, l, i.insert[l]), r.scroll.query(l, p.INLINE) != null) {
+          const [c] = r.descendant(A, s), h = x(c);
+          o = C.diff(h, o) || {};
+        }
+      }
+    }
+    return Object.keys(o).forEach((l) => {
+      r.formatAt(s, n, l, o[l]);
+    }), s + n;
+  }, t);
+}
+const Dt = {
+  scope: p.BLOCK,
+  whitelist: ["right", "center", "justify"]
+}, Ue = new j("align", "align", Dt), zs = new q(
+  "align",
+  `${L}-align`,
+  Dt
+), je = new V("align", "text-align", Dt);
+class ne extends V {
+  value(t) {
+    let e = super.value(t);
+    return e.startsWith("rgb(") ? (e = e.replace(/^[^\d]+/, "").replace(/[^\d]+$/, ""), `#${e.split(",").map((i) => `00${parseInt(i, 10).toString(16)}`.slice(-2)).join("")}`) : e;
+  }
+}
+const Ks = new q(
+  "color",
+  `${L}-color`,
+  {
+    scope: p.INLINE
+  }
+), $e = new ne("color", "color", {
+  scope: p.INLINE
+}), qs = new q(
+  "background",
+  `${L}-bg`,
+  {
+    scope: p.INLINE
+  }
+), Fe = new ne("background", "background-color", {
+  scope: p.INLINE
+});
+class st extends Bt {
+  static create(t) {
+    const e = super.create(t);
+    return e.setAttribute("spellcheck", "false"), e;
+  }
+  code(t, e) {
+    return this.children.map((s) => s.length() <= 1 ? "" : s.domNode.innerText).join(`
+`).slice(t, t + e);
+  }
+  html(t, e) {
+    return `<pre>
+${se(this.code(t, e))}
+</pre>`;
+  }
+}
+class z extends O {
+  static {
+    this.TAB = "  ";
+  }
+  static register() {
+    u.register(st);
+  }
+}
+class oe extends M {
+}
+oe.blotName = "code";
+oe.tagName = "CODE";
+z.blotName = "code-block";
+z.className = `${L}-code-block`;
+z.tagName = "DIV";
+st.blotName = "code-block-container";
+st.className = `${L}-code-block-container`;
+st.tagName = "DIV";
+st.allowedChildren = [z];
+z.allowedChildren = [$, F, U];
+z.requiredContainer = st;
+const Mt = {
+  scope: p.BLOCK,
+  whitelist: ["rtl"]
+}, Pe = new j("direction", "dir", Mt), Hs = new q(
+  "direction",
+  `${L}-direction`,
+  Mt
+), _e = new V("direction", "direction", Mt), le = {
+  scope: p.INLINE,
+  whitelist: ["serif", "monospace"]
+}, Ws = new q(
+  "font",
+  `${L}-font`,
+  le
+);
+class ze extends V {
+  value(t) {
+    return super.value(t).replace(/["']/g, "");
+  }
+}
+const Ke = new ze("font", "font-family", le), Vs = new q(
+  "size",
+  `${L}-size`,
+  {
+    scope: p.INLINE,
+    whitelist: ["small", "large", "huge"]
+  }
+), qe = new V("size", "font-size", {
+  scope: p.INLINE,
+  whitelist: ["10px", "18px", "32px"]
+}), He = G("rich:keyboard"), We = /Mac/i.test(navigator.platform) ? "metaKey" : "ctrlKey";
+class gt extends Y {
+  static match(t, e) {
+    return ["altKey", "ctrlKey", "metaKey", "shiftKey"].some((s) => !!e[s] !== t[s] && e[s] !== null) ? !1 : e.key === t.key || e.key === t.which;
+  }
+  constructor(t, e) {
+    super(t, e), this.bindings = {}, Object.keys(this.options.bindings).forEach((s) => {
+      this.options.bindings[s] && this.addBinding(this.options.bindings[s]);
+    }), this.addBinding({ key: "Enter", shiftKey: null }, this.handleEnter), this.addBinding(
+      { key: "Enter", metaKey: null, ctrlKey: null, altKey: null },
+      () => {
+      }
+    ), /Firefox/i.test(navigator.userAgent) ? (this.addBinding(
+      { key: "Backspace" },
+      { collapsed: !0 },
+      this.handleBackspace
+    ), this.addBinding(
+      { key: "Delete" },
+      { collapsed: !0 },
+      this.handleDelete
+    )) : (this.addBinding(
+      { key: "Backspace" },
+      { collapsed: !0, prefix: /^.?$/ },
+      this.handleBackspace
+    ), this.addBinding(
+      { key: "Delete" },
+      { collapsed: !0, suffix: /^.?$/ },
+      this.handleDelete
+    )), this.addBinding(
+      { key: "Backspace" },
+      { collapsed: !1 },
+      this.handleDeleteRange
+    ), this.addBinding(
+      { key: "Delete" },
+      { collapsed: !1 },
+      this.handleDeleteRange
+    ), this.addBinding(
+      {
+        key: "Backspace",
+        altKey: null,
+        ctrlKey: null,
+        metaKey: null,
+        shiftKey: null
+      },
+      { collapsed: !0, offset: 0 },
+      this.handleBackspace
+    ), this.listen();
+  }
+  addBinding(t, e = {}, s = {}) {
+    const i = Ge(t);
+    if (i == null) {
+      He.warn("Attempted to add invalid keyboard binding", i);
+      return;
+    }
+    typeof e == "function" && (e = { handler: e }), typeof s == "function" && (s = { handler: s }), (Array.isArray(i.key) ? i.key : [i.key]).forEach((o) => {
+      const l = {
+        ...i,
+        key: o,
+        ...e,
+        ...s
+      };
+      this.bindings[l.key] = this.bindings[l.key] || [], this.bindings[l.key].push(l);
+    });
+  }
+  listen() {
+    this.rich.root.addEventListener("keydown", (t) => {
+      if (t.defaultPrevented || t.isComposing || t.keyCode === 229 && (t.key === "Enter" || t.key === "Backspace")) return;
+      const i = (this.bindings[t.key] || []).concat(
+        this.bindings[t.which] || []
+      ).filter(
+        (y) => gt.match(t, y)
+      );
+      if (i.length === 0) return;
+      const n = u.find(t.target, !0);
+      if (n && n.scroll !== this.rich.scroll) return;
+      const o = this.rich.getSelection();
+      if (o == null || !this.rich.hasFocus()) return;
+      const [l, a] = this.rich.getLine(o.index), [c, h] = this.rich.getLeaf(o.index), [d, g] = o.length === 0 ? [c, h] : this.rich.getLeaf(o.index + o.length), b = c instanceof et ? c.value().slice(0, h) : "", N = d instanceof et ? d.value().slice(g) : "", E = {
+        collapsed: o.length === 0,
+        empty: o.length === 0 && l.length() <= 1,
+        format: this.rich.getFormat(o),
+        line: l,
+        offset: a,
+        prefix: b,
+        suffix: N,
+        event: t
+      };
+      i.some((y) => {
+        if (y.collapsed != null && y.collapsed !== E.collapsed || y.empty != null && y.empty !== E.empty || y.offset != null && y.offset !== E.offset)
+          return !1;
+        if (Array.isArray(y.format)) {
+          if (y.format.every((v) => E.format[v] == null))
+            return !1;
+        } else if (typeof y.format == "object" && !Object.keys(y.format).every((v) => y.format[v] === !0 ? E.format[v] != null : y.format[v] === !1 ? E.format[v] == null : X(y.format[v], E.format[v])))
+          return !1;
+        return y.prefix != null && !y.prefix.test(E.prefix) || y.suffix != null && !y.suffix.test(E.suffix) ? !1 : y.handler.call(this, o, E, y) !== !0;
+      }) && t.preventDefault();
+    });
+  }
+  handleBackspace(t, e) {
+    const s = /[\uD800-\uDBFF][\uDC00-\uDFFF]$/.test(e.prefix) ? 2 : 1;
+    if (t.index === 0 || this.rich.getLength() <= 1) return;
+    let i = {};
+    const [n] = this.rich.getLine(t.index);
+    let o = new f().retain(t.index - s).delete(s);
+    if (e.offset === 0) {
+      const [l] = this.rich.getLine(t.index - 1);
+      if (l && !(l.statics.blotName === "block" && l.length() <= 1)) {
+        const c = n.formats(), h = this.rich.getFormat(t.index - 1, 1);
+        if (i = C.diff(c, h) || {}, Object.keys(i).length > 0) {
+          const d = new f().retain(t.index + n.length() - 2).retain(1, i);
+          o = o.compose(d);
+        }
+      }
+    }
+    this.rich.updateContents(o, u.sources.USER), this.rich.focus();
+  }
+  handleDelete(t, e) {
+    const s = /^[\uD800-\uDBFF][\uDC00-\uDFFF]/.test(e.suffix) ? 2 : 1;
+    if (t.index >= this.rich.getLength() - s) return;
+    let i = {};
+    const [n] = this.rich.getLine(t.index);
+    let o = new f().retain(t.index).delete(s);
+    if (e.offset >= n.length() - 1) {
+      const [l] = this.rich.getLine(t.index + 1);
+      if (l) {
+        const a = n.formats(), c = this.rich.getFormat(t.index, 1);
+        i = C.diff(a, c) || {}, Object.keys(i).length > 0 && (o = o.retain(l.length() - 1).retain(1, i));
+      }
+    }
+    this.rich.updateContents(o, u.sources.USER), this.rich.focus();
+  }
+  handleDeleteRange(t) {
+    Ut({ range: t, rich: this.rich }), this.rich.focus();
+  }
+  handleEnter(t, e) {
+    const s = Object.keys(e.format).reduce(
+      (n, o) => (this.rich.scroll.query(o, p.BLOCK) && !Array.isArray(e.format[o]) && (n[o] = e.format[o]), n),
+      {}
+    ), i = new f().retain(t.index).delete(t.length).insert(`
+`, s);
+    this.rich.updateContents(i, u.sources.USER), this.rich.setSelection(t.index + 1, u.sources.SILENT), this.rich.focus();
+  }
+}
+const Ve = {
+  bindings: {
+    bold: wt("bold"),
+    italic: wt("italic"),
+    underline: wt("underline"),
+    indent: {
+      // highlight tab or tab at beginning of list, indent or blockquote
+      key: "Tab",
+      format: ["blockquote", "indent", "list"],
+      handler(r, t) {
+        return t.collapsed && t.offset !== 0 ? !0 : (this.rich.format("indent", "+1", u.sources.USER), !1);
+      }
+    },
+    outdent: {
+      key: "Tab",
+      shiftKey: !0,
+      format: ["blockquote", "indent", "list"],
+      // highlight tab or tab at beginning of list, indent or blockquote
+      handler(r, t) {
+        return t.collapsed && t.offset !== 0 ? !0 : (this.rich.format("indent", "-1", u.sources.USER), !1);
+      }
+    },
+    "outdent backspace": {
+      key: "Backspace",
+      collapsed: !0,
+      shiftKey: null,
+      metaKey: null,
+      ctrlKey: null,
+      altKey: null,
+      format: ["indent", "list"],
+      offset: 0,
+      handler(r, t) {
+        t.format.indent != null ? this.rich.format("indent", "-1", u.sources.USER) : t.format.list != null && this.rich.format("list", !1, u.sources.USER);
+      }
+    },
+    "indent code-block": Xt(!0),
+    "outdent code-block": Xt(!1),
+    "remove tab": {
+      key: "Tab",
+      shiftKey: !0,
+      collapsed: !0,
+      prefix: /\t$/,
+      handler(r) {
+        this.rich.deleteText(r.index - 1, 1, u.sources.USER);
+      }
+    },
+    tab: {
+      key: "Tab",
+      handler(r, t) {
+        if (t.format.table) return !0;
+        this.rich.history.cutoff();
+        const e = new f().retain(r.index).delete(r.length).insert("	");
+        return this.rich.updateContents(e, u.sources.USER), this.rich.history.cutoff(), this.rich.setSelection(r.index + 1, u.sources.SILENT), !1;
+      }
+    },
+    "blockquote empty enter": {
+      key: "Enter",
+      collapsed: !0,
+      format: ["blockquote"],
+      empty: !0,
+      handler() {
+        this.rich.format("blockquote", !1, u.sources.USER);
+      }
+    },
+    "list empty enter": {
+      key: "Enter",
+      collapsed: !0,
+      format: ["list"],
+      empty: !0,
+      handler(r, t) {
+        const e = { list: !1 };
+        t.format.indent && (e.indent = !1), this.rich.formatLine(
+          r.index,
+          r.length,
+          e,
+          u.sources.USER
+        );
+      }
+    },
+    "checklist enter": {
+      key: "Enter",
+      collapsed: !0,
+      format: { list: "checked" },
+      handler(r) {
+        const [t, e] = this.rich.getLine(r.index), s = {
+          ...t.formats(),
+          list: "checked"
+        }, i = new f().retain(r.index).insert(`
+`, s).retain(t.length() - e - 1).retain(1, { list: "unchecked" });
+        this.rich.updateContents(i, u.sources.USER), this.rich.setSelection(r.index + 1, u.sources.SILENT), this.rich.scrollSelectionIntoView();
+      }
+    },
+    "header enter": {
+      key: "Enter",
+      collapsed: !0,
+      format: ["header"],
+      suffix: /^$/,
+      handler(r, t) {
+        const [e, s] = this.rich.getLine(r.index), i = new f().retain(r.index).insert(`
+`, t.format).retain(e.length() - s - 1).retain(1, { header: null });
+        this.rich.updateContents(i, u.sources.USER), this.rich.setSelection(r.index + 1, u.sources.SILENT), this.rich.scrollSelectionIntoView();
+      }
+    },
+    "table backspace": {
+      key: "Backspace",
+      format: ["table"],
+      collapsed: !0,
+      offset: 0,
+      handler() {
+      }
+    },
+    "table delete": {
+      key: "Delete",
+      format: ["table"],
+      collapsed: !0,
+      suffix: /^$/,
+      handler() {
+      }
+    },
+    "table enter": {
+      key: "Enter",
+      shiftKey: null,
+      format: ["table"],
+      handler(r) {
+        const t = this.rich.getModule("table");
+        if (t) {
+          const [e, s, i, n] = t.getTable(r), o = Xe(e, s, i, n);
+          if (o == null) return;
+          let l = e.offset();
+          if (o < 0) {
+            const a = new f().retain(l).insert(`
+`);
+            this.rich.updateContents(a, u.sources.USER), this.rich.setSelection(
+              r.index + 1,
+              r.length,
+              u.sources.SILENT
+            );
+          } else if (o > 0) {
+            l += e.length();
+            const a = new f().retain(l).insert(`
+`);
+            this.rich.updateContents(a, u.sources.USER), this.rich.setSelection(l, u.sources.USER);
+          }
+        }
+      }
+    },
+    "table tab": {
+      key: "Tab",
+      shiftKey: null,
+      format: ["table"],
+      handler(r, t) {
+        const { event: e, line: s } = t, i = s.offset(this.rich.scroll);
+        e.shiftKey ? this.rich.setSelection(i - 1, u.sources.USER) : this.rich.setSelection(i + s.length(), u.sources.USER);
+      }
+    },
+    "list autofill": {
+      key: " ",
+      shiftKey: null,
+      collapsed: !0,
+      format: {
+        "code-block": !1,
+        blockquote: !1,
+        table: !1
+      },
+      prefix: /^\s*?(\d+\.|-|\*|\[ ?\]|\[x\])$/,
+      handler(r, t) {
+        if (this.rich.scroll.query("list") == null) return !0;
+        const { length: e } = t.prefix, [s, i] = this.rich.getLine(r.index);
+        if (i > e) return !0;
+        let n;
+        switch (t.prefix.trim()) {
+          case "[]":
+          case "[ ]":
+            n = "unchecked";
+            break;
+          case "[x]":
+            n = "checked";
+            break;
+          case "-":
+          case "*":
+            n = "bullet";
+            break;
+          default:
+            n = "ordered";
+        }
+        this.rich.insertText(r.index, " ", u.sources.USER), this.rich.history.cutoff();
+        const o = new f().retain(r.index - i).delete(e + 1).retain(s.length() - 2 - i).retain(1, { list: n });
+        return this.rich.updateContents(o, u.sources.USER), this.rich.history.cutoff(), this.rich.setSelection(r.index - e, u.sources.SILENT), !1;
+      }
+    },
+    "code exit": {
+      key: "Enter",
+      collapsed: !0,
+      format: ["code-block"],
+      prefix: /^$/,
+      suffix: /^\s*$/,
+      handler(r) {
+        const [t, e] = this.rich.getLine(r.index);
+        let s = 2, i = t;
+        for (; i != null && i.length() <= 1 && i.formats()["code-block"]; )
+          if (i = i.prev, s -= 1, s <= 0) {
+            const n = new f().retain(r.index + t.length() - e - 2).retain(1, { "code-block": null }).delete(1);
+            return this.rich.updateContents(n, u.sources.USER), this.rich.setSelection(r.index - 1, u.sources.SILENT), !1;
+          }
+        return !0;
+      }
+    },
+    "embed left": ut("ArrowLeft", !1),
+    "embed left shift": ut("ArrowLeft", !0),
+    "embed right": ut("ArrowRight", !1),
+    "embed right shift": ut("ArrowRight", !0),
+    "table down": Yt(!1),
+    "table up": Yt(!0)
+  }
+};
+gt.DEFAULTS = Ve;
+function Xt(r) {
+  return {
+    key: "Tab",
+    shiftKey: !r,
+    format: { "code-block": !0 },
+    handler(t, { event: e }) {
+      const s = this.rich.scroll.query("code-block"), { TAB: i } = s;
+      if (t.length === 0 && !e.shiftKey) {
+        this.rich.insertText(t.index, i, u.sources.USER), this.rich.setSelection(t.index + i.length, u.sources.SILENT);
+        return;
+      }
+      const n = t.length === 0 ? this.rich.getLines(t.index, 1) : this.rich.getLines(t);
+      let { index: o, length: l } = t;
+      n.forEach((a, c) => {
+        r ? (a.insertAt(0, i), c === 0 ? o += i.length : l += i.length) : a.domNode.textContent.startsWith(i) && (a.deleteAt(0, i.length), c === 0 ? o -= i.length : l -= i.length);
+      }), this.rich.update(u.sources.USER), this.rich.setSelection(o, l, u.sources.SILENT);
+    }
+  };
+}
+function ut(r, t) {
+  return {
+    key: r,
+    shiftKey: t,
+    altKey: null,
+    [r === "ArrowLeft" ? "prefix" : "suffix"]: /^$/,
+    handler(s) {
+      let { index: i } = s;
+      r === "ArrowRight" && (i += s.length + 1);
+      const [n] = this.rich.getLeaf(i);
+      return n instanceof B ? (r === "ArrowLeft" ? t ? this.rich.setSelection(
+        s.index - 1,
+        s.length + 1,
+        u.sources.USER
+      ) : this.rich.setSelection(s.index - 1, u.sources.USER) : t ? this.rich.setSelection(
+        s.index,
+        s.length + 1,
+        u.sources.USER
+      ) : this.rich.setSelection(
+        s.index + s.length + 1,
+        u.sources.USER
+      ), !1) : !0;
+    }
+  };
+}
+function wt(r) {
+  return {
+    key: r[0],
+    shortKey: !0,
+    handler(t, e) {
+      this.rich.format(r, !e.format[r], u.sources.USER);
+    }
+  };
+}
+function Yt(r) {
+  return {
+    key: r ? "ArrowUp" : "ArrowDown",
+    collapsed: !0,
+    format: ["table"],
+    handler(t, e) {
+      const s = r ? "prev" : "next", i = e.line, n = i.parent[s];
+      if (n != null) {
+        if (n.statics.blotName === "table-row") {
+          let o = n.children.head, l = i;
+          for (; l.prev != null; )
+            l = l.prev, o = o.next;
+          const a = o.offset(this.rich.scroll) + Math.min(e.offset, o.length() - 1);
+          this.rich.setSelection(a, 0, u.sources.USER);
+        }
+      } else {
+        const o = i.table()[s];
+        o != null && (r ? this.rich.setSelection(
+          o.offset(this.rich.scroll) + o.length() - 1,
+          0,
+          u.sources.USER
+        ) : this.rich.setSelection(
+          o.offset(this.rich.scroll),
+          0,
+          u.sources.USER
+        ));
+      }
+      return !1;
+    }
+  };
+}
+function Ge(r) {
+  if (typeof r == "string" || typeof r == "number")
+    r = { key: r };
+  else if (typeof r == "object")
+    r = W(r);
+  else
+    return null;
+  return r.shortKey && (r[We] = r.shortKey, delete r.shortKey), r;
+}
+function Ut({ rich: r, range: t }) {
+  const e = r.getLines(t);
+  let s = {};
+  if (e.length > 1) {
+    const i = e[0].formats(), n = e[e.length - 1].formats();
+    s = C.diff(n, i) || {};
+  }
+  r.deleteText(t, u.sources.USER), Object.keys(s).length > 0 && r.formatLine(t.index, 1, s, u.sources.USER), r.setSelection(t.index, u.sources.SILENT);
+}
+function Xe(r, t, e, s) {
+  return t.prev == null && t.next == null ? e.prev == null && e.next == null ? s === 0 ? -1 : 1 : e.prev == null ? -1 : 1 : t.prev == null ? -1 : t.next == null ? 1 : null;
+}
+const Ye = /font-weight:\s*normal/, Ze = ["P", "OL", "UL"], Zt = (r) => r && Ze.includes(r.tagName), Qe = (r) => {
+  Array.from(r.querySelectorAll("br")).filter(
+    (t) => Zt(t.previousElementSibling) && Zt(t.nextElementSibling)
+  ).forEach((t) => {
+    t.parentNode?.removeChild(t);
+  });
+}, Je = (r) => {
+  Array.from(r.querySelectorAll('b[style*="font-weight"]')).filter((t) => t.getAttribute("style")?.match(Ye)).forEach((t) => {
+    const e = r.createDocumentFragment();
+    e.append(...t.childNodes), t.parentNode?.replaceChild(e, t);
+  });
+};
+function ts(r) {
+  r.querySelector('[id^="docs-internal-guid-"]') && (Je(r), Qe(r));
+}
+const es = /\bmso-list:[^;]*ignore/i, ss = /\bmso-list:[^;]*\bl(\d+)/i, is = /\bmso-list:[^;]*\blevel(\d+)/i, rs = (r, t) => {
+  const e = r.getAttribute("style"), s = e?.match(ss);
+  if (!s)
+    return null;
+  const i = Number(s[1]), n = e?.match(is), o = n ? Number(n[1]) : 1, l = new RegExp(
+    `@list l${i}:level${o}\\s*\\{[^\\}]*mso-level-number-format:\\s*([\\w-]+)`,
+    "i"
+  ), a = t.match(l), c = a && a[1] === "bullet" ? "bullet" : "ordered";
+  return { id: i, indent: o, type: c, element: r };
+}, ns = (r) => {
+  const t = Array.from(r.querySelectorAll("[style*=mso-list]")), e = [], s = [];
+  t.forEach((o) => {
+    (o.getAttribute("style") || "").match(es) ? e.push(o) : s.push(o);
+  }), e.forEach((o) => o.parentNode?.removeChild(o));
+  const i = r.documentElement.innerHTML, n = s.map((o) => rs(o, i)).filter((o) => o);
+  for (; n.length; ) {
+    const o = [];
+    let l = n.shift();
+    for (; l; )
+      o.push(l), l = n.length && n[0]?.element === l.element.nextElementSibling && // Different id means the next item doesn't belong to this group.
+      n[0].id === l.id ? n.shift() : null;
+    const a = document.createElement("ul");
+    o.forEach((d) => {
+      const g = document.createElement("li");
+      g.setAttribute("data-list", d.type), d.indent > 1 && g.setAttribute(
+        "class",
+        `${L}-indent-${d.indent - 1}`
+      ), g.innerHTML = d.element.innerHTML, a.appendChild(g);
+    });
+    const c = o[0]?.element, { parentNode: h } = c ?? {};
+    c && h?.replaceChild(a, c), o.slice(1).forEach(({ element: d }) => {
+      h?.removeChild(d);
+    });
+  }
+};
+function os(r) {
+  r.documentElement.getAttribute("xmlns:w") === "urn:schemas-microsoft-com:office:word" && ns(r);
+}
+const ls = [os, ts], as = (r) => {
+  r.documentElement && ls.forEach((t) => {
+    t(r);
+  });
+}, cs = G("rich:clipboard"), hs = [
+  [Node.TEXT_NODE, As],
+  [Node.TEXT_NODE, Jt],
+  ["br", gs],
+  [Node.ELEMENT_NODE, Jt],
+  [Node.ELEMENT_NODE, ms],
+  [Node.ELEMENT_NODE, ps],
+  [Node.ELEMENT_NODE, Ts],
+  ["li", ys],
+  ["ol, ul", Es],
+  ["pre", bs],
+  ["tr", Ls],
+  ["b", Ct("bold")],
+  ["i", Ct("italic")],
+  ["strike", Ct("strike")],
+  ["style", Ns]
+], us = [Ue, Pe].reduce(
+  (r, t) => (r[t.keyName] = t, r),
+  {}
+), Qt = [
+  je,
+  Fe,
+  $e,
+  _e,
+  Ke,
+  qe
+].reduce((r, t) => (r[t.keyName] = t, r), {});
+class fs extends Y {
+  static {
+    this.DEFAULTS = {
+      matchers: []
+    };
+  }
+  constructor(t, e) {
+    super(t, e), this.rich.root.addEventListener(
+      "copy",
+      (s) => this.onCaptureCopy(s, !1)
+    ), this.rich.root.addEventListener("cut", (s) => this.onCaptureCopy(s, !0)), this.rich.root.addEventListener("paste", this.onCapturePaste.bind(this)), this.matchers = [], hs.concat(this.options.matchers ?? []).forEach(
+      ([s, i]) => {
+        this.addMatcher(s, i);
+      }
+    );
+  }
+  addMatcher(t, e) {
+    this.matchers.push([t, e]);
+  }
+  convert({ html: t, text: e }, s = {}) {
+    if (s[z.blotName])
+      return new f().insert(e || "", {
+        [z.blotName]: s[z.blotName]
+      });
+    if (!t)
+      return new f().insert(e || "", s);
+    const i = this.convertHTML(t);
+    return ot(i, `
+`) && (i.ops[i.ops.length - 1].attributes == null || s.table) ? i.compose(new f().retain(i.length() - 1).delete(1)) : i;
+  }
+  normalizeHTML(t) {
+    as(t);
+  }
+  convertHTML(t) {
+    const e = new DOMParser().parseFromString(t, "text/html");
+    this.normalizeHTML(e);
+    const s = e.body, i = /* @__PURE__ */ new WeakMap(), [n, o] = this.prepareMatching(
+      s,
+      i
+    );
+    return ce(
+      this.rich.scroll,
+      s,
+      n,
+      o,
+      i
+    );
+  }
+  dangerouslyPasteHTML(t, e, s = u.sources.API) {
+    if (typeof t == "string") {
+      const i = this.convert({ html: t, text: "" });
+      this.rich.setContents(i, e), this.rich.setSelection(0, u.sources.SILENT);
+    } else {
+      const i = this.convert({ html: e, text: "" });
+      this.rich.updateContents(new f().retain(t).concat(i), s), this.rich.setSelection(t + i.length(), u.sources.SILENT);
+    }
+  }
+  onCaptureCopy(t, e = !1) {
+    if (t.defaultPrevented) return;
+    t.preventDefault();
+    const [s] = this.rich.selection.getRange();
+    if (s == null) return;
+    const { html: i, text: n } = this.onCopy(s, e);
+    t.clipboardData?.setData("text/plain", n), t.clipboardData?.setData("text/html", i), e && Ut({ range: s, rich: this.rich });
+  }
+  /*
+   * https://www.iana.org/assignments/media-types/text/uri-list
+   */
+  normalizeURIList(t) {
+    return t.split(/\r?\n/).filter((e) => e[0] !== "#").join(`
+`);
+  }
+  onCapturePaste(t) {
+    if (t.defaultPrevented || !this.rich.isEnabled()) return;
+    t.preventDefault();
+    const e = this.rich.getSelection(!0);
+    if (e == null) return;
+    const s = t.clipboardData?.getData("text/html");
+    let i = t.clipboardData?.getData("text/plain");
+    if (!s && !i) {
+      const o = t.clipboardData?.getData("text/uri-list");
+      o && (i = this.normalizeURIList(o));
+    }
+    const n = Array.from(t.clipboardData?.files || []);
+    if (!s && n.length > 0) {
+      this.rich.uploader.upload(e, n);
+      return;
+    }
+    if (s && n.length > 0) {
+      const o = new DOMParser().parseFromString(s, "text/html");
+      if (o.body.childElementCount === 1 && o.body.firstElementChild?.tagName === "IMG") {
+        this.rich.uploader.upload(e, n);
+        return;
+      }
+    }
+    this.onPaste(e, { html: s, text: i });
+  }
+  onCopy(t) {
+    const e = this.rich.getText(t);
+    return { html: this.rich.getSemanticHTML(t), text: e };
+  }
+  onPaste(t, { text: e, html: s }) {
+    const i = this.rich.getFormat(t.index), n = this.convert({ text: e, html: s }, i);
+    cs.log("onPaste", n, { text: e, html: s });
+    const o = new f().retain(t.index).delete(t.length).concat(n);
+    this.rich.updateContents(o, u.sources.USER), this.rich.setSelection(o.length() - t.length, u.sources.SILENT), this.rich.scrollSelectionIntoView();
+  }
+  prepareMatching(t, e) {
+    const s = [], i = [];
+    return this.matchers.forEach((n) => {
+      const [o, l] = n;
+      switch (o) {
+        case Node.TEXT_NODE:
+          i.push(l);
+          break;
+        case Node.ELEMENT_NODE:
+          s.push(l);
+          break;
+        default:
+          Array.from(t.querySelectorAll(o)).forEach((a) => {
+            e.has(a) ? e.get(a)?.push(l) : e.set(a, [l]);
+          });
+          break;
+      }
+    }), [s, i];
+  }
+}
+function Z(r, t, e, s) {
+  return s.query(t) ? r.reduce((i, n) => {
+    if (!n.insert) return i;
+    if (n.attributes && n.attributes[t])
+      return i.push(n);
+    const o = e ? { [t]: e } : {};
+    return i.insert(n.insert, { ...o, ...n.attributes });
+  }, new f()) : r;
+}
+function ot(r, t) {
+  let e = "";
+  for (let s = r.ops.length - 1; s >= 0 && e.length < t.length; --s) {
+    const i = r.ops[s];
+    if (typeof i.insert != "string") break;
+    e = i.insert + e;
+  }
+  return e.slice(-1 * t.length) === t;
+}
+function H(r, t) {
+  if (!(r instanceof Element)) return !1;
+  const e = t.query(r);
+  return e && e.prototype instanceof B ? !1 : [
+    "address",
+    "article",
+    "blockquote",
+    "canvas",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "iframe",
+    "li",
+    "main",
+    "nav",
+    "ol",
+    "output",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "td",
+    "tr",
+    "ul",
+    "video"
+  ].includes(r.tagName.toLowerCase());
+}
+function ds(r, t) {
+  return r.previousElementSibling && r.nextElementSibling && !H(r.previousElementSibling, t) && !H(r.nextElementSibling, t);
+}
+const ft = /* @__PURE__ */ new WeakMap();
+function ae(r) {
+  return r == null ? !1 : (ft.has(r) || (r.tagName === "PRE" ? ft.set(r, !0) : ft.set(r, ae(r.parentNode))), ft.get(r));
+}
+function ce(r, t, e, s, i) {
+  return t.nodeType === t.TEXT_NODE ? s.reduce((n, o) => o(t, n, r), new f()) : t.nodeType === t.ELEMENT_NODE ? Array.from(t.childNodes || []).reduce((n, o) => {
+    let l = ce(
+      r,
+      o,
+      e,
+      s,
+      i
+    );
+    return o.nodeType === t.ELEMENT_NODE && (l = e.reduce((a, c) => c(o, a, r), l), l = (i.get(o) || []).reduce(
+      (a, c) => c(o, a, r),
+      l
+    )), n.concat(l);
+  }, new f()) : new f();
+}
+function Ct(r) {
+  return (t, e, s) => Z(e, r, !0, s);
+}
+function ps(r, t, e) {
+  const s = j.keys(r), i = q.keys(r), n = V.keys(r), o = {};
+  return s.concat(i).concat(n).forEach((l) => {
+    let a = e.query(l, p.ATTRIBUTE);
+    a != null && (o[a.attrName] = a.value(r), o[a.attrName]) || (a = us[l], a != null && (a.attrName === l || a.keyName === l) && (o[a.attrName] = a.value(r) || void 0), a = Qt[l], a != null && (a.attrName === l || a.keyName === l) && (a = Qt[l], o[a.attrName] = a.value(r) || void 0));
+  }), Object.entries(o).reduce(
+    (l, [a, c]) => Z(l, a, c, e),
+    t
+  );
+}
+function ms(r, t, e) {
+  const s = e.query(r);
+  if (s == null) return t;
+  if (s.prototype instanceof B) {
+    const i = {}, n = s.value(r);
+    if (n != null)
+      return i[s.blotName] = n, new f().insert(i, s.formats(r, e));
+  } else if (s.prototype instanceof _ && !ot(t, `
+`) && t.insert(`
+`), "blotName" in s && "formats" in s && typeof s.formats == "function")
+    return Z(
+      t,
+      s.blotName,
+      s.formats(r, e),
+      e
+    );
+  return t;
+}
+function gs(r, t) {
+  return ot(t, `
+`) || t.insert(`
+`), t;
+}
+function bs(r, t, e) {
+  const s = e.query("code-block"), i = s && "formats" in s && typeof s.formats == "function" ? s.formats(r, e) : !0;
+  return Z(t, "code-block", i, e);
+}
+function Ns() {
+  return new f();
+}
+function ys(r, t, e) {
+  const s = e.query(r);
+  if (s == null || s.blotName !== "list" || !ot(t, `
+`))
+    return t;
+  let i = -1, n = r.parentNode;
+  for (; n != null; )
+    ["OL", "UL"].includes(n.tagName) && (i += 1), n = n.parentNode;
+  return i <= 0 ? t : t.reduce((o, l) => l.insert ? l.attributes && typeof l.attributes.indent == "number" ? o.push(l) : o.insert(l.insert, { indent: i, ...l.attributes || {} }) : o, new f());
+}
+function Es(r, t, e) {
+  const s = r;
+  let i = s.tagName === "OL" ? "ordered" : "bullet";
+  const n = s.getAttribute("data-checked");
+  return n && (i = n === "true" ? "checked" : "unchecked"), Z(t, "list", i, e);
+}
+function Jt(r, t, e) {
+  if (!ot(t, `
+`)) {
+    if (H(r, e) && (r.childNodes.length > 0 || r instanceof HTMLParagraphElement))
+      return t.insert(`
+`);
+    if (t.length() > 0 && r.nextSibling) {
+      let s = r.nextSibling;
+      for (; s != null; ) {
+        if (H(s, e))
+          return t.insert(`
+`);
+        const i = e.query(s);
+        if (i && i.prototype instanceof I)
+          return t.insert(`
+`);
+        s = s.firstChild;
+      }
+    }
+  }
+  return t;
+}
+function Ts(r, t, e) {
+  const s = {}, i = r.style || {};
+  return i.fontStyle === "italic" && (s.italic = !0), i.textDecoration === "underline" && (s.underline = !0), i.textDecoration === "line-through" && (s.strike = !0), (i.fontWeight?.startsWith("bold") || parseInt(i.fontWeight, 10) >= 700) && (s.bold = !0), t = Object.entries(s).reduce(
+    (n, [o, l]) => Z(n, o, l, e),
+    t
+  ), parseFloat(i.textIndent || 0) > 0 ? new f().insert("	").concat(t) : t;
+}
+function Ls(r, t, e) {
+  const s = r.parentElement?.tagName === "TABLE" ? r.parentElement : r.parentElement?.parentElement;
+  if (s != null) {
+    const n = Array.from(s.querySelectorAll("tr")).indexOf(r) + 1;
+    return Z(t, "table", n, e);
+  }
+  return t;
+}
+function As(r, t, e) {
+  let s = r.data;
+  if (r.parentElement?.tagName === "O:P")
+    return t.insert(s.trim());
+  if (!ae(r)) {
+    if (s.trim().length === 0 && s.includes(`
+`) && !ds(r, e))
+      return t;
+    s = s.replace(/[^\S\u00a0]/g, " "), s = s.replace(/ {2,}/g, " "), (r.previousSibling == null && r.parentElement != null && H(r.parentElement, e) || r.previousSibling instanceof Element && H(r.previousSibling, e)) && (s = s.replace(/^ /, "")), (r.nextSibling == null && r.parentElement != null && H(r.parentElement, e) || r.nextSibling instanceof Element && H(r.nextSibling, e)) && (s = s.replace(/ $/, "")), s = s.replaceAll(" ", " ");
+  }
+  return t.insert(s);
+}
+class ws extends Y {
+  constructor(t, e) {
+    super(t, e), this.lastRecorded = 0, this.ignoreChange = !1, this.stack = { undo: [], redo: [] }, this.currentRange = null, this.rich.on(
+      u.events.EDITOR_CHANGE,
+      (s, i, n, o) => {
+        s === u.events.SELECTION_CHANGE ? i && o !== u.sources.SILENT && (this.currentRange = i) : s === u.events.TEXT_CHANGE && (this.ignoreChange || (!this.options.userOnly || o === u.sources.USER ? this.record(i, n) : this.transform(i)), this.currentRange = St(this.currentRange, i));
+      }
+    ), this.rich.keyboard.addBinding(
+      { key: "z", shortKey: !0 },
+      this.undo.bind(this)
+    ), this.rich.keyboard.addBinding(
+      { key: ["z", "Z"], shortKey: !0, shiftKey: !0 },
+      this.redo.bind(this)
+    ), /Win/i.test(navigator.platform) && this.rich.keyboard.addBinding(
+      { key: "y", shortKey: !0 },
+      this.redo.bind(this)
+    ), this.rich.root.addEventListener("beforeinput", (s) => {
+      s.inputType === "historyUndo" ? (this.undo(), s.preventDefault()) : s.inputType === "historyRedo" && (this.redo(), s.preventDefault());
+    });
+  }
+  static {
+    this.DEFAULTS = {
+      delay: 1e3,
+      maxStack: 100,
+      userOnly: !1
+    };
+  }
+  change(t, e) {
+    if (this.stack[t].length === 0) return;
+    const s = this.stack[t].pop();
+    if (!s) return;
+    const i = this.rich.getContents(), n = s.delta.invert(i);
+    this.stack[e].push({
+      delta: n,
+      range: St(s.range, n)
+    }), this.lastRecorded = 0, this.ignoreChange = !0, this.rich.updateContents(s.delta, u.sources.USER), this.ignoreChange = !1, this.restoreSelection(s);
+  }
+  clear() {
+    this.stack = { undo: [], redo: [] };
+  }
+  cutoff() {
+    this.lastRecorded = 0;
+  }
+  record(t, e) {
+    if (t.ops.length === 0) return;
+    this.stack.redo = [];
+    let s = t.invert(e), i = this.currentRange;
+    const n = Date.now();
+    if (this.lastRecorded + this.options.delay > n && this.stack.undo.length > 0) {
+      const o = this.stack.undo.pop();
+      o && (s = s.compose(o.delta), i = o.range);
+    } else
+      this.lastRecorded = n;
+    s.length() !== 0 && (this.stack.undo.push({ delta: s, range: i }), this.stack.undo.length > this.options.maxStack && this.stack.undo.shift());
+  }
+  redo() {
+    this.change("redo", "undo");
+  }
+  transform(t) {
+    te(this.stack.undo, t), te(this.stack.redo, t);
+  }
+  undo() {
+    this.change("undo", "redo");
+  }
+  restoreSelection(t) {
+    if (t.range)
+      this.rich.setSelection(t.range, u.sources.USER);
+    else {
+      const e = ks(this.rich.scroll, t.delta);
+      this.rich.setSelection(e, u.sources.USER);
+    }
+  }
+}
+function te(r, t) {
+  let e = t;
+  for (let s = r.length - 1; s >= 0; s -= 1) {
+    const i = r[s];
+    r[s] = {
+      delta: e.transform(i.delta, !0),
+      range: i.range && St(i.range, e)
+    }, e = i.delta.transform(e), r[s].delta.length() === 0 && r.splice(s, 1);
+  }
+}
+function Cs(r, t) {
+  const e = t.ops[t.ops.length - 1];
+  return e == null ? !1 : e.insert != null ? typeof e.insert == "string" && e.insert.endsWith(`
+`) : e.attributes != null ? Object.keys(e.attributes).some((s) => r.query(s, p.BLOCK) != null) : !1;
+}
+function ks(r, t) {
+  const e = t.reduce((i, n) => i + (n.delete || 0), 0);
+  let s = t.length() - e;
+  return Cs(r, t) && (s -= 1), s;
+}
+function St(r, t) {
+  if (!r) return r;
+  const e = t.transformPosition(r.index), s = t.transformPosition(r.index + r.length);
+  return { index: e, length: s - e };
+}
+const Os = ["insertText", "insertReplacementText"];
+class vs extends Y {
+  constructor(t, e) {
+    super(t, e), t.root.addEventListener("beforeinput", (s) => {
+      this.handleBeforeInput(s);
+    }), /Android/i.test(navigator.userAgent) || t.on(u.events.COMPOSITION_BEFORE_START, () => {
+      this.handleCompositionStart();
+    });
+  }
+  deleteRange(t) {
+    Ut({ range: t, rich: this.rich });
+  }
+  replaceText(t, e = "") {
+    if (t.length === 0) return !1;
+    if (e) {
+      const s = this.rich.getFormat(t.index, 1);
+      this.deleteRange(t), this.rich.updateContents(
+        new f().retain(t.index).insert(e, s),
+        u.sources.USER
+      );
+    } else
+      this.deleteRange(t);
+    return this.rich.setSelection(t.index + e.length, 0, u.sources.SILENT), !0;
+  }
+  handleBeforeInput(t) {
+    if (this.rich.composition.isComposing || t.defaultPrevented || !Os.includes(t.inputType))
+      return;
+    const e = t.getTargetRanges ? t.getTargetRanges()[0] : null;
+    if (!e || e.collapsed === !0)
+      return;
+    const s = xs(t);
+    if (s == null)
+      return;
+    const i = this.rich.selection.normalizeNative(e), n = i ? this.rich.selection.normalizedToRange(i) : null;
+    n && this.replaceText(n, s) && t.preventDefault();
+  }
+  handleCompositionStart() {
+    const t = this.rich.getSelection();
+    t && this.replaceText(t);
+  }
+}
+function xs(r) {
+  return typeof r.data == "string" ? r.data : r.dataTransfer?.types.includes("text/plain") ? r.dataTransfer.getData("text/plain") : null;
+}
+const Rs = fe, Ss = 100, Is = (r) => !!(r.key === "ArrowLeft" || r.key === "ArrowRight" || // RTL scripts or moving from the end of the previous line
+r.key === "ArrowUp" || r.key === "ArrowDown" || r.key === "Home" || Rs && r.key === "a" && r.ctrlKey === !0);
+class Bs extends Y {
+  constructor(t, e) {
+    super(t, e), this.isListening = !1, this.selectionChangeDeadline = 0, this.handleArrowKeys(), this.handleNavigationShortcuts();
+  }
+  handleArrowKeys() {
+    this.rich.keyboard.addBinding({
+      key: ["ArrowLeft", "ArrowRight"],
+      offset: 0,
+      shiftKey: null,
+      handler(t, { line: e, event: s }) {
+        if (!(e instanceof T) || !e.uiNode)
+          return !0;
+        const i = getComputedStyle(e.domNode).direction === "rtl";
+        return i && s.key !== "ArrowRight" || !i && s.key !== "ArrowLeft" ? !0 : (this.rich.setSelection(
+          t.index - 1,
+          t.length + (s.shiftKey ? 1 : 0),
+          u.sources.USER
+        ), !1);
+      }
+    });
+  }
+  handleNavigationShortcuts() {
+    this.rich.root.addEventListener("keydown", (t) => {
+      !t.defaultPrevented && Is(t) && this.ensureListeningToSelectionChange();
+    });
+  }
+  /**
+   * We only listen to the `selectionchange` event when
+   * there is an intention of moving the caret to the beginning using shortcuts.
+   * This is primarily implemented to prevent infinite loops, as we are changing
+   * the selection within the handler of a `selectionchange` event.
+   */
+  ensureListeningToSelectionChange() {
+    if (this.selectionChangeDeadline = Date.now() + Ss, this.isListening) return;
+    this.isListening = !0;
+    const t = () => {
+      this.isListening = !1, Date.now() <= this.selectionChangeDeadline && this.handleSelectionChange();
+    };
+    document.addEventListener("selectionchange", t, {
+      once: !0
+    });
+  }
+  handleSelectionChange() {
+    const t = document.getSelection();
+    if (!t) return;
+    const e = t.getRangeAt(0);
+    if (e.collapsed !== !0 || e.startOffset !== 0) return;
+    const s = this.rich.scroll.find(e.startContainer);
+    if (!(s instanceof T) || !s.uiNode) return;
+    const i = document.createRange();
+    i.setStartAfter(s.uiNode), i.setEndAfter(s.uiNode), t.removeAllRanges(), t.addRange(i);
+  }
+}
+class he extends Y {
+  constructor(t, e) {
+    super(t, e), t.root.addEventListener("drop", (s) => {
+      s.preventDefault();
+      let i = null;
+      if (document.caretRangeFromPoint)
+        i = document.caretRangeFromPoint(s.clientX, s.clientY);
+      else if (document.caretPositionFromPoint) {
+        const o = document.caretPositionFromPoint(s.clientX, s.clientY);
+        i = document.createRange(), i.setStart(o.offsetNode, o.offset), i.setEnd(o.offsetNode, o.offset);
+      }
+      const n = i && t.selection.normalizeNative(i);
+      if (n) {
+        const o = t.selection.normalizedToRange(n);
+        s.dataTransfer?.files && this.upload(o, s.dataTransfer.files);
+      }
+    });
+  }
+  upload(t, e) {
+    const s = [];
+    Array.from(e).forEach((i) => {
+      i && this.options.mimetypes?.includes(i.type) && s.push(i);
+    }), s.length > 0 && this.options.handler.call(this, t, s);
+  }
+}
+he.DEFAULTS = {
+  mimetypes: ["image/png", "image/jpeg"],
+  handler(r, t) {
+    if (!this.rich.scroll.query("image"))
+      return;
+    const e = t.map((s) => new Promise((i) => {
+      const n = new FileReader();
+      n.onload = () => {
+        i(n.result);
+      }, n.readAsDataURL(s);
+    }));
+    Promise.all(e).then((s) => {
+      const i = s.reduce((n, o) => n.insert({ image: o }), new f().retain(r.index).delete(r.length));
+      this.rich.updateContents(i, m.sources.USER), this.rich.setSelection(
+        r.index + s.length,
+        m.sources.SILENT
+      );
+    });
+  }
+};
+u.register({
+  "blots/block": O,
+  "blots/block/embed": I,
+  "blots/break": F,
+  "blots/container": Bt,
+  "blots/cursor": U,
+  "blots/embed": ie,
+  "blots/inline": M,
+  "blots/scroll": Me,
+  "blots/text": $,
+  "modules/clipboard": fs,
+  "modules/history": ws,
+  "modules/keyboard": gt,
+  "modules/uploader": he,
+  "modules/input": vs,
+  "modules/uiNode": Bs
+});
+export {
+  C as A,
+  O as B,
+  q as C,
+  f as D,
+  ie as E,
+  Ke as F,
+  Pe as G,
+  oe as H,
+  R as I,
+  Y as M,
+  k as O,
+  Ne as P,
+  u as R,
+  p as S,
+  $ as T,
+  rt as a,
+  Bt as b,
+  M as c,
+  B as d,
+  I as e,
+  U as f,
+  F as g,
+  z as h,
+  st as i,
+  Le as j,
+  se as k,
+  mt as l,
+  m,
+  G as n,
+  qe as o,
+  _e as p,
+  $e as q,
+  Fe as r,
+  je as s,
+  ce as t,
+  Vs as u,
+  Ws as v,
+  Hs as w,
+  Ks as x,
+  qs as y,
+  zs as z
+};