@type32/codemirror-rich-obsidian-editor 0.0.3

package/dist/runtime/editor/lezer-parsers/lezerInternalLinkParser.js

@@ -0,0 +1,110 @@
+import { Tag } from "@lezer/highlight";
+export const lezerHighlightEmbed = Tag.define("Embed");
+export const lezerHighlightEmbedMark = Tag.define("EmbedMark");
+export const lezerHighlightInternalLink = Tag.define("InternalLink");
+export const lezerHighlightInternalMark = Tag.define("InternalMark", lezerHighlightInternalLink);
+export const lezerHighlightInternalPath = Tag.define("InternalPath", lezerHighlightInternalLink);
+export const lezerHighlightInternalSubpath = Tag.define("InternalSubpath", lezerHighlightInternalLink);
+export const lezerHighlightInternalDisplay = Tag.define("InternalDisplay", lezerHighlightInternalLink);
+export const lezerInternalLinkParser = {
+  defineNodes: [
+    { name: "Embed", style: lezerHighlightEmbed },
+    { name: "EmbedMark", style: lezerHighlightEmbedMark },
+    // For "!"
+    { name: "InternalLink", style: lezerHighlightInternalLink },
+    // For [[link]] itself
+    { name: "InternalMark", style: lezerHighlightInternalMark },
+    // For "[[" and "]]" and "|"
+    { name: "InternalPath", style: lezerHighlightInternalPath },
+    // For "link" part
+    { name: "InternalSubpath", style: lezerHighlightInternalSubpath },
+    // For "#subpath" part
+    { name: "InternalDisplay", style: lezerHighlightInternalDisplay }
+    // For "alias" part
+  ],
+  parseInline: [
+    {
+      name: "InternalLink",
+      parse(cx, _, pos) {
+        const el = parseInternalLink(cx, pos);
+        if (el) {
+          return cx.addElement(el);
+        }
+        return -1;
+      },
+      before: "Link"
+    },
+    {
+      name: "Embed",
+      parse(cx, next, pos) {
+        if (next != 33) {
+          return -1;
+        }
+        const linkElement = parseInternalLink(cx, pos + 1);
+        if (linkElement) {
+          const embedMark = cx.elt("EmbedMark", pos, pos + 1);
+          return cx.addElement(
+            cx.elt("Embed", pos, linkElement.to, [embedMark, linkElement])
+          );
+        }
+        return -1;
+      },
+      before: "Image"
+      // Parse before standard images ![]()
+    }
+  ]
+};
+function parseInternalLink(cx, pos) {
+  if (cx.char(pos) != 91 || cx.char(pos + 1) != 91) {
+    return null;
+  }
+  let endMarkerPos = -1;
+  for (let i = pos + 2; i < cx.end - 1; i++) {
+    if (cx.char(i) === 93 && cx.char(i + 1) === 93) {
+      if (i === pos + 2) return null;
+      endMarkerPos = i;
+      break;
+    }
+    if (cx.char(i) === 91 && cx.char(i + 1) === 91) {
+      return null;
+    }
+  }
+  if (endMarkerPos === -1) return null;
+  const children = [];
+  children.push(cx.elt("InternalMark", pos, pos + 2));
+  let currentPos = pos + 2;
+  let pathEnd = endMarkerPos;
+  const pipePos = cx.slice(currentPos, endMarkerPos).indexOf("|");
+  if (pipePos !== -1) {
+    pathEnd = currentPos + pipePos;
+  }
+  const pathText = cx.slice(currentPos, pathEnd).trim();
+  if (pathText.length > 0) {
+    const hashPos = pathText.indexOf("#");
+    if (hashPos !== -1) {
+      const mainPath = pathText.substring(0, hashPos);
+      const subPath = pathText.substring(hashPos);
+      if (mainPath.length > 0) {
+        children.push(cx.elt("InternalPath", currentPos, currentPos + mainPath.length));
+      }
+      if (subPath.length > 0) {
+        children.push(cx.elt("InternalSubpath", currentPos + mainPath.length, currentPos + pathText.length));
+      }
+    } else {
+      children.push(cx.elt("InternalPath", currentPos, currentPos + pathText.length));
+    }
+  }
+  currentPos = pathEnd;
+  if (pipePos !== -1 && currentPos < endMarkerPos) {
+    children.push(cx.elt("InternalMark", currentPos, currentPos + 1));
+    currentPos += 1;
+    const displayText = cx.slice(currentPos, endMarkerPos).trim();
+    if (displayText.length > 0) {
+      children.push(cx.elt("InternalDisplay", currentPos, currentPos + displayText.length));
+    }
+    currentPos += displayText.length;
+  }
+  children.push(cx.elt("InternalMark", endMarkerPos, endMarkerPos + 2));
+  if (children.length <= 2) return null;
+  return cx.elt("InternalLink", pos, endMarkerPos + 2, children);
+}

