import { markdownLanguage } from "@codemirror/lang-markdown";import { syntaxTree } from "@codemirror/language";import type { SyntaxNode } from "@lezer/common";import {  EditorSelection,  type ChangeSpec,  type EditorState,  type Extension,  type SelectionRange,} from "@codemirror/state";import { type Command, type KeyBinding, keymap } from "@codemirror/view"; function isMarkdownContext(state: EditorState, pos: number): boolean {  return markdownLanguage.isActiveAt(state, pos, -1) || markdownLanguage.isActiveAt(state, pos, 1);} /** * Among syntax nodes that match `predicate` and overlap the range `[from, to]`, * return the one that spans the selection most broadly (smallest `from`, largest * `to`). * * We need the **outermost** match so toggling matches user intent in nested * inline markup (e.g. `***bold italic***`: an inner `StrongEmphasis` sits inside * an outer `Emphasis`). If the selection lies inside both, stripping the * innermost delimiter pair first would leave broken markup; preferring the * widest covering node removes the whole construct the user is effectively * “inside.” Scanning every offset in `[from, to]` covers selections that start * or end between Lezer tokens so we still find a node that fully wraps the * selection. */function findOutermostCoveringNode(  state: EditorState,  from: number,  to: number,  predicate: (n: SyntaxNode) => boolean,): SyntaxNode | null {  const tree = syntaxTree(state);  let found: SyntaxNode | null = null;  for (let pos = from; pos <= to; pos++) {    let node: SyntaxNode | null = tree.resolveInner(pos, 1);    while (node) {      if (node.to < from || node.from > to) break;      if (predicate(node)) {        if (!found || node.from < found.from || node.to > found.to) found = node;      }      node = node.parent;    }  }  return found;} /** * If the selection is already wrapped by a matching node (e.g. `StrongEmphasis` * for `**…**`), remove that wrapper and leave the inner text selected. * Otherwise wrap the selection with `open`/`close` and select the former * selection bounds inside the new delimiters. */function toggleInlineMarkup(  state: EditorState,  range: SelectionRange,  nodeName: string,  open: string,  close: string,): { range: SelectionRange; changes: ChangeSpec } | null {  if (!isMarkdownContext(state, range.from)) return null;  const { from, to } = range;  const covering = findOutermostCoveringNode(state, from, to, (n) => n.name === nodeName);  if (covering && covering.from <= from && covering.to >= to) {    const innerFrom = covering.from + open.length;    const innerTo = covering.to - close.length;    if (innerFrom > innerTo) return null;    const innerLen = innerTo - innerFrom;    return {      changes: {        from: covering.from,        to: covering.to,        insert: state.sliceDoc(innerFrom, innerTo),      },      range: EditorSelection.range(covering.from, covering.from + innerLen),    };  }  const text = state.sliceDoc(from, to);  const innerLen = text.length;  return {    changes: { from, to, insert: open + text + close },    range: EditorSelection.range(from + open.length, from + open.length + innerLen),  };} /** * Builds a `Command` that toggles one kind of inline markup for every selection * range. We precompute each range’s `{ changes, range }` from the **initial** * document, then feed them into `EditorState.changeByRange` in order. That API * merges all edits and remaps selections in one transaction; using a counter * closure ties the *i*-th spec to the *i*-th range without recomputing from a * half-updated document (which would break multiple cursors). */function makeToggleInlineCommand(nodeName: string, open: string, close: string): Command {  return (view) => {    const { state } = view;    const specs: { range: SelectionRange; changes: ChangeSpec }[] = [];    for (const range of state.selection.ranges) {      if (!isMarkdownContext(state, range.from)) return false;      const spec = toggleInlineMarkup(state, range, nodeName, open, close);      if (!spec) return false;      specs.push(spec);    }    let i = 0;    view.dispatch({      ...state.changeByRange(() => specs[i++] as { range: SelectionRange; changes: ChangeSpec }),      scrollIntoView: true,      userEvent: "input",    });    return true;  };} const toggleStrongEmphasis = makeToggleInlineCommand("StrongEmphasis", "**", "**");const toggleEmphasis = makeToggleInlineCommand("Emphasis", "_", "_");const toggleStrikethrough = makeToggleInlineCommand("Strikethrough", "~~", "~~"); /** * Wraps the selection as a Markdown link: selected text becomes the **label** * in `[label]()`. Cursor is placed inside the empty parentheses so the URL can * be typed next. With no selection, inserts `[]()` and focuses the label * brackets first. */const insertLink: Command = (view) => {  const { state } = view;  for (const range of state.selection.ranges) {    if (!isMarkdownContext(state, range.from)) return false;  }  view.dispatch({    ...state.changeByRange((range) => {      const label = state.sliceDoc(range.from, range.to);      const insert = range.empty ? `[]()` : `[${label}]()`;      // Empty: cursor after `[` to type the label. Non-empty: cursor after `](`      // so the URL is typed inside `()`.      const head = range.empty ? range.from + 1 : range.from + 1 + label.length + 2;      return {        changes: { from: range.from, to: range.to, insert },        range: EditorSelection.cursor(head),      };    }),    scrollIntoView: true,    userEvent: "input",  });  return true;}; /** * Key bindings for common rich-text shortcuts in Markdown (Mod = Ctrl on * Windows/Linux, Cmd on macOS). Placed ahead of CodeMirror defaults so * **Mod-i** applies emphasis instead of `selectParentSyntax`. */export const prosemarkMarkdownFormattingKeymap: readonly KeyBinding[] = [  { key: "Mod-b", run: toggleStrongEmphasis, preventDefault: true },  { key: "Mod-i", run: toggleEmphasis, preventDefault: true },  { key: "Mod-k", run: insertLink, preventDefault: true },  { key: "Mod-Shift-x", run: toggleStrikethrough, preventDefault: true },]; export function prosemarkMarkdownFormattingKeymapExtension(): Extension {  return keymap.of([...prosemarkMarkdownFormattingKeymap]);}