@milkdown/preset-commonmark 6.2.0 → 6.3.2

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, calculateTextPosition, findSelectedNodeOfType } from "@milkdown/prose";
-import { toggleMark, wrapIn, setBlockType } from "@milkdown/prose/commands";
-import { InputRule, wrappingInputRule, textblockTypeInputRule } from "@milkdown/prose/inputrules";
-import { PluginKey, TextSelection, Plugin, NodeSelection, 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 L, createPlugin as De, AtomList as ye } from "@milkdown/utils";
+import { createCmdKey as I, createCmd as M, schemaCtx as A, commandsCtx as Ne, editorViewCtx as P, getPalette as He } from "@milkdown/core";
+import { markRule as _, calculateTextPosition as Te, cloneTr as Oe, findSelectedNodeOfType as F, getNodeFromSchema as Ae } from "@milkdown/prose";
+import { toggleMark as W, wrapIn as de, setBlockType as E } from "@milkdown/prose/commands";
+import { expectDomTypeError as D, missingRootElement as Ee } from "@milkdown/exception";
+import { InputRule as me, wrappingInputRule as q, textblockTypeInputRule as J } from "@milkdown/prose/inputrules";
+import { PluginKey as T, TextSelection as ge, Plugin as H, NodeSelection as _e, Selection as Le } from "@milkdown/prose/state";
+import { Fragment as R } from "@milkdown/prose/model";
+import { ReplaceStep as ve, AddMarkStep as $e } from "@milkdown/prose/transform";
+import { DecorationSet as O, Decoration as Q } from "@milkdown/prose/view";
+import { splitListItem as Se, sinkListItem as Re, liftListItem as Be } from "@milkdown/prose/schema-list";
+import Pe from "remark-inline-links";
+import { visit as We } 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,372 +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 || "");
-        }
+}, pe = "code_inline", X = I("ToggleInlineCode"), qe = B((i) => ({
+  id: pe,
+  schema: () => ({
+    priority: 100,
+    code: !0,
+    inclusive: !1,
+    parseDOM: [{ tag: "code" }],
+    toDOM: (e) => ["code", { class: i.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 === pe,
+      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(X, () => W(e))],
+  shortcuts: {
+    [k.CodeInline]: h(X, "Mod-e")
+  }
+})), U = "em", Y = I("ToggleItalic"), Ke = B((i) => ({
+  id: U,
   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: i.getClassName(e.attrs, U) }],
     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 === U,
+      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(Y, () => W(e))],
   shortcuts: {
-    [SupportedKeys.Em]: createShortcut(ToggleItalic, "Mod-i")
+    [k.Em]: h(Y, "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"]
-          });
+})), Fe = new T("MILKDOWN_LINK_INPUT"), we = I("ToggleLink"), Z = I("ModifyLink"), v = "link", Ue = B((i, 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) => {
-        var _a;
-        if (!dispatch)
-          return false;
-        const { marks: marks2 } = state.schema;
-        let node;
-        let pos = -1;
-        const { selection } = state;
-        const { from, to } = selection;
-        state.doc.nodesBetween(from, from === to ? to + 1 : to, (n, p) => {
-          var _a2;
-          if ((_a2 = marks2["link"]) == null ? void 0 : _a2.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 = (_a = marks2["link"]) == null ? void 0 : _a.create(__spreadProps(__spreadValues({}, mark.attrs), { href }));
-        if (!linkMark)
-          return false;
-        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: i.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(we, (r = "") => W(t, { href: r })),
+    M(Z, (r = "") => (n, s) => {
+      var y;
+      if (!s)
+        return !1;
+      const { marks: a } = n.schema;
+      let o, l = -1;
+      const { selection: c } = n, { from: u, to: f } = c;
+      if (n.doc.nodesBetween(u, u === f ? f + 1 : f, (N, x) => {
+        var w;
+        if ((w = a.link) != null && w.isInSet(N.marks))
+          return o = N, l = x, !1;
+      }), !o)
+        return !1;
+      const d = o.marks.find(({ type: N }) => N === t);
+      if (!d)
+        return !1;
+      const m = l, g = l + o.nodeSize, { tr: p } = n, b = (y = a.link) == null ? void 0 : y.create({ ...d.attrs, href: r });
+      return b ? (s(p.removeMark(m, g, d).addMark(m, g, b).setSelection(new ge(p.selection.$anchor)).scrollIntoView()), !0) : !1;
+    })
+  ],
+  inputRules: (t, r) => [
+    new me(/\[(?<text>.*?)]\((?<href>.*?)(?=“|\))"?(?<title>[^"]+)?"?\)/, (n, s, a, o) => {
+      const [l, c = "", u, f] = s, { tr: d } = n;
+      if (l) {
+        const m = c || "link";
+        d.replaceWith(a, o, r.get(A).text(m)).addMark(a, m.length + a, t.create({ title: f, href: u }));
+      }
+      return d;
+    })
+  ],
+  prosePlugins: (t, r) => {
+    let n = !1;
+    return [
+      new H({
+        key: Fe,
+        view: (s) => {
+          var u, f, d;
+          const a = i.themeManager.get("input-chip", {
+            placeholder: (f = (u = e == null ? void 0 : e.input) == null ? void 0 : u.placeholder) != null ? f : "Input Web Link",
+            buttonText: (d = e == null ? void 0 : e.input) == null ? void 0 : d.buttonText,
+            onUpdate: (m) => {
+              r.get(Ne).call(Z, m);
+            },
+            calculatePosition: (m, g) => {
+              Te(m, g, (p, b, y, N) => {
+                const x = m.dom.parentElement;
+                if (!x)
+                  throw Ee();
+                const w = b.left - p.left;
+                let K = p.left - N.left - (y.width - w) / 2, fe = p.bottom - N.top + 14 + x.scrollTop;
+                return n && (fe = p.top - N.top - y.height - 14 + x.scrollTop), K < 0 && (K = 0), [fe, K];
+              });
+            }
+          });
+          if (!a)
+            return {};
+          const o = (m) => {
+            const { selection: g, doc: p } = m.state, { from: b, to: y } = g;
+            if (!m.hasFocus())
+              return !1;
+            if (g.empty && g instanceof ge && y < p.content.size && b < p.content.size && p.rangeHasMark(b, b === y ? y + 1 : y, t))
+              return n = !1, !0;
+            if (g instanceof _e) {
+              const { node: N } = g;
+              if (N.type.name === "image" && N.marks.findIndex((x) => x.type.name === v) > -1)
+                return n = !0, !0;
+            }
+            return !1;
+          }, l = (m) => {
+            const { selection: g } = m.state;
+            let p;
+            const { from: b, to: y } = g;
+            if (m.state.doc.nodesBetween(b, b === y ? y + 1 : y, (w) => {
+              if (t.isInSet(w.marks))
+                return p = w, !1;
+            }), !p)
+              return;
+            const N = p.marks.find((w) => w.type === t);
+            return N ? N.attrs.href : void 0;
+          }, c = (m) => {
+            if (!m.editable)
+              return;
+            o(m) ? (a.show(m), a.update(l(m))) : a.hide();
+          };
+          return a.init(s), c(s), {
+            update: (m, g) => {
+              (g == null ? void 0 : g.doc.eq(m.state.doc)) && g.selection.eq(m.state.selection) || requestAnimationFrame(() => {
+                c(m);
+              });
+            },
+            destroy: () => {
+              a.destroy();
+            }
+          };
         }
-        return tr;
       })
+    ];
+  }
+})), V = "strong", ee = I("ToggleBold"), Ve = B((i) => ({
+  id: V,
+  schema: () => ({
+    parseDOM: [
+      { tag: "b" },
+      { tag: "strong" },
+      { style: "font-style", getAttrs: (e) => e === "bold" }
     ],
-    prosePlugins: (type, ctx) => {
-      let renderOnTop = false;
-      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);
-              },
-              calculatePosition: (view, input) => {
-                calculateTextPosition(view, input, (start, end, target, parent) => {
-                  const $editor = view.dom.parentElement;
-                  if (!$editor) {
-                    throw new Error();
-                  }
-                  const selectionWidth = end.left - start.left;
-                  let left = start.left - parent.left - (target.width - selectionWidth) / 2;
-                  let top = start.bottom - parent.top + 14 + $editor.scrollTop;
-                  if (renderOnTop) {
-                    top = start.top - parent.top - target.height - 14 + $editor.scrollTop;
-                  }
-                  if (left < 0)
-                    left = 0;
-                  return [top, left];
-                });
-              }
-            });
-            if (!inputChipRenderer)
-              return {};
-            const shouldDisplay = (view) => {
-              const { selection, doc: doc2 } = view.state;
-              const { from, to } = selection;
-              if (!view.hasFocus()) {
-                return false;
-              }
-              if (selection.empty && selection instanceof TextSelection && to < doc2.content.size && from < doc2.content.size && doc2.rangeHasMark(from, from === to ? to + 1 : to, type)) {
-                renderOnTop = false;
-                return true;
-              }
-              if (selection instanceof NodeSelection) {
-                const { node } = selection;
-                if (node.type.name === "image" && node.marks.findIndex((mark) => mark.type.name === id$8) > -1) {
-                  renderOnTop = true;
-                  return true;
-                }
-              }
-              return false;
-            };
-            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;
-                requestAnimationFrame(() => {
-                  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: i.getClassName(e.attrs, V) }],
+    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 === V,
+      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(ee, () => W(e))],
+  shortcuts: {
+    [k.Bold]: h(ee, "Mod-b")
+  }
+})), je = [qe(), Ke(), Ve(), Ue()], $ = "blockquote", te = I("WrapInBlockquote"), ze = L((i) => ({
+  id: $,
+  schema: () => ({
+    content: "block+",
+    group: "block",
+    defining: !0,
+    parseDOM: [{ tag: "blockquote" }],
+    toDOM: (e) => ["blockquote", { class: i.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) => [q(/^\s*>\s$/, e)],
+  commands: (e) => [M(te, () => de(e))],
+  shortcuts: {
+    [k.Blockquote]: h(te, "Mod-Shift-b")
+  }
+})), re = I("WrapInBulletList"), Ge = L((i) => {
+  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: i.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) => [q(/^\s*([-+*])\s$/, t)],
+    commands: (t) => [M(re, () => de(t))],
     shortcuts: {
-      [SupportedKeys.BulletList]: createShortcut(WrapInBulletList, "Mod-Alt-8")
+      [k.BulletList]: h(re, "Mod-Alt-8")
     }
   };
-});
-const languageOptions = [
+}), Je = [
   "",
   "javascript",
   "typescript",
@@ -429,304 +324,354 @@ 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;
+], Qe = /^```(?<language>[a-z]*)?[\s\n]$/, Xe = /^~~~(?<language>[a-z]*)?[\s\n]$/, ne = I("TurnIntoCodeFence"), j = "fence", Ye = L((i, e) => {
+  const t = (e == null ? void 0 : e.languageList) || Je;
   return {
-    id: id$5,
-    schema: (ctx) => ({
+    id: j,
+    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 l, c;
+            if (!(n instanceof HTMLElement))
+              throw D(n);
+            const a = (c = (l = n.querySelector("pre")) == null ? void 0 : l.textContent) != null ? c : "";
+            if (!a)
+              return R.empty;
+            const o = s.text(a);
+            return R.from(o);
           }
         },
         {
           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(P);
+          if (!l.editable) {
+            o.value = n.attrs.language;
             return;
           }
-          const { top, left } = target.getBoundingClientRect();
-          const result = view.posAtCoords({ top, left });
-          if (!result)
+          const { top: c, left: u } = o.getBoundingClientRect(), f = l.posAtCoords({ top: c, left: u });
+          if (!f)
             return;
-          const { tr } = view.state;
-          view.dispatch(tr.setNodeMarkup(result.inside, void 0, __spreadProps(__spreadValues({}, node.attrs), {
-            language: target.value
-          })));
-        };
-        return [
+          const { tr: d } = l.state;
+          l.dispatch(d.setNodeMarkup(f.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: i.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 === j,
+        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) => [
+      J(Qe, r, (n) => {
+        const [s, a] = n;
+        if (!!s)
+          return { language: a };
       }),
-      textblockTypeInputRule(tildeInputRegex, nodeType, (match) => {
-        const [ok, language] = match;
-        if (!ok)
-          return;
-        return { language };
+      J(Xe, r, (n) => {
+        const [s, a] = n;
+        if (!!s)
+          return { language: a };
       })
     ],
-    commands: (nodeType) => [createCmd(TurnIntoCodeFence, () => setBlockType(nodeType))],
+    commands: (r) => [M(ne, () => E(r))],
     shortcuts: {
-      [SupportedKeys.CodeFence]: createShortcut(TurnIntoCodeFence, "Mod-Alt-c")
+      [k.CodeFence]: h(ne, "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: b } = n.state;
+        n.dispatch(b.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
+        }));
+      }, c = () => {
+        const { tr: p } = n.state;
+        n.dispatch(p.setNodeMarkup(s(), void 0, {
+          ...a.attrs,
+          fold: !1
+        }));
+      }, u = i.themeManager.get("code-fence", {
+        onBlur: l,
+        onFocus: c,
+        onSelectLanguage: o,
+        editable: () => n.editable,
+        languageList: t
       });
-      if (!renderer)
+      if (!u)
         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: f, contentDOM: d, onUpdate: m, onDestroy: g } = u;
+      return m(a), {
+        dom: f,
+        contentDOM: d,
+        update: (p) => p.type.name !== j ? !1 : (a = p, m(a), !0),
+        destroy: g
       };
     }
   };
-});
-const doc = createNode(() => {
-  return {
-    id: "doc",
-    schema: () => ({
-      content: "block+",
-      parseMarkdown: {
-        match: ({ type }) => type === "root",
-        runner: (state, node, type) => {
-          state.injectRoot(node, type);
-        }
-      },
-      toMarkdown: {
-        match: (node) => node.type.name === "doc",
-        runner: (state, node) => {
-          state.openNode("root");
-          state.next(node.content);
-        }
+}), Ze = L(() => ({
+  id: "doc",
+  schema: () => ({
+    content: "block+",
+    parseMarkdown: {
+      match: ({ type: i }) => i === "root",
+      runner: (i, e, t) => {
+        i.injectRoot(e, t);
       }
-    })
-  };
-});
-const InsertHardbreak = createCmdKey("InsertHardbreak");
-const hardbreak = createNode((utils) => {
+    },
+    toMarkdown: {
+      match: (i) => i.type.name === "doc",
+      runner: (i, e) => {
+        i.openNode("root"), i.next(e.content);
+      }
+    }
+  })
+})), se = I("InsertHardbreak"), et = new T("MILKDOWN_HARDBREAK_FILTER"), tt = L((i, e) => {
+  var r;
+  const t = (r = e == null ? void 0 : e.notIn) != null ? r : ["table", "fence"];
   return {
     id: "hardbreak",
     schema: () => ({
-      inline: true,
+      inline: !0,
       group: "inline",
-      selectable: false,
+      selectable: !1,
       parseDOM: [{ tag: "br" }],
-      toDOM: (node) => ["br", { class: utils.getClassName(node.attrs, "hardbreak") }],
+      toDOM: (n) => ["br", { class: i.getClassName(n.attrs, "hardbreak") }],
       parseMarkdown: {
-        match: ({ type }) => type === "break",
-        runner: (state, _, type) => {
-          state.addNode(type);
+        match: ({ type: n }) => n === "break",
+        runner: (n, s, a) => {
+          n.addNode(a);
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === "hardbreak",
-        runner: (state) => {
-          state.addNode("break");
+        match: (n) => n.type.name === "hardbreak",
+        runner: (n) => {
+          n.addNode("break");
         }
       }
     }),
-    commands: (type) => [
-      createCmd(InsertHardbreak, () => (state, dispatch) => {
-        var _a;
-        const { selection, tr } = state;
-        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;
-          }
+    commands: (n) => [
+      M(se, () => (s, a) => {
+        var c;
+        const { selection: o, tr: l } = s;
+        if (o.empty) {
+          const u = o.$from.node();
+          if (u.childCount > 0 && ((c = u.lastChild) == null ? void 0 : c.type.name) === "hardbreak")
+            return a == null || a(l.replaceRangeWith(o.to - 1, o.to, s.schema.node("paragraph")).setSelection(Le.near(l.doc.resolve(o.to))).scrollIntoView()), !0;
         }
-        dispatch == null ? void 0 : dispatch(tr.setMeta("hardbreak", true).replaceSelectionWith(type.create()).scrollIntoView());
-        return true;
+        return a == null || a(l.setMeta("hardbreak", !0).replaceSelectionWith(n.create()).scrollIntoView()), !0;
       })
     ],
     shortcuts: {
-      [SupportedKeys.HardBreak]: createShortcut(InsertHardbreak, "Shift-Enter")
+      [k.HardBreak]: h(se, "Shift-Enter")
     },
-    prosePlugins: (type) => [
-      new Plugin({
-        key: new PluginKey("MILKDOWN_HARDBREAK_MARKS"),
-        appendTransaction: (trs, _oldState, newState) => {
-          if (!trs.length)
+    prosePlugins: (n) => [
+      new H({
+        key: et,
+        filterTransaction: (s, a) => {
+          const o = s.getMeta("hardbreak"), [l] = s.steps;
+          if (o && l) {
+            const { from: c } = l, u = a.doc.resolve(c);
+            let f = u.depth, d = !0;
+            for (; f > 0; )
+              t.includes(u.node(f).type.name) && (d = !1), f--;
+            return d;
+          }
+          return !0;
+        }
+      }),
+      new H({
+        key: new T("MILKDOWN_HARDBREAK_MARKS"),
+        appendTransaction: (s, a, o) => {
+          if (!s.length)
             return;
-          const [tr] = trs;
-          if (!tr)
+          const [l] = s;
+          if (!l)
             return;
-          const [step] = tr.steps;
-          const isInsertHr = tr.getMeta("hardbreak");
-          if (isInsertHr) {
-            if (!(step instanceof ReplaceStep)) {
+          const [c] = l.steps;
+          if (l.getMeta("hardbreak")) {
+            if (!(c instanceof ve))
               return;
-            }
-            const { from } = step;
-            return newState.tr.setNodeMarkup(from, type, void 0, []);
+            const { from: d } = c;
+            return o.tr.setNodeMarkup(d, n, 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;
+          if (c instanceof $e) {
+            let d = o.tr;
+            const { from: m, to: g } = c;
+            return o.doc.nodesBetween(m, g, (p, b) => {
+              p.type === n && (d = d.setNodeMarkup(b, n, void 0, []));
+            }), d;
           }
-          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, options) => {
-  var _a;
-  const id2 = "heading";
-  const getId = (_a = options == null ? void 0 : options.getId) != null ? _a : createId;
+}), he = Array(6).fill(0).map((i, e) => e + 1), C = I("TurnIntoHeading"), ke = I("DowngradeHeading"), z = new T("MILKDOWN_HEADING_ID"), rt = new T("MILKDOWN_HEADING_HASH"), nt = (i) => i.textContent.replace(/[\p{P}\p{S}]/gu, "").replace(/\s/g, "-").toLowerCase().trim(), st = (i, e, t) => {
+  let r = !1;
+  const n = (s, a) => {
+    const o = s.tr;
+    s.doc.descendants((l, c) => {
+      if (l.type === e && !r) {
+        if (l.textContent.trim().length === 0)
+          return;
+        const u = l.attrs, f = t(l);
+        u.id !== f && o.setMeta(z, !0).setNodeMarkup(c, void 0, {
+          ...u,
+          id: f
+        });
+      }
+    }), a(o);
+  };
+  return new H({
+    key: z,
+    props: {
+      handleDOMEvents: {
+        compositionstart: () => (r = !0, !1),
+        compositionend: () => {
+          r = !1;
+          const s = i.get(P);
+          return setTimeout(() => {
+            n(s.state, (a) => s.dispatch(a));
+          }, 0), !1;
+        }
+      }
+    },
+    appendTransaction: (s, a, o) => {
+      let l = null;
+      return s.every((c) => !c.getMeta(z)) && s.some((c) => c.docChanged) && n(o, (c) => {
+        l = c;
+      }), l;
+    },
+    view: (s) => {
+      const a = s.state.doc;
+      let o = s.state.tr;
+      return a.descendants((l, c) => {
+        l.type.name === "heading" && l.attrs.level && (l.attrs.id || (o = o.setNodeMarkup(c, void 0, {
+          ...l.attrs,
+          id: t(l)
+        })));
+      }), s.dispatch(o), {};
+    }
+  });
+}, ot = (i, e, t) => new H({
+  key: rt,
+  state: {
+    init: () => O.empty,
+    apply: (r) => {
+      const n = i.get(P);
+      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 = (f) => Array(f).fill(0).map((d) => "#").join(""), c = document.createElement("span");
+      c.textContent = l(o), c.contentEditable = "false", t.themeManager.onFlush(() => {
+        const f = t.getStyle(({ css: d }) => {
+          const m = He(t.themeManager);
+          return d`
+                            margin-right: 4px;
+                            color: ${m("primary")};
+                        `;
+        });
+        f && (c.className = f);
+      });
+      const u = Q.widget(s.before() + 1, c, { side: -1 });
+      return O.create(r.doc, [u]);
+    }
+  },
+  props: {
+    handleDOMEvents: {
+      focus: (r) => {
+        const n = Oe(r.state.tr);
+        return r.dispatch(n), !1;
+      }
+    },
+    decorations(r) {
+      return this.getState(r);
+    }
+  }
+}), at = L((i, 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: ""
@@ -735,422 +680,351 @@ const heading = createNode((utils, options) => {
           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: he.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"] || getId(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: i.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, c) => {
+          const u = l.depth;
+          o.openNode(c, { level: u }), o.next(l.children), o.closeNode();
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id2,
-        runner: (state, node) => {
-          var _a2;
-          state.openNode("heading", void 0, { depth: node.attrs["level"] });
-          const lastIsHardbreak = node.childCount >= 1 && ((_a2 = node.lastChild) == null ? void 0 : _a2.type.name) === "hardbreak";
-          if (lastIsHardbreak) {
-            const contentArr = [];
-            node.content.forEach((n, _, i) => {
-              if (i === node.childCount - 1) {
-                return;
-              }
-              contentArr.push(n);
-            });
-            state.next(Fragment.fromArray(contentArr));
-          } else {
-            state.next(node.content);
-          }
-          state.closeNode();
+        match: (o) => o.type.name === t,
+        runner: (o, l) => {
+          var u;
+          if (o.openNode("heading", void 0, { depth: l.attrs.level }), l.childCount >= 1 && ((u = l.lastChild) == null ? void 0 : u.type.name) === "hardbreak") {
+            const f = [];
+            l.content.forEach((d, m, g) => {
+              g !== l.childCount - 1 && f.push(d);
+            }), o.next(R.fromArray(f));
+          } 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) => he.map((c) => J(new RegExp(`^(#{1,${c}})\\s$`), o, () => {
+      const u = l.get(P), { $from: f } = u.state.selection, d = f.node();
+      if (d.type.name === "heading") {
+        let m = Number(d.attrs.level) + Number(c);
+        return m > 6 && (m = 6), {
+          level: m
+        };
+      }
+      return {
+        level: c
+      };
+    })),
+    commands: (o, l) => [
+      M(C, (c = 1) => c < 1 ? E(c === 0 && l.get(A).nodes.paragraph || o) : E(c === 0 && l.get(A).nodes.paragraph || o, { level: c })),
+      M(ke, () => (c, u, f) => {
+        const { $from: d } = c.selection, m = d.node();
+        if (m.type !== o || !c.selection.empty || d.parentOffset !== 0)
+          return !1;
+        const g = m.attrs.level - 1;
+        return g ? (u == null || u(c.tr.setNodeMarkup(c.selection.$from.before(), void 0, {
+          ...m.attrs,
+          level: g
+        })), !0) : E(l.get(A).nodes.paragraph || o)(c, u, f);
+      })
+    ],
     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(ke, ["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 = getId(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;
-          },
-          view: (view) => {
-            const doc2 = view.state.doc;
-            let tr = view.state.tr;
-            doc2.descendants((node, pos) => {
-              if (node.type.name === "heading" && node.attrs["level"]) {
-                if (!node.attrs["id"]) {
-                  tr = tr.setNodeMarkup(pos, void 0, __spreadProps(__spreadValues({}, node.attrs), {
-                    id: getId(node)
-                  }));
-                }
-              }
-            });
-            view.dispatch(tr);
-            return {};
-          }
-        })
-      ];
+    prosePlugins: (o, l) => {
+      const c = [st(l, o, r)];
+      return n && c.push(ot(l, o, i)), c;
     }
   };