package/dist/runtime/editor/lezer-parsers/lezerLatexParser.d.ts

@@ -0,0 +1,7 @@
+import type { MarkdownConfig } from '@lezer/markdown';
+import { Tag } from "@lezer/highlight";
+export declare const lezerHighlightLatex: Tag;
+export declare const lezerHighlightLatexBlock: Tag;
+export declare const lezerHighlightLatexInline: Tag;
+export declare const lezerHighlightLatexMarker: Tag;
+export declare const lezerLatexParser: MarkdownConfig;

package/dist/runtime/editor/lezer-parsers/lezerLatexParser.js

@@ -0,0 +1,75 @@
+import { Tag } from "@lezer/highlight";
+const TexDelim = { resolve: "TexInline", mark: "TexMarker" };
+export const lezerHighlightLatex = Tag.define("Tex");
+export const lezerHighlightLatexBlock = Tag.define("TexBlock");
+export const lezerHighlightLatexInline = Tag.define("TexInline");
+export const lezerHighlightLatexMarker = Tag.define("TexMarker");
+export const lezerLatexParser = {
+  defineNodes: [
+    { name: "Tex", style: lezerHighlightLatex },
+    { name: "TexBlock", style: lezerHighlightLatexBlock },
+    { name: "TexInline", style: lezerHighlightLatexInline },
+    { name: "TexMarker", style: lezerHighlightLatexMarker }
+  ],
+  parseBlock: [
+    {
+      name: "TexBlock",
+      endLeaf: (_, line) => line.text.slice(line.pos, line.pos + 2) == "$$",
+      // Check for "$$" at line start
+      parse(cx, line) {
+        if (line.text.slice(line.pos, line.pos + 2) != "$$") {
+          return false;
+        }
+        const start = cx.lineStart + line.pos;
+        const markers = [cx.elt("TexMarker", start, start + 2)];
+        const regex = /(^|[^\\])\$\$/;
+        let remaining = line.text.slice(line.pos + 2);
+        let startOffset = 2;
+        let match;
+        while (!(match = regex.exec(remaining)) && cx.nextLine()) {
+          remaining = line.text;
+          startOffset = 0;
+        }
+        let end;
+        if (match) {
+          const lineEnd = match.index + match[0].length + startOffset;
+          end = cx.lineStart + lineEnd;
+          markers.push(cx.elt("TexMarker", end - 2, end));
+          if (lineEnd == line.text.length || /^\s*$/.test(line.text.slice(lineEnd))) {
+            cx.nextLine();
+          } else {
+            line.pos = line.skipSpace(lineEnd);
+          }
+        } else {
+          end = cx.lineStart + line.text.length;
+        }
+        cx.addElement(cx.elt("TexBlock", start, end, markers));
+        return true;
+      },
+      before: "FencedCode"
+      // Run before fenced code blocks
+    }
+  ],
+  parseInline: [
+    {
+      name: "TexInline",
+      parse(cx, next, pos) {
+        if (next != 36) {
+          return -1;
+        }
+        if (cx.char(pos + 1) == 36) return -1;
+        const before = cx.slice(pos - 1, pos);
+        const after = cx.slice(pos + 1, pos + 2);
+        let canOpen = !/\s/.test(after) && after !== "$";
+        let canClose = !/\s/.test(before) && before !== "$";
+        if (cx.char(pos - 1) === 32 && cx.char(pos + 1) === 32) {
+          canOpen = false;
+          canClose = false;
+        }
+        return cx.addDelimiter(TexDelim, pos, pos + 1, canOpen, canClose);
+      },
+      before: "Emphasis"
+      // Or "Escape"
+    }
+  ]
+};

package/dist/runtime/editor/lezer-parsers/lezerYamlFrontmatterParser.d.ts

