leepi 0.0.2 → 0.0.4

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# leepi
+
+## 0.0.4
+
+### Patch Changes
+
+- e25ae8e: Fix bug with ul/ol toggles
+- e25ae8e: Use link paste primitive from library instead of custom
+
+## 0.0.3
+
+### Patch Changes
+
+- 2aa717f: Build package first before publishing
+
+## 0.0.2
+
+### Patch Changes
+
+- 5778861: A headless markdown editor using CodeMirror with keyboard shortcuts and built-in React primitives

package/dist/core/active-marks.d.ts

@@ -0,0 +1,15 @@
+import { EditorView } from "@codemirror/view";
+import { Extension } from "@codemirror/state";
+
+//#region src/core/active-marks.d.ts
+/**
+* Active marks as a dynamic record. Keys are mark names registered via `markRegistry`.
+*/
+type ActiveMarks = Record<string, boolean>;
+declare const emptyMarks: ActiveMarks;
+declare function detectMarks(view: EditorView): ActiveMarks;
+declare function subscribeToMarks(view: EditorView, callback: () => void): () => void;
+declare function getMarksSnapshot(view: EditorView): ActiveMarks;
+declare const activeMarksPlugin: Extension;
+//#endregion
+export { ActiveMarks, activeMarksPlugin, detectMarks, emptyMarks, getMarksSnapshot, subscribeToMarks };

package/dist/core/active-marks.js

@@ -0,0 +1,57 @@
+import { markRegistry } from "./registry.js";
+import { ViewPlugin } from "@codemirror/view";
+import { syntaxTree } from "@codemirror/language";
+//#region src/core/active-marks.ts
+const emptyMarks = {};
+function detectMarks(view) {
+	const { state } = view;
+	const pos = state.selection.main.from;
+	const tree = syntaxTree(state);
+	const detectors = state.facet(markRegistry);
+	const marks = {};
+	let node = tree.resolveInner(pos, -1);
+	while (node) {
+		for (const det of detectors) if (!marks[det.mark] && det.detect(node.name, state, pos)) marks[det.mark] = true;
+		if (!node.parent) break;
+		node = node.parent;
+	}
+	for (const det of detectors) if (!marks[det.mark] && det.detect("__line__", state, pos)) marks[det.mark] = true;
+	return marks;
+}
+const viewListeners = /* @__PURE__ */ new WeakMap();
+const viewSnapshots = /* @__PURE__ */ new WeakMap();
+function subscribeToMarks(view, callback) {
+	let listeners = viewListeners.get(view);
+	if (!listeners) {
+		listeners = /* @__PURE__ */ new Set();
+		viewListeners.set(view, listeners);
+	}
+	listeners.add(callback);
+	return () => {
+		listeners.delete(callback);
+	};
+}
+function getMarksSnapshot(view) {
+	return viewSnapshots.get(view) ?? emptyMarks;
+}
+function marksEqual(a, b) {
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) if (a[key] !== b[key]) return false;
+	return true;
+}
+const activeMarksPlugin = ViewPlugin.fromClass(class {
+	update(update) {
+		if (update.selectionSet || update.docChanged) {
+			const marks = detectMarks(update.view);
+			if (!marksEqual(viewSnapshots.get(update.view) ?? emptyMarks, marks)) {
+				viewSnapshots.set(update.view, marks);
+				const listeners = viewListeners.get(update.view);
+				if (listeners) for (const cb of listeners) cb();
+			}
+		}
+	}
+});
+//#endregion
+export { activeMarksPlugin, detectMarks, emptyMarks, getMarksSnapshot, subscribeToMarks };

package/dist/core/commands.d.ts

