@milkdown/preset-commonmark 7.4.0 → 7.5.0

package/lib/index.es.js

@@ -1,16 +1,16 @@
-import { $markAttr as V, $markSchema as U, $command as c, $inputRule as h, $useKeymap as f, $node as Qe, $nodeAttr as N, $nodeSchema as I, $ctx as Xe, $remark as D, $prose as _ } from "@milkdown/utils";
+import { $markAttr as U, $markSchema as G, $command as c, $inputRule as h, $useKeymap as f, $node as Qe, $nodeAttr as N, $nodeSchema as I, $ctx as Xe, $remark as D, $prose as _ } from "@milkdown/utils";
 import { remarkStringifyOptionsCtx as Ye, commandsCtx as u, editorViewCtx as At } from "@milkdown/core";
-import { toggleMark as z, setBlockType as K, wrapIn as J } from "@milkdown/prose/commands";
+import { toggleMark as J, setBlockType as K, wrapIn as Q } from "@milkdown/prose/commands";
 import { Fragment as wt } from "@milkdown/prose/model";
 import { expectDomTypeError as A } from "@milkdown/exception";
-import { textblockTypeInputRule as Ze, wrappingInputRule as Q, InputRule as et } from "@milkdown/prose/inputrules";
+import { textblockTypeInputRule as Ze, wrappingInputRule as X, InputRule as et } from "@milkdown/prose/inputrules";
 import Ht from "@sindresorhus/slugify";
-import { TextSelection as X, Selection as tt, PluginKey as E, Plugin as P } from "@milkdown/prose/state";
-import { markRule as G, findSelectedNodeOfType as Bt } from "@milkdown/prose";
+import { TextSelection as Y, Selection as tt, PluginKey as E, Plugin as P } from "@milkdown/prose/state";
+import { markRule as j, findSelectedNodeOfType as Bt } from "@milkdown/prose";
 import { sinkListItem as Rt, liftListItem as rt, splitListItem as vt } from "@milkdown/prose/schema-list";
 import { ReplaceStep as Ot, AddMarkStep as Tt } from "@milkdown/prose/transform";
 import { Decoration as ze, DecorationSet as Je } from "@milkdown/prose/view";
-import { visit as Y } from "unist-util-visit";
+import { visit as Z } from "unist-util-visit";
 import Kt from "remark-inline-links";
 function at(t, e) {
   var o;
@@ -31,12 +31,12 @@ function n(t, e) {
     }
   }), t;
 }