@@ -0,0 +1,13 @@
+import type { Input } from "@lezer/common";
+import type { MarkdownConfig } from '@lezer/markdown';
+import { Tag } from "@lezer/highlight";
+export declare const lezerHighlightYamlFrontmatter: Tag;
+export declare const lezerHighlightYamlMarker: Tag;
+export declare const lezerHighlightYamlContent: Tag;
+declare module "@lezer/markdown" {
+    interface BlockContext {
+        readonly input: Input;
+        checkedYaml?: boolean | null;
+    }
+}
+export declare const lezerYamlFrontmatterParser: MarkdownConfig;

package/dist/runtime/editor/lezer-parsers/lezerYamlFrontmatterParser.js

@@ -0,0 +1,55 @@
+import { Tag } from "@lezer/highlight";
+export const lezerHighlightYamlFrontmatter = Tag.define("YAMLFrontMatter");
+export const lezerHighlightYamlMarker = Tag.define("YAMLMarker", lezerHighlightYamlFrontmatter);
+export const lezerHighlightYamlContent = Tag.define("YAMLContent", lezerHighlightYamlFrontmatter);
+export const lezerYamlFrontmatterParser = {
+  defineNodes: [
+    { name: "YAMLFrontMatter", style: lezerHighlightYamlFrontmatter },
+    { name: "YAMLMarker", style: lezerHighlightYamlMarker },
+    { name: "YAMLContent", style: lezerHighlightYamlContent }
+  ],
+  parseBlock: [
+    {
+      name: "YAMLFrontMatter",
+      parse(cx, line) {
+        if (!Object.prototype.hasOwnProperty.call(cx, "checkedYaml")) {
+          cx.checkedYaml = null;
+        }
+        if (cx.checkedYaml || cx.lineStart !== 0) {
+          return false;
+        }
+        cx.checkedYaml = true;
+        if (line.text.slice(line.pos) !== "---") {
+          return false;
+        }
+        const start = cx.lineStart + line.pos;
+        const markers = [cx.elt("YAMLMarker", start, start + 3)];
+        let contentStart = -1;
+        let contentEnd = -1;
+        let end = -1;
+        while (cx.nextLine()) {
+          if (contentStart === -1) contentStart = cx.lineStart;
+          const lineText = line.text.slice(line.pos);
+          if (lineText === "---" || lineText === "...") {
+            contentEnd = cx.lineStart - 1;
+            if (contentStart > contentEnd && contentStart !== -1) contentEnd = contentStart;
+            end = cx.lineStart + line.pos + 3;
+            markers.push(cx.elt("YAMLMarker", cx.lineStart + line.pos, end));
+            cx.nextLine();
+            break;
+          }
+        }
+        if (end === -1) return false;
+        if (contentStart !== -1 && contentEnd !== -1 && contentStart <= contentEnd) {
+          markers.splice(1, 0, cx.elt("YAMLContent", contentStart, contentEnd));
+        } else if (contentStart !== -1 && contentEnd === -1) {
+          contentEnd = cx.docLen;
+          markers.splice(1, 0, cx.elt("YAMLContent", contentStart, contentEnd));
+        }
+        cx.addElement(cx.elt("YAMLFrontMatter", start, end, markers));
+        return true;
+      },
+      before: "LinkReference"
+    }
+  ]
+};

package/dist/runtime/editor/plugins/codemirror-editor-plugins/customBracketClosingPlugin.d.ts

@@ -0,0 +1,4 @@
+import { ViewPlugin, type ViewUpdate } from '@codemirror/view';
+export declare const customBracketClosingPlugin: ViewPlugin<{
+    update(update: ViewUpdate): void;
+}, undefined>;

package/dist/runtime/editor/plugins/codemirror-editor-plugins/customBracketClosingPlugin.js

