@segnavia/markdown-editor 0.0.0-stage → 0.42.0-setup.0

package/dist/markdown-editor.js

@@ -0,0 +1,348 @@
+import { ensureEditorStyle } from "./editor-style.js";
+import { MarkdownEditorFontRegistration } from "./markdown-editor-font-registration.js";
+import { validateMarkdownLink } from "./markdown-editor-link.js";
+import { joinLeadingHeading, normalizeMarkdownTitle, splitLeadingHeading } from "./markdown-title.js";
+import { markdownEditorModel, setModelEditable, setModelMarkdown, setModelTitle, setModelTitleSource } from "./markdown-editor-model.js";
+import { equalAlertLabels, equalFontReferences, equalFonts, equalLockedFences, normalizeAlertLabels, normalizeFontReferences, normalizeLockedFences } from "./markdown-editor-options.js";
+import { MARKDOWN_EDITOR_COMMANDS, MARKDOWN_EDITOR_MODES, availableMarkdownMode, markdownEditorKeyAction, richModeCommandRefusal } from "./markdown-editor-policy.js";
+import { RICH_COMMANDS, lockedBlockSourceOffset, richEditorState, selectedLockedBlock } from "./markdown-rich-commands.js";
+import { mountRichEditor } from "./markdown-rich-editor.js";
+import { parseRichDocument, saveRichDocument } from "./markdown-rich-save.js";
+import { markdownSourceState } from "./markdown-source.js";
+import { redo, redoDepth, undo, undoDepth } from "@codemirror/commands";
+import { EditorView } from "@codemirror/view";
+import { sanitizeBookCss } from "@segnavia/html";
+//#region src/markdown-editor.ts
+const TAG = "segnavia-markdown-editor";
+const COMMAND_NAMES = new Set(MARKDOWN_EDITOR_COMMANDS.map(({ name }) => name));
+var MarkdownEditorElement = class extends HTMLElement {
+	static observedAttributes = [
+		"markdown",
+		"mode",
+		"title-source"
+	];
+	root = this.attachShadow({ mode: "open" });
+	container = document.createElement("div");
+	titleField = document.createElement("input");
+	sourceMount = document.createElement("div");
+	richMount = document.createElement("div");
+	richStyle = document.createElement("style");
+	sourceView = null;
+	richView = null;
+	model = markdownEditorModel();
+	modeValue = "rich";
+	reflecting = false;
+	richOriginal = "";
+	stateKey = "";
+	lockedFenceOptions = {};
+	cssValue = "";
+	fontOptions;
+	fontReferenceOptions = [];
+	linkOriginOptions;
+	alertLabelOptions;
+	fontRegistration = new MarkdownEditorFontRegistration(this);
+	constructor() {
+		super();
+		this.container.part.add("editor");
+		this.titleField.part.add("title");
+		this.titleField.type = "text";
+		this.titleField.dir = "auto";
+		this.titleField.setAttribute("aria-label", "Title");
+		this.sourceMount.part.add("source");
+		this.richMount.part.add("rich");
+		this.container.append(this.titleField, this.sourceMount, this.richMount);
+		this.root.append(this.richStyle, this.container);
+	}
+	connectedCallback() {
+		ensureEditorStyle(this.container);
+		this.titleField.addEventListener("input", this.onTitleInput);
+		this.titleField.addEventListener("keydown", this.onTitleKeyDown);
+		this.titleField.addEventListener("paste", this.onTitlePaste);
+		this.mountMode();
+		this.renderTitle();
+	}
+	disconnectedCallback() {
+		this.titleField.removeEventListener("input", this.onTitleInput);
+		this.titleField.removeEventListener("keydown", this.onTitleKeyDown);
+		this.titleField.removeEventListener("paste", this.onTitlePaste);
+		this.sourceView?.destroy();
+		this.sourceView = null;
+		this.richView?.destroy();
+		this.richView = null;
+		this.fontRegistration.clear();
+	}
+	attributeChangedCallback(name, _old, value) {
+		if (this.reflecting) return;
+		if (name === "markdown") this.markdown = value ?? "";
+		else if (name === "mode") this.mode = value;
+		else this.titleSource = value === "leading-heading" ? "leading-heading" : "separate";
+	}
+	get markdown() {
+		return this.model.markdown;
+	}
+	set markdown(value) {
+		const model = setModelMarkdown(this.model, String(value ?? ""));
+		if (model === this.model) return;
+		this.model = model;
+		this.richOriginal = model.editable;
+		this.renderTitle();
+		this.resetVisibleEditor();
+	}
+	get mode() {
+		return this.modeValue;
+	}
+	set mode(value) {
+		this.setMode(availableMarkdownMode(value), false);
+	}
+	get modes() {
+		return MARKDOWN_EDITOR_MODES;
+	}
+	get title() {
+		return this.model.title;
+	}
+	set title(value) {
+		const model = setModelTitle(this.model, value);
+		if (model !== this.model) {
+			this.model = model;
+			this.renderTitle();
+		}
+	}
+	get titleSource() {
+		return this.model.titleSource;
+	}
+	set titleSource(value) {
+		const next = value === "leading-heading" ? value : "separate";
+		const model = setModelTitleSource(this.model, next);
+		if (model === this.model) return;
+		this.reflect("title-source", next === "separate" ? null : next);
+		this.model = model;
+		this.richOriginal = model.editable;
+		this.renderTitle();
+		this.resetVisibleEditor();
+	}
+	get lockedFences() {
+		return this.lockedFenceOptions;
+	}
+	set lockedFences(value) {
+		const next = normalizeLockedFences(value);
+		if (equalLockedFences(this.lockedFenceOptions, next)) return;
+		this.lockedFenceOptions = next;
+		if (this.modeValue === "rich") this.resetRich();
+	}
+	get css() {
+		return this.cssValue;
+	}
+	set css(value) {
+		const next = String(value ?? "");
+		if (next === this.cssValue) return;
+		const sanitized = sanitizeBookCss(next).css;
+		this.cssValue = next;
+		this.richStyle.textContent = sanitized;
+		for (const page of this.richMount.querySelectorAll("segnavia-page")) page.css = next;
+	}
+	get fonts() {
+		return this.fontOptions;
+	}
+	set fonts(value) {
+		if (equalFonts(this.fontOptions, value)) return;
+		this.fontOptions = value;
+		this.fontRegistration.load(this.fontReferenceOptions, this.fontOptions);
+		if (this.modeValue === "rich") this.resetRich();
+	}
+	get fontReferences() {
+		return this.fontReferenceOptions;
+	}
+	set fontReferences(value) {
+		const next = normalizeFontReferences(value);
+		if (equalFontReferences(this.fontReferenceOptions, next)) return;
+		this.fontReferenceOptions = next;
+		this.fontRegistration.load(this.fontReferenceOptions, this.fontOptions);
+		if (this.modeValue === "rich") this.resetRich();
+	}
+	get linkOrigins() {
+		return this.linkOriginOptions;
+	}
+	set linkOrigins(value) {
+		this.linkOriginOptions = value;
+	}
+	get alertLabels() {
+		return this.alertLabelOptions;
+	}
+	set alertLabels(value) {
+		const next = normalizeAlertLabels(value);
+		if (equalAlertLabels(this.alertLabelOptions, next)) return;
+		this.alertLabelOptions = next;
+		if (this.modeValue === "rich") this.resetRich();
+	}
+	get unstyled() {
+		return this.hasAttribute("unstyled");
+	}
+	set unstyled(value) {
+		this.toggleAttribute("unstyled", value);
+	}
+	run(command, args) {
+		if (!COMMAND_NAMES.has(command)) throw new Error(`Unknown markdown editor command ${JSON.stringify(command)}.`);
+		if (command === "toggle-mode") return this.setMode(this.modeValue === "rich" ? "source" : "rich", true);
+		if (this.modeValue === "source") return this.runSourceCommand(command);
+		const editor = this.richView;
+		if (!editor) return false;
+		if (command === "edit-in-source") return this.editSelectedLockedBlock();
+		if (command === "link") validateMarkdownLink(String(args?.href ?? ""), this.linkOriginOptions);
+		return RICH_COMMANDS[command].apply(editor, args);
+	}
+	runSourceCommand(command) {
+		if (command === "undo") return this.sourceView ? undo(this.sourceView) : false;
+		if (command === "redo") return this.sourceView ? redo(this.sourceView) : false;
+		throw richModeCommandRefusal(command);
+	}
+	setMode(mode, emit) {
+		if (mode === this.modeValue) return false;
+		this.modeValue = mode;
+		this.reflect("mode", mode);
+		this.mountMode();
+		if (emit) this.emit("segnavia-mode-change", { mode });
+		return true;
+	}
+	mountMode() {
+		if (!this.isConnected) return;
+		this.sourceMount.hidden = this.modeValue !== "source";
+		this.richMount.hidden = this.modeValue !== "rich";
+		if (this.modeValue === "source") this.mountSource();
+		else this.resetRich();
+		this.fontRegistration.load(this.fontReferenceOptions, this.fontOptions);
+	}
+	mountSource() {
+		this.sourceView?.destroy();
+		this.sourceMount.replaceChildren();
+		this.sourceView = new EditorView({
+			parent: this.sourceMount,
+			root: this.root,
+			state: this.sourceState()
+		});
+		this.emitSourceState(false, false);
+	}
+	sourceState() {
+		return markdownSourceState(this.model.editable, {
+			change: (markdown) => this.onSourceChange(markdown),
+			save: () => this.emit("segnavia-save"),
+			toggleMode: () => this.run("toggle-mode"),
+			state: (canUndo, canRedo) => this.emitSourceState(canUndo, canRedo)
+		});
+	}
+	resetVisibleEditor() {
+		if (this.modeValue === "source" && this.sourceView) this.sourceView.setState(this.sourceState());
+		if (this.modeValue === "rich") this.resetRich();
+		this.emitVisibleState();
+	}
+	resetRich() {
+		if (!this.isConnected) return;
+		this.richView?.destroy();
+		this.richMount.replaceChildren();
+		this.richOriginal = this.model.editable;
+		this.richView = mountRichEditor({
+			mount: this.richMount,
+			content: parseRichDocument(this.model.editable, { lockedFences: this.lockedFenceOptions }),
+			css: () => this.cssValue,
+			fonts: this.fontOptions,
+			fontReferences: this.fontReferenceOptions,
+			alertLabels: this.alertLabelOptions,
+			linkOrigins: () => this.linkOriginOptions,
+			change: (content) => this.onRichChange(content),
+			state: (state) => this.emitState(state),
+			linkRequest: (href) => this.emit("segnavia-link-request", { href }),
+			save: () => this.emit("segnavia-save"),
+			toggleMode: () => this.setMode("source", true),
+			editLocked: () => this.editSelectedLockedBlock()
+		});
+	}
+	onRichChange(content) {
+		const editable = saveRichDocument(this.richOriginal, content, { lockedFences: this.lockedFenceOptions });
+		const model = setModelEditable(this.model, editable);
+		if (model === this.model) return;
+		this.model = model;
+		this.emit("segnavia-markdown-change", { markdown: model.markdown });
+	}
+	editSelectedLockedBlock() {
+		const selected = this.richView ? selectedLockedBlock(this.richView) : null;
+		if (!selected) throw new Error("Cannot edit in source because no locked block is selected; select a locked block to clear this refusal.");
+		const position = lockedBlockSourceOffset(this.model.editable, selected.source, selected.occurrence);
+		this.setMode("source", true);
+		const view = this.sourceView;
+		if (view && position >= 0) view.dispatch({
+			selection: { anchor: position },
+			effects: EditorView.scrollIntoView(position)
+		});
+		view?.focus();
+		return true;
+	}
+	onSourceChange(editable) {
+		const model = setModelEditable(this.model, editable);
+		if (model === this.model) return;
+		this.model = model;
+		this.emit("segnavia-markdown-change", { markdown: model.markdown });
+	}
+	onTitleInput = () => {
+		const normalized = normalizeMarkdownTitle(this.titleField.value);
+		this.titleField.value = normalized;
+		const model = setModelTitle(this.model, normalized);
+		if (model === this.model) return;
+		this.model = model;
+		this.emit("segnavia-title-change", { title: normalized });
+		if (model.titleSource === "leading-heading") this.emit("segnavia-markdown-change", { markdown: model.markdown });
+	};
+	onTitleKeyDown = (event) => {
+		if (event.key === "Enter") event.preventDefault();
+		const action = markdownEditorKeyAction(event);
+		if (!action) return;
+		event.preventDefault();
+		if (action === "save") this.emit("segnavia-save");
+		else this.run("toggle-mode");
+	};
+	onTitlePaste = (event) => {
+		const pasted = event.clipboardData?.getData("text");
+		if (pasted === void 0) return;
+		event.preventDefault();
+		this.titleField.setRangeText(normalizeMarkdownTitle(pasted), this.titleField.selectionStart ?? 0, this.titleField.selectionEnd ?? 0, "end");
+		this.onTitleInput();
+	};
+	renderTitle() {
+		this.titleField.hidden = this.model.titleSource === "separate" && this.model.title === null;
+		this.titleField.value = this.model.title ?? "";
+	}
+	emitSourceState(canUndo = this.sourceView ? undoDepth(this.sourceView.state) > 0 : false, canRedo = this.sourceView ? redoDepth(this.sourceView.state) > 0 : false) {
+		this.emitState({
+			marks: [],
+			nodes: [],
+			canUndo,
+			canRedo
+		});
+	}
+	emitVisibleState() {
+		if (this.modeValue === "rich" && this.richView) this.emitState(richEditorState(this.richView));
+		else this.emitSourceState();
+	}
+	emitState(state) {
+		const key = JSON.stringify(state);
+		if (key === this.stateKey) return;
+		this.stateKey = key;
+		this.emit("segnavia-editor-state", state);
+	}
+	emit(name, detail) {
+		this.dispatchEvent(new CustomEvent(name, {
+			detail,
+			bubbles: true,
+			composed: true
+		}));
+	}
+	reflect(name, value) {
+		if (this.getAttribute(name) === value) return;
+		this.reflecting = true;
+		if (value === null) this.removeAttribute(name);
+		else this.setAttribute(name, value);
+		this.reflecting = false;
+	}
+};
+const SegnaviaMarkdownEditor = MarkdownEditorElement;
+if (!customElements.get(TAG)) customElements.define(TAG, SegnaviaMarkdownEditor);
+//#endregion
+export { MARKDOWN_EDITOR_COMMANDS, MARKDOWN_EDITOR_MODES, SegnaviaMarkdownEditor, joinLeadingHeading, normalizeMarkdownTitle, splitLeadingHeading };