-const Z = V("emphasis");
-n(Z, {
+const ee = U("emphasis");
+n(ee, {
   displayName: "Attr<emphasis>",
   group: "Emphasis"
 });
-const R = U("emphasis", (t) => ({
+const R = G("emphasis", (t) => ({
   attrs: {
     marker: {
       default: t.get(Ye).emphasis || "*"
@@ -47,7 +47,7 @@ const R = U("emphasis", (t) => ({
     { tag: "em" },
     { style: "font-style", getAttrs: (e) => e === "italic" }
   ],
-  toDOM: (e) => ["em", t.get(Z.key)(e)],
+  toDOM: (e) => ["em", t.get(ee.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "emphasis",
     runner: (e, r, a) => {
@@ -71,12 +71,12 @@ n(R.ctx, {
   displayName: "MarkSchemaCtx<emphasis>",
   group: "Emphasis"
 });
-const ee = c("ToggleEmphasis", (t) => () => z(R.type(t)));
-n(ee, {
+const te = c("ToggleEmphasis", (t) => () => J(R.type(t)));
+n(te, {
   displayName: "Command<toggleEmphasisCommand>",
   group: "Emphasis"
 });
-const nt = h((t) => G(/(?:^|[^*])\*([^*]+)\*$/, R.type(t), {
+const nt = h((t) => j(/(?:^|[^*])\*([^*]+)\*$/, R.type(t), {
   getAttr: () => ({
     marker: "*"
   }),
@@ -86,7 +86,7 @@ n(nt, {
   displayName: "InputRule<emphasis>|Star",
   group: "Emphasis"
 });
-const ot = h((t) => G(/(?:^|[^_])_([^_]+)_$/, R.type(t), {
+const ot = h((t) => j(/(?:^|[^_])_([^_]+)_$/, R.type(t), {
   getAttr: () => ({
     marker: "_"
   }),
@@ -96,29 +96,29 @@ n(ot, {
   displayName: "InputRule<emphasis>|Underscore",
   group: "Emphasis"
 });
-const te = f("emphasisKeymap", {
+const re = f("emphasisKeymap", {
   ToggleEmphasis: {
     shortcuts: "Mod-i",
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(ee.key);
+      return () => e.call(te.key);
     }
   }
 });
-n(te.ctx, {
+n(re.ctx, {
   displayName: "KeymapCtx<emphasis>",
   group: "Emphasis"
 });
-n(te.shortcuts, {
+n(re.shortcuts, {
   displayName: "Keymap<emphasis>",
   group: "Emphasis"
 });
-const re = V("strong");
-n(re, {
+const ae = U("strong");
+n(ae, {
   displayName: "Attr<strong>",
   group: "Strong"
 });
-const $ = U("strong", (t) => ({
+const $ = G("strong", (t) => ({
   attrs: {
     marker: {
       default: t.get(Ye).strong || "*"
@@ -129,7 +129,7 @@ const $ = U("strong", (t) => ({
     { tag: "strong" },
     { style: "font-style", getAttrs: (e) => e === "bold" }
   ],
-  toDOM: (e) => ["strong", t.get(re.key)(e)],
+  toDOM: (e) => ["strong", t.get(ae.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "strong",
     runner: (e, r, a) => {
@@ -153,12 +153,12 @@ n($.ctx, {
   displayName: "MarkSchemaCtx<strong>",
   group: "Strong"
 });
-const ae = c("ToggleStrong", (t) => () => z($.type(t)));
-n(ae, {
+const ne = c("ToggleStrong", (t) => () => J($.type(t)));
+n(ne, {
   displayName: "Command<toggleStrongCommand>",
   group: "Strong"
 });
-const st = h((t) => G(/(?:\*\*|__)([^*_]+)(?:\*\*|__)$/, $.type(t), {
+const st = h((t) => j(/(?:\*\*|__)([^*_]+)(?:\*\*|__)$/, $.type(t), {
   getAttr: (e) => ({
     marker: e[0].startsWith("*") ? "*" : "_"
   })
@@ -167,34 +167,34 @@ n(st, {
   displayName: "InputRule<strong>",
   group: "Strong"
 });
-const ne = f("strongKeymap", {
+const oe = f("strongKeymap", {
   ToggleBold: {
     shortcuts: ["Mod-b"],
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(ae.key);
+      return () => e.call(ne.key);
     }
   }
 });
-n(ne.ctx, {
+n(oe.ctx, {
   displayName: "KeymapCtx<strong>",
   group: "Strong"
 });
-n(ne.shortcuts, {
+n(oe.shortcuts, {
   displayName: "Keymap<strong>",
   group: "Strong"
 });
-const oe = V("inlineCode");
-n(oe, {
+const se = U("inlineCode");
+n(se, {
   displayName: "Attr<inlineCode>",
   group: "InlineCode"
 });
-const x = U("inlineCode", (t) => ({
+const x = G("inlineCode", (t) => ({
   priority: 100,
   code: !0,
   inclusive: !1,
   parseDOM: [{ tag: "code" }],
-  toDOM: (e) => ["code", t.get(oe.key)(e)],
+  toDOM: (e) => ["code", t.get(se.key)(e)],
   parseMarkdown: {
     match: (e) => e.type === "inlineCode",
     runner: (e, r, a) => {
@@ -216,7 +216,7 @@ n(x.ctx, {
   displayName: "MarkSchemaCtx<inlineCode>",
   group: "InlineCode"
 });
-const se = c("ToggleInlineCode", (t) => () => (e, r) => {
+const le = c("ToggleInlineCode", (t) => () => (e, r) => {
   const { selection: a, tr: o } = e;
   if (a.empty)
     return !1;
@@ -225,38 +225,38 @@ const se = c("ToggleInlineCode", (t) => () => (e, r) => {
     o.removeMark(s, l, m);
   }), r == null || r(o.addMark(s, l, x.type(t).create())), !0);
 });
-n(se, {
+n(le, {
   displayName: "Command<toggleInlineCodeCommand>",
   group: "InlineCode"
 });
-const lt = h((t) => G(/(?:\`)([^\`]+)(?:\`)$/, x.type(t)));
+const lt = h((t) => j(/(?:\`)([^\`]+)(?:\`)$/, x.type(t)));
 n(lt, {
   displayName: "InputRule<inlineCodeInputRule>",
   group: "InlineCode"
 });
-const le = f("inlineCodeKeymap", {
+const ie = f("inlineCodeKeymap", {
   ToggleInlineCode: {
     shortcuts: "Mod-e",
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(se.key);
+      return () => e.call(le.key);
     }
   }
 });
-n(le.ctx, {
+n(ie.ctx, {
   displayName: "KeymapCtx<inlineCode>",
   group: "InlineCode"
 });
-n(le.shortcuts, {
+n(ie.shortcuts, {
   displayName: "Keymap<inlineCode>",
   group: "InlineCode"
 });
-const ie = V("link");
-n(ie, {
+const de = U("link");
+n(de, {
   displayName: "Attr<link>",
   group: "Link"
 });
-const B = U("link", (t) => ({
+const B = G("link", (t) => ({
   attrs: {
     href: {},
     title: { default: null }
@@ -271,7 +271,7 @@ const B = U("link", (t) => ({
       }
     }
   ],
-  toDOM: (e) => ["a", { ...t.get(ie.key)(e), ...e.attrs }],
+  toDOM: (e) => ["a", { ...t.get(de.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: (e) => e.type === "link",
     runner: (e, r, a) => {
@@ -293,7 +293,7 @@ n(B.mark, {
   displayName: "MarkSchema<link>",
   group: "Link"
 });
-const it = c("ToggleLink", (t) => (e = {}) => z(B.type(t), e));
+const it = c("ToggleLink", (t) => (e = {}) => J(B.type(t), e));
 n(it, {
   displayName: "Command<toggleLinkCommand>",
   group: "Link"
@@ -313,7 +313,7 @@ const dt = c("UpdateLink", (t) => (e = {}) => (r, a) => {
     return !1;
   const p = s, y = s + o.nodeSize, { tr: g } = r, C = B.type(t).create({ ...m.attrs, ...e });
   return C ? (a(
-    g.removeMark(p, y, m).addMark(p, y, C).setSelection(new X(g.selection.$anchor)).scrollIntoView()
+    g.removeMark(p, y, m).addMark(p, y, C).setSelection(new Y(g.selection.$anchor)).scrollIntoView()
   ), !0) : !1;
 });
 n(dt, {
@@ -339,8 +339,8 @@ n(mt, {
   displayName: "NodeSchema<doc>",
   group: "Doc"
 });
-const de = N("paragraph");
-n(de, {
+const me = N("paragraph");
+n(me, {
   displayName: "Attr<paragraph>",
   group: "Paragraph"
 });
@@ -348,7 +348,7 @@ const w = I("paragraph", (t) => ({
   content: "inline*",
   group: "block",
   parseDOM: [{ tag: "p" }],
-  toDOM: (e) => ["p", t.get(de.key)(e), 0],
+  toDOM: (e) => ["p", t.get(me.key)(e), 0],
   parseMarkdown: {
     match: (e) => e.type === "paragraph",
     runner: (e, r, a) => {
@@ -370,25 +370,25 @@ n(w.ctx, {
   displayName: "NodeSchemaCtx<paragraph>",
   group: "Paragraph"
 });
-const me = c("TurnIntoText", (t) => () => K(w.type(t)));
-n(me, {
+const pe = c("TurnIntoText", (t) => () => K(w.type(t)));
+n(pe, {
   displayName: "Command<turnIntoTextCommand>",
   group: "Paragraph"
 });
-const pe = f("paragraphKeymap", {
+const ce = f("paragraphKeymap", {
   TurnIntoText: {
     shortcuts: "Mod-Alt-0",
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(me.key);
+      return () => e.call(pe.key);
     }
   }
 });
-n(pe.ctx, {
+n(ce.ctx, {
   displayName: "KeymapCtx<paragraph>",
   group: "Paragraph"
 });
-n(pe.shortcuts, {
+n(ce.shortcuts, {
   displayName: "Keymap<paragraph>",
   group: "Paragraph"
 });
@@ -396,18 +396,18 @@ const Dt = Array(6).fill(0).map((t, e) => e + 1);
 function _t(t) {
   return Ht(t.textContent);
 }
-const j = Xe(_t, "headingIdGenerator");
-n(j, {
+const z = Xe(_t, "headingIdGenerator");
+n(z, {
   displayName: "Ctx<HeadingIdGenerator>",
   group: "Heading"
 });
-const ce = N("heading");
-n(ce, {
+const ue = N("heading");
+n(ue, {
   displayName: "Attr<heading>",
   group: "Heading"
 });
 const H = I("heading", (t) => {
-  const e = t.get(j.key);
+  const e = t.get(z.key);
   return {
     content: "inline*",
     group: "block",
@@ -431,7 +431,7 @@ const H = I("heading", (t) => {
     toDOM: (r) => [
       `h${r.attrs.level}`,
       {
-        ...t.get(ce.key)(r),
+        ...t.get(ue.key)(r),
         id: r.attrs.id || e(r)
       },
       0
@@ -477,7 +477,7 @@ n(L, {
   displayName: "Command<wrapInHeadingCommand>",
   group: "Heading"
 });
-const ue = c("DowngradeHeading", (t) => () => (e, r, a) => {
+const ge = c("DowngradeHeading", (t) => () => (e, r, a) => {
   const { $from: o } = e.selection, s = o.node();
   if (s.type !== H.type(t) || !e.selection.empty || o.parentOffset !== 0)
     return !1;
@@ -489,11 +489,11 @@ const ue = c("DowngradeHeading", (t) => () => (e, r, a) => {
     })
   ), !0) : K(w.type(t))(e, r, a);
 });
-n(ue, {
+n(ge, {
   displayName: "Command<downgradeHeadingCommand>",
   group: "Heading"
 });
-const ge = f("headingKeymap", {
+const ke = f("headingKeymap", {
   TurnIntoH1: {
     shortcuts: "Mod-Alt-1",
     command: (t) => {
@@ -540,20 +540,20 @@ const ge = f("headingKeymap", {
     shortcuts: ["Delete", "Backspace"],
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(ue.key);
+      return () => e.call(ge.key);
     }
   }
 });
-n(ge.ctx, {
+n(ke.ctx, {
   displayName: "KeymapCtx<heading>",
   group: "Heading"
 });
-n(ge.shortcuts, {
+n(ke.shortcuts, {
   displayName: "Keymap<heading>",
   group: "Heading"
 });
-const ke = N("blockquote");
-n(ke, {
+const ye = N("blockquote");
+n(ye, {
   displayName: "Attr<blockquote>",
   group: "Blockquote"
 });
@@ -562,7 +562,7 @@ const q = I("blockquote", (t) => ({
   group: "block",
   defining: !0,
   parseDOM: [{ tag: "blockquote" }],
-  toDOM: (e) => ["blockquote", t.get(ke.key)(e), 0],
+  toDOM: (e) => ["blockquote", t.get(ye.key)(e), 0],
   parseMarkdown: {
     match: ({ type: e }) => e === "blockquote",
     runner: (e, r, a) => {
@@ -584,38 +584,38 @@ n(q.ctx, {
   displayName: "NodeSchemaCtx<blockquote>",
   group: "Blockquote"
 });
-const ct = h((t) => Q(/^\s*>\s$/, q.type(t)));
+const ct = h((t) => X(/^\s*>\s$/, q.type(t)));
 n(ct, {
   displayName: "InputRule<wrapInBlockquoteInputRule>",
   group: "Blockquote"
 });
-const ye = c("WrapInBlockquote", (t) => () => J(q.type(t)));
-n(ye, {
+const he = c("WrapInBlockquote", (t) => () => Q(q.type(t)));
+n(he, {
   displayName: "Command<wrapInBlockquoteCommand>",
   group: "Blockquote"
 });
-const he = f("blockquoteKeymap", {
+const fe = f("blockquoteKeymap", {
   WrapInBlockquote: {
     shortcuts: "Mod-Shift-b",
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(ye.key);
+      return () => e.call(he.key);
     }
   }
 });
-n(he.ctx, {
+n(fe.ctx, {
   displayName: "KeymapCtx<blockquote>",
   group: "Blockquote"
 });
-n(he.shortcuts, {
+n(fe.shortcuts, {
   displayName: "Keymap<blockquote>",
   group: "Blockquote"
 });
-const fe = N("codeBlock", () => ({
+const Ne = N("codeBlock", () => ({
   pre: {},
   code: {}
 }));
-n(fe, {
+n(Ne, {
   displayName: "Attr<codeBlock>",
   group: "CodeBlock"
 });
@@ -642,7 +642,7 @@ const W = I("code_block", (t) => ({
     }
   ],
   toDOM: (e) => {
-    const r = t.get(fe.key)(e);
+    const r = t.get(Ne.key)(e);
     return [
       "pre",
       {
@@ -687,8 +687,8 @@ n(ut, {
   displayName: "InputRule<createCodeBlockInputRule>",
   group: "CodeBlock"
 });
-const Ne = c("CreateCodeBlock", (t) => (e = "") => K(W.type(t), { language: e }));
-n(Ne, {
+const Ie = c("CreateCodeBlock", (t) => (e = "") => K(W.type(t), { language: e }));
+n(Ie, {
   displayName: "Command<createCodeBlockCommand>",
   group: "CodeBlock"
 });
@@ -697,25 +697,25 @@ n(Et, {
   displayName: "Command<updateCodeBlockLanguageCommand>",
   group: "CodeBlock"
 });
-const Ie = f("codeBlockKeymap", {
+const Ce = f("codeBlockKeymap", {
   CreateCodeBlock: {
     shortcuts: "Mod-Alt-c",
     command: (t) => {
       const e = t.get(u);
-      return () => e.call(Ne.key);
+      return () => e.call(Ie.key);
     }
   }
 });
-n(Ie.ctx, {
+n(Ce.ctx, {
   displayName: "KeymapCtx<codeBlock>",
   group: "CodeBlock"
 });
-n(Ie.shortcuts, {
+n(Ce.shortcuts, {
   displayName: "Keymap<codeBlock>",
   group: "CodeBlock"
 });
-const Ce = N("image");
-n(Ce, {
+const Me = N("image");
+n(Me, {
   displayName: "Attr<image>",
   group: "Image"
 });
@@ -747,7 +747,7 @@ const v = I("image", (t) => ({
       }
     }
   ],
-  toDOM: (e) => ["img", { ...t.get(Ce.key)(e), ...e.attrs }],
+  toDOM: (e) => ["img", { ...t.get(Me.key)(e), ...e.attrs }],
   parseMarkdown: {
     match: ({ type: e }) => e === "image",
     runner: (e, r, a) => {
@@ -810,10 +810,11 @@ n(Pt, {
   displayName: "InputRule<insertImageInputRule>",
   group: "Image"
 });
-const Me = N("hardbreak", (t) => ({
+const V = N("hardbreak", (t) => ({
+  "data-type": "hardbreak",
   "data-is-inline": t.attrs.isInline
 }));
-n(Me, {
+n(V, {
   displayName: "Attr<hardbreak>",
   group: "Hardbreak"
 });
@@ -826,8 +827,8 @@ const S = I("hardbreak", (t) => ({
     }
   },
   selectable: !1,
-  parseDOM: [{ tag: "br" }],
-  toDOM: (e) => ["br", t.get(Me.key)(e)],
+  parseDOM: [{ tag: "br" }, { tag: 'span[data-type="hardbreak"]', getAttrs: () => ({ isInline: !0 }) }],
+  toDOM: (e) => e.attrs.isInline ? ["span", t.get(V.key)(e), " "] : ["br", t.get(V.key)(e)],
   parseMarkdown: {
     match: ({ type: e }) => e === "break",
     runner: (e, r, a) => {
@@ -856,7 +857,7 @@ n(S.ctx, {
 const be = c("InsertHardbreak", (t) => () => (e, r) => {
   var s;
   const { selection: a, tr: o } = e;
-  if (!(a instanceof X))
+  if (!(a instanceof Y))
     return !1;
   if (a.empty) {
     const l = a.$from.node();
@@ -997,12 +998,12 @@ n(O.ctx, {
   displayName: "NodeSchemaCtx<bulletList>",
   group: "BulletList"
 });
-const ft = h((t) => Q(/^\s*([-+*])\s$/, O.type(t)));
+const ft = h((t) => X(/^\s*([-+*])\s$/, O.type(t)));
 n(ft, {
   displayName: "InputRule<wrapInBulletListInputRule>",
   group: "BulletList"
 });
-const Ae = c("WrapInBulletList", (t) => () => J(O.type(t)));
+const Ae = c("WrapInBulletList", (t) => () => Q(O.type(t)));
 n(Ae, {
   displayName: "Command<wrapInBulletListCommand>",
   group: "BulletList"
@@ -1084,7 +1085,7 @@ n(T.ctx, {
   displayName: "NodeSchemaCtx<orderedList>",
   group: "OrderedList"
 });
-const Nt = h((t) => Q(
+const Nt = h((t) => X(
   /^\s*(\d+)\.\s$/,
   T.type(t),
   (e) => ({ order: Number(e[1]) }),
@@ -1094,7 +1095,7 @@ n(Nt, {
   displayName: "InputRule<wrapInOrderedListInputRule>",
   group: "OrderedList"
 });
-const Be = c("WrapInOrderedList", (t) => () => J(T.type(t)));
+const Be = c("WrapInOrderedList", (t) => () => Q(T.type(t)));
 n(Be, {
   displayName: "Command<wrapInOrderedListCommand>",
   group: "OrderedList"
@@ -1200,7 +1201,7 @@ n(Ke, {
 function $t(t) {
   return (e, r, a) => {
     const { selection: o } = e;
-    if (!(o instanceof X))
+    if (!(o instanceof Y))
       return !1;
     const { empty: s, $from: l } = o;
     if (!s || l.parentOffset !== 0)
@@ -1322,20 +1323,20 @@ n(Pe.ctx, {
 });
 const qt = [
   mt,
-  de,
+  me,
   w,
-  j,
-  ce,
+  z,
+  ue,
   H,
-  Me,
+  V,
   S,
-  ke,
+  ye,
   q,
-  fe,
+  Ne,
   W,
   xe,
   F,
-  Ce,
+  Me,
   v,
   Se,
   O,
@@ -1343,13 +1344,13 @@ const qt = [
   T,
   ve,
   M,
-  Z,
+  ee,
   R,
-  re,
+  ae,
   $,
-  oe,
+  se,
   x,
-  ie,
+  de,
   B,
   Ee,
   Pe,
@@ -1367,11 +1368,11 @@ const qt = [
   lt,
   st
 ], Vt = [
-  me,
-  ye,
+  pe,
+  he,
   L,
-  ue,
-  Ne,
+  ge,
+  Ie,
   be,
   ht,
   gt,
@@ -1382,25 +1383,25 @@ const qt = [
   Ke,
   Te,
   De,
-  ee,
-  se,
-  ae,
+  te,
+  le,
+  ne,
   it,
   dt
 ], Ut = [
-  he,
-  Ie,
+  fe,
+  Ce,
   Le,
-  ge,
+  ke,
   _e,
   Re,
   we,
-  pe,
-  te,
-  le,
-  ne
+  ce,
+  re,
+  ie,
+  oe
 ].flat(), $e = D("remarkAddOrderInList", () => () => (t) => {
-  Y(t, "list", (e) => {
+  Z(t, "list", (e) => {
     if (e.ordered) {
       const r = e.start ?? 1;
       e.children.forEach((a, o) => {
@@ -1419,7 +1420,7 @@ n($e.options, {
 });
 const qe = D("remarkLineBreak", () => () => (t) => {
   const e = /[\t ]*(?:\r?\n|\r)/g;
-  Y(t, "text", (r, a, o) => {
+  Z(t, "text", (r, a, o) => {
     if (!r.value || typeof r.value != "string")
       return;
     const s = [];
@@ -1486,7 +1487,7 @@ n(Fe.options, {
 });
 const Ve = D("remarkMarker", () => () => (t, e) => {
   const r = (a) => e.value.charAt(a.position.start.offset);
-  Y(t, (a) => ["strong", "emphasis"].includes(a.type), (a) => {
+  Z(t, (a) => ["strong", "emphasis"].includes(a.type), (a) => {
     a.marker = r(a);
   });
 });
@@ -1607,7 +1608,7 @@ const Lt = _((t) => {
   const e = new E("MILKDOWN_HEADING_ID"), r = (a) => {
     if (a.composing)
       return;
-    const o = t.get(j.key), s = a.state.tr.setMeta("addToHistory", !1);
+    const o = t.get(z.key), s = a.state.tr.setMeta("addToHistory", !1);
     let l = !1;
     a.state.doc.descendants((i, d) => {
       if (i.type === H.type(t)) {
@@ -1624,8 +1625,8 @@ const Lt = _((t) => {
   return new P({
     key: e,
     view: (a) => (r(a), {
-      update: (o) => {
-        r(o);
+      update: (o, s) => {
+        o.state.doc.eq(s.doc) || r(o);
       }
     })
   });
@@ -1688,45 +1689,45 @@ const Jt = [
   xt
 ].flat(), cr = [qt, Wt, Ft, Vt, Ut, Jt].flat();
 export {
-  ke as blockquoteAttr,
-  he as blockquoteKeymap,
+  ye as blockquoteAttr,
+  fe as blockquoteKeymap,
   q as blockquoteSchema,
   Se as bulletListAttr,
   we as bulletListKeymap,
   O as bulletListSchema,
-  fe as codeBlockAttr,
-  Ie as codeBlockKeymap,
+  Ne as codeBlockAttr,
+  Ce as codeBlockKeymap,
   W as codeBlockSchema,
   Vt as commands,
   cr as commonmark,
-  Ne as createCodeBlockCommand,
+  Ie as createCodeBlockCommand,
   ut as createCodeBlockInputRule,
   mt as docSchema,
-  ue as downgradeHeadingCommand,
-  Z as emphasisAttr,
-  te as emphasisKeymap,
+  ge as downgradeHeadingCommand,
+  ee as emphasisAttr,
+  re as emphasisKeymap,
   R as emphasisSchema,
   nt as emphasisStarInputRule,
   ot as emphasisUnderscoreInputRule,
-  Me as hardbreakAttr,
+  V as hardbreakAttr,
   Mt as hardbreakClearMarkPlugin,
   Ue as hardbreakFilterNodes,
   bt as hardbreakFilterPlugin,
   Le as hardbreakKeymap,
   S as hardbreakSchema,
-  ce as headingAttr,
-  j as headingIdGenerator,
-  ge as headingKeymap,
+  ue as headingAttr,
+  z as headingIdGenerator,
+  ke as headingKeymap,
   H as headingSchema,
   xe as hrAttr,
   F as hrSchema,
   Ee as htmlAttr,
   Pe as htmlSchema,
-  Ce as imageAttr,
+  Me as imageAttr,
   v as imageSchema,
-  oe as inlineCodeAttr,
+  se as inlineCodeAttr,
   lt as inlineCodeInputRule,
-  le as inlineCodeKeymap,
+  ie as inlineCodeKeymap,
   x as inlineCodeSchema,
   Ct as inlineNodesCursorPlugin,
   Wt as inputRules,
@@ -1738,7 +1739,7 @@ export {
   Ut as keymap,
   De as liftFirstListItemCommand,
   Te as liftListItemCommand,
-  ie as linkAttr,
+  de as linkAttr,
   B as linkSchema,
   ve as listItemAttr,
   _e as listItemKeymap,
@@ -1747,8 +1748,8 @@ export {
   He as orderedListAttr,
   Re as orderedListKeymap,
   T as orderedListSchema,
-  de as paragraphAttr,
-  pe as paragraphKeymap,
+  me as paragraphAttr,
+  ce as paragraphKeymap,
   w as paragraphSchema,
   Jt as plugins,
   $e as remarkAddOrderInListPlugin,
@@ -1759,22 +1760,22 @@ export {
   qt as schema,
   Oe as sinkListItemCommand,
   Ke as splitListItemCommand,
-  re as strongAttr,
+  ae as strongAttr,
   st as strongInputRule,
-  ne as strongKeymap,
+  oe as strongKeymap,
   $ as strongSchema,
   Lt as syncHeadingIdPlugin,
   xt as syncListOrderPlugin,
   It as textSchema,
-  ee as toggleEmphasisCommand,
-  se as toggleInlineCodeCommand,
+  te as toggleEmphasisCommand,
+  le as toggleInlineCodeCommand,
   it as toggleLinkCommand,
-  ae as toggleStrongCommand,
-  me as turnIntoTextCommand,
+  ne as toggleStrongCommand,
+  pe as turnIntoTextCommand,
   Et as updateCodeBlockLanguageCommand,
   kt as updateImageCommand,
   dt as updateLinkCommand,
-  ye as wrapInBlockquoteCommand,
+  he as wrapInBlockquoteCommand,
   ct as wrapInBlockquoteInputRule,
   Ae as wrapInBulletListCommand,
   ft as wrapInBulletListInputRule,