@@ -0,0 +1,94 @@
+import { ViewPlugin } from "@codemirror/view";
+import { EditorSelection } from "@codemirror/state";
+import { customBracketClosingConfig } from "../customBracketClosingConfig.js";
+const bracketMap = {
+  "(": ")",
+  "{": "}",
+  "'": "'",
+  '"': '"',
+  "[": "]"
+};
+const bracketClosingEventHandlers = {
+  keydown(event, view) {
+    if (!view.state.facet(customBracketClosingConfig)) return false;
+    if (bracketMap[event.key]) {
+      const closingBracket = bracketMap[event.key];
+      const { state, dispatch } = view;
+      const { selection } = state;
+      if (selection.ranges.length > 1) return false;
+      const range = selection.main;
+      if (!range.empty) {
+        const selectedText = state.doc.sliceString(range.from, range.to);
+        const changes2 = {
+          from: range.from,
+          to: range.to,
+          insert: `${event.key}${selectedText}${closingBracket}`
+        };
+        dispatch(
+          state.update({
+            changes: changes2,
+            selection: EditorSelection.range(range.from + 1, range.to + 1),
+            userEvent: "input.type"
+          })
+        );
+        event.preventDefault();
+        return true;
+      }
+      const charAfter = state.doc.sliceString(range.from, range.from + 1);
+      if (charAfter === closingBracket) {
+        dispatch(
+          state.update({
+            selection: { anchor: range.from + 1 },
+            userEvent: "input.type"
+          })
+        );
+        event.preventDefault();
+        return true;
+      }
+      const changes = {
+        from: range.from,
+        insert: `${event.key}${closingBracket}`
+      };
+      dispatch(
+        state.update({
+          changes,
+          selection: { anchor: range.from + 1 },
+          userEvent: "input.type"
+        })
+      );
+      event.preventDefault();
+      return true;
+    }
+    if (event.key === "Backspace") {
+      if (!view.state.facet(customBracketClosingConfig)) return false;
+      const { state, dispatch } = view;
+      const { selection } = state;
+      if (selection.ranges.length > 1 || !selection.main.empty) return false;
+      const range = selection.main;
+      const charBefore = state.doc.sliceString(range.from - 1, range.from);
+      const charAfter = state.doc.sliceString(range.from, range.from + 1);
+      if (bracketMap[charBefore] === charAfter) {
+        dispatch(
+          state.update({
+            changes: { from: range.from - 1, to: range.from + 1, insert: "" },
+            userEvent: "delete.backward"
+          })
+        );
+        event.preventDefault();
+        return true;
+      }
+    }
+    return false;
+  }
+};
+export const customBracketClosingPlugin = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+    }
+    update(update) {
+    }
+  },
+  {
+    eventHandlers: bracketClosingEventHandlers
+  }
+);

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorAttributesPlugin.d.ts

@@ -0,0 +1,8 @@
+import { EditorView, type DecorationSet, ViewUpdate, ViewPlugin } from '@codemirror/view';
+declare const editorAttributesPlugin: ViewPlugin<{
+    decorations: DecorationSet;
+    update(update: ViewUpdate): void;
+    destroy(): void;
+    buildDecorations(view: EditorView): DecorationSet;
+}, undefined>;
+export { editorAttributesPlugin };

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorAttributesPlugin.js