package/dist/markdown-rich-commands.js

@@ -0,0 +1,114 @@
+import { MARKDOWN_EDITOR_COMMANDS, MARKDOWN_EDITOR_KEYS } from "./markdown-editor-policy.js";
+import { LOCKED_BLOCK_NAME } from "./markdown-rich-locked.js";
+import { Extension } from "@tiptap/core";
+import { NodeSelection } from "@tiptap/pm/state";
+//#region src/markdown-rich-commands.ts
+const commandKeys = Object.fromEntries(MARKDOWN_EDITOR_COMMANDS.map(({ name, key }) => [name, key]));
+const RICH_KEYBOARD_COMMANDS = MARKDOWN_EDITOR_COMMANDS.filter(({ name }) => name !== "heading" && name !== "toggle-mode" && name !== "edit-in-source").map(({ name }) => name);
+const RICH_COMMANDS = {
+	bold: { apply: (editor) => editor.chain().focus().toggleBold().run() },
+	italic: { apply: (editor) => editor.chain().focus().toggleItalic().run() },
+	code: { apply: (editor) => editor.chain().focus().toggleCode().run() },
+	strike: { apply: (editor) => editor.chain().focus().toggleStrike().run() },
+	paragraph: { apply: (editor) => editor.chain().focus().setParagraph().run() },
+	heading: { apply: (editor, args) => editor.chain().focus().toggleHeading({ level: Number(args?.level) }).run() },
+	"bullet-list": { apply: (editor) => editor.chain().focus().toggleBulletList().run() },
+	"ordered-list": { apply: (editor) => editor.chain().focus().toggleOrderedList().run() },
+	"task-list": { apply: (editor) => editor.chain().focus().toggleTaskList().run() },
+	quote: { apply: (editor) => editor.chain().focus().toggleBlockquote().run() },
+	"code-block": { apply: (editor) => editor.chain().focus().toggleCodeBlock().run() },
+	link: { apply: (editor, args) => editor.chain().focus().extendMarkRange("link").setLink({ href: String(args?.href ?? "") }).run() },
+	unlink: { apply: (editor) => editor.chain().focus().extendMarkRange("link").unsetLink().run() },
+	"insert-table": { apply: (editor) => editor.chain().focus().insertTable({
+		rows: 3,
+		cols: 3,
+		withHeaderRow: true
+	}).run() },
+	"add-row": { apply: (editor) => editor.chain().focus().addRowAfter().run() },
+	"delete-row": { apply: (editor) => editor.chain().focus().deleteRow().run() },
+	"add-column": { apply: (editor) => editor.chain().focus().addColumnAfter().run() },
+	"delete-column": { apply: (editor) => editor.chain().focus().deleteColumn().run() },
+	"delete-table": { apply: (editor) => editor.chain().focus().deleteTable().run() },
+	undo: { apply: (editor) => editor.chain().focus().undo().run() },
+	redo: { apply: (editor) => editor.chain().focus().redo().run() }
+};
+function selectedLockedBlock(editor) {
+	const selection = editor.state.selection;
+	if (!(selection instanceof NodeSelection) || selection.node.type.name !== "lockedBlock") return null;
+	const source = typeof selection.node.attrs.source === "string" ? selection.node.attrs.source : "";
+	let occurrence = 0;
+	editor.state.doc.nodesBetween(0, selection.from, (node) => {
+		if (node.type.name === "lockedBlock" && node.attrs.source === source) occurrence++;
+	});
+	return {
+		source,
+		occurrence
+	};
+}
+function lockedBlockSourceOffset(markdown, source, occurrence) {
+	let offset = -1;
+	for (let index = 0; index <= occurrence; index++) offset = markdown.indexOf(source, offset + 1);
+	return offset;
+}
+function richKeyboard(options) {
+	return Extension.create({
+		name: "segnaviaKeyboard",
+		priority: 1e3,
+		addKeyboardShortcuts() {
+			const tableOnly = (command) => this.editor.isActive("table") && RICH_COMMANDS[command].apply(this.editor, void 0);
+			const commandShortcuts = Object.fromEntries(RICH_KEYBOARD_COMMANDS.map((command) => [commandKeys[command], () => RICH_COMMANDS[command].apply(this.editor, void 0)]));
+			const saveKey = MARKDOWN_EDITOR_KEYS.find(({ action }) => action === "save")?.key;
+			const toggleKey = MARKDOWN_EDITOR_KEYS.find(({ action }) => action === "toggle-mode")?.key;
+			if (!saveKey || !toggleKey) throw new Error("Markdown editor save and mode-toggle keys must be declared.");
+			return {
+				...commandShortcuts,
+				[saveKey]: () => {
+					options.save();
+					return true;
+				},
+				[toggleKey]: options.toggleMode,
+				[commandKeys.link]: () => {
+					const href = this.editor.isActive("link") ? String(this.editor.getAttributes("link").href ?? "") : null;
+					options.linkRequest(href);
+					return true;
+				},
+				[commandKeys.unlink]: () => RICH_COMMANDS.unlink.apply(this.editor, void 0),
+				[commandKeys["insert-table"]]: () => RICH_COMMANDS["insert-table"].apply(this.editor, void 0),
+				[commandKeys["add-row"]]: () => tableOnly("add-row"),
+				[commandKeys["delete-row"]]: () => tableOnly("delete-row"),
+				[commandKeys["add-column"]]: () => tableOnly("add-column"),
+				[commandKeys["delete-column"]]: () => tableOnly("delete-column"),
+				[commandKeys["delete-table"]]: () => tableOnly("delete-table"),
+				[commandKeys["edit-in-source"]]: () => selectedLockedBlock(this.editor) ? options.editLocked() : false
+			};
+		}
+	});
+}
+function richEditorState(editor) {
+	const marks = [
+		"bold",
+		"italic",
+		"code",
+		"strike",
+		"link"
+	].filter((name) => editor.isActive(name));
+	const nodes = [
+		["paragraph", "paragraph"],
+		["bulletList", "bullet-list"],
+		["orderedList", "ordered-list"],
+		["taskList", "task-list"],
+		["blockquote", "quote"],
+		["codeBlock", "code-block"],
+		["table", "table"],
+		[LOCKED_BLOCK_NAME, "locked-block"]
+	].filter(([name]) => editor.isActive(name)).map(([, vocabulary]) => vocabulary);
+	for (let level = 1; level <= 6; level++) if (editor.isActive("heading", { level })) nodes.push(`heading-${level}`);
+	return {
+		marks,
+		nodes,
+		canUndo: editor.can().undo(),
+		canRedo: editor.can().redo()
+	};
+}
+//#endregion
+export { RICH_COMMANDS, RICH_KEYBOARD_COMMANDS, lockedBlockSourceOffset, richEditorState, richKeyboard, selectedLockedBlock };