@@ -0,0 +1,39 @@
+import { CodeBlockData } from "./plugins/code-block.js";
+import { EditorView } from "@codemirror/view";
+import { EditorState } from "@codemirror/state";
+
+//#region src/core/commands.d.ts
+/**
+* Toggle an inline markdown marker (e.g. `**`, `_`, `` ` ``, `~~`) around
+* each selection range. If the selected text is already wrapped with the
+* marker, the marker is removed; otherwise it is added.
+*
+* When nothing is selected the marker pair is inserted at the cursor and the
+* cursor is placed between them.
+*/
+declare function toggleMarker(marker: string): (view: EditorView) => boolean;
+declare function toggleBlockquote(view: EditorView): boolean;
+declare function toggleHeading(level: number): (view: EditorView) => boolean;
+type ListKind = "ul" | "ol" | "task" | "none";
+declare function toggleListKind(target: ListKind): (view: EditorView) => boolean;
+declare function toggleTaskCheck(view: EditorView): boolean;
+declare function findLinkAtCursor(state: EditorState, pos: number): {
+  from: number;
+  to: number;
+  label: string;
+  url: string;
+} | null;
+/** Insert a markdown link into the editor, replacing `from..to`. */
+declare function insertLink(view: EditorView, from: number, to: number, label: string, url: string): void;
+declare function findCodeFenceAtCursor(view: EditorView): {
+  fenceLine: {
+    from: number;
+    to: number;
+  };
+  lang: string;
+  filename: string;
+} | null;
+/** Apply code block settings. For existing blocks, replaces the fence line. For new blocks, inserts a fenced block. */
+declare function applyCodeBlock(view: EditorView, data: CodeBlockData, lang: string, filename: string): void;
+//#endregion
+export { applyCodeBlock, findCodeFenceAtCursor, findLinkAtCursor, insertLink, toggleBlockquote, toggleHeading, toggleListKind, toggleMarker, toggleTaskCheck };

package/dist/core/commands.js

