@threadlabs/looma 0.28.15 → 0.28.17

package/editor/chunks/extensions.js

@@ -8,8 +8,8 @@ import { dropCursor } from "@tiptap/pm/dropcursor";
 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 MarkdownIt from "markdown-it";
 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,10 +127,10 @@ var LoomaActiveBlock = Extension.create({
 	}
 });
 //#endregion
-//#region src/editor/extensions/callout.ts
+//#region src/markdown/index.ts
 /**
-* Canonical tone values that may be persisted in a Looma callout node: the shared block
-* vocabulary of Callout, Markdown `:::` containers and GitHub alerts.
+* Callout tones a document stores, in the order the editor offers them. The Callout component also
+* takes `neutral` and `success`, which Markdown and the editor store as `note`.
 */
 var LOOMA_CALLOUT_TONES = [
 	"note",
@@ -140,17 +140,202 @@ var LOOMA_CALLOUT_TONES = [
 	"warning",
 	"danger"
 ];
-var TONE_ALIASES = {
+/** Names that read as a stored tone: `caution` is `danger`, and `neutral` is the same muted aside as `note`. */
+var LOOMA_CALLOUT_TONE_ALIASES = {
 	caution: "danger",
 	neutral: "note"
 };
-/** Maps a tone name, alias, or unknown value onto a persisted tone. */
+/**
+* Maps a tone name or alias, in any case, onto a stored tone.
+* @failure Unknown and non-string values become `note`.
+*/
 function normalizeLoomaCalloutTone(value) {
 	if (typeof value !== "string") return "note";
 	const tone = value.toLowerCase();
-	return LOOMA_CALLOUT_TONES.includes(tone) ? tone : TONE_ALIASES[tone] ?? "note";
+	return LOOMA_CALLOUT_TONES.includes(tone) ? tone : LOOMA_CALLOUT_TONE_ALIASES[tone] ?? "note";
+}
+/** The hues chips and swatches take as their tone, written `:chip[Label]{tone=green}`. */
+var LOOMA_CHIP_TONES = [
+	"neutral",
+	"blue",
+	"green",
+	"yellow",
+	"red",
+	"purple"
+];
+/**
+* Keeps a chip tone within the palette.
+* @failure Unknown values become `neutral`.
+*/
+function normalizeLoomaChipTone(value) {
+	return LOOMA_CHIP_TONES.includes(value) ? value : "neutral";
+}
+/**
+* Names that open a `:::` container, matched without regard to case. A container with any other
+* name is ordinary text.
+*/
+var LOOMA_CONTAINER_NAMES = /* @__PURE__ */ new Set([
+	...LOOMA_CALLOUT_TONES,
+	"caution",
+	"details",
+	"figure",
+	"tabs",
+	"code-group"
+]);
+var ATTRIBUTE_KEY = /[A-Za-z][\w-]*/y;
+var ATTRIBUTE_ID = /#([\w-]+)/y;
+var ATTRIBUTE_VALUE = /[^\s"'=<>`{}]+/y;
+function sticky(pattern, source, index) {
+	pattern.lastIndex = index;
+	return pattern.exec(source);
+}
+/**
+* Reads a brace attribute list starting at `source[start]`, which must be `{`.
+* @contract Returns the attributes and the index just past the closing brace.
+* @failure Returns null for anything that is not a complete, well-formed list, so the text stays literal.
+*/
+function readLoomaAttributes(source, start = 0) {
+	if (source[start] !== "{") return null;
+	const attributes = {};
+	let index = start + 1;
+	for (;;) {
+		while (source[index] === " " || source[index] === "	") index++;
+		if (source[index] === "}") return {
+			attributes,
+			end: index + 1
+		};
+		if (index > start + 1 && !/\s/.test(source[index - 1])) return null;
+		const id = sticky(ATTRIBUTE_ID, source, index);
+		if (id) {
+			attributes.id = id[1];
+			index += id[0].length;
+			continue;
+		}
+		const key = sticky(ATTRIBUTE_KEY, source, index);
+		if (!key) return null;
+		index += key[0].length;
+		if (source[index] !== "=") {
+			attributes[key[0]] = true;
+			continue;
+		}
+		index++;
+		const quote = source[index];
+		if (quote === "\"" || quote === "'") {
+			const close = source.indexOf(quote, index + 1);
+			if (close < 0) return null;
+			attributes[key[0]] = source.slice(index + 1, close);
+			index = close + 1;
+			continue;
+		}
+		const value = sticky(ATTRIBUTE_VALUE, source, index);
+		if (!value) return null;
+		attributes[key[0]] = value[0];
+		index += value[0].length;
+	}
+}
+/**
+* Reads a whole string as one brace attribute list.
+* @failure Returns null unless the string is exactly one well-formed list.
+*/
+function parseLoomaAttributes(source) {
+	const read = readLoomaAttributes(source);
+	return read && read.end === source.length ? read.attributes : null;
+}
+/**
+* Writes attributes as a brace list, `id` first as `#id`, then the rest in order.
+* @contract `true` writes a bare key; values are quoted only when they need it. `false`, null and
+* undefined values are left out, and an empty set writes an empty string. An ID that `#` cannot
+* carry, or any ID when `hashId` is false, is written `id=…`.
+*/
+function formatLoomaAttributes(attributes, { hashId = true } = {}) {
+	const items = [];
+	const { id, ...rest } = attributes;
+	const hashed = hashId && typeof id === "string" && /^[\w-]+$/.test(id);
+	if (hashed) items.push(`#${id}`);
+	for (const [key, value] of Object.entries(hashed ? rest : attributes)) if (value === true) items.push(key);
+	else if (value === false || value === null || value === void 0) continue;
+	else {
+		const text = String(value);
+		items.push(/^[^\s"'=<>`{}]+$/.test(text) ? `${key}=${text}` : text.includes("\"") ? `${key}='${text}'` : `${key}="${text}"`);
+	}
+	return items.length ? `{${items.join(" ")}}` : "";
+}
+/**
+* The anchor a heading's text derives: NFC, lowercase, keeping letters, numbers and combining
+* marks, with every other run of characters one hyphen.
+* @failure Text with no letters or numbers, such as only emoji, derives `heading`.
+*/
+function loomaHeadingSlug(text) {
+	return text.normalize("NFC").toLowerCase().replace(/[^\p{L}\p{N}\p{M}]+/gu, "-").replace(/^-+|-+$/g, "") || "heading";
 }
 /**
+* Gives every heading of a document its anchor, in document order.
+* @contract A custom ID is kept unless an earlier heading already has it. Any other heading takes
+* its slug, or the slug's first free suffix (`-1`, `-2`…), never one a later custom ID reserves.
+*/
+function assignLoomaHeadingIds(headings) {
+	const reserved = new Set(headings.map(({ id }) => id).filter((id) => Boolean(id)));
+	const used = /* @__PURE__ */ new Set();
+	return headings.map(({ text, id: custom }) => {
+		let id = custom || loomaHeadingSlug(text);
+		if (custom ? used.has(id) : used.has(id) || reserved.has(id)) {
+			const stem = id;
+			let suffix = 1;
+			while (used.has(`${stem}-${suffix}`) || reserved.has(`${stem}-${suffix}`)) suffix++;
+			id = `${stem}-${suffix}`;
+		}
+		used.add(id);
+		return id;
+	});
+}
+/** Reads a fence's info string: ```` ```ts title="a.ts" {1,3-5} :line-numbers ````. */
+function parseLoomaFenceInfo(info) {
+	const source = info.trim();
+	const language = /^[^\s={:]+(?=[\s{:]|$)/.exec(source)?.[0];
+	const meta = (language ? source.slice(language.length) : source).trim();
+	const title = /(?:^|\s)title="([^"]*)"/.exec(meta)?.[1];
+	const rest = meta.replace(/(?:^|\s)title="[^"]*"/, "");
+	const lines = /* @__PURE__ */ new Set();
+	for (const range of /\{([\d\s,-]+)\}/.exec(rest)?.[1].split(",") ?? []) {
+		const [from = NaN, to = from] = range.split("-").map((part) => Number.parseInt(part, 10));
+		for (let line = from; line <= to; line++) lines.add(line);
+	}
+	const numbers = /:(no-)?line-numbers(?![\w-])/.exec(rest);
+	return {
+		...language ? { language } : {},
+		meta,
+		...title !== void 0 ? { title } : {},
+		lines: [...lines].sort((a, b) => a - b),
+		...numbers ? { lineNumbers: numbers[1] === void 0 } : {}
+	};
+}
+/**
+* Splits YAML front matter from the start of a document.
+* @contract Front matter opens with a `---` line at the very start, holds at least one `key: value`
+* line, and closes at a `---` or `...` line. `source` is the block as written, delimiters included.
+* @failure Returns null when the document has none.
+*/
+function splitLoomaFrontmatter(document) {
+	const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/.exec(document.slice(0, 8192));
+	if (!match || !/^[A-Za-z][\w-]*:[ \t]*\S/m.test(match[1])) return null;
+	return {
+		source: match[0].trimEnd(),
+		yaml: match[1],
+		body: document.slice(match[0].length)
+	};
+}
+/** The colons a container opens and closes with, given how deeply containers nest inside it. */
+function loomaContainerMarker(nestedDepth) {
+	return ":".repeat(3 + Math.max(0, nestedDepth));
+}
+/** A backtick fence longer than any run of backticks in the code, and at least three long. */
+function loomaCodeFence(code) {
+	const longest = Math.max(0, ...(code.match(/`+/g) ?? []).map((run) => run.length));
+	return "`".repeat(Math.max(3, longest + 1));
+}
+//#endregion
+//#region src/editor/extensions/callout.ts
+/**
 * A durable block container for informational editor content, saved as Looma's Callout.
 *
 * @invariant Rendered `tone` values always belong to `LOOMA_CALLOUT_TONES`; missing or
@@ -196,19 +381,12 @@ var LoomaCallout = Node$1.create({
 });
 //#endregion
 //#region src/editor/extensions/chip.ts
-/** The six palette values a chip may persist; other values fall back to neutral. */
-var LOOMA_CHIP_COLORS = [
-	"neutral",
-	"blue",
-	"green",
-	"yellow",
-	"red",
-	"purple"
-];
+/** The six palette values a chip may persist, Looma Markdown's chip tones; other values fall back to neutral. */
+var LOOMA_CHIP_COLORS = LOOMA_CHIP_TONES;
 var CHIP_PLACEHOLDER = "Set a label";
 /** Keep imported or programmatic colors within the supported palette. */
 function normalizeLoomaChipColor(value) {
-	return LOOMA_CHIP_COLORS.includes(value) ? value : "neutral";
+	return normalizeLoomaChipTone(value);
 }
 /**
 * An inline, atomic label. The editor's popover edits its attributes; its text
@@ -466,6 +644,144 @@ var LoomaExpand = Node$1.create({
 	}
 });
 //#endregion
+//#region src/editor/extensions/figure.ts
+/**
+* An image with a caption, saved as `<figure><img><figcaption>` and written in Looma Markdown as
+* `::: figure Caption`. The caption is inline content the author edits in place.
+* @invariant A figure holds exactly one block image and one caption; an empty caption stays empty.
+*/
+var LoomaFigure = Node$1.create({
+	name: "loomaFigure",
+	group: "block",
+	content: "image loomaFigcaption",
+	defining: true,
+	parseHTML() {
+		return [{
+			tag: "figure",
+			getAttrs: (element) => element.querySelector(":scope > img") ? null : false
+		}];
+	},
+	renderHTML() {
+		return ["figure", 0];
+	}
+});
+/**
+* A figure's caption: inline content under its image.
+* @invariant It exists only as the second child of `LoomaFigure`.
+*/
+var LoomaFigcaption = Node$1.create({
+	name: "loomaFigcaption",
+	content: "inline*",
+	defining: true,
+	parseHTML() {
+		return [{ tag: "figcaption" }];
+	},
+	renderHTML() {
+		return ["figcaption", 0];
+	}
+});
+//#endregion
+//#region src/editor/extensions/tabs.ts
+/**
+* Tabs or a code group, kept whole so Looma Markdown's `::: tabs` and `::: code-group` survive
+* editing. Saved as `<ui-tabs group>` with a `<section aria-label>` per panel.
+* @contract While editing, panels show one after another under their labels; the Tabs component
+* draws them only where the saved HTML renders.
+*/
+var LoomaTabs = Node$1.create({
+	name: "loomaTabs",
+	group: "block",
+	content: "loomaTab+",
+	defining: true,
+	isolating: true,
+	addAttributes() {
+		return {
+			group: {
+				default: "",
+				parseHTML: (element) => element.getAttribute("group") ?? "",
+				renderHTML: (attributes) => attributes.group ? { group: attributes.group } : {}
+			},
+			codeGroup: {
+				default: false,
+				parseHTML: (element) => element.classList.contains("code-group"),
+				renderHTML: (attributes) => attributes.codeGroup ? { class: "code-group" } : {}
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: "ui-tabs" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"ui-tabs",
+			HTMLAttributes,
+			0
+		];
+	},
+	addNodeView() {
+		return () => {
+			const dom = document.createElement("div");
+			dom.dataset.loomaTabs = "";
+			return {
+				dom,
+				contentDOM: dom
+			};
+		};
+	}
+});
+/**
+* One panel of `LoomaTabs`, labelled by `label`.
+* @invariant It exists only inside `LoomaTabs`; its label is the tab Tabs shows and the `== Label` line Markdown writes.
+*/
+var LoomaTab = Node$1.create({
+	name: "loomaTab",
+	content: "block+",
+	defining: true,
+	isolating: true,
+	addAttributes() {
+		return { label: {
+			default: "",
+			parseHTML: (element) => element.getAttribute("aria-label") ?? "",
+			renderHTML: (attributes) => ({ "aria-label": attributes.label })
+		} };
+	},
+	parseHTML() {
+		return [{ tag: "ui-tabs > section" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"section",
+			HTMLAttributes,
+			0
+		];
+	},
+	addNodeView() {
+		return ({ node }) => {
+			let current = node;
+			const dom = document.createElement("section");
+			const label = document.createElement("div");
+			label.contentEditable = "false";
+			label.dataset.loomaTabLabel = "";
+			label.textContent = node.attrs.label;
+			const contentDOM = document.createElement("div");
+			dom.setAttribute("aria-label", node.attrs.label);
+			dom.append(label, contentDOM);
+			return {
+				dom,
+				contentDOM,
+				update(next) {
+					if (next.type !== current.type) return false;
+					current = next;
+					label.textContent = next.attrs.label;
+					dom.setAttribute("aria-label", next.attrs.label);
+					return true;
+				},
+				ignoreMutation: (mutation) => mutation.type !== "selection" && !contentDOM.contains(mutation.target)
+			};
+		};
+	}
+});
+//#endregion
 //#region src/editor/extensions/table-of-contents.ts
 /** Normalize loaded configuration without persisting unsupported presentation values. */
 function normalizeTableOfContentsConfig(attributes) {
@@ -512,7 +828,17 @@ function tableOfContentsTree(entries) {
 	}
 	return roots;
 }
-function anchorTransaction(state) {
+var derivedFrom = (id, text) => {
+	const slug = loomaHeadingSlug(text);
+	return id === slug || id.startsWith(`${slug}-`) && /^\d+$/.test(id.slice(slug.length + 1));
+};
+/**
+* Keeps heading anchors on Looma Markdown's rule. An anchor derived from its heading's text
+* (as it read before this change) follows the text; any other, including `looma-heading-N` anchors
+* saved before this rule, is a custom anchor and stays, so links to it keep working. With
+* a table of contents every heading gets an anchor; without one, only headings that have one.
+*/
+function anchorTransaction(state, previous) {
 	let hasToc = false;
 	const headings = [];
 	state.doc.descendants((node, position) => {
@@ -522,24 +848,28 @@ function anchorTransaction(state) {
 			position
 		});
 	});
-	if (!hasToc) return null;
-	const reserved = new Set(headings.map(({ node }) => String(node.attrs.id ?? "")).filter(Boolean));
-	const used = /* @__PURE__ */ new Set();
+	if (!headings.length) return null;
+	const before = /* @__PURE__ */ new Map();
+	previous?.descendants((node) => {
+		if (node.type.name === "heading" && typeof node.attrs.id === "string") before.set(node.attrs.id, node.textContent.trim());
+	});
+	const custom = (node) => {
+		const id = node.attrs.id;
+		if (typeof id !== "string" || !id || /\s/.test(id)) return void 0;
+		return derivedFrom(id, before.get(id) ?? node.textContent.trim()) ? void 0 : id;
+	};
+	const ids = assignLoomaHeadingIds(headings.map(({ node }) => ({
+		text: node.textContent.trim(),
+		id: custom(node)
+	})));
 	const transaction = state.tr;
-	let sequence = 1;
-	for (const { node, position } of headings) {
-		let id = typeof node.attrs.id === "string" ? node.attrs.id : "";
-		if (!id || /\s/.test(id) || used.has(id)) {
-			do
-				id = `looma-heading-${sequence++}`;
-			while (reserved.has(id) || used.has(id));
-			transaction.setNodeMarkup(position, void 0, {
-				...node.attrs,
-				id
-			});
-		}
-		used.add(id);
-	}
+	headings.forEach(({ node, position }, index) => {
+		if (node.attrs.id === ids[index] || !hasToc && !node.attrs.id) return;
+		transaction.setNodeMarkup(position, void 0, {
+			...node.attrs,
+			id: ids[index]
+		});
+	});
 	return transaction.docChanged ? transaction : null;
 }
 var LoomaHeadingAnchors = Extension.create({
@@ -555,7 +885,7 @@ var LoomaHeadingAnchors = Extension.create({
 		if (transaction) this.editor.view.dispatch(transaction.setMeta("addToHistory", false));
 	},
 	addProseMirrorPlugins() {
-		return [new Plugin({ appendTransaction: (transactions, _oldState, state) => transactions.some((transaction) => transaction.docChanged) ? anchorTransaction(state) : null })];
+		return [new Plugin({ appendTransaction: (transactions, oldState, state) => transactions.some((transaction) => transaction.docChanged) ? anchorTransaction(state, oldState.doc) : null })];
 	}
 });
 function contentsHtml(doc, config) {
@@ -9165,47 +9495,96 @@ 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]*$/;
+//#region src/markdown/markdown-it.ts
+var CONTAINER_OPEN = /^(:{3,})[ \t]*([A-Za-z][\w-]*)(?:[ \t]+(.*?))?[ \t]*$/;
 var CONTAINER_CLOSE = /^:{3,}[ \t]*$/;
+var FENCE_OPEN = /^(`{3,}|~{3,})/;
+var TAB_LABEL = /^==[ \t]+(\S.*?)[ \t]*$/;
 var OPEN_FLAG = /[ \t]*\{open\}$/;
 var ALERT = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][ \t]*(?:\n|$)/i;
+var LEAF = /^::([A-Za-z][\w-]*)(\{.*\})?[ \t]*$/;
+var TASK = /^\[([ xX])\](?:[ \t]+|$)/;
+var TOC_FORMATS = /* @__PURE__ */ new Set([
+	"plain",
+	"bulleted",
+	"numbered"
+]);
+var PLACEMENTS = /* @__PURE__ */ new Set([
+	"block",
+	"center",
+	"wrap-left",
+	"wrap-right"
+]);
+var opensContainer = (text) => {
+	const match = CONTAINER_OPEN.exec(text);
+	return match && LOOMA_CONTAINER_NAMES.has(match[2].toLowerCase()) ? match : null;
+};
 function lineText(state, line) {
 	return state.src.slice(state.bMarks[line] + state.tShift[line], state.eMarks[line]);
 }
+function frontmatter(state, startLine, _endLine, silent) {
+	if (startLine !== 0 || state.blkIndent !== 0) return false;
+	const split = splitLoomaFrontmatter(state.src);
+	if (!split) return false;
+	if (silent) return true;
+	const lines = split.source.split("\n").length;
+	const token = state.push("looma_frontmatter", "", 0);
+	Object.assign(token, {
+		content: split.yaml,
+		block: true,
+		hidden: true,
+		map: [0, lines]
+	});
+	state.env.frontmatter = split.yaml;
+	state.line = lines;
+	return true;
+}
 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;
+	const match = opensContainer(lineText(state, startLine));
+	if (!match) return false;
 	if (silent) return true;
+	const name = match[2].toLowerCase();
+	const grouped = name === "tabs" || name === "code-group";
+	const labels = [];
 	let depth = 1;
+	let fence = null;
 	let next = startLine + 1;
 	for (; next < endLine; next++) {
-		if (state.sCount[next] < state.blkIndent) break;
 		const text = lineText(state, next);
+		if (text && state.sCount[next] < state.blkIndent) break;
+		if (fence) {
+			const close = FENCE_OPEN.exec(text);
+			if (close && close[1][0] === fence.char && close[1].length >= fence.length && !text.slice(close[1].length).trim()) fence = null;
+			continue;
+		}
+		const opener = FENCE_OPEN.exec(text);
+		if (opener) {
+			fence = {
+				char: opener[1][0],
+				length: opener[1].length
+			};
+			continue;
+		}
 		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++;
+		} else if (opensContainer(text)) depth++;
+		else if (grouped && depth === 1) {
+			const label = TAB_LABEL.exec(text);
+			if (label) labels.push({
+				line: next,
+				label: label[1]
+			});
+		}
 	}
-	const name = match[2].toLowerCase();
 	let title = (match[3] ?? "").trim();
-	const open = OPEN_FLAG.test(title);
-	title = title.replace(OPEN_FLAG, "");
+	const open = name === "details" && OPEN_FLAG.test(title);
+	if (name === "details") 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);
+	const opening = state.push("looma_container_open", "div", 1);
 	Object.assign(opening, {
 		info: name,
 		meta: {
@@ -9216,10 +9595,30 @@ function container(state, startLine, endLine, silent) {
 		map: [startLine, next],
 		markup: match[1]
 	});
-	state.md.block.tokenize(state, startLine + 1, next);
-	const closing = state.push("looma_container_close", "", -1);
+	const panel = (label, from, to) => {
+		state.push("looma_tab_open", "section", 1).meta = { label };
+		state.md.block.tokenize(state, from, to);
+		state.push("looma_tab_close", "section", -1);
+	};
+	if (labels.length) {
+		state.md.block.tokenize(state, startLine + 1, labels[0].line);
+		labels.forEach(({ line, label }, index) => panel(label, line + 1, labels[index + 1]?.line ?? next));
+	} else {
+		const first = state.tokens.length;
+		state.md.block.tokenize(state, startLine + 1, next);
+		if (name === "code-group") for (let index = state.tokens.length - 1; index >= first; index--) {
+			const token = state.tokens[index];
+			if (token.type !== "fence" || token.level !== opening.level + 1) continue;
+			const { title: fenceTitle, language } = parseLoomaFenceInfo(token.info);
+			const tabOpen = new state.Token("looma_tab_open", "section", 1);
+			tabOpen.meta = { label: fenceTitle ?? language ?? "Code" };
+			state.tokens.splice(index, 1, tabOpen, token, new state.Token("looma_tab_close", "section", -1));
+		}
+	}
+	const closing = state.push("looma_container_close", "div", -1);
 	Object.assign(closing, {
 		info: name,
+		meta: { title },
 		block: true,
 		markup: match[1]
 	});
@@ -9228,6 +9627,27 @@ function container(state, startLine, endLine, silent) {
 	state.line = Math.min(next + 1, endLine);
 	return true;
 }
+function leaf(state, startLine, _endLine, silent) {
+	if (state.sCount[startLine] - state.blkIndent >= 4) return false;
+	const match = LEAF.exec(lineText(state, startLine));
+	if (!match || match[1].toLowerCase() !== "toc") return false;
+	const attributes = match[2] ? parseLoomaAttributes(match[2]) : {};
+	if (!attributes) return false;
+	if (silent) return true;
+	const format = typeof attributes.format === "string" && TOC_FORMATS.has(attributes.format) ? attributes.format : "plain";
+	const depth = attributes.depth === "1" || attributes.depth === "2" ? Number(attributes.depth) : 3;
+	const token = state.push("looma_toc", "nav", 0);
+	Object.assign(token, {
+		block: true,
+		map: [startLine, startLine + 1],
+		meta: {
+			format,
+			depth
+		}
+	});
+	state.line = startLine + 1;
+	return true;
+}
 function alerts(state) {
 	const tokens = state.tokens;
 	for (let index = 0; index < tokens.length; index++) {
@@ -9246,78 +9666,363 @@ function alerts(state) {
 		}
 	}
 }
-function withSharedBlocks(md) {
+function taskLists(state) {
+	const tokens = state.tokens;
+	for (let index = 0; index < tokens.length; index++) {
+		if (tokens[index].type !== "bullet_list_open") continue;
+		const level = tokens[index].level;
+		const items = [];
+		let isTaskList = true;
+		for (let cursor = index + 1; cursor < tokens.length; cursor++) {
+			const token = tokens[cursor];
+			if (token.type === "bullet_list_close" && token.level === level) break;
+			if (token.type !== "list_item_open" || token.level !== level + 1) continue;
+			const inline = tokens[cursor + 2];
+			const match = tokens[cursor + 1]?.type === "paragraph_open" && inline?.type === "inline" ? TASK.exec(inline.content) : null;
+			if (!match) {
+				isTaskList = false;
+				break;
+			}
+			items.push({
+				item: token,
+				inline,
+				checked: match[1] !== " "
+			});
+		}
+		if (!isTaskList || !items.length) continue;
+		tokens[index].attrSet("data-type", "taskList");
+		for (const { item, inline, checked } of items) {
+			inline.content = inline.content.replace(TASK, "");
+			item.attrSet("data-type", "taskItem");
+			item.attrSet("data-checked", String(checked));
+			item.meta = { checked };
+		}
+	}
+}
+function directive(state, silent) {
+	const { src, pos } = state;
+	if (src.charCodeAt(pos) !== 58) return false;
+	const name = /^:(chip|mention)\[/.exec(src.slice(pos, pos + 10))?.[1];
+	if (!name) return false;
+	let label = "";
+	let index = pos + name.length + 2;
+	for (; index < state.posMax && src[index] !== "]"; index++) {
+		if (src[index] === "\\" && index + 1 < state.posMax) index++;
+		label += src[index];
+	}
+	if (src[index] !== "]") return false;
+	const read = src[index + 1] === "{" ? readLoomaAttributes(src, index + 1) : {
+		attributes: {},
+		end: index + 1
+	};
+	if (!read || read.end > state.posMax) return false;
+	if (name === "mention" && typeof read.attributes.id !== "string") return false;
+	if (!silent) {
+		const token = state.push(`looma_${name}`, "span", 0);
+		token.meta = {
+			label,
+			attributes: read.attributes
+		};
+	}
+	state.pos = read.end;
+	return true;
+}
+function inlineText(token) {
+	return (token?.children ?? []).map((child) => child.type === "image" ? inlineText(child) : child.content).join("");
+}
+function attributes(state) {
+	const headings = [];
+	const tokens = state.tokens;
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.type !== "inline" || !token.children) continue;
+		const children = token.children;
+		for (let child = children.length - 3; child >= 0; child--) {
+			const text = children[child + 1];
+			if (children[child].type !== "link_open" || children[child].markup !== "linkify" || /^(?:[a-z][\w+.-]*:|www\.)/i.test(text.content)) continue;
+			children.splice(child, 3, Object.assign(new state.Token("text", "", 0), { content: text.content }));
+		}
+		if (tokens[index - 1]?.type === "heading_open") {
+			const last = children.at(-1);
+			const marker = last?.type === "text" ? /[ \t]+(\{[^{}]*\})$/.exec(last.content) : null;
+			const parsed = marker && parseLoomaAttributes(marker[1]);
+			let id;
+			if (last && marker && parsed && typeof parsed.id === "string") {
+				id = parsed.id;
+				last.content = last.content.slice(0, marker.index);
+			}
+			headings.push({
+				open: tokens[index - 1],
+				text: inlineText(token).trim(),
+				id
+			});
+		}
+		for (let child = 0; child < children.length; child++) {
+			const next = children[child + 1];
+			if (children[child].type !== "image" || next?.type !== "text" || !next.content.startsWith("{")) continue;
+			const read = readLoomaAttributes(next.content);
+			if (!read) continue;
+			applyImageAttributes(children[child], read.attributes);
+			next.content = next.content.slice(read.end);
+			if (!next.content) children.splice(child + 1, 1);
+		}
+		if (tokens[index - 1]?.type === "paragraph_open" && children.length === 1 && children[0].type === "image") {
+			tokens[index - 1].hidden = true;
+			tokens[index + 1].hidden = true;
+		}
+	}
+	const ids = assignLoomaHeadingIds(headings);
+	headings.forEach(({ open }, index) => open.attrSet("id", ids[index]));
+}
+function applyImageAttributes(image, attributes) {
+	for (const key of ["width", "height"]) {
+		const value = Number(attributes[key]);
+		if (Number.isSafeInteger(value) && value > 0) image.attrSet(key, String(value));
+	}
+	const placement = attributes.placement;
+	if (typeof placement === "string" && PLACEMENTS.has(placement) && placement !== "block") image.attrSet("data-placement", placement);
+	if (attributes.responsive === true) image.attrSet("data-looma-responsive", "");
+}
+function tableOfContents(tokens, format, depth, escape) {
+	const roots = [];
+	const ancestors = [];
+	tokens.forEach((token, index) => {
+		if (token.type !== "heading_open") return;
+		const level = Number(token.tag.slice(1));
+		const text = inlineText(tokens[index + 1]).trim();
+		if (level > depth || !text) return;
+		while (ancestors.length && ancestors[ancestors.length - 1].level >= level) ancestors.pop();
+		const entry = {
+			id: token.attrGet("id") ?? "",
+			text,
+			children: []
+		};
+		(ancestors.at(-1)?.entry.children ?? roots).push(entry);
+		ancestors.push({
+			level,
+			entry
+		});
+	});
+	const [list, item] = format === "plain" ? ["div", "div"] : [format === "numbered" ? "ol" : "ul", "li"];
+	const render = (entries) => `<${list} role="list">${entries.map(({ id, text, children }) => `<${item} role="listitem"><a href="#${escape(id)}">${escape(text)}</a>${children.length ? render(children) : ""}</${item}>`).join("")}</${list}>`;
+	return `<nav data-looma-toc="" data-format="${format}" data-depth="${depth}" aria-label="Table of contents"><strong>Table of contents</strong>${roots.length ? render(roots) : ""}</nav>\n`;
+}
+/**
+* Adds Looma Markdown to a markdown-it instance: containers, alerts, task lists, the table of
+* contents, chips, mentions, brace attributes, heading anchors, code meta and front matter.
+* @contract Renders the canonical HTML, which is the HTML LoomaEditor saves. It is not sanitized.
+* Linkify and raw HTML are instance options; `createLoomaMarkdownIt` turns both on.
+*/
+function loomaMarkdown$1(md) {
 	const escape = md.utils.escapeHtml;
+	md.block.ruler.before("table", "looma_frontmatter", frontmatter);
 	md.block.ruler.before("fence", "looma_container", container, { alt: [
 		"paragraph",
 		"reference",
 		"blockquote",
 		"list"
 	] });
+	md.block.ruler.before("paragraph", "looma_leaf", leaf, { alt: [
+		"paragraph",
+		"reference",
+		"blockquote",
+		"list"
+	] });
+	md.inline.ruler.before("link", "looma_directive", directive);
+	md.core.ruler.after("block", "looma_task_lists", taskLists);
 	md.core.ruler.before("inline", "looma_alerts", alerts);
-	md.renderer.rules.looma_container_open = (tokens, index) => {
+	md.core.ruler.before("text_join", "looma_attributes", attributes);
+	const rules = md.renderer.rules;
+	rules.looma_frontmatter = () => "";
+	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`;
+		if (info === "figure") return "<figure>\n";
+		if (info === "tabs" || info === "code-group") return `<ui-tabs${info === "code-group" ? " class=\"code-group\"" : ""} group="${escape(meta.title || info)}">\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;
+	rules.looma_container_close = (tokens, index, _options, env) => {
+		const { info } = tokens[index];
+		if (info === "details") return "</details>\n";
+		if (info === "figure") {
+			const title = tokens[index].meta.title;
+			return `${title ? `<figcaption>${md.renderInline(title, env)}</figcaption>\n` : ""}</figure>\n`;
+		}
+		if (info === "tabs" || info === "code-group") return "</ui-tabs>\n";
+		return "</ui-callout>\n";
+	};
+	rules.looma_tab_open = (tokens, index) => `<section aria-label="${escape(tokens[index].meta.label)}">\n`;
+	rules.looma_tab_close = () => "</section>\n";
+	rules.looma_toc = (tokens, index) => tableOfContents(tokens, tokens[index].meta.format, tokens[index].meta.depth, escape);
+	rules.looma_chip = (tokens, index) => {
+		const { label, attributes } = tokens[index].meta;
+		const tone = normalizeLoomaChipTone(attributes.tone);
+		return `<span data-looma-chip="" data-label="${escape(label)}" data-color="${tone}"${label ? "" : " data-placeholder=\"\""}>${escape(label)}</span>`;
+	};
+	rules.looma_mention = (tokens, index) => {
+		const { label, attributes } = tokens[index].meta;
+		const id = String(attributes.id);
+		return `<span data-type="mention" class="looma-mention" data-id="${escape(id)}" data-label="${escape(label || id)}">@${escape(label || id)}</span>`;
+	};
+	const listItem = rules.list_item_open ?? ((tokens, index, options, _env, self) => self.renderToken(tokens, index, options));
+	rules.list_item_open = (tokens, index, options, env, self) => {
+		const html = listItem(tokens, index, options, env, self);
+		const task = tokens[index].meta;
+		return task && typeof task.checked === "boolean" ? `${html}<input type="checkbox" disabled=""${task.checked ? " checked=\"\"" : ""}>` : html;
+	};
+	const code = (content, info) => {
+		const { language, meta } = parseLoomaFenceInfo(info);
+		return `<pre><code${language ? ` class="language-${escape(language)}"` : ""}${meta ? ` data-meta="${escape(meta)}"` : ""}>${escape(content.replace(/\n$/, ""))}</code></pre>\n`;
+	};
+	rules.fence = (tokens, index) => code(tokens[index].content, tokens[index].info);
+	rules.code_block = (tokens, index) => code(tokens[index].content, "");
 }
-/** 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.
+* A markdown-it instance for Looma Markdown: raw HTML and GFM autolinks on, with `loomaMarkdown`.
+* @contract Each call returns a new instance that callers may extend.
+*/
+function createLoomaMarkdownIt() {
+	return new MarkdownIt({
+		html: true,
+		linkify: true,
+		typographer: false
+	}).use(loomaMarkdown$1);
+}
+//#endregion
+//#region src/editor/extensions/markdown.ts
+/** The markdown-it instance LoomaEditor reads Looma Markdown with. */
+var loomaMarkdown = createLoomaMarkdownIt();
+/**
+* Renders Looma Markdown as the HTML the editor parses.
 * @contract The result is not sanitized; pass it to the editor's `setContent`, whose schema
-* keeps only content it knows.
+* keeps only content it knows. Front matter renders nothing.
 */
 function loomaMarkdownToHtml(source) {
-	return loomaMarkdown.render(source).replace(/\n<\/code><\/pre>/g, "</code></pre>");
+	return loomaMarkdown.render(source);
 }
+var CONTAINERS = /* @__PURE__ */ new Set([
+	"loomaCallout",
+	"loomaExpand",
+	"loomaFigure",
+	"loomaTabs"
+]);
 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));
+		if (!CONTAINERS.has(child.type.name)) return true;
+		depth = Math.max(depth, 1 + containerDepth(child));
 		return false;
 	});
 	return depth;
 };
-function writeContainer(state, node, opening) {
-	const marker = ":".repeat(3 + containerDepth(node));
+var endLine = (state) => state.flushClose(1);
+function writeContainer(state, node, opening, content = () => state.renderContent(node)) {
+	const marker = loomaContainerMarker(containerDepth(node));
 	state.write(`${marker} ${opening}`.trimEnd());
 	state.ensureNewLine();
-	state.renderContent(node);
+	content();
+	endLine(state);
 	state.write(marker);
 	state.closeBlock(node);
 }
 var defaults = defaultMarkdownSerializer.nodes;
+var label = (text) => text.replace(/[\\\]]/g, "\\$&");
+var ALIGNMENT = {
+	left: ":---",
+	center: ":---:",
+	right: "---:"
+};
 var NODES = {
 	paragraph: defaults.paragraph,
-	text: defaults.text,
+	text: (state, node, parent, index) => {
+		const marker = /^:{3,}[ \t]*([A-Za-z][\w-]*)?/.exec(node.text ?? "");
+		if ((marker ? !marker[1] || LOOMA_CONTAINER_NAMES.has(marker[1].toLowerCase()) : /^::toc(?![\w-])/i.test(node.text ?? "")) && state.atBlank()) state.write("\\");
+		defaults.text(state, node, parent, index);
+	},
 	blockquote: defaults.blockquote,
-	heading: defaults.heading,
 	horizontalRule: defaults.horizontal_rule,
-	bulletList: defaults.bullet_list,
+	bulletList: (state, node) => state.renderList(node, "  ", () => "- "),
 	orderedList: (state, node) => {
 		const start = Number(node.attrs.start ?? 1);
 		state.renderList(node, "   ", (index) => `${start + index}. `);
 	},
 	listItem: defaults.list_item,
+	taskList: (state, node) => state.renderList(node, "  ", () => "- "),
+	taskItem: (state, node) => {
+		state.write(node.attrs.checked ? "[x] " : "[ ] ");
+		state.renderContent(node);
+	},
 	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`);
+		const fence = loomaCodeFence(node.textContent);
+		state.write(`${fence}${node.attrs.language ?? ""}${node.attrs.meta ? ` ${node.attrs.meta}` : ""}\n`);
 		state.text(node.textContent, false);
 		state.ensureNewLine();
 		state.write(fence);
 		state.closeBlock(node);
 	},
+	image: (state, node, parent, index) => {
+		defaults.image(state, node, parent, index);
+		const { width, height, placement, responsive } = node.attrs;
+		state.write(formatLoomaAttributes({
+			width,
+			height,
+			placement: placement && placement !== "block" ? placement : null,
+			responsive: responsive === true
+		}));
+		if (node.isBlock) 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}" : ""}`)
+	loomaExpand: (state, node) => writeContainer(state, node, `details ${node.attrs.summary}${node.attrs.open ? " {open}" : ""}`),
+	loomaFigure: (state, node) => {
+		const caption = node.lastChild;
+		const marker = loomaContainerMarker(containerDepth(node));
+		state.write(`${marker} figure`);
+		if (caption.content.size) {
+			state.write(" ");
+			state.renderInline(caption, false);
+		}
+		state.ensureNewLine();
+		state.render(node.firstChild, node, 0);
+		endLine(state);
+		state.write(marker);
+		state.closeBlock(node);
+	},
+	loomaFigcaption: (state, node) => state.renderInline(node),
+	loomaTabs: (state, node) => {
+		const name = node.attrs.codeGroup ? "code-group" : "tabs";
+		const bare = node.attrs.codeGroup && Array.from({ length: node.childCount }, (_, index) => node.child(index)).every((tab) => {
+			const code = tab.firstChild;
+			if (tab.childCount !== 1 || code?.type.name !== "codeBlock") return false;
+			const { title, language } = parseLoomaFenceInfo(`${code.attrs.language ?? ""} ${code.attrs.meta ?? ""}`);
+			return tab.attrs.label === (title ?? language ?? "Code");
+		});
+		writeContainer(state, node, `${name} ${node.attrs.group && node.attrs.group !== name ? node.attrs.group : ""}`, () => node.forEach((tab, _offset, index) => {
+			if (index) endLine(state);
+			if (!bare) {
+				state.write(`== ${tab.attrs.label}`);
+				state.ensureNewLine();
+			}
+			state.renderContent(tab);
+		}));
+	},
+	loomaTab: (state, node) => state.renderContent(node),
+	loomaTableOfContents: (state, node) => {
+		const { format, depth } = node.attrs;
+		state.write(`::toc${formatLoomaAttributes({
+			depth: depth !== 3 ? depth : null,
+			format: format !== "plain" ? format : null
+		})}`);
+		state.closeBlock(node);
+	},
+	loomaChip: (state, node) => {
+		const tone = normalizeLoomaChipTone(node.attrs.color);
+		state.write(`:chip[${label(String(node.attrs.label ?? ""))}]${formatLoomaAttributes({ tone: tone !== "neutral" ? tone : null })}`);
+	},
+	mention: (state, node) => {
+		const id = String(node.attrs.id ?? "");
+		state.write(`:mention[${label(String(node.attrs.label ?? id))}]${formatLoomaAttributes({ id }, { hashId: false })}`);
+	}
 };
 var MARKS = {
 	bold: defaultMarkdownSerializer.marks.strong,
@@ -9341,31 +10046,96 @@ var MARKS = {
 		mixable: true
 	}
 };
+function customHeadingIds(doc) {
+	const headings = [];
+	doc.descendants((node) => {
+		if (node.type.name === "heading") headings.push({
+			text: node.textContent.trim(),
+			id: typeof node.attrs.id === "string" && node.attrs.id ? node.attrs.id : void 0
+		});
+	});
+	const marked = /* @__PURE__ */ new Set();
+	for (;;) {
+		const derived = assignLoomaHeadingIds(headings.map(({ text, id }, index) => ({
+			text,
+			id: marked.has(index) ? id : void 0
+		})));
+		const next = headings.findIndex(({ id }, index) => id && !marked.has(index) && derived[index] !== id);
+		if (next < 0) return marked;
+		marked.add(next);
+	}
+}
 /**
-* 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.
+* Writes an editor document as Looma Markdown, the form `loomaMarkdownToHtml` and Markupress read.
+* @contract Every node in the default preset has a Markdown form. A table that fits GFM is a GFM
+* table and any other is HTML. Content from extensions outside the preset is written as its saved
+* HTML, and marks without a Markdown form other than underline and highlight are dropped.
 */
 function loomaMarkdownFromDoc(doc) {
-	const dom = DOMSerializer.fromSchema(doc.type.schema);
+	const schema = doc.type.schema;
+	const dom = DOMSerializer.fromSchema(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) => {
+	const custom = customHeadingIds(doc);
+	let heading = 0;
+	const nodes = {
+		heading: (state, node) => {
+			state.write(`${"#".repeat(node.attrs.level)} `);
+			state.renderInline(node, false);
+			if (custom.has(heading++)) state.write(` {#${node.attrs.id}}`);
+			else {
+				const out = state;
+				out.out = out.out.replace(/([ \t])\{([^{}]*\})$/, "$1\\{$2");
+			}
+			state.closeBlock(node);
+		},
+		table: (state, node) => {
+			state.write(gfmTable(node) ?? `<table><tbody>${Array.from({ length: node.childCount }, (_, index) => html(node.child(index))).join("")}</tbody></table>`.replace(/ (?:colspan|rowspan)="1"/g, ""));
+			state.closeBlock(node);
+		}
+	};
+	for (const name of Object.keys(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] ?? {
+	for (const name of Object.keys(schema.marks)) marks[name] = MARKS[name] ?? {
 		open: "",
 		close: ""
 	};
-	return new MarkdownSerializer(nodes, marks).serialize(doc, { tightLists: true });
+	const serializer = new MarkdownSerializer(nodes, marks);
+	const inline = (paragraph) => serializer.serialize(schema.topNodeType.create(null, paragraph)).replace(/\|/g, "\\|");
+	function gfmTable(table) {
+		const rows = Array.from({ length: table.childCount }, (_, index) => table.child(index));
+		const width = rows[0]?.childCount ?? 0;
+		const alignments = [];
+		const lines = [];
+		for (const [rowIndex, row] of rows.entries()) {
+			if (row.childCount !== width) return null;
+			const cells = [];
+			for (let column = 0; column < width; column++) {
+				const cell = row.child(column);
+				const { colspan, rowspan, colwidth, backgroundColor, textAlign } = cell.attrs;
+				const paragraph = cell.firstChild;
+				if (cell.type.name === "tableHeader" !== (rowIndex === 0) || colspan !== 1 || rowspan !== 1 || colwidth || backgroundColor || cell.childCount !== 1 || paragraph?.type.name !== "paragraph") return null;
+				let hasBreak = false;
+				paragraph.descendants((child) => {
+					if (child.type.name === "hardBreak") hasBreak = true;
+				});
+				if (hasBreak) return null;
+				if (rowIndex === 0) alignments.push(textAlign ?? null);
+				else if ((textAlign ?? null) !== alignments[column]) return null;
+				cells.push(inline(paragraph));
+			}
+			lines.push(`| ${cells.join(" | ")} |`);
+			if (rowIndex === 0) lines.push(`| ${alignments.map((alignment) => ALIGNMENT[alignment] ?? "---").join(" | ")} |`);
+		}
+		return width ? lines.join("\n") : null;
+	}
+	return serializer.serialize(doc, { tightLists: true });
 }
 //#endregion
 //#region src/editor/extensions/smart-paste.ts
@@ -9391,12 +10161,14 @@ function looksLikeMarkdown(value) {
 			"blockquote_open",
 			"fence",
 			"table_open",
-			"looma_container_open"
+			"looma_container_open",
+			"looma_toc"
 		].includes(token.type)) return true;
-		return token.type === "inline" && Boolean(token.children?.some((child) => [
-			"link_open",
+		return token.type === "inline" && Boolean(token.children?.some((child) => child.type === "link_open" && child.markup !== "linkify" || [
 			"image",
-			"strong_open"
+			"strong_open",
+			"looma_chip",
+			"looma_mention"
 		].includes(child.type)));
 	});
 }
@@ -9411,7 +10183,7 @@ function hasRichClipboardStructure(value) {
 	if (body.querySelector("[data-pm-slice]") && !body.querySelector("pre")) return true;
 	return body.querySelectorAll("p").length > 1;
 }
-function parseHtmlSlice(schema, value) {
+function parseHtmlSlice(schema, value, fromHtml = false) {
 	const parsed = new globalThis.DOMParser().parseFromString(value, "text/html");
 	if (parsed.body.style.display === "none") return Slice.empty;
 	for (const element of parsed.body.querySelectorAll("[style]")) if (element.style.display === "none") element.remove();
@@ -9422,7 +10194,7 @@ function parseHtmlSlice(schema, value) {
 		if (/\s$/.test(child.textContent) || /^\s/.test(next.textContent)) continue;
 		wrapper.insertBefore(parsed.createTextNode(" "), next);
 	}
-	for (const pre of parsed.body.querySelectorAll("pre")) {
+	for (const pre of fromHtml ? parsed.body.querySelectorAll("pre") : []) {
 		let last = pre;
 		while (last.lastChild) last = last.lastChild;
 		if (last.nodeType === Node.TEXT_NODE) last.textContent = last.textContent?.replace(/\r?\n$/, "") ?? "";
@@ -9439,28 +10211,24 @@ function parseHtmlSlice(schema, value) {
 			"template"
 		],
 		FORBID_ATTR: ["style"],
-		ADD_TAGS: ["ui-callout"],
-		ADD_ATTR: ["tone", "heading"],
+		ADD_TAGS: ["ui-callout", "ui-tabs"],
+		ADD_ATTR: [
+			"tone",
+			"heading",
+			"group"
+		],
 		RETURN_DOM_FRAGMENT: true
 	}));
 	if (!container.textContent?.trim() && !container.querySelector("img, hr")) return Slice.empty;
 	return DOMParser.fromSchema(schema).parseSlice(container, { preserveWhitespace: false });
 }
-function markdownFrontmatter(value) {
-	const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/.exec(value.slice(0, 8192));
-	if (!match || !/^[A-Za-z][\w-]*:[ \t]*\S/m.test(match[1])) return null;
-	return {
-		source: match[0].trimEnd(),
-		body: value.slice(match[0].length)
-	};
-}
 function escapeHtmlText(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function documentSlice(schema, plainText) {
-	const frontmatter = markdownFrontmatter(plainText);
+	const frontmatter = splitLoomaFrontmatter(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);
+	if (looksLikeDocumentHtml(plainText)) return parseHtmlSlice(schema, plainText, true);
 	return null;
 }
 /**
@@ -9992,6 +10760,16 @@ function setActiveTableCellBackground(editor, backgroundColor) {
 * Uses the Vanilla JS Tiptap API; apps provide @tiptap/core and Looma ships the preset extensions.
 */
 var LoomaCodeBlock = CodeBlockLowlight.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			meta: {
+				default: null,
+				parseHTML: (element) => element.querySelector("code")?.getAttribute("data-meta") || element.getAttribute("data-meta") || null,
+				renderHTML: () => ({})
+			}
+		};
+	},
 	renderHTML({ node, HTMLAttributes }) {
 		return [
 			"pre",
@@ -10000,6 +10778,7 @@ var LoomaCodeBlock = CodeBlockLowlight.extend({
 				"code",
 				{
 					class: node.attrs.language ? `${this.options.languageClassPrefix}${node.attrs.language}` : null,
+					"data-meta": node.attrs.meta || null,
 					spellcheck: "false"
 				},
 				0
@@ -10075,7 +10854,10 @@ function getDefaultEditorExtensions(options = {}) {
 		Heading.configure({ levels: [
 			1,
 			2,
-			3
+			3,
+			4,
+			5,
+			6
 		] }),
 		BulletList,
 		OrderedList,
@@ -10085,6 +10867,9 @@ function getDefaultEditorExtensions(options = {}) {
 		Blockquote,
 		calloutNodeView ? LoomaCallout.extend({ addNodeView: () => calloutNodeView }) : LoomaCallout,
 		LoomaChip,
+		LoomaTabs,
+		LoomaTab,
+		...imageInline ? [] : [LoomaFigure, LoomaFigcaption],
 		LoomaExpand.configure({ nodeView: expandNodeView ?? null }),
 		LoomaTableOfContents.configure({ nodeView: tableOfContentsNodeView ?? null }),
 		dividerNodeView ? HorizontalRule.extend({ addNodeView: () => dividerNodeView }) : HorizontalRule,
@@ -11076,4 +11861,4 @@ function createLoomaSlashCommandExtension(options = {}) {
 	});
 }
 //#endregion
-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 };
+export { LoomaActiveBlockPluginKey as $, filterLoomaMentionItems as A, LoomaFigcaption as B, loomaMarkdownToHtml as C, createLoomaMentionExtension as D, LoomaMentionSuggestionPluginKey as E, LoomaTableOfContents as F, LoomaChip as G, LoomaExpand as H, getTableOfContentsEntries as I, LOOMA_CALLOUT_TONES as J, normalizeLoomaChipColor as K, normalizeTableOfContentsConfig as L, LoomaImage as M, normalizeImageDimension as N, DEFAULT_MENTION_RESULT_LIMIT as O, normalizeImagePlacement as P, LoomaActiveBlock as Q, LoomaTab as R, loomaMarkdownFromDoc as S, siteRelativeHref as T, revealLoomaExpandAt as U, LoomaFigure as V, LOOMA_CHIP_COLORS as W, LOOMA_ACTIVE_BLOCK_CLASS as X, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS as Y, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS as Z, 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, LoomaCallout 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, LoomaTabs as z };