@milkdown/preset-commonmark 7.2.1 → 7.2.2

package/lib/index.es.js

@@ -1,18 +1,18 @@
-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 { $markAttr as W, $markSchema as F, $command as g, $useKeymap as f, $node as ze, $nodeAttr as N, $nodeSchema as I, $ctx as J, $inputRule as L, pipe as Lt, $prose as H, $remark as G } from "@milkdown/utils";
+import { commandsCtx as h, editorViewCtx as Y, serializerCtx as St, parserCtx as wt } 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) => {
+import { Fragment as At } from "@milkdown/prose/model";
+import { expectDomTypeError as S } from "@milkdown/exception";
+import { textblockTypeInputRule as Ue, wrappingInputRule as Z, InputRule as Ye } from "@milkdown/prose/inputrules";
+import vt from "@sindresorhus/slugify";
+import { TextSelection as ee, Selection as Je, PluginKey as B, Plugin as T } from "@milkdown/prose/state";
+import { findSelectedNodeOfType as Ht } from "@milkdown/prose";
+import { sinkListItem as Bt, liftListItem as Qe, splitListItem as Tt } from "@milkdown/prose/schema-list";
+import { ReplaceStep as Ot, AddMarkStep as Kt } from "@milkdown/prose/transform";
+import { Decoration as Ve, DecorationSet as je } from "@milkdown/prose/view";
+import { visit as Xe } from "unist-util-visit";
+import Dt from "remark-inline-links";
+const Ze = (t, e) => {
   var o;
   if (!(e.childCount >= 1 && ((o = e.lastChild) == null ? void 0 : o.type.name) === "hardbreak")) {
     t.next(e.content);
@@ -21,14 +21,14 @@ const Qe = (t, e) => {
   const a = [];
   e.content.forEach((s, i, l) => {
     l !== e.childCount - 1 && a.push(s);
-  }), t.next(St.fromArray(a));
+  }), t.next(At.fromArray(a));
 }, n = (t, e) => (Object.assign(t, {
   meta: {
     package: "@milkdown/preset-commonmark",
     ...e
   }
-}), t), ee = W("emphasis");
-n(ee, {
+}), t), te = W("emphasis");
+n(te, {
   displayName: "Attr<emphasis>",
   group: "Emphasis"
 });