-});
-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");
-        }
+}), G = "hr", xe = I("InsertHr"), lt = L((i) => ({
+  id: G,
+  schema: () => ({
+    group: "block",
+    parseDOM: [{ tag: "hr" }],
+    toDOM: (e) => ["hr", { class: i.getClassName(e.attrs, G) }],
+    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 paragraph2 = ctx.get(schemaCtx).node("paragraph");
-        const { tr, selection } = state;
-        const { from } = selection;
-        const node = type.create();
-        if (!node) {
-          return true;
-        }
-        const _tr = tr.replaceSelectionWith(node).insert(from, paragraph2);
-        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 === G,
+      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(xe, () => (r, n) => {
+      if (!n)
+        return !0;
+      const s = t.get(A).node("paragraph"), { tr: a, selection: o } = r, { from: l } = o, c = e.create();
+      if (!c)
+        return !0;
+      const u = a.replaceSelectionWith(c).insert(l, s), f = Le.findFrom(u.doc.resolve(l), 1, !0);
+      return f && n(u.setSelection(f).scrollIntoView()), !0;
+    })
+  ]
+})), oe = I("ModifyImage"), Ce = I("InsertImage"), S = "image", ct = new T("MILKDOWN_IMAGE_INPUT"), it = L((i, 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: i.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(Ce, (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(oe, (r = "") => (n, s) => {
+      const a = F(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, c = "", u] = n, { tr: f } = r;
+      return o && f.replaceWith(s, a, t.create({ src: c, alt: l, title: u })), f;
+    })
+  ],
+  view: () => (t) => {
+    var c, u;
+    let r = t;
+    const n = (c = e == null ? void 0 : e.placeholder) != null ? c : "Add an Image", s = (u = e == null ? void 0 : e.isBlock) != null ? u : !1, a = i.themeManager.get("image", {
+      placeholder: n,
+      isBlock: s
+    });
+    if (!a)
+      return {};
+    const { dom: o, onUpdate: l } = a;
+    return l(r), {
+      dom: o,
+      update: (f) => f.type.name !== S ? !1 : (r = f, l(r), !0),
+      selectNode: () => {
+        o.classList.add("ProseMirror-selectednode");
+      },
+      deselectNode: () => {
+        o.classList.remove("ProseMirror-selectednode");
+      }
+    };
+  },
+  prosePlugins: (t, r) => [
+    new H({
+      key: ct,
+      view: (n) => {
+        var c, u, f;
+        const s = i.themeManager.get("input-chip", {
+          placeholder: (u = (c = e == null ? void 0 : e.input) == null ? void 0 : c.placeholder) != null ? u : "Input Image Link",
+          buttonText: (f = e == null ? void 0 : e.input) == null ? void 0 : f.buttonText,
+          onUpdate: (d) => {
+            r.get(Ne).call(oe, d);
+          }
+        });
+        if (!s)
+          return {};
+        const a = (d) => Boolean(d.hasFocus() && t && F(d.state.selection, t)), o = (d) => {
+          const m = F(d.state.selection, t);
+          return m ? m.node.attrs.src : void 0;
+        }, l = (d) => {
+          if (!d.editable)
+            return;
+          a(d) ? (s.show(d), s.update(o(d))) : s.hide();
+        };
+        return s.init(n), l(n), {
+          update: (d, m) => {
+            (m == null ? void 0 : m.doc.eq(d.state.doc)) && m.selection.eq(d.state.selection) || l(d);
+          },
+          destroy: () => {
+            s.destroy();
+          }
+        };
+      }
+    })
+  ]
+})), Me = "list_item", ae = I("SplitListItem"), le = I("SinkListItem"), ce = I("LiftListItem"), ut = new T("MILKDOWN_KEEP_LIST_ORDER"), dt = (i) => {
+  const e = (t, r) => {
+    const n = Ae("ordered_list", t.schema);
+    let s = t.tr;
+    t.doc.descendants((a, o, l, c) => {
+      if (a.type === i && (l == null ? void 0 : l.type) === n) {
+        let u = !1;
+        const f = { ...a.attrs };
+        a.attrs.listType !== "ordered" && (f.listType = "ordered", u = !0);
+        const d = l == null ? void 0 : l.maybeChild(0);
+        if (d && d.type === i && d.attrs.listType === "ordered") {
+          const m = d.attrs.label;
+          f.label = `${Number(m.slice(0, -1)) + c}.`, u = !0;
+        }
+        a.attrs.label === "\u2022" && (f.label = `${c + 1}.`, u = !0), u && (s = s.setNodeMarkup(o, void 0, f));
+      }
+    }), 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 H({
+    key: ut,
+    appendTransaction: (t, r, n) => {
+      let s = null;
+      return t.some((a) => a.docChanged) && e(n, (a) => {
+        s = a;
+      }), s;
+    }
+  });
+}, mt = L((i) => ({
+  id: Me,
   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: i.getClassName(e.attrs, "list-item"),
+        "data-label": e.attrs.label,
+        "data-list-type": e.attrs.listType
+      },
+      ["div", { class: i.getClassName(e.attrs, "list-item_label") }, e.attrs.label],
+      ["div", { class: i.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 === Me,
+      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) => [q(/^\s*([-+*])\s$/, e)],
+  commands: (e) => [
+    M(ae, () => Se(e)),
+    M(le, () => Re(e)),
+    M(ce, () => Be(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(ae, "Enter"),
+    [k.SinkListItem]: h(le, "Mod-]"),
+    [k.LiftListItem]: h(ce, "Mod-[")
+  },
+  prosePlugins: (e) => [dt(e)]
+})), ie = I("WrapInOrderedList"), Ie = "ordered_list", ft = L((i) => ({
+  id: Ie,
   schema: () => ({
     content: "listItem+",
     group: "block",
@@ -1162,244 +1036,262 @@ 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: i.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 === Ie,
+      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) => [
+    q(/^(\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(ie, () => de(e))],
   shortcuts: {
-    [SupportedKeys.OrderedList]: createShortcut(WrapInOrderedList, "Mod-Alt-7")
+    [k.OrderedList]: h(ie, "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 lastIsHardbreak = node.childCount >= 1 && ((_a = node.lastChild) == null ? void 0 : _a.type.name) === "hardbreak";
-          if (lastIsHardbreak) {
-            const contentArr = [];
-            node.content.forEach((n, _, i) => {
-              if (i === node.childCount - 1) {
-                return;
-              }
-              contentArr.push(n);
-            });
-            state.next(Fragment.fromArray(contentArr));
-          } else {
-            state.next(node.content);
-          }
-          state.closeNode();
-        }
+})), ue = I("TurnIntoText"), be = "paragraph", gt = L((i) => ({
+  id: be,
+  schema: () => ({
+    content: "inline*",
+    group: "block",
+    parseDOM: [{ tag: "p" }],
+    toDOM: (e) => ["p", { class: i.getClassName(e.attrs, be) }, 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(R.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(ue, () => E(e))],
+  shortcuts: {
+    [k.Text]: h(ue, "Mod-Alt-0")
+  }
+})), pt = L(() => ({
   id: "text",
   schema: () => ({
     group: "inline",
     parseMarkdown: {
-      match: ({ type }) => type === "text",
-      runner: (state, node) => {
-        state.addText(node["value"]);
+      match: ({ type: i }) => i === "text",
+      runner: (i, e) => {
+        i.addText(e.value);
       }
     },
     toMarkdown: {
-      match: (node) => node.type.name === "text",
-      runner: (state, node) => {
-        state.addNode("text", void 0, node.text);
+      match: (i) => i.type.name === "text",
+      runner: (i, e) => {
+        i.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 = [
+  Ze(),
+  gt(),
+  tt(),
+  ze(),
+  Ye(),
+  Ge(),
+  ft(),
+  mt(),
+  at(),
+  lt(),
+  it(),
+  pt()
+], kt = () => {
+  function i(e) {
+    We(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 i;
+}, Mt = (i) => !!i.children, It = (i) => i.type === "html";
+function bt(i, e) {
+  return t(i, 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 c = r.children[o];
+        if (c) {
+          const u = t(c, o, r);
+          if (u)
+            for (let f = 0, d = u.length; f < d; f++) {
+              const m = u[f];
+              m && a.push(m);
             }
-          }
         }
       }
-      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 i(e) {
+    bt(e, (t) => It(t) ? [] : [t]);
   }
-  return transformer;
-};
-const inlineNodesCursorPluginKey = new PluginKey("MILKDOWN_INLINE_NODES_CURSOR");
-const inlineNodesCursorPlugin = new Plugin({
-  key: inlineNodesCursorPluginKey,
-  state: {
-    init() {
-      return false;
-    },
-    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: {
-      beforeinput: (view, e) => {
-        const active = inlineNodesCursorPlugin.getState(view.state);
-        if (active && e instanceof InputEvent) {
-          const from = view.state.selection.from;
-          e.preventDefault();
-          view.dispatch(view.state.tr.insertText(e.data || "", from));
-          return true;
-        }
-        return false;
+  return i;
+}, Nt = new T("MILKDOWN_INLINE_NODES_CURSOR"), Lt = () => {
+  let i = !1;
+  const e = new H({
+    key: Nt,
+    state: {
+      init() {
+        return !1;
+      },
+      apply(t) {
+        if (!t.selection.empty)
+          return !1;
+        const r = t.selection.$from, n = r.nodeBefore, s = r.nodeAfter;
+        return !!(n && s && n.isInline && !n.isText && s.isInline && !s.isText);
       }
     },
-    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, {
-          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]);
+    props: {
+      handleDOMEvents: {
+        compositionend: (t, r) => i ? (i = !1, requestAnimationFrame(() => {
+          if (e.getState(t.state)) {
+            const s = t.state.selection.from;
+            r.preventDefault(), t.dispatch(t.state.tr.insertText(r.data || "", s));
+          }
+        }), !0) : !1,
+        compositionstart: (t) => (e.getState(t.state) && (i = !0), !1),
+        beforeinput: (t, r) => {
+          if (e.getState(t.state) && r instanceof InputEvent && r.data && !i) {
+            const s = t.state.selection.from;
+            return r.preventDefault(), t.dispatch(t.state.tr.insertText(r.data || "", s)), !0;
+          }
+          return !1;
+        }
+      },
+      decorations(t) {
+        if (e.getState(t)) {
+          const s = t.selection.$from.pos, a = document.createElement("span"), o = Q.widget(s, a, {
+            side: -1
+          }), l = document.createElement("span"), c = Q.widget(s, l);
+          return setTimeout(() => {
+            a.contentEditable = "true", l.contentEditable = "true";
+          }), O.create(t.doc, [o, c]);
+        }
+        return O.empty;
       }
-      return DecorationSet.empty;
     }
-  }
-});
-const commonmarkPlugins = [
-  createPlugin(() => ({
-    prosePlugins: () => [inlineNodesCursorPlugin],
-    remarkPlugins: () => [links, filterHTMLPlugin]
+  });
+  return e;
+}, wt = [
+  De(() => ({
+    prosePlugins: () => [Lt()],
+    remarkPlugins: () => [Pe, 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
+], xt = ye.create([...ht, ...je]), Pt = ye.create([...wt, ...xt]), Wt = {
+  ToggleInlineCode: X,
+  ToggleItalic: Y,
+  ToggleLink: we,
+  ToggleBold: ee,
+  ModifyLink: Z,
+  ModifyImage: oe,
+  WrapInBlockquote: te,
+  WrapInBulletList: re,
+  WrapInOrderedList: ie,
+  TurnIntoCodeFence: ne,
+  TurnIntoHeading: C,
+  TurnIntoText: ue,
+  InsertHardbreak: se,
+  InsertHr: xe,
+  InsertImage: Ce,
+  SplitListItem: ae,
+  SinkListItem: le,
+  LiftListItem: ce
+};
+export {
+  ke as DowngradeHeading,
+  et as HardbreakFilterPluginKey,
+  se as InsertHardbreak,
+  xe as InsertHr,
+  Ce as InsertImage,
+  ce as LiftListItem,
+  oe as ModifyImage,
+  Z as ModifyLink,
+  le as SinkListItem,
+  ae as SplitListItem,
+  k as SupportedKeys,
+  ee as ToggleBold,
+  X as ToggleInlineCode,
+  Y as ToggleItalic,
+  we as ToggleLink,
+  ne as TurnIntoCodeFence,
+  C as TurnIntoHeading,
+  ue as TurnIntoText,
+  te as WrapInBlockquote,
+  re as WrapInBulletList,
+  ie as WrapInOrderedList,
+  Qe as backtickInputRegex,
+  ze as blockquote,
+  Ge as bulletList,
+  Ye as codeFence,
+  qe as codeInline,
+  Wt as commands,
+  Pt as commonmark,
+  xt as commonmarkNodes,
+  wt as commonmarkPlugins,
+  Ze as doc,
+  Ke as em,
+  tt as hardbreak,
+  at as heading,
+  rt as headingHashPluginKey,
+  z as headingIdPluginKey,
+  lt as hr,
+  it as image,
+  Ue as link,
+  mt as listItem,
+  je as marks,
+  ht as nodes,
+  ft as orderedList,
+  gt as paragraph,
+  Ve as strong,
+  pt as text,
+  Xe 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