@threadlabs/looma 0.27.6 → 0.28.1

package/editor/chunks/extensions.js

@@ -9,6 +9,7 @@ import { gapCursor } from "@tiptap/pm/gapcursor";
 import { createLowlight } from "lowlight";
 import { Mapping } from "@tiptap/pm/transform";
 import MarkdownIt from "markdown-it";
+import { MarkdownSerializer, defaultMarkdownSerializer } from "@tiptap/pm/markdown";
 import { CellSelection, TableMap, addColumn, addColumnAfter, addColumnBefore, addRow, addRowAfter, addRowBefore, cellAround, columnResizing, deleteCellSelection, deleteColumn, deleteRow, deleteTable, fixTables, goToNextCell, mergeCells, moveTableColumn, moveTableRow, setCellAttr, splitCell, tableEditing, toggleHeader, toggleHeaderCell } from "@tiptap/pm/tables";
 //#region src/editor/extensions/active-block.ts
 /**
@@ -127,20 +128,34 @@ var LoomaActiveBlock = Extension.create({
 });
 //#endregion
 //#region src/editor/extensions/callout.ts
-/** Canonical tone values that may be persisted in a Looma callout node. */
+/**
+* Canonical tone values that may be persisted in a Looma callout node: the shared block
+* vocabulary of Callout, Markdown `:::` containers and GitHub alerts.
+*/
 var LOOMA_CALLOUT_TONES = [
-	"info",
 	"note",
-	"warning"
+	"tip",
+	"info",
+	"important",
+	"warning",
+	"danger"
 ];