@@ -39,7 +39,7 @@ const V = F("emphasis", (t) => ({
     { tag: "em" },
     { style: "font-style", getAttrs: (e) => e === "italic" }
   ],
-  toDOM: (e) => ["em", t.get(ee.key)(e)],
+  toDOM: (e) => ["em", t.get(te.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "emphasis",
     runner: (e, r, a) => {
@@ -61,30 +61,30 @@ n(V.ctx, {
   displayName: "MarkSchemaCtx<emphasis>",
   group: "Emphasis"
 });
-const te = g("ToggleEmphasis", () => () => Q(V.type()));
-n(te, {
+const re = g("ToggleEmphasis", () => () => Q(V.type()));
+n(re, {
   displayName: "Command<toggleEmphasisCommand>",
   group: "Emphasis"
 });
-const re = f("emphasisKeymap", {
+const ae = f("emphasisKeymap", {
   ToggleEmphasis: {
     shortcuts: "Mod-i",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(te.key);
+      return () => e.call(re.key);
     }
   }
 });
-n(re.ctx, {
+n(ae.ctx, {
   displayName: "KeymapCtx<emphasis>",
   group: "Emphasis"
 });
-n(re.shortcuts, {
+n(ae.shortcuts, {
   displayName: "Keymap<emphasis>",
   group: "Emphasis"
 });
-const ae = W("strong");
-n(ae, {
+const ne = W("strong");
+n(ne, {
   displayName: "Attr<strong>",
   group: "Strong"
 });
@@ -95,7 +95,7 @@ const j = F("strong", (t) => ({
     { tag: "strong" },
     { style: "font-style", getAttrs: (e) => e === "bold" }
   ],
-  toDOM: (e) => ["strong", t.get(ae.key)(e)],
+  toDOM: (e) => ["strong", t.get(ne.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "strong",
     runner: (e, r, a) => {
@@ -117,39 +117,39 @@ n(j.ctx, {
   displayName: "MarkSchemaCtx<strong>",
   group: "Strong"
 });
-const ne = g("ToggleStrong", () => () => Q(j.type()));
-n(ne, {
+const oe = g("ToggleStrong", () => () => Q(j.type()));
+n(oe, {
   displayName: "Command<toggleStrongCommand>",
   group: "Strong"
 });
-const oe = f("strongKeymap", {
+const se = f("strongKeymap", {
   ToggleBold: {
     shortcuts: ["Mod-b"],
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(ne.key);
+      return () => e.call(oe.key);
     }
   }
 });
-n(oe.ctx, {
+n(se.ctx, {
   displayName: "KeymapCtx<strong>",
   group: "Strong"
 });
-n(oe.shortcuts, {
+n(se.shortcuts, {
   displayName: "Keymap<strong>",
   group: "Strong"
 });
-const se = W("inlineCode");
-n(se, {
+const le = W("inlineCode");
+n(le, {
   displayName: "Attr<inlineCode>",
   group: "InlineCode"
 });
-const M = F("inlineCode", (t) => ({
+const b = F("inlineCode", (t) => ({
   priority: 100,
   code: !0,
   inclusive: !1,
   parseDOM: [{ tag: "code" }],
-  toDOM: (e) => ["code", t.get(se.key)(e)],
+  toDOM: (e) => ["code", t.get(le.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "inlineCode",
     runner: (e, r, a) => {
@@ -163,46 +163,46 @@ const M = F("inlineCode", (t) => ({
     }
   }
 }));
-n(M.mark, {
+n(b.mark, {
   displayName: "MarkSchema<inlineCode>",
   group: "InlineCode"
 });
-n(M.ctx, {
+n(b.ctx, {
   displayName: "MarkSchemaCtx<inlineCode>",
   group: "InlineCode"
 });
-const le = g("ToggleInlineCode", () => () => (t, e) => {
+const ie = g("ToggleInlineCode", () => () => (t, e) => {
   const { selection: r, tr: a } = t;
   if (r.empty)
     return !1;
   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) => {
+  return t.doc.rangeHasMark(o, s, b.type()) ? (e == null || e(a.removeMark(o, s, b.type())), !0) : (Object.keys(t.schema.marks).filter((c) => c !== b.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);
+  }), e == null || e(a.addMark(o, s, b.type().create())), !0);
 });
-n(le, {
+n(ie, {
   displayName: "Command<toggleInlineCodeCommand>",
   group: "InlineCode"
 });
-const ie = f("inlineCodeKeymap", {
+const ce = f("inlineCodeKeymap", {
   ToggleInlineCode: {
     shortcuts: "Mod-e",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(le.key);
+      return () => e.call(ie.key);
     }
   }
 });
-n(ie.ctx, {
+n(ce.ctx, {
   displayName: "KeymapCtx<inlineCode>",
   group: "InlineCode"
 });
-n(ie.shortcuts, {
+n(ce.shortcuts, {
   displayName: "Keymap<inlineCode>",
   group: "InlineCode"
 });
-const ce = W("link");
-n(ce, {
+const de = W("link");
+n(de, {
   displayName: "Attr<link>",
   group: "Link"
 });
@@ -216,12 +216,12 @@ const v = F("link", (t) => ({
       tag: "a[href]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw L(e);
+          throw S(e);
         return { href: e.getAttribute("href"), title: e.getAttribute("title") };
       }
     }
   ],
-  toDOM: (e) => ["a", { ...t.get(ce.key)(e), ...e.attrs }],
+  toDOM: (e) => ["a", { ...t.get(de.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: (e) => e.type === "link",
     runner: (e, r, a) => {
@@ -243,12 +243,12 @@ n(v.mark, {
   displayName: "MarkSchema<link>",
   group: "Link"
 });
-const Xe = g("ToggleLink", () => (t = {}) => Q(v.type(), t));
-n(Xe, {
+const et = g("ToggleLink", () => (t = {}) => Q(v.type(), t));
+n(et, {
   displayName: "Command<toggleLinkCommand>",
   group: "Link"
 });
-const Ze = g("UpdateLink", () => (t = {}) => (e, r) => {
+const tt = g("UpdateLink", () => (t = {}) => (e, r) => {
   if (!r)
     return !1;
   let a, o = -1;
@@ -263,14 +263,14 @@ const Ze = g("UpdateLink", () => (t = {}) => (e, r) => {
     return !1;
   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()
+    u.removeMark(d, m, c).addMark(d, m, y).setSelection(new ee(u.selection.$anchor)).scrollIntoView()
   ), !0) : !1;
 });
-n(Ze, {
+n(tt, {
   displayName: "Command<updateLinkCommand>",
   group: "Link"
 });
-const et = Ve("doc", () => ({
+const rt = ze("doc", () => ({
   content: "block+",
   parseMarkdown: {
     match: ({ type: t }) => t === "root",
@@ -285,20 +285,20 @@ const et = Ve("doc", () => ({
     }
   }
 }));
-n(et, {
+n(rt, {
   displayName: "NodeSchema<doc>",
   group: "Doc"
 });
-const de = N("paragraph");
-n(de, {
+const me = N("paragraph");
+n(me, {
   displayName: "Attr<paragraph>",
   group: "Paragraph"
 });
-const S = I("paragraph", (t) => ({
+const w = I("paragraph", (t) => ({
   content: "inline*",
   group: "block",
   parseDOM: [{ tag: "p" }],
-  toDOM: (e) => ["p", t.get(de.key)(e), 0],
+  toDOM: (e) => ["p", t.get(me.key)(e), 0],
   parseMarkdown: {
     match: (e) => e.type === "paragraph",
     runner: (e, r, a) => {
@@ -308,51 +308,51 @@ const S = I("paragraph", (t) => ({
   toMarkdown: {
     match: (e) => e.type.name === "paragraph",
     runner: (e, r) => {
-      e.openNode("paragraph"), Qe(e, r), e.closeNode();
+      e.openNode("paragraph"), Ze(e, r), e.closeNode();
     }
   }
 }));
-n(S.node, {
+n(w.node, {
   displayName: "NodeSchema<paragraph>",
   group: "Paragraph"
 });
-n(S.ctx, {
+n(w.ctx, {
   displayName: "NodeSchemaCtx<paragraph>",
   group: "Paragraph"
 });
-const me = g("TurnIntoText", () => () => R(S.type()));
-n(me, {
+const ue = g("TurnIntoText", () => () => R(w.type()));
+n(ue, {
   displayName: "Command<turnIntoTextCommand>",
   group: "Paragraph"
 });
-const ue = f("paragraphKeymap", {
+const pe = f("paragraphKeymap", {
   TurnIntoText: {
     shortcuts: "Mod-Alt-0",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(me.key);
+      return () => e.call(ue.key);
     }
   }
 });
-n(ue.ctx, {
+n(pe.ctx, {
   displayName: "KeymapCtx<paragraph>",
   group: "Paragraph"
 });
-n(ue.shortcuts, {
+n(pe.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");
+const Pt = Array(6).fill(0).map((t, e) => e + 1), Rt = (t) => vt(t.textContent), z = J(Rt, "headingIdGenerator");
 n(z, {
   displayName: "Ctx<HeadingIdGenerator>",
   group: "Heading"
 });
-const pe = N("heading");
-n(pe, {
+const ge = N("heading");
+n(ge, {
   displayName: "Attr<heading>",
   group: "Heading"
 });
-const w = I("heading", (t) => {
+const A = I("heading", (t) => {
   const e = t.get(z.key);
   return {
     content: "inline*",
@@ -366,18 +366,18 @@ const w = I("heading", (t) => {
         default: 1
       }
     },
-    parseDOM: Dt.map((r) => ({
+    parseDOM: Pt.map((r) => ({
       tag: `h${r}`,
       getAttrs: (a) => {
         if (!(a instanceof HTMLElement))
-          throw L(a);
+          throw S(a);
         return { level: r, id: a.id };
       }
     })),
     toDOM: (r) => [
       `h${r.attrs.level}`,
       {
-        ...t.get(pe.key)(r),
+        ...t.get(ge.key)(r),
         id: r.attrs.id || e(r)
       },
       0
@@ -392,20 +392,20 @@ const w = I("heading", (t) => {
     toMarkdown: {
       match: (r) => r.type.name === "heading",
       runner: (r, a) => {
-        r.openNode("heading", void 0, { depth: a.attrs.level }), Qe(r, a), r.closeNode();
+        r.openNode("heading", void 0, { depth: a.attrs.level }), Ze(r, a), r.closeNode();
       }
     }
   };
 });
-n(w.node, {
+n(A.node, {
   displayName: "NodeSchema<heading>",
   group: "Heading"
 });
-n(w.ctx, {
+n(A.ctx, {
   displayName: "NodeSchemaCtx<heading>",
   group: "Heading"
 });
-const tt = x((t) => je(/^(?<hashes>#+)\s$/, w.type(), (e) => {
+const at = L((t) => Ue(/^(?<hashes>#+)\s$/, A.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") {
@@ -414,18 +414,18 @@ const tt = x((t) => je(/^(?<hashes>#+)\s$/, w.type(), (e) => {
   }
   return { level: r };
 }));
-n(tt, {
+n(at, {
   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, {
+const M = g("WrapInHeading", () => (t) => (t ?? (t = 1), t < 1 ? R(w.type()) : R(A.type(), { level: t })));
+n(M, {
   displayName: "Command<wrapInHeadingCommand>",
   group: "Heading"
 });
-const ge = g("DowngradeHeading", () => () => (t, e, r) => {
+const he = g("DowngradeHeading", () => () => (t, e, r) => {
   const { $from: a } = t.selection, o = a.node();
-  if (o.type !== w.type() || !t.selection.empty || a.parentOffset !== 0)
+  if (o.type !== A.type() || !t.selection.empty || a.parentOffset !== 0)
     return !1;
   const s = o.attrs.level - 1;
   return s ? (e == null || e(
@@ -433,73 +433,73 @@ const ge = g("DowngradeHeading", () => () => (t, e, r) => {
       ...o.attrs,
       level: s
     })
-  ), !0) : R(S.type())(t, e, r);
+  ), !0) : R(w.type())(t, e, r);
 });
-n(ge, {
+n(he, {
   displayName: "Command<downgradeHeadingCommand>",
   group: "Heading"
 });
-const he = f("headingKeymap", {
+const ye = f("headingKeymap", {
   TurnIntoH1: {
     shortcuts: "Mod-Alt-1",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(C.key, 1);
+      return () => e.call(M.key, 1);
     }
   },
   TurnIntoH2: {
     shortcuts: "Mod-Alt-2",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(C.key, 2);
+      return () => e.call(M.key, 2);
     }
   },
   TurnIntoH3: {
     shortcuts: "Mod-Alt-3",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(C.key, 3);
+      return () => e.call(M.key, 3);
     }
   },
   TurnIntoH4: {
     shortcuts: "Mod-Alt-4",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(C.key, 3);
+      return () => e.call(M.key, 3);
     }
   },
   TurnIntoH5: {
     shortcuts: "Mod-Alt-5",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(C.key, 3);
+      return () => e.call(M.key, 3);
     }
   },
   TurnIntoH6: {
     shortcuts: "Mod-Alt-6",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(C.key, 3);
+      return () => e.call(M.key, 3);
     }
   },
   DowngradeHeading: {
     shortcuts: ["Delete", "Backspace"],
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(ge.key);
+      return () => e.call(he.key);
     }
   }
 });
-n(he.ctx, {
+n(ye.ctx, {
   displayName: "KeymapCtx<heading>",
   group: "Heading"
 });
-n(he.shortcuts, {
+n(ye.shortcuts, {
   displayName: "Keymap<heading>",
   group: "Heading"
 });
-const ye = N("blockquote");
-n(ye, {
+const ke = N("blockquote");
+n(ke, {
   displayName: "Attr<blockquote>",
   group: "Blockquote"
 });
@@ -508,7 +508,7 @@ const E = I("blockquote", (t) => ({
   group: "block",
   defining: !0,
   parseDOM: [{ tag: "blockquote" }],
-  toDOM: (e) => ["blockquote", t.get(ye.key)(e), 0],
+  toDOM: (e) => ["blockquote", t.get(ke.key)(e), 0],
   parseMarkdown: {
     match: ({ type: e }) => e === "blockquote",
     runner: (e, r, a) => {
@@ -530,38 +530,38 @@ n(E.ctx, {
   displayName: "NodeSchemaCtx<blockquote>",
   group: "Blockquote"
 });
-const rt = x(() => Z(/^\s*>\s$/, E.type()));
-n(rt, {
+const nt = L(() => Z(/^\s*>\s$/, E.type()));
+n(nt, {
   displayName: "InputRule<wrapInBlockquoteInputRule>",
   group: "Blockquote"
 });
-const ke = g("WrapInBlockquote", () => () => X(E.type()));
-n(ke, {
+const fe = g("WrapInBlockquote", () => () => X(E.type()));
+n(fe, {
   displayName: "Command<wrapInBlockquoteCommand>",
   group: "Blockquote"
 });
-const fe = f("blockquoteKeymap", {
+const Ne = f("blockquoteKeymap", {
   WrapInBlockquote: {
     shortcuts: "Mod-Shift-b",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(ke.key);
+      return () => e.call(fe.key);
     }
   }
 });
-n(fe.ctx, {
+n(Ne.ctx, {
   displayName: "KeymapCtx<blockquote>",
   group: "Blockquote"
 });
-n(fe.shortcuts, {
+n(Ne.shortcuts, {
   displayName: "Keymap<blockquote>",
   group: "Blockquote"
 });
-const Ne = N("codeBlock", () => ({
+const Ie = N("codeBlock", () => ({
   pre: {},
   code: {}
 }));
-n(Ne, {
+n(Ie, {
   displayName: "Attr<codeBlock>",
   group: "CodeBlock"
 });
@@ -582,13 +582,13 @@ const _ = I("code_block", (t) => ({
       preserveWhitespace: "full",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw L(e);
+          throw S(e);
         return { language: e.dataset.language };
       }
     }
   ],
   toDOM: (e) => {
-    const r = t.get(Ne.key)(e);
+    const r = t.get(Ie.key)(e);
     return [
       "pre",
       {
@@ -623,45 +623,45 @@ n(_.ctx, {
   displayName: "NodeSchemaCtx<codeBlock>",
   group: "CodeBlock"
 });
-const at = x(() => je(/^```(?<language>[a-z]*)?[\s\n]$/, _.type(), (t) => {
+const ot = L(() => Ue(/^```(?<language>[a-z]*)?[\s\n]$/, _.type(), (t) => {
   var e;
   return {
     language: ((e = t.groups) == null ? void 0 : e.language) ?? ""
   };
 }));
-n(at, {
+n(ot, {
   displayName: "InputRule<createCodeBlockInputRule>",
   group: "CodeBlock"
 });
-const Ie = g("CreateCodeBlock", () => (t = "") => R(_.type(), { language: t }));
-n(Ie, {
+const Ce = g("CreateCodeBlock", () => (t = "") => R(_.type(), { language: t }));
+n(Ce, {
   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, {
+const Et = 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(Et, {
   displayName: "Command<updateCodeBlockLanguageCommand>",
   group: "CodeBlock"
 });
-const Ce = f("codeBlockKeymap", {
+const Me = f("codeBlockKeymap", {
   CreateCodeBlock: {
     shortcuts: "Mod-Alt-c",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(Ie.key);
+      return () => e.call(Ce.key);
     }
   }
 });
-n(Ce.ctx, {
+n(Me.ctx, {
   displayName: "KeymapCtx<codeBlock>",
   group: "CodeBlock"
 });
-n(Ce.shortcuts, {
+n(Me.shortcuts, {
   displayName: "Keymap<codeBlock>",
   group: "CodeBlock"
 });
-const Me = N("image");
-n(Me, {
+const be = N("image");
+n(be, {
   displayName: "Attr<image>",
   group: "Image"
 });
@@ -684,7 +684,7 @@ const O = I("image", (t) => ({
       tag: "img[src]",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw L(e);
+          throw S(e);
         return {
           src: e.getAttribute("src") || "",
           alt: e.getAttribute("alt") || "",
@@ -693,7 +693,7 @@ const O = I("image", (t) => ({
       }
     }
   ],
-  toDOM: (e) => ["img", { ...t.get(Me.key)(e), ...e.attrs }],
+  toDOM: (e) => ["img", { ...t.get(be.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: ({ type: e }) => e === "image",
     runner: (e, r, a) => {
@@ -724,46 +724,46 @@ n(O.ctx, {
   displayName: "NodeSchemaCtx<image>",
   group: "Image"
 });
-const nt = g("InsertImage", () => (t = {}) => (e, r) => {
+const st = g("InsertImage", () => (t = {}) => (e, r) => {
   if (!r)
     return !0;
   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, {
+n(st, {
   displayName: "Command<insertImageCommand>",
   group: "Image"
 });
-const ot = g("UpdateImage", () => (t = {}) => (e, r) => {
-  const a = At(e.selection, O.type());
+const lt = g("UpdateImage", () => (t = {}) => (e, r) => {
+  const a = Ht(e.selection, O.type());
   if (!a)
     return !1;
   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, {
+n(lt, {
   displayName: "Command<updateImageCommand>",
   group: "Image"
 });
-const Et = x(() => new ze(
+const _t = L(() => new Ye(
   /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
   (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;
   }
 ));
-n(Et, {
+n(_t, {
   displayName: "InputRule<insertImageInputRule>",
   group: "Image"
 });
-const be = N("hardbreak", (t) => ({
+const xe = N("hardbreak", (t) => ({
   "data-is-inline": t.attrs.isInline
 }));
-n(be, {
+n(xe, {
   displayName: "Attr<hardbreak>",
   group: "Hardbreak"
 });
-const b = I("hardbreak", (t) => ({
+const x = I("hardbreak", (t) => ({
   inline: !0,
   group: "inline",
   attrs: {
@@ -773,7 +773,7 @@ const b = I("hardbreak", (t) => ({
   },
   selectable: !1,
   parseDOM: [{ tag: "br" }],
-  toDOM: (e) => ["br", t.get(be.key)(e)],
+  toDOM: (e) => ["br", t.get(xe.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "break",
     runner: (e, r, a) => {
@@ -791,56 +791,56 @@ const b = I("hardbreak", (t) => ({
     }
   }
 }));
-n(b.node, {
+n(x.node, {
   displayName: "NodeSchema<hardbreak>",
   group: "Hardbreak"
 });
-n(b.ctx, {
+n(x.ctx, {
   displayName: "NodeSchemaCtx<hardbreak>",
   group: "Hardbreak"
 });
-const xe = g("InsertHardbreak", () => () => (t, e) => {
+const Le = g("InsertHardbreak", () => () => (t, e) => {
   var o;
   const { selection: r, tr: a } = t;
   if (r.empty) {
     const s = r.$from.node();
     if (s.childCount > 0 && ((o = s.lastChild) == null ? void 0 : o.type.name) === "hardbreak")
       return e == null || e(
-        a.replaceRangeWith(r.to - 1, r.to, t.schema.node("paragraph")).setSelection(Ye.near(a.doc.resolve(r.to))).scrollIntoView()
+        a.replaceRangeWith(r.to - 1, r.to, t.schema.node("paragraph")).setSelection(Je.near(a.doc.resolve(r.to))).scrollIntoView()
       ), !0;
   }
-  return e == null || e(a.setMeta("hardbreak", !0).replaceSelectionWith(b.type().create()).scrollIntoView()), !0;
+  return e == null || e(a.setMeta("hardbreak", !0).replaceSelectionWith(x.type().create()).scrollIntoView()), !0;
 });
-n(xe, {
+n(Le, {
   displayName: "Command<insertHardbreakCommand>",
   group: "Hardbreak"
 });
-const Le = f("hardbreakKeymap", {
+const Se = f("hardbreakKeymap", {
   InsertHardbreak: {
     shortcuts: "Shift-Enter",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(xe.key);
+      return () => e.call(Le.key);
     }
   }
 });
-n(Le.ctx, {
+n(Se.ctx, {
   displayName: "KeymapCtx<hardbreak>",
   group: "Hardbreak"
 });
-n(Le.shortcuts, {
+n(Se.shortcuts, {
   displayName: "Keymap<hardbreak>",
   group: "Hardbreak"
 });
-const Se = N("hr");
-n(Se, {
+const we = N("hr");
+n(we, {
   displayName: "Attr<hr>",
   group: "Hr"
 });
 const $ = I("hr", (t) => ({
   group: "block",
   parseDOM: [{ tag: "hr" }],
-  toDOM: (e) => ["hr", t.get(Se.key)(e)],
+  toDOM: (e) => ["hr", t.get(we.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "thematicBreak",
     runner: (e, r, a) => {
@@ -862,32 +862,32 @@ n($.ctx, {
   displayName: "NodeSchemaCtx<hr>",
   group: "Hr"
 });
-const st = x(() => new ze(
+const it = L(() => new Ye(
   /^(?:---|___\s|\*\*\*\s)$/,
   (t, e, r, a) => {
     const { tr: o } = t;
     return e[0] && o.replaceWith(r - 1, a, $.type().create()), o;
   }
 ));
-n(st, {
+n(it, {
   displayName: "InputRule<insertHrInputRule>",
   group: "Hr"
 });
-const lt = g("InsertHr", () => () => (t, e) => {
+const ct = g("InsertHr", () => () => (t, e) => {
   if (!e)
     return !0;
-  const r = S.node.type().create(), { tr: a, selection: o } = t, { from: s } = o, i = $.type().create();
+  const r = w.node.type().create(), { tr: a, selection: o } = t, { from: s } = o, i = $.type().create();
   if (!i)
     return !0;
-  const l = a.replaceSelectionWith(i).insert(s, r), c = Ye.findFrom(l.doc.resolve(s), 1, !0);
+  const l = a.replaceSelectionWith(i).insert(s, r), c = Je.findFrom(l.doc.resolve(s), 1, !0);
   return c && e(l.setSelection(c).scrollIntoView()), !0;
 });
-n(lt, {
+n(ct, {
   displayName: "Command<insertHrCommand>",
   group: "Hr"
 });
-const we = N("bulletList");
-n(we, {
+const Ae = N("bulletList");
+n(Ae, {
   displayName: "Attr<bulletList>",
   group: "BulletList"
 });
@@ -904,7 +904,7 @@ const K = I("bullet_list", (t) => ({
       tag: "ul",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw L(e);
+          throw S(e);
         return {
           spread: e.dataset.spread
         };
@@ -914,7 +914,7 @@ const K = I("bullet_list", (t) => ({
   toDOM: (e) => [
     "ul",
     {
-      ...t.get(we.key)(e),
+      ...t.get(Ae.key)(e),
       "data-spread": e.attrs.spread
     },
     0
@@ -941,35 +941,35 @@ n(K.ctx, {
   displayName: "NodeSchemaCtx<bulletList>",
   group: "BulletList"
 });
-const it = x(() => Z(/^\s*([-+*])\s$/, K.type()));
-n(it, {
+const dt = L(() => Z(/^\s*([-+*])\s$/, K.type()));
+n(dt, {
   displayName: "InputRule<wrapInBulletListInputRule>",
   group: "BulletList"
 });
-const Ae = g("WrapInBulletList", () => () => X(K.type()));
-n(Ae, {
+const ve = g("WrapInBulletList", () => () => X(K.type()));
+n(ve, {
   displayName: "Command<wrapInBulletListCommand>",
   group: "BulletList"
 });
-const ve = f("bulletListKeymap", {
+const He = f("bulletListKeymap", {
   WrapInBulletList: {
     shortcuts: "Mod-Alt-8",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(Ae.key);
+      return () => e.call(ve.key);
     }
   }
 });
-n(ve.ctx, {
+n(He.ctx, {
   displayName: "KeymapCtx<bulletListKeymap>",
   group: "BulletList"
 });
-n(ve.shortcuts, {
+n(He.shortcuts, {
   displayName: "Keymap<bulletListKeymap>",
   group: "BulletList"
 });
-const He = N("orderedList");
-n(He, {
+const Be = N("orderedList");
+n(Be, {
   displayName: "Attr<orderedList>",
   group: "OrderedList"
 });
@@ -989,7 +989,7 @@ const D = I("ordered_list", (t) => ({
       tag: "ol",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw L(e);
+          throw S(e);
         return {
           spread: e.dataset.spread,
           order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
@@ -1000,7 +1000,7 @@ const D = I("ordered_list", (t) => ({
   toDOM: (e) => [
     "ol",
     {
-      ...t.get(He.key)(e),
+      ...t.get(Be.key)(e),
       ...e.attrs.order === 1 ? {} : e.attrs.order,
       "data-spread": e.attrs.spread
     },
@@ -1028,44 +1028,44 @@ n(D.ctx, {
   displayName: "NodeSchemaCtx<orderedList>",
   group: "OrderedList"
 });
-const ct = x(() => Z(
+const mt = L(() => Z(
   /^\s*(\d+)\.\s$/,
   D.type(),
   (t) => ({ order: Number(t[1]) }),
   (t, e) => e.childCount + e.attrs.order === Number(t[1])
 ));
-n(ct, {
+n(mt, {
   displayName: "InputRule<wrapInOrderedListInputRule>",
   group: "OrderedList"
 });
-const Be = g("WrapInOrderedList", () => () => X(D.type()));
-n(Be, {
+const Te = g("WrapInOrderedList", () => () => X(D.type()));
+n(Te, {
   displayName: "Command<wrapInOrderedListCommand>",
   group: "OrderedList"
 });
-const Te = f("orderedListKeymap", {
+const Oe = f("orderedListKeymap", {
   WrapInOrderedList: {
     shortcuts: "Mod-Alt-7",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(Be.key);
+      return () => e.call(Te.key);
     }
   }
 });
-n(Te.ctx, {
+n(Oe.ctx, {
   displayName: "KeymapCtx<orderedList>",
   group: "OrderedList"
 });
-n(Te.shortcuts, {
+n(Oe.shortcuts, {
   displayName: "Keymap<orderedList>",
   group: "OrderedList"
 });
-const Oe = N("listItem");
-n(Oe, {
+const Ke = N("listItem");
+n(Ke, {
   displayName: "Attr<listItem>",
   group: "ListItem"
 });
-const A = I("list_item", (t) => ({
+const C = I("list_item", (t) => ({
   group: "listItem",
   content: "paragraph block*",
   attrs: {
@@ -1085,7 +1085,7 @@ const A = I("list_item", (t) => ({
       tag: "li",
       getAttrs: (e) => {
         if (!(e instanceof HTMLElement))
-          throw L(e);
+          throw S(e);
         return {
           label: e.dataset.label,
           listType: e.dataset["list-type"],
@@ -1097,7 +1097,7 @@ const A = I("list_item", (t) => ({
   toDOM: (e) => [
     "li",
     {
-      ...t.get(Oe.key)(e),
+      ...t.get(Ke.key)(e),
       "data-label": e.attrs.label,
       "data-list-type": e.attrs.listType,
       "data-spread": e.attrs.spread
@@ -1118,61 +1118,82 @@ const A = I("list_item", (t) => ({
     }
   }
 }));
-n(A.node, {
+n(C.node, {
   displayName: "NodeSchema<listItem>",
   group: "ListItem"
 });
-n(A.ctx, {
+n(C.ctx, {
   displayName: "NodeSchemaCtx<listItem>",
   group: "ListItem"
 });
-const Ke = g("SinkListItem", () => () => vt(A.type()));
-n(Ke, {
+const De = g("SinkListItem", () => () => Bt(C.type()));
+n(De, {
   displayName: "Command<sinkListItemCommand>",
   group: "ListItem"
 });
-const De = g("SplitListItem", () => () => Ht(A.type()));
-n(De, {
+const Pe = g("SplitListItem", () => () => Qe(C.type()));
+n(Pe, {
   displayName: "Command<liftListItemCommand>",
   group: "ListItem"
 });
-const Pe = g("SplitListItem", () => () => Bt(A.type()));
-n(Pe, {
+const Re = g("SplitListItem", () => () => Tt(C.type()));
+n(Re, {
   displayName: "Command<splitListItemCommand>",
   group: "ListItem"
 });
-const Re = f("listItemKeymap", {
+const $t = (t, e, r) => {
+  const { selection: a } = t;
+  if (!(a instanceof ee))
+    return !1;
+  const { empty: o, $from: s } = a;
+  if (!o || s.parentOffset !== 0)
+    return !1;
+  const i = s.node(-1);
+  return i.type !== C.type() || i.firstChild !== s.node() || s.node(-2).childCount > 1 ? !1 : Qe(C.type())(t, e, r);
+}, Ee = g("LiftFirstListItem", () => () => $t);
+n(Ee, {
+  displayName: "Command<liftFirstListItemCommand>",
+  group: "ListItem"
+});
+const _e = f("listItemKeymap", {
   NextListItem: {
     shortcuts: "Enter",
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(Pe.key);
+      return () => e.call(Re.key);
     }
   },
   SinkListItem: {
     shortcuts: ["Tab", "Mod-]"],
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(Ke.key);
+      return () => e.call(De.key);
     }
   },
   LiftListItem: {
     shortcuts: ["Shift-Tab", "Mod-["],
     command: (t) => {
       const e = t.get(h);
-      return () => e.call(De.key);
+      return () => e.call(Pe.key);
+    }
+  },
+  LiftFirstListItem: {
+    shortcuts: ["Backspace", "Delete"],
+    command: (t) => {
+      const e = t.get(h);
+      return () => e.call(Ee.key);
     }
   }
 });
-n(Re.ctx, {
+n(_e.ctx, {
   displayName: "KeymapCtx<listItem>",
   group: "ListItem"
 });
-n(Re.shortcuts, {
+n(_e.shortcuts, {
   displayName: "Keymap<listItem>",
   group: "ListItem"
 });
-const dt = Ve("text", () => ({
+const ut = ze("text", () => ({
   group: "inline",
   parseMarkdown: {
     match: ({ type: t }) => t === "text",
@@ -1187,16 +1208,16 @@ const dt = Ve("text", () => ({
     }
   }
 }));
-n(dt, {
+n(ut, {
   displayName: "NodeSchema<text>",
   group: "Text"
 });
-const Ee = N("html");
-n(Ee, {
+const $e = N("html");
+n($e, {
   displayName: "Attr<html>",
   group: "Html"
 });
-const _e = I("html", (t) => ({
+const qe = I("html", (t) => ({
   atom: !0,
   group: "inline",
   inline: !0,
@@ -1207,7 +1228,7 @@ const _e = I("html", (t) => ({
   },
   toDOM: (e) => {
     const r = document.createElement("span"), a = {
-      ...t.get(Ee.key)(e),
+      ...t.get($e.key)(e),
       "data-value": e.attrs.value,
       "data-type": "html"
     };
@@ -1232,101 +1253,102 @@ const _e = I("html", (t) => ({
     }
   }
 }));
-n(_e.node, {
+n(qe.node, {
   displayName: "NodeSchema<html>",
   group: "Html"
 });
-n(_e.ctx, {
+n(qe.ctx, {
   displayName: "NodeSchemaCtx<html>",
   group: "Html"
 });
-const _t = [
-  et,
-  de,
-  S,
-  z,
-  pe,
+const qt = [
+  rt,
+  me,
   w,
-  be,
-  b,
-  ye,
+  z,
+  ge,
+  A,
+  xe,
+  x,
+  ke,
   E,
-  Ne,
+  Ie,
   _,
-  Se,
+  we,
   $,
-  Me,
+  be,
   O,
-  we,
+  Ae,
   K,
-  He,
+  Be,
   D,
-  Oe,
-  A,
-  ee,
+  Ke,
+  C,
+  te,
   V,
-  ae,
+  ne,
   j,
-  se,
-  M,
-  ce,
+  le,
+  b,
+  de,
   v,
-  Ee,
-  _e,
-  dt
-].flat(), $t = [
-  rt,
-  it,
-  ct,
-  at,
-  st,
-  tt
-].flat(), qt = [
-  me,
-  ke,
-  C,
-  ge,
-  Ie,
-  xe,
-  lt,
+  $e,
+  qe,
+  ut
+].flat(), Wt = [
   nt,
+  dt,
+  mt,
   ot,
-  Be,
-  Ae,
-  Ke,
-  Pe,
-  De,
-  te,
-  le,
-  ne,
-  Xe,
-  Ze
-], Wt = [
+  it,
+  at
+].flat(), Ft = [
+  ue,
   fe,
+  M,
+  he,
   Ce,
   Le,
-  he,
-  Re,
+  ct,
+  st,
+  lt,
   Te,
   ve,
-  ue,
+  De,
+  Re,
+  Pe,
+  Ee,
   re,
   ie,
-  oe
-].flat(), U = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, Ft = (t) => new RegExp(`\\\\(?=[^\\w\\s${t}\\\\]|_)`, "g"), Gt = (t) => {
+  oe,
+  et,
+  tt
+], Gt = [
+  Ne,
+  Me,
+  Se,
+  ye,
+  _e,
+  Oe,
+  He,
+  pe,
+  ae,
+  ce,
+  se
+].flat(), U = /\[(?<span>((www|https:\/\/|http:\/\/)[^\s\]]+))]\((?<url>[^\s\]]+)\)/, Vt = (t) => new RegExp(`\\\\(?=[^\\w\\s${t}\\\\]|_)`, "g"), jt = (t) => {
   let e = t, r = e.match(U);
   for (; r && r.groups; ) {
     const { span: a } = r.groups;
     e = e.replace(U, a), r = e.match(U);
   }
   return e;
-}, Vt = (t, e, r) => {
+}, zt = (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) => {
+}, Ut = (t) => (e) => e.replace(Vt(t), ""), Yt = (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) => {
+}, Jt = (t, e, r) => {
   let a = e, o = !1;
   return t.descendants((s) => {
     var i;
@@ -1341,7 +1363,7 @@ const _t = [
     }
     return a += 1, !0;
   }), a;
-}, Yt = {
+}, Qt = {
   placeholderConfig: {
     hole: "∅",
     punctuation: "⁂",
@@ -1353,46 +1375,46 @@ const _t = [
     const r = ["*", "_"];
     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;
+      e = zt(e, a, a + 1), a = a + 1;
     return e;
   }
-}, P = J(Yt, "inlineSyncConfig");
+}, P = J(Qt, "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]);
+const Xt = (t) => t.selection.$from.node(), Zt = (t, e, r, a) => {
+  const o = t.get(St), s = e.schema.topNodeType.create(void 0, [r, ...a]);
   return o(s);
-}, Xt = (t, e) => {
+}, er = (t, e) => {
   const r = t.get(P.key), a = r.placeholderConfig.hole, [o = "", ...s] = e.split(`
 
 `), i = (m) => r.movePlaceholder(a, m);
-  let c = bt(jt(a), i, Gt)(o);
-  const d = zt(r.placeholderConfig)(c);
+  let c = Lt(Ut(a), i, jt)(o);
+  const d = Yt(r.placeholderConfig)(c);
   return c = c.replace(a, d), c = [c, ...s].join(`
 
 `), [c, d];
-}, Zt = (t, e) => {
-  const a = t.get(Lt)(e);
+}, tr = (t, e) => {
+  const a = t.get(wt)(e);
   return a ? a.firstChild : null;
-}, er = (t, e) => {
+}, rr = (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 a.push(o), !1;
   }), a;
-}, tr = (t) => t.split(`
+}, ar = (t) => t.split(`
 
-`)[0] || "", rr = (t) => t.childCount === 1 && t.child(0).type.name === "html", mt = (t, e) => {
+`)[0] || "", nr = (t) => t.childCount === 1 && t.child(0).type.name === "html", pt = (t, e) => {
   try {
-    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) => {
+    const r = rr(t, e), a = Xt(e), o = Zt(t, e, a, r), [s, i] = er(t, o), l = tr(t, s);
+    return !l || a.type !== l.type || nr(l) ? null : (l.attrs = { ...a.attrs }, l.descendants((c) => {
       var u;
       const m = c.marks.find((y) => y.type.name === "link");
       m && ((u = c.text) != null && u.includes(i)) && m.attrs.href.includes(i) && (m.attrs.href = m.attrs.href.replace(i, ""));
     }), {
-      text: tr(s),
+      text: ar(s),
       prevNode: a,
       nextNode: l,
       placeholder: i
@@ -1400,15 +1422,15 @@ const Jt = (t) => t.selection.$from.node(), Qt = (t, e, r, a) => {
   } catch {
     return null;
   }
-}, ar = (t, e, r, a, o) => {
+}, or = (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);
+  const c = r.apply(l), d = pt(t, c);
   if (!d)
     return;
-  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) => {
+  const { $from: m } = c.selection, u = m.before(), y = m.after(), p = Jt(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(ee.near(l.doc.resolve(p + 1))), a(l);
+}, gt = H((t) => {
   let e = null;
   const r = new B("MILKDOWN_INLINE_SYNC");
   return new T({
@@ -1420,26 +1442,26 @@ const Jt = (t) => t.selection.$from.node(), Qt = (t, e, r, a) => {
         const l = t.get(Y);
         if (!((k = l.hasFocus) != null && k.call(l)) || !l.editable || !a.docChanged || a.getMeta(r))
           return null;
-        const d = mt(t, i);
+        const d = pt(t, i);
         if (!d)
           return null;
         e && (cancelAnimationFrame(e), e = null);
         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: q, state: qe } = t.get(Y);
-          ar(t, r, qe, q, m.attrs);
+          const { dispatch: q, state: Fe } = t.get(Y);
+          or(t, r, Fe, q, m.attrs);
         }), a.setMeta("addToHistory", !1)), null;
       }
     }
   });
 });
-n(ut, {
+n(gt, {
   displayName: "Prose<inlineSyncPlugin>",
   group: "Prose"
 });
-const pt = G(() => () => (t) => {
-  Je(t, "list", (e) => {
+const ht = G(() => () => (t) => {
+  Xe(t, "list", (e) => {
     if (e.ordered) {
       const r = e.start ?? 1;
       e.children.forEach((a, o) => {
@@ -1448,13 +1470,13 @@ const pt = G(() => () => (t) => {
     }
   });
 });
-n(pt, {
+n(ht, {
   displayName: "Remark<remarkAddOrderInListPlugin>",
   group: "Remark"
 });
-const gt = G(() => () => (t) => {
+const yt = G(() => () => (t) => {
   const e = /[\t ]*(?:\r?\n|\r)/g;
-  Je(t, "text", (r, a, o) => {
+  Xe(t, "text", (r, a, o) => {
     if (!r.value || typeof r.value != "string")
       return;
     const s = [];
@@ -1469,20 +1491,20 @@ const gt = G(() => () => (t) => {
       return i < r.value.length && s.push({ type: "text", value: r.value.slice(i) }), o.children.splice(a, 1, ...s), a + s.length;
   });
 });
-n(gt, {
+n(yt, {
   displayName: "Remark<remarkLineBreak>",
   group: "Remark"
 });
-const ht = G(() => Kt);
-n(ht, {
+const kt = G(() => Dt);
+n(kt, {
   displayName: "Remark<remarkInlineLinkPlugin>",
   group: "Remark"
 });
-const nr = (t) => !!t.children, or = (t) => t.type === "html";
-function sr(t, e) {
+const sr = (t) => !!t.children, lr = (t) => t.type === "html";
+function ir(t, e) {
   return r(t, 0, null)[0];
   function r(a, o, s) {
-    if (nr(a)) {
+    if (sr(a)) {
       const i = [];
       for (let l = 0, c = a.children.length; l < c; l++) {
         const d = a.children[l];
@@ -1500,14 +1522,14 @@ function sr(t, e) {
     return e(a, o, s);
   }
 }
-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]);
+const ft = G(() => () => (t) => {
+  ir(t, (e, r, a) => lr(e) ? ((a == null ? void 0 : a.type) === "root" && (e.children = [{ ...e }], delete e.value, e.type = "paragraph"), [e]) : [e]);
 });
-n(yt, {
+n(ft, {
   displayName: "Remark<remarkHtmlTransformer>",
   group: "Remark"
 });
-const kt = H(() => {
+const Nt = H(() => {
   let t = !1;
   const e = new B("MILKDOWN_INLINE_NODES_CURSOR"), r = new T({
     key: e,
@@ -1541,24 +1563,24 @@ const kt = H(() => {
       },
       decorations(a) {
         if (r.getState(a)) {
-          const i = a.selection.$from.pos, l = document.createElement("span"), c = Fe.widget(i, l, {
+          const i = a.selection.$from.pos, l = document.createElement("span"), c = Ve.widget(i, l, {
             side: -1
-          }), d = document.createElement("span"), m = Fe.widget(i, d);
+          }), d = document.createElement("span"), m = Ve.widget(i, d);
           return setTimeout(() => {
             l.contentEditable = "true", d.contentEditable = "true";
-          }), Ge.create(a.doc, [c, m]);
+          }), je.create(a.doc, [c, m]);
         }
-        return Ge.empty;
+        return je.empty;
       }
     }
   });
   return r;
 });
-n(kt, {
+n(Nt, {
   displayName: "Prose<inlineNodesCursorPlugin>",
   group: "Prose"
 });
-const ft = H(() => new T({
+const It = H(() => new T({
   key: new B("MILKDOWN_HARDBREAK_MARKS"),
   appendTransaction: (t, e, r) => {
     if (!t.length)
@@ -1568,31 +1590,31 @@ const ft = H(() => new T({
       return;
     const [o] = a.steps;
     if (a.getMeta("hardbreak")) {
-      if (!(o instanceof Tt))
+      if (!(o instanceof Ot))
         return;
       const { from: l } = o;
-      return r.tr.setNodeMarkup(l, b.type(), void 0, []);
+      return r.tr.setNodeMarkup(l, x.type(), void 0, []);
     }
-    if (o instanceof Ot) {
+    if (o instanceof Kt) {
       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, []));
+        m.type === x.type() && (l = l.setNodeMarkup(u, x.type(), void 0, []));
       }), l;
     }
   }
 }));
-n(ft, {
+n(It, {
   displayName: "Prose<hardbreakClearMarkPlugin>",
   group: "Prose"
 });
-const $e = J(["table", "code_block"], "hardbreakFilterNodes");
-n($e, {
+const We = J(["table", "code_block"], "hardbreakFilterNodes");
+n(We, {
   displayName: "Ctx<hardbreakFilterNodes>",
   group: "Prose"
 });
-const Nt = H((t) => {
-  const e = t.get($e.key);
+const Ct = H((t) => {
+  const e = t.get(We.key);
   return new T({
     key: new B("MILKDOWN_HARDBREAK_FILTER"),
     filterTransaction: (r, a) => {
@@ -1608,18 +1630,18 @@ const Nt = H((t) => {
     }
   });
 });
-n(Nt, {
+n(Ct, {
   displayName: "Prose<hardbreakFilterPlugin>",
   group: "Prose"
 });
-const It = H((t) => {
+const Mt = H((t) => {
   const e = new B("MILKDOWN_HEADING_ID"), r = (a) => {
     if (a.composing || !a.editable)
       return;
     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.type === A.type()) {
         if (l.textContent.trim().length === 0)
           return;
         const d = l.attrs, m = o(l);
@@ -1639,15 +1661,15 @@ const It = H((t) => {
     })
   });
 });
-n(It, {
+n(Mt, {
   displayName: "Prose<syncHeadingIdPlugin>",
   group: "Prose"
 });
-const Ct = H(() => {
+const bt = H(() => {
   const t = (e) => {
     if (e.composing || !e.editable)
       return;
-    const r = D.type(), a = K.type(), o = A.type(), s = e.state, i = (d, m) => {
+    const r = D.type(), a = K.type(), o = C.type(), s = e.state, i = (d, m) => {
       let u = !1;
       const y = `${m + 1}.`;
       return d.label !== y && (d.label = y, u = !0), u;
@@ -1656,10 +1678,10 @@ const Ct = H(() => {
     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) => {
+        (p == null ? void 0 : p.type) === o && p.attrs.listType === "ordered" && (c = !0, l.setNodeMarkup(m, r, { spread: "true" }), d.descendants((k, q, Fe, xt) => {
           if (k.type === o) {
-            const We = { ...k.attrs };
-            i(We, Mt) && (l = l.setNodeMarkup(q, void 0, We));
+            const Ge = { ...k.attrs };
+            i(Ge, xt) && (l = l.setNodeMarkup(q, void 0, Ge));
           }
           return !1;
         }));
@@ -1679,114 +1701,115 @@ const Ct = H(() => {
     })
   });
 });
-n(Ct, {
+n(bt, {
   displayName: "Prose<syncListOrderPlugin>",
   group: "Prose"
 });
-const lr = [
+const cr = [
   P,
-  ut,
-  ft,
-  $e,
+  gt,
+  It,
+  We,
+  Ct,
   Nt,
-  kt,
-  pt,
   ht,
-  gt,
+  kt,
   yt,
-  It,
-  Ct
-], br = [_t, $t, qt, Wt, lr].flat();
+  ft,
+  Mt,
+  bt
+], Lr = [qt, Wt, Ft, Gt, cr].flat();
 export {
-  ye as blockquoteAttr,
-  fe as blockquoteKeymap,
+  ke as blockquoteAttr,
+  Ne as blockquoteKeymap,
   E as blockquoteSchema,
-  we as bulletListAttr,
-  ve as bulletListKeymap,
+  Ae as bulletListAttr,
+  He as bulletListKeymap,
   K as bulletListSchema,
-  Ne as codeBlockAttr,
-  Ce as codeBlockKeymap,
+  Ie as codeBlockAttr,
+  Me 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,
+  Ft as commands,
+  Lr as commonmark,
+  Ce as createCodeBlockCommand,
+  ot as createCodeBlockInputRule,
+  Qt as defaultConfig,
+  rt as docSchema,
+  he as downgradeHeadingCommand,
+  te as emphasisAttr,
+  ae 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,
+  xe as hardbreakAttr,
+  It as hardbreakClearMarkPlugin,
+  We as hardbreakFilterNodes,
+  Ct as hardbreakFilterPlugin,
+  Se as hardbreakKeymap,
+  x as hardbreakSchema,
+  ge as headingAttr,
   z as headingIdGenerator,
-  he as headingKeymap,
-  w as headingSchema,
-  Se as hrAttr,
+  ye as headingKeymap,
+  A as headingSchema,
+  we as hrAttr,
   $ as hrSchema,
-  Ee as htmlAttr,
-  _e as htmlSchema,
-  Me as imageAttr,
+  $e as htmlAttr,
+  qe as htmlSchema,
+  be as imageAttr,
   O as imageSchema,
-  se as inlineCodeAttr,
-  ie as inlineCodeKeymap,
-  M as inlineCodeSchema,
-  kt as inlineNodesCursorPlugin,
+  le as inlineCodeAttr,
+  ce as inlineCodeKeymap,
+  b as inlineCodeSchema,
+  Nt 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,
+  gt as inlineSyncPlugin,
+  Wt as inputrules,
+  Le as insertHardbreakCommand,
+  ct as insertHrCommand,
+  it as insertHrInputRule,
+  st as insertImageCommand,
+  _t as insertImageInputRule,
+  Gt as keymap,
+  Ee as liftFirstListItemCommand,
+  Pe as liftListItemCommand,
+  de as linkAttr,
   v as linkSchema,
-  Oe as listItemAttr,
-  Re as listItemKeymap,
-  A as listItemSchema,
-  He as orderedListAttr,
-  Te as orderedListKeymap,
+  Ke as listItemAttr,
+  _e as listItemKeymap,
+  C as listItemSchema,
+  Be as orderedListAttr,
+  Oe as orderedListKeymap,
   D as orderedListSchema,
-  de as paragraphAttr,
-  ue as paragraphKeymap,
-  S as paragraphSchema,
-  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,
+  me as paragraphAttr,
+  pe as paragraphKeymap,
+  w as paragraphSchema,
+  cr as plugins,
+  ht as remarkAddOrderInListPlugin,
+  ft as remarkHtmlTransformer,
+  kt as remarkInlineLinkPlugin,
+  yt as remarkLineBreak,
+  qt as schema,
+  De as sinkListItemCommand,
+  Re as splitListItemCommand,
+  ne as strongAttr,
+  se 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
+  Mt as syncHeadingIdPlugin,
+  bt as syncListOrderPlugin,
+  ut as textSchema,
+  re as toggleEmphasisCommand,
+  ie as toggleInlineCodeCommand,
+  et as toggleLinkCommand,
+  oe as toggleStrongCommand,
+  ue as turnIntoTextCommand,
+  Et as updateCodeBlockLanguageCommand,
+  lt as updateImageCommand,
+  tt as updateLinkCommand,
+  fe as wrapInBlockquoteCommand,
+  nt as wrapInBlockquoteInputRule,
+  ve as wrapInBulletListCommand,
+  dt as wrapInBulletListInputRule,
+  M as wrapInHeadingCommand,
+  at as wrapInHeadingInputRule,
+  Te as wrapInOrderedListCommand,
+  mt as wrapInOrderedListInputRule
 };
 //# sourceMappingURL=index.es.js.map