@milkdown/preset-commonmark 7.6.3 → 7.6.4

package/lib/index.es.js

@@ -1,265 +1,297 @@
-import { $markAttr as U, $markSchema as G, $inputRule as h, $command as u, $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 g, editorViewCtx as At } from "@milkdown/core";
-import { toggleMark as J, setBlockType as K, wrapIn as Q } from "@milkdown/prose/commands";
-import { Fragment as wt } from "@milkdown/prose/model";
-import { expectDomTypeError as A } from "@milkdown/exception";
-import { textblockTypeInputRule as Ze, wrappingInputRule as X, InputRule as et } from "@milkdown/prose/inputrules";
-import { TextSelection as Y, Selection as tt, PluginKey as E, Plugin as P } from "@milkdown/prose/state";
-import { markRule as j, findSelectedNodeOfType as Ht } from "@milkdown/prose";
-import { sinkListItem as Bt, splitListItem as Rt, liftListItem as rt } from "@milkdown/prose/schema-list";
-import { ReplaceStep as vt, AddMarkStep as Ot } from "@milkdown/prose/transform";
-import { Decoration as ze, DecorationSet as Je } from "@milkdown/prose/view";
-import { visit as Z } from "unist-util-visit";
-import Tt 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);
+import { $markAttr, $markSchema, $inputRule, $command, $useKeymap, $node, $nodeAttr, $nodeSchema, $ctx, $remark, $prose } from "@milkdown/utils";
+import { remarkStringifyOptionsCtx, commandsCtx, editorViewCtx } from "@milkdown/core";
+import { toggleMark, setBlockType, wrapIn } from "@milkdown/prose/commands";
+import { Fragment } from "@milkdown/prose/model";
+import { expectDomTypeError } from "@milkdown/exception";
+import { textblockTypeInputRule, wrappingInputRule, InputRule } from "@milkdown/prose/inputrules";
+import { TextSelection, Selection, PluginKey, Plugin } from "@milkdown/prose/state";
+import { markRule, findSelectedNodeOfType } from "@milkdown/prose";
+import { sinkListItem, splitListItem, liftListItem } from "@milkdown/prose/schema-list";
+import { ReplaceStep, AddMarkStep } from "@milkdown/prose/transform";
+import { Decoration, DecorationSet } from "@milkdown/prose/view";
+import { visit } from "unist-util-visit";
+import remarkInlineLinks from "remark-inline-links";
+function serializeText(state, node) {
+  var _a;
+  const lastIsHardBreak = node.childCount >= 1 && ((_a = node.lastChild) == null ? void 0 : _a.type.name) === "hardbreak";
+  if (!lastIsHardBreak) {
+    state.next(node.content);
     return;
   }
-  const a = [];
-  e.content.forEach((s, l, i) => {
-    i !== e.childCount - 1 && a.push(s);
-  }), t.next(wt.fromArray(a));
+  const contentArr = [];
+  node.content.forEach((n, _, i) => {
+    if (i === node.childCount - 1) return;
+    contentArr.push(n);
+  });
+  state.next(Fragment.fromArray(contentArr));
 }