-function normalizeCalloutTone(value) {
-	return typeof value === "string" && LOOMA_CALLOUT_TONES.includes(value) ? value : "note";
+var TONE_ALIASES = {
+	caution: "danger",
+	neutral: "note"
+};
+/** Maps a tone name, alias, or unknown value onto a persisted tone. */
+function normalizeLoomaCalloutTone(value) {
+	if (typeof value !== "string") return "note";
+	const tone = value.toLowerCase();
+	return LOOMA_CALLOUT_TONES.includes(tone) ? tone : TONE_ALIASES[tone] ?? "note";
 }
 /**
-* A durable, themeable block container for informational editor content.
+* A durable block container for informational editor content, saved as Looma's Callout.
 *
-* @invariant Parsed and rendered `data-tone` values always belong to
-* `LOOMA_CALLOUT_TONES`; missing or unknown values round-trip as `note`.
+* @invariant Rendered `tone` values always belong to `LOOMA_CALLOUT_TONES`; missing or
+* unknown values round-trip as `note`. Content saved as the older
+* `aside[data-looma-callout][data-tone]` still parses.
 */
 var LoomaCallout = Node$1.create({
 	name: "loomaCallout",
@@ -148,25 +163,32 @@ var LoomaCallout = Node$1.create({
 	content: "block+",
 	defining: true,
 	addAttributes() {
-		return { tone: {
-			default: "note",
-			parseHTML: (element) => normalizeCalloutTone(element.getAttribute("data-tone")),
-			renderHTML: (attributes) => ({ "data-tone": normalizeCalloutTone(attributes.tone) })
-		} };
+		return {
+			tone: {
+				default: "note",
+				parseHTML: (element) => normalizeLoomaCalloutTone(element.getAttribute("tone") ?? element.getAttribute("data-tone")),
+				renderHTML: (attributes) => ({ tone: normalizeLoomaCalloutTone(attributes.tone) })
+			},
+			heading: {
+				default: "",
+				parseHTML: (element) => element.getAttribute("heading") ?? "",
+				renderHTML: (attributes) => attributes.heading ? { heading: String(attributes.heading) } : {}
+			}
+		};
 	},
 	parseHTML() {
-		return [{ tag: "aside[data-looma-callout]" }];
+		return [{ tag: "ui-callout" }, { tag: "aside[data-looma-callout]" }];
 	},
 	renderHTML({ HTMLAttributes }) {
 		return [
-			"aside",
-			mergeAttributes(HTMLAttributes, { "data-looma-callout": "" }),
+			"ui-callout",
+			HTMLAttributes,
 			0
 		];
 	},
 	addCommands() {
 		return { setLoomaCallout: (tone = "note") => ({ state, commands }) => {
-			const normalizedTone = normalizeCalloutTone(tone);
+			const normalizedTone = normalizeLoomaCalloutTone(tone);
 			for (let depth = state.selection.$from.depth; depth > 0; depth -= 1) if (state.selection.$from.node(depth).type.name === this.name) return commands.updateAttributes(this.name, { tone: normalizedTone });
 			return commands.wrapIn(this.name, { tone: normalizedTone });
 		} };
@@ -2475,7 +2497,7 @@ function decodeTlds(encoded) {
 /**
 * @type Required<Opts>
 */
-var defaults = {
+var defaults$1 = {
 	defaultProtocol: "http",
 	events: null,
 	format: noop,
@@ -2502,7 +2524,7 @@ var defaults = {
 *   Similar to render option
 */
 function Options(opts, defaultRender = null) {
-	let o = Object.assign({}, defaults);
+	let o = Object.assign({}, defaults$1);
 	if (opts) o = Object.assign(o, opts instanceof Options ? opts.o : opts);
 	const ignoredTags = o.ignoreTags;
 	const uppercaseIgnoredTags = [];
@@ -2513,7 +2535,7 @@ function Options(opts, defaultRender = null) {
 	this.ignoreTags = uppercaseIgnoredTags;
 }
 Options.prototype = {
-	o: defaults,
+	o: defaults$1,
 	/**
 	* @type string[]
 	*/
@@ -2550,7 +2572,7 @@ Options.prototype = {
 		let option = this.o[key];
 		if (!option) return option;
 		if (typeof option === "object") {
-			option = token.t in option ? option[token.t] : defaults[key];
+			option = token.t in option ? option[token.t] : defaults$1[key];
 			if (typeof option === "function" && isCallable) option = option(operator, token);
 		} else if (typeof option === "function" && isCallable) option = option(operator, token.t, token);
 		return option;
@@ -2668,7 +2690,7 @@ MultiToken.prototype = {
 	@method toObject
 	@param {string} [protocol] `'http'` by default
 	*/
-	toObject(protocol = defaults.defaultProtocol) {
+	toObject(protocol = defaults$1.defaultProtocol) {
 		return {
 			type: this.t,
 			value: this.toString(),
@@ -2777,7 +2799,7 @@ var Url = createTokenClass("url", {
 	@param {string} [scheme] default scheme (e.g., 'https')
 	@return {string} the full href
 	*/
-	toHref(scheme = defaults.defaultProtocol) {
+	toHref(scheme = defaults$1.defaultProtocol) {
 		return this.hasProtocol() ? this.v : `${scheme}://${this.v}`;
 	},
 	/**
@@ -9143,15 +9165,213 @@ function createDOMPurify() {
 }
 var purify = createDOMPurify();
 //#endregion
+//#region src/editor/extensions/markdown.ts
+var CONTAINER_NAMES = /* @__PURE__ */ new Set([
+	"note",
+	"tip",
+	"info",
+	"important",
+	"warning",
+	"danger",
+	"caution",
+	"details"
+]);
+var CONTAINER_OPEN = /^(:{3,})[ \t]*([A-Za-z]+)(?:[ \t]+(.*?))?[ \t]*$/;
+var CONTAINER_CLOSE = /^:{3,}[ \t]*$/;
+var OPEN_FLAG = /[ \t]*\{open\}$/;
+var ALERT = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][ \t]*(?:\n|$)/i;
+function lineText(state, line) {
+	return state.src.slice(state.bMarks[line] + state.tShift[line], state.eMarks[line]);
+}
+function container(state, startLine, endLine, silent) {
+	if (state.sCount[startLine] - state.blkIndent >= 4) return false;
+	const match = CONTAINER_OPEN.exec(lineText(state, startLine));
+	if (!match || !CONTAINER_NAMES.has(match[2].toLowerCase())) return false;
+	if (silent) return true;
+	let depth = 1;
+	let next = startLine + 1;
+	for (; next < endLine; next++) {
+		if (state.sCount[next] < state.blkIndent) break;
+		const text = lineText(state, next);
+		if (CONTAINER_CLOSE.test(text)) {
+			if (--depth === 0) break;
+		} else if (CONTAINER_OPEN.test(text) && CONTAINER_NAMES.has(CONTAINER_OPEN.exec(text)[2].toLowerCase())) depth++;
+	}
+	const name = match[2].toLowerCase();
+	let title = (match[3] ?? "").trim();
+	const open = OPEN_FLAG.test(title);
+	title = title.replace(OPEN_FLAG, "");
+	const parentType = state.parentType;
+	const lineMax = state.lineMax;
+	state.parentType = "container";
+	state.lineMax = next;
+	const opening = state.push("looma_container_open", "", 1);
+	Object.assign(opening, {
+		info: name,
+		meta: {
+			title,
+			open
+		},
+		block: true,
+		map: [startLine, next],
+		markup: match[1]
+	});
+	state.md.block.tokenize(state, startLine + 1, next);
+	const closing = state.push("looma_container_close", "", -1);
+	Object.assign(closing, {
+		info: name,
+		block: true,
+		markup: match[1]
+	});
+	state.parentType = parentType;
+	state.lineMax = lineMax;
+	state.line = Math.min(next + 1, endLine);
+	return true;
+}
+function alerts(state) {
+	const tokens = state.tokens;
+	for (let index = 0; index < tokens.length; index++) {
+		if (tokens[index].type !== "blockquote_open" || tokens[index + 1]?.type !== "paragraph_open") continue;
+		const inline = tokens[index + 2];
+		const match = inline?.type === "inline" ? ALERT.exec(inline.content) : null;
+		if (!match) continue;
+		inline.content = inline.content.slice(match[0].length);
+		if (!inline.content.trim()) tokens.splice(index + 1, 3);
+		tokens[index].tag = "ui-callout";
+		tokens[index].attrSet("tone", normalizeLoomaCalloutTone(match[1]));
+		for (let depth = 0, end = index; end < tokens.length; end++) if (tokens[end].type === "blockquote_open") depth++;
+		else if (tokens[end].type === "blockquote_close" && --depth === 0) {
+			tokens[end].tag = "ui-callout";
+			break;
+		}
+	}
+}
+function withSharedBlocks(md) {
+	const escape = md.utils.escapeHtml;
+	md.block.ruler.before("fence", "looma_container", container, { alt: [
+		"paragraph",
+		"reference",
+		"blockquote",
+		"list"
+	] });
+	md.core.ruler.before("inline", "looma_alerts", alerts);
+	md.renderer.rules.looma_container_open = (tokens, index) => {
+		const { info, meta } = tokens[index];
+		if (info === "details") return `<details${meta.open ? " open" : ""}><summary>${escape(meta.title || "Details")}</summary>\n`;
+		return `<ui-callout tone="${normalizeLoomaCalloutTone(info)}"${meta.title ? ` heading="${escape(meta.title)}"` : ""}>\n`;
+	};
+	md.renderer.rules.looma_container_close = (tokens, index) => tokens[index].info === "details" ? "</details>\n" : "</ui-callout>\n";
+	return md;
+}
+/** The markdown-it instance LoomaEditor imports Markdown with, shared block vocabulary included. */
+var loomaMarkdown = withSharedBlocks(new MarkdownIt({
+	html: true,
+	linkify: false,
+	typographer: false
+}));
+/**
+* Renders Markdown, including the shared block vocabulary, as HTML the editor parses.
+* @contract The result is not sanitized; pass it to the editor's `setContent`, whose schema
+* keeps only content it knows.
+*/
+function loomaMarkdownToHtml(source) {
+	return loomaMarkdown.render(source).replace(/\n<\/code><\/pre>/g, "</code></pre>");
+}
+var containerDepth = (node) => {
+	let depth = 0;
+	node.descendants((child) => {
+		if (child.type.name === "loomaCallout" || child.type.name === "loomaExpand") depth = Math.max(depth, 1 + containerDepth(child));
+		return false;
+	});
+	return depth;
+};
+function writeContainer(state, node, opening) {
+	const marker = ":".repeat(3 + containerDepth(node));
+	state.write(`${marker} ${opening}`.trimEnd());
+	state.ensureNewLine();
+	state.renderContent(node);
+	state.write(marker);
+	state.closeBlock(node);
+}
+var defaults = defaultMarkdownSerializer.nodes;
+var NODES = {
+	paragraph: defaults.paragraph,
+	text: defaults.text,
+	blockquote: defaults.blockquote,
+	heading: defaults.heading,
+	horizontalRule: defaults.horizontal_rule,
+	bulletList: defaults.bullet_list,
+	orderedList: (state, node) => {
+		const start = Number(node.attrs.start ?? 1);
+		state.renderList(node, "   ", (index) => `${start + index}. `);
+	},
+	listItem: defaults.list_item,
+	hardBreak: defaults.hard_break,
+	codeBlock: (state, node) => {
+		const longest = Math.max(0, ...(node.textContent.match(/`+/g) ?? []).map((run) => run.length));
+		const fence = "`".repeat(Math.max(3, longest + 1));
+		state.write(`${fence}${node.attrs.language ?? ""}\n`);
+		state.text(node.textContent, false);
+		state.ensureNewLine();
+		state.write(fence);
+		state.closeBlock(node);
+	},
+	loomaCallout: (state, node) => writeContainer(state, node, `${node.attrs.tone} ${node.attrs.heading ?? ""}`),
+	loomaExpand: (state, node) => writeContainer(state, node, `details ${node.attrs.summary}${node.attrs.open ? " {open}" : ""}`)
+};
+var MARKS = {
+	bold: defaultMarkdownSerializer.marks.strong,
+	italic: defaultMarkdownSerializer.marks.em,
+	code: defaultMarkdownSerializer.marks.code,
+	link: defaultMarkdownSerializer.marks.link,
+	strike: {
+		open: "~~",
+		close: "~~",
+		mixable: true,
+		expelEnclosingWhitespace: true
+	},
+	underline: {
+		open: "<u>",
+		close: "</u>",
+		mixable: true
+	},
+	highlight: {
+		open: "<mark>",
+		close: "</mark>",
+		mixable: true
+	}
+};
+/**
+* Writes an editor document as Markdown, with callouts and expand sections in the shared
+* `:::` syntax that `loomaMarkdownToHtml` and Markupress read.
+* @contract Content Markdown has no syntax for (tables, task lists, images, chips, mentions,
+* the table of contents) is written as its saved HTML, which Markdown carries unchanged.
+* Marks without a Markdown form other than underline and highlight are dropped.
+*/
+function loomaMarkdownFromDoc(doc) {
+	const dom = DOMSerializer.fromSchema(doc.type.schema);
+	const html = (node) => {
+		const holder = document.createElement("div");
+		holder.append(dom.serializeNode(node));
+		return holder.innerHTML;
+	};
+	const nodes = {};
+	for (const name of Object.keys(doc.type.schema.nodes)) nodes[name] = NODES[name] ?? ((state, node) => {
+		state.write(html(node));
+		if (node.isBlock) state.closeBlock(node);
+	});
+	const marks = {};
+	for (const name of Object.keys(doc.type.schema.marks)) marks[name] = MARKS[name] ?? {
+		open: "",
+		close: ""
+	};
+	return new MarkdownSerializer(nodes, marks).serialize(doc, { tightLists: true });
+}
+//#endregion
 //#region src/editor/extensions/smart-paste.ts
 var HTML_DOCUMENT_PATTERN = /<!doctype\s+html\b|<(?:html|body)\b[^>]*>/i;
 var HTML_PAIRED_TAG_PATTERN = /<(h[1-6]|p|ul|ol|li|blockquote|table|thead|tbody|tfoot|tr|th|td|figure|figcaption|article|section|header|footer|main|div|span|strong|em|b|i|a|code|pre)\b[^>]*>[\s\S]*?<\/\1\s*>/i;
 var HTML_VOID_TAG_PATTERN = /<(?:img|hr|br)\b[^>]*\/?\s*>/i;
-var markdown = new MarkdownIt({
-	html: true,
-	linkify: false,
-	typographer: false
-});
 function selectionIsInsideCodeBlock(parentTypeName) {
 	return parentTypeName === "codeBlock";
 }
@@ -9162,7 +9382,7 @@ function looksLikeDocumentHtml(value) {
 	return !/[={};`"']|=>|\b(?:const|let|var|return|function|class|import|export)\b/.test(prefix);
 }
 function looksLikeMarkdown(value) {
-	const tokens = markdown.parse(value, {});
+	const tokens = loomaMarkdown.parse(value, {});
 	return tokens.some((token, index) => {
 		if (token.type === "heading_open") return Boolean(tokens[index + 1]?.content.trim());
 		if ([
@@ -9170,7 +9390,8 @@ function looksLikeMarkdown(value) {
 			"ordered_list_open",
 			"blockquote_open",
 			"fence",
-			"table_open"
+			"table_open",
+			"looma_container_open"
 		].includes(token.type)) return true;
 		return token.type === "inline" && Boolean(token.children?.some((child) => [
 			"link_open",
@@ -9218,6 +9439,8 @@ function parseHtmlSlice(schema, value) {
 			"template"
 		],
 		FORBID_ATTR: ["style"],
+		ADD_TAGS: ["ui-callout"],
+		ADD_ATTR: ["tone", "heading"],
 		RETURN_DOM_FRAGMENT: true
 	}));
 	if (!container.textContent?.trim() && !container.querySelector("img, hr")) return Slice.empty;
@@ -9236,7 +9459,7 @@ function escapeHtmlText(value) {
 }
 function documentSlice(schema, plainText) {
 	const frontmatter = markdownFrontmatter(plainText);
-	if (frontmatter || looksLikeMarkdown(plainText)) return parseHtmlSlice(schema, frontmatter ? `<pre><code class="language-yaml">${escapeHtmlText(frontmatter.source)}</code></pre>${markdown.render(frontmatter.body)}` : markdown.render(plainText));
+	if (frontmatter || looksLikeMarkdown(plainText)) return parseHtmlSlice(schema, frontmatter ? `<pre><code class="language-yaml">${escapeHtmlText(frontmatter.source)}</code></pre>${loomaMarkdown.render(frontmatter.body)}` : loomaMarkdown.render(plainText));
 	if (looksLikeDocumentHtml(plainText)) return parseHtmlSlice(schema, plainText);
 	return null;
 }
@@ -9838,7 +10061,7 @@ function getLoomaTableExtensions() {
 * the code and explicit language stay in the document schema.
 */
 function getDefaultEditorExtensions(options = {}) {
-	const { placeholder = "Type “/” for commands, or start writing…", linkOpenOnClick = false, linkBaseUrl, imageInline = false, imageNodeView, dividerNodeView, mention = createLoomaMentionExtension(), disableHighlight = false, codeLanguages, codeLowlight, codeBlockNodeView, tableOfContentsNodeView, expandNodeView } = options;
+	const { placeholder = "Type “/” for commands, or start writing…", linkOpenOnClick = false, linkBaseUrl, imageInline = false, imageNodeView, dividerNodeView, mention = createLoomaMentionExtension(), disableHighlight = false, codeLanguages, codeLowlight, codeBlockNodeView, tableOfContentsNodeView, expandNodeView, calloutNodeView } = options;
 	const image = LoomaImage.configure({ inline: imageInline });
 	const codeBlock = LoomaCodeBlock.configure({ lowlight: codeLowlight ?? createLowlight(codeLanguages) });
 	return [
@@ -9860,7 +10083,7 @@ function getDefaultEditorExtensions(options = {}) {
 		TaskList,
 		TaskItem.configure({ nested: false }),
 		Blockquote,
-		LoomaCallout,
+		calloutNodeView ? LoomaCallout.extend({ addNodeView: () => calloutNodeView }) : LoomaCallout,
 		LoomaChip,
 		LoomaExpand.configure({ nodeView: expandNodeView ?? null }),
 		LoomaTableOfContents.configure({ nodeView: tableOfContentsNodeView ?? null }),
@@ -10307,27 +10530,65 @@ var CALLOUT_COMMANDS = [
 	},
 	{
 		title: "Note",
-		description: "Highlighted note",
+		description: "Muted aside",
 		tone: "note",
 		icon: "notebook-pen",
 		keywords: [
 			"note",
+			"aside",
+			"callout",
+			"panel"
+		]
+	},
+	{
+		title: "Tip",
+		description: "Helpful advice",
+		tone: "tip",
+		icon: "lightbulb",
+		keywords: [
+			"tip",
+			"hint",
+			"advice",
+			"callout",
+			"panel"
+		]
+	},
+	{
+		title: "Important",
+		description: "Must-read information",
+		tone: "important",
+		icon: "message-square-warning",
+		keywords: [
+			"important",
+			"key",
 			"callout",
 			"panel"
 		]
 	},
 	{
 		title: "Warning",
-		description: "Important warning",
+		description: "Proceed with care",
 		tone: "warning",
 		icon: "triangle-alert",
 		keywords: [
 			"warning",
-			"caution",
 			"alert",
 			"callout",
 			"panel"
 		]
+	},
+	{
+		title: "Danger",
+		description: "Harmful consequence",
+		tone: "danger",
+		icon: "circle-x",
+		keywords: [
+			"danger",
+			"caution",
+			"error",
+			"callout",
+			"panel"
+		]
 	}
 ];
 /**
@@ -10589,6 +10850,8 @@ function getDefaultSlashCommands(onOpenImagePicker, onOpenChipEditor, onOpenLink
 }
 function canRunDefaultCommand(title, { editor, range }) {
 	const chain = editor.can().chain().deleteRange(range);
+	const callout = CALLOUT_COMMANDS.find((command) => command.title === title);
+	if (callout) return chain.setLoomaCallout(callout.tone).run();
 	switch (title) {
 		case "Text": return editor.isActive("paragraph") || chain.setParagraph().run();
 		case "Heading 1": return editor.isActive("heading", { level: 1 }) || chain.setHeading({ level: 1 }).run();
@@ -10598,9 +10861,6 @@ function canRunDefaultCommand(title, { editor, range }) {
 		case "Numbered list": return chain.toggleOrderedList().run();
 		case "Checklist": return chain.toggleTaskList().run();
 		case "Blockquote": return chain.toggleBlockquote().run();
-		case "Info": return chain.setLoomaCallout("info").run();
-		case "Note": return chain.setLoomaCallout("note").run();
-		case "Warning": return chain.setLoomaCallout("warning").run();
 		case "Chip": return chain.insertLoomaChip({ label: "" }).run();
 		case "Inline code": return chain.toggleCode().run();
 		case "Code block": return chain.toggleCodeBlock().run();
@@ -10816,4 +11076,4 @@ function createLoomaSlashCommandExtension(options = {}) {
 	});
 }
 //#endregion
-export { LoomaImage as A, normalizeLoomaChipColor as B, siteRelativeHref as C, MAX_MENTION_RESULT_LIMIT as D, DEFAULT_MENTION_RESULT_LIMIT as E, normalizeTableOfContentsConfig as F, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS as G, LoomaCallout as H, LoomaExpand as I, LoomaActiveBlock as K, revealLoomaExpandAt as L, normalizeImagePlacement as M, LoomaTableOfContents as N, filterLoomaMentionItems as O, getTableOfContentsEntries as P, LOOMA_CHIP_COLORS as R, createSiteRelativeLinks as S, createLoomaMentionExtension as T, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS as U, LOOMA_CALLOUT_TONES as V, LOOMA_ACTIVE_BLOCK_CLASS as W, getActiveTableCellAlignment as _, getActiveTableUiState as a, setActiveTableCellBackground as b, insertTableAtRange as c, LoomaTableKit as d, getDefaultEditorExtensions as f, LoomaTableHeader as g, LoomaTableCell as h, getDefaultSlashCommands as i, normalizeImageDimension as j, normalizeMentionResultLimit as k, normalizeActiveTableColumnWidths as l, LoomaTable as m, createLoomaSlashCommandExtension as n, handleTableAction as o, getLoomaTableExtensions as p, LoomaActiveBlockPluginKey as q, filterLoomaSlashCommands as r, handleTableOverlayAction as s, LoomaSlashCommand as t, shouldShowTextFormattingToolbar as u, getActiveTableCellBackground as v, LoomaMentionSuggestionPluginKey as w, LoomaSmartPaste as x, setActiveTableCellAlignment as y, LoomaChip as z };
+export { filterLoomaMentionItems as A, LOOMA_CHIP_COLORS as B, loomaMarkdownToHtml as C, createLoomaMentionExtension as D, LoomaMentionSuggestionPluginKey as E, LoomaTableOfContents as F, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS as G, normalizeLoomaChipColor as H, getTableOfContentsEntries as I, LoomaActiveBlock as J, LOOMA_ACTIVE_BLOCK_CLASS as K, normalizeTableOfContentsConfig as L, LoomaImage as M, normalizeImageDimension as N, DEFAULT_MENTION_RESULT_LIMIT as O, normalizeImagePlacement as P, LoomaExpand as R, loomaMarkdownFromDoc as S, siteRelativeHref as T, LOOMA_CALLOUT_TONES as U, LoomaChip as V, LoomaCallout as W, LoomaActiveBlockPluginKey as Y, getActiveTableCellAlignment as _, getActiveTableUiState as a, setActiveTableCellBackground as b, insertTableAtRange as c, LoomaTableKit as d, getDefaultEditorExtensions as f, LoomaTableHeader as g, LoomaTableCell as h, getDefaultSlashCommands as i, normalizeMentionResultLimit as j, MAX_MENTION_RESULT_LIMIT as k, normalizeActiveTableColumnWidths as l, LoomaTable as m, createLoomaSlashCommandExtension as n, handleTableAction as o, getLoomaTableExtensions as p, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS as q, filterLoomaSlashCommands as r, handleTableOverlayAction as s, LoomaSlashCommand as t, shouldShowTextFormattingToolbar as u, getActiveTableCellBackground as v, createSiteRelativeLinks as w, LoomaSmartPaste as x, setActiveTableCellAlignment as y, revealLoomaExpandAt as z };

package/editor/code-highlighting.d.ts

@@ -0,0 +1,25 @@
+import type { Editor } from "@tiptap/core";
+import { createLowlight } from "lowlight";
+import type { LoomaCodeLanguages } from "./extensions/preset.js";
+/** Code-block highlighting for one editor: its lowlight registry, picker languages, and grammar loading. */
+export interface LoomaCodeHighlighting {
+    /** The registry the code-block extension highlights with. */
+    readonly lowlight: ReturnType<typeof createLowlight>;
+    /** Languages the picker offers, in display order. */
+    readonly languageNames: readonly string[];
+    /**
+     * Loads the grammar a code block needs, then re-highlights the document.
+     *
+     * @contract Does nothing when the host supplied its own languages; each grammar loads once.
+     * @failure A failed import is forgotten so a later call retries it.
+     */
+    loadForCodeBlock(editor: Editor, language: unknown, value: string): void;
+}
+/**
+ * Highlighting from the host's `codeLanguages`, or, when that is null, from the built-in catalog,
+ * whose grammars load on demand and whose automatic detection uses a common subset.
+ *
+ * @lifecycle `onGrammarsLoaded` runs after each lazy load, before the document is re-highlighted,
+ * because the lowlight registry is mutable rather than reactive.
+ */
+export declare function createCodeHighlighting(codeLanguages: LoomaCodeLanguages | null, onGrammarsLoaded: () => void): LoomaCodeHighlighting;

package/editor/content.d.ts

@@ -0,0 +1,10 @@
+import type { JSONContent } from "@tiptap/core";
+/** Whether a controlled document already matches the editor, so applying it would only reset the selection. */
+export declare function sameDocument(left: JSONContent, right: JSONContent): boolean;
+/**
+ * A link destination the editor may store: a site-relative path, fragment, or query, or an
+ * absolute http, https, mailto, or tel URL.
+ *
+ * @failure Returns null for empty input, control characters, other schemes, and unparseable URLs.
+ */
+export declare function validLinkHref(value: string): string | null;

package/editor/extensions/callout.d.ts

@@ -1,6 +1,9 @@
 import { Node } from "@tiptap/core";
-/** Canonical tone values that may be persisted in a Looma callout node. */
-export declare const LOOMA_CALLOUT_TONES: readonly ["info", "note", "warning"];
+/**
+ * Canonical tone values that may be persisted in a Looma callout node: the shared block
+ * vocabulary of Callout, Markdown `:::` containers and GitHub alerts.
+ */
+export declare const LOOMA_CALLOUT_TONES: readonly ["note", "tip", "info", "important", "warning", "danger"];
 /** A serialized callout tone; unsupported input is normalized to `note`. */
 export type LoomaCalloutTone = (typeof LOOMA_CALLOUT_TONES)[number];
 declare module "@tiptap/core" {
@@ -11,10 +14,13 @@ declare module "@tiptap/core" {
         };
     }
 }
+/** Maps a tone name, alias, or unknown value onto a persisted tone. */
+export declare function normalizeLoomaCalloutTone(value: unknown): LoomaCalloutTone;
 /**
- * A durable, themeable block container for informational editor content.
+ * A durable block container for informational editor content, saved as Looma's Callout.
  *
- * @invariant Parsed and rendered `data-tone` values always belong to
- * `LOOMA_CALLOUT_TONES`; missing or unknown values round-trip as `note`.
+ * @invariant Rendered `tone` values always belong to `LOOMA_CALLOUT_TONES`; missing or
+ * unknown values round-trip as `note`. Content saved as the older
+ * `aside[data-looma-callout][data-tone]` still parses.
  */
 export declare const LoomaCallout: Node<any, any>;

package/editor/extensions/index.d.ts

@@ -13,6 +13,7 @@ export { LoomaExpand, revealLoomaExpandAt, type LoomaExpandAttributes } from "./
 export { LoomaTableOfContents, getTableOfContentsEntries, normalizeTableOfContentsConfig, type LoomaTableOfContentsConfig, type LoomaTableOfContentsEntry, type LoomaTableOfContentsFormat, } from "./table-of-contents.js";
 export { getDefaultEditorExtensions, getLoomaTableExtensions, LoomaTableKit, type DefaultEditorExtensionsOptions, type LoomaCodeLanguages, } from "./preset.js";
 export { LoomaSmartPaste } from "./smart-paste.js";
+export { loomaMarkdownFromDoc, loomaMarkdownToHtml } from "./markdown.js";
 export { getActiveTableUiState, handleTableAction, handleTableOverlayAction, insertTableAtRange, normalizeActiveTableColumnWidths, shouldShowTextFormattingToolbar, type ActiveTableUiState, type InsertTableAtRangeOptions, type TableActionCapabilities, } from "./table-commands.js";
 export { LoomaTable, getActiveTableCellAlignment, getActiveTableCellBackground, LoomaTableCell, LoomaTableHeader, setActiveTableCellAlignment, setActiveTableCellBackground, TABLE_CELL_BACKGROUND_PRESETS, type TableCellAlignment, type TableCellBackground, } from "./table-formatting.js";
 export { createLoomaMentionExtension, DEFAULT_MENTION_RESULT_LIMIT, filterLoomaMentionItems, LoomaMentionSuggestionPluginKey, MAX_MENTION_RESULT_LIMIT, normalizeMentionResultLimit, type LoomaMentionItem, type LoomaMentionMenuSnapshot, type LoomaMentionOptions, type LoomaMentionProvider, type LoomaMentionProviderContext, } from "./mention.js";

package/editor/extensions/index.js

@@ -1,3 +1,3 @@
 import { n as TABLE_CELL_BACKGROUND_PRESETS } from "../chunks/table-backgrounds.js";
-import { A as LoomaImage, B as normalizeLoomaChipColor, C as siteRelativeHref, D as MAX_MENTION_RESULT_LIMIT, E as DEFAULT_MENTION_RESULT_LIMIT, F as normalizeTableOfContentsConfig, G as LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, H as LoomaCallout, I as LoomaExpand, K as LoomaActiveBlock, L as revealLoomaExpandAt, M as normalizeImagePlacement, N as LoomaTableOfContents, O as filterLoomaMentionItems, P as getTableOfContentsEntries, R as LOOMA_CHIP_COLORS, S as createSiteRelativeLinks, T as createLoomaMentionExtension, U as LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, V as LOOMA_CALLOUT_TONES, W as LOOMA_ACTIVE_BLOCK_CLASS, _ as getActiveTableCellAlignment, a as getActiveTableUiState, b as setActiveTableCellBackground, c as insertTableAtRange, d as LoomaTableKit, f as getDefaultEditorExtensions, g as LoomaTableHeader, h as LoomaTableCell, i as getDefaultSlashCommands, j as normalizeImageDimension, k as normalizeMentionResultLimit, l as normalizeActiveTableColumnWidths, m as LoomaTable, n as createLoomaSlashCommandExtension, o as handleTableAction, p as getLoomaTableExtensions, q as LoomaActiveBlockPluginKey, r as filterLoomaSlashCommands, s as handleTableOverlayAction, t as LoomaSlashCommand, u as shouldShowTextFormattingToolbar, v as getActiveTableCellBackground, w as LoomaMentionSuggestionPluginKey, x as LoomaSmartPaste, y as setActiveTableCellAlignment, z as LoomaChip } from "../chunks/extensions.js";
-export { DEFAULT_MENTION_RESULT_LIMIT, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, LOOMA_ACTIVE_BLOCK_CLASS, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, LOOMA_CALLOUT_TONES, LOOMA_CHIP_COLORS, LoomaActiveBlock, LoomaActiveBlockPluginKey, LoomaCallout, LoomaChip, LoomaExpand, LoomaImage, LoomaMentionSuggestionPluginKey, LoomaSlashCommand, LoomaSmartPaste, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, LoomaTableOfContents, MAX_MENTION_RESULT_LIMIT, TABLE_CELL_BACKGROUND_PRESETS, createLoomaMentionExtension, createLoomaSlashCommandExtension, createSiteRelativeLinks, filterLoomaMentionItems, filterLoomaSlashCommands, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, getTableOfContentsEntries, handleTableAction, handleTableOverlayAction, insertTableAtRange, normalizeActiveTableColumnWidths, normalizeImageDimension, normalizeImagePlacement, normalizeLoomaChipColor, normalizeMentionResultLimit, normalizeTableOfContentsConfig, revealLoomaExpandAt, setActiveTableCellAlignment, setActiveTableCellBackground, shouldShowTextFormattingToolbar, siteRelativeHref };
+import { A as filterLoomaMentionItems, B as LOOMA_CHIP_COLORS, C as loomaMarkdownToHtml, D as createLoomaMentionExtension, E as LoomaMentionSuggestionPluginKey, F as LoomaTableOfContents, G as LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, H as normalizeLoomaChipColor, I as getTableOfContentsEntries, J as LoomaActiveBlock, K as LOOMA_ACTIVE_BLOCK_CLASS, L as normalizeTableOfContentsConfig, M as LoomaImage, N as normalizeImageDimension, O as DEFAULT_MENTION_RESULT_LIMIT, P as normalizeImagePlacement, R as LoomaExpand, S as loomaMarkdownFromDoc, T as siteRelativeHref, U as LOOMA_CALLOUT_TONES, V as LoomaChip, W as LoomaCallout, Y as LoomaActiveBlockPluginKey, _ as getActiveTableCellAlignment, a as getActiveTableUiState, b as setActiveTableCellBackground, c as insertTableAtRange, d as LoomaTableKit, f as getDefaultEditorExtensions, g as LoomaTableHeader, h as LoomaTableCell, i as getDefaultSlashCommands, j as normalizeMentionResultLimit, k as MAX_MENTION_RESULT_LIMIT, l as normalizeActiveTableColumnWidths, m as LoomaTable, n as createLoomaSlashCommandExtension, o as handleTableAction, p as getLoomaTableExtensions, q as LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, r as filterLoomaSlashCommands, s as handleTableOverlayAction, t as LoomaSlashCommand, u as shouldShowTextFormattingToolbar, v as getActiveTableCellBackground, w as createSiteRelativeLinks, x as LoomaSmartPaste, y as setActiveTableCellAlignment, z as revealLoomaExpandAt } from "../chunks/extensions.js";
+export { DEFAULT_MENTION_RESULT_LIMIT, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, LOOMA_ACTIVE_BLOCK_CLASS, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, LOOMA_CALLOUT_TONES, LOOMA_CHIP_COLORS, LoomaActiveBlock, LoomaActiveBlockPluginKey, LoomaCallout, LoomaChip, LoomaExpand, LoomaImage, LoomaMentionSuggestionPluginKey, LoomaSlashCommand, LoomaSmartPaste, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, LoomaTableOfContents, MAX_MENTION_RESULT_LIMIT, TABLE_CELL_BACKGROUND_PRESETS, createLoomaMentionExtension, createLoomaSlashCommandExtension, createSiteRelativeLinks, filterLoomaMentionItems, filterLoomaSlashCommands, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, getTableOfContentsEntries, handleTableAction, handleTableOverlayAction, insertTableAtRange, loomaMarkdownFromDoc, loomaMarkdownToHtml, normalizeActiveTableColumnWidths, normalizeImageDimension, normalizeImagePlacement, normalizeLoomaChipColor, normalizeMentionResultLimit, normalizeTableOfContentsConfig, revealLoomaExpandAt, setActiveTableCellAlignment, setActiveTableCellBackground, shouldShowTextFormattingToolbar, siteRelativeHref };

package/editor/extensions/markdown.d.ts

@@ -0,0 +1,18 @@
+import MarkdownIt from "markdown-it";
+import { type Node as ProseMirrorNode } from "@tiptap/pm/model";
+/** The markdown-it instance LoomaEditor imports Markdown with, shared block vocabulary included. */
+export declare const loomaMarkdown: MarkdownIt;
+/**
+ * Renders Markdown, including the shared block vocabulary, as HTML the editor parses.
+ * @contract The result is not sanitized; pass it to the editor's `setContent`, whose schema
+ * keeps only content it knows.
+ */
+export declare function loomaMarkdownToHtml(source: string): string;
+/**
+ * Writes an editor document as Markdown, with callouts and expand sections in the shared
+ * `:::` syntax that `loomaMarkdownToHtml` and Markupress read.
+ * @contract Content Markdown has no syntax for (tables, task lists, images, chips, mentions,
+ * the table of contents) is written as its saved HTML, which Markdown carries unchanged.
+ * Marks without a Markdown form other than underline and highlight are dropped.
+ */
+export declare function loomaMarkdownFromDoc(doc: ProseMirrorNode): string;

package/editor/extensions/preset.d.ts

@@ -43,6 +43,8 @@ export interface DefaultEditorExtensionsOptions {
     tableOfContentsNodeView?: NodeViewRenderer;
     /** Optional section settings; the shared schema owns summary and body content. */
     expandNodeView?: NodeViewRenderer;
+    /** Renders callouts while editing; saved HTML stays `<ui-callout>` either way. */
+    calloutNodeView?: NodeViewRenderer;
 }
 /**
  * Complete Looma table schema as one Tiptap extension.

package/editor/icons.d.ts

@@ -45,8 +45,10 @@ export declare const LOOMA_ICONS: {
     list: IconNode;
     'list-ordered': IconNode;
     'list-todo': IconNode;
+    lightbulb: IconNode;
     loader: IconNode;
     merge: IconNode;
+    'message-square-warning': IconNode;
     'notebook-pen': IconNode;
     minus: IconNode;
     'paint-bucket': IconNode;

package/{vue/editor → editor}/image-delivery.d.ts

@@ -1,5 +1,5 @@
 import { Extension, type Editor, type JSONContent } from "@tiptap/core";
-export { normalizeImageDimension } from "../../editor/extensions/image.js";
+export { normalizeImageDimension } from "./extensions/image.js";
 /** What caused an overlay to open or close. */
 type OverlayTrigger = "keyboard" | "pointer" | "programmatic";
 /**