@milkdown/preset-commonmark 7.0.0-next.6 → 7.0.1

package/lib/index.es.js

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