@milkdown/preset-commonmark 7.1.1 → 7.1.2-next.0

package/lib/index.es.js

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