@@ -0,0 +1,421 @@
+import { isInsideCodeBlock } from "./utils.js";
+import { syntaxTree } from "@codemirror/language";
+import { EditorSelection } from "@codemirror/state";
+//#region src/core/commands.ts
+/**
+* Toggle an inline markdown marker (e.g. `**`, `_`, `` ` ``, `~~`) around
+* each selection range. If the selected text is already wrapped with the
+* marker, the marker is removed; otherwise it is added.
+*
+* When nothing is selected the marker pair is inserted at the cursor and the
+* cursor is placed between them.
+*/
+function toggleMarker(marker) {
+	return (view) => {
+		if (isInsideCodeBlock(view)) return false;
+		const { state } = view;
+		const len = marker.length;
+		const changes = state.changeByRange((range) => {
+			const doc = state.doc;
+			if (range.empty) {
+				const line = doc.lineAt(range.from);
+				const lineText = line.text;
+				const cursorOffset = range.from - line.from;
+				const positions = [];
+				let searchFrom = 0;
+				while (searchFrom <= lineText.length - len) {
+					const idx = lineText.indexOf(marker, searchFrom);
+					if (idx === -1) break;
+					positions.push(idx);
+					searchFrom = idx + len;
+				}
+				for (let i = 0; i + 1 < positions.length; i += 2) {
+					const openEnd = positions[i] + len;
+					const closeStart = positions[i + 1];
+					if (cursorOffset >= openEnd && cursorOffset <= closeStart) {
+						const absOpen = line.from + positions[i];
+						const absClose = line.from + closeStart;
+						const innerText = doc.sliceString(absOpen + len, absClose);
+						const cursorInInner = range.from - (absOpen + len);
+						return {
+							changes: {
+								from: absOpen,
+								to: absClose + len,
+								insert: innerText
+							},
+							range: EditorSelection.cursor(absOpen + cursorInInner)
+						};
+					}
+				}
+				return {
+					changes: {
+						from: range.from,
+						insert: marker + marker
+					},
+					range: EditorSelection.cursor(range.from + len)
+				};
+			}
+			const selected = doc.sliceString(range.from, range.to);
+			if (selected.startsWith(marker) && selected.endsWith(marker) && selected.length >= len * 2) {
+				const inner = selected.slice(len, -len);
+				return {
+					changes: {
+						from: range.from,
+						to: range.to,
+						insert: inner
+					},
+					range: EditorSelection.range(range.from, range.from + inner.length)
+				};
+			}
+			const beforeSel = doc.sliceString(Math.max(0, range.from - len), range.from);
+			const afterSel = doc.sliceString(range.to, Math.min(doc.length, range.to + len));
+			if (beforeSel === marker && afterSel === marker) return {
+				changes: [{
+					from: range.from - len,
+					to: range.from
+				}, {
+					from: range.to,
+					to: range.to + len
+				}],
+				range: EditorSelection.range(range.from - len, range.to - len)
+			};
+			return {
+				changes: [{
+					from: range.from,
+					insert: marker
+				}, {
+					from: range.to,
+					insert: marker
+				}],
+				range: EditorSelection.range(range.from, range.to + len * 2)
+			};
+		});
+		view.dispatch(changes);
+		return true;
+	};
+}
+const BQ_RE = /^(\s*)>\s?/;
+function toggleBlockquote(view) {
+	if (isInsideCodeBlock(view)) return false;
+	const { state } = view;
+	const changes = state.changeByRange((range) => {
+		const fromLine = state.doc.lineAt(range.from);
+		const toLine = state.doc.lineAt(range.to);
+		const edits = [];
+		let allQuoted = true;
+		for (let num = fromLine.number; num <= toLine.number; num++) {
+			const line = state.doc.line(num);
+			if (!BQ_RE.test(line.text)) {
+				allQuoted = false;
+				break;
+			}
+		}
+		for (let num = fromLine.number; num <= toLine.number; num++) {
+			const line = state.doc.line(num);
+			if (allQuoted) {
+				const match = line.text.match(BQ_RE);
+				edits.push({
+					from: line.from,
+					to: line.from + match[0].length,
+					insert: match[1]
+				});
+			} else if (!BQ_RE.test(line.text)) {
+				const indent = line.text.match(/^(\s*)/)[1];
+				edits.push({
+					from: line.from + indent.length,
+					to: line.from + indent.length,
+					insert: "> "
+				});
+			}
+		}
+		if (edits.length === 0) return {
+			changes: [],
+			range
+		};
+		const firstDelta = edits[0].insert.length - (edits[0].to - edits[0].from);
+		const totalDelta = edits.reduce((sum, e) => sum + e.insert.length - (e.to - e.from), 0);
+		const newFrom = Math.max(0, range.from + firstDelta);
+		return {
+			changes: edits,
+			range: range.empty ? EditorSelection.cursor(newFrom) : EditorSelection.range(newFrom, Math.max(newFrom, range.to + totalDelta))
+		};
+	});
+	view.dispatch(changes);
+	return true;
+}
+/**
+* Find the offset where content begins after any blockquote markers on a line.
+* Uses the syntax tree to detect `QuoteMark` nodes, handling nested blockquotes.
+*/
+function getBlockContentOffset(state, lineFrom, lineTo) {
+	const tree = syntaxTree(state);
+	let lastQuoteEnd = lineFrom;
+	let foundQuote = false;
+	tree.iterate({
+		from: lineFrom,
+		to: lineTo,
+		enter(node) {
+			if (node.name === "QuoteMark" && node.from >= lineFrom && node.to <= lineTo) {
+				foundQuote = true;
+				lastQuoteEnd = node.to;
+			}
+		}
+	});
+	if (!foundQuote) return 0;
+	const doc = state.doc;
+	let offset = lastQuoteEnd;
+	while (offset < lineTo && doc.sliceString(offset, offset + 1) === " ") offset++;
+	return offset - lineFrom;
+}
+function toggleHeading(level) {
+	return (view) => {
+		if (isInsideCodeBlock(view)) return false;
+		const { state } = view;
+		const line = state.doc.lineAt(state.selection.main.from);
+		const contentOffset = getBlockContentOffset(state, line.from, line.to);
+		const headingMatch = line.text.slice(contentOffset).match(/^(#{1,6})\s/);
+		const prefix = "#".repeat(level) + " ";
+		const contentFrom = line.from + contentOffset;
+		const cursorPos = state.selection.main.from;
+		if (headingMatch && headingMatch[1].length === level) {
+			const delta = -headingMatch[0].length;
+			view.dispatch({
+				changes: {
+					from: contentFrom,
+					to: contentFrom + headingMatch[0].length,
+					insert: ""
+				},
+				selection: EditorSelection.cursor(Math.max(contentFrom, cursorPos + delta))
+			});
+		} else if (headingMatch) {
+			const delta = prefix.length - headingMatch[0].length;
+			view.dispatch({
+				changes: {
+					from: contentFrom,
+					to: contentFrom + headingMatch[0].length,
+					insert: prefix
+				},
+				selection: EditorSelection.cursor(Math.max(contentFrom + prefix.length, cursorPos + delta))
+			});
+		} else view.dispatch({
+			changes: {
+				from: contentFrom,
+				to: contentFrom,
+				insert: prefix
+			},
+			selection: EditorSelection.cursor(Math.max(contentFrom + prefix.length, cursorPos + prefix.length))
+		});
+		return true;
+	};
+}
+const TASK_RE = /^(\s*)[-*+]\s\[([ xX])\]\s/;
+const UL_RE = /^(\s*)[-*+]\s/;
+const OL_RE = /^(\s*)\d+\.\s/;
+function detectListKind(state, pos, contentText) {
+	const indent = contentText.match(/^(\s*)/)[1];
+	if (!UL_RE.test(contentText) && !OL_RE.test(contentText) && !TASK_RE.test(contentText)) return {
+		kind: "none",
+		indent: ""
+	};
+	let node = syntaxTree(state).resolveInner(pos, 1);
+	while (node) {
+		if (node.name === "ListItem" && node.getChild("Task")) return {
+			kind: "task",
+			indent
+		};
+		if (node.name === "BulletList" || node.name === "OrderedList") return {
+			kind: node.name === "BulletList" ? "ul" : "ol",
+			indent
+		};
+		if (!node.parent) break;
+		node = node.parent;
+	}
+	return {
+		kind: "none",
+		indent: ""
+	};
+}
+function stripListPrefix(lineText) {
+	return lineText.replace(/^(\s*)(?:[-*+]\s\[([ xX])\]\s|[-*+]\s|\d+\.\s)/, "$1");
+}
+function toggleListKind(target) {
+	return (view) => {
+		if (isInsideCodeBlock(view)) return false;
+		const { state } = view;
+		const changes = state.changeByRange((range) => {
+			const fromLine = state.doc.lineAt(range.from);
+			const toLine = state.doc.lineAt(range.to);
+			const edits = [];
+			let olIdx = 1;
+			for (let num = fromLine.number; num <= toLine.number; num++) {
+				const line = state.doc.line(num);
+				const bqOffset = getBlockContentOffset(state, line.from, line.to);
+				const content = line.text.slice(bqOffset);
+				const { kind, indent } = detectListKind(state, line.from + bqOffset, content);
+				const stripped = stripListPrefix(content);
+				let newPrefix;
+				if (kind === target) newPrefix = indent;
+				else switch (target) {
+					case "ul":
+						newPrefix = `${indent}- `;
+						break;
+					case "ol":
+						newPrefix = `${indent}${olIdx++}. `;
+						break;
+					case "task":
+						newPrefix = `${indent}- [ ] `;
+						break;
+					default: newPrefix = indent;
+				}
+				const newContent = newPrefix + stripped.slice(indent.length);
+				const newLine = line.text.slice(0, bqOffset) + newContent;
+				if (newLine !== line.text) edits.push({
+					from: line.from,
+					to: line.to,
+					insert: newLine
+				});
+			}
+			if (edits.length === 0) return {
+				changes: [],
+				range
+			};
+			const firstDelta = edits[0].insert.length - (edits[0].to - edits[0].from);
+			const totalDelta = edits.reduce((sum, e) => sum + e.insert.length - (e.to - e.from), 0);
+			const newFrom = Math.max(0, range.from + firstDelta);
+			return {
+				changes: edits,
+				range: range.empty ? EditorSelection.cursor(newFrom) : EditorSelection.range(newFrom, Math.max(newFrom, range.to + totalDelta))
+			};
+		});
+		view.dispatch(changes);
+		return true;
+	};
+}
+function toggleTaskCheck(view) {
+	if (isInsideCodeBlock(view)) return false;
+	const { state } = view;
+	const changes = state.changeByRange((range) => {
+		const fromLine = state.doc.lineAt(range.from);
+		const toLine = state.doc.lineAt(range.to);
+		const edits = [];
+		for (let num = fromLine.number; num <= toLine.number; num++) {
+			const line = state.doc.line(num);
+			const match = line.text.match(TASK_RE);
+			if (!match) continue;
+			const isChecked = match[2] !== " ";
+			const bracketStart = line.from + line.text.indexOf("[");
+			edits.push({
+				from: bracketStart,
+				to: bracketStart + 3,
+				insert: isChecked ? "[ ]" : "[x]"
+			});
+		}
+		if (edits.length === 0) return {
+			changes: [],
+			range
+		};
+		return {
+			changes: edits,
+			range
+		};
+	});
+	view.dispatch(changes);
+	return true;
+}
+function findLinkAtCursor(state, pos) {
+	let node = syntaxTree(state).resolveInner(pos, -1);
+	while (node) {
+		if (node.name === "Link") {
+			const from = node.from;
+			const to = node.to;
+			const full = state.sliceDoc(from, to);
+			const labelStart = full.indexOf("[");
+			const labelEnd = full.indexOf("]");
+			const urlStart = full.indexOf("(", labelEnd);
+			const urlEnd = full.lastIndexOf(")");
+			if (labelStart === -1 || labelEnd === -1 || urlStart === -1 || urlEnd === -1) return null;
+			return {
+				from,
+				to,
+				label: full.slice(labelStart + 1, labelEnd),
+				url: full.slice(urlStart + 1, urlEnd)
+			};
+		}
+		if (!node.parent) break;
+		node = node.parent;
+	}
+	return null;
+}
+/** Insert a markdown link into the editor, replacing `from..to`. */
+function insertLink(view, from, to, label, url) {
+	const insert = `[${label}](${url})`;
+	view.dispatch({
+		changes: {
+			from,
+			to,
+			insert
+		},
+		selection: EditorSelection.cursor(from + insert.length)
+	});
+	view.focus();
+}
+function parseFenceInfo(info) {
+	const parts = info.trim().split(/\s+/);
+	let lang = "";
+	let filename = "";
+	for (const part of parts) if (part.startsWith("filename=")) filename = part.slice(9);
+	else if (!lang) lang = part;
+	return {
+		lang,
+		filename
+	};
+}
+function findCodeFenceAtCursor(view) {
+	const { state } = view;
+	const pos = state.selection.main.from;
+	let node = syntaxTree(state).resolveInner(pos, -1);
+	while (node) {
+		if (node.name === "FencedCode") {
+			const fenceLine = state.doc.lineAt(node.from);
+			const infoNode = node.getChild("CodeInfo");
+			const { lang, filename } = parseFenceInfo(infoNode ? state.sliceDoc(infoNode.from, infoNode.to) : "");
+			return {
+				fenceLine: {
+					from: fenceLine.from,
+					to: fenceLine.to
+				},
+				lang,
+				filename
+			};
+		}
+		if (!node.parent) break;
+		node = node.parent;
+	}
+	return null;
+}
+/** Apply code block settings. For existing blocks, replaces the fence line. For new blocks, inserts a fenced block. */
+function applyCodeBlock(view, data, lang, filename) {
+	const info = [lang, filename ? `filename=${filename}` : ""].filter(Boolean).join(" ");
+	if (data.isNew) {
+		const insert = `\`\`\`${info}\n\n\`\`\``;
+		const pos = data.insertPos;
+		view.dispatch({
+			changes: {
+				from: pos,
+				to: pos,
+				insert
+			},
+			selection: EditorSelection.cursor(pos + 3 + info.length + 1)
+		});
+	} else {
+		const fenceLine = `\`\`\`${info}`;
+		view.dispatch({ changes: {
+			from: data.fenceFrom,
+			to: data.fenceTo,
+			insert: fenceLine
+		} });
+	}
+	view.focus();
+}
+//#endregion
+export { applyCodeBlock, findCodeFenceAtCursor, findLinkAtCursor, insertLink, toggleBlockquote, toggleHeading, toggleListKind, toggleMarker, toggleTaskCheck };

package/dist/core/editor.d.ts

@@ -0,0 +1,25 @@
+import { EditorView } from "@codemirror/view";
+import { Compartment, EditorState, Extension } from "@codemirror/state";
+
+//#region src/core/editor.d.ts
+interface CreateEditorStateOptions {
+  doc?: string;
+  onUpdate?: (doc: string) => void;
+  /** Additional extensions (e.g. custom plugins) */
+  plugins?: Extension[];
+  placeholder?: string;
+  readOnly?: boolean;
+  /** When false, default plugins are NOT included. Defaults to true. */
+  includeDefaultPlugins?: boolean;
+}
+/** Compartment for swapping the markdown extension after lazy-loading language support */
+declare const markdownCompartment: Compartment;
+/** Compartment for toggling editable state */
+declare const editableCompartment: Compartment;
+/** Default set of all plugins */
+declare function defaultPlugins(): Extension;
+declare function createEditorState(options: CreateEditorStateOptions): EditorState;
+/** Lazy-load code language support and reconfigure the markdown extension */
+declare function loadLanguageSupport(view: EditorView): void;
+//#endregion
+export { CreateEditorStateOptions, createEditorState, defaultPlugins, editableCompartment, loadLanguageSupport, markdownCompartment };

package/dist/core/editor.js

@@ -0,0 +1,102 @@
+import { activeMarksPlugin } from "./active-marks.js";
+import { editorTheme, highlightStyle } from "./highlight-style.js";
+import { fieldNotifier } from "./field-notifier.js";
+import { popoverField } from "./popover.js";
+import { inlinePlugin } from "./plugins/inline.js";
+import { headingPlugin } from "./plugins/heading.js";
+import { listPlugin } from "./plugins/list.js";
+import { blockquotePlugin } from "./plugins/blockquote.js";
+import { linkPlugin } from "./plugins/link.js";
+import { codeBlockPlugin } from "./plugins/code-block.js";
+import { tablePlugin } from "./plugins/table.js";
+import { bracketPlugin } from "./plugins/bracket.js";
+import "./plugins.js";
+import { EditorView, keymap, placeholder } from "@codemirror/view";
+import { syntaxHighlighting } from "@codemirror/language";
+import { Compartment, EditorSelection, EditorState } from "@codemirror/state";
+import { markdown, markdownLanguage } from "@codemirror/lang-markdown";
+import { defaultKeymap, history, historyKeymap } from "@codemirror/commands";
+import { styleTags, tags } from "@lezer/highlight";
+//#region src/core/editor.ts
+/** Compartment for swapping the markdown extension after lazy-loading language support */
+const markdownCompartment = new Compartment();
+/** Compartment for toggling editable state */
+const editableCompartment = new Compartment();
+const markdownStyleTags = { props: [styleTags({
+	ListMark: tags.processingInstruction,
+	QuoteMark: tags.processingInstruction,
+	TaskMarker: tags.processingInstruction,
+	CodeText: tags.content
+})] };
+/** Select the word under the cursor. Does nothing if there is already a selection. */
+function selectWord(view) {
+	const main = view.state.selection.main;
+	if (!main.empty) return false;
+	const word = view.state.wordAt(main.head);
+	if (!word) return false;
+	view.dispatch({ selection: EditorSelection.single(word.from, word.to) });
+	return true;
+}
+/** Default set of all plugins */
+function defaultPlugins() {
+	return [
+		inlinePlugin(),
+		headingPlugin(),
+		listPlugin(),
+		blockquotePlugin(),
+		linkPlugin(),
+		codeBlockPlugin(),
+		tablePlugin(),
+		bracketPlugin()
+	];
+}
+function createEditorState(options) {
+	const { doc = "", onUpdate, plugins = [], placeholder: placeholder$1 = "", readOnly = false, includeDefaultPlugins = true } = options;
+	const extensions = [
+		editableCompartment.of(EditorView.editable.of(!readOnly)),
+		...includeDefaultPlugins ? [defaultPlugins()] : [],
+		...plugins,
+		keymap.of([
+			{
+				key: "Mod-d",
+				run: selectWord,
+				preventDefault: true
+			},
+			...defaultKeymap,
+			...historyKeymap
+		]),
+		history(),
+		popoverField,
+		activeMarksPlugin,
+		fieldNotifier(),
+		markdownCompartment.of(markdown({
+			base: markdownLanguage,
+			extensions: markdownStyleTags,
+			addKeymap: true
+		})),
+		syntaxHighlighting(highlightStyle),
+		editorTheme,
+		EditorView.lineWrapping
+	];
+	if (placeholder$1) extensions.push(placeholder(placeholder$1));
+	if (onUpdate) extensions.push(EditorView.updateListener.of((update) => {
+		if (update.docChanged) onUpdate(update.state.doc.toString());
+	}));
+	return EditorState.create({
+		doc,
+		extensions
+	});
+}
+/** Lazy-load code language support and reconfigure the markdown extension */
+function loadLanguageSupport(view) {
+	import("@codemirror/language-data").then(({ languages }) => {
+		view.dispatch({ effects: markdownCompartment.reconfigure(markdown({
+			base: markdownLanguage,
+			codeLanguages: languages,
+			extensions: markdownStyleTags,
+			addKeymap: true
+		})) });
+	});
+}
+//#endregion
+export { createEditorState, defaultPlugins, editableCompartment, loadLanguageSupport, markdownCompartment };