@prosemark/core 0.0.0 → 0.0.3

package/dist/main.js

@@ -0,0 +1,875 @@
+import { Decoration, EditorView, EditorView as EditorView$1, ViewPlugin, WidgetType, dropCursor, keymap } from "@codemirror/view";
+import { CharCategory, EditorSelection, EditorState, Facet, RangeSetBuilder, StateField, findClusterBreak } from "@codemirror/state";
+import { HighlightStyle, bracketMatching, foldGutter, foldKeymap, indentOnInput, syntaxHighlighting, syntaxTree } from "@codemirror/language";
+import { defaultKeymap, history, historyKeymap, indentWithTab } from "@codemirror/commands";
+import { searchKeymap } from "@codemirror/search";
+import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap } from "@codemirror/autocomplete";
+import { lintKeymap } from "@codemirror/lint";
+import { Tag, styleTags, tags } from "@lezer/highlight";
+import * as emoji from "node-emoji";
+
+//#region lib/utils.ts
+function stateWORDAt(state, pos) {
+	const { text, from, length } = state.doc.lineAt(pos);
+	const cat = state.charCategorizer(pos);
+	let start = pos - from, end = pos - from;
+	while (start > 0) {
+		const prev = findClusterBreak(text, start, false);
+		if (cat(text.slice(prev, start)) === CharCategory.Space) break;
+		start = prev;
+	}
+	while (end < length) {
+		const next = findClusterBreak(text, end);
+		if (cat(text.slice(end, next)) === CharCategory.Space) break;
+		end = next;
+	}
+	return start == end ? null : EditorSelection.range(start + from, end + from);
+}
+function rangeTouchesRange(a, b) {
+	return a.from <= b.to && b.from <= a.to;
+}
+function selectionTouchesRange(selection, b) {
+	return selection.some((range) => rangeTouchesRange(range, b));
+}
+function iterChildren(cursor, enter) {
+	if (!cursor.firstChild()) return;
+	do
+		if (enter(cursor)) break;
+	while (cursor.nextSibling());
+	console.assert(cursor.parent());
+}
+function eventHandlersWithClass(handlers) {
+	return Object.fromEntries(Object.entries(handlers).filter(([_event, handlers$1]) => !!handlers$1).map(([event, handlers$1]) => [event, function(ev, view) {
+		const res = [];
+		for (const className in handlers$1) if (ev.composedPath().some((el) => {
+			if (!(el instanceof Element)) return false;
+			return el.classList.contains(className);
+		})) res.push(handlers$1[className]?.call(this, ev, view));
+		return res.some((res$1) => !!res$1);
+	}]));
+}
+
+//#endregion
+//#region lib/hide/core.ts
+const hideTheme = EditorView.theme({ ".cm-hidden-token": { fontSize: "0px" } });
+const hideInlineDecoration = Decoration.mark({ class: "cm-hidden-token" });
+const hideBlockDecoration = Decoration.replace({ block: true });
+const buildDecorations$1 = (state) => {
+	const decorations = [];
+	const specs = state.facet(hidableNodeFacet);
+	syntaxTree(state).iterate({ enter: (node) => {
+		if (state.selection.ranges.some((range) => rangeTouchesRange(node, range))) return;
+		for (const spec of specs) {
+			if (spec.nodeName instanceof Function) {
+				if (!spec.nodeName(node.type.name)) continue;
+			} else if (spec.nodeName instanceof Array) {
+				if (!spec.nodeName.includes(node.type.name)) continue;
+			} else if (node.type.name !== spec.nodeName) continue;
+			if (spec.unhideZone) {
+				const res = spec.unhideZone(state, node);
+				if (state.selection.ranges.some((range) => rangeTouchesRange(res, range))) return;
+			}
+			if (spec.onHide) {
+				const res = spec.onHide(state, node);
+				if (res instanceof Array) decorations.push(...res);
+				else if (res) decorations.push(res);
+			}
+			if (spec.subNodeNameToHide) {
+				let names;
+				if (!Array.isArray(spec.subNodeNameToHide)) names = [spec.subNodeNameToHide];
+				else names = spec.subNodeNameToHide;
+				const cursor = node.node.cursor();
+				console.assert(cursor.firstChild(), "A hide node must have children");
+				do
+					if (names.includes(cursor.type.name)) decorations.push((spec.block ? hideBlockDecoration : hideInlineDecoration).range(cursor.from, cursor.to));
+				while (cursor.nextSibling());
+			}
+		}
+	} });
+	return Decoration.set(decorations, true);
+};
+const hideExtension = StateField.define({
+	create(state) {
+		return buildDecorations$1(state);
+	},
+	update(deco, tr) {
+		if (tr.docChanged || tr.selection) return buildDecorations$1(tr.state);
+		return deco.map(tr.changes);
+	},
+	provide: (f) => [EditorView.decorations.from(f), hideTheme]
+});
+const hidableNodeFacet = Facet.define({
+	combine(value) {
+		return [...value];
+	},
+	enables: hideExtension
+});
+
+//#endregion
+//#region lib/markdownTags.ts
+const markdownTags = {
+	headerMark: Tag.define(),
+	inlineCode: Tag.define(),
+	fencedCode: Tag.define(),
+	linkURL: Tag.define(),
+	escapeMark: Tag.define(),
+	emoji: Tag.define(),
+	emojiMark: Tag.define(),
+	listMark: Tag.define()
+};
+
+//#endregion
+//#region lib/hide/index.ts
+const renderedLinkDecoration = Decoration.mark({ class: "cm-rendered-link" });
+const defaultHidableSpecs = [
+	{
+		nodeName: (name) => name.startsWith("ATXHeading"),
+		onHide: (_view, node) => {
+			const headerMark = node.node.firstChild;
+			return hideInlineDecoration.range(headerMark.from, Math.min(headerMark.to + 1, node.to));
+		}
+	},
+	{
+		nodeName: (name) => name.startsWith("SetextHeading"),
+		subNodeNameToHide: "HeaderMark",
+		block: true
+	},
+	{
+		nodeName: ["StrongEmphasis", "Emphasis"],
+		subNodeNameToHide: "EmphasisMark"
+	},
+	{
+		nodeName: "InlineCode",
+		subNodeNameToHide: "CodeMark"
+	},
+	{
+		nodeName: "Link",
+		subNodeNameToHide: ["LinkMark", "URL"],
+		onHide: (_state, node) => {
+			return renderedLinkDecoration.range(node.from, node.to);
+		}
+	},
+	{
+		nodeName: "Strikethrough",
+		subNodeNameToHide: "StrikethroughMark"
+	},
+	{
+		nodeName: "Escape",
+		subNodeNameToHide: "EscapeMark",
+		unhideZone: (state, node) => {
+			const WORDAt = stateWORDAt(state, node.from);
+			if (WORDAt && WORDAt.to > node.from + 1) return WORDAt;
+			return state.doc.lineAt(node.from);
+		}
+	},
+	{
+		nodeName: "FencedCode",
+		subNodeNameToHide: ["CodeMark", "CodeInfo"]
+	},
+	{
+		nodeName: "Blockquote",
+		subNodeNameToHide: "QuoteMark"
+	}
+];
+const defaultHideExtensions = defaultHidableSpecs.map((spec) => hidableNodeFacet.of(spec));
+const escapeMarkdownSyntaxExtension = {
+	defineNodes: [{
+		name: "EscapeMark",
+		style: markdownTags.escapeMark
+	}],
+	parseInline: [{
+		name: "EscapeMark",
+		parse: (cx, next, pos) => {
+			if (next !== 92) return -1;
+			return cx.addElement(cx.elt("Escape", pos, pos + 2, [cx.elt("EscapeMark", pos, pos + 1)]));
+		},
+		before: "Escape"
+	}]
+};
+
+//#endregion
+//#region lib/fold/core.ts
+const buildDecorations = (state) => {
+	const decorations = [];
+	const specs = state.facet(foldableSyntaxFacet);
+	syntaxTree(state).iterate({ enter: (node) => {
+		if (selectionTouchesRange(state.selection.ranges, node)) return;
+		for (const spec of specs) {
+			const lineage = [];
+			let node_ = node;
+			while (node_) {
+				lineage.push(node_.name);
+				node_ = node_.node.parent;
+			}
+			const path = lineage.reverse().join("/");
+			if (spec.nodePath instanceof Function) {
+				if (!spec.nodePath(path)) continue;
+			} else if (spec.nodePath instanceof Array) {
+				if (!spec.nodePath.some((testPath) => path.endsWith(testPath))) continue;
+			} else if (!path.endsWith(spec.nodePath)) continue;
+			if (spec.unfoldZone) {
+				if (selectionTouchesRange(state.selection.ranges, spec.unfoldZone(state, node))) return;
+			}
+			if (spec.onFold) {
+				const res = spec.onFold(state, node);
+				if (res instanceof Array) decorations.push(...res);
+				else if (res) decorations.push(res);
+			}
+		}
+	} });
+	return Decoration.set(decorations, true);
+};
+const foldDecorationExtension = StateField.define({
+	create(state) {
+		return buildDecorations(state);
+	},
+	update(deco, tr) {
+		if (tr.docChanged || tr.selection) return buildDecorations(tr.state);
+		return deco.map(tr.changes);
+	},
+	provide: (f) => [EditorView.decorations.from(f)]
+});
+const foldExtension = [foldDecorationExtension];
+const foldableSyntaxFacet = Facet.define({
+	combine(value) {
+		return [...value];
+	},
+	enables: foldExtension
+});
+const selectAllDecorationsOnSelectExtension = (widgetClass) => EditorView.domEventHandlers(eventHandlersWithClass({ mousedown: { [widgetClass]: (e, view) => {
+	const ranges = view.state.selection.ranges;
+	if (ranges.length === 0 || ranges[0]?.anchor !== ranges[0]?.head) return;
+	const target = e.target;
+	const pos = view.posAtDOM(target);
+	view.state.field(foldDecorationExtension).between(pos, pos, (from, to) => {
+		setTimeout(() => {
+			view.dispatch({ selection: EditorSelection.single(to, from) });
+		}, 0);
+		return false;
+	});
+} } }));
+
+//#endregion
+//#region lib/fold/bulletList.ts
+var BulletPoint = class extends WidgetType {
+	toDOM() {
+		const span = document.createElement("span");
+		span.className = "cm-rendered-list-mark";
+		span.innerHTML = "•";
+		return span;
+	}
+	ignoreEvent(_event) {
+		return false;
+	}
+};
+const bulletListExtension = foldableSyntaxFacet.of({
+	nodePath: "BulletList/ListItem/ListMark",
+	onFold: (_state, node) => {
+		const cursor = node.node.cursor();
+		if (cursor.nextSibling() && cursor.name === "Task") return;
+		return Decoration.replace({ widget: new BulletPoint() }).range(node.from, node.to);
+	}
+});
+
+//#endregion
+//#region lib/fold/emoji.ts
+const emojiDelimiter = {
+	resolve: "Emoji",
+	mark: "EmojiMark"
+};
+const emojiMarkdownSyntaxExtension = {
+	defineNodes: [{
+		name: "Emoji",
+		style: markdownTags.emoji
+	}, {
+		name: "EmojiMark",
+		style: markdownTags.emojiMark
+	}],
+	parseInline: [{
+		name: "Emoji",
+		parse: (cx, next, pos) => {
+			if (next !== 58) return -1;
+			const open = /^\w+:/.test(cx.slice(pos + 1, cx.end));
+			const close = /:\w+$/.test(cx.slice(cx.offset, pos));
+			if (!open && !close) return -1;
+			return cx.addDelimiter(emojiDelimiter, pos, pos + 1, open, close);
+		},
+		before: "Emphasis"
+	}]
+};
+var EmojiWidget = class extends WidgetType {
+	constructor(emoji$1) {
+		super();
+		this.emoji = emoji$1;
+	}
+	toDOM() {
+		const span = document.createElement("span");
+		span.className = "cm-emoji";
+		span.innerHTML = this.emoji;
+		return span;
+	}
+};
+const emojiExtension = foldableSyntaxFacet.of({
+	nodePath: "Emoji",
+	onFold: (state, node) => {
+		const emojiName = state.doc.sliceString(node.from + 1, node.to - 1);
+		const emoji_ = emoji.get(emojiName);
+		if (!emoji_) return;
+		return Decoration.replace({ widget: new EmojiWidget(emoji_) }).range(node.from, node.to);
+	}
+});
+
+//#endregion
+//#region lib/fold/horizontalRule.ts
+var HorizontalRuleWidget = class extends WidgetType {
+	toDOM() {
+		const div = document.createElement("div");
+		div.className = "cm-horizontal-rule-container";
+		const hr = document.createElement("hr");
+		div.appendChild(hr);
+		return div;
+	}
+	ignoreEvent(_event) {
+		return false;
+	}
+	destroy(dom) {
+		dom.remove();
+	}
+};
+const horizontalRuleTheme = EditorView.theme({ ".cm-horizontal-rule-container": {
+	height: "1.4em",
+	display: "flow-root",
+	"align-items": "center",
+	padding: "0 2px 0 6px"
+} });
+const horizonalRuleExtension = [
+	foldableSyntaxFacet.of({
+		nodePath: "HorizontalRule",
+		onFold: (_state, node) => {
+			return Decoration.replace({
+				widget: new HorizontalRuleWidget(),
+				block: true,
+				inclusiveStart: true
+			}).range(node.from, node.to);
+		}
+	}),
+	horizontalRuleTheme,
+	selectAllDecorationsOnSelectExtension("cm-horizontal-rule-container")
+];
+
+//#endregion
+//#region lib/fold/image.ts
+var ImageWidget = class extends WidgetType {
+	constructor(url) {
+		super();
+		this.url = url;
+	}
+	toDOM() {
+		const span = document.createElement("span");
+		span.className = "cm-image";
+		if (this.url) span.innerHTML = `<img src="${this.url}" />`;
+		return span;
+	}
+	ignoreEvent(_event) {
+		return false;
+	}
+};
+const imageExtension = [foldableSyntaxFacet.of({
+	nodePath: "Image",
+	onFold: (state, node) => {
+		let imageUrl;
+		iterChildren(node.node.cursor(), (node$1) => {
+			if (node$1.name === "URL") imageUrl = state.doc.sliceString(node$1.from, node$1.to);
+		});
+		if (imageUrl) return Decoration.replace({ widget: new ImageWidget(imageUrl) }).range(node.from, node.to);
+	}
+}), selectAllDecorationsOnSelectExtension("cm-image")];
+
+//#endregion
+//#region lib/fold/task.ts
+var Checkbox = class extends WidgetType {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	toDOM() {
+		const el = document.createElement("input");
+		el.type = "checkbox";
+		el.className = "cm-checkbox";
+		el.checked = this.value;
+		return el;
+	}
+	ignoreEvent(_event) {
+		return false;
+	}
+};
+const taskExtension = [foldableSyntaxFacet.of({
+	nodePath: "BulletList/ListItem/Task/TaskMarker",
+	onFold: (state, node) => {
+		const value = state.doc.sliceString(node.from + 1, node.to - 1).toLowerCase() === "x";
+		return Decoration.replace({ widget: new Checkbox(value) }).range(node.from - 2, node.to);
+	},
+	unfoldZone: (_state, node) => ({
+		from: node.from - 2,
+		to: node.to
+	})
+}), EditorView.domEventHandlers(eventHandlersWithClass({ mousedown: { "cm-checkbox": (ev, view) => {
+	const pos = view.posAtDOM(ev.target);
+	const change = {
+		from: pos + 3,
+		to: pos + 4,
+		insert: ev.target.checked ? " " : "x"
+	};
+	view.dispatch({ changes: change });
+	return true;
+} } }))];
+
+//#endregion
+//#region lib/fold/blockQuote.ts
+var BlockQuoteVerticalLine = class extends WidgetType {
+	toDOM() {
+		const span = document.createElement("span");
+		span.className = "cm-blockquote-vertical-line";
+		return span;
+	}
+	ignoreEvent(_event) {
+		return false;
+	}
+};
+const blockQuoteExtension = foldableSyntaxFacet.of({
+	nodePath: (nodePath) => nodePath.endsWith("Blockquote/QuoteMark") || nodePath.endsWith("Blockquote/Paragraph/QuoteMark"),
+	onFold: (_state, node) => {
+		return Decoration.replace({ widget: new BlockQuoteVerticalLine() }).range(node.from, node.to);
+	}
+});
+
+//#endregion
+//#region lib/syntaxHighlighting.ts
+const additionalMarkdownSyntaxTags = {
+	defineNodes: [],
+	props: [styleTags({
+		HeaderMark: markdownTags.headerMark,
+		FencedCode: markdownTags.fencedCode,
+		InlineCode: markdownTags.inlineCode,
+		URL: markdownTags.linkURL,
+		ListMark: markdownTags.listMark
+	})]
+};
+const headingTagStyles = (fontSizes) => fontSizes.map((fontSize, i) => ({
+	tag: tags[`heading${(i + 1).toString()}`],
+	fontSize,
+	fontWeight: "bold"
+}));
+const baseSyntaxHighlights = syntaxHighlighting(HighlightStyle.define([
+	...headingTagStyles([
+		"1.6em",
+		"1.4em",
+		"1.2em",
+		null,
+		null,
+		null
+	]),
+	{
+		tag: markdownTags.headerMark,
+		color: "var(--pm-header-mark-color)"
+	},
+	{
+		tag: tags.strong,
+		fontWeight: "bold"
+	},
+	{
+		tag: tags.emphasis,
+		fontStyle: "italic"
+	},
+	{
+		tag: tags.strikethrough,
+		textDecoration: "line-through"
+	},
+	{
+		tag: tags.meta,
+		color: "var(--pm-muted-color)"
+	},
+	{
+		tag: tags.comment,
+		color: "var(--pm-muted-color)"
+	},
+	{
+		tag: markdownTags.listMark,
+		color: "var(--pm-muted-color)"
+	},
+	{
+		tag: markdownTags.escapeMark,
+		color: "var(--pm-muted-color)"
+	},
+	{
+		tag: markdownTags.inlineCode,
+		fontFamily: "monospace",
+		padding: "0.2rem",
+		borderRadius: "0.4rem",
+		fontSize: "0.8rem",
+		backgroundColor: "var(--pm-code-background-color)"
+	},
+	{
+		tag: markdownTags.linkURL,
+		color: "var(--pm-link-color)",
+		textDecoration: "underline",
+		cursor: "pointer"
+	}
+]));
+const baseTheme = EditorView.theme({
+	".cm-content": {
+		fontFamily: "var(--font)",
+		fontSize: "0.9rem",
+		caretColor: "var(--pm-cursor-color)"
+	},
+	".cm-editor .cm-cursor, .cm-editor .cm-dropCursor": { borderLeftColor: "var(--pm-cursor-color)" },
+	"&.cm-focused": { outline: "none" },
+	".cm-gutters": {
+		backgroundColor: "transparent",
+		border: "none"
+	},
+	".cm-rendered-link": {
+		textDecoration: "underline",
+		cursor: "pointer",
+		color: "var(--pm-link-color)"
+	},
+	".cm-rendered-list-mark": {
+		color: "var(--pm-muted-color)",
+		margin: "0 0.2em"
+	},
+	".cm-blockquote-vertical-line": {
+		display: "inline-block",
+		width: "4px",
+		marginRight: "4px",
+		marginLeft: "4px",
+		height: "1.4em",
+		verticalAlign: "bottom",
+		backgroundColor: "var(--pm-blockquote-vertical-line-background-color)"
+	}
+});
+const generalSyntaxHighlights = syntaxHighlighting(HighlightStyle.define([
+	{
+		tag: tags.link,
+		color: "var(--pm-syntax-link)"
+	},
+	{
+		tag: tags.keyword,
+		color: "var(--pm-syntax-keyword)"
+	},
+	{
+		tag: [
+			tags.atom,
+			tags.bool,
+			tags.url,
+			tags.contentSeparator,
+			tags.labelName
+		],
+		color: "var(--pm-syntax-atom)"
+	},
+	{
+		tag: [tags.literal, tags.inserted],
+		color: "var(--pm-syntax-literal)"
+	},
+	{
+		tag: [tags.string, tags.deleted],
+		color: "var(--pm-syntax-string)"
+	},
+	{
+		tag: [
+			tags.regexp,
+			tags.escape,
+			tags.special(tags.string)
+		],
+		color: "var(--pm-syntax-regexp)"
+	},
+	{
+		tag: tags.definition(tags.variableName),
+		color: "var(--pm-syntax-definition-variable)"
+	},
+	{
+		tag: tags.local(tags.variableName),
+		color: "var(--pm-syntax-local-variable)"
+	},
+	{
+		tag: [tags.typeName, tags.namespace],
+		color: "var(--pm-syntax-type-namespace)"
+	},
+	{
+		tag: tags.className,
+		color: "var(--pm-syntax-class-name)"
+	},
+	{
+		tag: [tags.special(tags.variableName), tags.macroName],
+		color: "var(--pm-syntax-special-variable-macro)"
+	},
+	{
+		tag: tags.definition(tags.propertyName),
+		color: "var(--pm-syntax-definition-property)"
+	},
+	{
+		tag: tags.comment,
+		color: "var(--pm-syntax-comment)"
+	},
+	{
+		tag: tags.invalid,
+		color: "var(--pm-syntax-invalid)"
+	}
+]));
+const lightTheme = EditorView.theme({ ".cm-content": {
+	"--pm-cursor-color": "black",
+	"--pm-header-mark-color": "oklch(82.8% 0.111 230.318)",
+	"--pm-link-color": "oklch(58.8% 0.158 241.966)",
+	"--pm-muted-color": "oklch(37.2% 0.044 257.287)",
+	"--pm-code-background-color": "oklch(92.9% 0.013 255.508)",
+	"--pm-code-btn-background-color": "oklch(86.9% 0.022 252.894)",
+	"--pm-code-btn-hover-background-color": "oklch(70.4% 0.04 256.788)",
+	"--pm-blockquote-vertical-line-background-color": "oklch(70.4% 0.04 256.788)",
+	"--pm-syntax-link": "oklch(62.75% 0.188 259.38)",
+	"--pm-syntax-keyword": "oklch(58.13% 0.248 297.57)",
+	"--pm-syntax-atom": "oklch(51.29% 0.219 260.63)",
+	"--pm-syntax-literal": "oklch(57.38% 0.111 170.31)",
+	"--pm-syntax-string": "oklch(54.86% 0.184 25.53)",
+	"--pm-syntax-regexp": "oklch(65.88% 0.184 43.8)",
+	"--pm-syntax-definition-variable": "oklch(45.32% 0.171 260.3)",
+	"--pm-syntax-local-variable": "oklch(64.13% 0.09 184.42)",
+	"--pm-syntax-type-namespace": "oklch(49.1% 0.091 165.52)",
+	"--pm-syntax-class-name": "oklch(64.42% 0.11 168.83)",
+	"--pm-syntax-special-variable-macro": "oklch(52.58% 0.212 282.71)",
+	"--pm-syntax-definition-property": "oklch(42.1% 0.142 260.08)",
+	"--pm-syntax-comment": "oklch(62.79% 0.022 252.89)",
+	"--pm-syntax-invalid": "oklch(64.62% 0.203 29.2)"
+} });
+
+//#endregion
+//#region lib/clickLink.ts
+function getUrlFromLink(view, pos) {
+	const tree = syntaxTree(view.state);
+	let url;
+	tree.iterate({
+		to: pos,
+		from: pos,
+		enter(node) {
+			if (node.name !== "Link") return;
+			iterChildren(node.node.cursor(), (cursor) => {
+				if (cursor.name === "URL") {
+					url = view.state.doc.sliceString(cursor.from, cursor.to);
+					return true;
+				}
+			});
+			return true;
+		}
+	});
+	return url;
+}
+const clickLinkHandler = Facet.define();
+const defaultClickLinkHandler = clickLinkHandler.of((url) => {
+	window.open(url, "_blank");
+});
+const clickFullLinkExtension = EditorView$1.domEventHandlers(eventHandlersWithClass({ mousedown: { "cm-rendered-link": (e, view) => {
+	const pos = view.posAtCoords(e);
+	if (pos === null) return;
+	const url = getUrlFromLink(view, pos);
+	if (!url) return;
+	view.state.facet(clickLinkHandler).map((handler) => {
+		handler(url);
+	});
+} } }));
+const getRawUrl = (view, pos) => {
+	const tree = syntaxTree(view.state);
+	let url;
+	tree.iterate({
+		to: pos,
+		from: pos,
+		enter(node) {
+			if (node.name !== "URL") return;
+			if (node.node.parent?.name === "Link") return;
+			url = view.state.doc.sliceString(node.from, node.to);
+			return true;
+		}
+	});
+	return url;
+};
+const addClassToUrl = syntaxHighlighting(HighlightStyle.define([{
+	tag: markdownTags.linkURL,
+	class: "cm-url"
+}]));
+const clickRawUrlExtension = EditorView$1.domEventHandlers(eventHandlersWithClass({ mousedown: { "cm-url": (e, view) => {
+	const pos = view.posAtCoords(e);
+	if (pos === null) return;
+	const url = getRawUrl(view, pos);
+	if (!url) return;
+	view.state.facet(clickLinkHandler).map((handler) => {
+		handler(url);
+	});
+} } }));
+const clickLinkExtension = [
+	clickFullLinkExtension,
+	addClassToUrl,
+	clickRawUrlExtension
+];
+
+//#endregion
+//#region lib/codeFenceExtension.ts
+const codeBlockDecorations = (view) => {
+	const builder = new RangeSetBuilder();
+	const visited = /* @__PURE__ */ new Set();
+	for (const { from, to } of view.visibleRanges) syntaxTree(view.state).iterate({
+		from,
+		to,
+		enter: (node) => {
+			if (node.name === "FencedCode") {
+				const key = JSON.stringify([node.from, node.to]);
+				if (visited.has(key)) return;
+				visited.add(key);
+				let lang = "";
+				const codeInfoNode = node.node.getChild("CodeInfo");
+				if (codeInfoNode) lang = view.state.doc.sliceString(codeInfoNode.from, codeInfoNode.to).toUpperCase();
+				for (let pos = node.from; pos <= node.to;) {
+					const line = view.state.doc.lineAt(pos);
+					const isFirstLine = pos === node.from;
+					const isLastLine = line.to >= node.to;
+					builder.add(line.from, line.from, Decoration.line({ class: `cm-fenced-code-line ${isFirstLine ? "cm-fenced-code-line-first" : ""} ${isLastLine ? "cm-fenced-code-line-last" : ""}` }));
+					if (isFirstLine) builder.add(line.from, line.from, Decoration.widget({ widget: new CodeBlockInfoWidget(lang, view.state.doc.sliceString(line.to + 1, node.to - 4)) }));
+					pos = line.to + 1;
+				}
+			}
+		}
+	});
+	return builder.finish();
+};
+var CodeBlockInfoWidget = class extends WidgetType {
+	constructor(lang, code) {
+		super();
+		this.lang = lang;
+		this.code = code;
+	}
+	eq(other) {
+		return other.lang === this.lang && other.code === this.code;
+	}
+	toDOM() {
+		const container = document.createElement("div");
+		container.className = "cm-code-block-info";
+		const langContainer = document.createElement("span");
+		langContainer.className = "cm-code-block-lang-container";
+		langContainer.innerText = this.lang;
+		container.appendChild(langContainer);
+		const copyButton = document.createElement("button");
+		copyButton.className = "cm-code-block-copy-button";
+		copyButton.innerHTML = `
+      <svg xmlns="http://www.w3.org/2000/svg"
+        width="16" height="16" viewBox="0 0 24 24"
+        fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
+        class="lucide lucide-copy-icon lucide-copy">
+          <rect width="14" height="14" x="8" y="8" rx="2" ry="2"/>
+          <path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/>
+      </svg>`;
+		copyButton.onclick = () => {
+			navigator.clipboard.writeText(this.code);
+		};
+		container.appendChild(copyButton);
+		return container;
+	}
+};
+const codeBlockDecorationsExtension = ViewPlugin.fromClass(class {
+	decorations;
+	constructor(view) {
+		this.decorations = codeBlockDecorations(view);
+	}
+	update(update) {
+		if (update.docChanged || update.viewportChanged) this.decorations = codeBlockDecorations(update.view);
+	}
+}, { decorations: (v) => v.decorations });
+const codeFenceTheme = EditorView.theme({
+	".cm-fenced-code-line": {
+		display: "block",
+		marginLeft: "6px",
+		backgroundColor: "var(--pm-code-background-color)"
+	},
+	".cm-activeLine.cm-fenced-code-line": { backgroundColor: "var(--pm-code-background-color)" },
+	".cm-fenced-code-line-first": {
+		borderTopLeftRadius: "0.4rem",
+		borderTopRightRadius: "0.4rem"
+	},
+	".cm-fenced-code-line-last": {
+		borderBottomLeftRadius: "0.4rem",
+		borderBottomRightRadius: "0.4rem"
+	},
+	".cm-code-block-info": {
+		float: "right",
+		padding: "0.2rem",
+		display: "flex",
+		gap: "0.3rem",
+		alignItems: "center"
+	},
+	".cm-code-block-lang-container": {
+		fontSize: "0.8rem",
+		color: "var(--pm-muted-color)"
+	},
+	".cm-code-block-copy-button": {
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "center",
+		border: "none",
+		padding: "0.2rem",
+		borderRadius: "0.2rem",
+		cursor: "pointer",
+		backgroundColor: "var(--pm-code-btn-background-color)",
+		color: "var(--pm-muted-color)"
+	},
+	".cm-code-block-copy-button:hover": { backgroundColor: "var(--pm-code-btn-hover-background-color)" },
+	".cm-code-block-copy-button svg": {
+		width: "16px",
+		height: "16px"
+	}
+});
+
+//#endregion
+//#region lib/basicSetup.ts
+const prosemarkMarkdownSyntaxExtensions = [
+	additionalMarkdownSyntaxTags,
+	escapeMarkdownSyntaxExtension,
+	emojiMarkdownSyntaxExtension
+];
+const defaultFoldableSyntaxExtensions = [
+	blockQuoteExtension,
+	bulletListExtension,
+	taskExtension,
+	imageExtension,
+	emojiExtension,
+	horizonalRuleExtension
+];
+const prosemarkBasicSetup = () => [
+	history(),
+	dropCursor(),
+	indentOnInput(),
+	bracketMatching(),
+	closeBrackets(),
+	autocompletion(),
+	keymap.of([
+		...closeBracketsKeymap,
+		...defaultKeymap,
+		...searchKeymap,
+		...historyKeymap,
+		...foldKeymap,
+		...completionKeymap,
+		...lintKeymap,
+		indentWithTab
+	]),
+	foldGutter(),
+	EditorView.lineWrapping,
+	defaultHideExtensions,
+	defaultFoldableSyntaxExtensions,
+	clickLinkExtension,
+	codeBlockDecorationsExtension
+];
+const prosemarkBaseThemeSetup = () => [
+	baseSyntaxHighlights,
+	generalSyntaxHighlights,
+	baseTheme,
+	codeFenceTheme
+];
+const prosemarkLightThemeSetup = () => lightTheme;
+
+//#endregion
+export { additionalMarkdownSyntaxTags, baseSyntaxHighlights, baseTheme, blockQuoteExtension, bulletListExtension, clickLinkExtension, clickLinkHandler, codeBlockDecorationsExtension, codeFenceTheme, defaultClickLinkHandler, defaultFoldableSyntaxExtensions, defaultHideExtensions, emojiExtension, emojiMarkdownSyntaxExtension, escapeMarkdownSyntaxExtension, eventHandlersWithClass, foldDecorationExtension, foldableSyntaxFacet, generalSyntaxHighlights, horizonalRuleExtension, imageExtension, lightTheme, markdownTags, prosemarkBaseThemeSetup, prosemarkBasicSetup, prosemarkLightThemeSetup, prosemarkMarkdownSyntaxExtensions, selectAllDecorationsOnSelectExtension, taskExtension };