@@ -0,0 +1,136 @@
+import { RangeSetBuilder } from "@codemirror/state";
+import { EditorView, Decoration, WidgetType, ViewPlugin } from "@codemirror/view";
+import { EditorSelection } from "@codemirror/state";
+import { syntaxTree, foldable, foldEffect, unfoldEffect, foldedRanges } from "@codemirror/language";
+class FoldWidget extends WidgetType {
+  isFolded;
+  isHeader;
+  constructor(isFolded, isHeader = false) {
+    super();
+    this.isFolded = isFolded;
+    this.isHeader = isHeader;
+  }
+  eq(other) {
+    return other.isFolded == this.isFolded;
+  }
+  toDOM() {
+    let el = document.createElement("div");
+    el.className = "cm-fold-widget collapse-indicator collapse-icon";
+    if (this.isFolded) el.classList.add("is-collapsed");
+    this.isHeader ? el.classList.add("heading-collapse-indicator") : el.classList.add("list-collapse-indicator");
+    const icon = document.createElement("span");
+    icon.innerText = "\u25B8";
+    icon.style.cursor = "pointer";
+    icon.style.transform = this.isFolded ? "rotate(0deg)" : "rotate(90deg)";
+    el.appendChild(icon);
+    return el;
+  }
+  ignoreEvent() {
+    return false;
+  }
+}
+function foldExists(state, from, to) {
+  const folded = foldedRanges(state);
+  let found = false;
+  folded.between(from, from, (a, b) => {
+    if (a == from && b == to) found = true;
+  });
+  return found;
+}
+function announceFold(view, range, fold = true) {
+  let lineFrom = view.state.doc.lineAt(range.from).number, lineTo = view.state.doc.lineAt(range.to).number;
+  return EditorView.announce.of(
+    `${view.state.phrase(fold ? "Folded lines" : "Unfolded lines")} ${lineFrom} ${view.state.phrase(
+      "to"
+    )} ${lineTo}.`
+  );
+}
+const editorAttributesPlugin = ViewPlugin.fromClass(
+  class {
+    decorations;
+    constructor(view) {
+      this.decorations = this.buildDecorations(view);
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged || update.selectionSet) {
+        this.decorations = this.buildDecorations(update.view);
+      } else if (update.geometryChanged) {
+        for (let tr of update.transactions) {
+          for (let effect of tr.effects) {
+            if (effect && effect.value) {
+              if (effect.is(foldEffect) || effect.is(unfoldEffect)) {
+                this.decorations = this.buildDecorations(update.view);
+              }
+            }
+          }
+        }
+      }
+    }
+    destroy() {
+    }
+    buildDecorations(view) {
+      const hashTagRegexp = /#(?:[^\u2000-\u206F\u2E00-\u2E7F'!"#$%&()*+,.:;<=>?@^`{|}~\[\]\\\s])+/g;
+      let builder = new RangeSetBuilder();
+      const processedLinesForTags = /* @__PURE__ */ new Set();
+      for (let { from, to } of view.visibleRanges) {
+        syntaxTree(view.state).iterate({
+          from,
+          to,
+          enter: (node) => {
+            const isHeader = node.name.startsWith("ATXHeading");
+            const isList = node.name === "ListItem";
+            if (isList || isHeader) {
+              let range, line = view.state.doc.lineAt(node.from);
+              if (range = foldable(view.state, line.from, line.to)) {
+                const isFolded = foldExists(view.state, range.from, range.to);
+                let deco = Decoration.widget({
+                  widget: new FoldWidget(isFolded, isHeader)
+                });
+                builder.add(node.from, node.from, deco);
+              }
+            }
+            if (node.name === "HashtagTag") {
+              const line = view.state.doc.lineAt(node.from);
+              if (!processedLinesForTags.has(line.number)) {
+                const tags = line.text.match(hashTagRegexp);
+                if (tags) {
+                  const tagAttribute = tags.join(" ").replace(/#/g, "");
+                  let deco = Decoration.line({
+                    attributes: { "data-tags": tagAttribute }
+                  });
+                  builder.add(line.from, line.from, deco);
+                }
+                processedLinesForTags.add(line.number);
+              }
+            }
+          }
+        });
+      }
+      return builder.finish();
+    }
+  },
+  {
+    decorations: (v) => v.decorations,
+    eventHandlers: {
+      mousedown: (e, view) => {
+        let target = e.target.closest(".cm-fold-widget");
+        if (target) {
+          const foldMarkerPos = view.posAtDOM(target);
+          const line = view.state.doc.lineAt(foldMarkerPos);
+          let range = foldable(view.state, line.from, line.to);
+          if (range) {
+            let curPos = view.state.selection.main.head;
+            let effect = foldExists(view.state, range.from, range.to) ? unfoldEffect : foldEffect;
+            let transaction = { effects: effect.of(range) };
+            if (curPos >= range.from && curPos <= range.to) {
+              transaction.selection = EditorSelection.cursor(range.to);
+            }
+            view.dispatch(transaction);
+            return true;
+          }
+        }
+      }
+    }
+  }
+);
+export { editorAttributesPlugin };

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorInternalLinkAutocompletePlugin.d.ts

@@ -0,0 +1 @@
+export declare const editorInternalLinkAutocompletePlugin: import("@codemirror/state").Extension;

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorInternalLinkAutocompletePlugin.js

@@ -0,0 +1,43 @@
+import { autocompletion } from "@codemirror/autocomplete";
+import { syntaxTree } from "@codemirror/language";
+import { internalLinkMapFacet } from "../linkMappingConfig.js";
+function internalLinkSource(context) {
+  const node = syntaxTree(context.state).resolve(context.pos, -1);
+  let textBefore = context.state.sliceDoc(node.from, context.pos);
+  let from = node.from;
+  if (node.name !== "InternalLink" && node.name !== "InternalPath") {
+    const precursor = context.state.sliceDoc(context.pos - 2, context.pos);
+    if (precursor === "[[") {
+      textBefore = "";
+      from = context.pos;
+    } else {
+      return null;
+    }
+  } else {
+    from = node.from;
+    if (node.name === "InternalLink") {
+      const pathNode = node.node.getChild("InternalPath");
+      if (pathNode) {
+        from = pathNode.from;
+      } else {
+        from = context.pos;
+      }
+    }
+  }
+  const linkMap = context.state.facet(internalLinkMapFacet);
+  const options = linkMap.filter((link) => link.internalLinkName.toLowerCase().includes(textBefore.toLowerCase())).map((link) => ({
+    label: link.internalLinkName,
+    detail: link.redirectToPath,
+    apply: `${link.internalLinkName}`
+  }));
+  if (options.length === 0) return null;
+  return {
+    from,
+    options,
+    validFor: /^[\w\s]*$/
+  };
+}
+export const editorInternalLinkAutocompletePlugin = autocompletion({
+  override: [internalLinkSource],
+  icons: false
+});

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorKeymapPlugin.d.ts