package/dist/markdown-rich-editor.js

@@ -0,0 +1,79 @@
+import { LockedBlock } from "./markdown-rich-locked.js";
+import { richEditorState, richKeyboard } from "./markdown-rich-commands.js";
+import { richExtensions } from "./markdown-rich-extensions.js";
+import { safeMarkdownUrl } from "@segnavia/html";
+import { HEADLESS_ELEMENTS, SegnaviaPage, createPageElement } from "@segnavia/frame";
+import { Editor } from "@tiptap/core";
+//#region src/markdown-rich-editor.ts
+if (!customElements.get(HEADLESS_ELEMENTS.page)) customElements.define(HEADLESS_ELEMENTS.page, SegnaviaPage);
+function lockedView(options) {
+	return LockedBlock.extend({ addNodeView() {
+		return ({ node }) => {
+			const dom = document.createElement("div");
+			dom.part.add("locked-block");
+			dom.dir = "auto";
+			dom.contentEditable = "false";
+			const label = typeof node.attrs.label === "string" ? node.attrs.label : null;
+			if (label) {
+				dom.dataset.lockedLabel = label;
+				const text = document.createElement("span");
+				text.dir = "auto";
+				text.textContent = label;
+				dom.append(text);
+			} else {
+				const page = createPageElement();
+				const current = options();
+				page.css = current.css();
+				page.fonts = current.fonts;
+				page.alertLabels = current.alertLabels;
+				page.page = {
+					markdown: String(node.attrs.source ?? ""),
+					scripts: "refuse",
+					fonts: current.fontReferences
+				};
+				dom.append(page);
+			}
+			return { dom };
+		};
+	} });
+}
+function extensions(options, keyboard) {
+	return [...richExtensions().map((extension) => extension.name === "lockedBlock" ? lockedView(options) : extension), richKeyboard(keyboard)];
+}
+function pastedHtml(html, linkOrigins) {
+	const parsed = new DOMParser().parseFromString(html, "text/html");
+	for (const link of parsed.querySelectorAll("a[href]")) {
+		if (safeMarkdownUrl("href", link.getAttribute("href") ?? "", linkOrigins)) continue;
+		link.replaceWith(...link.childNodes);
+	}
+	for (const image of parsed.querySelectorAll("img[src]")) if (!safeMarkdownUrl("src", image.getAttribute("src") ?? "")) image.remove();
+	for (const active of parsed.querySelectorAll("script,style,iframe,object,embed")) active.remove();
+	return parsed.body.innerHTML;
+}
+function mountRichEditor(options) {
+	const current = () => options;
+	const editor = new Editor({
+		element: options.mount,
+		injectCSS: false,
+		extensions: extensions(current, options),
+		content: {
+			type: "doc",
+			content: options.content
+		},
+		editorProps: {
+			attributes: { "aria-label": "Markdown body" },
+			handleDOMEvents: { click: (_view, event) => {
+				if (event.target instanceof Element && event.target.closest("a")) event.preventDefault();
+				return false;
+			} },
+			transformPastedHTML: (html) => pastedHtml(html, options.linkOrigins())
+		},
+		onUpdate: ({ editor: instance }) => options.change(Array.from(instance.state.doc.content.content)),
+		onTransaction: ({ editor: instance }) => options.state(richEditorState(instance)),
+		onSelectionUpdate: ({ editor: instance }) => options.state(richEditorState(instance))
+	});
+	options.state(richEditorState(editor));
+	return editor;
+}
+//#endregion
+export { mountRichEditor };

