@milkdown/preset-commonmark 7.3.1 → 7.3.3

package/lib/index.es.js

@@ -1,41 +1,45 @@
-import { $markAttr as V, $markSchema as j, $command as y, $useKeymap as N, $node as ot, $nodeAttr as I, $nodeSchema as C, $ctx as ne, $inputRule as w, pipe as Tt, $prose as O, $remark as q } from "@milkdown/utils";
-import { remarkStringifyOptionsCtx as st, commandsCtx as h, editorViewCtx as X, serializerCtx as Rt, parserCtx as Kt } from "@milkdown/core";
-import { toggleMark as oe, setBlockType as E, wrapIn as se } from "@milkdown/prose/commands";
-import { Fragment as Dt } from "@milkdown/prose/model";
-import { expectDomTypeError as A } from "@milkdown/exception";
-import { textblockTypeInputRule as lt, wrappingInputRule as le, InputRule as it } from "@milkdown/prose/inputrules";
-import Pt from "@sindresorhus/slugify";
-import { TextSelection as $, Selection as ct, PluginKey as T, Plugin as R } from "@milkdown/prose/state";
-import { findSelectedNodeOfType as _t } from "@milkdown/prose";
-import { sinkListItem as Et, liftListItem as dt, splitListItem as $t } from "@milkdown/prose/schema-list";
-import { ReplaceStep as qt, AddMarkStep as Wt } from "@milkdown/prose/transform";
-import { Decoration as at, DecorationSet as nt } from "@milkdown/prose/view";
-import { visit as ie } from "unist-util-visit";
-import Ft from "remark-inline-links";
-const mt = (t, e) => {
+import { $markAttr as V, $markSchema as U, $command as c, $inputRule as h, $useKeymap as f, $node as Qe, $nodeAttr as N, $nodeSchema as I, $ctx as Xe, $remark as D, $prose as _ } from "@milkdown/utils";
+import { remarkStringifyOptionsCtx as Ye, commandsCtx as u, editorViewCtx as wt } from "@milkdown/core";
+import { toggleMark as z, setBlockType as K, wrapIn as J } from "@milkdown/prose/commands";
+import { Fragment as At } from "@milkdown/prose/model";
+import { expectDomTypeError as w } from "@milkdown/exception";
+import { textblockTypeInputRule as Ze, wrappingInputRule as Q, InputRule as et } from "@milkdown/prose/inputrules";
+import Ht from "@sindresorhus/slugify";
+import { TextSelection as X, Selection as tt, PluginKey as E, Plugin as P } from "@milkdown/prose/state";
+import { markRule as G, findSelectedNodeOfType as Bt } from "@milkdown/prose";
+import { sinkListItem as Rt, liftListItem as rt, splitListItem as vt } from "@milkdown/prose/schema-list";
+import { ReplaceStep as Ot, AddMarkStep as Tt } from "@milkdown/prose/transform";
+import { Decoration as ze, DecorationSet as Je } from "@milkdown/prose/view";
+import { visit as Y } from "unist-util-visit";
+import Kt from "remark-inline-links";
+function at(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(Dt.fromArray(a));
-}, n = (t, e) => (Object.assign(t, {
-  meta: {
-    package: "@milkdown/preset-commonmark",
-    ...e
-  }
-}), t), ce = V("emphasis");
-n(ce, {
+  e.content.forEach((s, l, i) => {
+    i !== e.childCount - 1 && a.push(s);
+  }), t.next(At.fromArray(a));
+}
+function n(t, e) {
+  return Object.assign(t, {
+    meta: {
+      package: "@milkdown/preset-commonmark",
+      ...e
+    }
+  }), t;
+}
+const Z = V("emphasis");
+n(Z, {
   displayName: "Attr<emphasis>",
   group: "Emphasis"
 });
-const z = j("emphasis", (t) => ({
+const R = U("emphasis", (t) => ({
   attrs: {
     marker: {
-      default: t.get(st).emphasis || "*"
+      default: t.get(Ye).emphasis || "*"
     }
   },
   parseDOM: [
@@ -43,7 +47,7 @@ const z = j("emphasis", (t) => ({
     { tag: "em" },
     { style: "font-style", getAttrs: (e) => e === "italic" }
   ],
-  toDOM: (e) => ["em", t.get(ce.key)(e)],
+  toDOM: (e) => ["em", t.get(Z.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "emphasis",
     runner: (e, r, a) => {
@@ -59,45 +63,59 @@ const z = j("emphasis", (t) => ({
     }
   }
 }));
-n(z.mark, {
+n(R.mark, {
   displayName: "MarkSchema<emphasis>",
   group: "Emphasis"
 });
-n(z.ctx, {
+n(R.ctx, {
   displayName: "MarkSchemaCtx<emphasis>",
   group: "Emphasis"
 });
-const de = y("ToggleEmphasis", (t) => () => oe(z.type(t)));
-n(de, {
+const ee = c("ToggleEmphasis", (t) => () => z(R.type(t)));
+n(ee, {
   displayName: "Command<toggleEmphasisCommand>",
   group: "Emphasis"
 });
-const me = N("emphasisKeymap", {
+const nt = h((t) => G(/(?:^|[^*])\*([^*]+)\*$/, R.type(t), {
+  updateCaptured: ({ fullMatch: e, start: r }) => e.startsWith("*") ? {} : { fullMatch: e.slice(1), start: r + 1 }
+}));
+n(nt, {
+  displayName: "InputRule<emphasis>|Star",
+  group: "Emphasis"
+});
+const ot = h((t) => G(/(?:^|[^_])_([^_]+)_$/, R.type(t), {
+  updateCaptured: ({ fullMatch: e, start: r }) => e.startsWith("_") ? {} : { fullMatch: e.slice(1), start: r + 1 }
+}));
+n(ot, {
+  displayName: "InputRule<emphasis>|Underscore",
+  group: "Emphasis"
+});
+const te = f("emphasisKeymap", {
   ToggleEmphasis: {
     shortcuts: "Mod-i",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(de.key);
+      const e = t.get(u);
+      return () => e.call(ee.key);
     }
   }
 });
-n(me.ctx, {
+n(te.ctx, {
   displayName: "KeymapCtx<emphasis>",
   group: "Emphasis"
 });
-n(me.shortcuts, {
+n(te.shortcuts, {
   displayName: "Keymap<emphasis>",
   group: "Emphasis"
 });
-const ue = V("strong");
-n(ue, {
+const re = V("strong");
+n(re, {
   displayName: "Attr<strong>",
   group: "Strong"
 });
-const U = j("strong", (t) => ({
+const $ = U("strong", (t) => ({
   attrs: {
     marker: {
-      default: t.get(st).strong || "*"
+      default: t.get(Ye).strong || "*"
     }
   },
   parseDOM: [
@@ -105,7 +123,7 @@ const U = j("strong", (t) => ({
     { tag: "strong" },
     { style: "font-style", getAttrs: (e) => e === "bold" }
   ],
-  toDOM: (e) => ["strong", t.get(ue.key)(e)],
+  toDOM: (e) => ["strong", t.get(re.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "strong",
     runner: (e, r, a) => {
@@ -121,47 +139,52 @@ const U = j("strong", (t) => ({
     }
   }
 }));
-n(U.mark, {
+n($.mark, {
   displayName: "MarkSchema<strong>",
   group: "Strong"
 });
-n(U.ctx, {
+n($.ctx, {
   displayName: "MarkSchemaCtx<strong>",
   group: "Strong"
 });
-const pe = y("ToggleStrong", (t) => () => oe(U.type(t)));
-n(pe, {
+const ae = c("ToggleStrong", (t) => () => z($.type(t)));
+n(ae, {
   displayName: "Command<toggleStrongCommand>",
   group: "Strong"
 });
-const ge = N("strongKeymap", {
+const st = h((t) => G(/(?:\*\*|__)([^*_]+)(?:\*\*|__)$/, $.type(t)));
+n(st, {
+  displayName: "InputRule<strong>",
+  group: "Strong"
+});
+const ne = f("strongKeymap", {
   ToggleBold: {
     shortcuts: ["Mod-b"],
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(pe.key);
+      const e = t.get(u);
+      return () => e.call(ae.key);
     }
   }
 });
-n(ge.ctx, {
+n(ne.ctx, {
   displayName: "KeymapCtx<strong>",
   group: "Strong"
 });
-n(ge.shortcuts, {
+n(ne.shortcuts, {
   displayName: "Keymap<strong>",
   group: "Strong"
 });
-const ye = V("inlineCode");
-n(ye, {
+const oe = V("inlineCode");
+n(oe, {
   displayName: "Attr<inlineCode>",
   group: "InlineCode"
 });
-const x = j("inlineCode", (t) => ({
+const x = U("inlineCode", (t) => ({
   priority: 100,
   code: !0,
   inclusive: !1,
   parseDOM: [{ tag: "code" }],
-  toDOM: (e) => ["code", t.get(ye.key)(e)],
+  toDOM: (e) => ["code", t.get(oe.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "inlineCode",
     runner: (e, r, a) => {
@@ -183,42 +206,47 @@ n(x.ctx, {
   displayName: "MarkSchemaCtx<inlineCode>",
   group: "InlineCode"
 });
-const he = y("ToggleInlineCode", (t) => () => (e, r) => {
+const se = c("ToggleInlineCode", (t) => () => (e, r) => {
   const { selection: a, tr: o } = e;
   if (a.empty)
     return !1;
-  const { from: s, to: i } = a;
-  return e.doc.rangeHasMark(s, i, x.type(t)) ? (r == null || r(o.removeMark(s, i, x.type(t))), !0) : (Object.keys(e.schema.marks).filter((d) => d !== x.type.name).map((d) => e.schema.marks[d]).forEach((d) => {
-    o.removeMark(s, i, d);
-  }), r == null || r(o.addMark(s, i, x.type(t).create())), !0);
+  const { from: s, to: l } = a;
+  return e.doc.rangeHasMark(s, l, x.type(t)) ? (r == null || r(o.removeMark(s, l, x.type(t))), !0) : (Object.keys(e.schema.marks).filter((m) => m !== x.type.name).map((m) => e.schema.marks[m]).forEach((m) => {
+    o.removeMark(s, l, m);
+  }), r == null || r(o.addMark(s, l, x.type(t).create())), !0);
 });
-n(he, {
+n(se, {
   displayName: "Command<toggleInlineCodeCommand>",
   group: "InlineCode"
 });
-const ke = N("inlineCodeKeymap", {
+const lt = h((t) => G(/(?:\`)([^\`]+)(?:\`)$/, x.type(t)));
+n(lt, {
+  displayName: "InputRule<inlineCodeInputRule>",
+  group: "InlineCode"
+});
+const le = f("inlineCodeKeymap", {
   ToggleInlineCode: {
     shortcuts: "Mod-e",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(he.key);
+      const e = t.get(u);
+      return () => e.call(se.key);
     }
   }
 });
-n(ke.ctx, {
+n(le.ctx, {
   displayName: "KeymapCtx<inlineCode>",
   group: "InlineCode"
 });
-n(ke.shortcuts, {
+n(le.shortcuts, {
   displayName: "Keymap<inlineCode>",
   group: "InlineCode"
 });
-const fe = V("link");
-n(fe, {
+const ie = V("link");
+n(ie, {
   displayName: "Attr<link>",
   group: "Link"
 });
-const B = j("link", (t) => ({
+const B = U("link", (t) => ({
   attrs: {
     href: {},
     title: { default: null }
@@ -228,12 +256,12 @@ const B = j("link", (t) => ({
       tag: "a[href]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw A(e);
+          throw w(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(ie.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: (e) => e.type === "link",
     runner: (e, r, a) => {
@@ -255,34 +283,34 @@ n(B.mark, {
   displayName: "MarkSchema<link>",
   group: "Link"
 });
-const ut = y("ToggleLink", (t) => (e = {}) => oe(B.type(t), e));
-n(ut, {
+const it = c("ToggleLink", (t) => (e = {}) => z(B.type(t), e));
+n(it, {
   displayName: "Command<toggleLinkCommand>",
   group: "Link"
 });
-const pt = y("UpdateLink", (t) => (e = {}) => (r, a) => {
+const dt = c("UpdateLink", (t) => (e = {}) => (r, a) => {
   if (!a)
     return !1;
   let o, s = -1;
-  const { selection: i } = r, { from: l, to: c } = i;
-  if (r.doc.nodesBetween(l, l === c ? c + 1 : c, (p, f) => {
-    if (B.type(t).isInSet(p.marks))
-      return o = p, s = f, !1;
+  const { selection: l } = r, { from: i, to: d } = l;
+  if (r.doc.nodesBetween(i, i === d ? d + 1 : d, (y, b) => {
+    if (B.type(t).isInSet(y.marks))
+      return o = y, s = b, !1;
   }), !o)
     return !1;
-  const d = o.marks.find(({ type: p }) => p === B.type(t));
-  if (!d)
+  const m = o.marks.find(({ type: y }) => y === B.type(t));
+  if (!m)
     return !1;
-  const m = s, g = s + o.nodeSize, { tr: u } = r, k = B.type(t).create({ ...d.attrs, ...e });
-  return k ? (a(
-    u.removeMark(m, g, d).addMark(m, g, k).setSelection(new $(u.selection.$anchor)).scrollIntoView()
+  const p = s, k = s + o.nodeSize, { tr: g } = r, C = B.type(t).create({ ...m.attrs, ...e });
+  return C ? (a(
+    g.removeMark(p, k, m).addMark(p, k, C).setSelection(new X(g.selection.$anchor)).scrollIntoView()
   ), !0) : !1;
 });
-n(pt, {
+n(dt, {
   displayName: "Command<updateLinkCommand>",
   group: "Link"
 });
-const gt = ot("doc", () => ({
+const mt = Qe("doc", () => ({
   content: "block+",
   parseMarkdown: {
     match: ({ type: t }) => t === "root",
@@ -297,20 +325,20 @@ const gt = ot("doc", () => ({
     }
   }
 }));
-n(gt, {
+n(mt, {
   displayName: "NodeSchema<doc>",
   group: "Doc"
 });
-const Ne = I("paragraph");
-n(Ne, {
+const de = N("paragraph");
+n(de, {
   displayName: "Attr<paragraph>",
   group: "Paragraph"
 });
-const v = C("paragraph", (t) => ({
+const A = I("paragraph", (t) => ({
   content: "inline*",
   group: "block",
   parseDOM: [{ tag: "p" }],
-  toDOM: (e) => ["p", t.get(Ne.key)(e), 0],
+  toDOM: (e) => ["p", t.get(de.key)(e), 0],
   parseMarkdown: {
     match: (e) => e.type === "paragraph",
     runner: (e, r, a) => {
@@ -320,52 +348,56 @@ const v = C("paragraph", (t) => ({
   toMarkdown: {
     match: (e) => e.type.name === "paragraph",
     runner: (e, r) => {
-      e.openNode("paragraph"), mt(e, r), e.closeNode();
+      e.openNode("paragraph"), at(e, r), e.closeNode();
     }
   }
 }));
-n(v.node, {
+n(A.node, {
   displayName: "NodeSchema<paragraph>",
   group: "Paragraph"
 });
-n(v.ctx, {
+n(A.ctx, {
   displayName: "NodeSchemaCtx<paragraph>",
   group: "Paragraph"
 });
-const Ie = y("TurnIntoText", (t) => () => E(v.type(t)));
-n(Ie, {
+const me = c("TurnIntoText", (t) => () => K(A.type(t)));
+n(me, {
   displayName: "Command<turnIntoTextCommand>",
   group: "Paragraph"
 });
-const Ce = N("paragraphKeymap", {
+const pe = f("paragraphKeymap", {
   TurnIntoText: {
     shortcuts: "Mod-Alt-0",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Ie.key);
+      const e = t.get(u);
+      return () => e.call(me.key);
     }
   }
 });
-n(Ce.ctx, {
+n(pe.ctx, {
   displayName: "KeymapCtx<paragraph>",
   group: "Paragraph"
 });
-n(Ce.shortcuts, {
+n(pe.shortcuts, {
   displayName: "Keymap<paragraph>",
   group: "Paragraph"
 });
-const Gt = Array(6).fill(0).map((t, e) => e + 1), Vt = (t) => Pt(t.textContent), Y = ne(Vt, "headingIdGenerator");
-n(Y, {
+const Dt = Array(6).fill(0).map((t, e) => e + 1);
+function _t(t) {
+  return Ht(t.textContent);
+}
+const j = Xe(_t, "headingIdGenerator");
+n(j, {
   displayName: "Ctx<HeadingIdGenerator>",
   group: "Heading"
 });
-const Me = I("heading");
-n(Me, {
+const ce = N("heading");
+n(ce, {
   displayName: "Attr<heading>",
   group: "Heading"
 });
-const H = C("heading", (t) => {
-  const e = t.get(Y.key);
+const H = I("heading", (t) => {
+  const e = t.get(j.key);
   return {
     content: "inline*",
     group: "block",
@@ -378,18 +410,18 @@ const H = C("heading", (t) => {
         default: 1
       }
     },
-    parseDOM: Gt.map((r) => ({
+    parseDOM: Dt.map((r) => ({
       tag: `h${r}`,
       getAttrs: (a) => {
         if (!(a instanceof HTMLElement))
-          throw A(a);
+          throw w(a);
         return { level: r, id: a.id };
       }
     })),
     toDOM: (r) => [
       `h${r.attrs.level}`,
       {
-        ...t.get(Me.key)(r),
+        ...t.get(ce.key)(r),
         id: r.attrs.id || e(r)
       },
       0
@@ -404,7 +436,7 @@ const H = C("heading", (t) => {
     toMarkdown: {
       match: (r) => r.type.name === "heading",
       runner: (r, a) => {
-        r.openNode("heading", void 0, { depth: a.attrs.level }), mt(r, a), r.closeNode();
+        r.openNode("heading", void 0, { depth: a.attrs.level }), at(r, a), r.closeNode();
       }
     }
   };
@@ -417,110 +449,110 @@ n(H.ctx, {
   displayName: "NodeSchemaCtx<heading>",
   group: "Heading"
 });
-const yt = w((t) => lt(/^(?<hashes>#+)\s$/, H.type(t), (e) => {
-  var i, l;
-  const r = ((l = (i = e.groups) == null ? void 0 : i.hashes) == null ? void 0 : l.length) || 0, a = t.get(X), { $from: o } = a.state.selection, s = o.node();
+const pt = h((t) => Ze(/^(?<hashes>#+)\s$/, H.type(t), (e) => {
+  var l, i;
+  const r = ((i = (l = e.groups) == null ? void 0 : l.hashes) == null ? void 0 : i.length) || 0, a = t.get(wt), { $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 };
+    let d = Number(s.attrs.level) + Number(r);
+    return d > 6 && (d = 6), { level: d };
   }
   return { level: r };
 }));
-n(yt, {
+n(pt, {
   displayName: "InputRule<wrapInHeadingInputRule>",
   group: "Heading"
 });
-const b = y("WrapInHeading", (t) => (e) => (e ?? (e = 1), e < 1 ? E(v.type(t)) : E(H.type(t), { level: e })));
-n(b, {
+const L = c("WrapInHeading", (t) => (e) => (e ?? (e = 1), e < 1 ? K(A.type(t)) : K(H.type(t), { level: e })));
+n(L, {
   displayName: "Command<wrapInHeadingCommand>",
   group: "Heading"
 });
-const be = y("DowngradeHeading", (t) => () => (e, r, a) => {
+const ue = c("DowngradeHeading", (t) => () => (e, r, a) => {
   const { $from: o } = e.selection, s = o.node();
   if (s.type !== H.type(t) || !e.selection.empty || o.parentOffset !== 0)
     return !1;
-  const i = s.attrs.level - 1;
-  return i ? (r == null || r(
+  const l = s.attrs.level - 1;
+  return l ? (r == null || r(
     e.tr.setNodeMarkup(e.selection.$from.before(), void 0, {
       ...s.attrs,
-      level: i
+      level: l
     })
-  ), !0) : E(v.type(t))(e, r, a);
+  ), !0) : K(A.type(t))(e, r, a);
 });
-n(be, {
+n(ue, {
   displayName: "Command<downgradeHeadingCommand>",
   group: "Heading"
 });
-const Le = N("headingKeymap", {
+const ge = f("headingKeymap", {
   TurnIntoH1: {
     shortcuts: "Mod-Alt-1",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(b.key, 1);
+      const e = t.get(u);
+      return () => e.call(L.key, 1);
     }
   },
   TurnIntoH2: {
     shortcuts: "Mod-Alt-2",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(b.key, 2);
+      const e = t.get(u);
+      return () => e.call(L.key, 2);
     }
   },
   TurnIntoH3: {
     shortcuts: "Mod-Alt-3",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(b.key, 3);
+      const e = t.get(u);
+      return () => e.call(L.key, 3);
     }
   },
   TurnIntoH4: {
     shortcuts: "Mod-Alt-4",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(b.key, 4);
+      const e = t.get(u);
+      return () => e.call(L.key, 4);
     }
   },
   TurnIntoH5: {
     shortcuts: "Mod-Alt-5",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(b.key, 5);
+      const e = t.get(u);
+      return () => e.call(L.key, 5);
     }
   },
   TurnIntoH6: {
     shortcuts: "Mod-Alt-6",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(b.key, 6);
+      const e = t.get(u);
+      return () => e.call(L.key, 6);
     }
   },
   DowngradeHeading: {
     shortcuts: ["Delete", "Backspace"],
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(be.key);
+      const e = t.get(u);
+      return () => e.call(ue.key);
     }
   }
 });
-n(Le.ctx, {
+n(ge.ctx, {
   displayName: "KeymapCtx<heading>",
   group: "Heading"
 });
-n(Le.shortcuts, {
+n(ge.shortcuts, {
   displayName: "Keymap<heading>",
   group: "Heading"
 });
-const xe = I("blockquote");
-n(xe, {
+const ye = N("blockquote");
+n(ye, {
   displayName: "Attr<blockquote>",
   group: "Blockquote"
 });
-const W = C("blockquote", (t) => ({
+const q = I("blockquote", (t) => ({
   content: "block+",
   group: "block",
   defining: !0,
   parseDOM: [{ tag: "blockquote" }],
-  toDOM: (e) => ["blockquote", t.get(xe.key)(e), 0],
+  toDOM: (e) => ["blockquote", t.get(ye.key)(e), 0],
   parseMarkdown: {
     match: ({ type: e }) => e === "blockquote",
     runner: (e, r, a) => {
@@ -534,50 +566,50 @@ const W = C("blockquote", (t) => ({
     }
   }
 }));
-n(W.node, {
+n(q.node, {
   displayName: "NodeSchema<blockquote>",
   group: "Blockquote"
 });
-n(W.ctx, {
+n(q.ctx, {
   displayName: "NodeSchemaCtx<blockquote>",
   group: "Blockquote"
 });
-const ht = w((t) => le(/^\s*>\s$/, W.type(t)));
-n(ht, {
+const ct = h((t) => Q(/^\s*>\s$/, q.type(t)));
+n(ct, {
   displayName: "InputRule<wrapInBlockquoteInputRule>",
   group: "Blockquote"
 });
-const Se = y("WrapInBlockquote", (t) => () => se(W.type(t)));
-n(Se, {
+const ke = c("WrapInBlockquote", (t) => () => J(q.type(t)));
+n(ke, {
   displayName: "Command<wrapInBlockquoteCommand>",
   group: "Blockquote"
 });
-const we = N("blockquoteKeymap", {
+const he = f("blockquoteKeymap", {
   WrapInBlockquote: {
     shortcuts: "Mod-Shift-b",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Se.key);
+      const e = t.get(u);
+      return () => e.call(ke.key);
     }
   }
 });
-n(we.ctx, {
+n(he.ctx, {
   displayName: "KeymapCtx<blockquote>",
   group: "Blockquote"
 });
-n(we.shortcuts, {
+n(he.shortcuts, {
   displayName: "Keymap<blockquote>",
   group: "Blockquote"
 });
-const Ae = I("codeBlock", () => ({
+const fe = N("codeBlock", () => ({
   pre: {},
   code: {}
 }));
-n(Ae, {
+n(fe, {
   displayName: "Attr<codeBlock>",
   group: "CodeBlock"
 });
-const F = C("code_block", (t) => ({
+const W = I("code_block", (t) => ({
   content: "text*",
   group: "block",
   marks: "",
@@ -594,13 +626,13 @@ const F = C("code_block", (t) => ({
       preserveWhitespace: "full",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw A(e);
+          throw w(e);
         return { language: e.dataset.language };
       }
     }
   ],
   toDOM: (e) => {
-    const r = t.get(Ae.key)(e);
+    const r = t.get(fe.key)(e);
     return [
       "pre",
       {
@@ -627,57 +659,57 @@ const F = C("code_block", (t) => ({
     }
   }
 }));
-n(F.node, {
+n(W.node, {
   displayName: "NodeSchema<codeBlock>",
   group: "CodeBlock"
 });
-n(F.ctx, {
+n(W.ctx, {
   displayName: "NodeSchemaCtx<codeBlock>",
   group: "CodeBlock"
 });
-const kt = w((t) => lt(/^```(?<language>[a-z]*)?[\s\n]$/, F.type(t), (e) => {
+const ut = h((t) => Ze(/^```(?<language>[a-z]*)?[\s\n]$/, W.type(t), (e) => {
   var r;
   return {
     language: ((r = e.groups) == null ? void 0 : r.language) ?? ""
   };
 }));
-n(kt, {
+n(ut, {
   displayName: "InputRule<createCodeBlockInputRule>",
   group: "CodeBlock"
 });
-const ve = y("CreateCodeBlock", (t) => (e = "") => E(F.type(t), { language: e }));
-n(ve, {
+const Ne = c("CreateCodeBlock", (t) => (e = "") => K(W.type(t), { language: e }));
+n(Ne, {
   displayName: "Command<createCodeBlockCommand>",
   group: "CodeBlock"
 });
-const jt = y("UpdateCodeBlockLanguage", () => ({ pos: t, language: e } = { pos: -1, language: "" }) => (r, a) => t >= 0 ? (a == null || a(r.tr.setNodeAttribute(t, "language", e)), !0) : !1);
-n(jt, {
+const Et = c("UpdateCodeBlockLanguage", () => ({ pos: t, language: e } = { pos: -1, language: "" }) => (r, a) => t >= 0 ? (a == null || a(r.tr.setNodeAttribute(t, "language", e)), !0) : !1);
+n(Et, {
   displayName: "Command<updateCodeBlockLanguageCommand>",
   group: "CodeBlock"
 });
-const He = N("codeBlockKeymap", {
+const Ie = f("codeBlockKeymap", {
   CreateCodeBlock: {
     shortcuts: "Mod-Alt-c",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(ve.key);
+      const e = t.get(u);
+      return () => e.call(Ne.key);
     }
   }
 });
-n(He.ctx, {
+n(Ie.ctx, {
   displayName: "KeymapCtx<codeBlock>",
   group: "CodeBlock"
 });
-n(He.shortcuts, {
+n(Ie.shortcuts, {
   displayName: "Keymap<codeBlock>",
   group: "CodeBlock"
 });
-const Be = I("image");
-n(Be, {
+const Ce = N("image");
+n(Ce, {
   displayName: "Attr<image>",
   group: "Image"
 });
-const K = C("image", (t) => ({
+const v = I("image", (t) => ({
   inline: !0,
   group: "inline",
   selectable: !0,
@@ -696,7 +728,7 @@ const K = C("image", (t) => ({
       tag: "img[src]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw A(e);
+          throw w(e);
         return {
           src: e.getAttribute("src") || "",
           alt: e.getAttribute("alt") || "",
@@ -705,15 +737,15 @@ const K = C("image", (t) => ({
       }
     }
   ],
-  toDOM: (e) => ["img", { ...t.get(Be.key)(e), ...e.attrs }],
+  toDOM: (e) => ["img", { ...t.get(Ce.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: ({ type: e }) => e === "image",
     runner: (e, r, a) => {
-      const o = r.url, s = r.alt, i = r.title;
+      const o = r.url, s = r.alt, l = r.title;
       e.addNode(a, {
         src: o,
         alt: s,
-        title: i
+        title: l
       });
     }
   },
@@ -728,54 +760,54 @@ const K = C("image", (t) => ({
     }
   }
 }));
-n(K.node, {
+n(v.node, {
   displayName: "NodeSchema<image>",
   group: "Image"
 });
-n(K.ctx, {
+n(v.ctx, {
   displayName: "NodeSchemaCtx<image>",
   group: "Image"
 });
-const ft = y("InsertImage", (t) => (e = {}) => (r, a) => {
+const gt = c("InsertImage", (t) => (e = {}) => (r, a) => {
   if (!a)
     return !0;
-  const { src: o = "", alt: s = "", title: i = "" } = e, l = K.type(t).create({ src: o, alt: s, title: i });
-  return l && a(r.tr.replaceSelectionWith(l).scrollIntoView()), !0;
+  const { src: o = "", alt: s = "", title: l = "" } = e, i = v.type(t).create({ src: o, alt: s, title: l });
+  return i && a(r.tr.replaceSelectionWith(i).scrollIntoView()), !0;
 });
-n(ft, {
+n(gt, {
   displayName: "Command<insertImageCommand>",
   group: "Image"
 });
-const Nt = y("UpdateImage", (t) => (e = {}) => (r, a) => {
-  const o = _t(r.selection, K.type(t));
+const yt = c("UpdateImage", (t) => (e = {}) => (r, a) => {
+  const o = Bt(r.selection, v.type(t));
   if (!o)
     return !1;
-  const { node: s, pos: i } = o, l = { ...s.attrs }, { src: c, alt: d, title: m } = e;
-  return c !== void 0 && (l.src = c), d !== void 0 && (l.alt = d), m !== void 0 && (l.title = m), a == null || a(r.tr.setNodeMarkup(i, void 0, l).scrollIntoView()), !0;
+  const { node: s, pos: l } = o, i = { ...s.attrs }, { src: d, alt: m, title: p } = e;
+  return d !== void 0 && (i.src = d), m !== void 0 && (i.alt = m), p !== void 0 && (i.title = p), a == null || a(r.tr.setNodeMarkup(l, void 0, i).scrollIntoView()), !0;
 });
-n(Nt, {
+n(yt, {
   displayName: "Command<updateImageCommand>",
   group: "Image"
 });
-const zt = w((t) => new it(
+const Pt = h((t) => new et(
   /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
   (e, r, a, o) => {
-    const [s, i, l = "", c] = r;
-    return s ? e.tr.replaceWith(a, o, K.type(t).create({ src: l, alt: i, title: c })) : null;
+    const [s, l, i = "", d] = r;
+    return s ? e.tr.replaceWith(a, o, v.type(t).create({ src: i, alt: l, title: d })) : null;
   }
 ));
-n(zt, {
+n(Pt, {
   displayName: "InputRule<insertImageInputRule>",
   group: "Image"
 });
-const Oe = I("hardbreak", (t) => ({
+const Me = N("hardbreak", (t) => ({
   "data-is-inline": t.attrs.isInline
 }));
-n(Oe, {
+n(Me, {
   displayName: "Attr<hardbreak>",
   group: "Hardbreak"
 });
-const S = C("hardbreak", (t) => ({
+const S = I("hardbreak", (t) => ({
   inline: !0,
   group: "inline",
   attrs: {
@@ -785,7 +817,7 @@ const S = C("hardbreak", (t) => ({
   },
   selectable: !1,
   parseDOM: [{ tag: "br" }],
-  toDOM: (e) => ["br", t.get(Oe.key)(e)],
+  toDOM: (e) => ["br", t.get(Me.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "break",
     runner: (e, r, a) => {
@@ -811,50 +843,50 @@ n(S.ctx, {
   displayName: "NodeSchemaCtx<hardbreak>",
   group: "Hardbreak"
 });
-const Te = y("InsertHardbreak", (t) => () => (e, r) => {
+const be = c("InsertHardbreak", (t) => () => (e, r) => {
   var s;
   const { selection: a, tr: o } = e;
-  if (!(a instanceof $))
+  if (!(a instanceof X))
     return !1;
   if (a.empty) {
-    const i = a.$from.node();
-    if (i.childCount > 0 && ((s = i.lastChild) == null ? void 0 : s.type.name) === "hardbreak")
+    const l = a.$from.node();
+    if (l.childCount > 0 && ((s = l.lastChild) == null ? void 0 : s.type.name) === "hardbreak")
       return r == null || r(
-        o.replaceRangeWith(a.to - 1, a.to, e.schema.node("paragraph")).setSelection(ct.near(o.doc.resolve(a.to))).scrollIntoView()
+        o.replaceRangeWith(a.to - 1, a.to, e.schema.node("paragraph")).setSelection(tt.near(o.doc.resolve(a.to))).scrollIntoView()
       ), !0;
   }
   return r == null || r(o.setMeta("hardbreak", !0).replaceSelectionWith(S.type(t).create()).scrollIntoView()), !0;
 });
-n(Te, {
+n(be, {
   displayName: "Command<insertHardbreakCommand>",
   group: "Hardbreak"
 });
-const Re = N("hardbreakKeymap", {
+const Le = f("hardbreakKeymap", {
   InsertHardbreak: {
     shortcuts: "Shift-Enter",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Te.key);
+      const e = t.get(u);
+      return () => e.call(be.key);
     }
   }
 });
-n(Re.ctx, {
+n(Le.ctx, {
   displayName: "KeymapCtx<hardbreak>",
   group: "Hardbreak"
 });
-n(Re.shortcuts, {
+n(Le.shortcuts, {
   displayName: "Keymap<hardbreak>",
   group: "Hardbreak"
 });
-const Ke = I("hr");
-n(Ke, {
+const xe = N("hr");
+n(xe, {
   displayName: "Attr<hr>",
   group: "Hr"
 });
-const G = C("hr", (t) => ({
+const F = I("hr", (t) => ({
   group: "block",
   parseDOM: [{ tag: "hr" }],
-  toDOM: (e) => ["hr", t.get(Ke.key)(e)],
+  toDOM: (e) => ["hr", t.get(xe.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "thematicBreak",
     runner: (e, r, a) => {
@@ -868,44 +900,44 @@ const G = C("hr", (t) => ({
     }
   }
 }));
-n(G.node, {
+n(F.node, {
   displayName: "NodeSchema<hr>",
   group: "Hr"
 });
-n(G.ctx, {
+n(F.ctx, {
   displayName: "NodeSchemaCtx<hr>",
   group: "Hr"
 });
-const It = w((t) => new it(
+const kt = h((t) => new et(
   /^(?:---|___\s|\*\*\*\s)$/,
   (e, r, a, o) => {
     const { tr: s } = e;
-    return r[0] && s.replaceWith(a - 1, o, G.type(t).create()), s;
+    return r[0] && s.replaceWith(a - 1, o, F.type(t).create()), s;
   }
 ));
-n(It, {
+n(kt, {
   displayName: "InputRule<insertHrInputRule>",
   group: "Hr"
 });
-const Ct = y("InsertHr", (t) => () => (e, r) => {
+const ht = c("InsertHr", (t) => () => (e, r) => {
   if (!r)
     return !0;
-  const a = v.node.type(t).create(), { tr: o, selection: s } = e, { from: i } = s, l = G.type(t).create();
-  if (!l)
+  const a = A.node.type(t).create(), { tr: o, selection: s } = e, { from: l } = s, i = F.type(t).create();
+  if (!i)
     return !0;
-  const c = o.replaceSelectionWith(l).insert(i, a), d = ct.findFrom(c.doc.resolve(i), 1, !0);
-  return d && r(c.setSelection(d).scrollIntoView()), !0;
+  const d = o.replaceSelectionWith(i).insert(l, a), m = tt.findFrom(d.doc.resolve(l), 1, !0);
+  return m && r(d.setSelection(m).scrollIntoView()), !0;
 });
-n(Ct, {
+n(ht, {
   displayName: "Command<insertHrCommand>",
   group: "Hr"
 });
-const De = I("bulletList");
-n(De, {
+const Se = N("bulletList");
+n(Se, {
   displayName: "Attr<bulletList>",
   group: "BulletList"
 });
-const D = C("bullet_list", (t) => ({
+const O = I("bullet_list", (t) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -918,7 +950,7 @@ const D = C("bullet_list", (t) => ({
       tag: "ul",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw A(e);
+          throw w(e);
         return {
           spread: e.dataset.spread
         };
@@ -928,7 +960,7 @@ const D = C("bullet_list", (t) => ({
   toDOM: (e) => [
     "ul",
     {
-      ...t.get(De.key)(e),
+      ...t.get(Se.key)(e),
       "data-spread": e.attrs.spread
     },
     0
@@ -947,47 +979,47 @@ const D = C("bullet_list", (t) => ({
     }
   }
 }));
-n(D.node, {
+n(O.node, {
   displayName: "NodeSchema<bulletList>",
   group: "BulletList"
 });
-n(D.ctx, {
+n(O.ctx, {
   displayName: "NodeSchemaCtx<bulletList>",
   group: "BulletList"
 });
-const Mt = w((t) => le(/^\s*([-+*])\s$/, D.type(t)));
-n(Mt, {
+const ft = h((t) => Q(/^\s*([-+*])\s$/, O.type(t)));
+n(ft, {
   displayName: "InputRule<wrapInBulletListInputRule>",
   group: "BulletList"
 });
-const Pe = y("WrapInBulletList", (t) => () => se(D.type(t)));
-n(Pe, {
+const we = c("WrapInBulletList", (t) => () => J(O.type(t)));
+n(we, {
   displayName: "Command<wrapInBulletListCommand>",
   group: "BulletList"
 });
-const _e = N("bulletListKeymap", {
+const Ae = f("bulletListKeymap", {
   WrapInBulletList: {
     shortcuts: "Mod-Alt-8",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Pe.key);
+      const e = t.get(u);
+      return () => e.call(we.key);
     }
   }
 });
-n(_e.ctx, {
+n(Ae.ctx, {
   displayName: "KeymapCtx<bulletListKeymap>",
   group: "BulletList"
 });
-n(_e.shortcuts, {
+n(Ae.shortcuts, {
   displayName: "Keymap<bulletListKeymap>",
   group: "BulletList"
 });
-const Ee = I("orderedList");
-n(Ee, {
+const He = N("orderedList");
+n(He, {
   displayName: "Attr<orderedList>",
   group: "OrderedList"
 });
-const P = C("ordered_list", (t) => ({
+const T = I("ordered_list", (t) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -1003,7 +1035,7 @@ const P = C("ordered_list", (t) => ({
       tag: "ol",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw A(e);
+          throw w(e);
         return {
           spread: e.dataset.spread,
           order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
@@ -1014,7 +1046,7 @@ const P = C("ordered_list", (t) => ({
   toDOM: (e) => [
     "ol",
     {
-      ...t.get(Ee.key)(e),
+      ...t.get(He.key)(e),
       ...e.attrs.order === 1 ? {} : e.attrs.order,
       "data-spread": e.attrs.spread
     },
@@ -1034,52 +1066,52 @@ const P = C("ordered_list", (t) => ({
     }
   }
 }));
-n(P.node, {
+n(T.node, {
   displayName: "NodeSchema<orderedList>",
   group: "OrderedList"
 });
-n(P.ctx, {
+n(T.ctx, {
   displayName: "NodeSchemaCtx<orderedList>",
   group: "OrderedList"
 });
-const bt = w((t) => le(
+const Nt = h((t) => Q(
   /^\s*(\d+)\.\s$/,
-  P.type(t),
+  T.type(t),
   (e) => ({ order: Number(e[1]) }),
   (e, r) => r.childCount + r.attrs.order === Number(e[1])
 ));
-n(bt, {
+n(Nt, {
   displayName: "InputRule<wrapInOrderedListInputRule>",
   group: "OrderedList"
 });
-const $e = y("WrapInOrderedList", (t) => () => se(P.type(t)));
-n($e, {
+const Be = c("WrapInOrderedList", (t) => () => J(T.type(t)));
+n(Be, {
   displayName: "Command<wrapInOrderedListCommand>",
   group: "OrderedList"
 });
-const qe = N("orderedListKeymap", {
+const Re = f("orderedListKeymap", {
   WrapInOrderedList: {
     shortcuts: "Mod-Alt-7",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call($e.key);
+      const e = t.get(u);
+      return () => e.call(Be.key);
     }
   }
 });
-n(qe.ctx, {
+n(Re.ctx, {
   displayName: "KeymapCtx<orderedList>",
   group: "OrderedList"
 });
-n(qe.shortcuts, {
+n(Re.shortcuts, {
   displayName: "Keymap<orderedList>",
   group: "OrderedList"
 });
-const We = I("listItem");
-n(We, {
+const ve = N("listItem");
+n(ve, {
   displayName: "Attr<listItem>",
   group: "ListItem"
 });
-const M = C("list_item", (t) => ({
+const M = I("list_item", (t) => ({
   group: "listItem",
   content: "paragraph block*",
   attrs: {
@@ -1099,7 +1131,7 @@ const M = C("list_item", (t) => ({
       tag: "li",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw A(e);
+          throw w(e);
         return {
           label: e.dataset.label,
           listType: e.dataset["list-type"],
@@ -1111,7 +1143,7 @@ const M = C("list_item", (t) => ({
   toDOM: (e) => [
     "li",
     {
-      ...t.get(We.key)(e),
+      ...t.get(ve.key)(e),
       "data-label": e.attrs.label,
       "data-list-type": e.attrs.listType,
       "data-spread": e.attrs.spread
@@ -1121,8 +1153,8 @@ const M = C("list_item", (t) => ({
   parseMarkdown: {
     match: ({ type: e }) => e === "listItem",
     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();
+      const o = r.label != null ? `${r.label}.` : "•", s = r.label != null ? "ordered" : "bullet", l = r.spread != null ? `${r.spread}` : "true";
+      e.openNode(a, { label: o, listType: s, spread: l }), e.next(r.children), e.closeNode();
     }
   },
   toMarkdown: {
@@ -1140,74 +1172,77 @@ n(M.ctx, {
   displayName: "NodeSchemaCtx<listItem>",
   group: "ListItem"
 });
-const Fe = y("SinkListItem", (t) => () => Et(M.type(t)));
-n(Fe, {
+const Oe = c("SinkListItem", (t) => () => Rt(M.type(t)));
+n(Oe, {
   displayName: "Command<sinkListItemCommand>",
   group: "ListItem"
 });
-const Ge = y("SplitListItem", (t) => () => dt(M.type(t)));
-n(Ge, {
+const Te = c("SplitListItem", (t) => () => rt(M.type(t)));
+n(Te, {
   displayName: "Command<liftListItemCommand>",
   group: "ListItem"
 });
-const Ve = y("SplitListItem", (t) => () => $t(M.type(t)));
-n(Ve, {
+const Ke = c("SplitListItem", (t) => () => vt(M.type(t)));
+n(Ke, {
   displayName: "Command<splitListItemCommand>",
   group: "ListItem"
 });
-const Ut = (t) => (e, r, a) => {
-  const { selection: o } = e;
-  if (!(o instanceof $))
-    return !1;
-  const { empty: s, $from: i } = o;
-  if (!s || i.parentOffset !== 0)
-    return !1;
-  const l = i.node(-1);
-  return l.type !== M.type(t) || l.firstChild !== i.node() || i.node(-2).childCount > 1 ? !1 : dt(M.type(t))(e, r, a);
-}, je = y("LiftFirstListItem", (t) => () => Ut(t));
-n(je, {
+function $t(t) {
+  return (e, r, a) => {
+    const { selection: o } = e;
+    if (!(o instanceof X))
+      return !1;
+    const { empty: s, $from: l } = o;
+    if (!s || l.parentOffset !== 0)
+      return !1;
+    const i = l.node(-1);
+    return i.type !== M.type(t) || i.firstChild !== l.node() || l.node(-2).childCount > 1 ? !1 : rt(M.type(t))(e, r, a);
+  };
+}
+const De = c("LiftFirstListItem", (t) => () => $t(t));
+n(De, {
   displayName: "Command<liftFirstListItemCommand>",
   group: "ListItem"
 });
-const ze = N("listItemKeymap", {
+const _e = f("listItemKeymap", {
   NextListItem: {
     shortcuts: "Enter",
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Ve.key);
+      const e = t.get(u);
+      return () => e.call(Ke.key);
     }
   },
   SinkListItem: {
     shortcuts: ["Tab", "Mod-]"],
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Fe.key);
+      const e = t.get(u);
+      return () => e.call(Oe.key);
     }
   },
   LiftListItem: {
     shortcuts: ["Shift-Tab", "Mod-["],
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(Ge.key);
+      const e = t.get(u);
+      return () => e.call(Te.key);
     }
   },
   LiftFirstListItem: {
     shortcuts: ["Backspace", "Delete"],
     command: (t) => {
-      const e = t.get(h);
-      return () => e.call(je.key);
+      const e = t.get(u);
+      return () => e.call(De.key);
     }
   }
 });
-n(ze.ctx, {
+n(_e.ctx, {
   displayName: "KeymapCtx<listItem>",
   group: "ListItem"
 });
-n(ze.shortcuts, {
+n(_e.shortcuts, {
   displayName: "Keymap<listItem>",
   group: "ListItem"
 });
-const Lt = ot("text", () => ({
+const It = Qe("text", () => ({
   group: "inline",
   parseMarkdown: {
     match: ({ type: t }) => t === "text",
@@ -1222,16 +1257,16 @@ const Lt = ot("text", () => ({
     }
   }
 }));
-n(Lt, {
+n(It, {
   displayName: "NodeSchema<text>",
   group: "Text"
 });
-const Ue = I("html");
-n(Ue, {
+const Ee = N("html");
+n(Ee, {
   displayName: "Attr<html>",
   group: "Html"
 });
-const Ye = C("html", (t) => ({
+const Pe = I("html", (t) => ({
   atom: !0,
   group: "inline",
   inline: !0,
@@ -1242,7 +1277,7 @@ const Ye = C("html", (t) => ({
   },
   toDOM: (e) => {
     const r = document.createElement("span"), a = {
-      ...t.get(Ue.key)(e),
+      ...t.get(Ee.key)(e),
       "data-value": e.attrs.value,
       "data-type": "html"
     };
@@ -1267,218 +1302,95 @@ const Ye = C("html", (t) => ({
     }
   }
 }));
-n(Ye.node, {
+n(Pe.node, {
   displayName: "NodeSchema<html>",
   group: "Html"
 });
-n(Ye.ctx, {
+n(Pe.ctx, {
   displayName: "NodeSchemaCtx<html>",
   group: "Html"
 });
-const Yt = [
-  gt,
-  Ne,
-  v,
-  Y,
-  Me,
+const qt = [
+  mt,
+  de,
+  A,
+  j,
+  ce,
   H,
-  Oe,
+  Me,
   S,
-  xe,
+  ye,
+  q,
+  fe,
   W,
-  Ae,
+  xe,
   F,
-  Ke,
-  G,
-  Be,
-  K,
-  De,
-  D,
-  Ee,
-  P,
-  We,
+  Ce,
+  v,
+  Se,
+  O,
+  He,
+  T,
+  ve,
   M,
-  ce,
-  z,
-  ue,
-  U,
-  ye,
+  Z,
+  R,
+  re,
+  $,
+  oe,
   x,
-  fe,
+  ie,
   B,
-  Ue,
-  Ye,
-  Lt
-].flat(), Zt = [
-  ht,
-  Mt,
-  bt,
-  kt,
-  It,
-  yt
-].flat(), Jt = [
-  Ie,
-  Se,
-  b,
-  be,
-  ve,
-  Te,
-  Ct,
+  Ee,
+  Pe,
+  It
+].flat(), Wt = [
+  ct,
   ft,
   Nt,
-  $e,
-  Pe,
-  Fe,
-  Ve,
-  Ge,
-  je,
-  de,
-  he,
-  pe,
   ut,
+  kt,
   pt
-], Qt = [
+].flat(), Ft = [
+  nt,
+  ot,
+  lt,
+  st
+], Vt = [
+  me,
+  ke,
+  L,
+  ue,
+  Ne,
+  be,
+  ht,
+  gt,
+  yt,
+  Be,
   we,
-  He,
-  Re,
+  Oe,
+  Ke,
+  Te,
+  De,
+  ee,
+  se,
+  ae,
+  it,
+  dt
+], Ut = [
+  he,
+  Ie,
   Le,
-  ze,
-  qe,
+  ge,
   _e,
-  Ce,
-  me,
-  ke,
-  ge
-].flat(), Xt = /\[([^\]]+)]\([^\s\]]+\)/, Q = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, er = (t) => new RegExp(`\\\\(?=[^\\w\\s${t}\\\\]|_)`, "g"), Z = "​", ee = `${Z}*`, te = `${Z}＊`, re = `${Z}_`, ae = `${Z}⎽`, tr = (t) => {
-  let e = t, r = e.match(Q);
-  for (; r && r.groups; ) {
-    const { span: a } = r.groups;
-    e = e.replace(Q, a), r = e.match(Q);
-  }
-  return e;
-}, rr = (t) => t.replaceAll(/\\\\\*/g, ee).replaceAll(/\\\\_/g, re).replaceAll(ee, te).replaceAll(re, ae), ar = (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();
-}, nr = (t) => (e) => e.replace(er(t), ""), or = (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;
-}, sr = (t, e, r) => {
-  let a = e, o = !1;
-  return t.descendants((s) => {
-    var i;
-    if (o)
-      return !1;
-    if (!s.textContent.includes(r))
-      return a += s.nodeSize, !1;
-    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;
-    }
-    return a += 1, !0;
-  }), a;
-}, lr = {
-  placeholderConfig: {
-    hole: "∅",
-    punctuation: "⁂",
-    char: "∴"
-  },
-  globalNodes: ["footnote_definition"],
-  shouldSyncNode: ({ prevNode: t, nextNode: e }) => t.inlineContent && e && t.type === e.type && !t.eq(e),
-  movePlaceholder: (t, e) => {
-    const r = ["*", "_"];
-    let a = e.indexOf(t);
-    for (; r.includes(e[a - 1] || "") && r.includes(e[a + 1] || ""); )
-      e = ar(e, a, a + 1), a = a + 1;
-    return e;
-  }
-}, _ = ne(lr, "inlineSyncConfig");
-n(_, {
-  displayName: "Ctx<inlineSyncConfig>",
-  group: "Prose"
-});
-const ir = (t) => t.selection.$from.node(), cr = (t, e, r, a) => {
-  const o = t.get(Rt), s = e.schema.topNodeType.create(void 0, [r, ...a]);
-  return o(s);
-}, dr = (t, e) => {
-  const r = t.get(_.key), a = r.placeholderConfig.hole, [o = "", ...s] = e.split(`
-
-`), i = (m) => r.movePlaceholder(a, m);
-  let c = Tt(nr(a), i, tr, rr)(o);
-  const d = or(r.placeholderConfig)(c);
-  return c = c.replace(a, d), c = [c, ...s].join(`
-
-`), [c, d];
-}, mr = (t, e) => {
-  const a = t.get(Kt)(e);
-  return a ? a.firstChild : null;
-}, ur = (t, e) => {
-  const { globalNodes: r } = t.get(_.key), a = [];
-  return e.doc.descendants((o) => {
-    if (r.includes(o.type.name) || r.includes(o.type))
-      return a.push(o), !1;
-  }), a;
-}, pr = (t) => t.split(`
-
-`)[0] || "", gr = (t) => t.childCount === 1 && t.child(0).type.name === "html", xt = (t, e) => {
-  try {
-    const r = ur(t, e), a = ir(e), o = cr(t, e, a, r), [s, i] = dr(t, o), l = mr(t, s);
-    return !l || a.type !== l.type || gr(l) ? null : (l.attrs = { ...a.attrs }, l.descendants((c) => {
-      var g, u, k;
-      const m = c.marks.find((p) => p.type.name === "link");
-      m && ((g = c.text) != null && g.includes(i)) && m.attrs.href.includes(i) && (m.attrs.href = m.attrs.href.replace(i, "")), ((u = c.text) != null && u.includes(te) || (k = c.text) != null && k.includes(ae)) && (c.text = c.text.replaceAll(te, ee).replaceAll(ae, re));
-    }), {
-      text: pr(s),
-      prevNode: a,
-      nextNode: l,
-      placeholder: i
-    });
-  } catch {
-    return null;
-  }
-}, yr = (t, e, r, a, o) => {
-  var L;
-  const { placeholderConfig: s } = t.get(_.key), i = s.hole;
-  let l = r.tr.setMeta(e, !0).insertText(i, r.selection.from);
-  const c = r.apply(l), d = xt(t, c);
-  if (!d)
-    return;
-  const m = d.text.slice(0, d.text.indexOf(d.placeholder)), { $from: g } = c.selection, u = g.before(), k = g.after(), p = sr(d.nextNode, u, d.placeholder);
-  l = l.replaceWith(u, k, d.nextNode).setNodeMarkup(u, void 0, o).delete(p + 1, p + 2), l = l.setSelection($.near(l.doc.resolve(p + 1))), (Xt.test(m) || ["*", "_", "~"].includes(m.at(-1) || "")) && l.selection instanceof $ && (((L = l.selection.$cursor) == null ? void 0 : L.marks()) ?? []).forEach((J) => {
-    l = l.removeStoredMark(J.type);
-  }), a(l);
-}, St = O((t) => {
-  let e = null;
-  const r = new T("MILKDOWN_INLINE_SYNC");
-  return new R({
-    key: r,
-    state: {
-      init: () => null,
-      apply: (a, o, s, i) => {
-        var p;
-        const l = t.get(X);
-        if (!((p = l.hasFocus) != null && p.call(l)) || !l.editable || !a.docChanged || a.getMeta(r))
-          return null;
-        const d = xt(t, i);
-        if (!d)
-          return null;
-        e && (cancelAnimationFrame(e), e = null);
-        const { prevNode: m, nextNode: g, text: u } = d, { shouldSyncNode: k } = t.get(_.key);
-        return k({ prevNode: m, nextNode: g, ctx: t, tr: a, text: u }) && (e = requestAnimationFrame(() => {
-          e = null;
-          const { dispatch: f, state: L } = t.get(X);
-          yr(t, r, L, f, m.attrs);
-        })), null;
-      }
-    }
-  });
-});
-n(St, {
-  displayName: "Prose<inlineSyncPlugin>",
-  group: "Prose"
-});
-const Ze = q("remarkAddOrderInList", () => () => (t) => {
-  ie(t, "list", (e) => {
+  Re,
+  Ae,
+  pe,
+  te,
+  le,
+  ne
+].flat(), $e = D("remarkAddOrderInList", () => () => (t) => {
+  Y(t, "list", (e) => {
     if (e.ordered) {
       const r = e.start ?? 1;
       e.children.forEach((a, o) => {
@@ -1487,98 +1399,98 @@ const Ze = q("remarkAddOrderInList", () => () => (t) => {
     }
   });
 });
-n(Ze.plugin, {
+n($e.plugin, {
   displayName: "Remark<remarkAddOrderInListPlugin>",
   group: "Remark"
 });
-n(Ze.options, {
+n($e.options, {
   displayName: "RemarkConfig<remarkAddOrderInListPlugin>",
   group: "Remark"
 });
-const Je = q("remarkLineBreak", () => () => (t) => {
+const qe = D("remarkLineBreak", () => () => (t) => {
   const e = /[\t ]*(?:\r?\n|\r)/g;
-  ie(t, "text", (r, a, o) => {
+  Y(t, "text", (r, a, o) => {
     if (!r.value || typeof r.value != "string")
       return;
     const s = [];
-    let i = 0;
+    let l = 0;
     e.lastIndex = 0;
-    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);
+    let i = e.exec(r.value);
+    for (; i; ) {
+      const m = i.index;
+      l !== m && s.push({ type: "text", value: r.value.slice(l, m) }), s.push({ type: "break", data: { isInline: !0 } }), l = m + i[0].length, i = e.exec(r.value);
     }
     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;
+      return l < r.value.length && s.push({ type: "text", value: r.value.slice(l) }), o.children.splice(a, 1, ...s), a + s.length;
   });
 });
-n(Je.plugin, {
+n(qe.plugin, {
   displayName: "Remark<remarkLineBreak>",
   group: "Remark"
 });
-n(Je.options, {
+n(qe.options, {
   displayName: "RemarkConfig<remarkLineBreak>",
   group: "Remark"
 });
-const Qe = q("remarkInlineLink", () => Ft);
-n(Qe.plugin, {
+const We = D("remarkInlineLink", () => Kt);
+n(We.plugin, {
   displayName: "Remark<remarkInlineLinkPlugin>",
   group: "Remark"
 });
-n(Qe.options, {
+n(We.options, {
   displayName: "RemarkConfig<remarkInlineLinkPlugin>",
   group: "Remark"
 });
-const hr = (t) => !!t.children, kr = (t) => t.type === "html";
-function fr(t, e) {
+const Gt = (t) => !!t.children, jt = (t) => t.type === "html";
+function zt(t, e) {
   return r(t, 0, null)[0];
   function r(a, o, s) {
-    if (hr(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 g = 0, u = m.length; g < u; g++) {
-              const k = m[g];
-              k && i.push(k);
+    if (Gt(a)) {
+      const l = [];
+      for (let i = 0, d = a.children.length; i < d; i++) {
+        const m = a.children[i];
+        if (m) {
+          const p = r(m, i, a);
+          if (p)
+            for (let k = 0, g = p.length; k < g; k++) {
+              const C = p[k];
+              C && l.push(C);
             }
         }
       }
-      a.children = i;
+      a.children = l;
     }
     return e(a, o, s);
   }
 }
-const Xe = q("remarkHTMLTransformer", () => () => (t) => {
-  fr(t, (e, r, a) => kr(e) ? ((a == null ? void 0 : a.type) === "root" && (e.children = [{ ...e }], delete e.value, e.type = "paragraph"), [e]) : [e]);
+const Fe = D("remarkHTMLTransformer", () => () => (t) => {
+  zt(t, (e, r, a) => jt(e) ? ((a == null ? void 0 : a.type) === "root" && (e.children = [{ ...e }], delete e.value, e.type = "paragraph"), [e]) : [e]);
 });
-n(Xe.plugin, {
+n(Fe.plugin, {
   displayName: "Remark<remarkHtmlTransformer>",
   group: "Remark"
 });
-n(Xe.options, {
+n(Fe.options, {
   displayName: "RemarkConfig<remarkHtmlTransformer>",
   group: "Remark"
 });
-const et = q("remarkMarker", () => () => (t, e) => {
+const Ve = D("remarkMarker", () => () => (t, e) => {
   const r = (a) => e.value.charAt(a.position.start.offset);
-  ie(t, (a) => ["strong", "emphasis"].includes(a.type), (a) => {
+  Y(t, (a) => ["strong", "emphasis"].includes(a.type), (a) => {
     a.marker = r(a);
   });
 });
-n(et.plugin, {
+n(Ve.plugin, {
   displayName: "Remark<remarkMarker>",
   group: "Remark"
 });
-n(et.options, {
+n(Ve.options, {
   displayName: "RemarkConfig<remarkMarker>",
   group: "Remark"
 });
-const wt = O(() => {
+const Ct = _(() => {
   let t = !1;
-  const e = new T("MILKDOWN_INLINE_NODES_CURSOR"), r = new R({
+  const e = new E("MILKDOWN_INLINE_NODES_CURSOR"), r = new P({
     key: e,
     state: {
       init() {
@@ -1587,48 +1499,48 @@ const wt = O(() => {
       apply(a) {
         if (!a.selection.empty)
           return !1;
-        const o = a.selection.$from, s = o.nodeBefore, i = o.nodeAfter;
-        return !!(s && i && s.isInline && !s.isText && i.isInline && !i.isText);
+        const o = a.selection.$from, s = o.nodeBefore, l = o.nodeAfter;
+        return !!(s && l && s.isInline && !s.isText && l.isInline && !l.isText);
       }
     },
     props: {
       handleDOMEvents: {
         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));
+            const l = a.state.selection.from;
+            o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", l));
           }
         }), !0) : !1,
         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;
+            const l = a.state.selection.from;
+            return o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", l)), !0;
           }
           return !1;
         }
       },
       decorations(a) {
         if (r.getState(a)) {
-          const i = a.selection.$from.pos, l = document.createElement("span"), c = at.widget(i, l, {
+          const l = a.selection.$from.pos, i = document.createElement("span"), d = ze.widget(l, i, {
             side: -1
-          }), d = document.createElement("span"), m = at.widget(i, d);
+          }), m = document.createElement("span"), p = ze.widget(l, m);
           return setTimeout(() => {
-            l.contentEditable = "true", d.contentEditable = "true";
-          }), nt.create(a.doc, [c, m]);
+            i.contentEditable = "true", m.contentEditable = "true";
+          }), Je.create(a.doc, [d, p]);
         }
-        return nt.empty;
+        return Je.empty;
       }
     }
   });
   return r;
 });
-n(wt, {
+n(Ct, {
   displayName: "Prose<inlineNodesCursorPlugin>",
   group: "Prose"
 });
-const At = O((t) => new R({
-  key: new T("MILKDOWN_HARDBREAK_MARKS"),
+const Mt = _((t) => new P({
+  key: new E("MILKDOWN_HARDBREAK_MARKS"),
   appendTransaction: (e, r, a) => {
     if (!e.length)
       return;
@@ -1637,69 +1549,69 @@ const At = O((t) => new R({
       return;
     const [s] = o.steps;
     if (o.getMeta("hardbreak")) {
-      if (!(s instanceof qt))
+      if (!(s instanceof Ot))
         return;
-      const { from: c } = s;
-      return a.tr.setNodeMarkup(c, S.type(t), void 0, []);
+      const { from: d } = s;
+      return a.tr.setNodeMarkup(d, S.type(t), void 0, []);
     }
-    if (s instanceof Wt) {
-      let c = a.tr;
-      const { from: d, to: m } = s;
-      return a.doc.nodesBetween(d, m, (g, u) => {
-        g.type === S.type(t) && (c = c.setNodeMarkup(u, S.type(t), void 0, []));
-      }), c;
+    if (s instanceof Tt) {
+      let d = a.tr;
+      const { from: m, to: p } = s;
+      return a.doc.nodesBetween(m, p, (k, g) => {
+        k.type === S.type(t) && (d = d.setNodeMarkup(g, S.type(t), void 0, []));
+      }), d;
     }
   }
 }));
-n(At, {
+n(Mt, {
   displayName: "Prose<hardbreakClearMarkPlugin>",
   group: "Prose"
 });
-const tt = ne(["table", "code_block"], "hardbreakFilterNodes");
-n(tt, {
+const Ue = Xe(["table", "code_block"], "hardbreakFilterNodes");
+n(Ue, {
   displayName: "Ctx<hardbreakFilterNodes>",
   group: "Prose"
 });
-const vt = O((t) => {
-  const e = t.get(tt.key);
-  return new R({
-    key: new T("MILKDOWN_HARDBREAK_FILTER"),
+const bt = _((t) => {
+  const e = t.get(Ue.key);
+  return new P({
+    key: new E("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(l.node(c).type.name) && (d = !1), c--;
-        return d;
+        const { from: l } = s, i = a.doc.resolve(l);
+        let d = i.depth, m = !0;
+        for (; d > 0; )
+          e.includes(i.node(d).type.name) && (m = !1), d--;
+        return m;
       }
       return !0;
     }
   });
 });
-n(vt, {
+n(bt, {
   displayName: "Prose<hardbreakFilterPlugin>",
   group: "Prose"
 });
-const Ht = O((t) => {
-  const e = new T("MILKDOWN_HEADING_ID"), r = (a) => {
+const Lt = _((t) => {
+  const e = new E("MILKDOWN_HEADING_ID"), r = (a) => {
     if (a.composing || !a.editable)
       return;
-    const o = t.get(Y.key), s = a.state.tr.setMeta("addToHistory", !1);
-    let i = !1;
-    a.state.doc.descendants((l, c) => {
-      if (l.type === H.type(t)) {
-        if (l.textContent.trim().length === 0)
+    const o = t.get(j.key), s = a.state.tr.setMeta("addToHistory", !1);
+    let l = !1;
+    a.state.doc.descendants((i, d) => {
+      if (i.type === H.type(t)) {
+        if (i.textContent.trim().length === 0)
           return;
-        const d = l.attrs, m = o(l);
-        d.id !== m && (i = !0, s.setMeta(e, !0).setNodeMarkup(c, void 0, {
-          ...d,
-          id: m
+        const m = i.attrs, p = o(i);
+        m.id !== p && (l = !0, s.setMeta(e, !0).setNodeMarkup(d, void 0, {
+          ...m,
+          id: p
         }));
       }
-    }), i && a.dispatch(s);
+    }), l && a.dispatch(s);
   };
-  return new R({
+  return new P({
     key: e,
     view: (a) => (r(a), {
       update: (o) => {
@@ -1708,39 +1620,39 @@ const Ht = O((t) => {
     })
   });
 });
-n(Ht, {
+n(Lt, {
   displayName: "Prose<syncHeadingIdPlugin>",
   group: "Prose"
 });
-const Bt = O((t) => {
+const xt = _((t) => {
   const e = (r) => {
     if (r.composing || !r.editable)
       return;
-    const a = P.type(t), o = D.type(t), s = M.type(t), i = r.state, l = (m, g) => {
-      let u = !1;
-      const k = `${g + 1}.`;
-      return m.label !== k && (m.label = k, u = !0), u;
+    const a = T.type(t), o = O.type(t), s = M.type(t), l = r.state, i = (p, k) => {
+      let g = !1;
+      const C = `${k + 1}.`;
+      return p.label !== C && (p.label = C, g = !0), g;
     };
-    let c = i.tr, d = !1;
-    i.doc.descendants((m, g, u, k) => {
-      if (m.type === o) {
-        const p = m.maybeChild(0);
-        (p == null ? void 0 : p.type) === s && p.attrs.listType === "ordered" && (d = !0, c.setNodeMarkup(g, a, { spread: "true" }), m.descendants((f, L, Ot, J) => {
-          if (f.type === s) {
-            const rt = { ...f.attrs };
-            l(rt, J) && (c = c.setNodeMarkup(L, void 0, rt));
+    let d = l.tr, m = !1;
+    l.doc.descendants((p, k, g, C) => {
+      if (p.type === o) {
+        const y = p.maybeChild(0);
+        (y == null ? void 0 : y.type) === s && y.attrs.listType === "ordered" && (m = !0, d.setNodeMarkup(k, a, { spread: "true" }), p.descendants((b, Ge, Qt, St) => {
+          if (b.type === s) {
+            const je = { ...b.attrs };
+            i(je, St) && (d = d.setNodeMarkup(Ge, void 0, je));
           }
           return !1;
         }));
-      } else if (m.type === s && (u == null ? void 0 : u.type) === a) {
-        const p = { ...m.attrs };
-        let f = !1;
-        p.listType !== "ordered" && (p.listType = "ordered", f = !0), (u == null ? void 0 : u.maybeChild(0)) && (f = l(p, k)), f && (c = c.setNodeMarkup(g, void 0, p), d = !0);
+      } else if (p.type === s && (g == null ? void 0 : g.type) === a) {
+        const y = { ...p.attrs };
+        let b = !1;
+        y.listType !== "ordered" && (y.listType = "ordered", b = !0), (g == null ? void 0 : g.maybeChild(0)) && (b = i(y, C)), b && (d = d.setNodeMarkup(k, void 0, y), m = !0);
       }
-    }), d && r.dispatch(c.setMeta("addToHistory", !1));
+    }), m && r.dispatch(d.setMeta("addToHistory", !1));
   };
-  return new R({
-    key: new T("MILKDOWN_KEEP_LIST_ORDER"),
+  return new P({
+    key: new E("MILKDOWN_KEEP_LIST_ORDER"),
     view: (r) => (e(r), {
       update: (a) => {
         e(a);
@@ -1748,117 +1660,117 @@ const Bt = O((t) => {
     })
   });
 });
-n(Bt, {
+n(xt, {
   displayName: "Prose<syncListOrderPlugin>",
   group: "Prose"
 });
-const Nr = [
-  _,
-  St,
-  At,
-  tt,
-  vt,
-  wt,
-  Ze,
-  Qe,
-  Je,
-  Xe,
-  et,
-  Ht,
-  Bt
-].flat(), Kr = [Yt, Zt, Jt, Qt, Nr].flat();
+const Jt = [
+  Mt,
+  Ue,
+  bt,
+  Ct,
+  $e,
+  We,
+  qe,
+  Fe,
+  Ve,
+  Lt,
+  xt
+].flat(), cr = [qt, Wt, Ft, Vt, Ut, Jt].flat();
 export {
-  xe as blockquoteAttr,
-  we as blockquoteKeymap,
-  W as blockquoteSchema,
-  De as bulletListAttr,
-  _e as bulletListKeymap,
-  D as bulletListSchema,
-  Ae as codeBlockAttr,
-  He as codeBlockKeymap,
-  F as codeBlockSchema,
-  Jt as commands,
-  Kr as commonmark,
-  ve as createCodeBlockCommand,
-  kt as createCodeBlockInputRule,
-  lr as defaultConfig,
-  gt as docSchema,
-  be as downgradeHeadingCommand,
-  ce as emphasisAttr,
-  me as emphasisKeymap,
-  z as emphasisSchema,
-  Oe as hardbreakAttr,
-  At as hardbreakClearMarkPlugin,
-  tt as hardbreakFilterNodes,
-  vt as hardbreakFilterPlugin,
-  Re as hardbreakKeymap,
+  ye as blockquoteAttr,
+  he as blockquoteKeymap,
+  q as blockquoteSchema,
+  Se as bulletListAttr,
+  Ae as bulletListKeymap,
+  O as bulletListSchema,
+  fe as codeBlockAttr,
+  Ie as codeBlockKeymap,
+  W as codeBlockSchema,
+  Vt as commands,
+  cr as commonmark,
+  Ne as createCodeBlockCommand,
+  ut as createCodeBlockInputRule,
+  mt as docSchema,
+  ue as downgradeHeadingCommand,
+  Z as emphasisAttr,
+  te as emphasisKeymap,
+  R as emphasisSchema,
+  nt as emphasisStarInputRule,
+  ot as emphasisUnderscoreInputRule,
+  Me as hardbreakAttr,
+  Mt as hardbreakClearMarkPlugin,
+  Ue as hardbreakFilterNodes,
+  bt as hardbreakFilterPlugin,
+  Le as hardbreakKeymap,
   S as hardbreakSchema,
-  Me as headingAttr,
-  Y as headingIdGenerator,
-  Le as headingKeymap,
+  ce as headingAttr,
+  j as headingIdGenerator,
+  ge as headingKeymap,
   H as headingSchema,
-  Ke as hrAttr,
-  G as hrSchema,
-  Ue as htmlAttr,
-  Ye as htmlSchema,
-  Be as imageAttr,
-  K as imageSchema,
-  ye as inlineCodeAttr,
-  ke as inlineCodeKeymap,
+  xe as hrAttr,
+  F as hrSchema,
+  Ee as htmlAttr,
+  Pe as htmlSchema,
+  Ce as imageAttr,
+  v as imageSchema,
+  oe as inlineCodeAttr,
+  lt as inlineCodeInputRule,
+  le as inlineCodeKeymap,
   x as inlineCodeSchema,
-  wt as inlineNodesCursorPlugin,
-  _ as inlineSyncConfig,
-  St as inlineSyncPlugin,
-  Zt as inputrules,
-  Te as insertHardbreakCommand,
-  Ct as insertHrCommand,
-  It as insertHrInputRule,
-  ft as insertImageCommand,
-  zt as insertImageInputRule,
-  Qt as keymap,
-  je as liftFirstListItemCommand,
-  Ge as liftListItemCommand,
-  fe as linkAttr,
+  Ct as inlineNodesCursorPlugin,
+  Wt as inputRules,
+  be as insertHardbreakCommand,
+  ht as insertHrCommand,
+  kt as insertHrInputRule,
+  gt as insertImageCommand,
+  Pt as insertImageInputRule,
+  Ut as keymap,
+  De as liftFirstListItemCommand,
+  Te as liftListItemCommand,
+  ie as linkAttr,
   B as linkSchema,
-  We as listItemAttr,
-  ze as listItemKeymap,
+  ve as listItemAttr,
+  _e as listItemKeymap,
   M as listItemSchema,
-  Ee as orderedListAttr,
-  qe as orderedListKeymap,
-  P as orderedListSchema,
-  Ne as paragraphAttr,
-  Ce as paragraphKeymap,
-  v as paragraphSchema,
-  Nr as plugins,
-  Ze as remarkAddOrderInListPlugin,
-  Xe as remarkHtmlTransformer,
-  Qe as remarkInlineLinkPlugin,
-  Je as remarkLineBreak,
-  et as remarkMarker,
-  Yt as schema,
-  Fe as sinkListItemCommand,
-  Ve as splitListItemCommand,
-  ue as strongAttr,
-  ge as strongKeymap,
-  U as strongSchema,
-  Ht as syncHeadingIdPlugin,
-  Bt as syncListOrderPlugin,
-  Lt as textSchema,
-  de as toggleEmphasisCommand,
-  he as toggleInlineCodeCommand,
-  ut as toggleLinkCommand,
-  pe as toggleStrongCommand,
-  Ie as turnIntoTextCommand,
-  jt as updateCodeBlockLanguageCommand,
-  Nt as updateImageCommand,
-  pt as updateLinkCommand,
-  Se as wrapInBlockquoteCommand,
-  ht as wrapInBlockquoteInputRule,
-  Pe as wrapInBulletListCommand,
-  Mt as wrapInBulletListInputRule,
-  b as wrapInHeadingCommand,
-  yt as wrapInHeadingInputRule,
-  $e as wrapInOrderedListCommand,
-  bt as wrapInOrderedListInputRule
+  Ft as markInputRules,
+  He as orderedListAttr,
+  Re as orderedListKeymap,
+  T as orderedListSchema,
+  de as paragraphAttr,
+  pe as paragraphKeymap,
+  A as paragraphSchema,
+  Jt as plugins,
+  $e as remarkAddOrderInListPlugin,
+  Fe as remarkHtmlTransformer,
+  We as remarkInlineLinkPlugin,
+  qe as remarkLineBreak,
+  Ve as remarkMarker,
+  qt as schema,
+  Oe as sinkListItemCommand,
+  Ke as splitListItemCommand,
+  re as strongAttr,
+  st as strongInputRule,
+  ne as strongKeymap,
+  $ as strongSchema,
+  Lt as syncHeadingIdPlugin,
+  xt as syncListOrderPlugin,
+  It as textSchema,
+  ee as toggleEmphasisCommand,
+  se as toggleInlineCodeCommand,
+  it as toggleLinkCommand,
+  ae as toggleStrongCommand,
+  me as turnIntoTextCommand,
+  Et as updateCodeBlockLanguageCommand,
+  yt as updateImageCommand,
+  dt as updateLinkCommand,
+  ke as wrapInBlockquoteCommand,
+  ct as wrapInBlockquoteInputRule,
+  we as wrapInBulletListCommand,
+  ft as wrapInBulletListInputRule,
+  L as wrapInHeadingCommand,
+  pt as wrapInHeadingInputRule,
+  Be as wrapInOrderedListCommand,
+  Nt as wrapInOrderedListInputRule
 };
 //# sourceMappingURL=index.es.js.map