@milkdown/preset-commonmark 6.1.4 → 6.3.0

package/lib/index.es.js

@@ -1,34 +1,17 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { createMark, createShortcut, createNode, createPlugin, AtomList } from "@milkdown/utils";
-import { createCmdKey, createCmd, schemaCtx, commandsCtx, editorViewCtx } from "@milkdown/core";
-import { markRule, findSelectedNodeOfType } from "@milkdown/prose";
-import { toggleMark, wrapIn, setBlockType } from "@milkdown/prose/commands";
-import { InputRule, wrappingInputRule, textblockTypeInputRule } from "@milkdown/prose/inputrules";
-import { PluginKey, TextSelection, Plugin, Selection } from "@milkdown/prose/state";
-import { Fragment } from "@milkdown/prose/model";
-import { ReplaceStep, AddMarkStep } from "@milkdown/prose/transform";
-import { splitListItem, sinkListItem, liftListItem } from "@milkdown/prose/schema-list";
-import links from "remark-inline-links";
-import { Decoration, DecorationSet } from "@milkdown/prose/view";
-const SupportedKeys = {
+import { createMark as B, createShortcut as h, createNode as w, createPlugin as He, AtomList as Ne } from "@milkdown/utils";
+import { createCmdKey as I, createCmd as M, schemaCtx as A, commandsCtx as we, editorViewCtx as R, getPalette as Te } from "@milkdown/core";
+import { markRule as _, calculateTextPosition as Oe, cloneTr as Ae, findSelectedNodeOfType as K, getNodeFromSchema as Ee } from "@milkdown/prose";
+import { toggleMark as P, wrapIn as de, setBlockType as E } from "@milkdown/prose/commands";
+import { expectDomTypeError as D, missingRootElement as _e } from "@milkdown/exception";
+import { InputRule as me, wrappingInputRule as W, textblockTypeInputRule as G } from "@milkdown/prose/inputrules";
+import { PluginKey as H, TextSelection as pe, Plugin as T, NodeSelection as ve, Selection as Le } from "@milkdown/prose/state";
+import { Fragment as ge } from "@milkdown/prose/model";
+import { ReplaceStep as $e, AddMarkStep as Se } from "@milkdown/prose/transform";
+import { DecorationSet as O, Decoration as J } from "@milkdown/prose/view";
+import { splitListItem as Be, sinkListItem as Re, liftListItem as Pe } from "@milkdown/prose/schema-list";
+import We from "remark-inline-links";
+import { visit as qe } from "unist-util-visit";
+const k = {
   HardBreak: "HardBreak",
   Blockquote: "Blockquote",
   BulletList: "BulletList",
@@ -40,6 +23,7 @@ const SupportedKeys = {
   H4: "H4",
   H5: "H5",
   H6: "H6",
+  DowngradeHeading: "DowngradeHeading",
   Text: "Text",
   CodeInline: "CodeInline",
   Em: "Em",
@@ -47,333 +31,283 @@ const SupportedKeys = {
   NextListItem: "NextListItem",
   SinkListItem: "SinkListItem",
   LiftListItem: "LiftListItem"
-};
-const id$a = "code_inline";
-const ToggleInlineCode = createCmdKey("ToggleInlineCode");
-const codeInline = createMark((utils) => {
-  return {
-    id: id$a,
-    schema: () => ({
-      priority: 100,
-      code: true,
-      inclusive: false,
-      parseDOM: [{ tag: "code" }],
-      toDOM: (mark) => ["code", { class: utils.getClassName(mark.attrs, "code-inline") }],
-      parseMarkdown: {
-        match: (node) => node.type === "inlineCode",
-        runner: (state, node, markType) => {
-          state.openMark(markType);
-          state.addText(node["value"]);
-          state.closeMark(markType);
-        }
-      },
-      toMarkdown: {
-        match: (mark) => mark.type.name === id$a,
-        runner: (state, mark, node) => {
-          state.withMark(mark, "inlineCode", node.text || "");
-        }
+}, he = "code_inline", Q = I("ToggleInlineCode"), Ke = B((c) => ({
+  id: he,
+  schema: () => ({
+    priority: 100,
+    code: !0,
+    inclusive: !1,
+    parseDOM: [{ tag: "code" }],
+    toDOM: (e) => ["code", { class: c.getClassName(e.attrs, "code-inline") }],
+    parseMarkdown: {
+      match: (e) => e.type === "inlineCode",
+      runner: (e, t, r) => {
+        e.openMark(r), e.addText(t.value), e.closeMark(r);
+      }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === he,
+      runner: (e, t, r) => {
+        e.withMark(t, "inlineCode", r.text || "");
       }
-    }),
-    inputRules: (markType) => [markRule(/(?:^|[^`])(`([^`]+)`)$/, markType)],
-    commands: (markType) => [createCmd(ToggleInlineCode, () => toggleMark(markType))],
-    shortcuts: {
-      [SupportedKeys.CodeInline]: createShortcut(ToggleInlineCode, "Mod-e")
     }
-  };
-});
-const id$9 = "em";
-const ToggleItalic = createCmdKey("ToggleItalic");
-const em = createMark((utils) => ({
-  id: id$9,
+  }),
+  inputRules: (e) => [_(/(?:^|[^`])(`([^`]+)`)$/, e)],
+  commands: (e) => [M(Q, () => P(e))],
+  shortcuts: {
+    [k.CodeInline]: h(Q, "Mod-e")
+  }
+})), F = "em", X = I("ToggleItalic"), Fe = B((c) => ({
+  id: F,
   schema: () => ({
     parseDOM: [
       { tag: "i" },
       { tag: "em" },
-      { style: "font-style", getAttrs: (value) => value === "italic" }
+      { style: "font-style", getAttrs: (e) => e === "italic" }
     ],
-    toDOM: (mark) => ["em", { class: utils.getClassName(mark.attrs, id$9) }],
+    toDOM: (e) => ["em", { class: c.getClassName(e.attrs, F) }],
     parseMarkdown: {
-      match: (node) => node.type === "emphasis",
-      runner: (state, node, markType) => {
-        state.openMark(markType);
-        state.next(node.children);
-        state.closeMark(markType);
+      match: (e) => e.type === "emphasis",
+      runner: (e, t, r) => {
+        e.openMark(r), e.next(t.children), e.closeMark(r);
       }
     },
     toMarkdown: {
-      match: (mark) => mark.type.name === id$9,
-      runner: (state, mark) => {
-        state.withMark(mark, "emphasis");
+      match: (e) => e.type.name === F,
+      runner: (e, t) => {
+        e.withMark(t, "emphasis");
       }
     }
   }),
-  inputRules: (markType) => [
-    markRule(/(?:^|[^_])(_([^_]+)_)$/, markType),
-    markRule(/(?:^|[^*])(\*([^*]+)\*)$/, markType)
+  inputRules: (e) => [
+    _(/(?:^|[^_])(_([^_]+)_)$/, e),
+    _(/(?:^|[^*])(\*([^*]+)\*)$/, e)
   ],
-  commands: (markType) => [createCmd(ToggleItalic, () => toggleMark(markType))],
+  commands: (e) => [M(X, () => P(e))],
   shortcuts: {
-    [SupportedKeys.Em]: createShortcut(ToggleItalic, "Mod-i")
+    [k.Em]: h(X, "Mod-i")
   }
-}));
-const key$1 = new PluginKey("MILKDOWN_LINK_INPUT");
-const ToggleLink = createCmdKey("ToggleLink");
-const ModifyLink = createCmdKey("ModifyLink");
-const id$8 = "link";
-const link = createMark((utils, options) => {
-  return {
-    id: id$8,
-    schema: () => ({
-      attrs: {
-        href: {},
-        title: { default: null }
-      },
-      inclusive: false,
-      parseDOM: [
-        {
-          tag: "a[href]",
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error();
-            }
-            return { href: dom.getAttribute("href"), title: dom.getAttribute("title") };
-          }
-        }
-      ],
-      toDOM: (mark) => ["a", __spreadProps(__spreadValues({}, mark.attrs), { class: utils.getClassName(mark.attrs, id$8) })],
-      parseMarkdown: {
-        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: (mark) => mark.type.name === id$8,
-        runner: (state, mark) => {
-          state.withMark(mark, "link", void 0, {
-            title: mark.attrs["title"],
-            url: mark.attrs["href"]
-          });
+})), Ue = new H("MILKDOWN_LINK_INPUT"), xe = I("ToggleLink"), Y = I("ModifyLink"), v = "link", Ve = B((c, e) => ({
+  id: v,
+  schema: () => ({
+    attrs: {
+      href: {},
+      title: { default: null }
+    },
+    inclusive: !1,
+    parseDOM: [
+      {
+        tag: "a[href]",
+        getAttrs: (t) => {
+          if (!(t instanceof HTMLElement))
+            throw D(t);
+          return { href: t.getAttribute("href"), title: t.getAttribute("title") };
         }
       }
-    }),
-    commands: (markType) => [
-      createCmd(ToggleLink, (href = "") => toggleMark(markType, { href })),
-      createCmd(ModifyLink, (href = "") => (state, dispatch) => {
-        if (!dispatch)
-          return false;
-        const { marks: marks2 } = state.schema;
-        let node;
-        let pos = -1;
-        const { selection } = state;
-        state.doc.nodesBetween(selection.from, selection.to, (n, p) => {
-          if (marks2.link.isInSet(n.marks)) {
-            node = n;
-            pos = p;
-            return false;
-          }
-          return;
-        });
-        if (!node)
-          return false;
-        const mark = node.marks.find(({ type }) => type === markType);
-        if (!mark)
-          return false;
-        const start = pos;
-        const end = pos + node.nodeSize;
-        const { tr } = state;
-        const linkMark = marks2.link.create(__spreadProps(__spreadValues({}, mark.attrs), { href }));
-        dispatch(tr.removeMark(start, end, mark).addMark(start, end, linkMark).setSelection(new TextSelection(tr.selection.$anchor)).scrollIntoView());
-        return true;
-      })
     ],
-    inputRules: (markType, ctx) => [
-      new InputRule(/\[(?<text>.*?)]\((?<href>.*?)(?=“|\))"?(?<title>[^"]+)?"?\)/, (state, match, start, end) => {
-        const [okay, text2 = "", href, title] = match;
-        const { tr } = state;
-        if (okay) {
-          const content = text2 || "link";
-          tr.replaceWith(start, end, ctx.get(schemaCtx).text(content)).addMark(start, content.length + start, markType.create({ title, href }));
+    toDOM: (t) => ["a", { ...t.attrs, class: c.getClassName(t.attrs, v) }],
+    parseMarkdown: {
+      match: (t) => t.type === "link",
+      runner: (t, r, n) => {
+        const s = r.url, a = r.title;
+        t.openMark(n, { href: s, title: a }), t.next(r.children), t.closeMark(n);
+      }
+    },
+    toMarkdown: {
+      match: (t) => t.type.name === v,
+      runner: (t, r) => {
+        t.withMark(r, "link", void 0, {
+          title: r.attrs.title,
+          url: r.attrs.href
+        });
+      }
+    }
+  }),
+  commands: (t) => [
+    M(xe, (r = "") => P(t, { href: r })),
+    M(Y, (r = "") => (n, s) => {
+      var b;
+      if (!s)
+        return !1;
+      const { marks: a } = n.schema;
+      let o, l = -1;
+      const { selection: i } = n, { from: d, to: m } = i;
+      if (n.doc.nodesBetween(d, d === m ? m + 1 : m, (y, x) => {
+        var L;
+        if ((L = a.link) != null && L.isInSet(y.marks))
+          return o = y, l = x, !1;
+      }), !o)
+        return !1;
+      const g = o.marks.find(({ type: y }) => y === t);
+      if (!g)
+        return !1;
+      const u = l, f = l + o.nodeSize, { tr: p } = n, N = (b = a.link) == null ? void 0 : b.create({ ...g.attrs, href: r });
+      return N ? (s(p.removeMark(u, f, g).addMark(u, f, N).setSelection(new pe(p.selection.$anchor)).scrollIntoView()), !0) : !1;
+    })
+  ],
+  inputRules: (t, r) => [
+    new me(/\[(?<text>.*?)]\((?<href>.*?)(?=“|\))"?(?<title>[^"]+)?"?\)/, (n, s, a, o) => {
+      const [l, i = "", d, m] = s, { tr: g } = n;
+      if (l) {
+        const u = i || "link";
+        g.replaceWith(a, o, r.get(A).text(u)).addMark(a, u.length + a, t.create({ title: m, href: d }));
+      }
+      return g;
+    })
+  ],
+  prosePlugins: (t, r) => {
+    let n = !1;
+    return [
+      new T({
+        key: Ue,
+        view: (s) => {
+          var d, m, g;
+          const a = c.themeManager.get("input-chip", {
+            placeholder: (m = (d = e == null ? void 0 : e.input) == null ? void 0 : d.placeholder) != null ? m : "Input Web Link",
+            buttonText: (g = e == null ? void 0 : e.input) == null ? void 0 : g.buttonText,
+            onUpdate: (u) => {
+              r.get(we).call(Y, u);
+            },
+            calculatePosition: (u, f) => {
+              Oe(u, f, (p, N, b, y) => {
+                const x = u.dom.parentElement;
+                if (!x)
+                  throw _e();
+                const L = N.left - p.left;
+                let q = p.left - y.left - (b.width - L) / 2, fe = p.bottom - y.top + 14 + x.scrollTop;
+                return n && (fe = p.top - y.top - b.height - 14 + x.scrollTop), q < 0 && (q = 0), [fe, q];
+              });
+            }
+          });
+          if (!a)
+            return {};
+          const o = (u) => {
+            const { selection: f, doc: p } = u.state, { from: N, to: b } = f;
+            if (!u.hasFocus())
+              return !1;
+            if (f.empty && f instanceof pe && b < p.content.size && N < p.content.size && p.rangeHasMark(N, N === b ? b + 1 : b, t))
+              return n = !1, !0;
+            if (f instanceof ve) {
+              const { node: y } = f;
+              if (y.type.name === "image" && y.marks.findIndex((x) => x.type.name === v) > -1)
+                return n = !0, !0;
+            }
+            return !1;
+          }, l = (u) => {
+            const { selection: f } = u.state;
+            let p;
+            const { from: N, to: b } = f;
+            if (u.state.doc.nodesBetween(N, N === b ? b + 1 : b, (L) => {
+              if (t.isInSet(L.marks))
+                return p = L, !1;
+            }), !p)
+              return;
+            const y = p.marks.find((L) => L.type === t);
+            return y ? y.attrs.href : void 0;
+          }, i = (u) => {
+            if (!u.editable)
+              return;
+            o(u) ? (a.show(u), a.update(l(u))) : a.hide();
+          };
+          return a.init(s), i(s), {
+            update: (u, f) => {
+              (f == null ? void 0 : f.doc.eq(u.state.doc)) && f.selection.eq(u.state.selection) || requestAnimationFrame(() => {
+                i(u);
+              });
+            },
+            destroy: () => {
+              a.destroy();
+            }
+          };
         }
-        return tr;
       })
+    ];
+  }
+})), U = "strong", Z = I("ToggleBold"), je = B((c) => ({
+  id: U,
+  schema: () => ({
+    parseDOM: [
+      { tag: "b" },
+      { tag: "strong" },
+      { style: "font-style", getAttrs: (e) => e === "bold" }
     ],
-    prosePlugins: (type, ctx) => {
-      return [
-        new Plugin({
-          key: key$1,
-          view: (editorView) => {
-            var _a, _b, _c;
-            const inputChipRenderer = utils.themeManager.get("input-chip", {
-              placeholder: (_b = (_a = options == null ? void 0 : options.input) == null ? void 0 : _a.placeholder) != null ? _b : "Input Web Link",
-              buttonText: (_c = options == null ? void 0 : options.input) == null ? void 0 : _c.buttonText,
-              onUpdate: (value) => {
-                ctx.get(commandsCtx).call(ModifyLink, value);
-              }
-            });
-            if (!inputChipRenderer)
-              return {};
-            const shouldDisplay = (view) => {
-              const { selection, doc: doc2 } = view.state;
-              const { from, to } = selection;
-              return view.hasFocus() && selection.empty && selection instanceof TextSelection && to < doc2.content.size && from < doc2.content.size && doc2.rangeHasMark(from, from === to ? to + 1 : to, type);
-            };
-            const getCurrentLink = (view) => {
-              const { selection } = view.state;
-              let node;
-              const { from, to } = selection;
-              view.state.doc.nodesBetween(from, from === to ? to + 1 : to, (n) => {
-                if (type.isInSet(n.marks)) {
-                  node = n;
-                  return false;
-                }
-                return;
-              });
-              if (!node)
-                return;
-              const mark = node.marks.find((m) => m.type === type);
-              if (!mark)
-                return;
-              const value = mark.attrs["href"];
-              return value;
-            };
-            const renderByView = (view) => {
-              if (!view.editable) {
-                return;
-              }
-              const display = shouldDisplay(view);
-              if (display) {
-                inputChipRenderer.show(view);
-                inputChipRenderer.update(getCurrentLink(view));
-              } else {
-                inputChipRenderer.hide();
-              }
-            };
-            inputChipRenderer.init(editorView);
-            renderByView(editorView);
-            return {
-              update: (view, prevState) => {
-                const isEqualSelection = (prevState == null ? void 0 : prevState.doc.eq(view.state.doc)) && prevState.selection.eq(view.state.selection);
-                if (isEqualSelection)
-                  return;
-                renderByView(view);
-              },
-              destroy: () => {
-                inputChipRenderer.destroy();
-              }
-            };
-          }
-        })
-      ];
-    }
-  };
-});
-const id$7 = "strong";
-const ToggleBold = createCmdKey("ToggleBold");
-const strong = createMark((utils) => {
-  return {
-    id: id$7,
-    schema: () => ({
-      parseDOM: [
-        { tag: "b" },
-        { tag: "strong" },
-        { style: "font-style", getAttrs: (value) => value === "bold" }
-      ],
-      toDOM: (mark) => ["strong", { class: utils.getClassName(mark.attrs, id$7) }],
-      parseMarkdown: {
-        match: (node) => node.type === "strong",
-        runner: (state, node, markType) => {
-          state.openMark(markType);
-          state.next(node.children);
-          state.closeMark(markType);
-        }
-      },
-      toMarkdown: {
-        match: (mark) => mark.type.name === id$7,
-        runner: (state, mark) => {
-          state.withMark(mark, "strong");
-        }
+    toDOM: (e) => ["strong", { class: c.getClassName(e.attrs, U) }],
+    parseMarkdown: {
+      match: (e) => e.type === "strong",
+      runner: (e, t, r) => {
+        e.openMark(r), e.next(t.children), e.closeMark(r);
+      }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === U,
+      runner: (e, t) => {
+        e.withMark(t, "strong");
       }
-    }),
-    inputRules: (markType) => [
-      markRule(/(?:__)([^_]+)(?:__)$/, markType),
-      markRule(/(?:\*\*)([^*]+)(?:\*\*)$/, markType)
-    ],
-    commands: (markType) => [createCmd(ToggleBold, () => toggleMark(markType))],
-    shortcuts: {
-      [SupportedKeys.Bold]: createShortcut(ToggleBold, "Mod-b")
     }
-  };
-});
-const marks = [codeInline(), em(), strong(), link()];
-const id$6 = "blockquote";
-const WrapInBlockquote = createCmdKey("WrapInBlockquote");
-const blockquote = createNode((utils) => {
-  return {
-    id: id$6,
-    schema: () => ({
-      content: "block+",
-      group: "block",
-      defining: true,
-      parseDOM: [{ tag: "blockquote" }],
-      toDOM: (node) => ["blockquote", { class: utils.getClassName(node.attrs, id$6) }, 0],
-      parseMarkdown: {
-        match: ({ type }) => type === id$6,
-        runner: (state, node, type) => {
-          state.openNode(type).next(node.children).closeNode();
-        }
-      },
-      toMarkdown: {
-        match: (node) => node.type.name === id$6,
-        runner: (state, node) => {
-          state.openNode("blockquote").next(node.content).closeNode();
-        }
+  }),
+  inputRules: (e) => [
+    _(/(?:__)([^_]+)(?:__)$/, e),
+    _(/(?:\*\*)([^*]+)(?:\*\*)$/, e)
+  ],
+  commands: (e) => [M(Z, () => P(e))],
+  shortcuts: {
+    [k.Bold]: h(Z, "Mod-b")
+  }
+})), ze = [Ke(), Fe(), je(), Ve()], $ = "blockquote", ee = I("WrapInBlockquote"), Ge = w((c) => ({
+  id: $,
+  schema: () => ({
+    content: "block+",
+    group: "block",
+    defining: !0,
+    parseDOM: [{ tag: "blockquote" }],
+    toDOM: (e) => ["blockquote", { class: c.getClassName(e.attrs, $) }, 0],
+    parseMarkdown: {
+      match: ({ type: e }) => e === $,
+      runner: (e, t, r) => {
+        e.openNode(r).next(t.children).closeNode();
+      }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === $,
+      runner: (e, t) => {
+        e.openNode("blockquote").next(t.content).closeNode();
       }
-    }),
-    inputRules: (nodeType) => [wrappingInputRule(/^\s*>\s$/, nodeType)],
-    commands: (nodeType) => [createCmd(WrapInBlockquote, () => wrapIn(nodeType))],
-    shortcuts: {
-      [SupportedKeys.Blockquote]: createShortcut(WrapInBlockquote, "Mod-Shift-b")
     }
-  };
-});
-const WrapInBulletList = createCmdKey("WrapInBulletList");
-const bulletList = createNode((utils) => {
-  const id2 = "bullet_list";
+  }),
+  inputRules: (e) => [W(/^\s*>\s$/, e)],
+  commands: (e) => [M(ee, () => de(e))],
+  shortcuts: {
+    [k.Blockquote]: h(ee, "Mod-Shift-b")
+  }
+})), te = I("WrapInBulletList"), Je = w((c) => {
+  const e = "bullet_list";
   return {
-    id: id2,
+    id: e,
     schema: () => ({
       content: "listItem+",
       group: "block",
       parseDOM: [{ tag: "ul" }],
-      toDOM: (node) => {
-        return ["ul", { class: utils.getClassName(node.attrs, "bullet-list") }, 0];
-      },
+      toDOM: (t) => ["ul", { class: c.getClassName(t.attrs, "bullet-list") }, 0],
       parseMarkdown: {
-        match: ({ type, ordered }) => type === "list" && !ordered,
-        runner: (state, node, type) => {
-          state.openNode(type).next(node.children).closeNode();
+        match: ({ type: t, ordered: r }) => t === "list" && !r,
+        runner: (t, r, n) => {
+          t.openNode(n).next(r.children).closeNode();
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id2,
-        runner: (state, node) => {
-          state.openNode("list", void 0, { ordered: false }).next(node.content).closeNode();
+        match: (t) => t.type.name === e,
+        runner: (t, r) => {
+          t.openNode("list", void 0, { ordered: !1 }).next(r.content).closeNode();
         }
       }
     }),
-    inputRules: (nodeType) => [wrappingInputRule(/^\s*([-+*])\s$/, nodeType)],
-    commands: (nodeType) => [createCmd(WrapInBulletList, () => wrapIn(nodeType))],
+    inputRules: (t) => [W(/^\s*([-+*])\s$/, t)],
+    commands: (t) => [M(te, () => de(t))],
     shortcuts: {
-      [SupportedKeys.BulletList]: createShortcut(WrapInBulletList, "Mod-Alt-8")
+      [k.BulletList]: h(te, "Mod-Alt-8")
     }
   };
-});
-const languageOptions = [
+}), Qe = [
   "",
   "javascript",
   "typescript",
@@ -390,293 +324,333 @@ const languageOptions = [
   "go",
   "rust",
   "markdown"
-];
-const backtickInputRegex = /^```(?<language>[a-z]*)?[\s\n]$/;
-const tildeInputRegex = /^~~~(?<language>[a-z]*)?[\s\n]$/;
-const TurnIntoCodeFence = createCmdKey("TurnIntoCodeFence");
-const id$5 = "fence";
-const codeFence = createNode((utils, options) => {
-  const languageList = (options == null ? void 0 : options.languageList) || languageOptions;
+], Xe = /^```(?<language>[a-z]*)?[\s\n]$/, Ye = /^~~~(?<language>[a-z]*)?[\s\n]$/, re = I("TurnIntoCodeFence"), V = "fence", Ze = w((c, e) => {
+  const t = (e == null ? void 0 : e.languageList) || Qe;
   return {
-    id: id$5,
-    schema: (ctx) => ({
+    id: V,
+    schema: (r) => ({
       content: "text*",
       group: "block",
       marks: "",
-      defining: true,
-      code: true,
+      defining: !0,
+      code: !0,
       attrs: {
         language: {
           default: ""
         },
         fold: {
-          default: true
+          default: !0
         }
       },
       parseDOM: [
         {
           tag: "div.code-fence-container",
           preserveWhitespace: "full",
-          getAttrs: (dom) => {
-            var _a;
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error("Parse DOM error.");
-            }
-            return { language: (_a = dom.querySelector("pre")) == null ? void 0 : _a.dataset["language"] };
+          getAttrs: (n) => {
+            var s;
+            if (!(n instanceof HTMLElement))
+              throw D(n);
+            return { language: (s = n.querySelector("pre")) == null ? void 0 : s.dataset.language };
           },
-          getContent: (dom, schema) => {
-            var _a, _b;
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error("Parse DOM error.");
-            }
-            const textNode = schema.text((_b = (_a = dom.querySelector("pre")) == null ? void 0 : _a.textContent) != null ? _b : "");
-            return Fragment.from(textNode);
+          getContent: (n, s) => {
+            var o, l;
+            if (!(n instanceof HTMLElement))
+              throw D(n);
+            const a = s.text((l = (o = n.querySelector("pre")) == null ? void 0 : o.textContent) != null ? l : "");
+            return ge.from(a);
           }
         },
         {
           tag: "pre",
           preserveWhitespace: "full",
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error("Parse DOM error.");
-            }
-            return { language: dom.dataset["language"] };
+          getAttrs: (n) => {
+            if (!(n instanceof HTMLElement))
+              throw D(n);
+            return { language: n.dataset.language };
           }
         }
       ],
-      toDOM: (node) => {
-        const select = document.createElement("select");
-        languageList.forEach((lang) => {
-          const option = document.createElement("option");
-          option.value = lang;
-          option.innerText = !lang ? "--" : lang;
-          if (lang === node.attrs["language"]) {
-            option.selected = true;
-          }
-          select.appendChild(option);
-        });
-        select.onchange = (e) => {
-          const target = e.target;
-          if (!(target instanceof HTMLSelectElement)) {
+      toDOM: (n) => {
+        const s = document.createElement("select");
+        return t.forEach((a) => {
+          const o = document.createElement("option");
+          o.value = a, o.innerText = a || "--", a === n.attrs.language && (o.selected = !0), s.appendChild(o);
+        }), s.onchange = (a) => {
+          const o = a.target;
+          if (!(o instanceof HTMLSelectElement))
             return;
-          }
-          const view = ctx.get(editorViewCtx);
-          if (!view.editable) {
-            target.value = node.attrs["language"];
+          const l = r.get(R);
+          if (!l.editable) {
+            o.value = n.attrs.language;
             return;
           }
-          const { top, left } = target.getBoundingClientRect();
-          const result = view.posAtCoords({ top, left });
-          if (!result)
+          const { top: i, left: d } = o.getBoundingClientRect(), m = l.posAtCoords({ top: i, left: d });
+          if (!m)
             return;
-          const { tr } = view.state;
-          view.dispatch(tr.setNodeMarkup(result.inside, void 0, __spreadProps(__spreadValues({}, node.attrs), {
-            language: target.value
-          })));
-        };
-        return [
+          const { tr: g } = l.state;
+          l.dispatch(g.setNodeMarkup(m.inside, void 0, {
+            ...n.attrs,
+            language: o.value
+          }));
+        }, [
           "div",
           {
             class: "code-fence-container"
           },
-          select,
+          s,
           [
             "pre",
             {
-              "data-language": node.attrs["language"],
-              class: utils.getClassName(node.attrs, "code-fence")
+              "data-language": n.attrs.language,
+              class: c.getClassName(n.attrs, "code-fence")
             },
             ["code", { spellCheck: "false" }, 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();
+        match: ({ type: n }) => n === "code",
+        runner: (n, s, a) => {
+          const o = s.lang, l = s.value;
+          n.openNode(a, { language: o }), l && n.addText(l), n.closeNode();
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id$5,
-        runner: (state, node) => {
-          var _a;
-          state.addNode("code", void 0, ((_a = node.content.firstChild) == null ? void 0 : _a.text) || "", {
-            lang: node.attrs["language"]
+        match: (n) => n.type.name === V,
+        runner: (n, s) => {
+          var a;
+          n.addNode("code", void 0, ((a = s.content.firstChild) == null ? void 0 : a.text) || "", {
+            lang: s.attrs.language
           });
         }
       }
     }),
-    inputRules: (nodeType) => [
-      textblockTypeInputRule(backtickInputRegex, nodeType, (match) => {
-        const [ok, language] = match;
-        if (!ok)
-          return;
-        return { language };
+    inputRules: (r) => [
+      G(Xe, r, (n) => {
+        const [s, a] = n;
+        if (!!s)
+          return { language: a };
       }),
-      textblockTypeInputRule(tildeInputRegex, nodeType, (match) => {
-        const [ok, language] = match;
-        if (!ok)
-          return;
-        return { language };
+      G(Ye, r, (n) => {
+        const [s, a] = n;
+        if (!!s)
+          return { language: a };
       })
     ],
-    commands: (nodeType) => [createCmd(TurnIntoCodeFence, () => setBlockType(nodeType))],
+    commands: (r) => [M(re, () => E(r))],
     shortcuts: {
-      [SupportedKeys.CodeFence]: createShortcut(TurnIntoCodeFence, "Mod-Alt-c")
+      [k.CodeFence]: h(re, "Mod-Alt-c")
     },
-    view: () => (node, view, getPos) => {
-      let currNode = node;
-      const onSelectLanguage = (language) => {
-        const { tr } = view.state;
-        view.dispatch(tr.setNodeMarkup(getPos(), void 0, {
-          fold: true,
-          language
+    view: () => (r, n, s) => {
+      let a = r;
+      const o = (p) => {
+        const { tr: N } = n.state;
+        n.dispatch(N.setNodeMarkup(s(), void 0, {
+          fold: !0,
+          language: p
         }));
-      };
-      const onBlur = () => {
-        const { tr } = view.state;
-        view.dispatch(tr.setNodeMarkup(getPos(), void 0, __spreadProps(__spreadValues({}, currNode.attrs), {
-          fold: true
-        })));
-      };
-      const onFocus = () => {
-        const { tr } = view.state;
-        view.dispatch(tr.setNodeMarkup(getPos(), void 0, __spreadProps(__spreadValues({}, currNode.attrs), {
-          fold: false
-        })));
-      };
-      const renderer = utils.themeManager.get("code-fence", {
-        onBlur,
-        onFocus,
-        onSelectLanguage,
-        editable: () => view.editable,
-        languageList
+      }, l = () => {
+        const { tr: p } = n.state;
+        n.dispatch(p.setNodeMarkup(s(), void 0, {
+          ...a.attrs,
+          fold: !0
+        }));
+      }, i = () => {
+        const { tr: p } = n.state;
+        n.dispatch(p.setNodeMarkup(s(), void 0, {
+          ...a.attrs,
+          fold: !1
+        }));
+      }, d = c.themeManager.get("code-fence", {
+        onBlur: l,
+        onFocus: i,
+        onSelectLanguage: o,
+        editable: () => n.editable,
+        languageList: t
       });
-      if (!renderer)
+      if (!d)
         return {};
-      const { dom, contentDOM, onUpdate, onDestroy } = renderer;
-      onUpdate(currNode);
-      return {
-        dom,
-        contentDOM,
-        update: (updatedNode) => {
-          if (updatedNode.type.name !== id$5)
-            return false;
-          currNode = updatedNode;
-          onUpdate(currNode);
-          return true;
-        },
-        destroy: onDestroy
+      const { dom: m, contentDOM: g, onUpdate: u, onDestroy: f } = d;
+      return u(a), {
+        dom: m,
+        contentDOM: g,
+        update: (p) => p.type.name !== V ? !1 : (a = p, u(a), !0),
+        destroy: f
       };
     }
   };
-});
-const doc = createNode(() => {
-  return {
-    id: "doc",
-    schema: () => ({
-      content: "block+",
-      parseMarkdown: {
-        match: ({ type }) => type === "root",
-        runner: (state, node, type) => {
-          state.injectRoot(node, type);
+}), et = w(() => ({
+  id: "doc",
+  schema: () => ({
+    content: "block+",
+    parseMarkdown: {
+      match: ({ type: c }) => c === "root",
+      runner: (c, e, t) => {
+        c.injectRoot(e, t);
+      }
+    },
+    toMarkdown: {
+      match: (c) => c.type.name === "doc",
+      runner: (c, e) => {
+        c.openNode("root"), c.next(e.content);
+      }
+    }
+  })
+})), ne = I("InsertHardbreak"), tt = w((c) => ({
+  id: "hardbreak",
+  schema: () => ({
+    inline: !0,
+    group: "inline",
+    selectable: !1,
+    parseDOM: [{ tag: "br" }],
+    toDOM: (e) => ["br", { class: c.getClassName(e.attrs, "hardbreak") }],
+    parseMarkdown: {
+      match: ({ type: e }) => e === "break",
+      runner: (e, t, r) => {
+        e.addNode(r);
+      }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === "hardbreak",
+      runner: (e) => {
+        e.addNode("break");
+      }
+    }
+  }),
+  commands: (e) => [
+    M(ne, () => (t, r) => {
+      var a;
+      const { selection: n, tr: s } = t;
+      if (n.empty) {
+        const o = n.$from.node();
+        if (o.childCount > 0 && ((a = o.lastChild) == null ? void 0 : a.type.name) === "hardbreak")
+          return r == null || r(s.replaceRangeWith(n.to - 1, n.to, t.schema.node("paragraph")).setSelection(Le.near(s.doc.resolve(n.to))).scrollIntoView()), !0;
+      }
+      return r == null || r(s.setMeta("hardbreak", !0).replaceSelectionWith(e.create()).scrollIntoView()), !0;
+    })
+  ],
+  shortcuts: {
+    [k.HardBreak]: h(ne, "Shift-Enter")
+  },
+  prosePlugins: (e) => [
+    new T({
+      key: new H("MILKDOWN_HARDBREAK_MARKS"),
+      appendTransaction: (t, r, n) => {
+        if (!t.length)
+          return;
+        const [s] = t;
+        if (!s)
+          return;
+        const [a] = s.steps;
+        if (s.getMeta("hardbreak")) {
+          if (!(a instanceof $e))
+            return;
+          const { from: i } = a;
+          return n.tr.setNodeMarkup(i, e, void 0, []);
         }
-      },
-      toMarkdown: {
-        match: (node) => node.type.name === "doc",
-        runner: (state, node) => {
-          state.openNode("root");
-          state.next(node.content);
+        if (a instanceof Se) {
+          let i = n.tr;
+          const { from: d, to: m } = a;
+          return n.doc.nodesBetween(d, m, (g, u) => {
+            g.type === e && (i = i.setNodeMarkup(u, e, void 0, []));
+          }), i;
         }
       }
     })
+  ]
+})), ke = Array(6).fill(0).map((c, e) => e + 1), C = I("TurnIntoHeading"), Me = I("DowngradeHeading"), j = new H("MILKDOWN_HEADING_ID"), rt = new H("MILKDOWN_HEADING_HASH"), nt = (c) => c.textContent.replace(/[\p{P}\p{S}]/gu, "").replace(/\s/g, "-").toLowerCase().trim(), st = (c, e, t) => {
+  let r = !1;
+  const n = (s, a) => {
+    const o = s.tr;
+    s.doc.descendants((l, i) => {
+      if (l.type === e && !r) {
+        if (l.textContent.trim().length === 0)
+          return;
+        const d = l.attrs, m = t(l);
+        d.id !== m && o.setMeta(j, !0).setNodeMarkup(i, void 0, {
+          ...d,
+          id: m
+        });
+      }
+    }), a(o);
   };
-});
-const InsertHardbreak = createCmdKey("InsertHardbreak");
-const hardbreak = createNode((utils) => {
-  return {
-    id: "hardbreak",
-    schema: () => ({
-      inline: true,
-      group: "inline",
-      selectable: false,
-      parseDOM: [{ tag: "br" }],
-      toDOM: (node) => ["br", { class: utils.getClassName(node.attrs, "hardbreak") }],
-      parseMarkdown: {
-        match: ({ type }) => type === "break",
-        runner: (state, _, type) => {
-          state.addNode(type);
-        }
-      },
-      toMarkdown: {
-        match: (node) => node.type.name === "hardbreak",
-        runner: (state) => {
-          state.addNode("break");
+  return new T({
+    key: j,
+    props: {
+      handleDOMEvents: {
+        compositionstart: () => (r = !0, !1),
+        compositionend: () => {
+          r = !1;
+          const s = c.get(R);
+          return setTimeout(() => {
+            n(s.state, (a) => s.dispatch(a));
+          }, 0), !1;
         }
       }
-    }),
-    commands: (type) => [
-      createCmd(InsertHardbreak, () => (state, dispatch) => {
-        dispatch == null ? void 0 : dispatch(state.tr.setMeta("hardbreak", true).replaceSelectionWith(type.create()).scrollIntoView());
-        return true;
-      })
-    ],
-    shortcuts: {
-      [SupportedKeys.HardBreak]: createShortcut(InsertHardbreak, "Shift-Enter")
     },
-    prosePlugins: (type) => [
-      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, type, void 0, []);
-          }
-          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 === type) {
-                _tr = _tr.setNodeMarkup(pos, type, void 0, []);
-              }
-            });
-            return _tr;
-          }
-          return;
-        }
-      })
-    ]
-  };
-});
-const headingIndex = Array(6).fill(0).map((_, i) => i + 1);
-const TurnIntoHeading = createCmdKey("TurnIntoHeading");
-const headingPluginKey = new PluginKey("MILKDOWN_ID");
-const createId = (node) => node.textContent.replace(/[\p{P}\p{S}]/gu, "").replace(/\s/g, "-").toLowerCase().trim();
-const heading = createNode((utils) => {
-  const id2 = "heading";
+    appendTransaction: (s, a, o) => {
+      let l = null;
+      return s.every((i) => !i.getMeta(j)) && s.some((i) => i.docChanged) && n(o, (i) => {
+        l = i;
+      }), l;
+    },
+    view: (s) => {
+      const a = s.state.doc;
+      let o = s.state.tr;
+      return a.descendants((l, i) => {
+        l.type.name === "heading" && l.attrs.level && (l.attrs.id || (o = o.setNodeMarkup(i, void 0, {
+          ...l.attrs,
+          id: t(l)
+        })));
+      }), s.dispatch(o), {};
+    }
+  });
+}, ot = (c, e, t) => new T({
+  key: rt,
+  state: {
+    init: () => O.empty,
+    apply: (r) => {
+      const n = c.get(R);
+      if (!n.hasFocus || !n.editable)
+        return O.empty;
+      const { $from: s } = r.selection, a = s.node();
+      if (a.type !== e)
+        return O.empty;
+      const o = a.attrs.level, l = (m) => Array(m).fill(0).map((g) => "#").join(""), i = document.createElement("span");
+      i.textContent = l(o), i.contentEditable = "false", t.themeManager.onFlush(() => {
+        const m = t.getStyle(({ css: g }) => {
+          const u = Te(t.themeManager);
+          return g`
+                            margin-right: 4px;
+                            color: ${u("primary")};
+                        `;
+        });
+        m && (i.className = m);
+      });
+      const d = J.widget(s.before() + 1, i, { side: -1 });
+      return O.create(r.doc, [d]);
+    }
+  },
+  props: {
+    handleDOMEvents: {
+      focus: (r) => {
+        const n = Ae(r.state.tr);
+        return r.dispatch(n), !1;
+      }
+    },
+    decorations(r) {
+      return this.getState(r);
+    }
+  }
+}), at = w((c, e) => {
+  var s, a;
+  const t = "heading", r = (s = e == null ? void 0 : e.getId) != null ? s : nt, n = (a = e == null ? void 0 : e.displayHashtag) != null ? a : !0;
   return {
-    id: id2,
+    id: t,
     schema: () => ({
       content: "inline*",
       group: "block",
-      defining: true,
+      defining: !0,
       attrs: {
         id: {
           default: ""
@@ -685,393 +659,351 @@ const heading = createNode((utils) => {
           default: 1
         }
       },
-      parseDOM: headingIndex.map((x) => ({
-        tag: `h${x}`,
-        getAttrs: (node) => {
-          if (!(node instanceof HTMLElement)) {
-            throw new Error();
-          }
-          return { level: x, id: node.id };
+      parseDOM: ke.map((o) => ({
+        tag: `h${o}`,
+        getAttrs: (l) => {
+          if (!(l instanceof HTMLElement))
+            throw D(l);
+          return { level: o, id: l.id };
         }
       })),
-      toDOM: (node) => {
-        return [
-          `h${node.attrs["level"]}`,
-          {
-            id: node.attrs["id"] || createId(node),
-            class: utils.getClassName(node.attrs, `heading h${node.attrs["level"]}`)
-          },
-          0
-        ];
-      },
+      toDOM: (o) => [
+        `h${o.attrs.level}`,
+        {
+          id: o.attrs.id || r(o),
+          class: c.getClassName(o.attrs, `heading h${o.attrs.level}`)
+        },
+        0
+      ],
       parseMarkdown: {
-        match: ({ type }) => type === id2,
-        runner: (state, node, type) => {
-          const depth = node["depth"];
-          state.openNode(type, { level: depth });
-          state.next(node.children);
-          state.closeNode();
+        match: ({ type: o }) => o === t,
+        runner: (o, l, i) => {
+          const d = l.depth;
+          o.openNode(i, { level: d }), o.next(l.children), o.closeNode();
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id2,
-        runner: (state, node) => {
-          state.openNode("heading", void 0, { depth: node.attrs["level"] });
-          state.next(node.content);
-          state.closeNode();
+        match: (o) => o.type.name === t,
+        runner: (o, l) => {
+          var d;
+          if (o.openNode("heading", void 0, { depth: l.attrs.level }), l.childCount >= 1 && ((d = l.lastChild) == null ? void 0 : d.type.name) === "hardbreak") {
+            const m = [];
+            l.content.forEach((g, u, f) => {
+              f !== l.childCount - 1 && m.push(g);
+            }), o.next(ge.fromArray(m));
+          } else
+            o.next(l.content);
+          o.closeNode();
         }
       }
     }),
-    inputRules: (type) => headingIndex.map((x) => textblockTypeInputRule(new RegExp(`^(#{1,${x}})\\s$`), type, () => ({
-      level: x
-    }))),
-    commands: (type) => [createCmd(TurnIntoHeading, (level = 1) => setBlockType(type, { level }))],
+    inputRules: (o, l) => ke.map((i) => G(new RegExp(`^(#{1,${i}})\\s$`), o, () => {
+      const d = l.get(R), { $from: m } = d.state.selection, g = m.node();
+      if (g.type.name === "heading") {
+        let u = Number(g.attrs.level) + Number(i);
+        return u > 6 && (u = 6), {
+          level: u
+        };
+      }
+      return {
+        level: i
+      };
+    })),
+    commands: (o, l) => [
+      M(C, (i = 1) => i < 1 ? E(i === 0 && l.get(A).nodes.paragraph || o) : E(i === 0 && l.get(A).nodes.paragraph || o, { level: i })),
+      M(Me, () => (i, d, m) => {
+        const { $from: g } = i.selection, u = g.node();
+        if (u.type !== o || !i.selection.empty || g.parentOffset !== 0)
+          return !1;
+        const f = u.attrs.level - 1;
+        return f ? (d == null || d(i.tr.setNodeMarkup(i.selection.$from.before(), void 0, {
+          ...u.attrs,
+          level: f
+        })), !0) : E(l.get(A).nodes.paragraph || o)(i, d, m);
+      })
+    ],
     shortcuts: {
-      [SupportedKeys.H1]: createShortcut(TurnIntoHeading, "Mod-Alt-1", 1),
-      [SupportedKeys.H2]: createShortcut(TurnIntoHeading, "Mod-Alt-2", 2),
-      [SupportedKeys.H3]: createShortcut(TurnIntoHeading, "Mod-Alt-3", 3),
-      [SupportedKeys.H4]: createShortcut(TurnIntoHeading, "Mod-Alt-4", 4),
-      [SupportedKeys.H5]: createShortcut(TurnIntoHeading, "Mod-Alt-5", 5),
-      [SupportedKeys.H6]: createShortcut(TurnIntoHeading, "Mod-Alt-6", 6)
+      [k.H1]: h(C, "Mod-Alt-1", 1),
+      [k.H2]: h(C, "Mod-Alt-2", 2),
+      [k.H3]: h(C, "Mod-Alt-3", 3),
+      [k.H4]: h(C, "Mod-Alt-4", 4),
+      [k.H5]: h(C, "Mod-Alt-5", 5),
+      [k.H6]: h(C, "Mod-Alt-6", 6),
+      [k.DowngradeHeading]: h(Me, ["Backspace", "Delete"])
     },
-    prosePlugins: (type, ctx) => {
-      let lock = false;
-      const walkThrough = (state, callback) => {
-        const tr = state.tr;
-        state.doc.descendants((node, pos) => {
-          if (node.type === type && !lock) {
-            if (node.textContent.trim().length === 0) {
-              return;
-            }
-            const attrs = node.attrs;
-            const id22 = createId(node);
-            if (attrs["id"] !== id22) {
-              tr.setMeta(headingPluginKey, true).setNodeMarkup(pos, void 0, __spreadProps(__spreadValues({}, attrs), {
-                id: id22
-              }));
-            }
-          }
-        });
-        callback(tr);
-      };
-      return [
-        new Plugin({
-          key: headingPluginKey,
-          props: {
-            handleDOMEvents: {
-              compositionstart: () => {
-                lock = true;
-                return false;
-              },
-              compositionend: () => {
-                lock = false;
-                const view = ctx.get(editorViewCtx);
-                setTimeout(() => {
-                  walkThrough(view.state, (tr) => view.dispatch(tr));
-                }, 0);
-                return false;
-              }
-            }
-          },
-          appendTransaction: (transactions, _, nextState) => {
-            let tr = null;
-            if (transactions.every((transaction) => !transaction.getMeta(headingPluginKey)) && transactions.some((transaction) => transaction.docChanged)) {
-              walkThrough(nextState, (t) => {
-                tr = t;
-              });
-            }
-            return tr;
-          }
-        })
-      ];
+    prosePlugins: (o, l) => {
+      const i = [st(l, o, r)];
+      return n && i.push(ot(l, o, c)), i;
     }
   };
-});
-const id$4 = "hr";
-const InsertHr = createCmdKey("InsertHr");
-const hr = createNode((utils) => {
-  return {
-    id: id$4,
-    schema: () => ({
-      group: "block",
-      parseDOM: [{ tag: "hr" }],
-      toDOM: (node) => ["hr", { class: utils.getClassName(node.attrs, id$4) }],
-      parseMarkdown: {
-        match: ({ type }) => type === "thematicBreak",
-        runner: (state, _, type) => {
-          state.addNode(type);
-        }
-      },
-      toMarkdown: {
-        match: (node) => node.type.name === id$4,
-        runner: (state) => {
-          state.addNode("thematicBreak");
-        }
+}), z = "hr", Ce = I("InsertHr"), lt = w((c) => ({
+  id: z,
+  schema: () => ({
+    group: "block",
+    parseDOM: [{ tag: "hr" }],
+    toDOM: (e) => ["hr", { class: c.getClassName(e.attrs, z) }],
+    parseMarkdown: {
+      match: ({ type: e }) => e === "thematicBreak",
+      runner: (e, t, r) => {
+        e.addNode(r);
       }
-    }),
-    inputRules: (type) => [
-      new InputRule(/^(?:---|___\s|\*\*\*\s)$/, (state, match, start, end) => {
-        const { tr } = state;
-        if (match[0]) {
-          tr.replaceWith(start - 1, end, type.create());
-        }
-        return tr;
-      })
-    ],
-    commands: (type, ctx) => [
-      createCmd(InsertHr, () => (state, dispatch) => {
-        if (!dispatch)
-          return true;
-        const { tr, selection } = state;
-        const from = selection.from;
-        const node = type.create();
-        if (!node) {
-          return true;
-        }
-        const _tr = tr.replaceSelectionWith(node).insert(from, ctx.get(schemaCtx).node("paragraph"));
-        const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true);
-        if (!sel) {
-          return true;
-        }
-        dispatch(_tr.setSelection(sel).scrollIntoView());
-        return true;
-      })
-    ]
-  };
-});
-const ModifyImage = createCmdKey("ModifyImage");
-const InsertImage = createCmdKey("InsertImage");
-const id$3 = "image";
-const key = new PluginKey("MILKDOWN_IMAGE_INPUT");
-const image = createNode((utils, options) => {
-  return {
-    id: "image",
-    schema: () => ({
-      inline: true,
-      group: "inline",
-      selectable: true,
-      draggable: true,
-      marks: "",
-      atom: true,
-      defining: true,
-      isolating: true,
-      attrs: {
-        src: { default: "" },
-        alt: { default: null },
-        title: { default: null }
-      },
-      parseDOM: [
-        {
-          tag: "img[src]",
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error();
-            }
-            return {
-              src: dom.getAttribute("src") || "",
-              alt: dom.getAttribute("alt"),
-              title: dom.getAttribute("title") || dom.getAttribute("alt"),
-              width: dom.getAttribute("width")
-            };
-          }
-        }
-      ],
-      toDOM: (node) => {
-        return [
-          "img",
-          __spreadProps(__spreadValues({}, node.attrs), {
-            class: utils.getClassName(node.attrs, id$3)
-          })
-        ];
-      },
-      parseMarkdown: {
-        match: ({ type }) => type === id$3,
-        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 === id$3,
-        runner: (state, node) => {
-          state.addNode("image", void 0, void 0, {
-            title: node.attrs["title"],
-            url: node.attrs["src"],
-            alt: node.attrs["alt"]
-          });
-        }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === z,
+      runner: (e) => {
+        e.addNode("thematicBreak");
       }
-    }),
-    commands: (type) => [
-      createCmd(InsertImage, (src = "") => (state, dispatch) => {
-        if (!dispatch)
-          return true;
-        const { tr } = state;
-        const node = type.create({ src });
-        if (!node) {
-          return true;
+    }
+  }),
+  inputRules: (e) => [
+    new me(/^(?:---|___\s|\*\*\*\s)$/, (t, r, n, s) => {
+      const { tr: a } = t;
+      return r[0] && a.replaceWith(n - 1, s, e.create()), a;
+    })
+  ],
+  commands: (e, t) => [
+    M(Ce, () => (r, n) => {
+      if (!n)
+        return !0;
+      const s = t.get(A).node("paragraph"), { tr: a, selection: o } = r, { from: l } = o, i = e.create();
+      if (!i)
+        return !0;
+      const d = a.replaceSelectionWith(i).insert(l, s), m = Le.findFrom(d.doc.resolve(l), 1, !0);
+      return m && n(d.setSelection(m).scrollIntoView()), !0;
+    })
+  ]
+})), se = I("ModifyImage"), De = I("InsertImage"), S = "image", ct = new H("MILKDOWN_IMAGE_INPUT"), it = w((c, e) => ({
+  id: "image",
+  schema: () => ({
+    inline: !0,
+    group: "inline",
+    selectable: !0,
+    draggable: !0,
+    marks: "",
+    atom: !0,
+    defining: !0,
+    isolating: !0,
+    attrs: {
+      src: { default: "" },
+      alt: { default: null },
+      title: { default: null }
+    },
+    parseDOM: [
+      {
+        tag: "img[src]",
+        getAttrs: (t) => {
+          if (!(t instanceof HTMLElement))
+            throw D(t);
+          return {
+            src: t.getAttribute("src") || "",
+            alt: t.getAttribute("alt"),
+            title: t.getAttribute("title") || t.getAttribute("alt"),
+            width: t.getAttribute("width")
+          };
         }
-        const _tr = tr.replaceSelectionWith(node);
-        dispatch(_tr.scrollIntoView());
-        return true;
-      }),
-      createCmd(ModifyImage, (src = "") => (state, dispatch) => {
-        const node = findSelectedNodeOfType(state.selection, type);
-        if (!node)
-          return false;
-        const { tr } = state;
-        dispatch == null ? void 0 : dispatch(tr.setNodeMarkup(node.pos, void 0, __spreadProps(__spreadValues({}, node.node.attrs), { loading: true, src })).scrollIntoView());
-        return true;
-      })
+      }
     ],
-    inputRules: (type) => [
-      new InputRule(/!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/, (state, match, start, end) => {
-        const [okay, alt, src = "", title] = match;
-        const { tr } = state;
-        if (okay) {
-          tr.replaceWith(start, end, type.create({ src, alt, title }));
-        }
-        return tr;
-      })
+    toDOM: (t) => [
+      "img",
+      {
+        ...t.attrs,
+        class: c.getClassName(t.attrs, S)
+      }
     ],
-    view: () => (node) => {
-      var _a, _b;
-      let currNode = node;
-      const placeholder = (_a = options == null ? void 0 : options.placeholder) != null ? _a : "Add an Image";
-      const isBlock = (_b = options == null ? void 0 : options.isBlock) != null ? _b : false;
-      const renderer = utils.themeManager.get("image", {
-        placeholder,
-        isBlock
-      });
-      if (!renderer) {
-        return {};
+    parseMarkdown: {
+      match: ({ type: t }) => t === S,
+      runner: (t, r, n) => {
+        const s = r.url, a = r.alt, o = r.title;
+        t.addNode(n, {
+          src: s,
+          alt: a,
+          title: o
+        });
       }
-      const { dom, onUpdate } = renderer;
-      onUpdate(currNode);
-      return {
-        dom,
-        update: (updatedNode) => {
-          if (updatedNode.type.name !== id$3)
-            return false;
-          currNode = updatedNode;
-          onUpdate(currNode);
-          return true;
-        },
-        selectNode: () => {
-          dom.classList.add("ProseMirror-selectednode");
-        },
-        deselectNode: () => {
-          dom.classList.remove("ProseMirror-selectednode");
-        }
-      };
     },
-    prosePlugins: (type, ctx) => {
-      return [
-        new Plugin({
-          key,
-          view: (editorView) => {
-            var _a, _b, _c;
-            const inputChipRenderer = utils.themeManager.get("input-chip", {
-              placeholder: (_b = (_a = options == null ? void 0 : options.input) == null ? void 0 : _a.placeholder) != null ? _b : "Input Image Link",
-              buttonText: (_c = options == null ? void 0 : options.input) == null ? void 0 : _c.buttonText,
-              onUpdate: (value) => {
-                ctx.get(commandsCtx).call(ModifyImage, value);
-              }
-            });
-            if (!inputChipRenderer)
-              return {};
-            const shouldDisplay = (view) => {
-              return Boolean(view.hasFocus() && type && findSelectedNodeOfType(view.state.selection, type));
-            };
-            const getCurrentLink = (view) => {
-              const result = findSelectedNodeOfType(view.state.selection, type);
-              if (!result)
-                return;
-              const value = result.node.attrs["src"];
-              return value;
-            };
-            const renderByView = (view) => {
-              if (!view.editable) {
-                return;
-              }
-              const display = shouldDisplay(view);
-              if (display) {
-                inputChipRenderer.show(view);
-                inputChipRenderer.update(getCurrentLink(view));
-              } else {
-                inputChipRenderer.hide();
-              }
-            };
-            inputChipRenderer.init(editorView);
-            renderByView(editorView);
-            return {
-              update: (view, prevState) => {
-                const isEqualSelection = (prevState == null ? void 0 : prevState.doc.eq(view.state.doc)) && prevState.selection.eq(view.state.selection);
-                if (isEqualSelection)
-                  return;
-                renderByView(view);
-              },
-              destroy: () => {
-                inputChipRenderer.destroy();
-              }
-            };
-          }
-        })
-      ];
+    toMarkdown: {
+      match: (t) => t.type.name === S,
+      runner: (t, r) => {
+        t.addNode("image", void 0, void 0, {
+          title: r.attrs.title,
+          url: r.attrs.src,
+          alt: r.attrs.alt
+        });
+      }
     }
+  }),
+  commands: (t) => [
+    M(De, (r = "") => (n, s) => {
+      if (!s)
+        return !0;
+      const { tr: a } = n, o = t.create({ src: r });
+      if (!o)
+        return !0;
+      const l = a.replaceSelectionWith(o);
+      return s(l.scrollIntoView()), !0;
+    }),
+    M(se, (r = "") => (n, s) => {
+      const a = K(n.selection, t);
+      if (!a)
+        return !1;
+      const { tr: o } = n;
+      return s == null || s(o.setNodeMarkup(a.pos, void 0, { ...a.node.attrs, loading: !0, src: r }).scrollIntoView()), !0;
+    })
+  ],
+  inputRules: (t) => [
+    new me(/!\[(?<alt>.*?)]\((?<filename>.*?)\s*(?="|\))"?(?<title>[^"]+)?"?\)/, (r, n, s, a) => {
+      const [o, l, i = "", d] = n, { tr: m } = r;
+      return o && m.replaceWith(s, a, t.create({ src: i, alt: l, title: d })), m;
+    })
+  ],
+  view: () => (t) => {
+    var i, d;
+    let r = t;
+    const n = (i = e == null ? void 0 : e.placeholder) != null ? i : "Add an Image", s = (d = e == null ? void 0 : e.isBlock) != null ? d : !1, a = c.themeManager.get("image", {
+      placeholder: n,
+      isBlock: s
+    });
+    if (!a)
+      return {};
+    const { dom: o, onUpdate: l } = a;
+    return l(r), {
+      dom: o,
+      update: (m) => m.type.name !== S ? !1 : (r = m, l(r), !0),
+      selectNode: () => {
+        o.classList.add("ProseMirror-selectednode");
+      },
+      deselectNode: () => {
+        o.classList.remove("ProseMirror-selectednode");
+      }
+    };
+  },
+  prosePlugins: (t, r) => [
+    new T({
+      key: ct,
+      view: (n) => {
+        var i, d, m;
+        const s = c.themeManager.get("input-chip", {
+          placeholder: (d = (i = e == null ? void 0 : e.input) == null ? void 0 : i.placeholder) != null ? d : "Input Image Link",
+          buttonText: (m = e == null ? void 0 : e.input) == null ? void 0 : m.buttonText,
+          onUpdate: (g) => {
+            r.get(we).call(se, g);
+          }
+        });
+        if (!s)
+          return {};
+        const a = (g) => Boolean(g.hasFocus() && t && K(g.state.selection, t)), o = (g) => {
+          const u = K(g.state.selection, t);
+          return u ? u.node.attrs.src : void 0;
+        }, l = (g) => {
+          if (!g.editable)
+            return;
+          a(g) ? (s.show(g), s.update(o(g))) : s.hide();
+        };
+        return s.init(n), l(n), {
+          update: (g, u) => {
+            (u == null ? void 0 : u.doc.eq(g.state.doc)) && u.selection.eq(g.state.selection) || l(g);
+          },
+          destroy: () => {
+            s.destroy();
+          }
+        };
+      }
+    })
+  ]
+})), Ie = "list_item", oe = I("SplitListItem"), ae = I("SinkListItem"), le = I("LiftListItem"), ut = new H("MILKDOWN_KEEP_LIST_ORDER"), dt = (c) => {
+  const e = (t, r) => {
+    const n = Ee("ordered_list", t.schema);
+    let s = t.tr;
+    t.doc.descendants((a, o, l, i) => {
+      if (a.type === c && (l == null ? void 0 : l.type) === n) {
+        let d = !1;
+        const m = { ...a.attrs };
+        a.attrs.listType !== "ordered" && (m.listType = "ordered", d = !0);
+        const g = l == null ? void 0 : l.maybeChild(i - 1);
+        if (g && g.type === c && g.attrs.listType === "ordered") {
+          const u = g.attrs.label;
+          m.label = `${Number(u.slice(0, -1)) + 1}.`, d = !0;
+        }
+        a.attrs.label === "\u2022" && (m.label = `${i + 1}.`, d = !0), d && (s = s.setNodeMarkup(o, void 0, m));
+      }
+    }), r(s);
   };
-});
-const id$2 = "list_item";
-const SplitListItem = createCmdKey("SplitListItem");
-const SinkListItem = createCmdKey("SinkListItem");
-const LiftListItem = createCmdKey("LiftListItem");
-const listItem = createNode((utils) => ({
-  id: id$2,
+  return new T({
+    key: ut,
+    appendTransaction: (t, r, n) => {
+      let s = null;
+      return t.some((a) => a.docChanged) && e(n, (a) => {
+        s = a;
+      }), s;
+    }
+  });
+}, mt = w((c) => ({
+  id: Ie,
   schema: () => ({
     group: "listItem",
     content: "paragraph block*",
-    defining: true,
-    parseDOM: [{ tag: "li" }],
-    toDOM: (node) => ["li", { class: utils.getClassName(node.attrs, "list-item") }, 0],
+    attrs: {
+      label: {
+        default: "\u2022"
+      },
+      listType: {
+        default: "bullet"
+      }
+    },
+    defining: !0,
+    parseDOM: [
+      {
+        tag: "li.list-item",
+        getAttrs: (e) => {
+          if (!(e instanceof HTMLElement))
+            throw D(e);
+          return {
+            label: e.dataset.label,
+            listType: e.dataset["list-type"]
+          };
+        },
+        contentElement: "div.list-item_body"
+      },
+      { tag: "li" }
+    ],
+    toDOM: (e) => [
+      "li",
+      {
+        class: c.getClassName(e.attrs, "list-item"),
+        "data-label": e.attrs.label,
+        "data-list-type": e.attrs.listType
+      },
+      ["div", { class: c.getClassName(e.attrs, "list-item_label") }, e.attrs.label],
+      ["div", { class: c.getClassName(e.attrs, "list-item_body") }, 0]
+    ],
     parseMarkdown: {
-      match: ({ type, checked }) => type === "listItem" && checked === null,
-      runner: (state, node, type) => {
-        state.openNode(type);
-        state.next(node.children);
-        state.closeNode();
+      match: ({ type: e, checked: t }) => e === "listItem" && t === null,
+      runner: (e, t, r) => {
+        const n = t.label != null ? `${t.label}.` : "\u2022", s = t.label != null ? "ordered" : "bullet";
+        e.openNode(r, { label: n, listType: s }), e.next(t.children), e.closeNode();
       }
     },
     toMarkdown: {
-      match: (node) => node.type.name === id$2,
-      runner: (state, node) => {
-        state.openNode("listItem");
-        state.next(node.content);
-        state.closeNode();
+      match: (e) => e.type.name === Ie,
+      runner: (e, t) => {
+        e.openNode("listItem"), e.next(t.content), e.closeNode();
       }
     }
   }),
-  inputRules: (nodeType) => [wrappingInputRule(/^\s*([-+*])\s$/, nodeType)],
-  commands: (nodeType) => [
-    createCmd(SplitListItem, () => splitListItem(nodeType)),
-    createCmd(SinkListItem, () => sinkListItem(nodeType)),
-    createCmd(LiftListItem, () => liftListItem(nodeType))
+  inputRules: (e) => [W(/^\s*([-+*])\s$/, e)],
+  commands: (e) => [
+    M(oe, () => Be(e)),
+    M(ae, () => Re(e)),
+    M(le, () => Pe(e))
   ],
   shortcuts: {
-    [SupportedKeys.NextListItem]: createShortcut(SplitListItem, "Enter"),
-    [SupportedKeys.SinkListItem]: createShortcut(SinkListItem, "Mod-]"),
-    [SupportedKeys.LiftListItem]: createShortcut(LiftListItem, "Mod-[")
-  }
-}));
-const WrapInOrderedList = createCmdKey("WrapInOrderedList");
-const id$1 = "ordered_list";
-const orderedList = createNode((utils) => ({
-  id: id$1,
+    [k.NextListItem]: h(oe, "Enter"),
+    [k.SinkListItem]: h(ae, "Mod-]"),
+    [k.LiftListItem]: h(le, "Mod-[")
+  },
+  prosePlugins: (e) => [dt(e)]
+})), ce = I("WrapInOrderedList"), be = "ordered_list", gt = w((c) => ({
+  id: be,
   schema: () => ({
     content: "listItem+",
     group: "block",
@@ -1083,235 +1015,250 @@ const orderedList = createNode((utils) => ({
     parseDOM: [
       {
         tag: "ol",
-        getAttrs: (dom) => {
-          if (!(dom instanceof HTMLElement)) {
-            throw new Error();
-          }
-          return { order: dom.hasAttribute("start") ? Number(dom.getAttribute("start")) : 1 };
+        getAttrs: (e) => {
+          if (!(e instanceof HTMLElement))
+            throw D(e);
+          return { order: e.hasAttribute("start") ? Number(e.getAttribute("start")) : 1 };
         }
       }
     ],
-    toDOM: (node) => [
+    toDOM: (e) => [
       "ol",
-      __spreadProps(__spreadValues({}, node.attrs["order"] === 1 ? {} : node.attrs["order"]), {
-        class: utils.getClassName(node.attrs, "ordered-list")
-      }),
+      {
+        ...e.attrs.order === 1 ? {} : e.attrs.order,
+        class: c.getClassName(e.attrs, "ordered-list")
+      },
       0
     ],
     parseMarkdown: {
-      match: ({ type, ordered }) => type === "list" && !!ordered,
-      runner: (state, node, type) => {
-        state.openNode(type).next(node.children).closeNode();
+      match: ({ type: e, ordered: t }) => e === "list" && !!t,
+      runner: (e, t, r) => {
+        e.openNode(r).next(t.children).closeNode();
       }
     },
     toMarkdown: {
-      match: (node) => node.type.name === id$1,
-      runner: (state, node) => {
-        state.openNode("list", void 0, { ordered: true, start: 1 });
-        state.next(node.content);
-        state.closeNode();
+      match: (e) => e.type.name === be,
+      runner: (e, t) => {
+        e.openNode("list", void 0, { ordered: !0, start: 1 }), e.next(t.content), e.closeNode();
       }
     }
   }),
-  inputRules: (nodeType) => [
-    wrappingInputRule(/^(\d+)\.\s$/, nodeType, (match) => ({ order: Number(match[1]) }), (match, node) => node.childCount + node.attrs["order"] === Number(match[1]))
+  inputRules: (e) => [
+    W(/^(\d+)\.\s$/, e, (t) => ({ order: Number(t[1]) }), (t, r) => r.childCount + r.attrs.order === Number(t[1]))
   ],
-  commands: (nodeType) => [createCmd(WrapInOrderedList, () => wrapIn(nodeType))],
+  commands: (e) => [M(ce, () => de(e))],
   shortcuts: {
-    [SupportedKeys.OrderedList]: createShortcut(WrapInOrderedList, "Mod-Alt-7")
+    [k.OrderedList]: h(ce, "Mod-Alt-7")
   }
-}));
-const TurnIntoText = createCmdKey("TurnIntoText");
-const id = "paragraph";
-const paragraph = createNode((utils) => {
-  return {
-    id,
-    schema: () => ({
-      content: "inline*",
-      group: "block",
-      parseDOM: [{ tag: "p" }],
-      toDOM: (node) => ["p", { class: utils.getClassName(node.attrs, id) }, 0],
-      parseMarkdown: {
-        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: (node) => node.type.name === "paragraph",
-        runner: (state, node) => {
-          var _a;
-          state.openNode("paragraph");
-          const onlyHardbreak = node.childCount === 1 && ((_a = node.firstChild) == null ? void 0 : _a.type.name) === "hardbreak";
-          if (!onlyHardbreak) {
-            state.next(node.content);
-          }
-          state.closeNode();
-        }
+})), ie = I("TurnIntoText"), ye = "paragraph", ft = w((c) => ({
+  id: ye,
+  schema: () => ({
+    content: "inline*",
+    group: "block",
+    parseDOM: [{ tag: "p" }],
+    toDOM: (e) => ["p", { class: c.getClassName(e.attrs, ye) }, 0],
+    parseMarkdown: {
+      match: (e) => e.type === "paragraph",
+      runner: (e, t, r) => {
+        e.openNode(r), t.children ? e.next(t.children) : e.addText(t.value), e.closeNode();
+      }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === "paragraph",
+      runner: (e, t) => {
+        var n;
+        if (e.openNode("paragraph"), t.childCount >= 1 && ((n = t.lastChild) == null ? void 0 : n.type.name) === "hardbreak") {
+          const s = [];
+          t.content.forEach((a, o, l) => {
+            l !== t.childCount - 1 && s.push(a);
+          }), e.next(ge.fromArray(s));
+        } else
+          e.next(t.content);
+        e.closeNode();
       }
-    }),
-    commands: (nodeType) => [createCmd(TurnIntoText, () => setBlockType(nodeType))],
-    shortcuts: {
-      [SupportedKeys.Text]: createShortcut(TurnIntoText, "Mod-Alt-0")
     }
-  };
-});
-const text = createNode(() => ({
+  }),
+  commands: (e) => [M(ie, () => E(e))],
+  shortcuts: {
+    [k.Text]: h(ie, "Mod-Alt-0")
+  }
+})), pt = w(() => ({
   id: "text",
   schema: () => ({
     group: "inline",
     parseMarkdown: {
-      match: ({ type }) => type === "text",
-      runner: (state, node) => {
-        state.addText(node["value"]);
+      match: ({ type: c }) => c === "text",
+      runner: (c, e) => {
+        c.addText(e.value);
       }
     },
     toMarkdown: {
-      match: (node) => node.type.name === "text",
-      runner: (state, node) => {
-        state.addNode("text", void 0, node.text);
+      match: (c) => c.type.name === "text",
+      runner: (c, e) => {
+        c.addNode("text", void 0, e.text);
       }
     }
   })
-}));
-const nodes = [
-  doc(),
-  paragraph(),
-  hardbreak(),
-  blockquote(),
-  codeFence(),
-  bulletList(),
-  orderedList(),
-  listItem(),
-  heading(),
-  hr(),
-  image(),
-  text()
-];
-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);
-              }
+})), ht = [
+  et(),
+  ft(),
+  tt(),
+  Ge(),
+  Ze(),
+  Je(),
+  gt(),
+  mt(),
+  at(),
+  lt(),
+  it(),
+  pt()
+], kt = () => {
+  function c(e) {
+    qe(e, "list", (t) => {
+      var r;
+      if (t.ordered) {
+        const n = (r = t.start) != null ? r : 1;
+        t.children.forEach((s, a) => {
+          s.label = a + n;
+        });
+        return;
+      }
+    });
+  }
+  return c;
+}, Mt = (c) => !!c.children, It = (c) => c.type === "html";
+function bt(c, e) {
+  return t(c, 0, null)[0];
+  function t(r, n, s) {
+    if (Mt(r)) {
+      const a = [];
+      for (let o = 0, l = r.children.length; o < l; o++) {
+        const i = r.children[o];
+        if (i) {
+          const d = t(i, o, r);
+          if (d)
+            for (let m = 0, g = d.length; m < g; m++) {
+              const u = d[m];
+              u && a.push(u);
             }
-          }
         }
       }
-      node.children = out;
+      r.children = a;
     }
-    return fn(node, index, parent);
+    return e(r, n, s);
   }
 }
-const filterHTMLPlugin = () => {
-  function transformer(tree) {
-    flatMapWithDepth(tree, (node) => {
-      if (!isHTML(node)) {
-        return [node];
-      }
-      return [];
-    });
+const yt = () => {
+  function c(e) {
+    bt(e, (t) => It(t) ? [] : [t]);
   }
-  return transformer;
-};
-const inlineNodesCursorPluginKey = new PluginKey("MILKDOWN_INLINE_NODES_CURSOR");
-const inlineNodesCursorPlugin = new Plugin({
-  key: inlineNodesCursorPluginKey,
+  return c;
+}, Nt = new H("MILKDOWN_INLINE_NODES_CURSOR"), ue = new T({
+  key: Nt,
   state: {
     init() {
-      return false;
+      return !1;
     },
-    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;
+    apply(c) {
+      if (!c.selection.empty)
+        return !1;
+      const e = c.selection.$from, t = e.nodeBefore, r = e.nodeAfter;
+      return !!(t && r && t.isInline && !t.isText && r.isInline && !r.isText);
     }
   },
   props: {
     handleDOMEvents: {
-      beforeinput: (view, e) => {
-        const active = inlineNodesCursorPlugin.getState(view.state);
-        if (active) {
-          const from = view.state.selection.from;
-          e.preventDefault();
-          view.dispatch(view.state.tr.insertText(e.data || "", from));
-          return true;
+      beforeinput: (c, e) => {
+        if (ue.getState(c.state) && e instanceof InputEvent) {
+          const r = c.state.selection.from;
+          return e.preventDefault(), c.dispatch(c.state.tr.insertText(e.data || "", r)), !0;
         }
-        return false;
+        return !1;
       }
     },
-    decorations(state) {
-      const active = inlineNodesCursorPlugin.getState(state);
-      if (active) {
-        const pos = state.selection.$from;
-        const position = pos.pos;
-        const left = document.createElement("span");
-        const leftDec = Decoration.widget(position, left, {
+    decorations(c) {
+      if (ue.getState(c)) {
+        const r = c.selection.$from.pos, n = document.createElement("span"), s = J.widget(r, n, {
           side: -1
-        });
-        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]);
+        }), a = document.createElement("span"), o = J.widget(r, a);
+        return setTimeout(() => {
+          n.contentEditable = "true", a.contentEditable = "true";
+        }), O.create(c.doc, [s, o]);
       }
-      return DecorationSet.empty;
+      return O.empty;
     }
   }
-});
-const commonmarkPlugins = [
-  createPlugin(() => ({
-    prosePlugins: () => [inlineNodesCursorPlugin],
-    remarkPlugins: () => [links, filterHTMLPlugin]
+}), wt = [
+  He(() => ({
+    prosePlugins: () => [ue],
+    remarkPlugins: () => [We, yt, kt]
   }))()
-];
-const commonmarkNodes = AtomList.create([...nodes, ...marks]);
-const commonmark = AtomList.create([...commonmarkPlugins, ...commonmarkNodes]);
-const commands = {
-  ToggleInlineCode,
-  ToggleItalic,
-  ToggleLink,
-  ToggleBold,
-  ModifyLink,
-  ModifyImage,
-  WrapInBlockquote,
-  WrapInBulletList,
-  WrapInOrderedList,
-  TurnIntoCodeFence,
-  TurnIntoHeading,
-  TurnIntoText,
-  InsertHardbreak,
-  InsertHr,
-  InsertImage,
-  SplitListItem,
-  SinkListItem,
-  LiftListItem
+], Lt = Ne.create([...ht, ...ze]), Rt = Ne.create([...wt, ...Lt]), Pt = {
+  ToggleInlineCode: Q,
+  ToggleItalic: X,
+  ToggleLink: xe,
+  ToggleBold: Z,
+  ModifyLink: Y,
+  ModifyImage: se,
+  WrapInBlockquote: ee,
+  WrapInBulletList: te,
+  WrapInOrderedList: ce,
+  TurnIntoCodeFence: re,
+  TurnIntoHeading: C,
+  TurnIntoText: ie,
+  InsertHardbreak: ne,
+  InsertHr: Ce,
+  InsertImage: De,
+  SplitListItem: oe,
+  SinkListItem: ae,
+  LiftListItem: le
+};
+export {
+  Me as DowngradeHeading,
+  ne as InsertHardbreak,
+  Ce as InsertHr,
+  De as InsertImage,
+  le as LiftListItem,
+  se as ModifyImage,
+  Y as ModifyLink,
+  ae as SinkListItem,
+  oe as SplitListItem,
+  k as SupportedKeys,
+  Z as ToggleBold,
+  Q as ToggleInlineCode,
+  X as ToggleItalic,
+  xe as ToggleLink,
+  re as TurnIntoCodeFence,
+  C as TurnIntoHeading,
+  ie as TurnIntoText,
+  ee as WrapInBlockquote,
+  te as WrapInBulletList,
+  ce as WrapInOrderedList,
+  Xe as backtickInputRegex,
+  Ge as blockquote,
+  Je as bulletList,
+  Ze as codeFence,
+  Ke as codeInline,
+  Pt as commands,
+  Rt as commonmark,
+  Lt as commonmarkNodes,
+  wt as commonmarkPlugins,
+  et as doc,
+  Fe as em,
+  tt as hardbreak,
+  at as heading,
+  rt as headingHashPluginKey,
+  j as headingIdPluginKey,
+  lt as hr,
+  it as image,
+  Ve as link,
+  mt as listItem,
+  ze as marks,
+  ht as nodes,
+  gt as orderedList,
+  ft as paragraph,
+  je as strong,
+  pt as text,
+  Ye as tildeInputRegex
 };
-export { InsertHardbreak, InsertHr, InsertImage, LiftListItem, ModifyImage, ModifyLink, SinkListItem, SplitListItem, SupportedKeys, ToggleBold, ToggleInlineCode, ToggleItalic, ToggleLink, TurnIntoCodeFence, TurnIntoHeading, TurnIntoText, WrapInBlockquote, WrapInBulletList, WrapInOrderedList, backtickInputRegex, blockquote, bulletList, codeFence, codeInline, commands, commonmark, commonmarkNodes, commonmarkPlugins, doc, em, hardbreak, heading, headingPluginKey, hr, image, link, listItem, marks, nodes, orderedList, paragraph, strong, text, tildeInputRegex };
 //# sourceMappingURL=index.es.js.map