@type32/codemirror-rich-obsidian-editor 0.0.3

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

@@ -0,0 +1,43 @@
+import { EditorView } from "@codemirror/view";
+import { syntaxTree } from "@codemirror/language";
+export const editorLinkClickPlugin = EditorView.domEventHandlers({
+  mousedown(event, view) {
+    let target = event.target;
+    const imageEmbed = target.closest(".internal-embed");
+    if (imageEmbed) {
+      const posData = imageEmbed.dataset;
+      if (posData.embedPos) {
+        const from = posData.selectionFrom ? parseInt(posData.selectionFrom, 10) : parseInt(posData.embedPos, 10);
+        const to = posData.selectionTo ? parseInt(posData.selectionTo, 10) : syntaxTree(view.state).resolve(from, -1).to;
+        view.dispatch({
+          selection: { anchor: from, head: to }
+        });
+        return true;
+      }
+    }
+    const anchor = target.closest("a.cm-link");
+    if (!anchor) {
+      return false;
+    }
+    if (anchor.dataset.internalLink === "true") {
+      event.preventDefault();
+      view.dom.dispatchEvent(new CustomEvent("internal-link-click", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          path: anchor.dataset.path,
+          subpath: anchor.dataset.subpath,
+          display: anchor.dataset.display,
+          type: anchor.dataset.type
+        }
+      }));
+    } else if (anchor.dataset.externalLink === "true") {
+      event.preventDefault();
+      const url = anchor.dataset.url;
+      if (url) {
+        window.open(url, "_blank");
+      }
+    }
+    return true;
+  }
+});

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

@@ -0,0 +1,10 @@
+import { type Extension } from '@codemirror/state';
+export interface IndentationGuidesSettings {
+    showActiveIndentationGroup: boolean;
+    lists: boolean;
+    previewLists: boolean;
+    uncategorizedIndents: boolean;
+    code: boolean;
+}
+export declare const DEFAULT_SETTINGS: IndentationGuidesSettings;
+export declare const indentationGuides: (options?: Partial<IndentationGuidesSettings>) => Extension;

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

