@milkdown/preset-commonmark 6.5.4 → 7.0.0-next.0

package/lib/index.es.js

@@ -1,1486 +1,1201 @@
-import { createMark as q, createShortcut as M, createNode as C, pipe as Se, createPlugin as ve, AtomList as we } from "@milkdown/utils";
-import { createCmdKey as I, createCmd as N, commandsCtx as Le, editorViewCtx as v, schemaCtx as R, getPalette as Ae, createSlice as Ee, serializerCtx as _e, parserCtx as $e } from "@milkdown/core";
-import { toggleMark as pe, wrapIn as ge, setBlockType as A } from "@milkdown/prose/commands";
-import { expectDomTypeError as x, missingRootElement as Pe } from "@milkdown/exception";
-import { calculateTextPosition as Be, cloneTr as Re, findSelectedNodeOfType as F, getNodeFromSchema as We } from "@milkdown/prose";
-import { PluginKey as H, TextSelection as Q, Plugin as T, NodeSelection as qe, Selection as Ce } from "@milkdown/prose/state";
-import { wrappingInputRule as K, textblockTypeInputRule as X, InputRule as xe } from "@milkdown/prose/inputrules";
-import { Fragment as W } from "@milkdown/prose/model";
-import { ReplaceStep as Ke, AddMarkStep as Fe } from "@milkdown/prose/transform";
-import { DecorationSet as S, Decoration as Z } from "@milkdown/prose/view";
-import { splitListItem as je, sinkListItem as ze, liftListItem as Ue } from "@milkdown/prose/schema-list";
-import Ve from "remark-inline-links";
-import { visit as Ge } from "unist-util-visit";
-const y = {
-  HardBreak: "HardBreak",
-  Blockquote: "Blockquote",
-  BulletList: "BulletList",
-  OrderedList: "OrderedList",
-  CodeFence: "CodeFence",
-  H1: "H1",
-  H2: "H2",
-  H3: "H3",
-  H4: "H4",
-  H5: "H5",
-  H6: "H6",
-  DowngradeHeading: "DowngradeHeading",
-  Text: "Text",
-  CodeInline: "CodeInline",
-  Em: "Em",
-  Bold: "Bold",
-  NextListItem: "NextListItem",
-  SinkListItem: "SinkListItem",
-  LiftListItem: "LiftListItem"
-}, ke = "code_inline", ee = I("ToggleInlineCode"), Ye = q((a) => ({
-  id: ke,
-  schema: () => ({
-    priority: 100,
-    code: !0,
-    inclusive: !1,
-    parseDOM: [{ tag: "code" }],
-    toDOM: (e) => ["code", { class: a.getClassName(e.attrs, "code-inline") }],
-    parseMarkdown: {
-      match: (e) => e.type === "inlineCode",
-      runner: (e, t, r) => {
-        e.openMark(r), e.addText(t.value), e.closeMark(r);
-      }
-    },
-    toMarkdown: {
-      match: (e) => e.type.name === ke,
-      runner: (e, t, r) => {
-        e.withMark(t, "inlineCode", r.text || "");
-      }
-    }
-  }),
-  commands: (e) => [
-    N(ee, () => (t, r) => {
-      const { selection: n, tr: o } = t;
-      if (n.empty)
-        return !1;
-      const { from: l, to: s } = n;
-      return t.doc.rangeHasMark(l, s, e) ? (r == null || r(o.removeMark(l, s, e)), !0) : (Object.keys(t.schema.marks).filter((u) => u !== e.name).map((u) => t.schema.marks[u]).forEach((u) => {
-        o.removeMark(l, s, u);
-      }), r == null || r(o.addMark(l, s, e.create())), !0);
-    })
+import { $markAttr as H, $markSchema as K, $command as u, $useKeymap as f, $node as X, $nodeAttr as k, $nodeSchema as y, $ctx as P, $inputRule as I, pipe as Be, $prose as w, $remark as W } from "@milkdown/utils";
+import { commandsCtx as m, editorViewCtx as R, serializerCtx as Re, parserCtx as Pe } from "@milkdown/core";
+import { toggleMark as q, setBlockType as S, wrapIn as F } from "@milkdown/prose/commands";
+import { Fragment as Z } from "@milkdown/prose/model";
+import { expectDomTypeError as b } from "@milkdown/exception";
+import { textblockTypeInputRule as ee, wrappingInputRule as V, InputRule as te } from "@milkdown/prose/inputrules";
+import { TextSelection as re, Selection as ne, PluginKey as N, Plugin as C } from "@milkdown/prose/state";
+import { findSelectedNodeOfType as We } from "@milkdown/prose";
+import { sinkListItem as qe, splitListItem as Fe, liftListItem as Ve } from "@milkdown/prose/schema-list";
+import { ReplaceStep as Ge, AddMarkStep as ze } from "@milkdown/prose/transform";
+import { Decoration as J, DecorationSet as Q } from "@milkdown/prose/view";
+import { visit as oe } from "unist-util-visit";
+import je from "remark-inline-links";
+const ae = H("emphasis"), se = K("emphasis", (r) => ({
+  inclusive: !1,
+  parseDOM: [
+    { tag: "i" },
+    { tag: "em" },
+    { style: "font-style", getAttrs: (e) => e === "italic" }
   ],
-  shortcuts: {
-    [y.CodeInline]: M(ee, "Mod-e")
-  }
-})), j = "em", te = I("ToggleItalic"), Je = q((a) => ({
-  id: j,
-  schema: () => ({
-    inclusive: !1,
-    parseDOM: [
-      { tag: "i" },
-      { tag: "em" },
-      { style: "font-style", getAttrs: (e) => e === "italic" }
-    ],
-    toDOM: (e) => ["em", { class: a.getClassName(e.attrs, j) }],
-    parseMarkdown: {
-      match: (e) => e.type === "emphasis",
-      runner: (e, t, r) => {
-        e.openMark(r), e.next(t.children), e.closeMark(r);
-      }
-    },
-    toMarkdown: {
-      match: (e) => e.type.name === j,
-      runner: (e, t) => {
-        e.withMark(t, "emphasis");
-      }
+  toDOM: (e) => ["em", r.get(ae.key)(e)],
+  parseMarkdown: {
+    match: (e) => e.type === "emphasis",
+    runner: (e, t, n) => {
+      e.openMark(n), e.next(t.children), e.closeMark(n);
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "emphasis",
+    runner: (e, t) => {
+      e.withMark(t, "emphasis");
     }
-  }),
-  commands: (e) => [N(te, () => pe(e))],
-  shortcuts: {
-    [y.Em]: M(te, "Mod-i")
   }
-})), Qe = new H("MILKDOWN_LINK_INPUT"), Te = I("ToggleLink"), re = I("ModifyLink"), $ = "link", Xe = q((a, e) => ({
-  id: $,
-  schema: () => ({
-    attrs: {
-      href: {},
-      title: { default: null }
-    },
-    parseDOM: [
-      {
-        tag: "a[href]",
-        getAttrs: (t) => {
-          if (!(t instanceof HTMLElement))
-            throw x(t);
-          return { href: t.getAttribute("href"), title: t.getAttribute("title") };
-        }
-      }
-    ],
-    toDOM: (t) => ["a", { ...t.attrs, class: a.getClassName(t.attrs, $) }],
-    parseMarkdown: {
-      match: (t) => t.type === "link",
-      runner: (t, r, n) => {
-        const o = r.url, l = r.title;
-        t.openMark(n, { href: o, title: l }), t.next(r.children), t.closeMark(n);
-      }
-    },
-    toMarkdown: {
-      match: (t) => t.type.name === $,
-      runner: (t, r) => {
-        t.withMark(r, "link", void 0, {
-          title: r.attrs.title,
-          url: r.attrs.href
-        });
-      }
+})), le = u("ToggleEmphasis", () => () => q(se.type())), Ue = f("emphasisKeymap", {
+  ToggleEmphasis: {
+    shortcuts: "Mod-i",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(le.key);
     }
-  }),
-  commands: (t) => [
-    N(Te, (r = "") => pe(t, { href: r })),
-    N(re, (r = "") => (n, o) => {
-      var k;
-      if (!o)
-        return !1;
-      const { marks: l } = n.schema;
-      let s, c = -1;
-      const { selection: i } = n, { from: u, to: f } = i;
-      if (n.doc.nodesBetween(u, u === f ? f + 1 : f, (b, w) => {
-        var L;
-        if ((L = l.link) != null && L.isInSet(b.marks))
-          return s = b, c = w, !1;
-      }), !s)
-        return !1;
-      const d = s.marks.find(({ type: b }) => b === t);
-      if (!d)
-        return !1;
-      const m = c, p = c + s.nodeSize, { tr: g } = n, h = (k = l.link) == null ? void 0 : k.create({ ...d.attrs, href: r });
-      return h ? (o(
-        g.removeMark(m, p, d).addMark(m, p, h).setSelection(new Q(g.selection.$anchor)).scrollIntoView()
-      ), !0) : !1;
-    })
+  }
+}), ce = H("strong"), ie = K("strong", (r) => ({
+  inclusive: !1,
+  parseDOM: [
+    { tag: "b" },
+    { tag: "strong" },
+    { style: "font-style", getAttrs: (e) => e === "bold" }
   ],
-  prosePlugins: (t, r) => {
-    let n = !1;
-    return [
-      new T({
-        key: Qe,
-        view: (o) => {
-          var u, f, d;
-          const l = a.themeManager.get("input-chip", {
-            placeholder: (f = (u = e == null ? void 0 : e.input) == null ? void 0 : u.placeholder) != null ? f : "Input Web Link",
-            buttonText: (d = e == null ? void 0 : e.input) == null ? void 0 : d.buttonText,
-            onUpdate: (m) => {
-              r.get(Le).call(re, m);
-            },
-            calculatePosition: (m, p) => {
-              Be(m, p, (g, h, k, b) => {
-                const w = m.dom.parentElement;
-                if (!w)
-                  throw Pe();
-                const L = h.left - g.left;
-                let D = g.left - b.left - (k.width - L) / 2, _ = g.bottom - b.top + 14 + w.scrollTop;
-                n && (_ = g.top - b.top - k.height - 14 + w.scrollTop), D < 0 && (D = 0);
-                const he = w.clientWidth - (k.width + 4);
-                return D > he && (D = he), [_, D];
-              });
-            }
-          });
-          if (!l)
-            return {};
-          const s = (m) => {
-            var b;
-            const { selection: p, doc: g } = m.state, { from: h, to: k } = p;
-            if (!m.hasFocus())
-              return !1;
-            if (p instanceof Q && k < g.content.size && h < g.content.size && g.rangeHasMark(h, h === k ? k + 1 : k, t)) {
-              let w = p.empty;
-              if (((b = e == null ? void 0 : e.input) == null ? void 0 : b.displayWhenSelected) && !w && g.nodesBetween(h, h === k ? k + 1 : k, (L, D) => {
-                if (L.marks.some(
-                  (_) => _.type === t && h >= D && k <= D + L.nodeSize
-                ))
-                  return w = !0, !1;
-              }), w)
-                return n = !1, !0;
-            }
-            if (p instanceof qe) {
-              const { node: w } = p;
-              if (w.type.name === "image" && w.marks.findIndex((L) => L.type.name === $) > -1)
-                return n = !0, !0;
-            }
-            return !1;
-          }, c = (m) => {
-            const { selection: p } = m.state;
-            let g;
-            const { from: h, to: k } = p;
-            if (m.state.doc.nodesBetween(h, h === k ? k + 1 : k, (L) => {
-              if (t.isInSet(L.marks))
-                return g = L, !1;
-            }), !g)
-              return;
-            const b = g.marks.find((L) => L.type === t);
-            return b ? b.attrs.href : void 0;
-          }, i = (m) => {
-            if (!m.editable)
-              return;
-            s(m) ? (l.show(m), l.update(c(m))) : l.hide();
-          };
-          return l.init(o), i(o), {
-            update: (m, p) => {
-              (p == null ? void 0 : p.doc.eq(m.state.doc)) && p.selection.eq(m.state.selection) || requestAnimationFrame(() => {
-                i(m);
-              });
-            },
-            destroy: () => {
-              l.destroy();
-            }
-          };
-        }
-      })
-    ];
+  toDOM: (e) => ["strong", r.get(ce.key)(e)],
+  parseMarkdown: {
+    match: (e) => e.type === "strong",
+    runner: (e, t, n) => {
+      e.openMark(n), e.next(t.children), e.closeMark(n);
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "strong",
+    runner: (e, t) => {
+      e.withMark(t, "strong");
+    }
   }
-})), z = "strong", ne = I("ToggleBold"), Ze = q((a) => ({
-  id: z,
-  schema: () => ({
-    inclusive: !1,
-    parseDOM: [
-      { tag: "b" },
-      { tag: "strong" },
-      { style: "font-style", getAttrs: (e) => e === "bold" }
-    ],
-    toDOM: (e) => ["strong", { class: a.getClassName(e.attrs, z) }],
-    parseMarkdown: {
-      match: (e) => e.type === "strong",
-      runner: (e, t, r) => {
-        e.openMark(r), e.next(t.children), e.closeMark(r);
-      }
-    },
-    toMarkdown: {
-      match: (e) => e.type.name === z,
-      runner: (e, t) => {
-        e.withMark(t, "strong");
-      }
+})), de = u("ToggleStrong", () => () => q(ie.type())), Ye = f("strongKeymap", {
+  ToggleBold: {
+    shortcuts: ["Mod-b"],
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(de.key);
     }
-  }),
-  commands: (e) => [N(ne, () => pe(e))],
-  shortcuts: {
-    [y.Bold]: M(ne, "Mod-b")
   }
-})), et = [Ye(), Je(), Ze(), Xe()], P = "blockquote", se = I("WrapInBlockquote"), tt = C((a) => ({
-  id: P,
-  schema: () => ({
-    content: "block+",
-    group: "block",
-    defining: !0,
-    parseDOM: [{ tag: "blockquote" }],
-    toDOM: (e) => ["blockquote", { class: a.getClassName(e.attrs, P) }, 0],
-    parseMarkdown: {
-      match: ({ type: e }) => e === P,
-      runner: (e, t, r) => {
-        e.openNode(r).next(t.children).closeNode();
-      }
-    },
-    toMarkdown: {
-      match: (e) => e.type.name === P,
-      runner: (e, t) => {
-        e.openNode("blockquote").next(t.content).closeNode();
-      }
+}), ue = H("inlineCode"), A = K("inlineCode", (r) => ({
+  priority: 100,
+  code: !0,
+  inclusive: !1,
+  parseDOM: [{ tag: "code" }],
+  toDOM: (e) => ["code", r.get(ue.key)(e)],
+  parseMarkdown: {
+    match: (e) => e.type === "inlineCode",
+    runner: (e, t, n) => {
+      e.openMark(n), e.addText(t.value), e.closeMark(n);
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "inlineCode",
+    runner: (e, t, n) => {
+      e.withMark(t, "inlineCode", n.text || "");
     }
-  }),
-  inputRules: (e) => [K(/^\s*>\s$/, e)],
-  commands: (e) => [N(se, () => ge(e))],
-  shortcuts: {
-    [y.Blockquote]: M(se, "Mod-Shift-b")
   }
-})), oe = I("WrapInBulletList"), rt = C((a) => {
-  const e = "bullet_list";
-  return {
-    id: e,
-    schema: () => ({
-      content: "listItem+",
-      group: "block",
-      attrs: {
-        spread: {
-          default: !1
-        }
-      },
-      parseDOM: [
-        {
-          tag: "ul",
-          getAttrs: (t) => {
-            if (!(t instanceof HTMLElement))
-              throw x(t);
-            return {
-              spread: t.dataset.spread
-            };
-          }
-        }
-      ],
-      toDOM: (t) => [
-        "ul",
-        {
-          "data-spread": t.attrs.spread,
-          class: a.getClassName(t.attrs, "bullet-list")
-        },
-        0
-      ],
-      parseMarkdown: {
-        match: ({ type: t, ordered: r }) => t === "list" && !r,
-        runner: (t, r, n) => {
-          const o = r.spread != null ? `${r.spread}` : "false";
-          t.openNode(n, { spread: o }).next(r.children).closeNode();
-        }
-      },
-      toMarkdown: {
-        match: (t) => t.type.name === e,
-        runner: (t, r) => {
-          t.openNode("list", void 0, { ordered: !1, spread: r.attrs.spread === "true" }).next(r.content).closeNode();
-        }
-      }
-    }),
-    inputRules: (t) => [K(/^\s*([-+*])\s$/, t)],
-    commands: (t) => [N(oe, () => ge(t))],
-    shortcuts: {
-      [y.BulletList]: M(oe, "Mod-Alt-8")
+})), pe = u("ToggleInlineCode", () => () => (r, e) => {
+  const { selection: t, tr: n } = r;
+  if (t.empty)
+    return !1;
+  const { from: o, to: a } = t;
+  return r.doc.rangeHasMark(o, a, A.type()) ? (e == null || e(n.removeMark(o, a, A.type())), !0) : (Object.keys(r.schema.marks).filter((c) => c !== A.type.name).map((c) => r.schema.marks[c]).forEach((c) => {
+    n.removeMark(o, a, c);
+  }), e == null || e(n.addMark(o, a, A.type().create())), !0);
+}), Je = f("inlineCodeKeymap", {
+  ToggleInlineCode: {
+    shortcuts: "Mod-e",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(pe.key);
     }
-  };
-}), nt = [
-  "",
-  "javascript",
-  "typescript",
-  "bash",
-  "sql",
-  "json",
-  "html",
-  "css",
-  "c",
-  "cpp",
-  "java",
-  "ruby",
-  "python",
-  "go",
-  "rust",
-  "markdown"
-], st = /^```(?<language>[a-z]*)?[\s\n]$/, ot = /^~~~(?<language>[a-z]*)?[\s\n]$/, ae = I("TurnIntoCodeFence"), U = "fence", at = C((a, e) => {
-  const t = (e == null ? void 0 : e.languageList) || nt;
-  return {
-    id: U,
-    schema: (r) => ({
-      content: "text*",
-      group: "block",
-      marks: "",
-      defining: !0,
-      code: !0,
-      attrs: {
-        language: {
-          default: ""
-        },
-        fold: {
-          default: !0
-        }
-      },
-      parseDOM: [
-        {
-          tag: "div.code-fence-container",
-          preserveWhitespace: "full",
-          getAttrs: (n) => {
-            var o;
-            if (!(n instanceof HTMLElement))
-              throw x(n);
-            return { language: (o = n.querySelector("pre")) == null ? void 0 : o.dataset.language };
-          },
-          getContent: (n, o) => {
-            var c, i;
-            if (!(n instanceof HTMLElement))
-              throw x(n);
-            const l = (i = (c = n.querySelector("pre")) == null ? void 0 : c.textContent) != null ? i : "";
-            if (!l)
-              return W.empty;
-            const s = o.text(l);
-            return W.from(s);
-          }
-        },
-        {
-          tag: "pre",
-          preserveWhitespace: "full",
-          getAttrs: (n) => {
-            if (!(n instanceof HTMLElement))
-              throw x(n);
-            return { language: n.dataset.language };
-          }
-        }
-      ],
-      toDOM: (n) => {
-        const o = document.createElement("select");
-        return t.forEach((l) => {
-          const s = document.createElement("option");
-          s.value = l, s.innerText = l || "--", l === n.attrs.language && (s.selected = !0), o.appendChild(s);
-        }), o.onchange = (l) => {
-          const s = l.target;
-          if (!(s instanceof HTMLSelectElement))
-            return;
-          const c = r.get(v);
-          if (!c.editable) {
-            s.value = n.attrs.language;
-            return;
-          }
-          const { top: i, left: u } = s.getBoundingClientRect(), f = c.posAtCoords({ top: i, left: u });
-          if (!f)
-            return;
-          const { tr: d } = c.state;
-          c.dispatch(
-            d.setNodeMarkup(f.inside, void 0, {
-              ...n.attrs,
-              language: s.value
-            })
-          );
-        }, [
-          "div",
-          {
-            class: "code-fence-container"
-          },
-          o,
-          [
-            "pre",
-            {
-              "data-language": n.attrs.language,
-              class: a.getClassName(n.attrs, "code-fence")
-            },
-            ["code", { spellCheck: "false" }, 0]
-          ]
-        ];
-      },
-      parseMarkdown: {
-        match: ({ type: n }) => n === "code",
-        runner: (n, o, l) => {
-          const s = o.lang, c = o.value;
-          n.openNode(l, { language: s }), c && n.addText(c), n.closeNode();
-        }
-      },
-      toMarkdown: {
-        match: (n) => n.type.name === U,
-        runner: (n, o) => {
-          var l;
-          n.addNode("code", void 0, ((l = o.content.firstChild) == null ? void 0 : l.text) || "", {
-            lang: o.attrs.language
-          });
-        }
+  }
+}), me = H("link"), v = K("link", (r) => ({
+  attrs: {
+    href: {},
+    title: { default: null }
+  },
+  parseDOM: [
+    {
+      tag: "a[href]",
+      getAttrs: (e) => {
+        if (!(e instanceof HTMLElement))
+          throw b(e);
+        return { href: e.getAttribute("href"), title: e.getAttribute("title") };
       }
-    }),
-    inputRules: (r) => [
-      X(st, r, (n) => {
-        const [o, l] = n;
-        if (!!o)
-          return { language: l };
-      }),
-      X(ot, r, (n) => {
-        const [o, l] = n;
-        if (!!o)
-          return { language: l };
-      })
-    ],
-    commands: (r) => [N(ae, () => A(r))],
-    shortcuts: {
-      [y.CodeFence]: M(ae, "Mod-Alt-c")
-    },
-    view: () => (r, n, o) => {
-      let l = r;
-      const s = (g) => {
-        const { tr: h } = n.state;
-        n.dispatch(
-          h.setNodeMarkup(o(), void 0, {
-            fold: !0,
-            language: g
-          })
-        );
-      }, c = () => {
-        const { tr: g } = n.state;
-        n.dispatch(
-          g.setNodeMarkup(o(), void 0, {
-            ...l.attrs,
-            fold: !0
-          })
-        );
-      }, i = () => {
-        const { tr: g } = n.state;
-        n.dispatch(
-          g.setNodeMarkup(o(), void 0, {
-            ...l.attrs,
-            fold: !1
-          })
-        );
-      }, u = a.themeManager.get("code-fence", {
-        view: n,
-        onBlur: c,
-        onFocus: i,
-        onSelectLanguage: s,
-        editable: () => n.editable,
-        languageList: t
+    }
+  ],
+  toDOM: (e) => ["a", { ...r.get(me.key)(e), ...e.attrs }],
+  parseMarkdown: {
+    match: (e) => e.type === "link",
+    runner: (e, t, n) => {
+      const o = t.url, a = t.title;
+      e.openMark(n, { href: o, title: a }), e.next(t.children), e.closeMark(n);
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "link",
+    runner: (e, t) => {
+      e.withMark(t, "link", void 0, {
+        title: t.attrs.title,
+        url: t.attrs.href
       });
-      if (!u)
-        return {};
-      const { dom: f, contentDOM: d, onUpdate: m, onDestroy: p } = u;
-      return m(l), {
-        dom: f,
-        contentDOM: d,
-        update: (g) => g.type.name !== U ? !1 : (l = g, m(l), !0),
-        destroy: p
-      };
     }
-  };
-}), lt = C(() => ({
-  id: "doc",
-  schema: () => ({
-    content: "block+",
-    parseMarkdown: {
-      match: ({ type: a }) => a === "root",
-      runner: (a, e, t) => {
-        a.injectRoot(e, t);
-      }
-    },
-    toMarkdown: {
-      match: (a) => a.type.name === "doc",
-      runner: (a, e) => {
-        a.openNode("root"), a.next(e.content);
-      }
+  }
+})), Qe = u("ToggleLink", () => (r = {}) => q(v.type(), r)), Xe = u("UpdateLink", () => (r = {}) => (e, t) => {
+  if (!t)
+    return !1;
+  let n, o = -1;
+  const { selection: a } = e, { from: s, to: l } = a;
+  if (e.doc.nodesBetween(s, s === l ? l + 1 : l, (h, _) => {
+    if (v.type().isInSet(h.marks))
+      return n = h, o = _, !1;
+  }), !n)
+    return !1;
+  const c = n.marks.find(({ type: h }) => h === v.type());
+  if (!c)
+    return !1;
+  const i = o, d = o + n.nodeSize, { tr: p } = e, g = v.type().create({ ...c.attrs, ...r });
+  return g ? (t(
+    p.removeMark(i, d, c).addMark(i, d, g).setSelection(new re(p.selection.$anchor)).scrollIntoView()
+  ), !0) : !1;
+}), Ze = X("doc", () => ({
+  content: "block+",
+  parseMarkdown: {
+    match: ({ type: r }) => r === "root",
+    runner: (r, e, t) => {
+      r.injectRoot(e, t);
     }
-  })
-})), le = I("InsertHardbreak"), ct = new H("MILKDOWN_HARDBREAK_FILTER"), it = C((a, e) => {
-  var r;
-  const t = (r = e == null ? void 0 : e.notIn) != null ? r : ["table", "fence"];
-  return {
-    id: "hardbreak",
-    schema: () => ({
-      inline: !0,
-      group: "inline",
-      selectable: !1,
-      parseDOM: [{ tag: "br" }],
-      toDOM: (n) => ["br", { class: a.getClassName(n.attrs, "hardbreak") }],
-      parseMarkdown: {
-        match: ({ type: n }) => n === "break",
-        runner: (n, o, l) => {
-          n.addNode(l);
-        }
-      },
-      toMarkdown: {
-        match: (n) => n.type.name === "hardbreak",
-        runner: (n) => {
-          n.addNode("break");
-        }
-      }
-    }),
-    commands: (n) => [
-      N(le, () => (o, l) => {
-        var i;
-        const { selection: s, tr: c } = o;
-        if (s.empty) {
-          const u = s.$from.node();
-          if (u.childCount > 0 && ((i = u.lastChild) == null ? void 0 : i.type.name) === "hardbreak")
-            return l == null || l(
-              c.replaceRangeWith(s.to - 1, s.to, o.schema.node("paragraph")).setSelection(Ce.near(c.doc.resolve(s.to))).scrollIntoView()
-            ), !0;
-        }
-        return l == null || l(c.setMeta("hardbreak", !0).replaceSelectionWith(n.create()).scrollIntoView()), !0;
-      })
-    ],
-    shortcuts: {
-      [y.HardBreak]: M(le, "Shift-Enter")
-    },
-    prosePlugins: (n) => [
-      new T({
-        key: ct,
-        filterTransaction: (o, l) => {
-          const s = o.getMeta("hardbreak"), [c] = o.steps;
-          if (s && c) {
-            const { from: i } = c, u = l.doc.resolve(i);
-            let f = u.depth, d = !0;
-            for (; f > 0; )
-              t.includes(u.node(f).type.name) && (d = !1), f--;
-            return d;
-          }
-          return !0;
-        }
-      }),
-      new T({
-        key: new H("MILKDOWN_HARDBREAK_MARKS"),
-        appendTransaction: (o, l, s) => {
-          if (!o.length)
-            return;
-          const [c] = o;
-          if (!c)
-            return;
-          const [i] = c.steps;
-          if (c.getMeta("hardbreak")) {
-            if (!(i instanceof Ke))
-              return;
-            const { from: d } = i;
-            return s.tr.setNodeMarkup(d, n, void 0, []);
-          }
-          if (i instanceof Fe) {
-            let d = s.tr;
-            const { from: m, to: p } = i;
-            return s.doc.nodesBetween(m, p, (g, h) => {
-              g.type === n && (d = d.setNodeMarkup(h, n, void 0, []));
-            }), d;
-          }
-        }
-      })
-    ]
-  };
-}), Me = Array(6).fill(0).map((a, e) => e + 1), O = I("TurnIntoHeading"), ye = I("DowngradeHeading"), V = new H("MILKDOWN_HEADING_ID"), ut = new H("MILKDOWN_HEADING_HASH"), dt = (a) => a.textContent.replace(/[\p{P}\p{S}]/gu, "").replace(/\s/g, "-").toLowerCase().trim(), ft = (a, e, t) => {
-  let r = !1;
-  const n = (o, l) => {
-    const s = o.tr.setMeta("addToHistory", !1);
-    let c = !1;
-    o.doc.descendants((i, u) => {
-      if (i.type === e && !r) {
-        if (i.textContent.trim().length === 0)
-          return;
-        const f = i.attrs, d = t(i);
-        f.id !== d && (c = !0, s.setMeta(V, !0).setNodeMarkup(u, void 0, {
-          ...f,
-          id: d
-        }));
-      }
-    }), c && l(s);
-  };
-  return new T({
-    key: V,
-    props: {
-      handleDOMEvents: {
-        compositionstart: () => (r = !0, !1),
-        compositionend: () => {
-          r = !1;
-          const o = a.get(v);
-          return setTimeout(() => {
-            n(o.state, (l) => o.dispatch(l));
-          }, 0), !1;
-        }
-      }
-    },
-    appendTransaction: (o, l, s) => {
-      let c = null;
-      return o.every((i) => !i.getMeta(V)) && o.some((i) => i.docChanged) && n(s, (i) => {
-        c = i;
-      }), c;
-    },
-    view: (o) => {
-      const l = o.state.doc;
-      let s = o.state.tr.setMeta("addToHistory", !1);
-      return l.descendants((c, i) => {
-        c.type.name === "heading" && c.attrs.level && (c.attrs.id || (s = s.setNodeMarkup(i, void 0, {
-          ...c.attrs,
-          id: t(c)
-        })));
-      }), o.dispatch(s), {};
+  },
+  toMarkdown: {
+    match: (r) => r.type.name === "doc",
+    runner: (r, e) => {
+      r.openNode("root"), r.next(e.content);
     }
-  });
-}, mt = (a, e, t) => new T({
-  key: ut,
-  state: {
-    init: () => S.empty,
-    apply: (r) => {
-      var f;
-      const n = a.get(v);
-      if (!((f = n.hasFocus) != null && f.call(n)) || !n.editable)
-        return S.empty;
-      const { $from: o } = r.selection, l = o.node();
-      if (l.type !== e)
-        return S.empty;
-      const s = l.attrs.level, c = (d) => Array(d).fill(0).map((m) => "#").join(""), i = document.createElement("span");
-      i.textContent = c(s), i.contentEditable = "false", t.themeManager.onFlush(() => {
-        const d = t.getStyle(({ css: m }) => {
-          const p = Ae(t.themeManager);
-          return m`
-                            margin-right: 4px;
-                            color: ${p("primary")};
-                        `;
-        });
-        d && (i.className = d);
-      });
-      const u = Z.widget(o.before() + 1, i, { side: -1 });
-      return S.create(r.doc, [u]);
+  }
+})), ge = k("paragraph"), L = y("paragraph", (r) => ({
+  content: "inline*",
+  group: "block",
+  parseDOM: [{ tag: "p" }],
+  toDOM: (e) => ["p", r.get(ge.key)(e), 0],
+  parseMarkdown: {
+    match: (e) => e.type === "paragraph",
+    runner: (e, t, n) => {
+      e.openNode(n), t.children ? e.next(t.children) : e.addText(t.value || ""), e.closeNode();
     }
   },
-  props: {
-    handleDOMEvents: {
-      focus: (r) => {
-        const n = Re(r.state.tr);
-        return r.dispatch(n), !1;
-      }
-    },
-    decorations(r) {
-      return this.getState(r);
+  toMarkdown: {
+    match: (e) => e.type.name === "paragraph",
+    runner: (e, t) => {
+      var o;
+      if (e.openNode("paragraph"), t.childCount >= 1 && ((o = t.lastChild) == null ? void 0 : o.type.name) === "hardbreak") {
+        const a = [];
+        t.content.forEach((s, l, c) => {
+          c !== t.childCount - 1 && a.push(s);
+        }), e.next(Z.fromArray(a));
+      } else
+        e.next(t.content);
+      e.closeNode();
     }
   }
-}), pt = C(
-  (a, e) => {
-    var o, l;
-    const t = "heading", r = (o = e == null ? void 0 : e.getId) != null ? o : dt, n = (l = e == null ? void 0 : e.displayHashtag) != null ? l : !0;
-    return {
-      id: t,
-      schema: () => ({
-        content: "inline*",
-        group: "block",
-        defining: !0,
-        attrs: {
-          id: {
-            default: ""
-          },
-          level: {
-            default: 1
-          }
-        },
-        parseDOM: Me.map((s) => ({
-          tag: `h${s}`,
-          getAttrs: (c) => {
-            if (!(c instanceof HTMLElement))
-              throw x(c);
-            return { level: s, id: c.id };
-          }
-        })),
-        toDOM: (s) => [
-          `h${s.attrs.level}`,
-          {
-            id: s.attrs.id || r(s),
-            class: a.getClassName(s.attrs, `heading h${s.attrs.level}`)
-          },
-          0
-        ],
-        parseMarkdown: {
-          match: ({ type: s }) => s === t,
-          runner: (s, c, i) => {
-            const u = c.depth;
-            s.openNode(i, { level: u }), s.next(c.children), s.closeNode();
-          }
-        },
-        toMarkdown: {
-          match: (s) => s.type.name === t,
-          runner: (s, c) => {
-            var u;
-            if (s.openNode("heading", void 0, { depth: c.attrs.level }), c.childCount >= 1 && ((u = c.lastChild) == null ? void 0 : u.type.name) === "hardbreak") {
-              const f = [];
-              c.content.forEach((d, m, p) => {
-                p !== c.childCount - 1 && f.push(d);
-              }), s.next(W.fromArray(f));
-            } else
-              s.next(c.content);
-            s.closeNode();
-          }
-        }
-      }),
-      inputRules: (s, c) => Me.map(
-        (i) => X(new RegExp(`^(#{1,${i}})\\s$`), s, () => {
-          const u = c.get(v), { $from: f } = u.state.selection, d = f.node();
-          if (d.type.name === "heading") {
-            let m = Number(d.attrs.level) + Number(i);
-            return m > 6 && (m = 6), {
-              level: m
-            };
-          }
-          return {
-            level: i
-          };
-        })
-      ),
-      commands: (s, c) => [
-        N(O, (i = 1) => i < 1 ? A(i === 0 && c.get(R).nodes.paragraph || s) : A(i === 0 && c.get(R).nodes.paragraph || s, { level: i })),
-        N(ye, () => (i, u, f) => {
-          const { $from: d } = i.selection, m = d.node();
-          if (m.type !== s || !i.selection.empty || d.parentOffset !== 0)
-            return !1;
-          const p = m.attrs.level - 1;
-          return p ? (u == null || u(
-            i.tr.setNodeMarkup(i.selection.$from.before(), void 0, {
-              ...m.attrs,
-              level: p
-            })
-          ), !0) : A(c.get(R).nodes.paragraph || s)(i, u, f);
-        })
-      ],
-      shortcuts: {
-        [y.H1]: M(O, "Mod-Alt-1", 1),
-        [y.H2]: M(O, "Mod-Alt-2", 2),
-        [y.H3]: M(O, "Mod-Alt-3", 3),
-        [y.H4]: M(O, "Mod-Alt-4", 4),
-        [y.H5]: M(O, "Mod-Alt-5", 5),
-        [y.H6]: M(O, "Mod-Alt-6", 6),
-        [y.DowngradeHeading]: M(ye, ["Backspace", "Delete"])
-      },
-      prosePlugins: (s, c) => {
-        const i = [ft(c, s, r)];
-        return n && i.push(mt(c, s, a)), i;
-      }
-    };
+})), fe = u("TurnIntoText", () => () => S(L.type())), et = f("paragraphKeymap", {
+  TurnIntoText: {
+    shortcuts: "Mod-Alt-0",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(fe.key);
+    }
   }
-), G = "hr", He = I("InsertHr"), gt = C((a) => ({
-  id: G,
-  schema: () => ({
+}), tt = Array(6).fill(0).map((r, e) => e + 1), rt = (r) => r.textContent.replace(/[\p{P}\p{S}]/gu, "").replace(/\s/g, "-").toLowerCase().trim(), G = P(rt, "headingIdGenerator"), he = k("heading"), T = y("heading", (r) => {
+  const e = r.get(G.key);
+  return {
+    content: "inline*",
     group: "block",
-    parseDOM: [{ tag: "hr" }],
-    toDOM: (e) => ["hr", { class: a.getClassName(e.attrs, G) }],
-    parseMarkdown: {
-      match: ({ type: e }) => e === "thematicBreak",
-      runner: (e, t, r) => {
-        e.addNode(r);
-      }
-    },
-    toMarkdown: {
-      match: (e) => e.type.name === G,
-      runner: (e) => {
-        e.addNode("thematicBreak");
-      }
-    }
-  }),
-  inputRules: (e) => [
-    new xe(/^(?:---|___\s|\*\*\*\s)$/, (t, r, n, o) => {
-      const { tr: l } = t;
-      return r[0] && l.replaceWith(n - 1, o, e.create()), l;
-    })
-  ],
-  commands: (e, t) => [
-    N(He, () => (r, n) => {
-      if (!n)
-        return !0;
-      const o = t.get(R).node("paragraph"), { tr: l, selection: s } = r, { from: c } = s, i = e.create();
-      if (!i)
-        return !0;
-      const u = l.replaceSelectionWith(i).insert(c, o), f = Ce.findFrom(u.doc.resolve(c), 1, !0);
-      return f && n(u.setSelection(f).scrollIntoView()), !0;
-    })
-  ]
-})), ce = I("ModifyImage"), De = I("InsertImage"), B = "image", ht = new H("MILKDOWN_IMAGE_INPUT"), kt = C((a, e) => ({
-  id: "image",
-  schema: () => ({
-    inline: !0,
-    group: "inline",
-    selectable: !0,
-    draggable: !0,
-    marks: "",
-    atom: !0,
     defining: !0,
-    isolating: !0,
     attrs: {
-      src: { default: "" },
-      alt: { default: "" },
-      title: { default: "" }
+      id: {
+        default: ""
+      },
+      level: {
+        default: 1
+      }
     },
-    parseDOM: [
-      {
-        tag: "img[src]",
-        getAttrs: (t) => {
-          if (!(t instanceof HTMLElement))
-            throw x(t);
-          return {
-            src: t.getAttribute("src") || "",
-            alt: t.getAttribute("alt") || "",
-            title: t.getAttribute("title") || t.getAttribute("alt") || ""
-          };
-        }
+    parseDOM: tt.map((t) => ({
+      tag: `h${t}`,
+      getAttrs: (n) => {
+        if (!(n instanceof HTMLElement))
+          throw b(n);
+        return { level: t, id: n.id };
       }
-    ],
+    })),
     toDOM: (t) => [
-      "img",
+      `h${t.attrs.level}`,
       {
-        ...t.attrs,
-        class: a.getClassName(t.attrs, B)
-      }
+        ...r.get(he.key)(t),
+        id: t.attrs.id || e(t)
+      },
+      0
     ],
     parseMarkdown: {
-      match: ({ type: t }) => t === B,
-      runner: (t, r, n) => {
-        const o = r.url, l = r.alt, s = r.title;
-        t.addNode(n, {
-          src: o,
-          alt: l,
-          title: s
-        });
+      match: ({ type: t }) => t === "heading",
+      runner: (t, n, o) => {
+        const a = n.depth;
+        t.openNode(o, { level: a }), t.next(n.children), t.closeNode();
       }
     },
     toMarkdown: {
-      match: (t) => t.type.name === B,
-      runner: (t, r) => {
-        t.addNode("image", void 0, void 0, {
-          title: r.attrs.title,
-          url: r.attrs.src,
-          alt: r.attrs.alt
-        });
+      match: (t) => t.type.name === "heading",
+      runner: (t, n) => {
+        var a;
+        if (t.openNode("heading", void 0, { depth: n.attrs.level }), n.childCount >= 1 && ((a = n.lastChild) == null ? void 0 : a.type.name) === "hardbreak") {
+          const s = [];
+          n.content.forEach((l, c, i) => {
+            i !== n.childCount - 1 && s.push(l);
+          }), t.next(Z.fromArray(s));
+        } else
+          t.next(n.content);
+        t.closeNode();
       }
     }
-  }),
-  commands: (t) => [
-    N(De, (r = "") => (n, o) => {
-      if (!o)
-        return !0;
-      const { tr: l } = n, s = t.create({ src: r });
-      if (!s)
-        return !0;
-      const c = l.replaceSelectionWith(s);
-      return o(c.scrollIntoView()), !0;
-    }),
-    N(ce, (r = "") => (n, o) => {
-      const l = F(n.selection, t);
-      if (!l)
-        return !1;
-      const { tr: s } = n;
-      return o == null || o(
-        s.setNodeMarkup(l.pos, void 0, { ...l.node.attrs, loading: !0, src: r }).scrollIntoView()
-      ), !0;
+  };
+}), nt = I(
+  (r) => ee(/^(?<hashes>#+)\s$/, T.type(), (e) => {
+    var s, l;
+    const t = ((l = (s = e.groups) == null ? void 0 : s.hashes) == null ? void 0 : l.length) || 0, n = r.get(R), { $from: o } = n.state.selection, a = o.node();
+    if (a.type.name === "heading") {
+      let c = Number(a.attrs.level) + Number(t);
+      return c > 6 && (c = 6), { level: c };
+    }
+    return { level: t };
+  })
+), M = u("WrapInHeading", () => (r) => (r ?? (r = 1), r < 1 ? S(L.type()) : S(T.type(), { level: r }))), ke = u("DowngradeHeading", () => () => (r, e, t) => {
+  const { $from: n } = r.selection, o = n.node();
+  if (o.type !== T.type() || !r.selection.empty || n.parentOffset !== 0)
+    return !1;
+  const a = o.attrs.level - 1;
+  return a ? (e == null || e(
+    r.tr.setNodeMarkup(r.selection.$from.before(), void 0, {
+      ...o.attrs,
+      level: a
     })
-  ],
-  inputRules: (t) => [
-    new xe(
-      /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
-      (r, n, o, l) => {
-        const [s, c, i = "", u] = n, { tr: f } = r;
-        return s && f.replaceWith(o, l, t.create({ src: i, alt: c, title: u })), f;
+  ), !0) : S(L.type())(r, e, t);
+}), ot = f("headingKeymap", {
+  TurnIntoH1: {
+    shortcuts: "Mod-Alt-1",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(M.key, 1);
+    }
+  },
+  TurnIntoH2: {
+    shortcuts: "Mod-Alt-2",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(M.key, 2);
+    }
+  },
+  TurnIntoH3: {
+    shortcuts: "Mod-Alt-3",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(M.key, 3);
+    }
+  },
+  TurnIntoH4: {
+    shortcuts: "Mod-Alt-4",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(M.key, 3);
+    }
+  },
+  TurnIntoH5: {
+    shortcuts: "Mod-Alt-5",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(M.key, 3);
+    }
+  },
+  TurnIntoH6: {
+    shortcuts: "Mod-Alt-6",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(M.key, 3);
+    }
+  },
+  DowngradeHeading: {
+    shortcuts: ["Delete", "Backspace"],
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(ke.key);
+    }
+  }
+}), ye = k("blockquote"), z = y("blockquote", (r) => ({
+  content: "block+",
+  group: "block",
+  defining: !0,
+  parseDOM: [{ tag: "blockquote" }],
+  toDOM: (e) => ["blockquote", r.get(ye.key)(e), 0],
+  parseMarkdown: {
+    match: ({ type: e }) => e === "blockquote",
+    runner: (e, t, n) => {
+      e.openNode(n).next(t.children).closeNode();
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "blockquote",
+    runner: (e, t) => {
+      e.openNode("blockquote").next(t.content).closeNode();
+    }
+  }
+})), at = I(() => V(/^\s*>\s$/, z.type())), Me = u("WrapInBlockquote", () => () => F(z.type())), st = f("blockquoteKeymap", {
+  WrapInBlockquote: {
+    shortcuts: "Mod-Shift-b",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(Me.key);
+    }
+  }
+}), Ie = k("codeBlock", () => ({
+  pre: {},
+  code: {}
+})), j = y("code_block", (r) => ({
+  content: "text*",
+  group: "block",
+  marks: "",
+  defining: !0,
+  code: !0,
+  attrs: {
+    language: {
+      default: ""
+    }
+  },
+  parseDOM: [
+    {
+      tag: "pre",
+      preserveWhitespace: "full",
+      getAttrs: (e) => {
+        if (!(e instanceof HTMLElement))
+          throw b(e);
+        return { language: e.dataset.language };
       }
-    )
+    }
   ],
-  view: () => (t) => {
-    var i, u;
-    let r = t;
-    const n = (i = e == null ? void 0 : e.placeholder) != null ? i : "Add an Image", o = (u = e == null ? void 0 : e.isBlock) != null ? u : !1, l = a.themeManager.get("image", {
-      placeholder: n,
-      isBlock: o
-    });
-    if (!l)
-      return {};
-    const { dom: s, onUpdate: c } = l;
-    return c(r), {
-      dom: s,
-      update: (f) => f.type.name !== B ? !1 : (r = f, c(r), !0),
-      selectNode: () => {
-        s.classList.add("ProseMirror-selectednode");
+  toDOM: (e) => {
+    const t = r.get(Ie.key)(e);
+    return [
+      "pre",
+      {
+        ...t.pre,
+        "data-language": e.attrs.language
       },
-      deselectNode: () => {
-        s.classList.remove("ProseMirror-selectednode");
-      }
-    };
+      ["code", t.code, 0]
+    ];
   },
-  prosePlugins: (t, r) => [
-    new T({
-      key: ht,
-      view: (n) => {
-        var i, u, f;
-        const o = a.themeManager.get("input-chip", {
-          placeholder: (u = (i = e == null ? void 0 : e.input) == null ? void 0 : i.placeholder) != null ? u : "Input Image Link",
-          buttonText: (f = e == null ? void 0 : e.input) == null ? void 0 : f.buttonText,
-          onUpdate: (d) => {
-            r.get(Le).call(ce, d);
-          }
-        });
-        if (!o)
-          return {};
-        const l = (d) => Boolean(
-          d.hasFocus() && t && F(d.state.selection, t)
-        ), s = (d) => {
-          const m = F(d.state.selection, t);
-          return m ? m.node.attrs.src : void 0;
-        }, c = (d) => {
-          if (!d.editable)
-            return;
-          l(d) ? (o.show(d), o.update(s(d))) : o.hide();
-        };
-        return o.init(n), c(n), {
-          update: (d, m) => {
-            (m == null ? void 0 : m.doc.eq(d.state.doc)) && m.selection.eq(d.state.selection) || c(d);
-          },
-          destroy: () => {
-            o.destroy();
-          }
-        };
-      }
-    })
-  ]
-})), Ne = "list_item", ie = I("SplitListItem"), ue = I("SinkListItem"), de = I("LiftListItem"), Mt = new H("MILKDOWN_KEEP_LIST_ORDER"), yt = (a) => {
-  const e = (t, r) => {
-    const n = We("ordered_list", t.schema);
-    let o = t.tr;
-    t.doc.descendants((l, s, c, i) => {
-      if (l.type === a && (c == null ? void 0 : c.type) === n) {
-        let u = !1;
-        const f = { ...l.attrs };
-        l.attrs.listType !== "ordered" && (f.listType = "ordered", u = !0);
-        const d = c == null ? void 0 : c.maybeChild(0);
-        d && d.type === a && d.attrs.listType === "ordered" && (f.label = `${i + 1}.`, u = !0), l.attrs.label === "\u2022" && (f.label = `${i + 1}.`, u = !0), u && (o = o.setNodeMarkup(s, void 0, f));
-      }
-    }), r(o);
+  parseMarkdown: {
+    match: ({ type: e }) => e === "code",
+    runner: (e, t, n) => {
+      const o = t.lang, a = t.value;
+      e.openNode(n, { language: o }), a && e.addText(a), e.closeNode();
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "code_block",
+    runner: (e, t) => {
+      var n;
+      e.addNode("code", void 0, ((n = t.content.firstChild) == null ? void 0 : n.text) || "", {
+        lang: t.attrs.language
+      });
+    }
+  }
+})), lt = I(() => ee(/^```(?<language>[a-z]*)?[\s\n]$/, j.type(), (r) => {
+  var e;
+  return {
+    language: ((e = r.groups) == null ? void 0 : e.language) ?? ""
   };
-  return new T({
-    key: Mt,
-    appendTransaction: (t, r, n) => {
-      let o = null;
-      return t.some((l) => l.docChanged) && e(n, (l) => {
-        o = l;
-      }), o;
+})), be = u("CreateCodeBlock", () => (r = "") => S(j.type(), { language: r })), lr = u("UpdateCodeBlockLanguage", () => ({ pos: r, language: e } = { pos: -1, language: "" }) => (t, n) => r >= 0 ? (n == null || n(t.tr.setNodeAttribute(r, "language", e)), !0) : !1), ct = f("codeBlockKeymap", {
+  CreateCodeBlock: {
+    shortcuts: "Mod-Alt-c",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(be.key);
     }
-  });
-}, Nt = C((a) => ({
-  id: Ne,
-  schema: () => ({
-    group: "listItem",
-    content: "paragraph block*",
-    attrs: {
-      label: {
-        default: "\u2022"
-      },
-      listType: {
-        default: "bullet"
-      },
-      spread: {
-        default: "true"
-      }
-    },
-    defining: !0,
-    parseDOM: [
-      {
-        tag: "li.list-item",
-        getAttrs: (e) => {
-          if (!(e instanceof HTMLElement))
-            throw x(e);
-          return {
-            label: e.dataset.label,
-            listType: e.dataset["list-type"],
-            spread: e.dataset.spread
-          };
-        },
-        contentElement: (e) => {
-          if (!(e instanceof HTMLElement))
-            throw x(e);
-          const t = e.querySelector(".list-item_body");
-          return t || e;
-        }
-      },
-      { tag: "li" }
-    ],
-    toDOM: (e) => [
-      "li",
-      {
-        class: a.getClassName(e.attrs, "list-item"),
-        "data-label": e.attrs.label,
-        "data-list-type": e.attrs.listType,
-        "data-spread": e.attrs.spread
-      },
-      ["div", { class: a.getClassName(e.attrs, "list-item_label") }, e.attrs.label],
-      ["div", { class: a.getClassName(e.attrs, "list-item_body") }, 0]
-    ],
-    parseMarkdown: {
-      match: ({ type: e, checked: t }) => e === "listItem" && t === null,
-      runner: (e, t, r) => {
-        const n = t.label != null ? `${t.label}.` : "\u2022", o = t.label != null ? "ordered" : "bullet", l = t.spread != null ? `${t.spread}` : "true";
-        e.openNode(r, { label: n, listType: o, spread: l }), e.next(t.children), e.closeNode();
-      }
-    },
-    toMarkdown: {
-      match: (e) => e.type.name === Ne,
-      runner: (e, t) => {
-        e.openNode("listItem", void 0, { spread: t.attrs.spread === "true" }), e.next(t.content), e.closeNode();
+  }
+}), we = k("image"), $ = y("image", (r) => ({
+  inline: !0,
+  group: "inline",
+  selectable: !0,
+  draggable: !0,
+  marks: "",
+  atom: !0,
+  defining: !0,
+  isolating: !0,
+  attrs: {
+    src: { default: "" },
+    alt: { default: "" },
+    title: { default: "" }
+  },
+  parseDOM: [
+    {
+      tag: "img[src]",
+      getAttrs: (e) => {
+        if (!(e instanceof HTMLElement))
+          throw b(e);
+        return {
+          src: e.getAttribute("src") || "",
+          alt: e.getAttribute("alt") || "",
+          title: e.getAttribute("title") || e.getAttribute("alt") || ""
+        };
       }
     }
-  }),
-  inputRules: (e) => [K(/^\s*([-+*])\s$/, e)],
-  commands: (e) => [
-    N(ie, () => je(e)),
-    N(ue, () => ze(e)),
-    N(de, () => Ue(e))
   ],
-  shortcuts: {
-    [y.NextListItem]: M(ie, "Enter"),
-    [y.SinkListItem]: M(ue, "Mod-]"),
-    [y.LiftListItem]: M(de, "Mod-[")
+  toDOM: (e) => ["img", { ...r.get(we.key)(e), ...e.attrs }],
+  parseMarkdown: {
+    match: ({ type: e }) => e === "image",
+    runner: (e, t, n) => {
+      const o = t.url, a = t.alt, s = t.title;
+      e.addNode(n, {
+        src: o,
+        alt: a,
+        title: s
+      });
+    }
   },
-  prosePlugins: (e) => [yt(e)]
-})), fe = I("WrapInOrderedList"), Ie = "ordered_list", It = C((a) => ({
-  id: Ie,
-  schema: () => ({
-    content: "listItem+",
-    group: "block",
-    attrs: {
-      order: {
-        default: 1
-      },
-      spread: {
-        default: !1
+  toMarkdown: {
+    match: (e) => e.type.name === "image",
+    runner: (e, t) => {
+      e.addNode("image", void 0, void 0, {
+        title: t.attrs.title,
+        url: t.attrs.src,
+        alt: t.attrs.alt
+      });
+    }
+  }
+})), it = u("InsertImage", () => (r = {}) => (e, t) => {
+  if (!t)
+    return !0;
+  const { src: n = "", alt: o = "", title: a = "" } = r, s = $.type().create({ src: n, alt: o, title: a });
+  return s && t(e.tr.replaceSelectionWith(s).scrollIntoView()), !0;
+}), dt = u("UpdateImage", () => (r = {}) => (e, t) => {
+  const n = We(e.selection, $.type());
+  if (!n)
+    return !1;
+  const { node: o, pos: a } = n, s = { ...o.attrs }, { src: l, alt: c, title: i } = r;
+  return l !== void 0 && (s.src = l), c !== void 0 && (s.alt = c), i !== void 0 && (s.title = i), t == null || t(e.tr.setNodeMarkup(a, void 0, s).scrollIntoView()), !0;
+}), cr = I(() => new te(
+  /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
+  (r, e, t, n) => {
+    const [o, a, s = "", l] = e;
+    return o ? r.tr.replaceWith(t, n, $.type().create({ src: s, alt: a, title: l })) : null;
+  }
+)), Ne = k("hardbreak", (r) => ({
+  "data-is-inline": r.attrs.isInline
+})), x = y("hardbreak", (r) => ({
+  inline: !0,
+  group: "inline",
+  attrs: {
+    isInline: {
+      default: !1
+    }
+  },
+  selectable: !1,
+  parseDOM: [{ tag: "br" }],
+  toDOM: (e) => ["br", r.get(Ne.key)(e)],
+  parseMarkdown: {
+    match: ({ type: e }) => e === "break",
+    runner: (e, t, n) => {
+      var o;
+      e.addNode(n, { isInline: Boolean((o = t.data) == null ? void 0 : o.isInline) });
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "hardbreak",
+    runner: (e, t) => {
+      t.attrs.isInline ? e.addNode("text", void 0, `
+`) : e.addNode("break");
+    }
+  }
+})), Ce = u("InsertHardbreak", () => () => (r, e) => {
+  var o;
+  const { selection: t, tr: n } = r;
+  if (t.empty) {
+    const a = t.$from.node();
+    if (a.childCount > 0 && ((o = a.lastChild) == null ? void 0 : o.type.name) === "hardbreak")
+      return e == null || e(
+        n.replaceRangeWith(t.to - 1, t.to, r.schema.node("paragraph")).setSelection(ne.near(n.doc.resolve(t.to))).scrollIntoView()
+      ), !0;
+  }
+  return e == null || e(n.setMeta("hardbreak", !0).replaceSelectionWith(x.type().create()).scrollIntoView()), !0;
+}), ut = f("hardbreakKeymap", {
+  InsertHardbreak: {
+    shortcuts: "Shift-Enter",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(Ce.key);
+    }
+  }
+}), Ae = k("hr"), U = y("hr", (r) => ({
+  group: "block",
+  parseDOM: [{ tag: "hr" }],
+  toDOM: (e) => ["hr", r.get(Ae.key)(e)],
+  parseMarkdown: {
+    match: ({ type: e }) => e === "thematicBreak",
+    runner: (e, t, n) => {
+      e.addNode(n);
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "hr",
+    runner: (e) => {
+      e.addNode("thematicBreak");
+    }
+  }
+})), pt = I(() => new te(
+  /^(?:---|___\s|\*\*\*\s)$/,
+  (r, e, t, n) => {
+    const { tr: o } = r;
+    return e[0] && o.replaceWith(t - 1, n, U.type().create()), o;
+  }
+)), mt = u("InsertHr", () => () => (r, e) => {
+  if (!e)
+    return !0;
+  const t = L.node.type().create(), { tr: n, selection: o } = r, { from: a } = o, s = U.type().create();
+  if (!s)
+    return !0;
+  const l = n.replaceSelectionWith(s).insert(a, t), c = ne.findFrom(l.doc.resolve(a), 1, !0);
+  return c && e(l.setSelection(c).scrollIntoView()), !0;
+}), ve = k("bulletList"), Y = y("bullet_list", (r) => ({
+  content: "listItem+",
+  group: "block",
+  attrs: {
+    spread: {
+      default: !1
+    }
+  },
+  parseDOM: [
+    {
+      tag: "ul",
+      getAttrs: (e) => {
+        if (!(e instanceof HTMLElement))
+          throw b(e);
+        return {
+          spread: e.dataset.spread
+        };
       }
+    }
+  ],
+  toDOM: (e) => [
+    "ul",
+    {
+      ...r.get(ve.key)(e),
+      "data-spread": e.attrs.spread
     },
-    parseDOM: [
-      {
-        tag: "ol",
-        getAttrs: (e) => {
-          if (!(e instanceof HTMLElement))
-            throw x(e);
-          return {
-            spread: e.dataset.spread,
-            order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
-          };
-        }
-      }
-    ],
-    toDOM: (e) => [
-      "ol",
-      {
-        ...e.attrs.order === 1 ? {} : e.attrs.order,
-        "data-spread": e.attrs.spread,
-        class: a.getClassName(e.attrs, "ordered-list")
-      },
-      0
-    ],
-    parseMarkdown: {
-      match: ({ type: e, ordered: t }) => e === "list" && !!t,
-      runner: (e, t, r) => {
-        const n = t.spread != null ? `${t.spread}` : "true";
-        e.openNode(r, { spread: n }).next(t.children).closeNode();
-      }
+    0
+  ],
+  parseMarkdown: {
+    match: ({ type: e, ordered: t }) => e === "list" && !t,
+    runner: (e, t, n) => {
+      const o = t.spread != null ? `${t.spread}` : "false";
+      e.openNode(n, { spread: o }).next(t.children).closeNode();
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "bullet_list",
+    runner: (e, t) => {
+      e.openNode("list", void 0, { ordered: !1, spread: t.attrs.spread === "true" }).next(t.content).closeNode();
+    }
+  }
+})), gt = I(() => V(/^\s*([-+*])\s$/, Y.type())), xe = u("WrapInBulletList", () => () => F(Y.type())), ft = f("bulletListKeymap", {
+  WrapInBulletList: {
+    shortcuts: "Mod-Alt-8",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(xe.key);
+    }
+  }
+}), Se = k("orderedList"), E = y("ordered_list", (r) => ({
+  content: "listItem+",
+  group: "block",
+  attrs: {
+    order: {
+      default: 1
     },
-    toMarkdown: {
-      match: (e) => e.type.name === Ie,
-      runner: (e, t) => {
-        e.openNode("list", void 0, { ordered: !0, start: 1, spread: t.attrs.spread === "true" }), e.next(t.content), e.closeNode();
+    spread: {
+      default: !1
+    }
+  },
+  parseDOM: [
+    {
+      tag: "ol",
+      getAttrs: (e) => {
+        if (!(e instanceof HTMLElement))
+          throw b(e);
+        return {
+          spread: e.dataset.spread,
+          order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
+        };
       }
     }
-  }),
-  inputRules: (e) => [
-    K(
-      /^(\d+)\.\s$/,
-      e,
-      (t) => ({ order: Number(t[1]) }),
-      (t, r) => r.childCount + r.attrs.order === Number(t[1])
-    )
   ],
-  commands: (e) => [N(fe, () => ge(e))],
-  shortcuts: {
-    [y.OrderedList]: M(fe, "Mod-Alt-7")
-  }
-})), me = I("TurnIntoText"), be = "paragraph", bt = C((a) => ({
-  id: be,
-  schema: () => ({
-    content: "inline*",
-    group: "block",
-    parseDOM: [{ tag: "p" }],
-    toDOM: (e) => ["p", { class: a.getClassName(e.attrs, be) }, 0],
-    parseMarkdown: {
-      match: (e) => e.type === "paragraph",
-      runner: (e, t, r) => {
-        e.openNode(r), t.children ? e.next(t.children) : e.addText(t.value), e.closeNode();
-      }
+  toDOM: (e) => [
+    "ol",
+    {
+      ...r.get(Se.key)(e),
+      ...e.attrs.order === 1 ? {} : e.attrs.order,
+      "data-spread": e.attrs.spread
     },
-    toMarkdown: {
-      match: (e) => e.type.name === "paragraph",
-      runner: (e, t) => {
-        var n;
-        if (e.openNode("paragraph"), t.childCount >= 1 && ((n = t.lastChild) == null ? void 0 : n.type.name) === "hardbreak") {
-          const o = [];
-          t.content.forEach((l, s, c) => {
-            c !== t.childCount - 1 && o.push(l);
-          }), e.next(W.fromArray(o));
-        } else
-          e.next(t.content);
-        e.closeNode();
-      }
+    0
+  ],
+  parseMarkdown: {
+    match: ({ type: e, ordered: t }) => e === "list" && !!t,
+    runner: (e, t, n) => {
+      const o = t.spread != null ? `${t.spread}` : "true";
+      e.openNode(n, { spread: o }).next(t.children).closeNode();
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "ordered_list",
+    runner: (e, t) => {
+      e.openNode("list", void 0, { ordered: !0, start: 1, spread: t.attrs.spread === "true" }), e.next(t.content), e.closeNode();
     }
-  }),
-  commands: (e) => [N(me, () => A(e))],
-  shortcuts: {
-    [y.Text]: M(me, "Mod-Alt-0")
   }
-})), wt = C(() => ({
-  id: "text",
-  schema: () => ({
-    group: "inline",
-    parseMarkdown: {
-      match: ({ type: a }) => a === "text",
-      runner: (a, e) => {
-        a.addText(e.value);
-      }
-    },
-    toMarkdown: {
-      match: (a) => a.type.name === "text",
-      runner: (a, e) => {
-        a.addNode("text", void 0, e.text);
-      }
+})), ht = I(() => V(
+  /^\s*(\d+)\.\s$/,
+  E.type(),
+  (r) => ({ order: Number(r[1]) }),
+  (r, e) => e.childCount + e.attrs.order === Number(r[1])
+)), Le = u("WrapInOrderedList", () => () => F(E.type())), kt = f("orderedListKeymap", {
+  WrapInOrderedList: {
+    shortcuts: "Mod-Alt-7",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(Le.key);
     }
-  })
-})), Lt = [
-  lt(),
-  bt(),
-  it(),
-  tt(),
-  at(),
-  rt(),
-  It(),
-  Nt(),
-  pt(),
-  gt(),
-  kt(),
-  wt()
-], Ct = () => {
-  function a(e) {
-    Ge(e, "list", (t) => {
-      var r;
-      if (t.ordered) {
-        const n = (r = t.start) != null ? r : 1;
-        t.children.forEach((o, l) => {
-          o.label = l + n;
-        });
-      }
-    });
   }
-  return a;
-}, xt = (a) => !!a.children, Tt = (a) => a.type === "html";
-function Ht(a, e) {
-  return t(a, 0, null)[0];
-  function t(r, n, o) {
-    if (xt(r)) {
-      const l = [];
-      for (let s = 0, c = r.children.length; s < c; s++) {
-        const i = r.children[s];
-        if (i) {
-          const u = t(i, s, r);
-          if (u)
-            for (let f = 0, d = u.length; f < d; f++) {
-              const m = u[f];
-              m && l.push(m);
-            }
-        }
+}), Te = k("listItem"), D = y("list_item", (r) => ({
+  group: "listItem",
+  content: "paragraph block*",
+  attrs: {
+    label: {
+      default: "•"
+    },
+    listType: {
+      default: "bullet"
+    },
+    spread: {
+      default: "true"
+    }
+  },
+  defining: !0,
+  parseDOM: [
+    {
+      tag: "li",
+      getAttrs: (e) => {
+        if (!(e instanceof HTMLElement))
+          throw b(e);
+        return {
+          label: e.dataset.label,
+          listType: e.dataset["list-type"],
+          spread: e.dataset.spread
+        };
       }
-      r.children = l;
     }
-    return e(r, n, o);
+  ],
+  toDOM: (e) => [
+    "li",
+    {
+      ...r.get(Te.key)(e),
+      "data-label": e.attrs.label,
+      "data-list-type": e.attrs.listType,
+      "data-spread": e.attrs.spread
+    },
+    0
+  ],
+  parseMarkdown: {
+    match: ({ type: e }) => e === "listItem",
+    runner: (e, t, n) => {
+      const o = t.label != null ? `${t.label}.` : "•", a = t.label != null ? "ordered" : "bullet", s = t.spread != null ? `${t.spread}` : "true";
+      e.openNode(n, { label: o, listType: a, spread: s }), e.next(t.children), e.closeNode();
+    }
+  },
+  toMarkdown: {
+    match: (e) => e.type.name === "list_item",
+    runner: (e, t) => {
+      e.openNode("listItem", void 0, { spread: t.attrs.spread === "true" }), e.next(t.content), e.closeNode();
+    }
   }
-}
-const Dt = () => {
-  function a(e) {
-    Ht(e, (t) => Tt(t) ? [] : [t]);
+})), De = u("SinkListItem", () => () => qe(D.type())), Oe = u("SplitListItem", () => () => Fe(D.type())), _e = u("SplitListItem", () => () => Ve(D.type())), yt = f("listItemKeymap", {
+  NextListItem: {
+    shortcuts: "Enter",
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(Oe.key);
+    }
+  },
+  SinkListItem: {
+    shortcuts: ["Tab", "Mod-]"],
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(De.key);
+    }
+  },
+  LiftListItem: {
+    shortcuts: ["Shift-Tab", "Mod-["],
+    command: (r) => {
+      const e = r.get(m);
+      return () => e.call(_e.key);
+    }
   }
-  return a;
-}, Ot = new H("MILKDOWN_INLINE_NODES_CURSOR"), St = () => {
-  let a = !1;
-  const e = new T({
-    key: Ot,
-    state: {
-      init() {
-        return !1;
-      },
-      apply(t) {
-        if (!t.selection.empty)
-          return !1;
-        const r = t.selection.$from, n = r.nodeBefore, o = r.nodeAfter;
-        return !!(n && o && n.isInline && !n.isText && o.isInline && !o.isText);
-      }
-    },
-    props: {
-      handleDOMEvents: {
-        compositionend: (t, r) => a ? (a = !1, requestAnimationFrame(() => {
-          if (e.getState(t.state)) {
-            const o = t.state.selection.from;
-            r.preventDefault(), t.dispatch(t.state.tr.insertText(r.data || "", o));
-          }
-        }), !0) : !1,
-        compositionstart: (t) => (e.getState(t.state) && (a = !0), !1),
-        beforeinput: (t, r) => {
-          if (e.getState(t.state) && r instanceof InputEvent && r.data && !a) {
-            const o = t.state.selection.from;
-            return r.preventDefault(), t.dispatch(t.state.tr.insertText(r.data || "", o)), !0;
-          }
-          return !1;
-        }
-      },
-      decorations(t) {
-        if (e.getState(t)) {
-          const o = t.selection.$from.pos, l = document.createElement("span"), s = Z.widget(o, l, {
-            side: -1
-          }), c = document.createElement("span"), i = Z.widget(o, c);
-          return setTimeout(() => {
-            l.contentEditable = "true", c.contentEditable = "true";
-          }), S.create(t.doc, [s, i]);
-        }
-        return S.empty;
-      }
+}), Mt = X("text", () => ({
+  group: "inline",
+  parseMarkdown: {
+    match: ({ type: r }) => r === "text",
+    runner: (r, e) => {
+      r.addText(e.value);
     }
-  });
-  return e;
-}, Y = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, vt = (a) => new RegExp(`\\\\(?=[^\\w\\s${a}\\\\]|_)`, "g"), At = (a) => {
-  let e = a, t = e.match(Y);
+  },
+  toMarkdown: {
+    match: (r) => r.type.name === "text",
+    runner: (r, e) => {
+      r.addNode("text", void 0, e.text);
+    }
+  }
+})), It = [
+  Ze,
+  ge,
+  L,
+  G,
+  he,
+  T,
+  Ne,
+  x,
+  ye,
+  z,
+  Ie,
+  j,
+  Ae,
+  U,
+  we,
+  $,
+  ve,
+  Y,
+  Se,
+  E,
+  Te,
+  D,
+  ae,
+  se,
+  ce,
+  ie,
+  ue,
+  A,
+  me,
+  v,
+  Mt
+].flat(), bt = [
+  at,
+  gt,
+  ht,
+  lt,
+  pt,
+  nt
+].flat(), wt = [
+  fe,
+  Me,
+  M,
+  ke,
+  be,
+  Ce,
+  mt,
+  it,
+  dt,
+  Le,
+  xe,
+  De,
+  Oe,
+  _e,
+  le,
+  pe,
+  de,
+  Qe,
+  Xe
+], Nt = [
+  st,
+  ct,
+  ut,
+  ot,
+  yt,
+  kt,
+  ft,
+  et,
+  Ue,
+  Je,
+  Ye
+].flat(), B = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, Ct = (r) => new RegExp(`\\\\(?=[^\\w\\s${r}\\\\]|_)`, "g"), At = (r) => {
+  let e = r, t = e.match(B);
   for (; t && t.groups; ) {
-    const { span: r } = t.groups;
-    e = e.replace(Y, r), t = e.match(Y);
+    const { span: n } = t.groups;
+    e = e.replace(B, n), t = e.match(B);
   }
   return e;
-}, Et = (a, e, t) => {
-  const r = a.split(""), n = r[e];
-  return r[e] && r[t] && (r[e] = r[t], r[t] = n), r.join("").toString();
-}, _t = (a) => (e) => e.replace(vt(a), ""), $t = (a) => (e) => {
-  const t = e.indexOf(a.hole), r = e.charAt(t - 1), n = e.charAt(t + 1), o = /[^\w]|_/;
-  return n ? r && o.test(r) && o.test(n) ? a.punctuation : a.char : a.punctuation;
-}, Pt = (a, e, t) => {
-  let r = e, n = !1;
-  return a.descendants((o) => {
-    var l;
-    if (n)
+}, vt = (r, e, t) => {
+  const n = r.split(""), o = n[e];
+  return n[e] && n[t] && (n[e] = n[t], n[t] = o), n.join("").toString();
+}, xt = (r) => (e) => e.replace(Ct(r), ""), St = (r) => (e) => {
+  const t = e.indexOf(r.hole), n = e.charAt(t - 1), o = e.charAt(t + 1), a = /[^\w]|_/;
+  return o ? n && a.test(n) && a.test(o) ? r.punctuation : r.char : r.punctuation;
+}, Lt = (r, e, t) => {
+  let n = e, o = !1;
+  return r.descendants((a) => {
+    var s;
+    if (o)
       return !1;
-    if (o.isText) {
-      const s = (l = o.text) == null ? void 0 : l.indexOf(t);
-      if (s != null && s >= 0)
-        return n = !0, r += s, !1;
-    }
-    r += o.nodeSize;
-  }), r;
-}, Bt = {
+    if (a.isText) {
+      const l = (s = a.text) == null ? void 0 : s.indexOf(t);
+      if (l != null && l >= 0)
+        return o = !0, n += l, !1;
+    }
+    n += a.nodeSize;
+  }), n;
+}, Tt = {
   placeholderConfig: {
-    hole: "\u2205",
-    punctuation: "\u2042",
-    char: "\u2234"
+    hole: "∅",
+    punctuation: "⁂",
+    char: "∴"
   },
   globalNodes: ["footnote_definition"],
-  shouldSyncNode: ({ prevNode: a, nextNode: e }) => a.inlineContent && e && a.type === e.type && !a.eq(e),
-  movePlaceholder: (a, e) => {
+  shouldSyncNode: ({ prevNode: r, nextNode: e }) => r.inlineContent && e && r.type === e.type && !r.eq(e),
+  movePlaceholder: (r, e) => {
     const t = ["*", "_"];
-    let r = e.indexOf(a);
-    for (; t.includes(e[r - 1] || "") && t.includes(e[r + 1] || ""); )
-      e = Et(e, r, r + 1), r = r + 1;
+    let n = e.indexOf(r);
+    for (; t.includes(e[n - 1] || "") && t.includes(e[n + 1] || ""); )
+      e = vt(e, n, n + 1), n = n + 1;
     return e;
   }
-}, E = Ee(Bt, "inlineSyncConfig"), Rt = (a) => {
-  const { selection: e } = a, { $from: t } = e;
+}, O = P(Tt, "inlineSyncConfig"), Dt = (r) => {
+  const { selection: e } = r, { $from: t } = e;
   return t.node();
-}, Wt = (a, e, t, r) => {
-  const n = a.get(_e), o = e.schema.topNodeType.create(void 0, [t, ...r]);
-  return n(o);
-}, qt = (a, e) => {
-  const t = a.get(E), r = t.placeholderConfig.hole, [n = "", ...o] = e.split(`
+}, Ot = (r, e, t, n) => {
+  const o = r.get(Re), a = e.schema.topNodeType.create(void 0, [t, ...n]);
+  return o(a);
+}, _t = (r, e) => {
+  const t = r.get(O.key), n = t.placeholderConfig.hole, [o = "", ...a] = e.split(`
 
-`), l = (u) => t.movePlaceholder(r, u);
-  let c = Se(_t(r), l, At)(n);
-  const i = $t(t.placeholderConfig)(c);
-  return c = c.replace(r, i), c = [c, ...o].join(`
+`), s = (d) => t.movePlaceholder(n, d);
+  let c = Be(xt(n), s, At)(o);
+  const i = St(t.placeholderConfig)(c);
+  return c = c.replace(n, i), c = [c, ...a].join(`
 
 `), [c, i];
-}, Kt = (a, e) => {
-  const r = a.get($e)(e);
-  return r ? r.firstChild : null;
-}, Ft = (a, e) => {
-  const { globalNodes: t } = a.get(E), r = [];
-  return e.doc.descendants((n) => {
-    if (t.includes(n.type.name) || t.includes(n.type))
-      return r.push(n), !1;
-  }), r;
-}, jt = (a) => a.split(`
+}, Ht = (r, e) => {
+  const n = r.get(Pe)(e);
+  return n ? n.firstChild : null;
+}, Kt = (r, e) => {
+  const { globalNodes: t } = r.get(O.key), n = [];
+  return e.doc.descendants((o) => {
+    if (t.includes(o.type.name) || t.includes(o.type))
+      return n.push(o), !1;
+  }), n;
+}, $t = (r) => r.split(`
 
-`)[0] || "", Oe = (a, e) => {
+`)[0] || "", He = (r, e) => {
   try {
-    const t = Ft(a, e), r = Rt(e), n = Wt(a, e, r, t), [o, l] = qt(a, n), s = Kt(a, o);
-    return !s || r.type !== s.type ? null : (s.attrs = { ...r.attrs }, s.descendants((c) => {
-      var f;
-      const u = c.marks.find((d) => d.type.name === "link");
-      u && ((f = c.text) == null ? void 0 : f.includes(l)) && u.attrs.href.includes(l) && (u.attrs.href = u.attrs.href.replace(l, ""));
+    const t = Kt(r, e), n = Dt(e), o = Ot(r, e, n, t), [a, s] = _t(r, o), l = Ht(r, a);
+    return !l || n.type !== l.type ? null : (l.attrs = { ...n.attrs }, l.descendants((c) => {
+      var p;
+      const d = c.marks.find((g) => g.type.name === "link");
+      d && ((p = c.text) == null ? void 0 : p.includes(s)) && d.attrs.href.includes(s) && (d.attrs.href = d.attrs.href.replace(s, ""));
     }), {
-      text: jt(o),
-      prevNode: r,
-      nextNode: s,
-      placeholder: l
+      text: $t(a),
+      prevNode: n,
+      nextNode: l,
+      placeholder: s
     });
   } catch {
     return null;
   }
-}, zt = (a, e, t, r, n) => {
-  const { placeholderConfig: o } = a.get(E), l = o.hole;
-  let s = t.tr.setMeta(e, !0).insertText(l, t.selection.from);
-  const c = t.apply(s), i = Oe(a, c);
+}, Et = (r, e, t, n, o) => {
+  const { placeholderConfig: a } = r.get(O.key), s = a.hole;
+  let l = t.tr.setMeta(e, !0).insertText(s, t.selection.from);
+  const c = t.apply(l), i = He(r, c);
   if (!i)
     return;
-  const { $from: u } = c.selection, f = u.before(), d = u.after(), m = Pt(i.nextNode, f, i.placeholder);
-  s = s.replaceWith(f, d, i.nextNode).setNodeMarkup(f, void 0, n).delete(m + 1, m + 2), s = s.setSelection(Q.near(s.doc.resolve(m + 1))), r(s);
-}, J = new H("MILKDOWN_INLINE_SYNC"), Ut = (a) => {
+  const { $from: d } = c.selection, p = d.before(), g = d.after(), h = Lt(i.nextNode, p, i.placeholder);
+  l = l.replaceWith(p, g, i.nextNode).setNodeMarkup(p, void 0, o).delete(h + 1, h + 2), l = l.setSelection(re.near(l.doc.resolve(h + 1))), n(l);
+}, Bt = w((r) => {
   let e = null;
-  return new T({
-    key: J,
+  const t = new N("MILKDOWN_INLINE_SYNC");
+  return new C({
+    key: t,
     state: {
       init: () => null,
-      apply: (r, n, o, l) => {
-        var p;
-        const s = a.get(v);
-        if (!((p = s.hasFocus) != null && p.call(s)) || !s.editable || !r.docChanged || r.getMeta(J))
+      apply: (n, o, a, s) => {
+        var _;
+        const l = r.get(R);
+        if (!((_ = l.hasFocus) != null && _.call(l)) || !l.editable || !n.docChanged || n.getMeta(t))
           return null;
-        const i = Oe(a, l);
+        const i = He(r, s);
         if (!i)
           return null;
         e && (cancelAnimationFrame(e), e = null);
-        const { prevNode: u, nextNode: f, text: d } = i, { shouldSyncNode: m } = a.get(E);
-        return m({ prevNode: u, nextNode: f, ctx: a, tr: r, text: d }) && (e = requestAnimationFrame(() => {
+        const { prevNode: d, nextNode: p, text: g } = i, { shouldSyncNode: h } = r.get(O.key);
+        return h({ prevNode: d, nextNode: p, ctx: r, tr: n, text: g }) && (e = requestAnimationFrame(() => {
           e = null;
-          const { dispatch: g, state: h } = a.get(v);
-          zt(a, J, h, g, u.attrs);
+          const { dispatch: $e, state: Ee } = r.get(R);
+          Et(r, t, Ee, $e, d.attrs);
         })), null;
       }
     }
   });
-}, Vt = [
-  ve(() => ({
-    injectSlices: [E],
-    prosePlugins: (a, e) => [St(), Ut(e)],
-    remarkPlugins: () => [Ve, Dt, Ct]
-  }))()
-], Gt = we.create([...Lt, ...et]), cr = we.create([...Vt, ...Gt]), ir = {
-  ToggleInlineCode: ee,
-  ToggleItalic: te,
-  ToggleLink: Te,
-  ToggleBold: ne,
-  ModifyLink: re,
-  ModifyImage: ce,
-  WrapInBlockquote: se,
-  WrapInBulletList: oe,
-  WrapInOrderedList: fe,
-  TurnIntoCodeFence: ae,
-  TurnIntoHeading: O,
-  TurnIntoText: me,
-  InsertHardbreak: le,
-  InsertHr: He,
-  InsertImage: De,
-  SplitListItem: ie,
-  SinkListItem: ue,
-  LiftListItem: de
-};
+}), Rt = W(() => () => (r) => {
+  oe(r, "list", (e) => {
+    if (e.ordered) {
+      const t = e.start ?? 1;
+      e.children.forEach((n, o) => {
+        n.label = o + t;
+      });
+    }
+  });
+}), Pt = W(() => () => (r) => {
+  const e = /[\t ]*(?:\r?\n|\r)/g;
+  oe(r, "text", (t, n, o) => {
+    if (!t.value || typeof t.value != "string")
+      return;
+    const a = [];
+    let s = 0;
+    e.lastIndex = 0;
+    let l = e.exec(t.value);
+    for (; l; ) {
+      const i = l.index;
+      s !== i && a.push({ type: "text", value: t.value.slice(s, i) }), a.push({ type: "break", data: { isInline: !0 } }), s = i + l[0].length, l = e.exec(t.value);
+    }
+    if (!!(a.length > 0 && o && typeof n == "number"))
+      return s < t.value.length && a.push({ type: "text", value: t.value.slice(s) }), o.children.splice(n, 1, ...a), n + a.length;
+  });
+}), Wt = W(() => je), qt = w(() => {
+  let r = !1;
+  const e = new N("MILKDOWN_INLINE_NODES_CURSOR"), t = new C({
+    key: e,
+    state: {
+      init() {
+        return !1;
+      },
+      apply(n) {
+        if (!n.selection.empty)
+          return !1;
+        const o = n.selection.$from, a = o.nodeBefore, s = o.nodeAfter;
+        return !!(a && s && a.isInline && !a.isText && s.isInline && !s.isText);
+      }
+    },
+    props: {
+      handleDOMEvents: {
+        compositionend: (n, o) => r ? (r = !1, requestAnimationFrame(() => {
+          if (t.getState(n.state)) {
+            const s = n.state.selection.from;
+            o.preventDefault(), n.dispatch(n.state.tr.insertText(o.data || "", s));
+          }
+        }), !0) : !1,
+        compositionstart: (n) => (t.getState(n.state) && (r = !0), !1),
+        beforeinput: (n, o) => {
+          if (t.getState(n.state) && o instanceof InputEvent && o.data && !r) {
+            const s = n.state.selection.from;
+            return o.preventDefault(), n.dispatch(n.state.tr.insertText(o.data || "", s)), !0;
+          }
+          return !1;
+        }
+      },
+      decorations(n) {
+        if (t.getState(n)) {
+          const s = n.selection.$from.pos, l = document.createElement("span"), c = J.widget(s, l, {
+            side: -1
+          }), i = document.createElement("span"), d = J.widget(s, i);
+          return setTimeout(() => {
+            l.contentEditable = "true", i.contentEditable = "true";
+          }), Q.create(n.doc, [c, d]);
+        }
+        return Q.empty;
+      }
+    }
+  });
+  return t;
+}), Ft = w(() => new C({
+  key: new N("MILKDOWN_HARDBREAK_MARKS"),
+  appendTransaction: (r, e, t) => {
+    if (!r.length)
+      return;
+    const [n] = r;
+    if (!n)
+      return;
+    const [o] = n.steps;
+    if (n.getMeta("hardbreak")) {
+      if (!(o instanceof Ge))
+        return;
+      const { from: l } = o;
+      return t.tr.setNodeMarkup(l, x.type(), void 0, []);
+    }
+    if (o instanceof ze) {
+      let l = t.tr;
+      const { from: c, to: i } = o;
+      return t.doc.nodesBetween(c, i, (d, p) => {
+        d.type === x.type() && (l = l.setNodeMarkup(p, x.type(), void 0, []));
+      }), l;
+    }
+  }
+})), Ke = P(["table", "code_block"], "hardbreakFilterNodes"), Vt = w((r) => {
+  const e = r.get(Ke.key);
+  return new C({
+    key: new N("MILKDOWN_HARDBREAK_FILTER"),
+    filterTransaction: (t, n) => {
+      const o = t.getMeta("hardbreak"), [a] = t.steps;
+      if (o && a) {
+        const { from: s } = a, l = n.doc.resolve(s);
+        let c = l.depth, i = !0;
+        for (; c > 0; )
+          e.includes(l.node(c).type.name) && (i = !1), c--;
+        return i;
+      }
+      return !0;
+    }
+  });
+}), Gt = w((r) => {
+  const e = new N("MILKDOWN_HEADING_ID"), t = (n) => {
+    if (n.composing || !n.editable)
+      return;
+    const o = r.get(G.key), a = n.state.tr.setMeta("addToHistory", !1);
+    let s = !1;
+    n.state.doc.descendants((l, c) => {
+      if (l.type === T.type()) {
+        if (l.textContent.trim().length === 0)
+          return;
+        const i = l.attrs, d = o(l);
+        i.id !== d && (s = !0, a.setMeta(e, !0).setNodeMarkup(c, void 0, {
+          ...i,
+          id: d
+        }));
+      }
+    }), s && n.dispatch(a);
+  };
+  return new C({
+    key: e,
+    view: (n) => (t(n), {
+      update: (o) => {
+        t(o);
+      }
+    })
+  });
+}), zt = w(() => {
+  const r = (e, t) => {
+    const n = E.type(), o = D.type();
+    let a = e.tr;
+    e.doc.descendants((s, l, c, i) => {
+      if (s.type === o && (c == null ? void 0 : c.type) === n) {
+        let d = !1;
+        const p = { ...s.attrs };
+        s.attrs.listType !== "ordered" && (p.listType = "ordered", d = !0);
+        const g = c == null ? void 0 : c.maybeChild(0);
+        g === s ? (p.label = "1.", d = !0) : (g == null ? void 0 : g.type) === o && g.attrs.listType === "ordered" ? (p.label = `${i + 1}.`, d = !0) : s.attrs.label === "•" && (p.label = `${i + 1}.`, d = !0), d && (a = a.setNodeMarkup(l, void 0, p));
+      }
+    }), t(a);
+  };
+  return new C({
+    key: new N("MILKDOWN_KEEP_LIST_ORDER"),
+    appendTransaction: (e, t, n) => {
+      let o = null;
+      return e.some((a) => a.docChanged) && r(n, (a) => {
+        o = a;
+      }), o;
+    }
+  });
+}), jt = [
+  O,
+  Bt,
+  Ft,
+  Ke,
+  Vt,
+  qt,
+  Rt,
+  Wt,
+  Pt,
+  Gt,
+  zt
+], ir = [It, bt, wt, Nt, jt].flat();
 export {
-  ye as DowngradeHeading,
-  ct as HardbreakFilterPluginKey,
-  le as InsertHardbreak,
-  He as InsertHr,
-  De as InsertImage,
-  de as LiftListItem,
-  ce as ModifyImage,
-  re as ModifyLink,
-  ue as SinkListItem,
-  ie as SplitListItem,
-  y as SupportedKeys,
-  ne as ToggleBold,
-  ee as ToggleInlineCode,
-  te as ToggleItalic,
-  Te as ToggleLink,
-  ae as TurnIntoCodeFence,
-  O as TurnIntoHeading,
-  me as TurnIntoText,
-  se as WrapInBlockquote,
-  oe as WrapInBulletList,
-  fe as WrapInOrderedList,
-  st as backtickInputRegex,
-  tt as blockquote,
-  rt as bulletList,
-  at as codeFence,
-  Ye as codeInline,
-  ir as commands,
-  cr as commonmark,
-  Gt as commonmarkNodes,
-  Vt as commonmarkPlugins,
-  lt as doc,
-  Je as em,
-  it as hardbreak,
-  pt as heading,
-  ut as headingHashPluginKey,
-  V as headingIdPluginKey,
-  gt as hr,
-  kt as image,
-  E as inlineSyncConfigCtx,
-  Xe as link,
-  Nt as listItem,
-  et as marks,
-  Lt as nodes,
-  It as orderedList,
-  bt as paragraph,
-  Ze as strong,
-  wt as text,
-  ot as tildeInputRegex
+  ye as blockquoteAttr,
+  st as blockquoteKeymap,
+  z as blockquoteSchema,
+  ve as bulletListAttr,
+  ft as bulletListKeymap,
+  Y as bulletListSchema,
+  Ie as codeBlockAttr,
+  ct as codeBlockKeymap,
+  j as codeBlockSchema,
+  wt as commands,
+  ir as commonmark,
+  be as createCodeBlockCommand,
+  lt as createCodeBlockInputRule,
+  Tt as defaultConfig,
+  Ze as docSchema,
+  ke as downgradeHeadingCommand,
+  ae as emphasisAttr,
+  Ue as emphasisKeymap,
+  se as emphasisSchema,
+  Ne as hardbreakAttr,
+  Ft as hardbreakClearMarkPlugin,
+  Ke as hardbreakFilterNodes,
+  Vt as hardbreakFilterPlugin,
+  ut as hardbreakKeymap,
+  x as hardbreakSchema,
+  he as headingAttr,
+  G as headingIdGenerator,
+  ot as headingKeymap,
+  T as headingSchema,
+  Ae as hrAttr,
+  U as hrSchema,
+  we as imageAttr,
+  $ as imageSchema,
+  ue as inlineCodeAttr,
+  Je as inlineCodeKeymap,
+  A as inlineCodeSchema,
+  qt as inlineNodesCursorPlugin,
+  O as inlineSyncConfig,
+  Bt as inlineSyncPlugin,
+  bt as inputrules,
+  Ce as insertHardbreakCommand,
+  mt as insertHrCommand,
+  pt as insertHrInputRule,
+  it as insertImageCommand,
+  cr as insertImageInputRule,
+  Nt as keymap,
+  _e as liftListItemCommand,
+  me as linkAttr,
+  v as linkSchema,
+  Te as listItemAttr,
+  yt as listItemKeymap,
+  D as listItemSchema,
+  Se as orderedListAttr,
+  kt as orderedListKeymap,
+  E as orderedListSchema,
+  ge as paragraphAttr,
+  et as paragraphKeymap,
+  L as paragraphSchema,
+  jt as plugins,
+  Rt as remarkAddOrderInListPlugin,
+  Wt as remarkInlineLinkPlugin,
+  Pt as remarkLineBreak,
+  It as schema,
+  De as sinkListItemCommand,
+  Oe as splitListItemCommand,
+  ce as strongAttr,
+  Ye as strongKeymap,
+  ie as strongSchema,
+  Gt as syncHeadingIdPlugin,
+  zt as syncListOrderPlugin,
+  Mt as textSchema,
+  le as toggleEmphasisCommand,
+  pe as toggleInlineCodeCommand,
+  Qe as toggleLinkCommand,
+  de as toggleStrongCommand,
+  fe as turnIntoTextCommand,
+  lr as updateCodeBlockLanguageCommand,
+  dt as updateImageCommand,
+  Xe as updateLinkCommand,
+  Me as wrapInBlockquoteCommand,
+  at as wrapInBlockquoteInputRule,
+  xe as wrapInBulletListCommand,
+  gt as wrapInBulletListInputRule,
+  M as wrapInHeadingCommand,
+  nt as wrapInHeadingInputRule,
+  Le as wrapInOrderedListCommand,
+  ht as wrapInOrderedListInputRule
 };
 //# sourceMappingURL=index.es.js.map