package/dist/markdown-rich-extensions.js

@@ -0,0 +1,61 @@
+import { LockedBlock } from "./markdown-rich-locked.js";
+import { Extension, getSchema } from "@tiptap/core";
+import Image from "@tiptap/extension-image";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { TableKit } from "@tiptap/extension-table";
+import { MarkdownManager } from "@tiptap/markdown";
+import StarterKit from "@tiptap/starter-kit";
+//#region src/markdown-rich-extensions.ts
+const directionalBlocks = Extension.create({
+	name: "directionalBlocks",
+	addGlobalAttributes() {
+		return [{
+			types: [
+				"paragraph",
+				"heading",
+				"bulletList",
+				"orderedList",
+				"taskList",
+				"listItem",
+				"taskItem",
+				"blockquote",
+				"codeBlock",
+				"tableCell",
+				"tableHeader"
+			],
+			attributes: { dir: {
+				default: "auto",
+				renderHTML: () => ({ dir: "auto" })
+			} }
+		}];
+	}
+});
+function richExtensions() {
+	return [
+		StarterKit.configure({
+			trailingNode: false,
+			link: { openOnClick: false }
+		}),
+		TableKit,
+		TaskList,
+		TaskItem.configure({ nested: true }),
+		Image.configure({ inline: true }),
+		directionalBlocks,
+		LockedBlock
+	];
+}
+let manager;
+function richMarkdownManager() {
+	manager ??= new MarkdownManager({
+		extensions: richExtensions(),
+		markedOptions: { gfm: true }
+	});
+	return manager;
+}
+let schema;
+function richSchema() {
+	schema ??= getSchema(richExtensions());
+	return schema;
+}
+//#endregion
+export { richExtensions, richMarkdownManager, richSchema };