@@ -0,0 +1,121 @@
+import { Decoration, MatchDecorator, ViewPlugin } from "@codemirror/view";
+import { StateField, RangeSetBuilder } from "@codemirror/state";
+export const DEFAULT_SETTINGS = {
+  showActiveIndentationGroup: true,
+  lists: true,
+  previewLists: false,
+  uncategorizedIndents: false,
+  code: false
+};
+function getLineIndent(line) {
+  const match = line.text.match(/^((?:\t| {4})+)/);
+  if (!match) return 0;
+  return Math.max(match[1]?.split(/(?:\t| {4})/).length || 0, 1);
+}
+const tabMark = Decoration.mark({
+  class: "cm-indent"
+});
+const indentGroupMark = Decoration.mark({
+  class: "cm-indent cm-active-indent"
+});
+const indentationGroupDecoration = Decoration.line({
+  attributes: { class: "cm-indent-group" }
+});
+const activeIndentField = StateField.define({
+  create(state) {
+    if (!state.selection?.main) return 0;
+    return getLineIndent(state.doc.lineAt(state.selection.main.from));
+  },
+  update(_, tr) {
+    if (!tr.selection) return _.valueOf();
+    const state = tr.state;
+    return getLineIndent(state.doc.lineAt(state.selection.main.from));
+  }
+});
+const tabDecoration = (getSettings) => {
+  return ViewPlugin.fromClass(
+    class {
+      constructor(view) {
+        this.view = view;
+        this.decorator = new MatchDecorator({
+          regexp: new RegExp(/(?:\t| {4})/g),
+          decoration: (match, view2) => {
+            if (!getSettings().showActiveIndentationGroup) {
+              return tabMark;
+            }
+            const currentIndent = Math.max(view2.state.field(activeIndentField), 1);
+            const thisIndent = match.index / match[0].length + 1;
+            return thisIndent === currentIndent ? indentGroupMark : tabMark;
+          }
+        });
+        this.decorations = this.decorator.createDeco(view);
+      }
+      decorator;
+      decorations = Decoration.none;
+      update(update) {
+        if (!getSettings().showActiveIndentationGroup) {
+          this.decorations = this.decorator.updateDeco(update, this.decorations);
+        } else {
+          this.decorations = this.decorator.createDeco(update.view);
+        }
+      }
+    },
+    {
+      decorations: (v) => v.decorations
+    }
+  );
+};
+function tagIndentationGroup(view) {
+  const builder = new RangeSetBuilder();
+  const state = view.state;
+  if (!state.selection?.main) return builder.finish();
+  const currentLine = state.doc.lineAt(state.selection.main.from);
+  const currentIndent = view.state.field(activeIndentField);
+  if (currentIndent === 0) return builder.finish();
+  const indentationGroup2 = [currentLine];
+  let from = currentLine.from;
+  let to = currentLine.to;
+  while (from > 0) {
+    const prevLine = state.doc.lineAt(from - 1);
+    const prevIndent = getLineIndent(prevLine);
+    if (prevIndent >= currentIndent) {
+      indentationGroup2.push(prevLine);
+      from = prevLine.from;
+    } else {
+      break;
+    }
+  }
+  while (to < state.doc.length - 1) {
+    const nextLine = state.doc.lineAt(to + 1);
+    const nextIndent = getLineIndent(nextLine);
+    if (nextIndent >= currentIndent) {
+      indentationGroup2.push(nextLine);
+      to = nextLine.to;
+    } else {
+      break;
+    }
+  }
+  indentationGroup2.sort((a, b) => a.from - b.from).forEach((line) => {
+    builder.add(line.from, line.from, indentationGroupDecoration);
+  });
+  return builder.finish();
+}
+const indentationGroup = ViewPlugin.fromClass(
+  class {
+    decorations;
+    constructor(view) {
+      this.decorations = tagIndentationGroup(view);
+    }
+    update(update) {
+      this.decorations = tagIndentationGroup(update.view);
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);
+export const indentationGuides = (options = {}) => {
+  const settings = { ...DEFAULT_SETTINGS, ...options };
+  const getSettings = () => settings;
+  return [activeIndentField, indentationGroup, tabDecoration(getSettings)];
+};

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

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

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

@@ -0,0 +1,66 @@
+import { Decoration, ViewPlugin } from "@codemirror/view";
+import { RangeSetBuilder } from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+function getLineIndent(line) {
+  const match = line.text.match(/^(?:\t| {4})*/);
+  if (!match) return 0;
+  return match[0].length;
+}
+function decorate(view) {
+  const builder = new RangeSetBuilder();
+  for (const { from, to } of view.visibleRanges) {
+    syntaxTree(view.state).iterate({
+      from,
+      to,
+      enter: (node) => {
+        if (node.name === "ListItem") {
+          const line = view.state.doc.lineAt(node.from);
+          const indentLevel = getLineIndent(line) + 1;
+          builder.add(
+            line.from,
+            line.from,
+            Decoration.line({
+              attributes: {
+                class: `cm-list-line cm-list-line-${indentLevel}`,
+                style: `--indent-level: ${indentLevel}`
+              }
+            })
+          );
+          let contentFrom = -1, contentTo = -1;
+          const listMark = node.node.getChild("ListMark");
+          if (listMark) {
+            contentFrom = listMark.to + 1;
+            contentTo = node.to;
+          }
+          if (contentFrom !== -1) {
+            builder.add(
+              contentFrom,
+              contentTo,
+              Decoration.mark({
+                class: `cm-list-internal cm-list-${indentLevel}`,
+                style: `--indent-level: ${indentLevel}`
+              })
+            );
+          }
+        }
+      }
+    });
+  }
+  return builder.finish();
+}
+export const indentationListPlugin = ViewPlugin.fromClass(
+  class {
+    decorations;
+    constructor(view) {
+      this.decorations = decorate(view);
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        this.decorations = decorate(update.view);
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseCalloutPlugin.d.ts

@@ -0,0 +1,3 @@
+import { type DecorationSet } from '@codemirror/view';
+import { StateField } from '@codemirror/state';
+export declare const proseCalloutPlugin: StateField<DecorationSet>;

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseCalloutPlugin.js

@@ -0,0 +1,63 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { StateField, RangeSet } from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+import { CalloutWidget } from "../codemirror-widgets/proseCalloutWidget.js";
+function isNodeRangeActive(state, nodeFrom, nodeTo) {
+  const cursor = state.selection.main;
+  if (cursor.empty) {
+    return cursor.from >= nodeFrom && cursor.from <= nodeTo;
+  }
+  return Math.max(nodeFrom, cursor.from) < Math.min(nodeTo, cursor.to);
+}
+function getCalloutNode(blockquoteNode) {
+  let calloutNode = null;
+  let found = false;
+  blockquoteNode.cursor().iterate((node) => {
+    if (found) return false;
+    if (node.name === "Paragraph") {
+      node.node.cursor().iterate((child) => {
+        if (child.name === "Callout") {
+          calloutNode = child.node;
+          found = true;
+          return false;
+        }
+      });
+      return false;
+    }
+  });
+  return calloutNode;
+}
+function buildCalloutWidgetDecorations(state) {
+  const decorations = [];
+  syntaxTree(state).iterate({
+    enter(node) {
+      if (node.name === "Blockquote") {
+        const calloutNode = getCalloutNode(node.node);
+        if (calloutNode && node.node.parent?.name !== "Blockquote") {
+          const from = node.from;
+          const to = node.to;
+          if (!isNodeRangeActive(state, from, to)) {
+            decorations.push(Decoration.replace({
+              widget: new CalloutWidget(from, to),
+              block: true
+            }).range(from, to));
+          }
+          return false;
+        }
+      }
+    }
+  });
+  return decorations.sort((a, b) => a.from - b.from);
+}
+export const proseCalloutPlugin = StateField.define({
+  create(state) {
+    return RangeSet.of(buildCalloutWidgetDecorations(state), true);
+  },
+  update(value, tr) {
+    if (tr.docChanged || tr.selection) {
+      return RangeSet.of(buildCalloutWidgetDecorations(tr.state), true);
+    }
+    return value.map(tr.changes);
+  },
+  provide: (f) => EditorView.decorations.from(f)
+});

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseCodeBlockCodemirrorViewPlugin.d.ts

@@ -0,0 +1,3 @@
+import { StateField } from '@codemirror/state';
+import type { DecorationSet } from '@codemirror/view';
+export declare const proseCodeBlockCodemirrorViewPlugin: StateField<DecorationSet>;

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseCodeBlockCodemirrorViewPlugin.js

@@ -0,0 +1,98 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { StateField, RangeSet } from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+import { EndFenceWidget, LanguageFlairWidget } from "../codemirror-widgets/proseCodeBlockWidgets.js";
+import { specialCodeBlockMapFacet } from "../specialCodeBlockMappingConfig.js";
+import { ProseVueComponentEmbedWidget } from "../codemirror-widgets/proseVueComponentEmbedWidget.js";
+import { cursorSelectionCoveredNode, isNodeRangeActive, toCursorNodePositions } from "../../utility/tools.js";
+function buildCodeBlockDecorations(state) {
+  const decorations = [];
+  const specialCodeBlocks = state.facet(specialCodeBlockMapFacet);
+  syntaxTree(state).iterate({
+    enter(node) {
+      if (node.name === "FencedCode") {
+        const codeInfoNode = node.node.getChild("CodeInfo");
+        let language = "";
+        if (codeInfoNode) {
+          language = state.doc.sliceString(codeInfoNode.from, codeInfoNode.to);
+        }
+        const specialMapping = specialCodeBlocks.find((m) => m.codeInfo === language);
+        const firstLineNode = state.doc.lineAt(node.from);
+        let scanPos = node.to;
+        while (scanPos > node.from && /\s/.test(state.doc.sliceString(scanPos - 1, scanPos))) {
+          scanPos--;
+        }
+        const lastLineNode = state.doc.lineAt(scanPos > node.from ? scanPos : node.from);
+        let codeText = "";
+        const firstContentLineNum = firstLineNode.number + 1;
+        const lastContentLineNum = lastLineNode.number - 1;
+        if (firstContentLineNum <= lastContentLineNum) {
+          const contentStartOffset = state.doc.line(firstContentLineNum).from;
+          const contentEndOffset = state.doc.line(lastContentLineNum).to;
+          codeText = state.doc.sliceString(contentStartOffset, contentEndOffset);
+        }
+        const poses = toCursorNodePositions(state, node);
+        if (specialMapping != void 0 && !(isNodeRangeActive(state, node.from, node.to) || cursorSelectionCoveredNode(poses.cursorFrom, poses.cursorTo, poses.nodeFrom, poses.nodeTo))) {
+          if (specialMapping)
+            decorations.push(
+              Decoration.replace({
+                widget: new ProseVueComponentEmbedWidget(
+                  specialMapping.component,
+                  { codeContent: codeText },
+                  node.from
+                ),
+                block: true
+              }).range(node.from, node.to)
+            );
+          return false;
+        }
+        const cursor = state.selection.main;
+        for (let currentLineNum = firstLineNode.number; currentLineNum <= lastLineNode.number; currentLineNum++) {
+          const line = state.doc.line(currentLineNum);
+          let lineClasses = ["cm-codeblock"];
+          const cursorFocusedOnThisLine = cursor.anchor >= line.from && cursor.anchor <= line.to || cursorSelectionCoveredNode(poses.cursorFrom, poses.cursorTo, poses.nodeFrom, poses.nodeTo);
+          if (currentLineNum === firstLineNode.number) {
+            lineClasses.push("cm-line-codeblock-begin");
+            if (!cursorFocusedOnThisLine) {
+              decorations.push(
+                Decoration.replace({
+                  widget: new LanguageFlairWidget(language, codeText)
+                }).range(line.from, line.to)
+              );
+            }
+          } else if (currentLineNum === lastLineNode.number) {
+            lineClasses.push("cm-line-codeblock-end");
+            if (!cursorFocusedOnThisLine) {
+              decorations.push(
+                Decoration.replace({
+                  widget: new EndFenceWidget()
+                }).range(line.from, line.to)
+              );
+            }
+          } else {
+            lineClasses.push("cm-line-codeblock-content");
+          }
+          decorations.push(
+            Decoration.line({
+              attributes: { class: lineClasses.join(" ") }
+            }).range(line.from)
+          );
+        }
+        return false;
+      }
+    }
+  });
+  return decorations;
+}
+export const proseCodeBlockCodemirrorViewPlugin = StateField.define({
+  create(state) {
+    return RangeSet.of(buildCodeBlockDecorations(state), true);
+  },
+  update(value, tr) {
+    if (tr.docChanged || tr.selection) {
+      return RangeSet.of(buildCodeBlockDecorations(tr.state), true);
+    }
+    return value.map(tr.changes);
+  },
+  provide: (f) => EditorView.decorations.from(f)
+});

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseHashtagCodemirrorViewPlugin.d.ts

@@ -0,0 +1,3 @@
+import { type DecorationSet } from '@codemirror/view';
+import { StateField } from '@codemirror/state';
+export declare const proseHashtagCodemirrorViewPlugin: StateField<DecorationSet>;

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseHashtagCodemirrorViewPlugin.js

@@ -0,0 +1,27 @@
+import { EditorView } from "@codemirror/view";
+import { StateField, RangeSet } from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+import { decorationProseHashtag } from "../../utility/decorations.js";
+function buildHashtagWrappers(state) {
+  const decorations = [];
+  syntaxTree(state).iterate({
+    enter(node) {
+      if (node.name === "HashtagTag") {
+        decorations.push(decorationProseHashtag.range(node.from, node.to));
+      }
+    }
+  });
+  return decorations;
+}
+export const proseHashtagCodemirrorViewPlugin = StateField.define({
+  create(state) {
+    return RangeSet.of(buildHashtagWrappers(state));
+  },
+  update(value, tr) {
+    if (tr.docChanged) {
+      return RangeSet.of(buildHashtagWrappers(tr.state));
+    }
+    return value.map(tr.changes);
+  },
+  provide: (f) => EditorView.decorations.from(f)
+});

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseHighlightCodemirrorViewPlugin.d.ts

@@ -0,0 +1,3 @@
+import { type DecorationSet } from '@codemirror/view';
+import { StateField } from '@codemirror/state';
+export declare const proseHighlightCodemirrorViewPlugin: StateField<DecorationSet>;

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseHighlightCodemirrorViewPlugin.js

@@ -0,0 +1,51 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { StateField, RangeSet } from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+import { cursorSelectionCoveredNode, isNodeRangeActive, toCursorNodePositions } from "../../utility/tools.js";
+function buildHighlightDecorations(state) {
+  const decorations = [];
+  syntaxTree(state).iterate({
+    enter(node) {
+      if (node.name === "Mark") {
+        const markers = node.node.getChildren("MarkMarker");
+        if (markers.length < 2) return;
+        const openMark = state.doc.sliceString(markers[0]?.from || 0, markers[0]?.to || 0);
+        if (openMark !== "==") return;
+        const closeMark = state.doc.sliceString(
+          markers[markers.length - 1]?.from || 0,
+          markers[markers.length - 1]?.to || 0
+        );
+        if (closeMark !== "==") return;
+        const poses = toCursorNodePositions(state, node);
+        if (isNodeRangeActive(state, node.from, node.to) || cursorSelectionCoveredNode(poses.cursorFrom, poses.cursorTo, poses.nodeFrom, poses.nodeTo)) {
+          return;
+        }
+        const startContent = markers[0]?.to || 0;
+        const endContent = markers[markers.length - 1]?.from || 0;
+        decorations.push(
+          Decoration.mark({
+            class: "cm-highlighted",
+            tagName: "span"
+          }).range(startContent, endContent)
+        );
+        decorations.push(Decoration.replace({}).range(markers[0]?.from || 0, markers[0]?.to || 0));
+        decorations.push(
+          Decoration.replace({}).range(markers[markers.length - 1]?.from || 0, markers[markers.length - 1]?.to || 0)
+        );
+      }
+    }
+  });
+  return decorations;
+}
+export const proseHighlightCodemirrorViewPlugin = StateField.define({
+  create(state) {
+    return RangeSet.of(buildHighlightDecorations(state), true);
+  },
+  update(value, tr) {
+    if (tr.docChanged || tr.selection) {
+      return RangeSet.of(buildHighlightDecorations(tr.state), true);
+    }
+    return value.map(tr.changes);
+  },
+  provide: (f) => EditorView.decorations.from(f)
+});

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseInternalLinkCodemirrorViewPlugin.d.ts

@@ -0,0 +1,6 @@
+import { type DecorationSet } from '@codemirror/view';
+import { StateField } from '@codemirror/state';
+import type { EditorState } from '@codemirror/state';
+declare function isNodeRangeActive(state: EditorState, nodeFrom: number, nodeTo: number): boolean;
+export { isNodeRangeActive };
+export declare const proseInternalLinkCodemirrorViewPlugin: StateField<DecorationSet>;

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseInternalLinkCodemirrorViewPlugin.js

@@ -0,0 +1,112 @@
+import { Decoration, EditorView } from "@codemirror/view";
+import { StateField, RangeSet } from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+import { internalLinkMapFacet } from "../linkMappingConfig.js";
+import { ProseVueComponentEmbedWidget } from "../codemirror-widgets/proseVueComponentEmbedWidget.js";
+import { cursorSelectionCoveredNode, toCursorNodePositions } from "../../utility/tools.js";
+function isNodeRangeActive(state, nodeFrom, nodeTo) {
+  const cursor = state.selection.main;
+  if (cursor.empty) {
+    return cursor.from >= nodeFrom && cursor.from <= nodeTo;
+  } else {
+    return Math.max(nodeFrom, cursor.from) < Math.min(nodeTo, cursor.to);
+  }
+}
+function buildInternalLinkDecorations(state) {
+  const decorations = [];
+  const linkMap = state.facet(internalLinkMapFacet);
+  const widgets = [];
+  syntaxTree(state).iterate({
+    enter(node) {
+      if (node.name === "Embed") {
+        const pathNode = node.node.getChild("InternalLink")?.getChild("InternalPath");
+        if (pathNode) {
+          const path = state.doc.sliceString(pathNode.from, pathNode.to);
+          const linkInfo = linkMap.find((l) => l.internalLinkName === path);
+          if (linkInfo?.embedComponent) {
+            const line = state.doc.lineAt(node.from);
+            const props = { linkData: linkInfo };
+            if (linkInfo.filePath) {
+              props.filePath = linkInfo.filePath;
+            }
+            widgets.push(Decoration.widget({
+              widget: new ProseVueComponentEmbedWidget(linkInfo.embedComponent, props, node.from),
+              block: true,
+              side: 1
+            }).range(line.to));
+            const poses = toCursorNodePositions(state, node);
+            if (!(isNodeRangeActive(state, node.from, node.to) || cursorSelectionCoveredNode(poses.cursorFrom, poses.cursorTo, poses.nodeFrom, poses.nodeTo))) {
+              decorations.push(Decoration.replace({}).range(node.from, node.to));
+            }
+            return false;
+          }
+        }
+      }
+      if (node.name === "InternalLink" || node.name === "Embed") {
+        const mainNode = node.node;
+        const isActive = isNodeRangeActive(state, mainNode.from, mainNode.to);
+        if (isActive) return;
+        const contentContainerNode = node.name === "Embed" ? mainNode.getChild("InternalLink") : mainNode;
+        if (!contentContainerNode) return;
+        const pathNode = contentContainerNode.getChild("InternalPath");
+        if (!pathNode) return;
+        const path = state.doc.sliceString(pathNode.from, pathNode.to);
+        const subpathNode = contentContainerNode.getChild("InternalSubpath");
+        const aliasNode = contentContainerNode.getChild("InternalDisplay");
+        const subpath = subpathNode ? state.doc.sliceString(subpathNode.from, subpathNode.to) : void 0;
+        const alias = aliasNode ? state.doc.sliceString(aliasNode.from, aliasNode.to) : void 0;
+        const linkInfo = linkMap.find((l) => l.internalLinkName === path);
+        if (node.name === "Embed" && linkInfo?.embedComponent) {
+          return false;
+        }
+        const linkAttributes = {
+          "class": "cm-link",
+          "href": "#",
+          "data-internal-link": "true",
+          "data-path": path,
+          "data-type": node.name === "Embed" ? "embed" : "internal-link"
+        };
+        if (!linkInfo) {
+          linkAttributes["class"] += " cm-unresolved-link";
+        }
+        if (subpath) linkAttributes["data-subpath"] = subpath;
+        if (alias) linkAttributes["data-display"] = alias;
+        if (node.name === "Embed") {
+          const embedMark = mainNode.getChild("EmbedMark");
+          if (embedMark) {
+            decorations.push(Decoration.replace({}).range(embedMark.from, embedMark.to));
+          }
+        }
+        if (aliasNode) {
+          decorations.push(Decoration.mark({ tagName: "a", attributes: linkAttributes }).range(aliasNode.from, aliasNode.to));
+          decorations.push(Decoration.replace({}).range(pathNode.from, pathNode.to));
+          if (subpathNode) {
+            decorations.push(Decoration.replace({}).range(subpathNode.from, subpathNode.to));
+          }
+        } else {
+          const linkStart = pathNode.from;
+          const linkEnd = subpathNode ? subpathNode.to : pathNode.to;
+          decorations.push(Decoration.mark({ tagName: "a", attributes: linkAttributes }).range(linkStart, linkEnd));
+        }
+        contentContainerNode.getChildren("InternalMark").forEach((mark) => {
+          decorations.push(Decoration.replace({}).range(mark.from, mark.to));
+        });
+        return false;
+      }
+    }
+  });
+  return [...decorations, ...widgets];
+}
+export { isNodeRangeActive };
+export const proseInternalLinkCodemirrorViewPlugin = StateField.define({
+  create(state) {
+    return RangeSet.of(buildInternalLinkDecorations(state), true);
+  },
+  update(value, tr) {
+    if (tr.docChanged || tr.selection) {
+      return RangeSet.of(buildInternalLinkDecorations(tr.state), true);
+    }
+    return value.map(tr.changes);
+  },
+  provide: (f) => EditorView.decorations.from(f)
+});

package/dist/runtime/editor/plugins/codemirror-plugin-proses/proseLatexCodemirrorViewPlugin.d.ts

@@ -0,0 +1,2 @@
+import { type Extension } from '@codemirror/state';
+export declare function proseLatexCodemirrorViewPlugin(): Extension;