-function n(t, e) {
-  return Object.assign(t, {
+function withMeta(plugin, meta) {
+  Object.assign(plugin, {
     meta: {
       package: "@milkdown/preset-commonmark",
-      ...e
+      ...meta
     }
-  }), t;
+  });
+  return plugin;
 }
-const ee = U("emphasis");
-n(ee, {
+const emphasisAttr = $markAttr("emphasis");
+withMeta(emphasisAttr, {
   displayName: "Attr<emphasis>",
   group: "Emphasis"
 });
-const R = G("emphasis", (t) => ({
+const emphasisSchema = $markSchema("emphasis", (ctx) => ({
   attrs: {
     marker: {
-      default: t.get(Ye).emphasis || "*"
+      default: ctx.get(remarkStringifyOptionsCtx).emphasis || "*"
     }
   },
   parseDOM: [
     { tag: "i" },
     { tag: "em" },
-    { style: "font-style", getAttrs: (e) => e === "italic" }
+    { style: "font-style", getAttrs: (value) => value === "italic" }
   ],
-  toDOM: (e) => ["em", t.get(ee.key)(e)],
+  toDOM: (mark) => ["em", ctx.get(emphasisAttr.key)(mark)],
   parseMarkdown: {
-    match: (e) => e.type === "emphasis",
-    runner: (e, r, a) => {
-      e.openMark(a, { marker: r.marker }), e.next(r.children), e.closeMark(a);
+    match: (node) => node.type === "emphasis",
+    runner: (state, node, markType) => {
+      state.openMark(markType, { marker: node.marker });
+      state.next(node.children);
+      state.closeMark(markType);
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "emphasis",
-    runner: (e, r) => {
-      e.withMark(r, "emphasis", void 0, {
-        marker: r.attrs.marker
+    match: (mark) => mark.type.name === "emphasis",
+    runner: (state, mark) => {
+      state.withMark(mark, "emphasis", void 0, {
+        marker: mark.attrs.marker
       });
     }
   }
 }));
-n(R.mark, {
+withMeta(emphasisSchema.mark, {
   displayName: "MarkSchema<emphasis>",
   group: "Emphasis"
 });
-n(R.ctx, {
+withMeta(emphasisSchema.ctx, {
   displayName: "MarkSchemaCtx<emphasis>",
   group: "Emphasis"
 });
-const te = u("ToggleEmphasis", (t) => () => J(R.type(t)));
-n(te, {
+const toggleEmphasisCommand = $command("ToggleEmphasis", (ctx) => () => {
+  return toggleMark(emphasisSchema.type(ctx));
+});
+withMeta(toggleEmphasisCommand, {
   displayName: "Command<toggleEmphasisCommand>",
   group: "Emphasis"
 });
-const nt = h((t) => j(/(?:^|[^*])\*([^*]+)\*$/, R.type(t), {
-  getAttr: () => ({
-    marker: "*"
-  }),
-  updateCaptured: ({ fullMatch: e, start: r }) => e.startsWith("*") ? {} : { fullMatch: e.slice(1), start: r + 1 }
-}));
-n(nt, {
+const emphasisStarInputRule = $inputRule((ctx) => {
+  return markRule(/(?:^|[^*])\*([^*]+)\*$/, emphasisSchema.type(ctx), {
+    getAttr: () => ({
+      marker: "*"
+    }),
+    updateCaptured: ({ fullMatch, start }) => !fullMatch.startsWith("*") ? { fullMatch: fullMatch.slice(1), start: start + 1 } : {}
+  });
+});
+withMeta(emphasisStarInputRule, {
   displayName: "InputRule<emphasis>|Star",
   group: "Emphasis"
 });
-const ot = h((t) => j(/(?:^|[^_])_([^_]+)_$/, R.type(t), {
-  getAttr: () => ({
-    marker: "_"
-  }),
-  updateCaptured: ({ fullMatch: e, start: r }) => e.startsWith("_") ? {} : { fullMatch: e.slice(1), start: r + 1 }
-}));
-n(ot, {
+const emphasisUnderscoreInputRule = $inputRule((ctx) => {
+  return markRule(/(?:^|[^_])_([^_]+)_$/, emphasisSchema.type(ctx), {
+    getAttr: () => ({
+      marker: "_"
+    }),
+    updateCaptured: ({ fullMatch, start }) => !fullMatch.startsWith("_") ? { fullMatch: fullMatch.slice(1), start: start + 1 } : {}
+  });
+});
+withMeta(emphasisUnderscoreInputRule, {
   displayName: "InputRule<emphasis>|Underscore",
   group: "Emphasis"
 });
-const re = f("emphasisKeymap", {
+const emphasisKeymap = $useKeymap("emphasisKeymap", {
   ToggleEmphasis: {
     shortcuts: "Mod-i",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(te.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(toggleEmphasisCommand.key);
     }
   }
 });
-n(re.ctx, {
+withMeta(emphasisKeymap.ctx, {
   displayName: "KeymapCtx<emphasis>",
   group: "Emphasis"
 });
-n(re.shortcuts, {
+withMeta(emphasisKeymap.shortcuts, {
   displayName: "Keymap<emphasis>",
   group: "Emphasis"
 });
-const ae = U("strong");
-n(ae, {
+const strongAttr = $markAttr("strong");
+withMeta(strongAttr, {
   displayName: "Attr<strong>",
   group: "Strong"
 });
-const $ = G("strong", (t) => ({
+const strongSchema = $markSchema("strong", (ctx) => ({
   attrs: {
     marker: {
-      default: t.get(Ye).strong || "*"
+      default: ctx.get(remarkStringifyOptionsCtx).strong || "*"
     }
   },
   parseDOM: [
     { tag: "b" },
     { tag: "strong" },
-    { style: "font-style", getAttrs: (e) => e === "bold" }
+    { style: "font-style", getAttrs: (value) => value === "bold" }
   ],
-  toDOM: (e) => ["strong", t.get(ae.key)(e)],
+  toDOM: (mark) => ["strong", ctx.get(strongAttr.key)(mark)],
   parseMarkdown: {
-    match: (e) => e.type === "strong",
-    runner: (e, r, a) => {
-      e.openMark(a, { marker: r.marker }), e.next(r.children), e.closeMark(a);
+    match: (node) => node.type === "strong",
+    runner: (state, node, markType) => {
+      state.openMark(markType, { marker: node.marker });
+      state.next(node.children);
+      state.closeMark(markType);
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "strong",
-    runner: (e, r) => {
-      e.withMark(r, "strong", void 0, {
-        marker: r.attrs.marker
+    match: (mark) => mark.type.name === "strong",
+    runner: (state, mark) => {
+      state.withMark(mark, "strong", void 0, {
+        marker: mark.attrs.marker
       });
     }
   }
 }));
-n($.mark, {
+withMeta(strongSchema.mark, {
   displayName: "MarkSchema<strong>",
   group: "Strong"
 });
-n($.ctx, {
+withMeta(strongSchema.ctx, {
   displayName: "MarkSchemaCtx<strong>",
   group: "Strong"
 });
-const ne = u("ToggleStrong", (t) => () => J($.type(t)));
-n(ne, {
+const toggleStrongCommand = $command("ToggleStrong", (ctx) => () => {
+  return toggleMark(strongSchema.type(ctx));
+});
+withMeta(toggleStrongCommand, {
   displayName: "Command<toggleStrongCommand>",
   group: "Strong"
 });
-const st = h((t) => j(/(?:\*\*|__)([^*_]+)(?:\*\*|__)$/, $.type(t), {
-  getAttr: (e) => ({
-    marker: e[0].startsWith("*") ? "*" : "_"
-  })
-}));
-n(st, {
+const strongInputRule = $inputRule((ctx) => {
+  return markRule(/(?:\*\*|__)([^*_]+)(?:\*\*|__)$/, strongSchema.type(ctx), {
+    getAttr: (match) => {
+      return {
+        marker: match[0].startsWith("*") ? "*" : "_"
+      };
+    }
+  });
+});
+withMeta(strongInputRule, {
   displayName: "InputRule<strong>",
   group: "Strong"
 });
-const oe = f("strongKeymap", {
+const strongKeymap = $useKeymap("strongKeymap", {
   ToggleBold: {
     shortcuts: ["Mod-b"],
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(ne.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(toggleStrongCommand.key);
     }
   }
 });
-n(oe.ctx, {
+withMeta(strongKeymap.ctx, {
   displayName: "KeymapCtx<strong>",
   group: "Strong"
 });
-n(oe.shortcuts, {
+withMeta(strongKeymap.shortcuts, {
   displayName: "Keymap<strong>",
   group: "Strong"
 });
-const se = U("inlineCode");
-n(se, {
+const inlineCodeAttr = $markAttr("inlineCode");
+withMeta(inlineCodeAttr, {
   displayName: "Attr<inlineCode>",
   group: "InlineCode"
 });
-const x = G("inlineCode", (t) => ({
+const inlineCodeSchema = $markSchema("inlineCode", (ctx) => ({
   priority: 100,
-  code: !0,
-  inclusive: !1,
+  code: true,
+  inclusive: false,
   parseDOM: [{ tag: "code" }],
-  toDOM: (e) => ["code", t.get(se.key)(e)],
+  toDOM: (mark) => ["code", ctx.get(inlineCodeAttr.key)(mark)],
   parseMarkdown: {
-    match: (e) => e.type === "inlineCode",
-    runner: (e, r, a) => {
-      e.openMark(a), e.addText(r.value), e.closeMark(a);
+    match: (node) => node.type === "inlineCode",
+    runner: (state, node, markType) => {
+      state.openMark(markType);
+      state.addText(node.value);
+      state.closeMark(markType);
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "inlineCode",
-    runner: (e, r, a) => {
-      e.withMark(r, "inlineCode", a.text || "");
+    match: (mark) => mark.type.name === "inlineCode",
+    runner: (state, mark, node) => {
+      state.withMark(mark, "inlineCode", node.text || "");
     }
   }
 }));
-n(x.mark, {
+withMeta(inlineCodeSchema.mark, {
   displayName: "MarkSchema<inlineCode>",
   group: "InlineCode"
 });
-n(x.ctx, {
+withMeta(inlineCodeSchema.ctx, {
   displayName: "MarkSchemaCtx<inlineCode>",
   group: "InlineCode"
 });
-const le = u(
+const toggleInlineCodeCommand = $command(
   "ToggleInlineCode",
-  (t) => () => (e, r) => {
-    const { selection: a, tr: o } = e;
-    if (a.empty) return !1;
-    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);
+  (ctx) => () => (state, dispatch) => {
+    const { selection, tr } = state;
+    if (selection.empty) return false;
+    const { from, to } = selection;
+    const has = state.doc.rangeHasMark(from, to, inlineCodeSchema.type(ctx));
+    if (has) {
+      dispatch == null ? void 0 : dispatch(tr.removeMark(from, to, inlineCodeSchema.type(ctx)));
+      return true;
+    }
+    const restMarksName = Object.keys(state.schema.marks).filter(
+      (x) => x !== inlineCodeSchema.type.name
+    );
+    restMarksName.map((name) => state.schema.marks[name]).forEach((t) => {
+      tr.removeMark(from, to, t);
+    });
+    dispatch == null ? void 0 : dispatch(tr.addMark(from, to, inlineCodeSchema.type(ctx).create()));
+    return true;
   }
 );
-n(le, {
+withMeta(toggleInlineCodeCommand, {
   displayName: "Command<toggleInlineCodeCommand>",
   group: "InlineCode"
 });
-const lt = h((t) => j(/(?:`)([^`]+)(?:`)$/, x.type(t)));
-n(lt, {
+const inlineCodeInputRule = $inputRule((ctx) => {
+  return markRule(/(?:`)([^`]+)(?:`)$/, inlineCodeSchema.type(ctx));
+});
+withMeta(inlineCodeInputRule, {
   displayName: "InputRule<inlineCodeInputRule>",
   group: "InlineCode"
 });
-const ie = f("inlineCodeKeymap", {
+const inlineCodeKeymap = $useKeymap("inlineCodeKeymap", {
   ToggleInlineCode: {
     shortcuts: "Mod-e",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(le.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(toggleInlineCodeCommand.key);
     }
   }
 });
-n(ie.ctx, {
+withMeta(inlineCodeKeymap.ctx, {
   displayName: "KeymapCtx<inlineCode>",
   group: "InlineCode"
 });
-n(ie.shortcuts, {
+withMeta(inlineCodeKeymap.shortcuts, {
   displayName: "Keymap<inlineCode>",
   group: "InlineCode"
 });
-const de = U("link");
-n(de, {
+const linkAttr = $markAttr("link");
+withMeta(linkAttr, {
   displayName: "Attr<link>",
   group: "Link"
 });
-const B = G("link", (t) => ({
+const linkSchema = $markSchema("link", (ctx) => ({
   attrs: {
     href: {},
     title: { default: null }
@@ -267,165 +299,186 @@ const B = G("link", (t) => ({
   parseDOM: [
     {
       tag: "a[href]",
-      getAttrs: (e) => {
-        if (!(e instanceof HTMLElement)) throw A(e);
+      getAttrs: (dom) => {
+        if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
         return {
-          href: e.getAttribute("href"),
-          title: e.getAttribute("title")
+          href: dom.getAttribute("href"),
+          title: dom.getAttribute("title")
         };
       }
     }
   ],
-  toDOM: (e) => ["a", { ...t.get(de.key)(e), ...e.attrs }],
+  toDOM: (mark) => ["a", { ...ctx.get(linkAttr.key)(mark), ...mark.attrs }],
   parseMarkdown: {
-    match: (e) => e.type === "link",
-    runner: (e, r, a) => {
-      const o = r.url, s = r.title;
-      e.openMark(a, { href: o, title: s }), e.next(r.children), e.closeMark(a);
+    match: (node) => node.type === "link",
+    runner: (state, node, markType) => {
+      const url = node.url;
+      const title = node.title;
+      state.openMark(markType, { href: url, title });
+      state.next(node.children);
+      state.closeMark(markType);
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "link",
-    runner: (e, r) => {
-      e.withMark(r, "link", void 0, {
-        title: r.attrs.title,
-        url: r.attrs.href
+    match: (mark) => mark.type.name === "link",
+    runner: (state, mark) => {
+      state.withMark(mark, "link", void 0, {
+        title: mark.attrs.title,
+        url: mark.attrs.href
       });
     }
   }
 }));
-n(B.mark, {
+withMeta(linkSchema.mark, {
   displayName: "MarkSchema<link>",
   group: "Link"
 });
-const it = u(
+const toggleLinkCommand = $command(
   "ToggleLink",
-  (t) => (e = {}) => J(B.type(t), e)
+  (ctx) => (payload = {}) => toggleMark(linkSchema.type(ctx), payload)
 );
-n(it, {
+withMeta(toggleLinkCommand, {
   displayName: "Command<toggleLinkCommand>",
   group: "Link"
 });
-const dt = u(
+const updateLinkCommand = $command(
   "UpdateLink",
-  (t) => (e = {}) => (r, a) => {
-    if (!a) return !1;
-    let o, s = -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 m = o.marks.find(({ type: y }) => y === B.type(t));
-    if (!m) return !1;
-    const p = s, c = s + o.nodeSize, { tr: k } = r, C = B.type(t).create({ ...m.attrs, ...e });
-    return C ? (a(
-      k.removeMark(p, c, m).addMark(p, c, C).setSelection(new Y(k.selection.$anchor)).scrollIntoView()
-    ), !0) : !1;
+  (ctx) => (payload = {}) => (state, dispatch) => {
+    if (!dispatch) return false;
+    let node;
+    let pos = -1;
+    const { selection } = state;
+    const { from, to } = selection;
+    state.doc.nodesBetween(from, from === to ? to + 1 : to, (n, p) => {
+      if (linkSchema.type(ctx).isInSet(n.marks)) {
+        node = n;
+        pos = p;
+        return false;
+      }
+      return void 0;
+    });
+    if (!node) return false;
+    const mark = node.marks.find(({ type }) => type === linkSchema.type(ctx));
+    if (!mark) return false;
+    const start = pos;
+    const end = pos + node.nodeSize;
+    const { tr } = state;
+    const linkMark = linkSchema.type(ctx).create({ ...mark.attrs, ...payload });
+    if (!linkMark) return false;
+    dispatch(
+      tr.removeMark(start, end, mark).addMark(start, end, linkMark).setSelection(new TextSelection(tr.selection.$anchor)).scrollIntoView()
+    );
+    return true;
   }
 );
-n(dt, {
+withMeta(updateLinkCommand, {
   displayName: "Command<updateLinkCommand>",
   group: "Link"
 });
-const mt = Qe("doc", () => ({
+const docSchema = $node("doc", () => ({
   content: "block+",
   parseMarkdown: {
-    match: ({ type: t }) => t === "root",
-    runner: (t, e, r) => {
-      t.injectRoot(e, r);
+    match: ({ type }) => type === "root",
+    runner: (state, node, type) => {
+      state.injectRoot(node, type);
     }
   },
   toMarkdown: {
-    match: (t) => t.type.name === "doc",
-    runner: (t, e) => {
-      t.openNode("root"), t.next(e.content);
+    match: (node) => node.type.name === "doc",
+    runner: (state, node) => {
+      state.openNode("root");
+      state.next(node.content);
     }
   }
 }));
-n(mt, {
+withMeta(docSchema, {
   displayName: "NodeSchema<doc>",
   group: "Doc"
 });
-const me = N("paragraph");
-n(me, {
+const paragraphAttr = $nodeAttr("paragraph");
+withMeta(paragraphAttr, {
   displayName: "Attr<paragraph>",
   group: "Paragraph"
 });
-const w = I("paragraph", (t) => ({
+const paragraphSchema = $nodeSchema("paragraph", (ctx) => ({
   content: "inline*",
   group: "block",
   parseDOM: [{ tag: "p" }],
-  toDOM: (e) => ["p", t.get(me.key)(e), 0],
+  toDOM: (node) => ["p", ctx.get(paragraphAttr.key)(node), 0],
   parseMarkdown: {
-    match: (e) => e.type === "paragraph",
-    runner: (e, r, a) => {
-      e.openNode(a), r.children ? e.next(r.children) : e.addText(r.value || ""), e.closeNode();
+    match: (node) => node.type === "paragraph",
+    runner: (state, node, type) => {
+      state.openNode(type);
+      if (node.children) state.next(node.children);
+      else state.addText(node.value || "");
+      state.closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "paragraph",
-    runner: (e, r) => {
-      e.openNode("paragraph"), at(e, r), e.closeNode();
+    match: (node) => node.type.name === "paragraph",
+    runner: (state, node) => {
+      state.openNode("paragraph");
+      serializeText(state, node);
+      state.closeNode();
     }
   }
 }));
-n(w.node, {
+withMeta(paragraphSchema.node, {
   displayName: "NodeSchema<paragraph>",
   group: "Paragraph"
 });
-n(w.ctx, {
+withMeta(paragraphSchema.ctx, {
   displayName: "NodeSchemaCtx<paragraph>",
   group: "Paragraph"
 });
-const pe = u(
+const turnIntoTextCommand = $command(
   "TurnIntoText",
-  (t) => () => K(w.type(t))
+  (ctx) => () => setBlockType(paragraphSchema.type(ctx))
 );
-n(pe, {
+withMeta(turnIntoTextCommand, {
   displayName: "Command<turnIntoTextCommand>",
   group: "Paragraph"
 });
-const ce = f("paragraphKeymap", {
+const paragraphKeymap = $useKeymap("paragraphKeymap", {
   TurnIntoText: {
     shortcuts: "Mod-Alt-0",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(pe.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(turnIntoTextCommand.key);
     }
   }
 });
-n(ce.ctx, {
+withMeta(paragraphKeymap.ctx, {
   displayName: "KeymapCtx<paragraph>",
   group: "Paragraph"
 });
-n(ce.shortcuts, {
+withMeta(paragraphKeymap.shortcuts, {
   displayName: "Keymap<paragraph>",
   group: "Paragraph"
 });
-const Kt = Array(6).fill(0).map((t, e) => e + 1);
-function Dt(t) {
-  return t.textContent.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-");
+const headingIndex = Array(6).fill(0).map((_, i) => i + 1);
+function defaultHeadingIdGenerator(node) {
+  return node.textContent.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-");
 }
-const z = Xe(
-  Dt,
+const headingIdGenerator = $ctx(
+  defaultHeadingIdGenerator,
   "headingIdGenerator"
 );
-n(z, {
+withMeta(headingIdGenerator, {
   displayName: "Ctx<HeadingIdGenerator>",
   group: "Heading"
 });
-const ue = N("heading");
-n(ue, {
+const headingAttr = $nodeAttr("heading");
+withMeta(headingAttr, {
   displayName: "Attr<heading>",
   group: "Heading"
 });
-const H = I("heading", (t) => {
-  const e = t.get(z.key);
+const headingSchema = $nodeSchema("heading", (ctx) => {
+  const getId = ctx.get(headingIdGenerator.key);
   return {
     content: "inline*",
     group: "block",
-    defining: !0,
+    defining: true,
     attrs: {
       id: {
         default: ""
@@ -434,682 +487,749 @@ const H = I("heading", (t) => {
         default: 1
       }
     },
-    parseDOM: Kt.map((r) => ({
-      tag: `h${r}`,
-      getAttrs: (a) => {
-        if (!(a instanceof HTMLElement)) throw A(a);
-        return { level: r, id: a.id };
+    parseDOM: headingIndex.map((x) => ({
+      tag: `h${x}`,
+      getAttrs: (node) => {
+        if (!(node instanceof HTMLElement)) throw expectDomTypeError(node);
+        return { level: x, id: node.id };
       }
     })),
-    toDOM: (r) => [
-      `h${r.attrs.level}`,
-      {
-        ...t.get(ue.key)(r),
-        id: r.attrs.id || e(r)
-      },
-      0
-    ],
+    toDOM: (node) => {
+      return [
+        `h${node.attrs.level}`,
+        {
+          ...ctx.get(headingAttr.key)(node),
+          id: node.attrs.id || getId(node)
+        },
+        0
+      ];
+    },
     parseMarkdown: {
-      match: ({ type: r }) => r === "heading",
-      runner: (r, a, o) => {
-        const s = a.depth;
-        r.openNode(o, { level: s }), r.next(a.children), r.closeNode();
+      match: ({ type }) => type === "heading",
+      runner: (state, node, type) => {
+        const depth = node.depth;
+        state.openNode(type, { level: depth });
+        state.next(node.children);
+        state.closeNode();
       }
     },
     toMarkdown: {
-      match: (r) => r.type.name === "heading",
-      runner: (r, a) => {
-        r.openNode("heading", void 0, { depth: a.attrs.level }), at(r, a), r.closeNode();
+      match: (node) => node.type.name === "heading",
+      runner: (state, node) => {
+        state.openNode("heading", void 0, { depth: node.attrs.level });
+        serializeText(state, node);
+        state.closeNode();
       }
     }
   };
 });
-n(H.node, {
+withMeta(headingSchema.node, {
   displayName: "NodeSchema<heading>",
   group: "Heading"
 });
-n(H.ctx, {
+withMeta(headingSchema.ctx, {
   displayName: "NodeSchemaCtx<heading>",
   group: "Heading"
 });
-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(At), { $from: o } = a.state.selection, s = o.node();
-    if (s.type.name === "heading") {
-      let d = Number(s.attrs.level) + Number(r);
-      return d > 6 && (d = 6), { level: d };
-    }
-    return { level: r };
-  }
-));
-n(pt, {
+const wrapInHeadingInputRule = $inputRule((ctx) => {
+  return textblockTypeInputRule(
+    /^(?<hashes>#+)\s$/,
+    headingSchema.type(ctx),
+    (match) => {
+      var _a, _b;
+      const x = ((_b = (_a = match.groups) == null ? void 0 : _a.hashes) == null ? void 0 : _b.length) || 0;
+      const view = ctx.get(editorViewCtx);
+      const { $from } = view.state.selection;
+      const node = $from.node();
+      if (node.type.name === "heading") {
+        let level = Number(node.attrs.level) + Number(x);
+        if (level > 6) level = 6;
+        return { level };
+      }
+      return { level: x };
+    }
+  );
+});
+withMeta(wrapInHeadingInputRule, {
   displayName: "InputRule<wrapInHeadingInputRule>",
   group: "Heading"
 });
-const L = u("WrapInHeading", (t) => (e) => (e ?? (e = 1), e < 1 ? K(w.type(t)) : K(H.type(t), { level: e })));
-n(L, {
+const wrapInHeadingCommand = $command("WrapInHeading", (ctx) => {
+  return (level) => {
+    level ?? (level = 1);
+    if (level < 1) return setBlockType(paragraphSchema.type(ctx));
+    return setBlockType(headingSchema.type(ctx), { level });
+  };
+});
+withMeta(wrapInHeadingCommand, {
   displayName: "Command<wrapInHeadingCommand>",
   group: "Heading"
 });
-const ge = u(
+const downgradeHeadingCommand = $command(
   "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 l = s.attrs.level - 1;
-    return l ? (r == null || r(
-      e.tr.setNodeMarkup(e.selection.$from.before(), void 0, {
-        ...s.attrs,
-        level: l
+  (ctx) => () => (state, dispatch, view) => {
+    const { $from } = state.selection;
+    const node = $from.node();
+    if (node.type !== headingSchema.type(ctx) || !state.selection.empty || $from.parentOffset !== 0)
+      return false;
+    const level = node.attrs.level - 1;
+    if (!level)
+      return setBlockType(paragraphSchema.type(ctx))(state, dispatch, view);
+    dispatch == null ? void 0 : dispatch(
+      state.tr.setNodeMarkup(state.selection.$from.before(), void 0, {
+        ...node.attrs,
+        level
       })
-    ), !0) : K(w.type(t))(e, r, a);
+    );
+    return true;
   }
 );
-n(ge, {
+withMeta(downgradeHeadingCommand, {
   displayName: "Command<downgradeHeadingCommand>",
   group: "Heading"
 });
-const ke = f("headingKeymap", {
+const headingKeymap = $useKeymap("headingKeymap", {
   TurnIntoH1: {
     shortcuts: "Mod-Alt-1",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(L.key, 1);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInHeadingCommand.key, 1);
     }
   },
   TurnIntoH2: {
     shortcuts: "Mod-Alt-2",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(L.key, 2);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInHeadingCommand.key, 2);
     }
   },
   TurnIntoH3: {
     shortcuts: "Mod-Alt-3",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(L.key, 3);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInHeadingCommand.key, 3);
     }
   },
   TurnIntoH4: {
     shortcuts: "Mod-Alt-4",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(L.key, 4);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInHeadingCommand.key, 4);
     }
   },
   TurnIntoH5: {
     shortcuts: "Mod-Alt-5",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(L.key, 5);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInHeadingCommand.key, 5);
     }
   },
   TurnIntoH6: {
     shortcuts: "Mod-Alt-6",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(L.key, 6);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInHeadingCommand.key, 6);
     }
   },
   DowngradeHeading: {
     shortcuts: ["Delete", "Backspace"],
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(ge.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(downgradeHeadingCommand.key);
     }
   }
 });
-n(ke.ctx, {
+withMeta(headingKeymap.ctx, {
   displayName: "KeymapCtx<heading>",
   group: "Heading"
 });
-n(ke.shortcuts, {
+withMeta(headingKeymap.shortcuts, {
   displayName: "Keymap<heading>",
   group: "Heading"
 });
-const ye = N("blockquote");
-n(ye, {
+const blockquoteAttr = $nodeAttr("blockquote");
+withMeta(blockquoteAttr, {
   displayName: "Attr<blockquote>",
   group: "Blockquote"
 });
-const q = I(
+const blockquoteSchema = $nodeSchema(
   "blockquote",
-  (t) => ({
+  (ctx) => ({
     content: "block+",
     group: "block",
-    defining: !0,
+    defining: true,
     parseDOM: [{ tag: "blockquote" }],
-    toDOM: (e) => ["blockquote", t.get(ye.key)(e), 0],
+    toDOM: (node) => ["blockquote", ctx.get(blockquoteAttr.key)(node), 0],
     parseMarkdown: {
-      match: ({ type: e }) => e === "blockquote",
-      runner: (e, r, a) => {
-        e.openNode(a).next(r.children).closeNode();
+      match: ({ type }) => type === "blockquote",
+      runner: (state, node, type) => {
+        state.openNode(type).next(node.children).closeNode();
       }
     },
     toMarkdown: {
-      match: (e) => e.type.name === "blockquote",
-      runner: (e, r) => {
-        e.openNode("blockquote").next(r.content).closeNode();
+      match: (node) => node.type.name === "blockquote",
+      runner: (state, node) => {
+        state.openNode("blockquote").next(node.content).closeNode();
       }
     }
   })
 );
-n(q.node, {
+withMeta(blockquoteSchema.node, {
   displayName: "NodeSchema<blockquote>",
   group: "Blockquote"
 });
-n(q.ctx, {
+withMeta(blockquoteSchema.ctx, {
   displayName: "NodeSchemaCtx<blockquote>",
   group: "Blockquote"
 });
-const ct = h(
-  (t) => X(/^\s*>\s$/, q.type(t))
+const wrapInBlockquoteInputRule = $inputRule(
+  (ctx) => wrappingInputRule(/^\s*>\s$/, blockquoteSchema.type(ctx))
 );
-n(ct, {
+withMeta(wrapInBlockquoteInputRule, {
   displayName: "InputRule<wrapInBlockquoteInputRule>",
   group: "Blockquote"
 });
-const he = u(
+const wrapInBlockquoteCommand = $command(
   "WrapInBlockquote",
-  (t) => () => Q(q.type(t))
+  (ctx) => () => wrapIn(blockquoteSchema.type(ctx))
 );
-n(he, {
+withMeta(wrapInBlockquoteCommand, {
   displayName: "Command<wrapInBlockquoteCommand>",
   group: "Blockquote"
 });
-const fe = f("blockquoteKeymap", {
+const blockquoteKeymap = $useKeymap("blockquoteKeymap", {
   WrapInBlockquote: {
     shortcuts: "Mod-Shift-b",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(he.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInBlockquoteCommand.key);
     }
   }
 });
-n(fe.ctx, {
+withMeta(blockquoteKeymap.ctx, {
   displayName: "KeymapCtx<blockquote>",
   group: "Blockquote"
 });
-n(fe.shortcuts, {
+withMeta(blockquoteKeymap.shortcuts, {
   displayName: "Keymap<blockquote>",
   group: "Blockquote"
 });
-const Ne = N("codeBlock", () => ({
+const codeBlockAttr = $nodeAttr("codeBlock", () => ({
   pre: {},
   code: {}
 }));
-n(Ne, {
+withMeta(codeBlockAttr, {
   displayName: "Attr<codeBlock>",
   group: "CodeBlock"
 });
-const W = I("code_block", (t) => ({
-  content: "text*",
-  group: "block",
-  marks: "",
-  defining: !0,
-  code: !0,
-  attrs: {
-    language: {
-      default: ""
-    }
-  },
-  parseDOM: [
-    {
-      tag: "pre",
-      preserveWhitespace: "full",
-      getAttrs: (e) => {
-        if (!(e instanceof HTMLElement)) throw A(e);
-        return { language: e.dataset.language };
+const codeBlockSchema = $nodeSchema("code_block", (ctx) => {
+  return {
+    content: "text*",
+    group: "block",
+    marks: "",
+    defining: true,
+    code: true,
+    attrs: {
+      language: {
+        default: ""
       }
-    }
-  ],
-  toDOM: (e) => {
-    const r = t.get(Ne.key)(e);
-    return [
-      "pre",
+    },
+    parseDOM: [
       {
-        ...r.pre,
-        "data-language": e.attrs.language
-      },
-      ["code", r.code, 0]
-    ];
-  },
-  parseMarkdown: {
-    match: ({ type: e }) => e === "code",
-    runner: (e, r, a) => {
-      const o = r.lang, s = r.value;
-      e.openNode(a, { language: o }), s && e.addText(s), e.closeNode();
-    }
-  },
-  toMarkdown: {
-    match: (e) => e.type.name === "code_block",
-    runner: (e, r) => {
-      var a;
-      e.addNode("code", void 0, ((a = r.content.firstChild) == null ? void 0 : a.text) || "", {
-        lang: r.attrs.language
-      });
+        tag: "pre",
+        preserveWhitespace: "full",
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
+          return { language: dom.dataset.language };
+        }
+      }
+    ],
+    toDOM: (node) => {
+      const attr = ctx.get(codeBlockAttr.key)(node);
+      return [
+        "pre",
+        {
+          ...attr.pre,
+          "data-language": node.attrs.language
+        },
+        ["code", attr.code, 0]
+      ];
+    },
+    parseMarkdown: {
+      match: ({ type }) => type === "code",
+      runner: (state, node, type) => {
+        const language = node.lang;
+        const value = node.value;
+        state.openNode(type, { language });
+        if (value) state.addText(value);
+        state.closeNode();
+      }
+    },
+    toMarkdown: {
+      match: (node) => node.type.name === "code_block",
+      runner: (state, node) => {
+        var _a;
+        state.addNode("code", void 0, ((_a = node.content.firstChild) == null ? void 0 : _a.text) || "", {
+          lang: node.attrs.language
+        });
+      }
     }
-  }
-}));
-n(W.node, {
+  };
+});
+withMeta(codeBlockSchema.node, {
   displayName: "NodeSchema<codeBlock>",
   group: "CodeBlock"
 });
-n(W.ctx, {
+withMeta(codeBlockSchema.ctx, {
   displayName: "NodeSchemaCtx<codeBlock>",
   group: "CodeBlock"
 });
-const ut = h(
-  (t) => Ze(
+const createCodeBlockInputRule = $inputRule(
+  (ctx) => textblockTypeInputRule(
     /^```(?<language>[a-z]*)?[\s\n]$/,
-    W.type(t),
-    (e) => {
-      var r;
+    codeBlockSchema.type(ctx),
+    (match) => {
+      var _a;
       return {
-        language: ((r = e.groups) == null ? void 0 : r.language) ?? ""
+        language: ((_a = match.groups) == null ? void 0 : _a.language) ?? ""
       };
     }
   )
 );
-n(ut, {
+withMeta(createCodeBlockInputRule, {
   displayName: "InputRule<createCodeBlockInputRule>",
   group: "CodeBlock"
 });
-const Ie = u(
+const createCodeBlockCommand = $command(
   "CreateCodeBlock",
-  (t) => (e = "") => K(W.type(t), { language: e })
+  (ctx) => (language = "") => setBlockType(codeBlockSchema.type(ctx), { language })
 );
-n(Ie, {
+withMeta(createCodeBlockCommand, {
   displayName: "Command<createCodeBlockCommand>",
   group: "CodeBlock"
 });
-const _t = u(
+const updateCodeBlockLanguageCommand = $command(
   "UpdateCodeBlockLanguage",
-  () => ({ pos: t, language: e } = {
+  () => ({ pos, language } = {
     pos: -1,
     language: ""
-  }) => (r, a) => t >= 0 ? (a == null || a(r.tr.setNodeAttribute(t, "language", e)), !0) : !1
+  }) => (state, dispatch) => {
+    if (pos >= 0) {
+      dispatch == null ? void 0 : dispatch(state.tr.setNodeAttribute(pos, "language", language));
+      return true;
+    }
+    return false;
+  }
 );
-n(_t, {
+withMeta(updateCodeBlockLanguageCommand, {
   displayName: "Command<updateCodeBlockLanguageCommand>",
   group: "CodeBlock"
 });
-const Ce = f("codeBlockKeymap", {
+const codeBlockKeymap = $useKeymap("codeBlockKeymap", {
   CreateCodeBlock: {
     shortcuts: "Mod-Alt-c",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(Ie.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(createCodeBlockCommand.key);
     }
   }
 });
-n(Ce.ctx, {
+withMeta(codeBlockKeymap.ctx, {
   displayName: "KeymapCtx<codeBlock>",
   group: "CodeBlock"
 });
-n(Ce.shortcuts, {
+withMeta(codeBlockKeymap.shortcuts, {
   displayName: "Keymap<codeBlock>",
   group: "CodeBlock"
 });
-const Me = N("image");
-n(Me, {
+const imageAttr = $nodeAttr("image");
+withMeta(imageAttr, {
   displayName: "Attr<image>",
   group: "Image"
 });
-const v = I("image", (t) => ({
-  inline: !0,
-  group: "inline",
-  selectable: !0,
-  draggable: !0,
-  marks: "",
-  atom: !0,
-  defining: !0,
-  isolating: !0,
-  attrs: {
-    src: { default: "" },
-    alt: { default: "" },
-    title: { default: "" }
-  },
-  parseDOM: [
-    {
-      tag: "img[src]",
-      getAttrs: (e) => {
-        if (!(e instanceof HTMLElement)) throw A(e);
-        return {
-          src: e.getAttribute("src") || "",
-          alt: e.getAttribute("alt") || "",
-          title: e.getAttribute("title") || e.getAttribute("alt") || ""
-        };
+const imageSchema = $nodeSchema("image", (ctx) => {
+  return {
+    inline: true,
+    group: "inline",
+    selectable: true,
+    draggable: true,
+    marks: "",
+    atom: true,
+    defining: true,
+    isolating: true,
+    attrs: {
+      src: { default: "" },
+      alt: { default: "" },
+      title: { default: "" }
+    },
+    parseDOM: [
+      {
+        tag: "img[src]",
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
+          return {
+            src: dom.getAttribute("src") || "",
+            alt: dom.getAttribute("alt") || "",
+            title: dom.getAttribute("title") || dom.getAttribute("alt") || ""
+          };
+        }
+      }
+    ],
+    toDOM: (node) => {
+      return ["img", { ...ctx.get(imageAttr.key)(node), ...node.attrs }];
+    },
+    parseMarkdown: {
+      match: ({ type }) => type === "image",
+      runner: (state, node, type) => {
+        const url = node.url;
+        const alt = node.alt;
+        const title = node.title;
+        state.addNode(type, {
+          src: url,
+          alt,
+          title
+        });
+      }
+    },
+    toMarkdown: {
+      match: (node) => node.type.name === "image",
+      runner: (state, node) => {
+        state.addNode("image", void 0, void 0, {
+          title: node.attrs.title,
+          url: node.attrs.src,
+          alt: node.attrs.alt
+        });
       }
     }
-  ],
-  toDOM: (e) => ["img", { ...t.get(Me.key)(e), ...e.attrs }],
-  parseMarkdown: {
-    match: ({ type: e }) => e === "image",
-    runner: (e, r, a) => {
-      const o = r.url, s = r.alt, l = r.title;
-      e.addNode(a, {
-        src: o,
-        alt: s,
-        title: l
-      });
-    }
-  },
-  toMarkdown: {
-    match: (e) => e.type.name === "image",
-    runner: (e, r) => {
-      e.addNode("image", void 0, void 0, {
-        title: r.attrs.title,
-        url: r.attrs.src,
-        alt: r.attrs.alt
-      });
-    }
-  }
-}));
-n(v.node, {
+  };
+});
+withMeta(imageSchema.node, {
   displayName: "NodeSchema<image>",
   group: "Image"
 });
-n(v.ctx, {
+withMeta(imageSchema.ctx, {
   displayName: "NodeSchemaCtx<image>",
   group: "Image"
 });
-const gt = u(
+const insertImageCommand = $command(
   "InsertImage",
-  (t) => (e = {}) => (r, a) => {
-    if (!a) return !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;
+  (ctx) => (payload = {}) => (state, dispatch) => {
+    if (!dispatch) return true;
+    const { src = "", alt = "", title = "" } = payload;
+    const node = imageSchema.type(ctx).create({ src, alt, title });
+    if (!node) return true;
+    dispatch(state.tr.replaceSelectionWith(node).scrollIntoView());
+    return true;
   }
 );
-n(gt, {
+withMeta(insertImageCommand, {
   displayName: "Command<insertImageCommand>",
   group: "Image"
 });
-const kt = u(
+const updateImageCommand = $command(
   "UpdateImage",
-  (t) => (e = {}) => (r, a) => {
-    const o = Ht(
-      r.selection,
-      v.type(t)
+  (ctx) => (payload = {}) => (state, dispatch) => {
+    const nodeWithPos = findSelectedNodeOfType(
+      state.selection,
+      imageSchema.type(ctx)
+    );
+    if (!nodeWithPos) return false;
+    const { node, pos } = nodeWithPos;
+    const newAttrs = { ...node.attrs };
+    const { src, alt, title } = payload;
+    if (src !== void 0) newAttrs.src = src;
+    if (alt !== void 0) newAttrs.alt = alt;
+    if (title !== void 0) newAttrs.title = title;
+    dispatch == null ? void 0 : dispatch(
+      state.tr.setNodeMarkup(pos, void 0, newAttrs).scrollIntoView()
     );
-    if (!o) return !1;
-    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;
+    return true;
   }
 );
-n(kt, {
+withMeta(updateImageCommand, {
   displayName: "Command<updateImageCommand>",
   group: "Image"
 });
-const Et = h(
-  (t) => new et(
+const insertImageInputRule = $inputRule(
+  (ctx) => new InputRule(
     /!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/,
-    (e, r, a, o) => {
-      const [s, l, i = "", d] = r;
-      return s ? e.tr.replaceWith(
-        a,
-        o,
-        v.type(t).create({ src: i, alt: l, title: d })
-      ) : null;
+    (state, match, start, end) => {
+      const [matched, alt, src = "", title] = match;
+      if (matched)
+        return state.tr.replaceWith(
+          start,
+          end,
+          imageSchema.type(ctx).create({ src, alt, title })
+        );
+      return null;
     }
   )
 );
-n(Et, {
+withMeta(insertImageInputRule, {
   displayName: "InputRule<insertImageInputRule>",
   group: "Image"
 });
-const V = N("hardbreak", (t) => ({
-  "data-type": "hardbreak",
-  "data-is-inline": t.attrs.isInline
-}));
-n(V, {
+const hardbreakAttr = $nodeAttr("hardbreak", (node) => {
+  return {
+    "data-type": "hardbreak",
+    "data-is-inline": node.attrs.isInline
+  };
+});
+withMeta(hardbreakAttr, {
   displayName: "Attr<hardbreak>",
   group: "Hardbreak"
 });
-const S = I("hardbreak", (t) => ({
-  inline: !0,
+const hardbreakSchema = $nodeSchema("hardbreak", (ctx) => ({
+  inline: true,
   group: "inline",
   attrs: {
     isInline: {
-      default: !1
+      default: false
     }
   },
-  selectable: !1,
+  selectable: false,
   parseDOM: [
     { tag: "br" },
     {
       tag: 'span[data-type="hardbreak"]',
-      getAttrs: () => ({ isInline: !0 })
+      getAttrs: () => ({ isInline: true })
     }
   ],
-  toDOM: (e) => e.attrs.isInline ? ["span", t.get(V.key)(e), " "] : ["br", t.get(V.key)(e)],
+  toDOM: (node) => node.attrs.isInline ? ["span", ctx.get(hardbreakAttr.key)(node), " "] : ["br", ctx.get(hardbreakAttr.key)(node)],
   parseMarkdown: {
-    match: ({ type: e }) => e === "break",
-    runner: (e, r, a) => {
-      var o;
-      e.addNode(a, {
-        isInline: !!((o = r.data) != null && o.isInline)
+    match: ({ type }) => type === "break",
+    runner: (state, node, type) => {
+      var _a;
+      state.addNode(type, {
+        isInline: Boolean(
+          (_a = node.data) == null ? void 0 : _a.isInline
+        )
       });
     }
   },
-  leafText: () => `
-`,
+  leafText: () => "\n",
   toMarkdown: {
-    match: (e) => e.type.name === "hardbreak",
-    runner: (e, r) => {
-      r.attrs.isInline ? e.addNode("text", void 0, `
-`) : e.addNode("break");
+    match: (node) => node.type.name === "hardbreak",
+    runner: (state, node) => {
+      if (node.attrs.isInline) state.addNode("text", void 0, "\n");
+      else state.addNode("break");
     }
   }
 }));
-n(S.node, {
+withMeta(hardbreakSchema.node, {
   displayName: "NodeSchema<hardbreak>",
   group: "Hardbreak"
 });
-n(S.ctx, {
+withMeta(hardbreakSchema.ctx, {
   displayName: "NodeSchemaCtx<hardbreak>",
   group: "Hardbreak"
 });
-const be = u(
+const insertHardbreakCommand = $command(
   "InsertHardbreak",
-  (t) => () => (e, r) => {
-    var s;
-    const { selection: a, tr: o } = e;
-    if (!(a instanceof Y)) return !1;
-    if (a.empty) {
-      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(tt.near(o.doc.resolve(a.to))).scrollIntoView()
-        ), !0;
-    }
-    return r == null || r(
-      o.setMeta("hardbreak", !0).replaceSelectionWith(S.type(t).create()).scrollIntoView()
-    ), !0;
+  (ctx) => () => (state, dispatch) => {
+    var _a;
+    const { selection, tr } = state;
+    if (!(selection instanceof TextSelection)) return false;
+    if (selection.empty) {
+      const node = selection.$from.node();
+      if (node.childCount > 0 && ((_a = node.lastChild) == null ? void 0 : _a.type.name) === "hardbreak") {
+        dispatch == null ? void 0 : dispatch(
+          tr.replaceRangeWith(
+            selection.to - 1,
+            selection.to,
+            state.schema.node("paragraph")
+          ).setSelection(Selection.near(tr.doc.resolve(selection.to))).scrollIntoView()
+        );
+        return true;
+      }
+    }
+    dispatch == null ? void 0 : dispatch(
+      tr.setMeta("hardbreak", true).replaceSelectionWith(hardbreakSchema.type(ctx).create()).scrollIntoView()
+    );
+    return true;
   }
 );
-n(be, {
+withMeta(insertHardbreakCommand, {
   displayName: "Command<insertHardbreakCommand>",
   group: "Hardbreak"
 });
-const Le = f("hardbreakKeymap", {
+const hardbreakKeymap = $useKeymap("hardbreakKeymap", {
   InsertHardbreak: {
     shortcuts: "Shift-Enter",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(be.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(insertHardbreakCommand.key);
     }
   }
 });
-n(Le.ctx, {
+withMeta(hardbreakKeymap.ctx, {
   displayName: "KeymapCtx<hardbreak>",
   group: "Hardbreak"
 });
-n(Le.shortcuts, {
+withMeta(hardbreakKeymap.shortcuts, {
   displayName: "Keymap<hardbreak>",
   group: "Hardbreak"
 });
-const xe = N("hr");
-n(xe, {
+const hrAttr = $nodeAttr("hr");
+withMeta(hrAttr, {
   displayName: "Attr<hr>",
   group: "Hr"
 });
-const F = I("hr", (t) => ({
+const hrSchema = $nodeSchema("hr", (ctx) => ({
   group: "block",
   parseDOM: [{ tag: "hr" }],
-  toDOM: (e) => ["hr", t.get(xe.key)(e)],
+  toDOM: (node) => ["hr", ctx.get(hrAttr.key)(node)],
   parseMarkdown: {
-    match: ({ type: e }) => e === "thematicBreak",
-    runner: (e, r, a) => {
-      e.addNode(a);
+    match: ({ type }) => type === "thematicBreak",
+    runner: (state, _, type) => {
+      state.addNode(type);
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "hr",
-    runner: (e) => {
-      e.addNode("thematicBreak");
+    match: (node) => node.type.name === "hr",
+    runner: (state) => {
+      state.addNode("thematicBreak");
     }
   }
 }));
-n(F.node, {
+withMeta(hrSchema.node, {
   displayName: "NodeSchema<hr>",
   group: "Hr"
 });
-n(F.ctx, {
+withMeta(hrSchema.ctx, {
   displayName: "NodeSchemaCtx<hr>",
   group: "Hr"
 });
-const yt = h(
-  (t) => new et(/^(?:---|___\s|\*\*\*\s)$/, (e, r, a, o) => {
-    const { tr: s } = e;
-    return r[0] && s.replaceWith(a - 1, o, F.type(t).create()), s;
+const insertHrInputRule = $inputRule(
+  (ctx) => new InputRule(/^(?:---|___\s|\*\*\*\s)$/, (state, match, start, end) => {
+    const { tr } = state;
+    if (match[0]) tr.replaceWith(start - 1, end, hrSchema.type(ctx).create());
+    return tr;
   })
 );
-n(yt, {
+withMeta(insertHrInputRule, {
   displayName: "InputRule<insertHrInputRule>",
   group: "Hr"
 });
-const ht = u(
+const insertHrCommand = $command(
   "InsertHr",
-  (t) => () => (e, r) => {
-    if (!r) return !0;
-    const a = w.node.type(t).create(), { tr: o, selection: s } = e, { from: l } = s, i = F.type(t).create();
-    if (!i) return !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;
+  (ctx) => () => (state, dispatch) => {
+    if (!dispatch) return true;
+    const paragraph = paragraphSchema.node.type(ctx).create();
+    const { tr, selection } = state;
+    const { from } = selection;
+    const node = hrSchema.type(ctx).create();
+    if (!node) return true;
+    const _tr = tr.replaceSelectionWith(node).insert(from, paragraph);
+    const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true);
+    if (!sel) return true;
+    dispatch(_tr.setSelection(sel).scrollIntoView());
+    return true;
   }
 );
-n(ht, {
+withMeta(insertHrCommand, {
   displayName: "Command<insertHrCommand>",
   group: "Hr"
 });
-const Se = N("bulletList");
-n(Se, {
+const bulletListAttr = $nodeAttr("bulletList");
+withMeta(bulletListAttr, {
   displayName: "Attr<bulletList>",
   group: "BulletList"
 });
-const O = I("bullet_list", (t) => ({
-  content: "listItem+",
-  group: "block",
-  attrs: {
-    spread: {
-      default: !1
-    }
-  },
-  parseDOM: [
-    {
-      tag: "ul",
-      getAttrs: (e) => {
-        if (!(e instanceof HTMLElement)) throw A(e);
-        return {
-          spread: e.dataset.spread
-        };
+const bulletListSchema = $nodeSchema("bullet_list", (ctx) => {
+  return {
+    content: "listItem+",
+    group: "block",
+    attrs: {
+      spread: {
+        default: false
       }
-    }
-  ],
-  toDOM: (e) => [
-    "ul",
-    {
-      ...t.get(Se.key)(e),
-      "data-spread": e.attrs.spread
     },
-    0
-  ],
-  parseMarkdown: {
-    match: ({ type: e, ordered: r }) => e === "list" && !r,
-    runner: (e, r, a) => {
-      const o = r.spread != null ? `${r.spread}` : "false";
-      e.openNode(a, { spread: o }).next(r.children).closeNode();
-    }
-  },
-  toMarkdown: {
-    match: (e) => e.type.name === "bullet_list",
-    runner: (e, r) => {
-      e.openNode("list", void 0, {
-        ordered: !1,
-        spread: r.attrs.spread === "true"
-      }).next(r.content).closeNode();
+    parseDOM: [
+      {
+        tag: "ul",
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
+          return {
+            spread: dom.dataset.spread
+          };
+        }
+      }
+    ],
+    toDOM: (node) => {
+      return [
+        "ul",
+        {
+          ...ctx.get(bulletListAttr.key)(node),
+          "data-spread": node.attrs.spread
+        },
+        0
+      ];
+    },
+    parseMarkdown: {
+      match: ({ type, ordered }) => type === "list" && !ordered,
+      runner: (state, node, type) => {
+        const spread = node.spread != null ? `${node.spread}` : "false";
+        state.openNode(type, { spread }).next(node.children).closeNode();
+      }
+    },
+    toMarkdown: {
+      match: (node) => node.type.name === "bullet_list",
+      runner: (state, node) => {
+        state.openNode("list", void 0, {
+          ordered: false,
+          spread: node.attrs.spread === "true"
+        }).next(node.content).closeNode();
+      }
     }
-  }
-}));
-n(O.node, {
+  };
+});
+withMeta(bulletListSchema.node, {
   displayName: "NodeSchema<bulletList>",
   group: "BulletList"
 });
-n(O.ctx, {
+withMeta(bulletListSchema.ctx, {
   displayName: "NodeSchemaCtx<bulletList>",
   group: "BulletList"
 });
-const ft = h(
-  (t) => X(/^\s*([-+*])\s$/, O.type(t))
+const wrapInBulletListInputRule = $inputRule(
+  (ctx) => wrappingInputRule(/^\s*([-+*])\s$/, bulletListSchema.type(ctx))
 );
-n(ft, {
+withMeta(wrapInBulletListInputRule, {
   displayName: "InputRule<wrapInBulletListInputRule>",
   group: "BulletList"
 });
-const Ae = u(
+const wrapInBulletListCommand = $command(
   "WrapInBulletList",
-  (t) => () => Q(O.type(t))
+  (ctx) => () => wrapIn(bulletListSchema.type(ctx))
 );
-n(Ae, {
+withMeta(wrapInBulletListCommand, {
   displayName: "Command<wrapInBulletListCommand>",
   group: "BulletList"
 });
-const we = f("bulletListKeymap", {
+const bulletListKeymap = $useKeymap("bulletListKeymap", {
   WrapInBulletList: {
     shortcuts: "Mod-Alt-8",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(Ae.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInBulletListCommand.key);
     }
   }
 });
-n(we.ctx, {
+withMeta(bulletListKeymap.ctx, {
   displayName: "KeymapCtx<bulletListKeymap>",
   group: "BulletList"
 });
-n(we.shortcuts, {
+withMeta(bulletListKeymap.shortcuts, {
   displayName: "Keymap<bulletListKeymap>",
   group: "BulletList"
 });
-const He = N("orderedList");
-n(He, {
+const orderedListAttr = $nodeAttr("orderedList");
+withMeta(orderedListAttr, {
   displayName: "Attr<orderedList>",
   group: "OrderedList"
 });
-const T = I("ordered_list", (t) => ({
+const orderedListSchema = $nodeSchema("ordered_list", (ctx) => ({
   content: "listItem+",
   group: "block",
   attrs: {
@@ -1117,101 +1237,103 @@ const T = I("ordered_list", (t) => ({
       default: 1
     },
     spread: {
-      default: !1
+      default: false
     }
   },
   parseDOM: [
     {
       tag: "ol",
-      getAttrs: (e) => {
-        if (!(e instanceof HTMLElement)) throw A(e);
+      getAttrs: (dom) => {
+        if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
         return {
-          spread: e.dataset.spread,
-          order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1
+          spread: dom.dataset.spread,
+          order: dom.hasAttribute("start") ? Number(dom.getAttribute("start")) : 1
         };
       }
     }
   ],
-  toDOM: (e) => [
+  toDOM: (node) => [
     "ol",
     {
-      ...t.get(He.key)(e),
-      ...e.attrs.order === 1 ? {} : e.attrs.order,
-      "data-spread": e.attrs.spread
+      ...ctx.get(orderedListAttr.key)(node),
+      ...node.attrs.order === 1 ? {} : node.attrs.order,
+      "data-spread": node.attrs.spread
     },
     0
   ],
   parseMarkdown: {
-    match: ({ type: e, ordered: r }) => e === "list" && !!r,
-    runner: (e, r, a) => {
-      const o = r.spread != null ? `${r.spread}` : "true";
-      e.openNode(a, { spread: o }).next(r.children).closeNode();
+    match: ({ type, ordered }) => type === "list" && !!ordered,
+    runner: (state, node, type) => {
+      const spread = node.spread != null ? `${node.spread}` : "true";
+      state.openNode(type, { spread }).next(node.children).closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "ordered_list",
-    runner: (e, r) => {
-      e.openNode("list", void 0, {
-        ordered: !0,
+    match: (node) => node.type.name === "ordered_list",
+    runner: (state, node) => {
+      state.openNode("list", void 0, {
+        ordered: true,
         start: 1,
-        spread: r.attrs.spread === "true"
-      }), e.next(r.content), e.closeNode();
+        spread: node.attrs.spread === "true"
+      });
+      state.next(node.content);
+      state.closeNode();
     }
   }
 }));
-n(T.node, {
+withMeta(orderedListSchema.node, {
   displayName: "NodeSchema<orderedList>",
   group: "OrderedList"
 });
-n(T.ctx, {
+withMeta(orderedListSchema.ctx, {
   displayName: "NodeSchemaCtx<orderedList>",
   group: "OrderedList"
 });
-const Nt = h(
-  (t) => X(
+const wrapInOrderedListInputRule = $inputRule(
+  (ctx) => wrappingInputRule(
     /^\s*(\d+)\.\s$/,
-    T.type(t),
-    (e) => ({ order: Number(e[1]) }),
-    (e, r) => r.childCount + r.attrs.order === Number(e[1])
+    orderedListSchema.type(ctx),
+    (match) => ({ order: Number(match[1]) }),
+    (match, node) => node.childCount + node.attrs.order === Number(match[1])
   )
 );
-n(Nt, {
+withMeta(wrapInOrderedListInputRule, {
   displayName: "InputRule<wrapInOrderedListInputRule>",
   group: "OrderedList"
 });
-const Be = u(
+const wrapInOrderedListCommand = $command(
   "WrapInOrderedList",
-  (t) => () => Q(T.type(t))
+  (ctx) => () => wrapIn(orderedListSchema.type(ctx))
 );
-n(Be, {
+withMeta(wrapInOrderedListCommand, {
   displayName: "Command<wrapInOrderedListCommand>",
   group: "OrderedList"
 });
-const Re = f("orderedListKeymap", {
+const orderedListKeymap = $useKeymap("orderedListKeymap", {
   WrapInOrderedList: {
     shortcuts: "Mod-Alt-7",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(Be.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(wrapInOrderedListCommand.key);
     }
   }
 });
-n(Re.ctx, {
+withMeta(orderedListKeymap.ctx, {
   displayName: "KeymapCtx<orderedList>",
   group: "OrderedList"
 });
-n(Re.shortcuts, {
+withMeta(orderedListKeymap.shortcuts, {
   displayName: "Keymap<orderedList>",
   group: "OrderedList"
 });
-const ve = N("listItem");
-n(ve, {
+const listItemAttr = $nodeAttr("listItem");
+withMeta(listItemAttr, {
   displayName: "Attr<listItem>",
   group: "ListItem"
 });
-const M = I("list_item", (t) => ({
+const listItemSchema = $nodeSchema("list_item", (ctx) => ({
   group: "listItem",
-  content: "(paragraph|blockquote) block*",
+  content: "paragraph block*",
   attrs: {
     label: {
       default: "•"
@@ -1223,707 +1345,833 @@ const M = I("list_item", (t) => ({
       default: "true"
     }
   },
-  defining: !0,
+  defining: true,
   parseDOM: [
     {
       tag: "li",
-      getAttrs: (e) => {
-        if (!(e instanceof HTMLElement)) throw A(e);
+      getAttrs: (dom) => {
+        if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
         return {
-          label: e.dataset.label,
-          listType: e.dataset.listType,
-          spread: e.dataset.spread
+          label: dom.dataset.label,
+          listType: dom.dataset.listType,
+          spread: dom.dataset.spread
         };
       }
     }
   ],
-  toDOM: (e) => [
+  toDOM: (node) => [
     "li",
     {
-      ...t.get(ve.key)(e),
-      "data-label": e.attrs.label,
-      "data-list-type": e.attrs.listType,
-      "data-spread": e.attrs.spread
+      ...ctx.get(listItemAttr.key)(node),
+      "data-label": node.attrs.label,
+      "data-list-type": node.attrs.listType,
+      "data-spread": node.attrs.spread
     },
     0
   ],
   parseMarkdown: {
-    match: ({ type: e }) => e === "listItem",
-    runner: (e, r, a) => {
-      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();
+    match: ({ type }) => type === "listItem",
+    runner: (state, node, type) => {
+      const label = node.label != null ? `${node.label}.` : "•";
+      const listType = node.label != null ? "ordered" : "bullet";
+      const spread = node.spread != null ? `${node.spread}` : "true";
+      state.openNode(type, { label, listType, spread });
+      state.next(node.children);
+      state.closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "list_item",
-    runner: (e, r) => {
-      e.openNode("listItem", void 0, {
-        spread: r.attrs.spread === "true"
-      }), e.next(r.content), e.closeNode();
+    match: (node) => node.type.name === "list_item",
+    runner: (state, node) => {
+      state.openNode("listItem", void 0, {
+        spread: node.attrs.spread === "true"
+      });
+      state.next(node.content);
+      state.closeNode();
     }
   }
 }));
-n(M.node, {
+withMeta(listItemSchema.node, {
   displayName: "NodeSchema<listItem>",
   group: "ListItem"
 });
-n(M.ctx, {
+withMeta(listItemSchema.ctx, {
   displayName: "NodeSchemaCtx<listItem>",
   group: "ListItem"
 });
-const Oe = u(
+const sinkListItemCommand = $command(
   "SinkListItem",
-  (t) => () => Bt(M.type(t))
+  (ctx) => () => sinkListItem(listItemSchema.type(ctx))
 );
-n(Oe, {
+withMeta(sinkListItemCommand, {
   displayName: "Command<sinkListItemCommand>",
   group: "ListItem"
 });
-const Te = u(
+const liftListItemCommand = $command(
   "LiftListItem",
-  (t) => () => rt(M.type(t))
+  (ctx) => () => liftListItem(listItemSchema.type(ctx))
 );
-n(Te, {
+withMeta(liftListItemCommand, {
   displayName: "Command<liftListItemCommand>",
   group: "ListItem"
 });
-const Ke = u(
+const splitListItemCommand = $command(
   "SplitListItem",
-  (t) => () => Rt(M.type(t))
+  (ctx) => () => splitListItem(listItemSchema.type(ctx))
 );
-n(Ke, {
+withMeta(splitListItemCommand, {
   displayName: "Command<splitListItemCommand>",
   group: "ListItem"
 });
-function Pt(t) {
-  return (e, r, a) => {
-    const { selection: o } = e;
-    if (!(o instanceof Y)) 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);
+function liftFirstListItem(ctx) {
+  return (state, dispatch, view) => {
+    const { selection } = state;
+    if (!(selection instanceof TextSelection)) return false;
+    const { empty, $from } = selection;
+    if (!empty || $from.parentOffset !== 0) return false;
+    const parentItem = $from.node(-1);
+    if (parentItem.type !== listItemSchema.type(ctx) || parentItem.firstChild !== $from.node())
+      return false;
+    const list = $from.node(-2);
+    if (list.childCount > 1) return false;
+    return liftListItem(listItemSchema.type(ctx))(state, dispatch, view);
   };
 }
-const De = u(
+const liftFirstListItemCommand = $command(
   "LiftFirstListItem",
-  (t) => () => Pt(t)
+  (ctx) => () => liftFirstListItem(ctx)
 );
-n(De, {
+withMeta(liftFirstListItemCommand, {
   displayName: "Command<liftFirstListItemCommand>",
   group: "ListItem"
 });
-const _e = f("listItemKeymap", {
+const listItemKeymap = $useKeymap("listItemKeymap", {
   NextListItem: {
     shortcuts: "Enter",
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(Ke.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(splitListItemCommand.key);
     }
   },
   SinkListItem: {
     shortcuts: ["Tab", "Mod-]"],
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(Oe.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(sinkListItemCommand.key);
     }
   },
   LiftListItem: {
     shortcuts: ["Shift-Tab", "Mod-["],
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(Te.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(liftListItemCommand.key);
     }
   },
   LiftFirstListItem: {
     shortcuts: ["Backspace", "Delete"],
-    command: (t) => {
-      const e = t.get(g);
-      return () => e.call(De.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(liftFirstListItemCommand.key);
     }
   }
 });
-n(_e.ctx, {
+withMeta(listItemKeymap.ctx, {
   displayName: "KeymapCtx<listItem>",
   group: "ListItem"
 });
-n(_e.shortcuts, {
+withMeta(listItemKeymap.shortcuts, {
   displayName: "Keymap<listItem>",
   group: "ListItem"
 });
-const It = Qe("text", () => ({
+const textSchema = $node("text", () => ({
   group: "inline",
   parseMarkdown: {
-    match: ({ type: t }) => t === "text",
-    runner: (t, e) => {
-      t.addText(e.value);
+    match: ({ type }) => type === "text",
+    runner: (state, node) => {
+      state.addText(node.value);
     }
   },
   toMarkdown: {
-    match: (t) => t.type.name === "text",
-    runner: (t, e) => {
-      t.addNode("text", void 0, e.text);
+    match: (node) => node.type.name === "text",
+    runner: (state, node) => {
+      state.addNode("text", void 0, node.text);
     }
   }
 }));
-n(It, {
+withMeta(textSchema, {
   displayName: "NodeSchema<text>",
   group: "Text"
 });
-const Ee = N("html");
-n(Ee, {
+const htmlAttr = $nodeAttr("html");
+withMeta(htmlAttr, {
   displayName: "Attr<html>",
   group: "Html"
 });
-const Pe = I("html", (t) => ({
-  atom: !0,
-  group: "inline",
-  inline: !0,
-  attrs: {
-    value: {
-      default: ""
-    }
-  },
-  toDOM: (e) => {
-    const r = document.createElement("span"), a = {
-      ...t.get(Ee.key)(e),
-      "data-value": e.attrs.value,
-      "data-type": "html"
-    };
-    return r.textContent = e.attrs.value, ["span", a, e.attrs.value];
-  },
-  parseDOM: [
-    {
-      tag: 'span[data-type="html"]',
-      getAttrs: (e) => ({
-        value: e.dataset.value ?? ""
-      })
-    }
-  ],
-  parseMarkdown: {
-    match: ({ type: e }) => e === "html",
-    runner: (e, r, a) => {
-      e.addNode(a, { value: r.value });
-    }
-  },
-  toMarkdown: {
-    match: (e) => e.type.name === "html",
-    runner: (e, r) => {
-      e.addNode("html", void 0, r.attrs.value);
+const htmlSchema = $nodeSchema("html", (ctx) => {
+  return {
+    atom: true,
+    group: "inline",
+    inline: true,
+    attrs: {
+      value: {
+        default: ""
+      }
+    },
+    toDOM: (node) => {
+      const span = document.createElement("span");
+      const attr = {
+        ...ctx.get(htmlAttr.key)(node),
+        "data-value": node.attrs.value,
+        "data-type": "html"
+      };
+      span.textContent = node.attrs.value;
+      return ["span", attr, node.attrs.value];
+    },
+    parseDOM: [
+      {
+        tag: 'span[data-type="html"]',
+        getAttrs: (dom) => {
+          return {
+            value: dom.dataset.value ?? ""
+          };
+        }
+      }
+    ],
+    parseMarkdown: {
+      match: ({ type }) => Boolean(type === "html"),
+      runner: (state, node, type) => {
+        state.addNode(type, { value: node.value });
+      }
+    },
+    toMarkdown: {
+      match: (node) => node.type.name === "html",
+      runner: (state, node) => {
+        state.addNode("html", void 0, node.attrs.value);
+      }
     }
-  }
-}));
-n(Pe.node, {
+  };
+});
+withMeta(htmlSchema.node, {
   displayName: "NodeSchema<html>",
   group: "Html"
 });
-n(Pe.ctx, {
+withMeta(htmlSchema.ctx, {
   displayName: "NodeSchemaCtx<html>",
   group: "Html"
 });
-const $t = [
-  mt,
-  me,
-  w,
-  z,
-  ue,
-  H,
-  V,
-  S,
-  ye,
-  q,
-  Ne,
-  W,
-  xe,
-  F,
-  Me,
-  v,
-  Se,
-  O,
-  He,
-  T,
-  ve,
-  M,
-  ee,
-  R,
-  ae,
-  $,
-  se,
-  x,
-  de,
-  B,
-  Ee,
-  Pe,
-  It
-].flat(), qt = [
-  ct,
-  ft,
-  Nt,
-  ut,
-  yt,
-  pt
-].flat(), Wt = [
-  nt,
-  ot,
-  lt,
-  st
-], Ft = [
-  pe,
-  he,
-  L,
-  ge,
-  Ie,
-  be,
-  ht,
-  gt,
-  kt,
-  Be,
-  Ae,
-  Oe,
-  Ke,
-  Te,
-  De,
-  te,
-  le,
-  ne,
-  it,
-  dt
-], Vt = [
-  fe,
-  Ce,
-  Le,
-  ke,
-  _e,
-  Re,
-  we,
-  ce,
-  re,
-  ie,
-  oe
-].flat(), $e = D(
+const schema = [
+  docSchema,
+  paragraphAttr,
+  paragraphSchema,
+  headingIdGenerator,
+  headingAttr,
+  headingSchema,
+  hardbreakAttr,
+  hardbreakSchema,
+  blockquoteAttr,
+  blockquoteSchema,
+  codeBlockAttr,
+  codeBlockSchema,
+  hrAttr,
+  hrSchema,
+  imageAttr,
+  imageSchema,
+  bulletListAttr,
+  bulletListSchema,
+  orderedListAttr,
+  orderedListSchema,
+  listItemAttr,
+  listItemSchema,
+  emphasisAttr,
+  emphasisSchema,
+  strongAttr,
+  strongSchema,
+  inlineCodeAttr,
+  inlineCodeSchema,
+  linkAttr,
+  linkSchema,
+  htmlAttr,
+  htmlSchema,
+  textSchema
+].flat();
+const inputRules = [
+  wrapInBlockquoteInputRule,
+  wrapInBulletListInputRule,
+  wrapInOrderedListInputRule,
+  createCodeBlockInputRule,
+  insertHrInputRule,
+  wrapInHeadingInputRule
+].flat();
+const markInputRules = [
+  emphasisStarInputRule,
+  emphasisUnderscoreInputRule,
+  inlineCodeInputRule,
+  strongInputRule
+];
+const commands = [
+  turnIntoTextCommand,
+  wrapInBlockquoteCommand,
+  wrapInHeadingCommand,
+  downgradeHeadingCommand,
+  createCodeBlockCommand,
+  insertHardbreakCommand,
+  insertHrCommand,
+  insertImageCommand,
+  updateImageCommand,
+  wrapInOrderedListCommand,
+  wrapInBulletListCommand,
+  sinkListItemCommand,
+  splitListItemCommand,
+  liftListItemCommand,
+  liftFirstListItemCommand,
+  toggleEmphasisCommand,
+  toggleInlineCodeCommand,
+  toggleStrongCommand,
+  toggleLinkCommand,
+  updateLinkCommand
+];
+const keymap = [
+  blockquoteKeymap,
+  codeBlockKeymap,
+  hardbreakKeymap,
+  headingKeymap,
+  listItemKeymap,
+  orderedListKeymap,
+  bulletListKeymap,
+  paragraphKeymap,
+  emphasisKeymap,
+  inlineCodeKeymap,
+  strongKeymap
+].flat();
+const remarkAddOrderInListPlugin = $remark(
   "remarkAddOrderInList",
-  () => () => (t) => {
-    Z(t, "list", (e) => {
-      if (e.ordered) {
-        const r = e.start ?? 1;
-        e.children.forEach((a, o) => {
-          a.label = o + r;
+  () => () => (tree) => {
+    visit(tree, "list", (node) => {
+      if (node.ordered) {
+        const start = node.start ?? 1;
+        node.children.forEach((child, index) => {
+          child.label = index + start;
         });
       }
     });
   }
 );
-n($e.plugin, {
+withMeta(remarkAddOrderInListPlugin.plugin, {
   displayName: "Remark<remarkAddOrderInListPlugin>",
   group: "Remark"
 });
-n($e.options, {
+withMeta(remarkAddOrderInListPlugin.options, {
   displayName: "RemarkConfig<remarkAddOrderInListPlugin>",
   group: "Remark"
 });
-const qe = D(
+const remarkLineBreak = $remark(
   "remarkLineBreak",
-  () => () => (t) => {
-    const e = /[\t ]*(?:\r?\n|\r)/g;
-    Z(
-      t,
+  () => () => (tree) => {
+    const find = /[\t ]*(?:\r?\n|\r)/g;
+    visit(
+      tree,
       "text",
-      (r, a, o) => {
-        if (!r.value || typeof r.value != "string") return;
-        const s = [];
-        let l = 0;
-        e.lastIndex = 0;
-        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);
+      (node, index, parent) => {
+        if (!node.value || typeof node.value !== "string") return;
+        const result = [];
+        let start = 0;
+        find.lastIndex = 0;
+        let match = find.exec(node.value);
+        while (match) {
+          const position = match.index;
+          if (start !== position)
+            result.push({
+              type: "text",
+              value: node.value.slice(start, position)
+            });
+          result.push({ type: "break", data: { isInline: true } });
+          start = position + match[0].length;
+          match = find.exec(node.value);
         }
-        if (s.length > 0 && o && typeof a == "number")
-          return l < r.value.length && s.push({ type: "text", value: r.value.slice(l) }), o.children.splice(a, 1, ...s), a + s.length;
+        const hasResultAndIndex = result.length > 0 && parent && typeof index === "number";
+        if (!hasResultAndIndex) return;
+        if (start < node.value.length)
+          result.push({ type: "text", value: node.value.slice(start) });
+        parent.children.splice(index, 1, ...result);
+        return index + result.length;
       }
     );
   }
 );
-n(qe.plugin, {
+withMeta(remarkLineBreak.plugin, {
   displayName: "Remark<remarkLineBreak>",
   group: "Remark"
 });
-n(qe.options, {
+withMeta(remarkLineBreak.options, {
   displayName: "RemarkConfig<remarkLineBreak>",
   group: "Remark"
 });
-const We = D(
+const remarkInlineLinkPlugin = $remark(
   "remarkInlineLink",
-  () => Tt
+  () => remarkInlineLinks
 );
-n(We.plugin, {
+withMeta(remarkInlineLinkPlugin.plugin, {
   displayName: "Remark<remarkInlineLinkPlugin>",
   group: "Remark"
 });
-n(We.options, {
+withMeta(remarkInlineLinkPlugin.options, {
   displayName: "RemarkConfig<remarkInlineLinkPlugin>",
   group: "Remark"
 });
-const Ut = (t) => !!t.children, Gt = (t) => t.type === "html";
-function jt(t, e) {
-  return r(t, 0, null)[0];
-  function r(a, o, s) {
-    if (Ut(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 c = 0, k = p.length; c < k; c++) {
-              const C = p[c];
-              C && l.push(C);
+const isParent = (node) => !!node.children;
+const isHTML = (node) => node.type === "html";
+function flatMapWithDepth(ast, fn) {
+  return transform(ast, 0, null)[0];
+  function transform(node, index, parent) {
+    if (isParent(node)) {
+      const out = [];
+      for (let i = 0, n = node.children.length; i < n; i++) {
+        const nthChild = node.children[i];
+        if (nthChild) {
+          const xs = transform(nthChild, i, node);
+          if (xs) {
+            for (let j = 0, m = xs.length; j < m; j++) {
+              const item = xs[j];
+              if (item) out.push(item);
             }
+          }
         }
       }
-      a.children = l;
+      node.children = out;
     }
-    return e(a, o, s);
+    return fn(node, index, parent);
   }
 }
-const Fe = D(
+const remarkHtmlTransformer = $remark(
   "remarkHTMLTransformer",
-  () => () => (t) => {
-    jt(t, (e, r, a) => Gt(e) ? ((a == null ? void 0 : a.type) === "root" && (e.children = [{ ...e }], delete e.value, e.type = "paragraph"), [e]) : [e]);
+  () => () => (tree) => {
+    flatMapWithDepth(tree, (node, _index, parent) => {
+      if (!isHTML(node)) return [node];
+      if ((parent == null ? void 0 : parent.type) === "root") {
+        node.children = [{ ...node }];
+        delete node.value;
+        node.type = "paragraph";
+      }
+      return [node];
+    });
   }
 );
-n(Fe.plugin, {
+withMeta(remarkHtmlTransformer.plugin, {
   displayName: "Remark<remarkHtmlTransformer>",
   group: "Remark"
 });
-n(Fe.options, {
+withMeta(remarkHtmlTransformer.options, {
   displayName: "RemarkConfig<remarkHtmlTransformer>",
   group: "Remark"
 });
-const Ve = D(
+const remarkMarker = $remark(
   "remarkMarker",
-  () => () => (t, e) => {
-    const r = (a) => e.value.charAt(a.position.start.offset);
-    Z(
-      t,
-      (a) => ["strong", "emphasis"].includes(a.type),
-      (a) => {
-        a.marker = r(a);
+  () => () => (tree, file) => {
+    const getMarker = (node) => {
+      return file.value.charAt(node.position.start.offset);
+    };
+    visit(
+      tree,
+      (node) => ["strong", "emphasis"].includes(node.type),
+      (node) => {
+        node.marker = getMarker(node);
       }
     );
   }
 );
-n(Ve.plugin, {
+withMeta(remarkMarker.plugin, {
   displayName: "Remark<remarkMarker>",
   group: "Remark"
 });
-n(Ve.options, {
+withMeta(remarkMarker.options, {
   displayName: "RemarkConfig<remarkMarker>",
   group: "Remark"
 });
-const Ct = _(() => {
-  let t = !1;
-  const e = new E(
+const inlineNodesCursorPlugin = $prose(() => {
+  let lock = false;
+  const inlineNodesCursorPluginKey = new PluginKey(
     "MILKDOWN_INLINE_NODES_CURSOR"
-  ), r = new P({
-    key: e,
+  );
+  const inlineNodesCursorPlugin2 = new Plugin({
+    key: inlineNodesCursorPluginKey,
     state: {
       init() {
-        return !1;
+        return false;
       },
-      apply(a) {
-        if (!a.selection.empty) return !1;
-        const o = a.selection.$from, s = o.nodeBefore, l = o.nodeAfter;
-        return !!(s && l && s.isInline && !s.isText && l.isInline && !l.isText);
+      apply(tr) {
+        if (!tr.selection.empty) return false;
+        const pos = tr.selection.$from;
+        const left = pos.nodeBefore;
+        const right = pos.nodeAfter;
+        if (left && right && left.isInline && !left.isText && right.isInline && !right.isText)
+          return true;
+        return false;
       }
     },
     props: {
       handleDOMEvents: {
-        compositionend: (a, o) => t ? (t = !1, requestAnimationFrame(() => {
-          if (r.getState(a.state)) {
-            const l = a.state.selection.from;
-            o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", l));
+        compositionend: (view, e) => {
+          if (lock) {
+            lock = false;
+            requestAnimationFrame(() => {
+              const active = inlineNodesCursorPlugin2.getState(view.state);
+              if (active) {
+                const from = view.state.selection.from;
+                e.preventDefault();
+                view.dispatch(view.state.tr.insertText(e.data || "", from));
+              }
+            });
+            return true;
           }
-        }), !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 l = a.state.selection.from;
-            return o.preventDefault(), a.dispatch(a.state.tr.insertText(o.data || "", l)), !0;
+          return false;
+        },
+        compositionstart: (view) => {
+          const active = inlineNodesCursorPlugin2.getState(view.state);
+          if (active) lock = true;
+          return false;
+        },
+        beforeinput: (view, e) => {
+          const active = inlineNodesCursorPlugin2.getState(view.state);
+          if (active && e instanceof InputEvent && e.data && !lock) {
+            const from = view.state.selection.from;
+            e.preventDefault();
+            view.dispatch(view.state.tr.insertText(e.data || "", from));
+            return true;
           }
-          return !1;
+          return false;
         }
       },
-      decorations(a) {
-        if (r.getState(a)) {
-          const l = a.selection.$from.pos, i = document.createElement("span"), d = ze.widget(l, i, {
+      decorations(state) {
+        const active = inlineNodesCursorPlugin2.getState(state);
+        if (active) {
+          const pos = state.selection.$from;
+          const position = pos.pos;
+          const left = document.createElement("span");
+          const leftDec = Decoration.widget(position, left, {
             side: -1
-          }), m = document.createElement("span"), p = ze.widget(l, m);
-          return setTimeout(() => {
-            i.contentEditable = "true", m.contentEditable = "true";
-          }), Je.create(a.doc, [d, p]);
+          });
+          const right = document.createElement("span");
+          const rightDec = Decoration.widget(position, right);
+          setTimeout(() => {
+            left.contentEditable = "true";
+            right.contentEditable = "true";
+          });
+          return DecorationSet.create(state.doc, [leftDec, rightDec]);
         }
-        return Je.empty;
+        return DecorationSet.empty;
       }
     }
   });
-  return r;
+  return inlineNodesCursorPlugin2;
 });
-n(Ct, {
+withMeta(inlineNodesCursorPlugin, {
   displayName: "Prose<inlineNodesCursorPlugin>",
   group: "Prose"
 });
-const Mt = _((t) => new P({
-  key: new E("MILKDOWN_HARDBREAK_MARKS"),
-  appendTransaction: (e, r, a) => {
-    if (!e.length) return;
-    const [o] = e;
-    if (!o) return;
-    const [s] = o.steps;
-    if (o.getMeta("hardbreak")) {
-      if (!(s instanceof vt)) return;
-      const { from: d } = s;
-      return a.tr.setNodeMarkup(
-        d,
-        S.type(t),
-        void 0,
-        []
-      );
-    }
-    if (s instanceof Ot) {
-      let d = a.tr;
-      const { from: m, to: p } = s;
-      return a.doc.nodesBetween(m, p, (c, k) => {
-        c.type === S.type(t) && (d = d.setNodeMarkup(
-          k,
-          S.type(t),
+const hardbreakClearMarkPlugin = $prose((ctx) => {
+  return new Plugin({
+    key: new PluginKey("MILKDOWN_HARDBREAK_MARKS"),
+    appendTransaction: (trs, _oldState, newState) => {
+      if (!trs.length) return;
+      const [tr] = trs;
+      if (!tr) return;
+      const [step] = tr.steps;
+      const isInsertHr = tr.getMeta("hardbreak");
+      if (isInsertHr) {
+        if (!(step instanceof ReplaceStep)) return;
+        const { from } = step;
+        return newState.tr.setNodeMarkup(
+          from,
+          hardbreakSchema.type(ctx),
           void 0,
           []
-        ));
-      }), d;
+        );
+      }
+      const isAddMarkStep = step instanceof AddMarkStep;
+      if (isAddMarkStep) {
+        let _tr = newState.tr;
+        const { from, to } = step;
+        newState.doc.nodesBetween(from, to, (node, pos) => {
+          if (node.type === hardbreakSchema.type(ctx))
+            _tr = _tr.setNodeMarkup(
+              pos,
+              hardbreakSchema.type(ctx),
+              void 0,
+              []
+            );
+        });
+        return _tr;
+      }
+      return void 0;
     }
-  }
-}));
-n(Mt, {
+  });
+});
+withMeta(hardbreakClearMarkPlugin, {
   displayName: "Prose<hardbreakClearMarkPlugin>",
   group: "Prose"
 });
-const Ue = Xe(
+const hardbreakFilterNodes = $ctx(
   ["table", "code_block"],
   "hardbreakFilterNodes"
 );
-n(Ue, {
+withMeta(hardbreakFilterNodes, {
   displayName: "Ctx<hardbreakFilterNodes>",
   group: "Prose"
 });
-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: 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;
+const hardbreakFilterPlugin = $prose((ctx) => {
+  const notIn = ctx.get(hardbreakFilterNodes.key);
+  return new Plugin({
+    key: new PluginKey("MILKDOWN_HARDBREAK_FILTER"),
+    filterTransaction: (tr, state) => {
+      const isInsertHr = tr.getMeta("hardbreak");
+      const [step] = tr.steps;
+      if (isInsertHr && step) {
+        const { from } = step;
+        const $from = state.doc.resolve(from);
+        let curDepth = $from.depth;
+        let canApply = true;
+        while (curDepth > 0) {
+          if (notIn.includes($from.node(curDepth).type.name)) canApply = false;
+          curDepth--;
+        }
+        return canApply;
       }
-      return !0;
+      return true;
     }
   });
 });
-n(bt, {
+withMeta(hardbreakFilterPlugin, {
   displayName: "Prose<hardbreakFilterPlugin>",
   group: "Prose"
 });
-const Lt = _((t) => {
-  const e = new E("MILKDOWN_HEADING_ID"), r = (a) => {
-    if (a.composing) return;
-    const o = t.get(z.key), s = a.state.tr.setMeta("addToHistory", !1);
-    let l = !1;
-    const i = {};
-    a.state.doc.descendants((d, m) => {
-      if (d.type === H.type(t)) {
-        if (d.textContent.trim().length === 0) return;
-        const p = d.attrs;
-        let c = o(d);
-        i[c] ? (i[c] += 1, c += `-#${i[c]}`) : i[c] = 1, p.id !== c && (l = !0, s.setMeta(e, !0).setNodeMarkup(m, void 0, {
-          ...p,
-          id: c
-        }));
+const syncHeadingIdPlugin = $prose((ctx) => {
+  const headingIdPluginKey = new PluginKey("MILKDOWN_HEADING_ID");
+  const updateId = (view) => {
+    if (view.composing) return;
+    const getId = ctx.get(headingIdGenerator.key);
+    const tr = view.state.tr.setMeta("addToHistory", false);
+    let found = false;
+    const idMap = {};
+    view.state.doc.descendants((node, pos) => {
+      if (node.type === headingSchema.type(ctx)) {
+        if (node.textContent.trim().length === 0) return;
+        const attrs = node.attrs;
+        let id = getId(node);
+        if (idMap[id]) {
+          idMap[id] += 1;
+          id += `-#${idMap[id]}`;
+        } else {
+          idMap[id] = 1;
+        }
+        if (attrs.id !== id) {
+          found = true;
+          tr.setMeta(headingIdPluginKey, true).setNodeMarkup(pos, void 0, {
+            ...attrs,
+            id
+          });
+        }
       }
-    }), l && a.dispatch(s);
+    });
+    if (found) view.dispatch(tr);
   };
-  return new P({
-    key: e,
-    view: (a) => (r(a), {
-      update: (o, s) => {
-        o.state.doc.eq(s.doc) || r(o);
-      }
-    })
+  return new Plugin({
+    key: headingIdPluginKey,
+    view: (view) => {
+      updateId(view);
+      return {
+        update: (view2, prevState) => {
+          if (view2.state.doc.eq(prevState.doc)) return;
+          updateId(view2);
+        }
+      };
+    }
   });
 });
-n(Lt, {
+withMeta(syncHeadingIdPlugin, {
   displayName: "Prose<syncHeadingIdPlugin>",
   group: "Prose"
 });
-const xt = _((t) => {
-  const e = (r) => {
-    if (r.composing || !r.editable) return;
-    const a = T.type(t), o = O.type(t), s = M.type(t), l = r.state, i = (p, c) => {
-      let k = !1;
-      const C = `${c + 1}.`;
-      return p.label !== C && (p.label = C, k = !0), k;
+const syncListOrderPlugin = $prose((ctx) => {
+  const syncOrderLabel = (view) => {
+    if (view.composing || !view.editable) return;
+    const orderedListType = orderedListSchema.type(ctx);
+    const bulletListType = bulletListSchema.type(ctx);
+    const listItemType = listItemSchema.type(ctx);
+    const state = view.state;
+    const handleNodeItem = (attrs, index) => {
+      let changed = false;
+      const expectedLabel = `${index + 1}.`;
+      if (attrs.label !== expectedLabel) {
+        attrs.label = expectedLabel;
+        changed = true;
+      }
+      return changed;
     };
-    let d = l.tr, m = !1;
-    l.doc.descendants((p, c, k, 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(c, a, { spread: "true" }), p.descendants((b, Ge, Jt, St) => {
-          if (b.type === s) {
-            const je = { ...b.attrs };
-            i(je, St) && (d = d.setNodeMarkup(Ge, void 0, je));
-          }
-          return !1;
-        }));
-      } else if (p.type === s && (k == null ? void 0 : k.type) === a) {
-        const y = { ...p.attrs };
-        let b = !1;
-        y.listType !== "ordered" && (y.listType = "ordered", b = !0), (k == null ? void 0 : k.maybeChild(0)) && (b = i(y, C)), b && (d = d.setNodeMarkup(c, void 0, y), m = !0);
+    let tr = state.tr;
+    let needDispatch = false;
+    state.doc.descendants((node, pos, parent, index) => {
+      if (node.type === bulletListType) {
+        const base = node.maybeChild(0);
+        if ((base == null ? void 0 : base.type) === listItemType && base.attrs.listType === "ordered") {
+          needDispatch = true;
+          tr.setNodeMarkup(pos, orderedListType, { spread: "true" });
+          node.descendants((child, pos2, _parent, index2) => {
+            if (child.type === listItemType) {
+              const attrs = { ...child.attrs };
+              const changed = handleNodeItem(attrs, index2);
+              if (changed) tr = tr.setNodeMarkup(pos2, void 0, attrs);
+            }
+            return false;
+          });
+        }
+      } else if (node.type === listItemType && (parent == null ? void 0 : parent.type) === orderedListType) {
+        const attrs = { ...node.attrs };
+        let changed = false;
+        if (attrs.listType !== "ordered") {
+          attrs.listType = "ordered";
+          changed = true;
+        }
+        const base = parent == null ? void 0 : parent.maybeChild(0);
+        if (base) changed = handleNodeItem(attrs, index);
+        if (changed) {
+          tr = tr.setNodeMarkup(pos, void 0, attrs);
+          needDispatch = true;
+        }
       }
-    }), m && r.dispatch(d.setMeta("addToHistory", !1));
+    });
+    if (needDispatch) view.dispatch(tr.setMeta("addToHistory", false));
   };
-  return new P({
-    key: new E("MILKDOWN_KEEP_LIST_ORDER"),
-    view: (r) => (e(r), {
-      update: (a) => {
-        e(a);
-      }
-    })
+  return new Plugin({
+    key: new PluginKey("MILKDOWN_KEEP_LIST_ORDER"),
+    view: (view) => {
+      syncOrderLabel(view);
+      return {
+        update: (view2) => {
+          syncOrderLabel(view2);
+        }
+      };
+    }
   });
 });
-n(xt, {
+withMeta(syncListOrderPlugin, {
   displayName: "Prose<syncListOrderPlugin>",
   group: "Prose"
 });
-const zt = [
-  Mt,
-  Ue,
-  bt,
-  Ct,
-  $e,
-  We,
-  qe,
-  Fe,
-  Ve,
-  Lt,
-  xt
-].flat(), mr = [
-  $t,
-  qt,
-  Wt,
-  Ft,
-  Vt,
-  zt
+const plugins = [
+  hardbreakClearMarkPlugin,
+  hardbreakFilterNodes,
+  hardbreakFilterPlugin,
+  inlineNodesCursorPlugin,
+  remarkAddOrderInListPlugin,
+  remarkInlineLinkPlugin,
+  remarkLineBreak,
+  remarkHtmlTransformer,
+  remarkMarker,
+  syncHeadingIdPlugin,
+  syncListOrderPlugin
+].flat();
+const commonmark = [
+  schema,
+  inputRules,
+  markInputRules,
+  commands,
+  keymap,
+  plugins
 ].flat();
 export {
-  ye as blockquoteAttr,
-  fe as blockquoteKeymap,
-  q as blockquoteSchema,
-  Se as bulletListAttr,
-  we as bulletListKeymap,
-  O as bulletListSchema,
-  Ne as codeBlockAttr,
-  Ce as codeBlockKeymap,
-  W as codeBlockSchema,
-  Ft as commands,
-  mr as commonmark,
-  Ie as createCodeBlockCommand,
-  ut as createCodeBlockInputRule,
-  mt as docSchema,
-  ge as downgradeHeadingCommand,
-  ee as emphasisAttr,
-  re as emphasisKeymap,
-  R as emphasisSchema,
-  nt as emphasisStarInputRule,
-  ot as emphasisUnderscoreInputRule,
-  V as hardbreakAttr,
-  Mt as hardbreakClearMarkPlugin,
-  Ue as hardbreakFilterNodes,
-  bt as hardbreakFilterPlugin,
-  Le as hardbreakKeymap,
-  S as hardbreakSchema,
-  ue as headingAttr,
-  z as headingIdGenerator,
-  ke as headingKeymap,
-  H as headingSchema,
-  xe as hrAttr,
-  F as hrSchema,
-  Ee as htmlAttr,
-  Pe as htmlSchema,
-  Me as imageAttr,
-  v as imageSchema,
-  se as inlineCodeAttr,
-  lt as inlineCodeInputRule,
-  ie as inlineCodeKeymap,
-  x as inlineCodeSchema,
-  Ct as inlineNodesCursorPlugin,
-  qt as inputRules,
-  be as insertHardbreakCommand,
-  ht as insertHrCommand,
-  yt as insertHrInputRule,
-  gt as insertImageCommand,
-  Et as insertImageInputRule,
-  Vt as keymap,
-  De as liftFirstListItemCommand,
-  Te as liftListItemCommand,
-  de as linkAttr,
-  B as linkSchema,
-  ve as listItemAttr,
-  _e as listItemKeymap,
-  M as listItemSchema,
-  Wt as markInputRules,
-  He as orderedListAttr,
-  Re as orderedListKeymap,
-  T as orderedListSchema,
-  me as paragraphAttr,
-  ce as paragraphKeymap,
-  w as paragraphSchema,
-  zt as plugins,
-  $e as remarkAddOrderInListPlugin,
-  Fe as remarkHtmlTransformer,
-  We as remarkInlineLinkPlugin,
-  qe as remarkLineBreak,
-  Ve as remarkMarker,
-  $t as schema,
-  Oe as sinkListItemCommand,
-  Ke as splitListItemCommand,
-  ae as strongAttr,
-  st as strongInputRule,
-  oe as strongKeymap,
-  $ as strongSchema,
-  Lt as syncHeadingIdPlugin,
-  xt as syncListOrderPlugin,
-  It as textSchema,
-  te as toggleEmphasisCommand,
-  le as toggleInlineCodeCommand,
-  it as toggleLinkCommand,
-  ne as toggleStrongCommand,
-  pe as turnIntoTextCommand,
-  _t as updateCodeBlockLanguageCommand,
-  kt as updateImageCommand,
-  dt as updateLinkCommand,
-  he as wrapInBlockquoteCommand,
-  ct as wrapInBlockquoteInputRule,
-  Ae as wrapInBulletListCommand,
-  ft as wrapInBulletListInputRule,
-  L as wrapInHeadingCommand,
-  pt as wrapInHeadingInputRule,
-  Be as wrapInOrderedListCommand,
-  Nt as wrapInOrderedListInputRule
+  blockquoteAttr,
+  blockquoteKeymap,
+  blockquoteSchema,
+  bulletListAttr,
+  bulletListKeymap,
+  bulletListSchema,
+  codeBlockAttr,
+  codeBlockKeymap,
+  codeBlockSchema,
+  commands,
+  commonmark,
+  createCodeBlockCommand,
+  createCodeBlockInputRule,
+  docSchema,
+  downgradeHeadingCommand,
+  emphasisAttr,
+  emphasisKeymap,
+  emphasisSchema,
+  emphasisStarInputRule,
+  emphasisUnderscoreInputRule,
+  hardbreakAttr,
+  hardbreakClearMarkPlugin,
+  hardbreakFilterNodes,
+  hardbreakFilterPlugin,
+  hardbreakKeymap,
+  hardbreakSchema,
+  headingAttr,
+  headingIdGenerator,
+  headingKeymap,
+  headingSchema,
+  hrAttr,
+  hrSchema,
+  htmlAttr,
+  htmlSchema,
+  imageAttr,
+  imageSchema,
+  inlineCodeAttr,
+  inlineCodeInputRule,
+  inlineCodeKeymap,
+  inlineCodeSchema,
+  inlineNodesCursorPlugin,
+  inputRules,
+  insertHardbreakCommand,
+  insertHrCommand,
+  insertHrInputRule,
+  insertImageCommand,
+  insertImageInputRule,
+  keymap,
+  liftFirstListItemCommand,
+  liftListItemCommand,
+  linkAttr,
+  linkSchema,
+  listItemAttr,
+  listItemKeymap,
+  listItemSchema,
+  markInputRules,
+  orderedListAttr,
+  orderedListKeymap,
+  orderedListSchema,
+  paragraphAttr,
+  paragraphKeymap,
+  paragraphSchema,
+  plugins,
+  remarkAddOrderInListPlugin,
+  remarkHtmlTransformer,
+  remarkInlineLinkPlugin,
+  remarkLineBreak,
+  remarkMarker,
+  schema,
+  sinkListItemCommand,
+  splitListItemCommand,
+  strongAttr,
+  strongInputRule,
+  strongKeymap,
+  strongSchema,
+  syncHeadingIdPlugin,
+  syncListOrderPlugin,
+  textSchema,
+  toggleEmphasisCommand,
+  toggleInlineCodeCommand,
+  toggleLinkCommand,
+  toggleStrongCommand,
+  turnIntoTextCommand,
+  updateCodeBlockLanguageCommand,
+  updateImageCommand,
+  updateLinkCommand,
+  wrapInBlockquoteCommand,
+  wrapInBlockquoteInputRule,
+  wrapInBulletListCommand,
+  wrapInBulletListInputRule,
+  wrapInHeadingCommand,
+  wrapInHeadingInputRule,
+  wrapInOrderedListCommand,
+  wrapInOrderedListInputRule
 };
 //# sourceMappingURL=index.es.js.map