@wrdagency/blockout 0.1.10 → 1.0.1

package/dist/components/controls/markdown-control/editor.js

@@ -0,0 +1,807 @@
+import { jsx as C, jsxs as ge } from "react/jsx-runtime";
+import { cn as ye } from "../../../utils/css.js";
+import { r as T, w as ve, c as we, d as be, a as V, h as S, b as F, p as Me, E as Ie, l as ke, e as Ee, f as Ce } from "../../../toolbar-j1SJvq8D.js";
+import { $ as X, d as Le, T as Y, a as ee, s as Pe, g as Oe, b as j, P as z, h as te, i as Te, j as Se, k as _e, l as Ae, m as De, M as je, n as Ne, o as ne, q as W, r as xe, I as Ue, S as Fe, t as Be, E as qe, u as ze, v as He, w as Ke } from "../../../index-EPj3dCzl.js";
+import { l as Re, c as $e, g as Ve, w as We } from "../../../commands-IQnqt4xL.js";
+import '../../../assets/prosemirror.css';/* empty css                            */
+import { d as Ge, M as Je, a as Ze, b as Qe } from "../../../index-CwFPDtaz.js";
+import { P as Xe } from "../../../base-jB1DIMnz.js";
+import "react";
+import { useMentionsPlugin as Ye } from "./slash/mentions.js";
+var et = Object.defineProperty, G = Object.getOwnPropertySymbols, tt = Object.prototype.hasOwnProperty, nt = Object.prototype.propertyIsEnumerable, J = (n, e, t) => e in n ? et(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, rt = (n, e) => {
+  for (var t in e || (e = {}))
+    tt.call(e, t) && J(n, t, e[t]);
+  if (G)
+    for (var t of G(e))
+      nt.call(e, t) && J(n, t, e[t]);
+  return n;
+};
+function re(n, e) {
+  return Object.assign(n, {
+    meta: rt({
+      package: "@milkdown/components"
+    }, e)
+  }), n;
+}
+const st = {
+  renderLabel: ({ label: n, listType: e, checked: t }) => t == null ? e === "bullet" ? "⦿" : n : t ? "☑" : "□"
+}, N = X(
+  st,
+  "listItemBlockConfigCtx"
+);
+re(N, {
+  displayName: "Config<list-item-block>",
+  group: "ListItemBlock"
+});
+function se({ icon: n, class: e, onClick: t }) {
+  return /* @__PURE__ */ S(
+    "span",
+    {
+      class: F("milkdown-icon", e),
+      onPointerdown: t,
+      innerHTML: n ? Me.sanitize(n.trim()) : void 0
+    }
+  );
+}
+se.props = {
+  icon: {
+    type: String,
+    required: !1
+  },
+  class: {
+    type: String,
+    required: !1
+  },
+  onClick: {
+    type: Function,
+    required: !1
+  }
+};
+const it = be({
+  props: {
+    label: {
+      type: Object,
+      required: !0
+    },
+    checked: {
+      type: Object,
+      required: !0
+    },
+    listType: {
+      type: Object,
+      required: !0
+    },
+    config: {
+      type: Object,
+      required: !0
+    },
+    readonly: {
+      type: Object,
+      required: !0
+    },
+    selected: {
+      type: Object,
+      required: !0
+    },
+    setAttr: {
+      type: Function,
+      required: !0
+    },
+    onMount: {
+      type: Function,
+      required: !0
+    }
+  },
+  setup({
+    label: n,
+    checked: e,
+    listType: t,
+    config: s,
+    readonly: r,
+    setAttr: i,
+    onMount: o,
+    selected: l
+  }) {
+    const a = (u) => {
+      u != null && u instanceof Element && o(u);
+    }, d = (u) => {
+      u.stopPropagation(), u.preventDefault(), e.value != null && i("checked", !e.value);
+    }, f = V(() => s.renderLabel({
+      label: n.value,
+      listType: t.value,
+      checked: e.value,
+      readonly: r.value
+    })), p = V(() => e.value == null ? t.value === "bullet" ? "bullet" : "ordered" : e.value ? "checked" : "unchecked");
+    return () => /* @__PURE__ */ S(
+      "li",
+      {
+        class: F(
+          "list-item",
+          l.value && "ProseMirror-selectednode"
+        )
+      },
+      /* @__PURE__ */ S(
+        "div",
+        {
+          class: "label-wrapper",
+          onPointerdown: d,
+          contenteditable: !1
+        },
+        /* @__PURE__ */ S(
+          se,
+          {
+            class: F(
+              "label",
+              r.value && "readonly",
+              p.value
+            ),
+            icon: f.value
+          }
+        )
+      ),
+      /* @__PURE__ */ S("div", { class: "children", ref: a })
+    );
+  }
+}), ie = Le(
+  Re.node,
+  (n) => (e, t, s) => {
+    const r = document.createElement("div");
+    r.className = "milkdown-list-item-block";
+    const i = document.createElement("div");
+    i.setAttribute("data-content-dom", "true"), i.classList.add("content-dom");
+    const o = T(e.attrs.label), l = T(e.attrs.checked), a = T(e.attrs.listType), d = T(!t.editable), f = n.get(N.key), p = T(!1), u = (c, E) => {
+      if (!t.editable) return;
+      const w = s();
+      w != null && (t.hasFocus() || t.focus(), t.dispatch(t.state.tr.setNodeAttribute(w, c, E)));
+    }, h = ve(() => {
+      p.value ? r.classList.add("selected") : r.classList.remove("selected");
+    });
+    let g = 0;
+    const b = we(it, {
+      label: o,
+      checked: l,
+      listType: a,
+      readonly: d,
+      config: f,
+      selected: p,
+      setAttr: u,
+      onMount: (c) => {
+        const { anchor: E, head: w } = t.state.selection;
+        c.appendChild(i);
+        const _ = t.state.doc.resolve(E), he = t.state.doc.resolve(w);
+        g = requestAnimationFrame(() => {
+          if (cancelAnimationFrame(g), !_.doc.eq(t.state.doc)) return;
+          const me = new Y(_, he);
+          t.dispatch(t.state.tr.setSelection(me));
+        });
+      }
+    });
+    b.mount(r);
+    const O = (c) => {
+      a.value = c.attrs.listType, o.value = c.attrs.label, l.value = c.attrs.checked, d.value = !t.editable;
+    };
+    O(e);
+    let k = e;
+    return {
+      dom: r,
+      contentDOM: i,
+      update: (c) => c.type !== e.type ? !1 : (c.sameMarkup(k) && c.content.eq(k.content) || (k = c, O(c)), !0),
+      ignoreMutation: (c) => !r || !i ? !0 : c.type === "selection" ? !1 : i === c.target && c.type === "attributes" ? !0 : !i.contains(c.target),
+      selectNode: () => {
+        p.value = !0;
+      },
+      deselectNode: () => {
+        p.value = !1;
+      },
+      destroy: () => {
+        h(), b.unmount(), r.remove(), i.remove();
+      }
+    };
+  }
+);
+re(ie, {
+  displayName: "NodeView<list-item-block>",
+  group: "ListItemBlock"
+});
+const ot = [
+  N,
+  ie
+];
+function B(n) {
+  if (!n) return !1;
+  if (Array.isArray(n))
+    return n.length > 1 ? !1 : B(n[0]);
+  const e = n.content;
+  return e ? B(e) : n.type === "text";
+}
+function at(n, e) {
+  return Object.assign(n, {
+    meta: {
+      package: "@milkdown/plugin-clipboard",
+      ...e
+    }
+  }), n;
+}
+const oe = ee((n) => {
+  const e = n.get(Pe);
+  n.update(Oe, (r) => ({
+    ...r,
+    editable: r.editable ?? (() => !0)
+  }));
+  const t = new j("MILKDOWN_CLIPBOARD");
+  return new z({
+    key: t,
+    props: {
+      handlePaste: (r, i) => {
+        var O, k;
+        const o = n.get(Te), l = (k = (O = r.props).editable) == null ? void 0 : k.call(O, r.state), { clipboardData: a } = i;
+        if (!l || !a || r.state.selection.$from.node().type.spec.code) return !1;
+        const f = a.getData("text/plain"), p = a.getData("vscode-editor-data");
+        if (p) {
+          const c = JSON.parse(p), E = c == null ? void 0 : c.mode;
+          if (f && E) {
+            const { tr: w } = r.state, _ = Se("code_block", e);
+            return w.replaceSelectionWith(_.create({ language: E })).setSelection(
+              Y.near(
+                w.doc.resolve(Math.max(0, w.selection.from - 2))
+              )
+            ).insertText(f.replace(/\r\n?/g, `
+`)), r.dispatch(w), !0;
+          }
+        }
+        const u = a.getData("text/html");
+        if (u.length === 0 && f.length === 0) return !1;
+        const h = _e.fromSchema(e);
+        let g;
+        if (u.length === 0) {
+          const c = o(f);
+          if (!c || typeof c == "string") return !1;
+          g = Ae.fromSchema(e).serializeFragment(
+            c.content
+          );
+        } else {
+          const c = document.createElement("template");
+          c.innerHTML = u, g = c.content.cloneNode(!0), c.remove();
+        }
+        const P = h.parseSlice(g), b = De(P);
+        if (b)
+          return r.dispatch(r.state.tr.replaceSelectionWith(b, !0)), !0;
+        try {
+          return r.dispatch(r.state.tr.replaceSelection(P)), !0;
+        } catch {
+          return !1;
+        }
+      },
+      clipboardTextSerializer: (r) => {
+        const i = n.get(te);
+        if (B(r.content.toJSON()))
+          return r.content.textBetween(
+            0,
+            r.content.size,
+            `
+
+`
+          );
+        const l = e.topNodeType.createAndFill(void 0, r.content);
+        return l ? i(l) : "";
+      }
+    }
+  });
+});
+at(oe, { displayName: "Prose<clipboard>" });
+var D = 200, m = function() {
+};
+m.prototype.append = function(e) {
+  return e.length ? (e = m.from(e), !this.length && e || e.length < D && this.leafAppend(e) || this.length < D && e.leafPrepend(this) || this.appendInner(e)) : this;
+};
+m.prototype.prepend = function(e) {
+  return e.length ? m.from(e).append(this) : this;
+};
+m.prototype.appendInner = function(e) {
+  return new lt(this, e);
+};
+m.prototype.slice = function(e, t) {
+  return e === void 0 && (e = 0), t === void 0 && (t = this.length), e >= t ? m.empty : this.sliceInner(Math.max(0, e), Math.min(this.length, t));
+};
+m.prototype.get = function(e) {
+  if (!(e < 0 || e >= this.length))
+    return this.getInner(e);
+};
+m.prototype.forEach = function(e, t, s) {
+  t === void 0 && (t = 0), s === void 0 && (s = this.length), t <= s ? this.forEachInner(e, t, s, 0) : this.forEachInvertedInner(e, t, s, 0);
+};
+m.prototype.map = function(e, t, s) {
+  t === void 0 && (t = 0), s === void 0 && (s = this.length);
+  var r = [];
+  return this.forEach(function(i, o) {
+    return r.push(e(i, o));
+  }, t, s), r;
+};
+m.from = function(e) {
+  return e instanceof m ? e : e && e.length ? new ae(e) : m.empty;
+};
+var ae = /* @__PURE__ */ function(n) {
+  function e(s) {
+    n.call(this), this.values = s;
+  }
+  n && (e.__proto__ = n), e.prototype = Object.create(n && n.prototype), e.prototype.constructor = e;
+  var t = { length: { configurable: !0 }, depth: { configurable: !0 } };
+  return e.prototype.flatten = function() {
+    return this.values;
+  }, e.prototype.sliceInner = function(r, i) {
+    return r == 0 && i == this.length ? this : new e(this.values.slice(r, i));
+  }, e.prototype.getInner = function(r) {
+    return this.values[r];
+  }, e.prototype.forEachInner = function(r, i, o, l) {
+    for (var a = i; a < o; a++)
+      if (r(this.values[a], l + a) === !1)
+        return !1;
+  }, e.prototype.forEachInvertedInner = function(r, i, o, l) {
+    for (var a = i - 1; a >= o; a--)
+      if (r(this.values[a], l + a) === !1)
+        return !1;
+  }, e.prototype.leafAppend = function(r) {
+    if (this.length + r.length <= D)
+      return new e(this.values.concat(r.flatten()));
+  }, e.prototype.leafPrepend = function(r) {
+    if (this.length + r.length <= D)
+      return new e(r.flatten().concat(this.values));
+  }, t.length.get = function() {
+    return this.values.length;
+  }, t.depth.get = function() {
+    return 0;
+  }, Object.defineProperties(e.prototype, t), e;
+}(m);
+m.empty = new ae([]);
+var lt = /* @__PURE__ */ function(n) {
+  function e(t, s) {
+    n.call(this), this.left = t, this.right = s, this.length = t.length + s.length, this.depth = Math.max(t.depth, s.depth) + 1;
+  }
+  return n && (e.__proto__ = n), e.prototype = Object.create(n && n.prototype), e.prototype.constructor = e, e.prototype.flatten = function() {
+    return this.left.flatten().concat(this.right.flatten());
+  }, e.prototype.getInner = function(s) {
+    return s < this.left.length ? this.left.get(s) : this.right.get(s - this.left.length);
+  }, e.prototype.forEachInner = function(s, r, i, o) {
+    var l = this.left.length;
+    if (r < l && this.left.forEachInner(s, r, Math.min(i, l), o) === !1 || i > l && this.right.forEachInner(s, Math.max(r - l, 0), Math.min(this.length, i) - l, o + l) === !1)
+      return !1;
+  }, e.prototype.forEachInvertedInner = function(s, r, i, o) {
+    var l = this.left.length;
+    if (r > l && this.right.forEachInvertedInner(s, r - l, Math.max(i, l) - l, o + l) === !1 || i < l && this.left.forEachInvertedInner(s, Math.min(r, l), i, o) === !1)
+      return !1;
+  }, e.prototype.sliceInner = function(s, r) {
+    if (s == 0 && r == this.length)
+      return this;
+    var i = this.left.length;
+    return r <= i ? this.left.slice(s, r) : s >= i ? this.right.slice(s - i, r - i) : this.left.slice(s, i).append(this.right.slice(0, r - i));
+  }, e.prototype.leafAppend = function(s) {
+    var r = this.right.leafAppend(s);
+    if (r)
+      return new e(this.left, r);
+  }, e.prototype.leafPrepend = function(s) {
+    var r = this.left.leafPrepend(s);
+    if (r)
+      return new e(r, this.right);
+  }, e.prototype.appendInner = function(s) {
+    return this.left.depth >= Math.max(this.right.depth, s.depth) + 1 ? new e(this.left, new e(this.right, s)) : new e(this, s);
+  }, e;
+}(m);
+const pt = 500;
+class y {
+  constructor(e, t) {
+    this.items = e, this.eventCount = t;
+  }
+  // Pop the latest event off the branch's history and apply it
+  // to a document transform.
+  popEvent(e, t) {
+    if (this.eventCount == 0)
+      return null;
+    let s = this.items.length;
+    for (; ; s--)
+      if (this.items.get(s - 1).selection) {
+        --s;
+        break;
+      }
+    let r, i;
+    t && (r = this.remapping(s, this.items.length), i = r.maps.length);
+    let o = e.tr, l, a, d = [], f = [];
+    return this.items.forEach((p, u) => {
+      if (!p.step) {
+        r || (r = this.remapping(s, u + 1), i = r.maps.length), i--, f.push(p);
+        return;
+      }
+      if (r) {
+        f.push(new v(p.map));
+        let h = p.step.map(r.slice(i)), g;
+        h && o.maybeStep(h).doc && (g = o.mapping.maps[o.mapping.maps.length - 1], d.push(new v(g, void 0, void 0, d.length + f.length))), i--, g && r.appendMap(g, i);
+      } else
+        o.maybeStep(p.step);
+      if (p.selection)
+        return l = r ? p.selection.map(r.slice(i)) : p.selection, a = new y(this.items.slice(0, s).append(f.reverse().concat(d)), this.eventCount - 1), !1;
+    }, this.items.length, 0), { remaining: a, transform: o, selection: l };
+  }
+  // Create a new branch with the given transform added.
+  addTransform(e, t, s, r) {
+    let i = [], o = this.eventCount, l = this.items, a = !r && l.length ? l.get(l.length - 1) : null;
+    for (let f = 0; f < e.steps.length; f++) {
+      let p = e.steps[f].invert(e.docs[f]), u = new v(e.mapping.maps[f], p, t), h;
+      (h = a && a.merge(u)) && (u = h, f ? i.pop() : l = l.slice(0, l.length - 1)), i.push(u), t && (o++, t = void 0), r || (a = u);
+    }
+    let d = o - s.depth;
+    return d > ct && (l = ut(l, d), o -= d), new y(l.append(i), o);
+  }
+  remapping(e, t) {
+    let s = new je();
+    return this.items.forEach((r, i) => {
+      let o = r.mirrorOffset != null && i - r.mirrorOffset >= e ? s.maps.length - r.mirrorOffset : void 0;
+      s.appendMap(r.map, o);
+    }, e, t), s;
+  }
+  addMaps(e) {
+    return this.eventCount == 0 ? this : new y(this.items.append(e.map((t) => new v(t))), this.eventCount);
+  }
+  // When the collab module receives remote changes, the history has
+  // to know about those, so that it can adjust the steps that were
+  // rebased on top of the remote changes, and include the position
+  // maps for the remote changes in its array of items.
+  rebased(e, t) {
+    if (!this.eventCount)
+      return this;
+    let s = [], r = Math.max(0, this.items.length - t), i = e.mapping, o = e.steps.length, l = this.eventCount;
+    this.items.forEach((u) => {
+      u.selection && l--;
+    }, r);
+    let a = t;
+    this.items.forEach((u) => {
+      let h = i.getMirror(--a);
+      if (h == null)
+        return;
+      o = Math.min(o, h);
+      let g = i.maps[h];
+      if (u.step) {
+        let P = e.steps[h].invert(e.docs[h]), b = u.selection && u.selection.map(i.slice(a + 1, h));
+        b && l++, s.push(new v(g, P, b));
+      } else
+        s.push(new v(g));
+    }, r);
+    let d = [];
+    for (let u = t; u < o; u++)
+      d.push(new v(i.maps[u]));
+    let f = this.items.slice(0, r).append(d).append(s), p = new y(f, l);
+    return p.emptyItemCount() > pt && (p = p.compress(this.items.length - s.length)), p;
+  }
+  emptyItemCount() {
+    let e = 0;
+    return this.items.forEach((t) => {
+      t.step || e++;
+    }), e;
+  }
+  // Compressing a branch means rewriting it to push the air (map-only
+  // items) out. During collaboration, these naturally accumulate
+  // because each remote change adds one. The `upto` argument is used
+  // to ensure that only the items below a given level are compressed,
+  // because `rebased` relies on a clean, untouched set of items in
+  // order to associate old items with rebased steps.
+  compress(e = this.items.length) {
+    let t = this.remapping(0, e), s = t.maps.length, r = [], i = 0;
+    return this.items.forEach((o, l) => {
+      if (l >= e)
+        r.push(o), o.selection && i++;
+      else if (o.step) {
+        let a = o.step.map(t.slice(s)), d = a && a.getMap();
+        if (s--, d && t.appendMap(d, s), a) {
+          let f = o.selection && o.selection.map(t.slice(s));
+          f && i++;
+          let p = new v(d.invert(), a, f), u, h = r.length - 1;
+          (u = r.length && r[h].merge(p)) ? r[h] = u : r.push(p);
+        }
+      } else o.map && s--;
+    }, this.items.length, 0), new y(m.from(r.reverse()), i);
+  }
+}
+y.empty = new y(m.empty, 0);
+function ut(n, e) {
+  let t;
+  return n.forEach((s, r) => {
+    if (s.selection && e-- == 0)
+      return t = r, !1;
+  }), n.slice(t);
+}
+class v {
+  constructor(e, t, s, r) {
+    this.map = e, this.step = t, this.selection = s, this.mirrorOffset = r;
+  }
+  merge(e) {
+    if (this.step && e.step && !e.selection) {
+      let t = e.step.merge(this.step);
+      if (t)
+        return new v(t.getMap().invert(), t, this.selection);
+    }
+  }
+}
+class M {
+  constructor(e, t, s, r, i) {
+    this.done = e, this.undone = t, this.prevRanges = s, this.prevTime = r, this.prevComposition = i;
+  }
+}
+const ct = 20;
+function dt(n, e, t, s) {
+  let r = t.getMeta(I), i;
+  if (r)
+    return r.historyState;
+  t.getMeta(mt) && (n = new M(n.done, n.undone, null, 0, -1));
+  let o = t.getMeta("appendedTransaction");
+  if (t.steps.length == 0)
+    return n;
+  if (o && o.getMeta(I))
+    return o.getMeta(I).redo ? new M(n.done.addTransform(t, void 0, s, A(e)), n.undone, Z(t.mapping.maps), n.prevTime, n.prevComposition) : new M(n.done, n.undone.addTransform(t, void 0, s, A(e)), null, n.prevTime, n.prevComposition);
+  if (t.getMeta("addToHistory") !== !1 && !(o && o.getMeta("addToHistory") === !1)) {
+    let l = t.getMeta("composition"), a = n.prevTime == 0 || !o && n.prevComposition != l && (n.prevTime < (t.time || 0) - s.newGroupDelay || !ft(t, n.prevRanges)), d = o ? x(n.prevRanges, t.mapping) : Z(t.mapping.maps);
+    return new M(n.done.addTransform(t, a ? e.selection.getBookmark() : void 0, s, A(e)), y.empty, d, t.time, l ?? n.prevComposition);
+  } else return (i = t.getMeta("rebased")) ? new M(n.done.rebased(t, i), n.undone.rebased(t, i), x(n.prevRanges, t.mapping), n.prevTime, n.prevComposition) : new M(n.done.addMaps(t.mapping.maps), n.undone.addMaps(t.mapping.maps), x(n.prevRanges, t.mapping), n.prevTime, n.prevComposition);
+}
+function ft(n, e) {
+  if (!e)
+    return !1;
+  if (!n.docChanged)
+    return !0;
+  let t = !1;
+  return n.mapping.maps[0].forEach((s, r) => {
+    for (let i = 0; i < e.length; i += 2)
+      s <= e[i + 1] && r >= e[i] && (t = !0);
+  }), t;
+}
+function Z(n) {
+  let e = [];
+  for (let t = n.length - 1; t >= 0 && e.length == 0; t--)
+    n[t].forEach((s, r, i, o) => e.push(i, o));
+  return e;
+}
+function x(n, e) {
+  if (!n)
+    return null;
+  let t = [];
+  for (let s = 0; s < n.length; s += 2) {
+    let r = e.map(n[s], 1), i = e.map(n[s + 1], -1);
+    r <= i && t.push(r, i);
+  }
+  return t;
+}
+function ht(n, e, t) {
+  let s = A(e), r = I.get(e).spec.config, i = (t ? n.undone : n.done).popEvent(e, s);
+  if (!i)
+    return null;
+  let o = i.selection.resolve(i.transform.doc), l = (t ? n.done : n.undone).addTransform(i.transform, e.selection.getBookmark(), r, s), a = new M(t ? l : i.remaining, t ? i.remaining : l, null, 0, -1);
+  return i.transform.setSelection(o).setMeta(I, { redo: t, historyState: a });
+}
+let U = !1, Q = null;
+function A(n) {
+  let e = n.plugins;
+  if (Q != e) {
+    U = !1, Q = e;
+    for (let t = 0; t < e.length; t++)
+      if (e[t].spec.historyPreserveItems) {
+        U = !0;
+        break;
+      }
+  }
+  return U;
+}
+const I = new j("history"), mt = new j("closeHistory");
+function gt(n = {}) {
+  return n = {
+    depth: n.depth || 100,
+    newGroupDelay: n.newGroupDelay || 500
+  }, new z({
+    key: I,
+    state: {
+      init() {
+        return new M(y.empty, y.empty, null, 0, -1);
+      },
+      apply(e, t, s) {
+        return dt(t, s, e, n);
+      }
+    },
+    config: n,
+    props: {
+      handleDOMEvents: {
+        beforeinput(e, t) {
+          let s = t.inputType, r = s == "historyUndo" ? pe : s == "historyRedo" ? ue : null;
+          return !r || !e.editable ? !1 : (t.preventDefault(), r(e.state, e.dispatch));
+        }
+      }
+    }
+  });
+}
+function le(n, e) {
+  return (t, s) => {
+    let r = I.getState(t);
+    if (!r || (n ? r.undone : r.done).eventCount == 0)
+      return !1;
+    if (s) {
+      let i = ht(r, t, n);
+      i && s(e ? i.scrollIntoView() : i);
+    }
+    return !0;
+  };
+}
+const pe = le(!1, !0), ue = le(!0, !0);
+function L(n, e) {
+  return Object.assign(n, {
+    meta: {
+      package: "@milkdown/plugin-history",
+      ...e
+    }
+  }), n;
+}
+const H = ne("Undo", () => () => pe);
+L(H, {
+  displayName: "Command<undo>"
+});
+const K = ne("Redo", () => () => ue);
+L(K, {
+  displayName: "Command<redo>"
+});
+const R = X({}, "historyProviderConfig");
+L(R, {
+  displayName: "Ctx<historyProviderConfig>"
+});
+const ce = ee(
+  (n) => gt(n.get(R.key))
+);
+L(ce, {
+  displayName: "Ctx<historyProviderPlugin>"
+});
+const $ = Ne("historyKeymap", {
+  Undo: {
+    shortcuts: "Mod-z",
+    command: (n) => {
+      const e = n.get(W);
+      return () => e.call(H.key);
+    }
+  },
+  Redo: {
+    shortcuts: ["Mod-y", "Shift-Mod-z"],
+    command: (n) => {
+      const e = n.get(W);
+      return () => e.call(K.key);
+    }
+  }
+});
+L($.ctx, {
+  displayName: "KeymapCtx<history>"
+});
+L($.shortcuts, {
+  displayName: "Keymap<history>"
+});
+const yt = [
+  R,
+  ce,
+  $,
+  H,
+  K
+].flat();
+class de {
+  constructor() {
+    this.beforeMountedListeners = [], this.mountedListeners = [], this.updatedListeners = [], this.selectionUpdatedListeners = [], this.markdownUpdatedListeners = [], this.blurListeners = [], this.focusListeners = [], this.destroyListeners = [], this.beforeMount = (e) => (this.beforeMountedListeners.push(e), this), this.mounted = (e) => (this.mountedListeners.push(e), this), this.updated = (e) => (this.updatedListeners.push(e), this);
+  }
+  /// A getter to get all [subscribers](#interface-subscribers). You should not use this method directly.
+  get listeners() {
+    return {
+      beforeMount: this.beforeMountedListeners,
+      mounted: this.mountedListeners,
+      updated: this.updatedListeners,
+      markdownUpdated: this.markdownUpdatedListeners,
+      blur: this.blurListeners,
+      focus: this.focusListeners,
+      destroy: this.destroyListeners,
+      selectionUpdated: this.selectionUpdatedListeners
+    };
+  }
+  /// Subscribe to the markdownUpdated event.
+  /// This event will be triggered after the editor state is updated and **the document is changed**.
+  /// The second parameter is the current markdown and the third parameter is the previous markdown.
+  markdownUpdated(e) {
+    return this.markdownUpdatedListeners.push(e), this;
+  }
+  /// Subscribe to the blur event.
+  /// This event will be triggered when the editor is blurred.
+  blur(e) {
+    return this.blurListeners.push(e), this;
+  }
+  /// Subscribe to the focus event.
+  /// This event will be triggered when the editor is focused.
+  focus(e) {
+    return this.focusListeners.push(e), this;
+  }
+  /// Subscribe to the destroy event.
+  /// This event will be triggered before the editor is destroyed.
+  destroy(e) {
+    return this.destroyListeners.push(e), this;
+  }
+  /// Subscribe to the selectionUpdated event.
+  /// This event will be triggered when the editor selection is updated.
+  selectionUpdated(e) {
+    return this.selectionUpdatedListeners.push(e), this;
+  }
+}
+const q = xe(
+  new de(),
+  "listener"
+), vt = new j("MILKDOWN_LISTENER"), fe = (n) => (n.inject(q, new de()), async () => {
+  await n.wait(Ue);
+  const e = n.get(q), { listeners: t } = e;
+  t.beforeMount.forEach((a) => a(n)), await n.wait(Fe);
+  const s = n.get(te);
+  let r = null, i = null, o = null;
+  const l = new z({
+    key: vt,
+    view: () => ({
+      destroy: () => {
+        t.destroy.forEach((a) => a(n));
+      }
+    }),
+    props: {
+      handleDOMEvents: {
+        focus: () => (t.focus.forEach((a) => a(n)), !1),
+        blur: () => (t.blur.forEach((a) => a(n)), !1)
+      }
+    },
+    state: {
+      init: (a, d) => {
+        r = d.doc, i = s(d.doc);
+      },
+      apply: (a) => {
+        const d = a.selection;
+        return (!o && d || o && !d.eq(o)) && (t.selectionUpdated.forEach((p) => {
+          p(n, d, o);
+        }), o = d), !(a.docChanged || a.storedMarksSet) || a.getMeta("addToHistory") === !1 ? void 0 : Ge(() => {
+          const { doc: p } = a;
+          if (t.updated.length > 0 && r && !r.eq(p) && t.updated.forEach((u) => {
+            u(n, p, r);
+          }), t.markdownUpdated.length > 0 && r && !r.eq(p)) {
+            const u = s(p);
+            t.markdownUpdated.forEach((h) => {
+              h(n, u, i);
+            }), i = u;
+          }
+          r = p;
+        }, 200)();
+      }
+    }
+  });
+  n.update(Be, (a) => a.concat(l)), await n.wait(qe), t.mounted.forEach((a) => a(n));
+});
+fe.meta = {
+  package: "@milkdown/plugin-listener",
+  displayName: "Listener"
+};
+const wt = ({
+  className: n,
+  value: e,
+  onChangeValue: t
+}) => {
+  const s = Ye();
+  return Ze(
+    (r) => ze.make().config((i) => {
+      i.set(He, r), i.set(Ke, e), i.get(q).markdownUpdated((l, a) => {
+        t(a);
+      }), i.set(N.key, {
+        renderLabel: () => ""
+      }), i.update(ke.key, (l) => ({
+        ...l,
+        linkIcon: "",
+        editButton: "",
+        removeButton: "",
+        confirmButton: "",
+        inputPlaceholder: "Enter a URL..."
+      })), s.config(i);
+    }).use(fe).use($e).use(Ve).use(oe).use(yt).use(ot).use(We).config(Ee).use(Ce).use(s.plugin)
+  ), /* @__PURE__ */ ge("div", { className: ye("component-markdown-editor", n), children: [
+    /* @__PURE__ */ C(Ie, { className: "component-markdown-editor__toolbar" }),
+    /* @__PURE__ */ C("div", { className: "component-markdown-editor__content", children: /* @__PURE__ */ C(Qe, {}) })
+  ] });
+}, St = (n) => /* @__PURE__ */ C(Je, { children: /* @__PURE__ */ C(Xe, { children: /* @__PURE__ */ C(wt, { ...n }) }) });
+export {
+  St as MarkdownEditor
+};