@milkdown/preset-commonmark 7.1.0 → 7.1.1

package/lib/index.es.js

@@ -1,107 +1,108 @@
-import { $markAttr as K, $markSchema as E, $command as p, $useKeymap as k, $node as te, $nodeAttr as y, $nodeSchema as M, $ctx as F, $inputRule as b, pipe as We, $prose as N, $remark as $ } from "@milkdown/utils";
+import { $markAttr as K, $markSchema as B, $command as p, $useKeymap as k, $node as te, $nodeAttr as y, $nodeSchema as M, $ctx as F, $inputRule as b, pipe as We, $prose as v, $remark as $ } from "@milkdown/utils";
 import { commandsCtx as g, editorViewCtx as q, serializerCtx as qe, parserCtx as Fe } from "@milkdown/core";
-import { toggleMark as V, setBlockType as S, wrapIn as G } from "@milkdown/prose/commands";
-import { Fragment as re } from "@milkdown/prose/model";
-import { expectDomTypeError as w } from "@milkdown/exception";
-import { textblockTypeInputRule as ne, wrappingInputRule as j, InputRule as oe } from "@milkdown/prose/inputrules";
-import { TextSelection as ae, Selection as se, PluginKey as v, Plugin as C } from "@milkdown/prose/state";
-import { findSelectedNodeOfType as Ve } from "@milkdown/prose";
-import { sinkListItem as Ge, liftListItem as je, splitListItem as ze } from "@milkdown/prose/schema-list";
-import { ReplaceStep as Ue, AddMarkStep as Ye } from "@milkdown/prose/transform";
+import { toggleMark as V, setBlockType as T, wrapIn as z } from "@milkdown/prose/commands";
+import { Fragment as Ve } from "@milkdown/prose/model";
+import { TextSelection as re, Selection as ne, PluginKey as C, Plugin as x } from "@milkdown/prose/state";
+import { expectDomTypeError as N } from "@milkdown/exception";
+import { textblockTypeInputRule as oe, wrappingInputRule as G, InputRule as ae } from "@milkdown/prose/inputrules";
+import ze from "@sindresorhus/slugify";
+import { findSelectedNodeOfType as Ge } from "@milkdown/prose";
+import { sinkListItem as je, liftListItem as Ue, splitListItem as Ye } from "@milkdown/prose/schema-list";
+import { ReplaceStep as Je, AddMarkStep as Qe } from "@milkdown/prose/transform";
 import { Decoration as Z, DecorationSet as ee } from "@milkdown/prose/view";