@@ -0,0 +1 @@
+export declare const editorKeymapPlugin: import("@codemirror/state").Extension;

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorKeymapPlugin.js

@@ -0,0 +1,95 @@
+import { keymap } from "@codemirror/view";
+import { EditorSelection } from "@codemirror/state";
+import { completionKeymap } from "@codemirror/autocomplete";
+const toggleMarkdownFormatting = (mark) => {
+  return (view) => {
+    const { state, dispatch } = view;
+    const { selection } = state;
+    if (selection.ranges.length === 0) {
+      return false;
+    }
+    const transactions = selection.ranges.map((range) => {
+      if (range.empty) {
+        const { from } = range;
+        const word = state.wordAt(from);
+        if (word) {
+          const wordText = state.doc.sliceString(word.from, word.to);
+          const textBeforeWord = state.doc.sliceString(word.from - mark.length, word.from);
+          const textAfterWord = state.doc.sliceString(word.to, word.to + mark.length);
+          if (textBeforeWord === mark && textAfterWord === mark) {
+            return state.update({
+              changes: [
+                { from: word.from - mark.length, to: word.from, insert: "" },
+                { from: word.to, to: word.to + mark.length, insert: "" }
+              ],
+              selection: { anchor: word.from - mark.length, head: word.to - mark.length }
+            });
+          }
+          return state.update({
+            changes: {
+              from: word.from,
+              to: word.to,
+              insert: `${mark}${wordText}${mark}`
+            },
+            selection: EditorSelection.range(word.from + mark.length, word.to + mark.length)
+          });
+        }
+        return state.update({
+          changes: { from, insert: `${mark}${mark}` },
+          selection: { anchor: from + mark.length }
+        });
+      } else {
+        const selectedText = state.doc.sliceString(range.from, range.to);
+        const textBefore = state.doc.sliceString(range.from - mark.length, range.from);
+        const textAfter = state.doc.sliceString(range.to, range.to + mark.length);
+        if (textBefore === mark && textAfter === mark) {
+          return state.update({
+            changes: [
+              { from: range.from - mark.length, to: range.from },
+              { from: range.to, to: range.to + mark.length }
+            ],
+            selection: { anchor: range.from - mark.length, head: range.to - mark.length }
+          });
+        } else {
+          return state.update({
+            changes: { from: range.from, to: range.to, insert: `${mark}${selectedText}${mark}` },
+            selection: { anchor: range.from + mark.length, head: range.to + mark.length }
+          });
+        }
+      }
+    });
+    const transaction = transactions.reduce((acc, tr) => {
+      if (!tr) return acc;
+      const changes = acc.changes.compose(tr.changes);
+      return {
+        changes,
+        selection: tr.selection ? tr.selection : acc.selection?.map(changes),
+        effects: acc.effects.concat(tr.effects)
+      };
+    }, state.update({}));
+    if (transaction.changes.empty) {
+      return false;
+    }
+    dispatch(state.update(transaction));
+    return true;
+  };
+};
+export const editorKeymapPlugin = keymap.of([
+  {
+    key: "Mod-b",
+    run: toggleMarkdownFormatting("**")
+  },
+  {
+    key: "Mod-i",
+    run: toggleMarkdownFormatting("*")
+  },
+  {
+    key: "Mod-Shift-x",
+    run: toggleMarkdownFormatting("~~")
+  },
+  {
+    key: "Mod-Shift-h",
+    run: toggleMarkdownFormatting("==")
+  },
+  ...completionKeymap
+]);

package/dist/runtime/editor/plugins/codemirror-editor-plugins/editorLinkClickPlugin.d.ts

@@ -0,0 +1 @@
+export declare const editorLinkClickPlugin: import("@codemirror/state").Extension;