-import { visit as le } from "unist-util-visit";
-import Je from "remark-inline-links";
-const ce = K("emphasis"), ie = E("emphasis", (r) => ({
+import { visit as se } from "unist-util-visit";
+import Xe from "remark-inline-links";
+const le = K("emphasis"), ce = B("emphasis", (t) => ({
   inclusive: !1,
   parseDOM: [
     { tag: "i" },
     { tag: "em" },
     { style: "font-style", getAttrs: (e) => e === "italic" }
   ],
-  toDOM: (e) => ["em", r.get(ce.key)(e)],
+  toDOM: (e) => ["em", t.get(le.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "emphasis",
-    runner: (e, t, n) => {
-      e.openMark(n), e.next(t.children), e.closeMark(n);
+    runner: (e, r, n) => {
+      e.openMark(n), e.next(r.children), e.closeMark(n);
     }
   },
   toMarkdown: {
     match: (e) => e.type.name === "emphasis",
-    runner: (e, t) => {
-      e.withMark(t, "emphasis");
+    runner: (e, r) => {
+      e.withMark(r, "emphasis");
     }
   }
-})), ue = p("ToggleEmphasis", () => () => V(ie.type())), Qe = k("emphasisKeymap", {
+})), ie = p("ToggleEmphasis", () => () => V(ce.type())), Ze = k("emphasisKeymap", {
   ToggleEmphasis: {
     shortcuts: "Mod-i",
-    command: (r) => {
-      const e = r.get(g);
-      return () => e.call(ue.key);
+    command: (t) => {
+      const e = t.get(g);
+      return () => e.call(ie.key);
     }
   }
-}), de = K("strong"), me = E("strong", (r) => ({
+}), de = K("strong"), ue = B("strong", (t) => ({
   inclusive: !1,
   parseDOM: [
     { tag: "b" },
     { tag: "strong" },
     { style: "font-style", getAttrs: (e) => e === "bold" }
   ],
-  toDOM: (e) => ["strong", r.get(de.key)(e)],
+  toDOM: (e) => ["strong", t.get(de.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "strong",
-    runner: (e, t, n) => {
-      e.openMark(n), e.next(t.children), e.closeMark(n);
+    runner: (e, r, n) => {
+      e.openMark(n), e.next(r.children), e.closeMark(n);
     }
   },
   toMarkdown: {
     match: (e) => e.type.name === "strong",
-    runner: (e, t) => {
-      e.withMark(t, "strong");
+    runner: (e, r) => {
+      e.withMark(r, "strong");
     }
   }
-})), pe = p("ToggleStrong", () => () => V(me.type())), Xe = k("strongKeymap", {
+})), me = p("ToggleStrong", () => () => V(ue.type())), et = k("strongKeymap", {
   ToggleBold: {
     shortcuts: ["Mod-b"],
-    command: (r) => {
-      const e = r.get(g);
-      return () => e.call(pe.key);
+    command: (t) => {
+      const e = t.get(g);
+      return () => e.call(me.key);
     }
   }
-}), ge = K("inlineCode"), x = E("inlineCode", (r) => ({
+}), pe = K("inlineCode"), A = B("inlineCode", (t) => ({
   priority: 100,
   code: !0,
   inclusive: !1,
   parseDOM: [{ tag: "code" }],
-  toDOM: (e) => ["code", r.get(ge.key)(e)],
+  toDOM: (e) => ["code", t.get(pe.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "inlineCode",
-    runner: (e, t, n) => {
-      e.openMark(n), e.addText(t.value), e.closeMark(n);
+    runner: (e, r, n) => {
+      e.openMark(n), e.addText(r.value), e.closeMark(n);
     }
   },
   toMarkdown: {
     match: (e) => e.type.name === "inlineCode",
-    runner: (e, t, n) => {
-      e.withMark(t, "inlineCode", n.text || "");
+    runner: (e, r, n) => {
+      e.withMark(r, "inlineCode", n.text || "");
     }
   }
-})), fe = p("ToggleInlineCode", () => () => (r, e) => {
-  const { selection: t, tr: n } = r;
-  if (t.empty)
+})), ge = p("ToggleInlineCode", () => () => (t, e) => {
+  const { selection: r, tr: n } = t;
+  if (r.empty)
     return !1;
-  const { from: o, to: a } = t;
-  return r.doc.rangeHasMark(o, a, x.type()) ? (e == null || e(n.removeMark(o, a, x.type())), !0) : (Object.keys(r.schema.marks).filter((c) => c !== x.type.name).map((c) => r.schema.marks[c]).forEach((c) => {
+  const { from: o, to: a } = r;
+  return t.doc.rangeHasMark(o, a, A.type()) ? (e == null || e(n.removeMark(o, a, A.type())), !0) : (Object.keys(t.schema.marks).filter((c) => c !== A.type.name).map((c) => t.schema.marks[c]).forEach((c) => {
     n.removeMark(o, a, c);
-  }), e == null || e(n.addMark(o, a, x.type().create())), !0);
-}), Ze = k("inlineCodeKeymap", {
+  }), e == null || e(n.addMark(o, a, A.type().create())), !0);
+}), tt = k("inlineCodeKeymap", {
   ToggleInlineCode: {
     shortcuts: "Mod-e",
-    command: (r) => {
-      const e = r.get(g);
-      return () => e.call(fe.key);
+    command: (t) => {
+      const e = t.get(g);
+      return () => e.call(ge.key);
     }
   }
-}), he = K("link"), A = E("link", (r) => ({
+}), fe = K("link"), L = B("link", (t) => ({
   attrs: {
     href: {},
     title: { default: null }
@@ -111,94 +112,96 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       tag: "a[href]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw w(e);
+          throw N(e);
         return { href: e.getAttribute("href"), title: e.getAttribute("title") };
       }
     }
   ],
-  toDOM: (e) => ["a", { ...r.get(he.key)(e), ...e.attrs }],
+  toDOM: (e) => ["a", { ...t.get(fe.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);
+    runner: (e, r, n) => {
+      const o = r.url, a = r.title;
+      e.openMark(n, { href: o, title: a }), e.next(r.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
+    runner: (e, r) => {
+      e.withMark(r, "link", void 0, {
+        title: r.attrs.title,
+        url: r.attrs.href
       });
     }
   }
-})), et = p("ToggleLink", () => (r = {}) => V(A.type(), r)), tt = p("UpdateLink", () => (r = {}) => (e, t) => {
-  if (!t)
+})), rt = p("ToggleLink", () => (t = {}) => V(L.type(), t)), nt = p("UpdateLink", () => (t = {}) => (e, r) => {
+  if (!r)
     return !1;
   let n, o = -1;
   const { selection: a } = e, { from: l, to: s } = a;
   if (e.doc.nodesBetween(l, l === s ? s + 1 : s, (m, h) => {
-    if (A.type().isInSet(m.marks))
+    if (L.type().isInSet(m.marks))
       return n = m, o = h, !1;
   }), !n)
     return !1;
-  const c = n.marks.find(({ type: m }) => m === A.type());
+  const c = n.marks.find(({ type: m }) => m === L.type());
   if (!c)
     return !1;
-  const i = o, u = o + n.nodeSize, { tr: d } = e, f = A.type().create({ ...c.attrs, ...r });
-  return f ? (t(
-    d.removeMark(i, u, c).addMark(i, u, f).setSelection(new ae(d.selection.$anchor)).scrollIntoView()
+  const i = o, d = o + n.nodeSize, { tr: u } = e, f = L.type().create({ ...c.attrs, ...t });
+  return f ? (r(
+    u.removeMark(i, d, c).addMark(i, d, f).setSelection(new re(u.selection.$anchor)).scrollIntoView()
   ), !0) : !1;
-}), rt = te("doc", () => ({
+}), ot = te("doc", () => ({
   content: "block+",
   parseMarkdown: {
-    match: ({ type: r }) => r === "root",
-    runner: (r, e, t) => {
-      r.injectRoot(e, t);
+    match: ({ type: t }) => t === "root",
+    runner: (t, e, r) => {
+      t.injectRoot(e, r);
     }
   },
   toMarkdown: {
-    match: (r) => r.type.name === "doc",
-    runner: (r, e) => {
-      r.openNode("root"), r.next(e.content);
+    match: (t) => t.type.name === "doc",
+    runner: (t, e) => {
+      t.openNode("root"), t.next(e.content);
     }
   }
-})), ke = y("paragraph"), T = M("paragraph", (r) => ({
+})), he = (t, e) => {
+  var o;
+  if (!(e.childCount >= 1 && ((o = e.lastChild) == null ? void 0 : o.type) === w.type())) {
+    t.next(e.content);
+    return;
+  }
+  const n = [];
+  e.content.forEach((a, l, s) => {
+    s !== e.childCount - 1 && n.push(a);
+  }), t.next(Ve.fromArray(n));
+}, ke = y("paragraph"), S = M("paragraph", (t) => ({
   content: "inline*",
   group: "block",
   parseDOM: [{ tag: "p" }],
-  toDOM: (e) => ["p", r.get(ke.key)(e), 0],
+  toDOM: (e) => ["p", t.get(ke.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();
+    runner: (e, r, n) => {
+      e.openNode(n), r.children ? e.next(r.children) : e.addText(r.value || ""), e.closeNode();
     }
   },
   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((l, s, c) => {
-          c !== t.childCount - 1 && a.push(l);
-        }), e.next(re.fromArray(a));
-      } else
-        e.next(t.content);
-      e.closeNode();
+    runner: (e, r) => {
+      e.openNode("paragraph"), he(e, r), e.closeNode();
     }
   }
-})), ye = p("TurnIntoText", () => () => S(T.type())), nt = k("paragraphKeymap", {
+})), ye = p("TurnIntoText", () => () => T(S.type())), at = k("paragraphKeymap", {
   TurnIntoText: {
     shortcuts: "Mod-Alt-0",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(ye.key);
     }
   }
-}), ot = Array(6).fill(0).map((r, e) => e + 1), at = (r) => r.textContent.replace(/[\p{P}\p{S}]/gu, "").replace(/\s/g, "-").toLowerCase().trim(), z = F(at, "headingIdGenerator"), Me = y("heading"), D = M("heading", (r) => {
-  const e = r.get(z.key);
+}), st = Array(6).fill(0).map((t, e) => e + 1), lt = (t) => ze(t.textContent), j = F(lt, "headingIdGenerator"), Me = y("heading"), D = M("heading", (t) => {
+  const e = t.get(j.key);
   return {
     content: "inline*",
     group: "block",
@@ -211,143 +214,135 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
         default: 1
       }
     },
-    parseDOM: ot.map((t) => ({
-      tag: `h${t}`,
+    parseDOM: st.map((r) => ({
+      tag: `h${r}`,
       getAttrs: (n) => {
         if (!(n instanceof HTMLElement))
-          throw w(n);
-        return { level: t, id: n.id };
+          throw N(n);
+        return { level: r, id: n.id };
       }
     })),
-    toDOM: (t) => [
-      `h${t.attrs.level}`,
+    toDOM: (r) => [
+      `h${r.attrs.level}`,
       {
-        ...r.get(Me.key)(t),
-        id: t.attrs.id || e(t)
+        ...t.get(Me.key)(r),
+        id: r.attrs.id || e(r)
       },
       0
     ],
     parseMarkdown: {
-      match: ({ type: t }) => t === "heading",
-      runner: (t, n, o) => {
+      match: ({ type: r }) => r === "heading",
+      runner: (r, n, o) => {
         const a = n.depth;
-        t.openNode(o, { level: a }), t.next(n.children), t.closeNode();
+        r.openNode(o, { level: a }), r.next(n.children), r.closeNode();
       }
     },
     toMarkdown: {
-      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 l = [];
-          n.content.forEach((s, c, i) => {
-            i !== n.childCount - 1 && l.push(s);
-          }), t.next(re.fromArray(l));
-        } else
-          t.next(n.content);
-        t.closeNode();
+      match: (r) => r.type.name === "heading",
+      runner: (r, n) => {
+        r.openNode("heading", void 0, { depth: n.attrs.level }), he(r, n), r.closeNode();
       }
     }
   };
-}), st = b((r) => ne(/^(?<hashes>#+)\s$/, D.type(), (e) => {
+}), ct = b((t) => oe(/^(?<hashes>#+)\s$/, D.type(), (e) => {
   var l, s;
-  const t = ((s = (l = e.groups) == null ? void 0 : l.hashes) == null ? void 0 : s.length) || 0, n = r.get(q), { $from: o } = n.state.selection, a = o.node();
+  const r = ((s = (l = e.groups) == null ? void 0 : l.hashes) == null ? void 0 : s.length) || 0, n = t.get(q), { $from: o } = n.state.selection, a = o.node();
   if (a.type.name === "heading") {
-    let c = Number(a.attrs.level) + Number(t);
+    let c = Number(a.attrs.level) + Number(r);
     return c > 6 && (c = 6), { level: c };
   }
-  return { level: t };
-})), I = p("WrapInHeading", () => (r) => (r ?? (r = 1), r < 1 ? S(T.type()) : S(D.type(), { level: r }))), Ie = p("DowngradeHeading", () => () => (r, e, t) => {
-  const { $from: n } = r.selection, o = n.node();
-  if (o.type !== D.type() || !r.selection.empty || n.parentOffset !== 0)
+  return { level: r };
+})), I = p("WrapInHeading", () => (t) => (t ?? (t = 1), t < 1 ? T(S.type()) : T(D.type(), { level: t }))), Ie = p("DowngradeHeading", () => () => (t, e, r) => {
+  const { $from: n } = t.selection, o = n.node();
+  if (o.type !== D.type() || !t.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, {
+    t.tr.setNodeMarkup(t.selection.$from.before(), void 0, {
       ...o.attrs,
       level: a
     })
-  ), !0) : S(T.type())(r, e, t);
-}), lt = k("headingKeymap", {
+  ), !0) : T(S.type())(t, e, r);
+}), it = k("headingKeymap", {
   TurnIntoH1: {
     shortcuts: "Mod-Alt-1",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(I.key, 1);
     }
   },
   TurnIntoH2: {
     shortcuts: "Mod-Alt-2",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(I.key, 2);
     }
   },
   TurnIntoH3: {
     shortcuts: "Mod-Alt-3",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(I.key, 3);
     }
   },
   TurnIntoH4: {
     shortcuts: "Mod-Alt-4",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(I.key, 3);
     }
   },
   TurnIntoH5: {
     shortcuts: "Mod-Alt-5",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(I.key, 3);
     }
   },
   TurnIntoH6: {
     shortcuts: "Mod-Alt-6",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(I.key, 3);
     }
   },
   DowngradeHeading: {
     shortcuts: ["Delete", "Backspace"],
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(Ie.key);
     }
   }
-}), be = y("blockquote"), U = M("blockquote", (r) => ({
+}), be = y("blockquote"), U = M("blockquote", (t) => ({
   content: "block+",
   group: "block",
   defining: !0,
   parseDOM: [{ tag: "blockquote" }],
-  toDOM: (e) => ["blockquote", r.get(be.key)(e), 0],
+  toDOM: (e) => ["blockquote", t.get(be.key)(e), 0],
   parseMarkdown: {
     match: ({ type: e }) => e === "blockquote",
-    runner: (e, t, n) => {
-      e.openNode(n).next(t.children).closeNode();
+    runner: (e, r, n) => {
+      e.openNode(n).next(r.children).closeNode();
     }
   },
   toMarkdown: {
     match: (e) => e.type.name === "blockquote",
-    runner: (e, t) => {
-      e.openNode("blockquote").next(t.content).closeNode();
+    runner: (e, r) => {
+      e.openNode("blockquote").next(r.content).closeNode();
     }
   }
-})), ct = b(() => j(/^\s*>\s$/, U.type())), we = p("WrapInBlockquote", () => () => G(U.type())), it = k("blockquoteKeymap", {
+})), dt = b(() => G(/^\s*>\s$/, U.type())), Ne = p("WrapInBlockquote", () => () => z(U.type())), ut = k("blockquoteKeymap", {
   WrapInBlockquote: {
     shortcuts: "Mod-Shift-b",
-    command: (r) => {
-      const e = r.get(g);
-      return () => e.call(we.key);
+    command: (t) => {
+      const e = t.get(g);
+      return () => e.call(Ne.key);
     }
   }
-}), Ne = y("codeBlock", () => ({
+}), we = y("codeBlock", () => ({
   pre: {},
   code: {}
-})), Y = M("code_block", (r) => ({
+})), Y = M("code_block", (t) => ({
   content: "text*",
   group: "block",
   marks: "",
@@ -364,52 +359,52 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       preserveWhitespace: "full",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw w(e);
+          throw N(e);
         return { language: e.dataset.language };
       }
     }
   ],
   toDOM: (e) => {
-    const t = r.get(Ne.key)(e);
+    const r = t.get(we.key)(e);
     return [
       "pre",
       {
-        ...t.pre,
+        ...r.pre,
         "data-language": e.attrs.language
       },
-      ["code", t.code, 0]
+      ["code", r.code, 0]
     ];
   },
   parseMarkdown: {
     match: ({ type: e }) => e === "code",
-    runner: (e, t, n) => {
-      const o = t.lang, a = t.value;
+    runner: (e, r, n) => {
+      const o = r.lang, a = r.value;
       e.openNode(n, { language: o }), a && e.addText(a), e.closeNode();
     }
   },
   toMarkdown: {
     match: (e) => e.type.name === "code_block",
-    runner: (e, t) => {
+    runner: (e, r) => {
       var n;
-      e.addNode("code", void 0, ((n = t.content.firstChild) == null ? void 0 : n.text) || "", {
-        lang: t.attrs.language
+      e.addNode("code", void 0, ((n = r.content.firstChild) == null ? void 0 : n.text) || "", {
+        lang: r.attrs.language
       });
     }
   }
-})), ut = b(() => ne(/^```(?<language>[a-z]*)?[\s\n]$/, Y.type(), (r) => {
+})), mt = b(() => oe(/^```(?<language>[a-z]*)?[\s\n]$/, Y.type(), (t) => {
   var e;
   return {
-    language: ((e = r.groups) == null ? void 0 : e.language) ?? ""
+    language: ((e = t.groups) == null ? void 0 : e.language) ?? ""
   };
-})), ve = p("CreateCodeBlock", () => (r = "") => S(Y.type(), { language: r })), kr = p("UpdateCodeBlockLanguage", () => ({ pos: r, language: e } = { pos: -1, language: "" }) => (t, n) => r >= 0 ? (n == null || n(t.tr.setNodeAttribute(r, "language", e)), !0) : !1), dt = k("codeBlockKeymap", {
+})), ve = p("CreateCodeBlock", () => (t = "") => T(Y.type(), { language: t })), Ir = p("UpdateCodeBlockLanguage", () => ({ pos: t, language: e } = { pos: -1, language: "" }) => (r, n) => t >= 0 ? (n == null || n(r.tr.setNodeAttribute(t, "language", e)), !0) : !1), pt = k("codeBlockKeymap", {
   CreateCodeBlock: {
     shortcuts: "Mod-Alt-c",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(ve.key);
     }
   }
-}), Ce = y("image"), B = M("image", (r) => ({
+}), Ce = y("image"), E = M("image", (t) => ({
   inline: !0,
   group: "inline",
   selectable: !0,
@@ -428,7 +423,7 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       tag: "img[src]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw w(e);
+          throw N(e);
         return {
           src: e.getAttribute("src") || "",
           alt: e.getAttribute("alt") || "",
@@ -437,11 +432,11 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       }
     }
   ],
-  toDOM: (e) => ["img", { ...r.get(Ce.key)(e), ...e.attrs }],
+  toDOM: (e) => ["img", { ...t.get(Ce.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: ({ type: e }) => e === "image",
-    runner: (e, t, n) => {
-      const o = t.url, a = t.alt, l = t.title;
+    runner: (e, r, n) => {
+      const o = r.url, a = r.alt, l = r.title;
       e.addNode(n, {
         src: o,
         alt: a,
@@ -451,34 +446,34 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   },
   toMarkdown: {
     match: (e) => e.type.name === "image",
-    runner: (e, t) => {
+    runner: (e, r) => {
       e.addNode("image", void 0, void 0, {
-        title: t.attrs.title,
-        url: t.attrs.src,
-        alt: t.attrs.alt
+        title: r.attrs.title,
+        url: r.attrs.src,
+        alt: r.attrs.alt
       });
     }
   }
-})), mt = p("InsertImage", () => (r = {}) => (e, t) => {
-  if (!t)
+})), gt = p("InsertImage", () => (t = {}) => (e, r) => {
+  if (!r)
     return !0;
-  const { src: n = "", alt: o = "", title: a = "" } = r, l = B.type().create({ src: n, alt: o, title: a });
-  return l && t(e.tr.replaceSelectionWith(l).scrollIntoView()), !0;
-}), pt = p("UpdateImage", () => (r = {}) => (e, t) => {
-  const n = Ve(e.selection, B.type());
+  const { src: n = "", alt: o = "", title: a = "" } = t, l = E.type().create({ src: n, alt: o, title: a });
+  return l && r(e.tr.replaceSelectionWith(l).scrollIntoView()), !0;
+}), ft = p("UpdateImage", () => (t = {}) => (e, r) => {
+  const n = Ge(e.selection, E.type());
   if (!n)
     return !1;
-  const { node: o, pos: a } = n, l = { ...o.attrs }, { src: s, alt: c, title: i } = r;
-  return s !== void 0 && (l.src = s), c !== void 0 && (l.alt = c), i !== void 0 && (l.title = i), t == null || t(e.tr.setNodeMarkup(a, void 0, l).scrollIntoView()), !0;
-}), yr = b(() => new oe(
+  const { node: o, pos: a } = n, l = { ...o.attrs }, { src: s, alt: c, title: i } = t;
+  return s !== void 0 && (l.src = s), c !== void 0 && (l.alt = c), i !== void 0 && (l.title = i), r == null || r(e.tr.setNodeMarkup(a, void 0, l).scrollIntoView()), !0;
+}), br = b(() => new ae(
   /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
-  (r, e, t, n) => {
+  (t, e, r, n) => {
     const [o, a, l = "", s] = e;
-    return o ? r.tr.replaceWith(t, n, B.type().create({ src: l, alt: a, title: s })) : null;
+    return o ? t.tr.replaceWith(r, n, E.type().create({ src: l, alt: a, title: s })) : null;
   }
-)), xe = y("hardbreak", (r) => ({
-  "data-is-inline": r.attrs.isInline
-})), L = M("hardbreak", (r) => ({
+)), xe = y("hardbreak", (t) => ({
+  "data-is-inline": t.attrs.isInline
+})), w = M("hardbreak", (t) => ({
   inline: !0,
   group: "inline",
   attrs: {
@@ -488,47 +483,49 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   },
   selectable: !1,
   parseDOM: [{ tag: "br" }],
-  toDOM: (e) => ["br", r.get(xe.key)(e)],
+  toDOM: (e) => ["br", t.get(xe.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "break",
-    runner: (e, t, n) => {
+    runner: (e, r, n) => {
       var o;
-      e.addNode(n, { isInline: Boolean((o = t.data) == null ? void 0 : o.isInline) });
+      e.addNode(n, { isInline: Boolean((o = r.data) == null ? void 0 : o.isInline) });
     }
   },
+  leafText: () => `
+`,
   toMarkdown: {
     match: (e) => e.type.name === "hardbreak",
-    runner: (e, t) => {
-      t.attrs.isInline ? e.addNode("text", void 0, `
+    runner: (e, r) => {
+      r.attrs.isInline ? e.addNode("text", void 0, `
 `) : e.addNode("break");
     }
   }
-})), Ae = p("InsertHardbreak", () => () => (r, e) => {
+})), Ae = p("InsertHardbreak", () => () => (t, e) => {
   var o;
-  const { selection: t, tr: n } = r;
-  if (t.empty) {
-    const a = t.$from.node();
+  const { selection: r, tr: n } = t;
+  if (r.empty) {
+    const a = r.$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(se.near(n.doc.resolve(t.to))).scrollIntoView()
+        n.replaceRangeWith(r.to - 1, r.to, t.schema.node("paragraph")).setSelection(ne.near(n.doc.resolve(r.to))).scrollIntoView()
       ), !0;
   }
-  return e == null || e(n.setMeta("hardbreak", !0).replaceSelectionWith(L.type().create()).scrollIntoView()), !0;
-}), gt = k("hardbreakKeymap", {
+  return e == null || e(n.setMeta("hardbreak", !0).replaceSelectionWith(w.type().create()).scrollIntoView()), !0;
+}), ht = k("hardbreakKeymap", {
   InsertHardbreak: {
     shortcuts: "Shift-Enter",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(Ae.key);
     }
   }
-}), Le = y("hr"), J = M("hr", (r) => ({
+}), Le = y("hr"), J = M("hr", (t) => ({
   group: "block",
   parseDOM: [{ tag: "hr" }],
-  toDOM: (e) => ["hr", r.get(Le.key)(e)],
+  toDOM: (e) => ["hr", t.get(Le.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "thematicBreak",
-    runner: (e, t, n) => {
+    runner: (e, r, n) => {
       e.addNode(n);
     }
   },
@@ -538,21 +535,21 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       e.addNode("thematicBreak");
     }
   }
-})), ft = b(() => new oe(
+})), kt = b(() => new ae(
   /^(?:---|___\s|\*\*\*\s)$/,
-  (r, e, t, n) => {
-    const { tr: o } = r;
-    return e[0] && o.replaceWith(t - 1, n, J.type().create()), o;
+  (t, e, r, n) => {
+    const { tr: o } = t;
+    return e[0] && o.replaceWith(r - 1, n, J.type().create()), o;
   }
-)), ht = p("InsertHr", () => () => (r, e) => {
+)), yt = p("InsertHr", () => () => (t, e) => {
   if (!e)
     return !0;
-  const t = T.node.type().create(), { tr: n, selection: o } = r, { from: a } = o, l = J.type().create();
+  const r = S.node.type().create(), { tr: n, selection: o } = t, { from: a } = o, l = J.type().create();
   if (!l)
     return !0;
-  const s = n.replaceSelectionWith(l).insert(a, t), c = se.findFrom(s.doc.resolve(a), 1, !0);
+  const s = n.replaceSelectionWith(l).insert(a, r), c = ne.findFrom(s.doc.resolve(a), 1, !0);
   return c && e(s.setSelection(c).scrollIntoView()), !0;
-}), Se = y("bulletList"), R = M("bullet_list", (r) => ({
+}), Te = y("bulletList"), R = M("bullet_list", (t) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -565,7 +562,7 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       tag: "ul",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw w(e);
+          throw N(e);
         return {
           spread: e.dataset.spread
         };
@@ -575,33 +572,33 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   toDOM: (e) => [
     "ul",
     {
-      ...r.get(Se.key)(e),
+      ...t.get(Te.key)(e),
       "data-spread": e.attrs.spread
     },
     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();
+    match: ({ type: e, ordered: r }) => e === "list" && !r,
+    runner: (e, r, n) => {
+      const o = r.spread != null ? `${r.spread}` : "false";
+      e.openNode(n, { spread: o }).next(r.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();
+    runner: (e, r) => {
+      e.openNode("list", void 0, { ordered: !1, spread: r.attrs.spread === "true" }).next(r.content).closeNode();
     }
   }
-})), kt = b(() => j(/^\s*([-+*])\s$/, R.type())), Te = p("WrapInBulletList", () => () => G(R.type())), yt = k("bulletListKeymap", {
+})), Mt = b(() => G(/^\s*([-+*])\s$/, R.type())), Se = p("WrapInBulletList", () => () => z(R.type())), It = k("bulletListKeymap", {
   WrapInBulletList: {
     shortcuts: "Mod-Alt-8",
-    command: (r) => {
-      const e = r.get(g);
-      return () => e.call(Te.key);
+    command: (t) => {
+      const e = t.get(g);
+      return () => e.call(Se.key);
     }
   }
-}), De = y("orderedList"), P = M("ordered_list", (r) => ({
+}), De = y("orderedList"), P = M("ordered_list", (t) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -617,7 +614,7 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       tag: "ol",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw w(e);
+          throw N(e);
         return {
           spread: e.dataset.spread,
           order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
@@ -628,39 +625,39 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   toDOM: (e) => [
     "ol",
     {
-      ...r.get(De.key)(e),
+      ...t.get(De.key)(e),
       ...e.attrs.order === 1 ? {} : e.attrs.order,
       "data-spread": e.attrs.spread
     },
     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();
+    match: ({ type: e, ordered: r }) => e === "list" && !!r,
+    runner: (e, r, n) => {
+      const o = r.spread != null ? `${r.spread}` : "true";
+      e.openNode(n, { spread: o }).next(r.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();
+    runner: (e, r) => {
+      e.openNode("list", void 0, { ordered: !0, start: 1, spread: r.attrs.spread === "true" }), e.next(r.content), e.closeNode();
     }
   }
-})), Mt = b(() => j(
+})), bt = b(() => G(
   /^\s*(\d+)\.\s$/,
   P.type(),
-  (r) => ({ order: Number(r[1]) }),
-  (r, e) => e.childCount + e.attrs.order === Number(r[1])
-)), Oe = p("WrapInOrderedList", () => () => G(P.type())), It = k("orderedListKeymap", {
+  (t) => ({ order: Number(t[1]) }),
+  (t, e) => e.childCount + e.attrs.order === Number(t[1])
+)), Oe = p("WrapInOrderedList", () => () => z(P.type())), Nt = k("orderedListKeymap", {
   WrapInOrderedList: {
     shortcuts: "Mod-Alt-7",
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(Oe.key);
     }
   }
-}), He = y("listItem"), O = M("list_item", (r) => ({
+}), He = y("listItem"), O = M("list_item", (t) => ({
   group: "listItem",
   content: "paragraph block*",
   attrs: {
@@ -680,7 +677,7 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
       tag: "li",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw w(e);
+          throw N(e);
         return {
           label: e.dataset.label,
           listType: e.dataset["list-type"],
@@ -692,7 +689,7 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   toDOM: (e) => [
     "li",
     {
-      ...r.get(He.key)(e),
+      ...t.get(He.key)(e),
       "data-label": e.attrs.label,
       "data-list-type": e.attrs.listType,
       "data-spread": e.attrs.spread
@@ -701,54 +698,54 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   ],
   parseMarkdown: {
     match: ({ type: e }) => e === "listItem",
-    runner: (e, t, n) => {
-      const o = t.label != null ? `${t.label}.` : "•", a = t.label != null ? "ordered" : "bullet", l = t.spread != null ? `${t.spread}` : "true";
-      e.openNode(n, { label: o, listType: a, spread: l }), e.next(t.children), e.closeNode();
+    runner: (e, r, n) => {
+      const o = r.label != null ? `${r.label}.` : "•", a = r.label != null ? "ordered" : "bullet", l = r.spread != null ? `${r.spread}` : "true";
+      e.openNode(n, { label: o, listType: a, spread: l }), e.next(r.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();
+    runner: (e, r) => {
+      e.openNode("listItem", void 0, { spread: r.attrs.spread === "true" }), e.next(r.content), e.closeNode();
     }
   }
-})), _e = p("SinkListItem", () => () => Ge(O.type())), Ke = p("SplitListItem", () => () => je(O.type())), Ee = p("SplitListItem", () => () => ze(O.type())), bt = k("listItemKeymap", {
+})), _e = p("SinkListItem", () => () => je(O.type())), Ke = p("SplitListItem", () => () => Ue(O.type())), Be = p("SplitListItem", () => () => Ye(O.type())), wt = k("listItemKeymap", {
   NextListItem: {
     shortcuts: "Enter",
-    command: (r) => {
-      const e = r.get(g);
-      return () => e.call(Ee.key);
+    command: (t) => {
+      const e = t.get(g);
+      return () => e.call(Be.key);
     }
   },
   SinkListItem: {
     shortcuts: ["Tab", "Mod-]"],
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(_e.key);
     }
   },
   LiftListItem: {
     shortcuts: ["Shift-Tab", "Mod-["],
-    command: (r) => {
-      const e = r.get(g);
+    command: (t) => {
+      const e = t.get(g);
       return () => e.call(Ke.key);
     }
   }
-}), wt = te("text", () => ({
+}), vt = te("text", () => ({
   group: "inline",
   parseMarkdown: {
-    match: ({ type: r }) => r === "text",
-    runner: (r, e) => {
-      r.addText(e.value);
+    match: ({ type: t }) => t === "text",
+    runner: (t, e) => {
+      t.addText(e.value);
     }
   },
   toMarkdown: {
-    match: (r) => r.type.name === "text",
-    runner: (r, e) => {
-      r.addNode("text", void 0, e.text);
+    match: (t) => t.type.name === "text",
+    runner: (t, e) => {
+      t.addNode("text", void 0, e.text);
     }
   }
-})), $e = y("html"), Nt = M("html", (r) => ({
+})), $e = y("html"), Ct = M("html", (t) => ({
   atom: !0,
   group: "inline",
   inline: !0,
@@ -758,12 +755,12 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
     }
   },
   toDOM: (e) => {
-    const t = document.createElement("span"), n = {
-      ...r.get($e.key)(e),
+    const r = document.createElement("span"), n = {
+      ...t.get($e.key)(e),
       "data-value": e.attrs.value,
       "data-type": "html"
     };
-    return t.textContent = e.attrs.value, ["span", n, e.attrs.value];
+    return r.textContent = e.attrs.value, ["span", n, e.attrs.value];
   },
   parseDOM: [{
     tag: 'span[data-type="html"]',
@@ -773,162 +770,162 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   }],
   parseMarkdown: {
     match: ({ type: e }) => Boolean(e === "html"),
-    runner: (e, t, n) => {
-      e.addNode(n, { value: t.value });
+    runner: (e, r, n) => {
+      e.addNode(n, { value: r.value });
     }
   },
   toMarkdown: {
     match: (e) => e.type.name === "html",
-    runner: (e, t) => {
-      e.addNode("html", void 0, t.attrs.value);
+    runner: (e, r) => {
+      e.addNode("html", void 0, r.attrs.value);
     }
   }
-})), vt = [
-  rt,
+})), xt = [
+  ot,
   ke,
-  T,
-  z,
+  S,
+  j,
   Me,
   D,
   xe,
-  L,
+  w,
   be,
   U,
-  Ne,
+  we,
   Y,
   Le,
   J,
   Ce,
-  B,
-  Se,
+  E,
+  Te,
   R,
   De,
   P,
   He,
   O,
+  le,
   ce,
-  ie,
   de,
-  me,
-  ge,
-  x,
-  he,
+  ue,
+  pe,
   A,
+  fe,
+  L,
   $e,
-  Nt,
-  wt
-].flat(), Ct = [
-  ct,
-  kt,
+  Ct,
+  vt
+].flat(), At = [
+  dt,
   Mt,
-  ut,
-  ft,
-  st
-].flat(), xt = [
+  bt,
+  mt,
+  kt,
+  ct
+].flat(), Lt = [
   ye,
-  we,
+  Ne,
   I,
   Ie,
   ve,
   Ae,
-  ht,
-  mt,
-  pt,
+  yt,
+  gt,
+  ft,
   Oe,
-  Te,
+  Se,
   _e,
-  Ee,
+  Be,
   Ke,
-  ue,
-  fe,
-  pe,
-  et,
-  tt
-], At = [
+  ie,
+  ge,
+  me,
+  rt,
+  nt
+], Tt = [
+  ut,
+  pt,
+  ht,
   it,
-  dt,
-  gt,
-  lt,
-  bt,
+  wt,
+  Nt,
   It,
-  yt,
-  nt,
-  Qe,
+  at,
   Ze,
-  Xe
-].flat(), W = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, Lt = (r) => new RegExp(`\\\\(?=[^\\w\\s${r}\\\\]|_)`, "g"), St = (r) => {
-  let e = r, t = e.match(W);
-  for (; t && t.groups; ) {
-    const { span: n } = t.groups;
-    e = e.replace(W, n), t = e.match(W);
+  tt,
+  et
+].flat(), W = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, St = (t) => new RegExp(`\\\\(?=[^\\w\\s${t}\\\\]|_)`, "g"), Dt = (t) => {
+  let e = t, r = e.match(W);
+  for (; r && r.groups; ) {
+    const { span: n } = r.groups;
+    e = e.replace(W, n), r = e.match(W);
   }
   return e;
-}, Tt = (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();
-}, Dt = (r) => (e) => e.replace(Lt(r), ""), Ot = (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;
-}, Ht = (r, e, t) => {
+}, Ot = (t, e, r) => {
+  const n = t.split(""), o = n[e];
+  return n[e] && n[r] && (n[e] = n[r], n[r] = o), n.join("").toString();
+}, Ht = (t) => (e) => e.replace(St(t), ""), _t = (t) => (e) => {
+  const r = e.indexOf(t.hole), n = e.charAt(r - 1), o = e.charAt(r + 1), a = /[^\w]|_/;
+  return o ? n && a.test(n) && a.test(o) ? t.punctuation : t.char : t.punctuation;
+}, Kt = (t, e, r) => {
   let n = e, o = !1;
-  return r.descendants((a) => {
+  return t.descendants((a) => {
     var l;
     if (o)
       return !1;
     if (a.isText) {
-      const s = (l = a.text) == null ? void 0 : l.indexOf(t);
+      const s = (l = a.text) == null ? void 0 : l.indexOf(r);
       if (s != null && s >= 0)
         return o = !0, n += s, !1;
     }
     n += a.nodeSize;
   }), n;
-}, _t = {
+}, Bt = {
   placeholderConfig: {
     hole: "∅",
     punctuation: "⁂",
     char: "∴"
   },
   globalNodes: ["footnote_definition"],
-  shouldSyncNode: ({ prevNode: r, nextNode: e }) => r.inlineContent && e && r.type === e.type && !r.eq(e),
-  movePlaceholder: (r, e) => {
-    const t = ["*", "_"];
-    let n = e.indexOf(r);
-    for (; t.includes(e[n - 1] || "") && t.includes(e[n + 1] || ""); )
-      e = Tt(e, n, n + 1), n = n + 1;
+  shouldSyncNode: ({ prevNode: t, nextNode: e }) => t.inlineContent && e && t.type === e.type && !t.eq(e),
+  movePlaceholder: (t, e) => {
+    const r = ["*", "_"];
+    let n = e.indexOf(t);
+    for (; r.includes(e[n - 1] || "") && r.includes(e[n + 1] || ""); )
+      e = Ot(e, n, n + 1), n = n + 1;
     return e;
   }
-}, H = F(_t, "inlineSyncConfig"), Kt = (r) => r.selection.$from.node(), Et = (r, e, t, n) => {
-  const o = r.get(qe), a = e.schema.topNodeType.create(void 0, [t, ...n]);
+}, H = F(Bt, "inlineSyncConfig"), $t = (t) => t.selection.$from.node(), Et = (t, e, r, n) => {
+  const o = t.get(qe), a = e.schema.topNodeType.create(void 0, [r, ...n]);
   return o(a);
-}, $t = (r, e) => {
-  const t = r.get(H.key), n = t.placeholderConfig.hole, [o = "", ...a] = e.split(`
+}, Rt = (t, e) => {
+  const r = t.get(H.key), n = r.placeholderConfig.hole, [o = "", ...a] = e.split(`
 
-`), l = (u) => t.movePlaceholder(n, u);
-  let c = We(Dt(n), l, St)(o);
-  const i = Ot(t.placeholderConfig)(c);
+`), l = (d) => r.movePlaceholder(n, d);
+  let c = We(Ht(n), l, Dt)(o);
+  const i = _t(r.placeholderConfig)(c);
   return c = c.replace(n, i), c = [c, ...a].join(`
 
 `), [c, i];
-}, Bt = (r, e) => {
-  const n = r.get(Fe)(e);
+}, Pt = (t, e) => {
+  const n = t.get(Fe)(e);
   return n ? n.firstChild : null;
-}, Rt = (r, e) => {
-  const { globalNodes: t } = r.get(H.key), n = [];
+}, Wt = (t, e) => {
+  const { globalNodes: r } = t.get(H.key), n = [];
   return e.doc.descendants((o) => {
-    if (t.includes(o.type.name) || t.includes(o.type))
+    if (r.includes(o.type.name) || r.includes(o.type))
       return n.push(o), !1;
   }), n;
-}, Pt = (r) => r.split(`
+}, qt = (t) => t.split(`
 
-`)[0] || "", Wt = (r) => r.childCount === 1 && r.child(0).type.name === "html", Be = (r, e) => {
+`)[0] || "", Ft = (t) => t.childCount === 1 && t.child(0).type.name === "html", Ee = (t, e) => {
   try {
-    const t = Rt(r, e), n = Kt(e), o = Et(r, e, n, t), [a, l] = $t(r, o), s = Bt(r, a);
-    return !s || n.type !== s.type || Wt(s) ? null : (s.attrs = { ...n.attrs }, s.descendants((c) => {
-      var d;
-      const u = c.marks.find((f) => f.type.name === "link");
-      u && ((d = c.text) == null ? void 0 : d.includes(l)) && u.attrs.href.includes(l) && (u.attrs.href = u.attrs.href.replace(l, ""));
+    const r = Wt(t, e), n = $t(e), o = Et(t, e, n, r), [a, l] = Rt(t, o), s = Pt(t, a);
+    return !s || n.type !== s.type || Ft(s) ? null : (s.attrs = { ...n.attrs }, s.descendants((c) => {
+      var u;
+      const d = c.marks.find((f) => f.type.name === "link");
+      d && ((u = c.text) == null ? void 0 : u.includes(l)) && d.attrs.href.includes(l) && (d.attrs.href = d.attrs.href.replace(l, ""));
     }), {
-      text: Pt(a),
+      text: qt(a),
       prevNode: n,
       nextNode: s,
       placeholder: l
@@ -936,77 +933,77 @@ const ce = K("emphasis"), ie = E("emphasis", (r) => ({
   } catch {
     return null;
   }
-}, qt = (r, e, t, n, o) => {
-  const { placeholderConfig: a } = r.get(H.key), l = a.hole;
-  let s = t.tr.setMeta(e, !0).insertText(l, t.selection.from);
-  const c = t.apply(s), i = Be(r, c);
+}, Vt = (t, e, r, n, o) => {
+  const { placeholderConfig: a } = t.get(H.key), l = a.hole;
+  let s = r.tr.setMeta(e, !0).insertText(l, r.selection.from);
+  const c = r.apply(s), i = Ee(t, c);
   if (!i)
     return;
-  const { $from: u } = c.selection, d = u.before(), f = u.after(), m = Ht(i.nextNode, d, i.placeholder);
-  s = s.replaceWith(d, f, i.nextNode).setNodeMarkup(d, void 0, o).delete(m + 1, m + 2), s = s.setSelection(ae.near(s.doc.resolve(m + 1))), n(s);
-}, Ft = N((r) => {
+  const { $from: d } = c.selection, u = d.before(), f = d.after(), m = Kt(i.nextNode, u, i.placeholder);
+  s = s.replaceWith(u, f, i.nextNode).setNodeMarkup(u, void 0, o).delete(m + 1, m + 2), s = s.setSelection(re.near(s.doc.resolve(m + 1))), n(s);
+}, zt = v((t) => {
   let e = null;
-  const t = new v("MILKDOWN_INLINE_SYNC");
-  return new C({
-    key: t,
+  const r = new C("MILKDOWN_INLINE_SYNC");
+  return new x({
+    key: r,
     state: {
       init: () => null,
       apply: (n, o, a, l) => {
         var h;
-        const s = r.get(q);
-        if (!((h = s.hasFocus) != null && h.call(s)) || !s.editable || !n.docChanged || n.getMeta(t))
+        const s = t.get(q);
+        if (!((h = s.hasFocus) != null && h.call(s)) || !s.editable || !n.docChanged || n.getMeta(r))
           return null;
-        const i = Be(r, l);
+        const i = Ee(t, l);
         if (!i)
           return null;
         e && (cancelAnimationFrame(e), e = null);
-        const { prevNode: u, nextNode: d, text: f } = i, { shouldSyncNode: m } = r.get(H.key);
-        return m({ prevNode: u, nextNode: d, ctx: r, tr: n, text: f }) && (e = requestAnimationFrame(() => {
+        const { prevNode: d, nextNode: u, text: f } = i, { shouldSyncNode: m } = t.get(H.key);
+        return m({ prevNode: d, nextNode: u, ctx: t, tr: n, text: f }) && (e = requestAnimationFrame(() => {
           e = null;
-          const { dispatch: _, state: Q } = r.get(q);
-          qt(r, t, Q, _, u.attrs);
-        })), null;
+          const { dispatch: _, state: Q } = t.get(q);
+          Vt(t, r, Q, _, d.attrs);
+        }), n.setMeta("addToHistory", !1)), null;
       }
     }
   });
-}), Vt = $(() => () => (r) => {
-  le(r, "list", (e) => {
+}), Gt = $(() => () => (t) => {
+  se(t, "list", (e) => {
     if (e.ordered) {
-      const t = e.start ?? 1;
+      const r = e.start ?? 1;
       e.children.forEach((n, o) => {
-        n.label = o + t;
+        n.label = o + r;
       });
     }
   });
-}), Gt = $(() => () => (r) => {
+}), jt = $(() => () => (t) => {
   const e = /[\t ]*(?:\r?\n|\r)/g;
-  le(r, "text", (t, n, o) => {
-    if (!t.value || typeof t.value != "string")
+  se(t, "text", (r, n, o) => {
+    if (!r.value || typeof r.value != "string")
       return;
     const a = [];
     let l = 0;
     e.lastIndex = 0;
-    let s = e.exec(t.value);
+    let s = e.exec(r.value);
     for (; s; ) {
       const i = s.index;
-      l !== i && a.push({ type: "text", value: t.value.slice(l, i) }), a.push({ type: "break", data: { isInline: !0 } }), l = i + s[0].length, s = e.exec(t.value);
+      l !== i && a.push({ type: "text", value: r.value.slice(l, i) }), a.push({ type: "break", data: { isInline: !0 } }), l = i + s[0].length, s = e.exec(r.value);
     }
     if (!!(a.length > 0 && o && typeof n == "number"))
-      return l < t.value.length && a.push({ type: "text", value: t.value.slice(l) }), o.children.splice(n, 1, ...a), n + a.length;
+      return l < r.value.length && a.push({ type: "text", value: r.value.slice(l) }), o.children.splice(n, 1, ...a), n + a.length;
   });
-}), jt = $(() => Je), zt = (r) => !!r.children, Ut = (r) => r.type === "html";
-function Yt(r, e) {
-  return t(r, 0, null)[0];
-  function t(n, o, a) {
-    if (zt(n)) {
+}), Ut = $(() => Xe), Yt = (t) => !!t.children, Jt = (t) => t.type === "html";
+function Qt(t, e) {
+  return r(t, 0, null)[0];
+  function r(n, o, a) {
+    if (Yt(n)) {
       const l = [];
       for (let s = 0, c = n.children.length; s < c; s++) {
         const i = n.children[s];
         if (i) {
-          const u = t(i, s, n);
-          if (u)
-            for (let d = 0, f = u.length; d < f; d++) {
-              const m = u[d];
+          const d = r(i, s, n);
+          if (d)
+            for (let u = 0, f = d.length; u < f; u++) {
+              const m = d[u];
               m && l.push(m);
             }
         }
@@ -1016,11 +1013,11 @@ function Yt(r, e) {
     return e(n, o, a);
   }
 }
-const Jt = $(() => () => (r) => {
-  Yt(r, (e, t, n) => Ut(e) ? ((n == null ? void 0 : n.type) === "root" && (e.children = [{ ...e }], delete e.value, e.type = "paragraph"), [e]) : [e]);
-}), Qt = N(() => {
-  let r = !1;
-  const e = new v("MILKDOWN_INLINE_NODES_CURSOR"), t = new C({
+const Xt = $(() => () => (t) => {
+  Qt(t, (e, r, n) => Jt(e) ? ((n == null ? void 0 : n.type) === "root" && (e.children = [{ ...e }], delete e.value, e.type = "paragraph"), [e]) : [e]);
+}), Zt = v(() => {
+  let t = !1;
+  const e = new C("MILKDOWN_INLINE_NODES_CURSOR"), r = new x({
     key: e,
     state: {
       init() {
@@ -1035,15 +1032,15 @@ const Jt = $(() => () => (r) => {
     },
     props: {
       handleDOMEvents: {
-        compositionend: (n, o) => r ? (r = !1, requestAnimationFrame(() => {
-          if (t.getState(n.state)) {
+        compositionend: (n, o) => t ? (t = !1, requestAnimationFrame(() => {
+          if (r.getState(n.state)) {
             const l = n.state.selection.from;
             o.preventDefault(), n.dispatch(n.state.tr.insertText(o.data || "", l));
           }
         }), !0) : !1,
-        compositionstart: (n) => (t.getState(n.state) && (r = !0), !1),
+        compositionstart: (n) => (r.getState(n.state) && (t = !0), !1),
         beforeinput: (n, o) => {
-          if (t.getState(n.state) && o instanceof InputEvent && o.data && !r) {
+          if (r.getState(n.state) && o instanceof InputEvent && o.data && !t) {
             const l = n.state.selection.from;
             return o.preventDefault(), n.dispatch(n.state.tr.insertText(o.data || "", l)), !0;
           }
@@ -1051,48 +1048,48 @@ const Jt = $(() => () => (r) => {
         }
       },
       decorations(n) {
-        if (t.getState(n)) {
+        if (r.getState(n)) {
           const l = n.selection.$from.pos, s = document.createElement("span"), c = Z.widget(l, s, {
             side: -1
-          }), i = document.createElement("span"), u = Z.widget(l, i);
+          }), i = document.createElement("span"), d = Z.widget(l, i);
           return setTimeout(() => {
             s.contentEditable = "true", i.contentEditable = "true";
-          }), ee.create(n.doc, [c, u]);
+          }), ee.create(n.doc, [c, d]);
         }
         return ee.empty;
       }
     }
   });
-  return t;
-}), Xt = N(() => new C({
-  key: new v("MILKDOWN_HARDBREAK_MARKS"),
-  appendTransaction: (r, e, t) => {
-    if (!r.length)
+  return r;
+}), er = v(() => new x({
+  key: new C("MILKDOWN_HARDBREAK_MARKS"),
+  appendTransaction: (t, e, r) => {
+    if (!t.length)
       return;
-    const [n] = r;
+    const [n] = t;
     if (!n)
       return;
     const [o] = n.steps;
     if (n.getMeta("hardbreak")) {
-      if (!(o instanceof Ue))
+      if (!(o instanceof Je))
         return;
       const { from: s } = o;
-      return t.tr.setNodeMarkup(s, L.type(), void 0, []);
+      return r.tr.setNodeMarkup(s, w.type(), void 0, []);
     }
-    if (o instanceof Ye) {
-      let s = t.tr;
+    if (o instanceof Qe) {
+      let s = r.tr;
       const { from: c, to: i } = o;
-      return t.doc.nodesBetween(c, i, (u, d) => {
-        u.type === L.type() && (s = s.setNodeMarkup(d, L.type(), void 0, []));
+      return r.doc.nodesBetween(c, i, (d, u) => {
+        d.type === w.type() && (s = s.setNodeMarkup(u, w.type(), void 0, []));
       }), s;
     }
   }
-})), Re = F(["table", "code_block"], "hardbreakFilterNodes"), Zt = N((r) => {
-  const e = r.get(Re.key);
-  return new C({
-    key: new v("MILKDOWN_HARDBREAK_FILTER"),
-    filterTransaction: (t, n) => {
-      const o = t.getMeta("hardbreak"), [a] = t.steps;
+})), Re = F(["table", "code_block"], "hardbreakFilterNodes"), tr = v((t) => {
+  const e = t.get(Re.key);
+  return new x({
+    key: new C("MILKDOWN_HARDBREAK_FILTER"),
+    filterTransaction: (r, n) => {
+      const o = r.getMeta("hardbreak"), [a] = r.steps;
       if (o && a) {
         const { from: l } = a, s = n.doc.resolve(l);
         let c = s.depth, i = !0;
@@ -1103,171 +1100,171 @@ const Jt = $(() => () => (r) => {
       return !0;
     }
   });
-}), er = N((r) => {
-  const e = new v("MILKDOWN_HEADING_ID"), t = (n) => {
+}), rr = v((t) => {
+  const e = new C("MILKDOWN_HEADING_ID"), r = (n) => {
     if (n.composing || !n.editable)
       return;
-    const o = r.get(z.key), a = n.state.tr.setMeta("addToHistory", !1);
+    const o = t.get(j.key), a = n.state.tr.setMeta("addToHistory", !1);
     let l = !1;
     n.state.doc.descendants((s, c) => {
       if (s.type === D.type()) {
         if (s.textContent.trim().length === 0)
           return;
-        const i = s.attrs, u = o(s);
-        i.id !== u && (l = !0, a.setMeta(e, !0).setNodeMarkup(c, void 0, {
+        const i = s.attrs, d = o(s);
+        i.id !== d && (l = !0, a.setMeta(e, !0).setNodeMarkup(c, void 0, {
           ...i,
-          id: u
+          id: d
         }));
       }
     }), l && n.dispatch(a);
   };
-  return new C({
+  return new x({
     key: e,
-    view: (n) => (t(n), {
+    view: (n) => (r(n), {
       update: (o) => {
-        t(o);
+        r(o);
       }
     })
   });
-}), tr = N(() => {
-  const r = (e) => {
+}), nr = v(() => {
+  const t = (e) => {
     if (e.composing || !e.editable)
       return;
-    const t = P.type(), n = R.type(), o = O.type(), a = e.state, l = (i, u) => {
-      let d = !1;
-      const f = `${u + 1}.`;
-      return i.label !== f && (i.label = f, d = !0), d;
+    const r = P.type(), n = R.type(), o = O.type(), a = e.state, l = (i, d) => {
+      let u = !1;
+      const f = `${d + 1}.`;
+      return i.label !== f && (i.label = f, u = !0), u;
     };
     let s = a.tr, c = !1;
-    a.doc.descendants((i, u, d, f) => {
+    a.doc.descendants((i, d, u, f) => {
       if (i.type === n) {
         const m = i.maybeChild(0);
-        (m == null ? void 0 : m.type) === o && m.attrs.listType === "ordered" && (c = !0, s.setNodeMarkup(u, t, { spread: "true" }), i.descendants((h, _, Q, Pe) => {
+        (m == null ? void 0 : m.type) === o && m.attrs.listType === "ordered" && (c = !0, s.setNodeMarkup(d, r, { spread: "true" }), i.descendants((h, _, Q, Pe) => {
           if (h.type === o) {
             const X = { ...h.attrs };
             l(X, Pe) && (s = s.setNodeMarkup(_, void 0, X));
           }
           return !1;
         }));
-      } else if (i.type === o && (d == null ? void 0 : d.type) === t) {
+      } else if (i.type === o && (u == null ? void 0 : u.type) === r) {
         const m = { ...i.attrs };
         let h = !1;
-        m.listType !== "ordered" && (m.listType = "ordered", h = !0), (d == null ? void 0 : d.maybeChild(0)) && (h = l(m, f)), h && (s = s.setNodeMarkup(u, void 0, m), c = !0);
+        m.listType !== "ordered" && (m.listType = "ordered", h = !0), (u == null ? void 0 : u.maybeChild(0)) && (h = l(m, f)), h && (s = s.setNodeMarkup(d, void 0, m), c = !0);
       }
     }), c && e.dispatch(s.setMeta("addToHistory", !1));
   };
-  return new C({
-    key: new v("MILKDOWN_KEEP_LIST_ORDER"),
-    view: (e) => (r(e), {
-      update: (t) => {
-        r(t);
+  return new x({
+    key: new C("MILKDOWN_KEEP_LIST_ORDER"),
+    view: (e) => (t(e), {
+      update: (r) => {
+        t(r);
       }
     })
   });
-}), rr = [
+}), or = [
   H,
-  Ft,
-  Xt,
+  zt,
+  er,
   Re,
+  tr,
   Zt,
-  Qt,
-  Vt,
-  jt,
   Gt,
-  Jt,
-  er,
-  tr
-], Mr = [vt, Ct, xt, At, rr].flat();
+  Ut,
+  jt,
+  Xt,
+  rr,
+  nr
+], Nr = [xt, At, Lt, Tt, or].flat();
 export {
   be as blockquoteAttr,
-  it as blockquoteKeymap,
+  ut as blockquoteKeymap,
   U as blockquoteSchema,
-  Se as bulletListAttr,
-  yt as bulletListKeymap,
+  Te as bulletListAttr,
+  It as bulletListKeymap,
   R as bulletListSchema,
-  Ne as codeBlockAttr,
-  dt as codeBlockKeymap,
+  we as codeBlockAttr,
+  pt as codeBlockKeymap,
   Y as codeBlockSchema,
-  xt as commands,
-  Mr as commonmark,
+  Lt as commands,
+  Nr as commonmark,
   ve as createCodeBlockCommand,
-  ut as createCodeBlockInputRule,
-  _t as defaultConfig,
-  rt as docSchema,
+  mt as createCodeBlockInputRule,
+  Bt as defaultConfig,
+  ot as docSchema,
   Ie as downgradeHeadingCommand,
-  ce as emphasisAttr,
-  Qe as emphasisKeymap,
-  ie as emphasisSchema,
+  le as emphasisAttr,
+  Ze as emphasisKeymap,
+  ce as emphasisSchema,
   xe as hardbreakAttr,
-  Xt as hardbreakClearMarkPlugin,
+  er as hardbreakClearMarkPlugin,
   Re as hardbreakFilterNodes,
-  Zt as hardbreakFilterPlugin,
-  gt as hardbreakKeymap,
-  L as hardbreakSchema,
+  tr as hardbreakFilterPlugin,
+  ht as hardbreakKeymap,
+  w as hardbreakSchema,
   Me as headingAttr,
-  z as headingIdGenerator,
-  lt as headingKeymap,
+  j as headingIdGenerator,
+  it as headingKeymap,
   D as headingSchema,
   Le as hrAttr,
   J as hrSchema,
   $e as htmlAttr,
-  Nt as htmlSchema,
+  Ct as htmlSchema,
   Ce as imageAttr,
-  B as imageSchema,
-  ge as inlineCodeAttr,
-  Ze as inlineCodeKeymap,
-  x as inlineCodeSchema,
-  Qt as inlineNodesCursorPlugin,
+  E as imageSchema,
+  pe as inlineCodeAttr,
+  tt as inlineCodeKeymap,
+  A as inlineCodeSchema,
+  Zt as inlineNodesCursorPlugin,
   H as inlineSyncConfig,
-  Ft as inlineSyncPlugin,
-  Ct as inputrules,
+  zt as inlineSyncPlugin,
+  At as inputrules,
   Ae as insertHardbreakCommand,
-  ht as insertHrCommand,
-  ft as insertHrInputRule,
-  mt as insertImageCommand,
-  yr as insertImageInputRule,
-  At as keymap,
+  yt as insertHrCommand,
+  kt as insertHrInputRule,
+  gt as insertImageCommand,
+  br as insertImageInputRule,
+  Tt as keymap,
   Ke as liftListItemCommand,
-  he as linkAttr,
-  A as linkSchema,
+  fe as linkAttr,
+  L as linkSchema,
   He as listItemAttr,
-  bt as listItemKeymap,
+  wt as listItemKeymap,
   O as listItemSchema,
   De as orderedListAttr,
-  It as orderedListKeymap,
+  Nt as orderedListKeymap,
   P as orderedListSchema,
   ke as paragraphAttr,
-  nt as paragraphKeymap,
-  T as paragraphSchema,
-  rr as plugins,
-  Vt as remarkAddOrderInListPlugin,
-  Jt as remarkHtmlTransformer,
-  jt as remarkInlineLinkPlugin,
-  Gt as remarkLineBreak,
-  vt as schema,
+  at as paragraphKeymap,
+  S as paragraphSchema,
+  or as plugins,
+  Gt as remarkAddOrderInListPlugin,
+  Xt as remarkHtmlTransformer,
+  Ut as remarkInlineLinkPlugin,
+  jt as remarkLineBreak,
+  xt as schema,
   _e as sinkListItemCommand,
-  Ee as splitListItemCommand,
+  Be as splitListItemCommand,
   de as strongAttr,
-  Xe as strongKeymap,
-  me as strongSchema,
-  er as syncHeadingIdPlugin,
-  tr as syncListOrderPlugin,
-  wt as textSchema,
-  ue as toggleEmphasisCommand,
-  fe as toggleInlineCodeCommand,
-  et as toggleLinkCommand,
-  pe as toggleStrongCommand,
+  et as strongKeymap,
+  ue as strongSchema,
+  rr as syncHeadingIdPlugin,
+  nr as syncListOrderPlugin,
+  vt as textSchema,
+  ie as toggleEmphasisCommand,
+  ge as toggleInlineCodeCommand,
+  rt as toggleLinkCommand,
+  me as toggleStrongCommand,
   ye as turnIntoTextCommand,
-  kr as updateCodeBlockLanguageCommand,
-  pt as updateImageCommand,
-  tt as updateLinkCommand,
-  we as wrapInBlockquoteCommand,
-  ct as wrapInBlockquoteInputRule,
-  Te as wrapInBulletListCommand,
-  kt as wrapInBulletListInputRule,
+  Ir as updateCodeBlockLanguageCommand,
+  ft as updateImageCommand,
+  nt as updateLinkCommand,
+  Ne as wrapInBlockquoteCommand,
+  dt as wrapInBlockquoteInputRule,
+  Se as wrapInBulletListCommand,
+  Mt as wrapInBulletListInputRule,
   I as wrapInHeadingCommand,
-  st as wrapInHeadingInputRule,
+  ct as wrapInHeadingInputRule,
   Oe as wrapInOrderedListCommand,
-  Mt as wrapInOrderedListInputRule
+  bt as wrapInOrderedListInputRule
 };
 //# sourceMappingURL=index.es.js.map