@vizejs/ui 0.426.3 → 0.427.0

package/dist/rich-text-DXsS6Ox4.mjs

@@ -0,0 +1,2767 @@
+import { a as useDeterministicId, n as deriveDeterministicId } from "./deterministic-id-bMmJU5xD.mjs";
+import { createContext } from "./context.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { t as positioner_default } from "./positioner--uuI0oZY.mjs";
+import { t as createCollectionRegistry } from "./collection-Cncgrq4U.mjs";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, guardReactiveProps, mergeProps, nextTick, normalizeProps, onMounted, onScopeDispose, onUnmounted, openBlock, renderSlot, shallowRef, unref, useTemplateRef, watch, withCtx } from "vue";
+//#region src/families/editor/rich-text/rich-text-model.ts
+const modelDiagnostic = "VIZE_UI_RICH_TEXT_MODEL";
+/** Whether an inline node is a text run. */
+function isText(node) {
+	return node.type === "text" && "text" in node;
+}
+/** Whether a node is a block (has `content`). */
+function isBlock(node) {
+	return "content" in node;
+}
+/** Whether a node is inline (text or leaf). */
+function isInline(node) {
+	return !("content" in node);
+}
+/** Inline children of a textblock. */
+function inlineContent(block) {
+	return block.content.filter(isInline);
+}
+/** Block children of a non-textblock. */
+function blockContent(block) {
+	return block.content.filter(isBlock);
+}
+/** Inline length of one inline node. */
+function inlineSize(node) {
+	return isText(node) ? node.text.length : 1;
+}
+/** Inline length of a textblock. */
+function textblockSize(block) {
+	return inlineContent(block).reduce((total, node) => total + inlineSize(node), 0);
+}
+/** Role of a node type in `schema` (text nodes are inline). */
+function roleOf(schema, type) {
+	if (type === "text") return "inline";
+	const spec = schema.nodes[type];
+	if (!spec) throw new Error(`${modelDiagnostic}: unknown node type "${type}"`);
+	return spec.role;
+}
+/** Plain text of a block tree (textblocks joined by newlines). */
+function textContent(node) {
+	const parts = [];
+	const visit = (block) => {
+		const inline = block.content.filter(isInline);
+		if (inline.length > 0 || block.content.length === 0) {
+			if (block.type !== "doc") parts.push(inline.map((child) => isText(child) ? child.text : "").join(""));
+			return;
+		}
+		for (const child of blockContent(block)) visit(child);
+	};
+	visit(node);
+	return parts.join("\n");
+}
+/** Every textblock in document order. */
+function textblocks(schema, doc) {
+	const found = [];
+	const visit = (children, prefix) => {
+		children.forEach((child, index) => {
+			const path = [...prefix, index];
+			if (roleOf(schema, child.type) === "textblock") found.push({
+				path,
+				node: child
+			});
+			else visit(blockContent(child), path);
+		});
+	};
+	visit(doc.content, []);
+	return found;
+}
+/** Block at `path`, or `undefined`. */
+function blockAt(doc, path) {
+	let children = doc.content;
+	let node;
+	for (const index of path) {
+		const next = children[index];
+		if (!next || !isBlock(next)) return void 0;
+		node = next;
+		children = next.content;
+	}
+	return node;
+}
+/** Replace the block at `path` (or delete it with `null`, or insert siblings). */
+function updateAt(doc, path, replace) {
+	const rebuild = (children, depth) => {
+		const index = path[depth];
+		if (index === void 0) return [...children];
+		const target = children[index];
+		if (!target || !isBlock(target)) throw new Error(`${modelDiagnostic}: no block at ${path.join(".")}`);
+		if (depth === path.length - 1) return [
+			...children.slice(0, index),
+			...replace(target),
+			...children.slice(index + 1)
+		];
+		return [
+			...children.slice(0, index),
+			{
+				...target,
+				content: rebuild(target.content, depth + 1)
+			},
+			...children.slice(index + 1)
+		];
+	};
+	return {
+		type: "doc",
+		content: rebuild(doc.content, 0).filter(isBlock)
+	};
+}
+/** Compare two positions in document order. */
+function comparePositions(left, right) {
+	const length = Math.min(left.path.length, right.path.length);
+	for (let index = 0; index < length; index++) {
+		const difference = (left.path[index] ?? 0) - (right.path[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	if (left.path.length !== right.path.length) return left.path.length - right.path.length;
+	return left.offset - right.offset;
+}
+/** Whether two paths are equal. */
+function samePath(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+/** Ordered `[from, to]` of a selection. */
+function selectionRange(selection) {
+	return comparePositions(selection.anchor, selection.head) <= 0 ? [selection.anchor, selection.head] : [selection.head, selection.anchor];
+}
+/** Whether a selection is collapsed. */
+function isCollapsed(selection) {
+	return comparePositions(selection.anchor, selection.head) === 0;
+}
+/** Collapsed selection at `position`. */
+function caret(position) {
+	return {
+		anchor: position,
+		head: position
+	};
+}
+/** Whether two mark sets are equal (order-insensitive). */
+function sameMarks(left, right) {
+	return left.length === right.length && left.every((mark) => right.some((other) => sameMark(mark, other)));
+}
+/** Whether two marks are equal including attributes. */
+function sameMark(left, right) {
+	if (left.type !== right.type) return false;
+	const keys = new Set([...Object.keys(left.attrs), ...Object.keys(right.attrs)]);
+	for (const key of keys) if (left.attrs[key] !== right.attrs[key]) return false;
+	return true;
+}
+/** Merge adjacent equal-mark text runs and drop empty ones. */
+function normalizeInline(nodes) {
+	const result = [];
+	for (const node of nodes) {
+		if (isText(node)) {
+			if (node.text.length === 0) continue;
+			const previous = result.at(-1);
+			if (previous && isText(previous) && sameMarks(previous.marks, node.marks)) {
+				result[result.length - 1] = {
+					...previous,
+					text: previous.text + node.text
+				};
+				continue;
+			}
+		}
+		result.push(node);
+	}
+	return result;
+}
+/** Inline nodes between `from` and `to` offsets. */
+function sliceInline(nodes, from, to) {
+	const result = [];
+	let position = 0;
+	for (const node of nodes) {
+		const size = inlineSize(node);
+		const start = position;
+		const end = position + size;
+		position = end;
+		if (end <= from || start >= to) continue;
+		if (isText(node)) result.push({
+			...node,
+			text: node.text.slice(Math.max(0, from - start), Math.min(size, to - start))
+		});
+		else result.push(node);
+	}
+	return normalizeInline(result);
+}
+/** Marks in effect just before `offset` of a textblock. */
+function marksBefore(schema, block, offset) {
+	let position = 0;
+	let found = [];
+	for (const node of inlineContent(block)) {
+		const size = inlineSize(node);
+		if (offset > position && offset <= position + size) {
+			found = node.marks;
+			if (offset === position + size) found = found.filter((mark) => schema.marks[mark.type]?.inclusive !== false);
+			break;
+		}
+		position += size;
+	}
+	return found;
+}
+/** Empty textblock of the default type. */
+function emptyBlock(schema, type = schema.defaultBlock) {
+	return {
+		type,
+		attrs: schema.nodes[type]?.defaults ?? {},
+		content: []
+	};
+}
+/** Empty document with one default block. */
+function emptyRichTextDoc(schema) {
+	return assertRichTextDoc(schema, {
+		type: "doc",
+		content: [emptyBlock(schema)]
+	});
+}
+/** Document of plain-text paragraphs (lines split on newlines). */
+function richTextDocFromText(schema, text) {
+	return assertRichTextDoc(schema, {
+		type: "doc",
+		content: text.split(/\r\n|\r|\n/u).map((line) => ({
+			...emptyBlock(schema),
+			content: line.length > 0 ? [{
+				type: "text",
+				text: line,
+				marks: []
+			}] : []
+		}))
+	});
+}
+const validated = /* @__PURE__ */ new WeakMap();
+/** Why a value is not a valid document for a schema, or `null` when it is. */
+function validateRichTextDoc(schema, value) {
+	if (isRecord(value) && validated.get(schema)?.has(value)) return null;
+	const error = validateUncached(schema, value);
+	if (error === null && isRecord(value)) {
+		let known = validated.get(schema);
+		if (!known) {
+			known = /* @__PURE__ */ new WeakSet();
+			validated.set(schema, known);
+		}
+		known.add(value);
+	}
+	return error;
+}
+/** Type guard to the value-erased document shape, backed by schema validation. */
+function isRtDoc(schema, value) {
+	return validateRichTextDoc(schema, value) === null;
+}
+/** Erase a (typed) document to {@link RtDoc}, re-checking it against the schema. */
+function toRtDoc(schema, value) {
+	if (!isRtDoc(schema, value)) throw new TypeError(`${modelDiagnostic}: invalid document`);
+	return value;
+}
+function validateUncached(schema, value) {
+	if (!isRecord(value) || value.type !== "doc" || !Array.isArray(value.content)) return "root must be { type: \"doc\", content: [] }";
+	if (value.content.length === 0) return "document must contain at least one block";
+	const visitBlock = (node, where, parentRole) => {
+		if (!isRecord(node) || typeof node.type !== "string") return `${where}: not a node`;
+		const spec = schema.nodes[node.type];
+		if (!spec || spec.role === "inline") return `${where}: "${String(node.type)}" is not a block type`;
+		if (!isRecord(node.attrs)) return `${where}: missing attrs`;
+		if (!Array.isArray(node.content)) return `${where}: missing content`;
+		if (parentRole === "list" && spec.role !== "listItem") return `${where}: lists hold list items`;
+		if (spec.role === "listItem" && parentRole !== "list") return `${where}: list items need a list`;
+		for (const [index, child] of node.content.entries()) {
+			const childWhere = `${where}.${index}`;
+			const error = spec.role === "textblock" ? visitInline(child, childWhere, spec.code === true) : visitBlock(child, childWhere, spec.role);
+			if (error) return error;
+		}
+		return null;
+	};
+	const visitInline = (node, where, code) => {
+		if (!isRecord(node) || typeof node.type !== "string" || !Array.isArray(node.marks)) return `${where}: not an inline node`;
+		if (code && node.marks.length > 0) return `${where}: code blocks hold unmarked text`;
+		for (const mark of node.marks) if (!isRecord(mark) || typeof mark.type !== "string" || !schema.marks[mark.type]) return `${where}: unknown mark`;
+		if (node.type === "text") return typeof node.text === "string" ? null : `${where}: text needs a string`;
+		if (code) return `${where}: code blocks hold text only`;
+		if (schema.nodes[node.type]?.role !== "inline" || !isRecord(node.attrs)) return `${where}: unknown inline node`;
+		return null;
+	};
+	for (const [index, child] of value.content.entries()) {
+		const error = visitBlock(child, String(index), "doc");
+		if (error) return error;
+	}
+	return null;
+}
+/** Type guard backed by {@link validateRichTextDoc}. */
+function isRichTextDoc(schema, value) {
+	return validateRichTextDoc(schema, value) === null;
+}
+/** Narrow to a typed document or throw a diagnostic describing the first problem. */
+function assertRichTextDoc(schema, value) {
+	const error = validateRichTextDoc(schema, value);
+	if (error !== null || !isRichTextDoc(schema, value)) throw new TypeError(`${modelDiagnostic}: invalid document (${error ?? "unknown"})`);
+	return value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-transform.ts
+const transformDiagnostic = "VIZE_UI_RICH_TEXT_TRANSFORM";
+function entryIndex(entries, position) {
+	const index = entries.findIndex((entry) => samePath(entry.path, position.path));
+	if (index === -1) throw new Error(`${transformDiagnostic}: ${position.path.join(".")} is not a textblock`);
+	return index;
+}
+/** Clamp a position into its textblock (or the nearest textblock). */
+function clampPosition(schema, doc, position) {
+	const entries = textblocks(schema, doc);
+	const exact = entries.find((entry) => samePath(entry.path, position.path));
+	if (exact) return {
+		path: exact.path,
+		offset: Math.max(0, Math.min(position.offset, textblockSize(exact.node)))
+	};
+	const after = entries.find((entry) => comparePositions({
+		path: entry.path,
+		offset: 0
+	}, position) >= 0);
+	const target = after ?? entries.at(-1);
+	if (!target) throw new Error(`${transformDiagnostic}: document has no textblocks`);
+	return {
+		path: target.path,
+		offset: after ? 0 : textblockSize(target.node)
+	};
+}
+/**
+* Remove empty wrappers (including emptied list items), keep at least one
+* block, and strip marks/leaves from code blocks.
+*/
+function normalizeDoc(schema, doc) {
+	const fixBlock = (block) => {
+		if (roleOf(schema, block.type) === "textblock") {
+			const inline = inlineContent(block);
+			const content = schema.nodes[block.type]?.code ? normalizeInline(inline.flatMap((node) => isText(node) ? [{
+				type: "text",
+				text: node.text,
+				marks: []
+			}] : [])) : normalizeInline(inline);
+			return {
+				...block,
+				content
+			};
+		}
+		const children = blockContent(block).map(fixBlock).filter((child) => child !== null);
+		return children.length > 0 ? {
+			...block,
+			content: children
+		} : null;
+	};
+	const content = doc.content.map(fixBlock).filter((block) => block !== null);
+	return {
+		type: "doc",
+		content: content.length > 0 ? content : [emptyBlock(schema)]
+	};
+}
+/** Replace the range `[from, to]` with inline nodes, merging across blocks. */
+function replaceRange(schema, doc, from, to, inline) {
+	const entries = textblocks(schema, doc);
+	const fromIndex = entryIndex(entries, from);
+	const toIndex = entryIndex(entries, to);
+	const first = entries[fromIndex];
+	const last = entries[toIndex];
+	if (!first || !last || toIndex < fromIndex) throw new Error(`${transformDiagnostic}: invalid range`);
+	const inserted = schema.nodes[first.node.type]?.code === true ? inline.flatMap((node) => isText(node) ? [{
+		...node,
+		marks: []
+	}] : []) : inline;
+	const head = sliceInline(inlineContent(first.node), 0, from.offset);
+	const tail = sliceInline(inlineContent(last.node), to.offset, textblockSize(last.node));
+	let next = doc;
+	for (let index = toIndex; index > fromIndex; index--) {
+		const entry = entries[index];
+		if (entry) next = updateAt(next, entry.path, () => []);
+	}
+	next = updateAt(next, first.path, (node) => [{
+		...node,
+		content: normalizeInline([
+			...head,
+			...inserted,
+			...tail
+		])
+	}]);
+	const insertedSize = inserted.reduce((total, node) => total + inlineSize(node), 0);
+	const normalized = normalizeDoc(schema, next);
+	return {
+		doc: normalized,
+		position: clampPosition(schema, normalized, {
+			path: first.path,
+			offset: from.offset + insertedSize
+		})
+	};
+}
+/** Split the textblock at `position` (splitting its list item when inside one). */
+function splitTextblock(schema, doc, position) {
+	const block = blockAt(doc, position.path);
+	if (!block) throw new Error(`${transformDiagnostic}: no textblock to split`);
+	const size = textblockSize(block);
+	const before = {
+		...block,
+		content: sliceInline(inlineContent(block), 0, position.offset)
+	};
+	const after = {
+		...position.offset >= size && block.type !== schema.defaultBlock ? emptyBlock(schema) : block,
+		content: sliceInline(inlineContent(block), position.offset, size)
+	};
+	const parentPath = position.path.slice(0, -1);
+	const index = position.path.at(-1) ?? 0;
+	const parent = parentPath.length > 0 ? blockAt(doc, parentPath) : void 0;
+	if (parent && roleOf(schema, parent.type) === "listItem") {
+		const siblings = blockContent(parent);
+		const itemIndex = parentPath.at(-1) ?? 0;
+		return {
+			doc: normalizeDoc(schema, updateAt(doc, parentPath, (item) => [{
+				...item,
+				content: [...siblings.slice(0, index), before]
+			}, {
+				...item,
+				content: [after, ...siblings.slice(index + 1)]
+			}])),
+			position: {
+				path: [
+					...parentPath.slice(0, -1),
+					itemIndex + 1,
+					0
+				],
+				offset: 0
+			}
+		};
+	}
+	return {
+		doc: normalizeDoc(schema, updateAt(doc, position.path, () => [before, after])),
+		position: {
+			path: [...parentPath, index + 1],
+			offset: 0
+		}
+	};
+}
+/** Change every textblock in `[from, to]` to `type`. */
+function setTextblockType(schema, doc, from, to, type, attrs) {
+	const entries = textblocks(schema, doc);
+	let next = doc;
+	for (const entry of entries.slice(entryIndex(entries, from), entryIndex(entries, to) + 1)) next = updateAt(next, entry.path, (node) => [{
+		...node,
+		type,
+		attrs
+	}]);
+	return normalizeDoc(schema, next);
+}
+function mapMarks(nodes, from, to, change) {
+	const result = [];
+	let position = 0;
+	for (const node of nodes) {
+		const size = inlineSize(node);
+		const start = position;
+		const end = position + size;
+		position = end;
+		if (end <= from || start >= to) {
+			result.push(node);
+			continue;
+		}
+		if (!isText(node)) {
+			result.push({
+				...node,
+				marks: change(node.marks)
+			});
+			continue;
+		}
+		const cutStart = Math.max(from, start) - start;
+		const cutEnd = Math.min(to, end) - start;
+		if (cutStart > 0) result.push({
+			...node,
+			text: node.text.slice(0, cutStart)
+		});
+		result.push({
+			...node,
+			text: node.text.slice(cutStart, cutEnd),
+			marks: change(node.marks)
+		});
+		if (cutEnd < size) result.push({
+			...node,
+			text: node.text.slice(cutEnd)
+		});
+	}
+	return normalizeInline(result);
+}
+/** Visit the inline segment of every textblock in `[from, to]`. */
+function rangeSegments(schema, doc, from, to) {
+	const entries = textblocks(schema, doc);
+	const fromIndex = entryIndex(entries, from);
+	const toIndex = entryIndex(entries, to);
+	return entries.slice(fromIndex, toIndex + 1).map((entry, index) => ({
+		entry,
+		start: index === 0 ? from.offset : 0,
+		end: fromIndex + index === toIndex ? to.offset : textblockSize(entry.node)
+	}));
+}
+/** Add (replacing same-type marks) or remove a mark across `[from, to]`. */
+function changeMark(schema, doc, from, to, mark, add) {
+	let next = doc;
+	for (const { entry, start, end } of rangeSegments(schema, doc, from, to)) {
+		if (schema.nodes[entry.node.type]?.code || start === end) continue;
+		next = updateAt(next, entry.path, (node) => [{
+			...node,
+			content: mapMarks(inlineContent(node), start, end, (marks) => {
+				const others = marks.filter((candidate) => candidate.type !== mark.type);
+				return add ? [...others, mark] : others;
+			})
+		}]);
+	}
+	return next;
+}
+/** Whether every non-empty text in `[from, to]` carries `type` (optionally with `attrs`). */
+function rangeHasMark(schema, doc, from, to, mark) {
+	let seen = false;
+	for (const { entry, start, end } of rangeSegments(schema, doc, from, to)) for (const node of sliceInline(inlineContent(entry.node), start, end)) {
+		seen = true;
+		if (!node.marks.some((candidate) => typeof mark === "string" ? candidate.type === mark : sameMark(candidate, mark))) return false;
+	}
+	return seen;
+}
+/** Common parent and sibling span covering `[from, to]`, lifted out of lists. */
+function wrapSpan(schema, doc, from, to) {
+	let common = 0;
+	while (common < from.path.length - 1 && common < to.path.length - 1 && from.path[common] === to.path[common]) common++;
+	let parentPath = from.path.slice(0, common);
+	let start = from.path[common] ?? 0;
+	let end = to.path[common] ?? start;
+	while (parentPath.length > 0) {
+		const parent = blockAt(doc, parentPath);
+		if (!parent || roleOf(schema, parent.type) !== "list") break;
+		start = parentPath.at(-1) ?? 0;
+		end = start;
+		parentPath = parentPath.slice(0, -1);
+	}
+	return {
+		parentPath,
+		start,
+		end
+	};
+}
+/** Wrap the blocks covering `[from, to]` in a container or list. */
+function wrapRange(schema, doc, from, to, type, attrs) {
+	const role = roleOf(schema, type);
+	if (role !== "container" && role !== "list") throw new Error(`${transformDiagnostic}: "${type}" cannot wrap blocks`);
+	const itemType = Object.keys(schema.nodes).find((name) => schema.nodes[name]?.role === "listItem");
+	const { parentPath, start, end } = wrapSpan(schema, doc, from, to);
+	const covered = (parentPath.length > 0 ? blockContent(blockAt(doc, parentPath) ?? doc) : doc.content).slice(start, end + 1);
+	const wrapper = {
+		type,
+		attrs,
+		content: role === "list" && itemType ? covered.map((block) => ({
+			type: itemType,
+			attrs: schema.nodes[itemType]?.defaults ?? {},
+			content: [block]
+		})) : covered
+	};
+	const replaceChildren = (children) => [
+		...children.slice(0, start),
+		wrapper,
+		...children.slice(end + 1)
+	];
+	const next = parentPath.length === 0 ? {
+		type: "doc",
+		content: replaceChildren(doc.content)
+	} : updateAt(doc, parentPath, (parent) => [{
+		...parent,
+		content: replaceChildren(blockContent(parent))
+	}]);
+	const depth = parentPath.length;
+	const map = (position) => {
+		const index = position.path[depth];
+		if (!samePath(position.path.slice(0, depth), parentPath) || index === void 0) return position;
+		if (index < start) return position;
+		if (index > end) return {
+			...position,
+			path: [
+				...parentPath,
+				index - (end - start),
+				...position.path.slice(depth + 1)
+			]
+		};
+		const inner = role === "list" ? [index - start, 0] : [index - start];
+		return {
+			...position,
+			path: [
+				...parentPath,
+				start,
+				...inner,
+				...position.path.slice(depth + 1)
+			]
+		};
+	};
+	return {
+		doc: normalizeDoc(schema, next),
+		map
+	};
+}
+/** Nearest ancestor of `position` whose type satisfies `match`. */
+function findWrapper(schema, doc, position, match) {
+	for (let depth = position.path.length - 1; depth >= 1; depth--) {
+		const path = position.path.slice(0, depth);
+		const node = blockAt(doc, path);
+		if (node && match(node.type)) return {
+			path,
+			node
+		};
+	}
+	return null;
+}
+/** Unwrap the wrapper at `wrapperPath`, splicing its (list items') children into its parent. */
+function liftWrapper(schema, doc, wrapperPath) {
+	const wrapper = blockAt(doc, wrapperPath);
+	if (!wrapper) throw new Error(`${transformDiagnostic}: no wrapper to lift`);
+	const isList = roleOf(schema, wrapper.type) === "list";
+	const groups = blockContent(wrapper).map((child) => isList ? blockContent(child) : [child]);
+	const next = updateAt(doc, wrapperPath, () => groups.flat());
+	const depth = wrapperPath.length;
+	const base = wrapperPath.at(-1) ?? 0;
+	const lifted = groups.flat().length;
+	const map = (position) => {
+		const parentPath = wrapperPath.slice(0, -1);
+		if (!samePath(position.path.slice(0, depth - 1), parentPath)) return position;
+		const index = position.path[depth - 1];
+		if (index === void 0 || index < base) return position;
+		if (index > base) return {
+			...position,
+			path: [
+				...parentPath,
+				index + lifted - 1,
+				...position.path.slice(depth)
+			]
+		};
+		const child = position.path[depth] ?? 0;
+		if (!isList) return {
+			...position,
+			path: [
+				...parentPath,
+				base + child,
+				...position.path.slice(depth + 1)
+			]
+		};
+		const before = groups.slice(0, child).reduce((total, group) => total + group.length, 0);
+		const within = position.path[depth + 1] ?? 0;
+		return {
+			...position,
+			path: [
+				...parentPath,
+				base + before + within,
+				...position.path.slice(depth + 2)
+			]
+		};
+	};
+	return {
+		doc: normalizeDoc(schema, next),
+		map
+	};
+}
+/** Move one list item's blocks out of its list, splitting the list around it. */
+function liftListItem(schema, doc, itemPath) {
+	const listPath = itemPath.slice(0, -1);
+	const list = blockAt(doc, listPath);
+	const itemIndex = itemPath.at(-1) ?? 0;
+	if (!list || roleOf(schema, list.type) !== "list") throw new Error(`${transformDiagnostic}: ${itemPath.join(".")} is not a list item`);
+	const items = blockContent(list);
+	const item = items[itemIndex];
+	if (!item) throw new Error(`${transformDiagnostic}: missing list item`);
+	const before = items.slice(0, itemIndex);
+	const after = items.slice(itemIndex + 1);
+	const replacement = [
+		...before.length > 0 ? [{
+			...list,
+			content: before
+		}] : [],
+		...blockContent(item),
+		...after.length > 0 ? [{
+			...list,
+			content: after
+		}] : []
+	];
+	const next = updateAt(doc, listPath, () => replacement);
+	const depth = listPath.length;
+	const parentPath = listPath.slice(0, -1);
+	const listIndex = listPath.at(-1) ?? 0;
+	const shift = before.length > 0 ? 1 : 0;
+	const map = (position) => {
+		if (!samePath(position.path.slice(0, depth), listPath)) return position;
+		const index = position.path[depth] ?? 0;
+		const child = position.path[depth + 1] ?? 0;
+		if (index === itemIndex) return {
+			...position,
+			path: [
+				...parentPath,
+				listIndex + shift + child,
+				...position.path.slice(depth + 2)
+			]
+		};
+		if (index > itemIndex) return {
+			...position,
+			path: [
+				...parentPath,
+				listIndex + shift + blockContent(item).length,
+				index - itemIndex - 1,
+				...position.path.slice(depth + 1)
+			]
+		};
+		return position;
+	};
+	return {
+		doc: normalizeDoc(schema, next),
+		map
+	};
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-state.ts
+const emptyHistory = Object.freeze({
+	done: [],
+	undone: [],
+	last: null
+});
+/** Create an editor state; the document is validated against the schema. */
+function createRichTextState(schema, options = {}) {
+	const doc = options.doc ? assertRichTextDoc(schema, options.doc) : emptyRichTextDoc(schema);
+	const start = {
+		path: textblocks(schema, doc)[0]?.path ?? [0],
+		offset: 0
+	};
+	return Object.freeze({
+		schema,
+		doc,
+		selection: options.selection ? clampSelection(schema, doc, options.selection) : caret(start),
+		storedMarks: null,
+		history: emptyHistory
+	});
+}
+/** Clamp both ends of a selection into the document. */
+function clampSelection(schema, doc, selection) {
+	return {
+		anchor: clampPosition(schema, doc, selection.anchor),
+		head: clampPosition(schema, doc, selection.head)
+	};
+}
+function record(before, kind, options) {
+	const time = options.time ?? Date.now();
+	const history = before.history;
+	return {
+		done: kind === "input" && history.last?.kind === "input" && time - history.last.time <= (options.groupDelay ?? 500) && history.done.length > 0 ? history.done : [...history.done, {
+			doc: before.doc,
+			selection: before.selection
+		}].slice(-(options.historyDepth ?? 100)),
+		undone: [],
+		last: {
+			kind,
+			time
+		}
+	};
+}
+/**
+* Build a transaction from a state and the changed parts. The resulting
+* document is re-validated, so a transaction can never produce a document the
+* schema rejects.
+*/
+function createTransaction(before, change, kind, options = {}) {
+	const docChanged = change.doc !== void 0 && change.doc !== before.doc;
+	const doc = docChanged && change.doc ? toRtDoc(before.schema, change.doc) : before.doc;
+	const selection = clampSelection(before.schema, doc, change.selection ?? before.selection);
+	const selectionMoved = comparePositions(selection.anchor, before.selection.anchor) !== 0 || comparePositions(selection.head, before.selection.head) !== 0;
+	const storedMarks = change.storedMarks !== void 0 ? change.storedMarks : docChanged || selectionMoved ? null : before.storedMarks;
+	const history = change.history ?? (docChanged && (options.addToHistory ?? true) ? record(before, kind, options) : before.history);
+	const state = Object.freeze({
+		schema: before.schema,
+		doc,
+		selection,
+		storedMarks,
+		history
+	});
+	return Object.freeze({
+		before,
+		state,
+		kind,
+		docChanged
+	});
+}
+/** Re-type a state produced by commands for its schema (the document is re-validated, cached). */
+function toRichTextState(schema, state) {
+	return Object.freeze({
+		schema,
+		doc: assertRichTextDoc(schema, state.doc),
+		selection: state.selection,
+		storedMarks: state.storedMarks,
+		history: state.history
+	});
+}
+/** Erase a typed state for schema-agnostic code (the document is re-validated, cached). */
+function toRtState(state) {
+	return {
+		schema: state.schema,
+		doc: toRtDoc(state.schema, state.doc),
+		selection: state.selection,
+		storedMarks: state.storedMarks,
+		history: state.history
+	};
+}
+/** Undo the last recorded change. */
+function undo(state, dispatch) {
+	const entry = state.history.done.at(-1);
+	if (!entry) return false;
+	dispatch?.(createTransaction(state, {
+		doc: entry.doc,
+		selection: entry.selection,
+		history: {
+			done: state.history.done.slice(0, -1),
+			undone: [...state.history.undone, {
+				doc: state.doc,
+				selection: state.selection
+			}],
+			last: null
+		}
+	}, "history"));
+	return true;
+}
+/** Redo the last undone change. */
+function redo(state, dispatch) {
+	const entry = state.history.undone.at(-1);
+	if (!entry) return false;
+	dispatch?.(createTransaction(state, {
+		doc: entry.doc,
+		selection: entry.selection,
+		history: {
+			done: [...state.history.done, {
+				doc: state.doc,
+				selection: state.selection
+			}],
+			undone: state.history.undone.slice(0, -1),
+			last: null
+		}
+	}, "history"));
+	return true;
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-commands.ts
+function withDefaults(defaults, attrs) {
+	const merged = { ...defaults };
+	for (const [name, value] of Object.entries(attrs ?? {})) if (value !== void 0) merged[name] = value;
+	return merged;
+}
+function isCode(state, position) {
+	const block = blockAt(state.doc, position.path);
+	return block !== void 0 && state.schema.nodes[block.type]?.code === true;
+}
+function replaceSelection(state, inline, kind, dispatch) {
+	const [from, to] = selectionRange(state.selection);
+	const result = replaceRange(state.schema, state.doc, from, to, inline);
+	dispatch?.(createTransaction(state, {
+		doc: result.doc,
+		selection: caret(result.position)
+	}, kind));
+	return true;
+}
+/** Marks typed text receives at the current caret. */
+function activeMarks(state) {
+	if (state.storedMarks) return state.storedMarks;
+	const [from] = selectionRange(state.selection);
+	const block = blockAt(state.doc, from.path);
+	return block ? marksBefore(state.schema, block, from.offset) : [];
+}
+/** Insert text at the selection with the active marks. */
+function insertText(text) {
+	return (state, dispatch) => {
+		if (text.length === 0) return false;
+		const [from] = selectionRange(state.selection);
+		return replaceSelection(state, [{
+			type: "text",
+			text,
+			marks: isCode(state, from) ? [] : activeMarks(state)
+		}], "input", dispatch);
+	};
+}
+/** Delete a non-empty selection. */
+function deleteSelection(state, dispatch) {
+	if (isCollapsed(state.selection)) return false;
+	return replaceSelection(state, [], "delete", dispatch);
+}
+function previousBoundary(text, offset, unit) {
+	if (unit === "word") {
+		const before = text.slice(0, offset);
+		const match = /[\p{L}\p{N}_]+[^\p{L}\p{N}_]*$|[^\p{L}\p{N}_]+$/u.exec(before);
+		return match ? offset - match[0].length : Math.max(0, offset - 1);
+	}
+	const code = text.charCodeAt(offset - 1);
+	return code >= 56320 && code <= 57343 && offset >= 2 ? offset - 2 : offset - 1;
+}
+function nextBoundary(text, offset, unit) {
+	if (unit === "word") {
+		const match = /^[^\p{L}\p{N}_]*[\p{L}\p{N}_]+|^[^\p{L}\p{N}_]+/u.exec(text.slice(offset));
+		return match ? offset + match[0].length : offset + 1;
+	}
+	const code = text.charCodeAt(offset);
+	return code >= 55296 && code <= 56319 ? offset + 2 : offset + 1;
+}
+function plainText(state, position) {
+	const block = blockAt(state.doc, position.path);
+	if (!block) return "";
+	return inlineContent(block).map((node) => isText(node) ? node.text : "").join("");
+}
+/** Backspace: delete the selection, the previous character/word, or join with the previous block. */
+function deleteBackward(unit = "character") {
+	return (state, dispatch) => {
+		if (!isCollapsed(state.selection)) return deleteSelection(state, dispatch);
+		const position = state.selection.head;
+		if (position.offset > 0) {
+			const from = {
+				...position,
+				offset: previousBoundary(plainText(state, position), position.offset, unit)
+			};
+			const result = replaceRange(state.schema, state.doc, from, position, []);
+			dispatch?.(createTransaction(state, {
+				doc: result.doc,
+				selection: caret(result.position)
+			}, "delete"));
+			return true;
+		}
+		return joinBackward(state, dispatch);
+	};
+}
+/** At the start of a textblock: lift it out of its list item/wrapper, reset its type, or merge it into the previous block. */
+function joinBackward(state, dispatch) {
+	const position = state.selection.head;
+	if (position.offset !== 0 || !isCollapsed(state.selection)) return false;
+	const { schema } = state;
+	const entries = textblocks(schema, state.doc);
+	const index = entries.findIndex((entry) => samePath(entry.path, position.path));
+	const previous = index > 0 ? entries[index - 1] : void 0;
+	const item = findWrapper(schema, state.doc, position, (type) => roleOf(schema, type) === "listItem");
+	const listPath = item?.path.slice(0, -1);
+	if (item && listPath && (!previous || !samePath(previous.path.slice(0, listPath.length), listPath))) {
+		const lifted = liftListItem(schema, state.doc, item.path);
+		dispatch?.(createTransaction(state, {
+			doc: lifted.doc,
+			selection: caret(lifted.map(position))
+		}, "structure"));
+		return true;
+	}
+	const wrapper = findWrapper(schema, state.doc, position, (type) => roleOf(schema, type) === "container");
+	if (wrapper && (!previous || !samePath(previous.path.slice(0, wrapper.path.length), wrapper.path))) {
+		const lifted = liftWrapper(schema, state.doc, wrapper.path);
+		dispatch?.(createTransaction(state, {
+			doc: lifted.doc,
+			selection: caret(lifted.map(position))
+		}, "structure"));
+		return true;
+	}
+	const block = entries[index]?.node;
+	if (block && block.type !== schema.defaultBlock && !previous) {
+		const doc = setTextblockType(schema, state.doc, position, position, schema.defaultBlock, schema.nodes[schema.defaultBlock]?.defaults ?? {});
+		dispatch?.(createTransaction(state, { doc }, "structure"));
+		return true;
+	}
+	if (!previous) return false;
+	const end = {
+		path: previous.path,
+		offset: textblockSize(previous.node)
+	};
+	const result = replaceRange(schema, state.doc, end, position, []);
+	dispatch?.(createTransaction(state, {
+		doc: result.doc,
+		selection: caret(result.position)
+	}, "delete"));
+	return true;
+}
+/** Delete: the selection, the next character/word, or merge the next block into this one. */
+function deleteForward(unit = "character") {
+	return (state, dispatch) => {
+		if (!isCollapsed(state.selection)) return deleteSelection(state, dispatch);
+		const position = state.selection.head;
+		const block = blockAt(state.doc, position.path);
+		if (!block) return false;
+		const size = textblockSize(block);
+		if (position.offset < size) {
+			const to = {
+				...position,
+				offset: Math.min(size, nextBoundary(plainText(state, position), position.offset, unit))
+			};
+			const result = replaceRange(state.schema, state.doc, position, to, []);
+			dispatch?.(createTransaction(state, {
+				doc: result.doc,
+				selection: caret(result.position)
+			}, "delete"));
+			return true;
+		}
+		const entries = textblocks(state.schema, state.doc);
+		const next = entries[entries.findIndex((entry) => samePath(entry.path, position.path)) + 1];
+		if (!next) return false;
+		const result = replaceRange(state.schema, state.doc, position, {
+			path: next.path,
+			offset: 0
+		}, []);
+		dispatch?.(createTransaction(state, {
+			doc: result.doc,
+			selection: caret(result.position)
+		}, "delete"));
+		return true;
+	};
+}
+/** Enter: newline in code blocks, leave an empty list item, or split the block. */
+function splitBlock(state, dispatch) {
+	const [from, to] = selectionRange(state.selection);
+	const { schema } = state;
+	if (isCode(state, from)) return insertText("\n")(state, dispatch);
+	let doc = state.doc;
+	let position = from;
+	if (comparePositions(from, to) !== 0) {
+		const cleared = replaceRange(schema, doc, from, to, []);
+		doc = cleared.doc;
+		position = cleared.position;
+	}
+	const block = blockAt(doc, position.path);
+	const item = findWrapper(schema, doc, position, (type) => roleOf(schema, type) === "listItem");
+	if (block && item && textblockSize(block) === 0 && samePath(position.path.slice(0, -1), item.path)) {
+		const lifted = liftListItem(schema, doc, item.path);
+		dispatch?.(createTransaction(state, {
+			doc: lifted.doc,
+			selection: caret(lifted.map(position))
+		}, "structure"));
+		return true;
+	}
+	const result = splitTextblock(schema, doc, position);
+	dispatch?.(createTransaction(state, {
+		doc: result.doc,
+		selection: caret(result.position)
+	}, "structure"));
+	return true;
+}
+/** Insert a document fragment (pasted content) at the selection. */
+function insertFragment(fragment) {
+	return (state, dispatch) => {
+		const { schema } = state;
+		const [from, to] = selectionRange(state.selection);
+		const blocks = fragment.content;
+		const first = blocks[0];
+		if (!first) return false;
+		if (isCode(state, from)) return replaceSelection(state, [{
+			type: "text",
+			text: textContent(fragment),
+			marks: []
+		}], "paste", dispatch);
+		const isTextblock = (block) => roleOf(schema, block.type) === "textblock";
+		if (blocks.length === 1 && isTextblock(first)) return replaceSelection(state, inlineContent(first), "paste", dispatch);
+		const cleared = replaceRange(schema, state.doc, from, to, []);
+		const split = splitTextblock(schema, cleared.doc, cleared.position);
+		const firstPath = cleared.position.path;
+		const head = isTextblock(first) ? inlineContent(first) : [];
+		const last = blocks.at(-1);
+		const tail = blocks.length > 1 && last && isTextblock(last) ? inlineContent(last) : null;
+		const middle = blocks.slice(isTextblock(first) ? 1 : 0, tail ? -1 : void 0);
+		let doc = updateAt(split.doc, firstPath, (node) => [{
+			...node,
+			content: [...inlineContent(node), ...head]
+		}, ...middle]);
+		const secondPath = [...split.position.path];
+		if (samePath(secondPath.slice(0, -1), firstPath.slice(0, -1))) secondPath[secondPath.length - 1] = (secondPath.at(-1) ?? 0) + middle.length;
+		let caretAt = {
+			path: secondPath,
+			offset: 0
+		};
+		if (tail) {
+			doc = updateAt(doc, secondPath, (node) => [{
+				...node,
+				content: [...tail, ...inlineContent(node)]
+			}]);
+			caretAt = {
+				path: secondPath,
+				offset: tail.reduce((total, node) => total + (isText(node) ? node.text.length : 1), 0)
+			};
+		}
+		const normalized = normalizeDoc(schema, doc);
+		dispatch?.(createTransaction(state, {
+			doc: normalized,
+			selection: caret(caretAt)
+		}, "paste"));
+		return true;
+	};
+}
+/** Select the whole document. */
+function selectAll(state, dispatch) {
+	const entries = textblocks(state.schema, state.doc);
+	const first = entries[0];
+	const last = entries.at(-1);
+	if (!first || !last) return false;
+	const selection = {
+		anchor: {
+			path: first.path,
+			offset: 0
+		},
+		head: {
+			path: last.path,
+			offset: textblockSize(last.node)
+		}
+	};
+	dispatch?.(createTransaction(state, { selection }, "selection"));
+	return true;
+}
+/** Whether the selection (or stored marks at a caret) carries a mark type. */
+function isMarkActive(state, type) {
+	const [from, to] = selectionRange(state.selection);
+	if (comparePositions(from, to) === 0) return activeMarks(state).some((mark) => mark.type === type);
+	return rangeHasMark(state.schema, state.doc, from, to, type);
+}
+/** Whether every selected textblock has `type` (and matching `attrs`). */
+function isBlockActive(state, type, attrs = {}) {
+	const [from, to] = selectionRange(state.selection);
+	const entries = textblocks(state.schema, state.doc);
+	const start = entries.findIndex((entry) => samePath(entry.path, from.path));
+	const end = entries.findIndex((entry) => samePath(entry.path, to.path));
+	return entries.slice(start, end + 1).every((entry) => entry.node.type === type && Object.entries(attrs).every(([key, value]) => entry.node.attrs[key] === value));
+}
+/** Whether the selection sits inside a wrapper of `type`. */
+function isWrappedIn(state, type) {
+	return findWrapper(state.schema, state.doc, state.selection.head, (candidate) => candidate === type) !== null;
+}
+/** Create the typed command set for a schema. */
+function createRichTextCommands(schema) {
+	return createUntypedRichTextCommands(schema);
+}
+/**
+* Commands that take plain type names; they return `false` for names the
+* schema does not declare. Prefer {@link createRichTextCommands} in app code.
+*/
+function createUntypedRichTextCommands(schema) {
+	const hasMark = (name) => Object.hasOwn(schema.marks, name);
+	const hasNode = (name, ...roles) => Object.hasOwn(schema.nodes, name) && roles.includes(schema.nodes[name]?.role ?? "");
+	const markDefaults = (name) => schema.marks[name]?.defaults ?? {};
+	const nodeDefaults = (name) => schema.nodes[name]?.defaults ?? {};
+	const linkType = Object.keys(schema.marks).find((name) => name === "link");
+	const setMark = (name, attrs) => (state, dispatch) => {
+		const [from, to] = selectionRange(state.selection);
+		if (!hasMark(name) || comparePositions(from, to) === 0) return false;
+		const mark = {
+			type: name,
+			attrs: withDefaults(markDefaults(name), attrs)
+		};
+		const doc = changeMark(state.schema, state.doc, from, to, mark, true);
+		dispatch?.(createTransaction(state, { doc }, "format"));
+		return true;
+	};
+	const removeMark = (name) => (state, dispatch) => {
+		const [from, to] = selectionRange(state.selection);
+		if (comparePositions(from, to) === 0) {
+			const marks = activeMarks(state);
+			if (!marks.some((mark) => mark.type === name)) return false;
+			dispatch?.(createTransaction(state, { storedMarks: marks.filter((mark) => mark.type !== name) }, "format"));
+			return true;
+		}
+		const doc = changeMark(state.schema, state.doc, from, to, {
+			type: name,
+			attrs: {}
+		}, false);
+		dispatch?.(createTransaction(state, { doc }, "format"));
+		return true;
+	};
+	const toggleMark = (name, attrs) => (state, dispatch) => {
+		const [from] = selectionRange(state.selection);
+		if (!hasMark(name) || isCode(state, from)) return false;
+		if (isCollapsed(state.selection)) {
+			const marks = activeMarks(state);
+			const storedMarks = marks.some((mark) => mark.type === name) ? marks.filter((mark) => mark.type !== name) : [...marks, {
+				type: name,
+				attrs: withDefaults(markDefaults(name), attrs)
+			}];
+			dispatch?.(createTransaction(state, { storedMarks }, "format"));
+			return true;
+		}
+		return isMarkActive(state, name) ? removeMark(name)(state, dispatch) : setMark(name, attrs)(state, dispatch);
+	};
+	const setBlockType = (name, attrs) => (state, dispatch) => {
+		const [from, to] = selectionRange(state.selection);
+		if (!hasNode(name, "textblock")) return false;
+		const resolved = withDefaults(nodeDefaults(name), attrs);
+		if (isBlockActive(state, name, resolved)) return false;
+		const doc = setTextblockType(state.schema, state.doc, from, to, name, resolved);
+		dispatch?.(createTransaction(state, { doc }, "structure"));
+		return true;
+	};
+	const wrapIn = (name, attrs) => (state, dispatch) => {
+		if (!hasNode(name, "container", "list")) return false;
+		const [from, to] = selectionRange(state.selection);
+		const wrapped = wrapRange(state.schema, state.doc, from, to, name, withDefaults(nodeDefaults(name), attrs));
+		dispatch?.(createTransaction(state, {
+			doc: wrapped.doc,
+			selection: {
+				anchor: wrapped.map(state.selection.anchor),
+				head: wrapped.map(state.selection.head)
+			}
+		}, "structure"));
+		return true;
+	};
+	const unwrap = (name) => (state, dispatch) => {
+		const wrapper = findWrapper(state.schema, state.doc, state.selection.head, (type) => type === name);
+		if (!wrapper) return false;
+		const lifted = liftWrapper(state.schema, state.doc, wrapper.path);
+		dispatch?.(createTransaction(state, {
+			doc: lifted.doc,
+			selection: {
+				anchor: lifted.map(state.selection.anchor),
+				head: lifted.map(state.selection.head)
+			}
+		}, "structure"));
+		return true;
+	};
+	const insertInline = (name, attrs) => (state, dispatch) => {
+		const [from] = selectionRange(state.selection);
+		if (!hasNode(name, "inline") || isCode(state, from)) return false;
+		return replaceSelection(state, [{
+			type: name,
+			attrs: withDefaults(nodeDefaults(name), attrs),
+			marks: activeMarks(state)
+		}], "input", dispatch);
+	};
+	const setLink = (href, text) => (state, dispatch) => {
+		if (!linkType) return false;
+		if (href === null) return removeMark(linkType)(state, dispatch);
+		if (!isCollapsed(state.selection)) return setMark(linkType, { href })(state, dispatch);
+		const [from] = selectionRange(state.selection);
+		if (!text || isCode(state, from)) return false;
+		return replaceSelection(state, [{
+			type: "text",
+			text,
+			marks: [...activeMarks(state).filter((mark) => mark.type !== linkType), {
+				type: linkType,
+				attrs: withDefaults(markDefaults(linkType), { href })
+			}]
+		}], "input", dispatch);
+	};
+	return {
+		insertText,
+		deleteSelection,
+		deleteBackward,
+		deleteForward,
+		splitBlock,
+		selectAll,
+		undo,
+		redo,
+		toggleMark,
+		setMark,
+		removeMark,
+		setBlockType,
+		toggleBlockType: (name, attrs) => (state, dispatch) => isBlockActive(state, name, withDefaults(nodeDefaults(name), attrs)) && name !== schema.defaultBlock ? setBlockType(schema.defaultBlock)(state, dispatch) : setBlockType(name, attrs)(state, dispatch),
+		wrapIn,
+		toggleWrap: (name, attrs) => (state, dispatch) => isWrappedIn(state, name) ? unwrap(name)(state, dispatch) : wrapIn(name, attrs)(state, dispatch),
+		insertInline,
+		setLink,
+		insertContent: insertFragment
+	};
+}
+/** Text before the caret in its textblock (leaves become U+FFFC). */
+function textBeforeCaret(state) {
+	const head = state.selection.head;
+	const block = blockAt(state.doc, head.path);
+	if (!block) return "";
+	return sliceInline(inlineContent(block), 0, head.offset).map((node) => isText(node) ? node.text : "").join("");
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-context.ts
+const richTextContext = createContext("RichText");
+const richTextToolbarContext = createContext("RichTextToolbar");
+//#endregion
+//#region src/families/editor/rich-text/rich-text-html.ts
+const htmlEscapes = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+/** Escape text or attribute content for HTML. */
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/gu, (character) => htmlEscapes[character] ?? character);
+}
+const voidTags = new Set([
+	"br",
+	"hr",
+	"img",
+	"input",
+	"wbr"
+]);
+const tagName = /^[a-z][a-z0-9-]*$/u;
+const attrName = /^[a-z_:][a-z0-9_.:-]*$/u;
+function openTag(spec, extra = {}) {
+	if (!tagName.test(spec.tag)) throw new TypeError(`VIZE_UI_RICH_TEXT_HTML: invalid tag "${spec.tag}"`);
+	let html = `<${spec.tag}`;
+	for (const [name, value] of Object.entries({
+		...spec.attrs,
+		...extra
+	})) {
+		if (value === null || value === void 0 || !attrName.test(name) || name.startsWith("on")) continue;
+		html += ` ${name}="${escapeHtml(value)}"`;
+	}
+	return `${html}>`;
+}
+function closeTag(spec) {
+	return voidTags.has(spec.tag) ? "" : `</${spec.tag}>`;
+}
+function markOrder(schema, marks) {
+	const order = Object.keys(schema.marks);
+	return [...marks].sort((left, right) => order.indexOf(left.type) - order.indexOf(right.type));
+}
+function leafHtml(schema, node, editor) {
+	if (isText(node)) return escapeHtml(node.text);
+	const spec = schema.nodes[node.type]?.render(node.attrs) ?? { tag: "span" };
+	return `${openTag(spec, editor ? {
+		"data-rt-leaf": "",
+		contenteditable: "false"
+	} : {})}${closeTag(spec)}`;
+}
+/** Serialize inline content, sharing mark elements across adjacent runs. */
+function inlineHtml(schema, nodes, editor) {
+	let html = "";
+	const open = [];
+	for (const node of nodes) {
+		const marks = markOrder(schema, node.marks);
+		let keep = 0;
+		while (keep < marks.length) {
+			const current = open[keep];
+			const mark = marks[keep];
+			if (!current || !mark || !sameMark(current.mark, mark)) break;
+			keep++;
+		}
+		while (open.length > keep) {
+			const closing = open.pop();
+			if (closing) html += closeTag(closing.spec);
+		}
+		for (const mark of marks.slice(keep)) {
+			const spec = schema.marks[mark.type]?.render(mark.attrs);
+			if (!spec) continue;
+			open.push({
+				mark,
+				spec
+			});
+			html += openTag(spec);
+		}
+		html += leafHtml(schema, node, editor);
+	}
+	while (open.length > 0) {
+		const closing = open.pop();
+		if (closing) html += closeTag(closing.spec);
+	}
+	return html;
+}
+function blockHtml(schema, block, path, editor) {
+	const role = roleOf(schema, block.type);
+	const spec = schema.nodes[block.type]?.render(block.attrs) ?? { tag: "div" };
+	const hooks = editor ? {
+		"data-rt-path": path.join("."),
+		...role === "textblock" ? { "data-rt-textblock": "" } : {}
+	} : {};
+	let inner;
+	if (role === "textblock") {
+		const inline = inlineContent(block);
+		inner = inlineHtml(schema, inline, editor);
+		const last = inline.at(-1);
+		if (editor && (textblockSize(block) === 0 || last && !isText(last) && schema.nodes[last.type]?.render(last.attrs).tag === "br")) inner += "<br data-rt-filler=\"\">";
+	} else inner = blockContent(block).map((child, index) => blockHtml(schema, child, [...path, index], editor)).join("");
+	return `${openTag(spec, hooks)}${inner}${closeTag(spec)}`;
+}
+/** Serialize a document to HTML (escaped text, sanitized attributes). */
+function richTextToHtml(schema, doc, options = {}) {
+	return doc.content.map((block, index) => blockHtml(schema, block, [index], options.editor === true)).join("");
+}
+const droppedTags = new Set([
+	"button",
+	"embed",
+	"head",
+	"iframe",
+	"input",
+	"link",
+	"meta",
+	"noscript",
+	"object",
+	"script",
+	"select",
+	"style",
+	"svg",
+	"template",
+	"textarea",
+	"title"
+]);
+const blockTags = new Set([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"dd",
+	"div",
+	"dl",
+	"dt",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"pre",
+	"section",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"ul"
+]);
+function matchRule(specs, element, accept) {
+	const tag = element.localName;
+	for (const [name, spec] of Object.entries(specs)) {
+		if (!accept(name)) continue;
+		for (const rule of spec.parse) {
+			if (rule.tag !== tag) continue;
+			const parsed = rule.attrs ? rule.attrs(element) : {};
+			if (parsed === null) continue;
+			const attrs = { ...spec.defaults };
+			for (const [key, value] of Object.entries(parsed)) if (value !== void 0 && Object.hasOwn(spec.defaults, key)) attrs[key] = value;
+			return {
+				name,
+				attrs
+			};
+		}
+	}
+	return null;
+}
+var HtmlReader = class {
+	#schema;
+	constructor(schema) {
+		this.#schema = schema;
+	}
+	blocks(nodes, marks) {
+		const blocks = [];
+		let pending = [];
+		const flush = () => {
+			const content = trimInline(normalizeInline(pending));
+			pending = [];
+			if (content.length > 0) blocks.push({
+				...emptyBlock(this.#schema),
+				content
+			});
+		};
+		for (const node of nodes) {
+			if (node.nodeType === 3) {
+				pending.push(...this.text(node.textContent ?? "", marks, false));
+				continue;
+			}
+			if (!isElement$1(node) || droppedTags.has(node.localName)) continue;
+			const rule = matchRule(this.#schema.nodes, node, (name) => roleOf(this.#schema, name) !== "inline");
+			const transparent = rule !== null && roleOf(this.#schema, rule.name) === "textblock" && [...node.children].some((child) => blockTags.has(child.localName));
+			if (rule && !transparent) {
+				flush();
+				blocks.push(...this.block(rule, node));
+			} else if (transparent || blockTags.has(node.localName)) {
+				flush();
+				blocks.push(...this.blocks(node.childNodes, marks));
+			} else pending.push(...this.inline(node, marks, false));
+		}
+		flush();
+		return blocks;
+	}
+	block(rule, element) {
+		const role = roleOf(this.#schema, rule.name);
+		if (role === "textblock") {
+			const code = this.#schema.nodes[rule.name]?.code === true;
+			const content = normalizeInline([...element.childNodes].flatMap((child) => this.inlineNode(child, [], code)));
+			return [{
+				type: rule.name,
+				attrs: rule.attrs,
+				content: code ? content : trimInline(content)
+			}];
+		}
+		if (role === "list") {
+			const itemType = Object.keys(this.#schema.nodes).find((name) => this.#schema.nodes[name]?.role === "listItem");
+			if (!itemType) return this.blocks(element.childNodes, []);
+			const items = [...element.childNodes].flatMap((child) => {
+				if (isElement$1(child) && droppedTags.has(child.localName)) return [];
+				const nodes = isElement$1(child) && child.localName === "li" ? child.childNodes : [child];
+				const content = this.blocks(nodes, []);
+				return content.length > 0 ? [{
+					type: itemType,
+					attrs: this.#schema.nodes[itemType]?.defaults ?? {},
+					content
+				}] : [];
+			});
+			return items.length > 0 ? [{
+				type: rule.name,
+				attrs: rule.attrs,
+				content: items
+			}] : [];
+		}
+		if (role === "listItem") return this.blocks(element.childNodes, []);
+		const content = this.blocks(element.childNodes, []);
+		return content.length > 0 ? [{
+			type: rule.name,
+			attrs: rule.attrs,
+			content
+		}] : [];
+	}
+	inlineNode(node, marks, code) {
+		if (node.nodeType === 3) return this.text(node.textContent ?? "", marks, code);
+		if (!isElement$1(node) || droppedTags.has(node.localName)) return [];
+		return this.inline(node, marks, code);
+	}
+	inline(element, marks, code) {
+		if (!code) {
+			const leaf = matchRule(this.#schema.nodes, element, (name) => roleOf(this.#schema, name) === "inline");
+			if (leaf) return [{
+				type: leaf.name,
+				attrs: leaf.attrs,
+				marks
+			}];
+		} else if (element.localName === "br") return [{
+			type: "text",
+			text: "\n",
+			marks: []
+		}];
+		const mark = code ? null : matchRule(this.#schema.marks, element, () => true);
+		const nextMarks = mark ? [...marks.filter((candidate) => candidate.type !== mark.name), {
+			type: mark.name,
+			attrs: mark.attrs
+		}] : marks;
+		return [...element.childNodes].flatMap((child) => this.inlineNode(child, nextMarks, code));
+	}
+	text(value, marks, code) {
+		const text = code ? value : value.replace(/[\t\n\r\f ]+/gu, " ");
+		return text.length > 0 ? [{
+			type: "text",
+			text,
+			marks: code ? [] : marks
+		}] : [];
+	}
+};
+function isElement$1(node) {
+	return node.nodeType === 1;
+}
+function trimInline(nodes) {
+	const result = [...nodes];
+	const first = result[0];
+	if (first && isText(first)) result[0] = {
+		...first,
+		text: first.text.replace(/^ +/u, "")
+	};
+	const lastIndex = result.length - 1;
+	const last = result[lastIndex];
+	if (last && isText(last)) result[lastIndex] = {
+		...last,
+		text: last.text.replace(/ +$/u, "")
+	};
+	return normalizeInline(result);
+}
+/**
+* Parse (untrusted) HTML into a document of the schema. Only elements the
+* schema declares survive; scripts, styles, frames, forms, and event
+* attributes are dropped and URLs are checked by each spec's parse rule.
+*/
+function richTextFromHtml(schema, html, options = {}) {
+	const Parser = (options.document ?? globalThis.document)?.defaultView?.DOMParser;
+	if (!Parser) throw new Error("VIZE_UI_RICH_TEXT_HTML: parsing HTML requires a DOM (pass options.document)");
+	const parsed = new Parser().parseFromString(html, "text/html");
+	return assertRichTextDoc(schema, normalizeDoc(schema, {
+		type: "doc",
+		content: new HtmlReader(schema).blocks(parsed.body.childNodes, [])
+	}));
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-input-rules.ts
+/** Remove the matched prefix, then run `command` on the result, as one undo step. */
+function blockInputRule(match, command) {
+	return {
+		match,
+		apply: (state, result, start, end) => {
+			const head = state.selection.head;
+			const removed = replaceRange(state.schema, state.doc, {
+				...head,
+				offset: start
+			}, {
+				...head,
+				offset: end
+			}, []);
+			const intermediate = createTransaction(state, {
+				doc: removed.doc,
+				selection: caret(removed.position)
+			}, "input", { addToHistory: false }).state;
+			const captured = { state: null };
+			if (!command(result)(intermediate, (transaction) => {
+				captured.state = transaction.state;
+			}) || captured.state === null) return null;
+			return createTransaction(state, {
+				doc: captured.state.doc,
+				selection: captured.state.selection
+			}, "structure");
+		}
+	};
+}
+/** Replace the matched text with its first capture group carrying a mark. */
+function markInputRule(match, mark) {
+	return {
+		match,
+		apply: (state, result, start, end) => {
+			const text = result[1];
+			if (!text || !Object.hasOwn(state.schema.marks, mark)) return null;
+			const head = state.selection.head;
+			const leading = result[0].length - result[0].trimStart().length;
+			const from = {
+				...head,
+				offset: start + leading
+			};
+			const replaced = replaceRange(state.schema, state.doc, from, {
+				...head,
+				offset: end
+			}, [{
+				type: "text",
+				text,
+				marks: [{
+					type: mark,
+					attrs: state.schema.marks[mark]?.defaults ?? {}
+				}]
+			}]);
+			return createTransaction(state, {
+				doc: replaced.doc,
+				selection: caret(replaced.position),
+				storedMarks: []
+			}, "format");
+		}
+	};
+}
+/** Markdown-style input rules for every built-in node and mark the schema declares. */
+function defaultRichTextInputRules(schema) {
+	const commands = createUntypedRichTextCommands(schema);
+	const has = (name) => Object.hasOwn(schema.nodes, name) || Object.hasOwn(schema.marks, name);
+	const rules = [];
+	if (has("heading")) rules.push(blockInputRule(/^(#{1,6}) $/u, (match) => commands.setBlockType("heading", { level: match[1]?.length ?? 1 })));
+	if (has("blockquote")) rules.push(blockInputRule(/^> $/u, () => commands.wrapIn("blockquote")));
+	if (has("bulletList")) rules.push(blockInputRule(/^[-*+] $/u, () => commands.wrapIn("bulletList")));
+	if (has("orderedList")) rules.push(blockInputRule(/^(\d{1,9})\. $/u, (match) => commands.wrapIn("orderedList", { start: Number(match[1] ?? 1) })));
+	if (has("codeBlock")) rules.push(blockInputRule(/^```$/u, () => commands.setBlockType("codeBlock")));
+	if (has("bold")) rules.push(markInputRule(/\*\*([^*]+)\*\*$/u, "bold"));
+	if (has("italic")) rules.push(markInputRule(/(?:^|\s)_([^_]+)_$/u, "italic"));
+	if (has("code")) rules.push(markInputRule(/`([^`]+)`$/u, "code"));
+	if (has("strike")) rules.push(markInputRule(/~~([^~]+)~~$/u, "strike"));
+	return rules;
+}
+/** Insert text, letting the first matching input rule transform it instead. */
+function insertTextWithRules(text, rules) {
+	return (state, dispatch) => {
+		const head = state.selection.head;
+		const block = blockAt(state.doc, head.path);
+		const code = block !== void 0 && state.schema.nodes[block.type]?.code === true;
+		if (isCollapsed(state.selection) && !code) {
+			const before = textBeforeCaret(state);
+			const probe = before + text;
+			for (const rule of rules) {
+				const match = new RegExp(rule.match.source, rule.match.flags.replace("g", "")).exec(probe);
+				if (!match) continue;
+				const start = probe.length - match[0].length;
+				if (start > before.length) continue;
+				const transaction = rule.apply(state, match, start, head.offset);
+				if (!transaction) continue;
+				dispatch?.(transaction);
+				return true;
+			}
+		}
+		return insertText(text)(state, dispatch);
+	};
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-keymap.ts
+/** Normalized binding name of a keyboard event, e.g. `Mod-Shift-z`. */
+function richTextKeyName(event) {
+	const parts = [];
+	if (event.ctrlKey || event.metaKey) parts.push("Mod");
+	if (event.altKey) parts.push("Alt");
+	if (event.shiftKey) parts.push("Shift");
+	const digit = /^Digit(\d)$/u.exec(event.code)?.[1];
+	const key = digit !== void 0 && parts.length > 0 ? digit : event.key.length === 1 ? event.key.toLowerCase() : event.key;
+	parts.push(key);
+	return parts.join("-");
+}
+/** Standard shortcuts for every built-in node and mark the schema declares. */
+function defaultRichTextKeymap(schema) {
+	const commands = createUntypedRichTextCommands(schema);
+	const has = (name) => Object.hasOwn(schema.nodes, name) || Object.hasOwn(schema.marks, name);
+	const keymap = {
+		"Mod-z": commands.undo,
+		"Mod-Shift-z": commands.redo,
+		"Mod-y": commands.redo,
+		"Mod-a": commands.selectAll,
+		Enter: commands.splitBlock,
+		Backspace: commands.deleteBackward("character"),
+		"Alt-Backspace": commands.deleteBackward("word"),
+		"Mod-Backspace": commands.deleteBackward("word"),
+		Delete: commands.deleteForward("character"),
+		"Alt-Delete": commands.deleteForward("word")
+	};
+	for (const [mark, key] of [
+		["bold", "Mod-b"],
+		["italic", "Mod-i"],
+		["underline", "Mod-u"],
+		["strike", "Mod-Shift-x"],
+		["code", "Mod-e"]
+	]) if (has(mark)) keymap[key] = commands.toggleMark(mark);
+	if (has("hardBreak")) keymap["Shift-Enter"] = commands.insertInline("hardBreak");
+	keymap["Mod-Alt-0"] = commands.setBlockType(schema.defaultBlock);
+	if (has("heading")) for (let level = 1; level <= 6; level++) keymap[`Mod-Alt-${level}`] = commands.toggleBlockType("heading", { level });
+	if (has("codeBlock")) keymap["Mod-Alt-c"] = commands.toggleBlockType("codeBlock");
+	if (has("orderedList")) keymap["Mod-Shift-7"] = commands.toggleWrap("orderedList");
+	if (has("bulletList")) keymap["Mod-Shift-8"] = commands.toggleWrap("bulletList");
+	if (has("blockquote")) keymap["Mod-Shift-9"] = commands.toggleWrap("blockquote");
+	return keymap;
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-root.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$4 = [
+	"id",
+	"data-editable",
+	"data-focused"
+];
+//#endregion
+//#region src/families/editor/rich-text/rich-text-root.vue
+var rich_text_root_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "rich-text-root",
+	props: {
+		schema: {
+			type: null,
+			required: true
+		},
+		modelValue: {
+			type: Object,
+			required: false,
+			default: () => void 0
+		},
+		defaultValue: {
+			type: Object,
+			required: false,
+			default: () => void 0
+		},
+		id: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		},
+		editable: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		inputRules: {
+			type: Array,
+			required: false,
+			default: () => void 0
+		},
+		keymap: {
+			type: Object,
+			required: false,
+			default: () => void 0
+		},
+		historyDepth: {
+			type: Number,
+			required: false,
+			default: 100
+		}
+	},
+	emits: ["update:modelValue", "transaction"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const baseId = useDeterministicId({
+			id: () => __props.id,
+			hint: "rich-text"
+		});
+		const contentId = computed(() => deriveDeterministicId(baseId.value, "content"));
+		const state = shallowRef(createRichTextState(__props.schema, {
+			...initialDoc(),
+			historyDepth: __props.historyDepth
+		}));
+		const focused = shallowRef(false);
+		const contentElement = shallowRef(null);
+		const toolbars = shallowRef([]);
+		const editableState = computed(() => __props.editable);
+		function initialDoc() {
+			const doc = __props.modelValue ?? __props.defaultValue;
+			return doc === void 0 ? {} : { doc };
+		}
+		const defaultRules = computed(() => defaultRichTextInputRules(__props.schema));
+		const defaultKeymap = computed(() => defaultRichTextKeymap(__props.schema));
+		const erased = computed(() => toRtState(state.value));
+		function dispatch(transaction) {
+			state.value = toRichTextState(__props.schema, transaction.state);
+			emit("transaction", transaction);
+			if (transaction.docChanged) emit("update:modelValue", state.value.doc);
+		}
+		function run(command) {
+			if (!__props.editable) return false;
+			return command(erased.value, dispatch);
+		}
+		watch(() => __props.modelValue, (next) => {
+			if (next === void 0 || next === state.value.doc) return;
+			state.value = createRichTextState(__props.schema, {
+				doc: next,
+				selection: state.value.selection,
+				historyDepth: __props.historyDepth
+			});
+		});
+		function focus() {
+			nextTick(() => contentElement.value?.focus({ preventScroll: true }));
+		}
+		richTextContext.provide({
+			id: baseId,
+			contentId,
+			state: erased,
+			editable: editableState,
+			focused,
+			contentElement,
+			commands: createUntypedRichTextCommands(__props.schema),
+			typeText: (text) => run(insertTextWithRules(text, __props.inputRules ?? defaultRules.value)),
+			runKey: (name) => {
+				const command = (__props.keymap ?? defaultKeymap.value)[name];
+				return command !== void 0 && run(command);
+			},
+			run,
+			can: (command) => __props.editable && command(erased.value),
+			select: (selection) => {
+				dispatch(createTransaction(erased.value, { selection }, "selection"));
+			},
+			focus,
+			toolbars
+		});
+		const slotProps = computed(() => ({
+			state: state.value,
+			editable: __props.editable,
+			focused: focused.value,
+			run
+		}));
+		__expose({
+			state,
+			run,
+			focus,
+			toHtml: () => richTextToHtml(__props.schema, state.value.doc)
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				id: unref(baseId),
+				"data-vize-ui": "rich-text",
+				part: "root",
+				"data-editable": __props.editable ? "true" : "false",
+				"data-focused": focused.value ? "true" : void 0
+			}, [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps.value)), void 0, true)], 8, _hoisted_1$4);
+		};
+	}
+}), [["__scopeId", "data-v-77eea66d"]]);
+//#endregion
+//#region src/families/editor/rich-text/rich-text-dom.ts
+function isElement(node) {
+	return node.nodeType === 1;
+}
+function isLeaf(node) {
+	return isElement(node) && node.hasAttribute("data-rt-leaf");
+}
+function isFiller(node) {
+	return isElement(node) && node.hasAttribute("data-rt-filler");
+}
+function sizeOf(node) {
+	if (node.nodeType === 3) return node.textContent?.length ?? 0;
+	if (isLeaf(node)) return 1;
+	if (isFiller(node) || !isElement(node)) return 0;
+	let total = 0;
+	for (const child of node.childNodes) total += sizeOf(child);
+	return total;
+}
+function textblockOf(node, root) {
+	let current = node;
+	while (current && current !== root) {
+		if (isElement(current) && current.hasAttribute("data-rt-textblock")) return current;
+		current = current.parentNode;
+	}
+	return null;
+}
+function pathOf(block) {
+	return (block.getAttribute("data-rt-path") ?? "").split(".").filter((part) => part !== "").map(Number);
+}
+function offsetWithin(block, target, targetOffset) {
+	let count = 0;
+	let done = false;
+	const visit = (node) => {
+		if (done) return;
+		if (node === target) {
+			if (node.nodeType === 3) count += Math.min(targetOffset, sizeOf(node));
+			else if (isLeaf(node)) count += targetOffset > 0 ? 1 : 0;
+			else for (const child of [...node.childNodes].slice(0, targetOffset)) count += sizeOf(child);
+			done = true;
+			return;
+		}
+		if (node.nodeType === 3 || isLeaf(node) || isFiller(node)) {
+			count += sizeOf(node);
+			return;
+		}
+		for (const child of node.childNodes) visit(child);
+	};
+	visit(block);
+	return count;
+}
+/** Map a DOM point inside the editable root to a model position. */
+function positionFromDom(root, node, offset) {
+	if (!root.contains(node)) return null;
+	const block = textblockOf(node, root);
+	if (block) return {
+		path: pathOf(block),
+		offset: offsetWithin(block, node, offset)
+	};
+	if (!isElement(node)) return null;
+	const blocks = [...root.querySelectorAll("[data-rt-textblock]")];
+	const after = node.childNodes[offset];
+	if (after) {
+		const next = blocks.find((candidate) => after === candidate || after.contains(candidate) || (after.compareDocumentPosition(candidate) & 4) !== 0);
+		if (next) return {
+			path: pathOf(next),
+			offset: 0
+		};
+	}
+	const before = node.childNodes[offset - 1] ?? node;
+	const previous = [...blocks].reverse().find((candidate) => before === candidate || before.contains(candidate) || (before.compareDocumentPosition(candidate) & 2) !== 0);
+	return previous ? {
+		path: pathOf(previous),
+		offset: sizeOf(previous)
+	} : null;
+}
+/** Map a model position to a DOM point, preferring text nodes. */
+function domFromPosition(root, position) {
+	const path = position.path.join(".");
+	const block = [...root.querySelectorAll("[data-rt-textblock]")].find((candidate) => candidate.getAttribute("data-rt-path") === path);
+	if (!block) return null;
+	let remaining = position.offset;
+	let found = null;
+	const visit = (node) => {
+		if (found) return;
+		if (node.nodeType === 3) {
+			const length = node.textContent?.length ?? 0;
+			if (remaining <= length) found = {
+				node,
+				offset: remaining
+			};
+			else remaining -= length;
+			return;
+		}
+		if (isLeaf(node) || isFiller(node)) {
+			const parent = node.parentNode;
+			const index = parent ? [...parent.childNodes].indexOf(node) : 0;
+			if (remaining === 0 && parent) found = {
+				node: parent,
+				offset: index
+			};
+			else if (isLeaf(node)) {
+				remaining -= 1;
+				if (remaining === 0 && parent && !node.nextSibling) found = {
+					node: parent,
+					offset: index + 1
+				};
+			}
+			return;
+		}
+		for (const child of node.childNodes) visit(child);
+	};
+	visit(block);
+	return found ?? {
+		node: block,
+		offset: remaining > 0 ? block.childNodes.length : 0
+	};
+}
+/** Read the document selection when it lies inside `root`. */
+function readDomSelection(root) {
+	const selection = root.ownerDocument.getSelection();
+	if (!selection?.anchorNode || !selection.focusNode) return null;
+	const anchor = positionFromDom(root, selection.anchorNode, selection.anchorOffset);
+	const head = positionFromDom(root, selection.focusNode, selection.focusOffset);
+	return anchor && head ? {
+		anchor,
+		head
+	} : null;
+}
+/** Write a model selection into the document selection. */
+function writeDomSelection(root, selection) {
+	const anchor = domFromPosition(root, selection.anchor);
+	const head = domFromPosition(root, selection.head);
+	const domSelection = root.ownerDocument.getSelection();
+	if (!anchor || !head || !domSelection) return false;
+	if (domSelection.anchorNode === anchor.node && domSelection.anchorOffset === anchor.offset && domSelection.focusNode === head.node && domSelection.focusOffset === head.offset) return true;
+	domSelection.setBaseAndExtent(anchor.node, anchor.offset, head.node, head.offset);
+	return true;
+}
+/** Viewport rectangle of the current DOM selection, when measurable. */
+function selectionRect(root) {
+	const selection = root.ownerDocument.getSelection();
+	if (!selection || selection.rangeCount === 0) return null;
+	const range = selection.getRangeAt(0);
+	if (!root.contains(range.commonAncestorContainer)) return null;
+	return typeof range.getBoundingClientRect === "function" ? range.getBoundingClientRect() : null;
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar-runtime.ts
+/** Roving focus for a toolbar-like container of RichTextToolbarButtons. */
+function useRichTextToolbar(editor, element) {
+	const registry = createCollectionRegistry({ disabledBehavior: "skip" });
+	const context = { registry };
+	richTextToolbarContext.provide(context);
+	function focusKey(key) {
+		if (key === null) return false;
+		registry.setActiveKey(key);
+		const target = registry.getItem(key)?.element;
+		if (!(target instanceof HTMLElement)) return false;
+		target.focus();
+		return true;
+	}
+	const focusFirst = () => focusKey(registry.activeKey.value ?? registry.getNavigationKey("first"));
+	editor.toolbars.value = [...editor.toolbars.value, focusFirst];
+	onScopeDispose(() => {
+		editor.toolbars.value = editor.toolbars.value.filter((entry) => entry !== focusFirst);
+	});
+	function onKeydown(event) {
+		const rtl = element.value?.closest("[dir]")?.getAttribute("dir") === "rtl";
+		const forward = rtl ? "ArrowLeft" : "ArrowRight";
+		const backward = rtl ? "ArrowRight" : "ArrowLeft";
+		let key = null;
+		if (event.key === forward) key = registry.getNavigationKey("next", { loop: true });
+		else if (event.key === backward) key = registry.getNavigationKey("previous", { loop: true });
+		else if (event.key === "Home") key = registry.getNavigationKey("first");
+		else if (event.key === "End") key = registry.getNavigationKey("last");
+		else if (event.key === "Escape") {
+			event.preventDefault();
+			editor.focus();
+			return;
+		} else return;
+		event.preventDefault();
+		focusKey(key);
+	}
+	return {
+		context,
+		onKeydown
+	};
+}
+//#endregion
+//#region src/families/editor/rich-text/rich-text-bubble-menu.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$3 = ["hidden"];
+const _hoisted_2 = ["aria-label", "aria-controls"];
+//#endregion
+//#region src/families/editor/rich-text/rich-text-bubble-menu.vue
+var rich_text_bubble_menu_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "rich-text-bubble-menu",
+	props: {
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: "Selection formatting"
+		},
+		placement: {
+			type: String,
+			required: false,
+			default: "top"
+		},
+		offset: {
+			type: Number,
+			required: false,
+			default: 8
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const editor = richTextContext.use();
+		const element = useTemplateRef("element");
+		const toolbar = useRichTextToolbar(editor, element);
+		const menuFocused = shallowRef(false);
+		const visible = computed(() => __props.open ?? (editor.editable.value && (editor.focused.value || menuFocused.value) && !isCollapsed(editor.state.value.selection)));
+		const anchor = shallowRef(null);
+		watch([visible, () => editor.state.value.selection], () => {
+			const root = editor.contentElement.value;
+			const rect = visible.value && root ? selectionRect(root) : null;
+			anchor.value = rect ? { getBoundingClientRect: () => rect } : null;
+		}, { flush: "post" });
+		const menuProps = computed(() => ({
+			role: "toolbar",
+			"aria-orientation": "horizontal",
+			onKeydown: toolbar.onKeydown,
+			onFocusin: () => {
+				menuFocused.value = true;
+			},
+			onFocusout: (event) => {
+				const next = event.relatedTarget;
+				menuFocused.value = next instanceof Node && element.value?.contains(next) === true;
+			}
+		}));
+		__expose({ element });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-vize-ui": "rich-text-bubble-menu-host",
+				part: "bubble-menu-host",
+				hidden: visible.value ? void 0 : true
+			}, [visible.value ? (openBlock(), createBlock(positioner_default, {
+				key: 0,
+				reference: anchor.value,
+				placement: __props.placement,
+				offset: __props.offset
+			}, {
+				default: withCtx(() => [createElementVNode("div", mergeProps({
+					ref_key: "element",
+					ref: element
+				}, menuProps.value, {
+					"aria-label": __props.ariaLabel,
+					"aria-controls": unref(editor).contentId.value,
+					"data-vize-ui": "rich-text-bubble-menu",
+					part: "bubble-menu"
+				}), [renderSlot(_ctx.$slots, "default", {}, void 0, true)], 16, _hoisted_2)]),
+				_: 3
+			}, 8, [
+				"reference",
+				"placement",
+				"offset"
+			])) : createCommentVNode("v-if", true)], 8, _hoisted_1$3);
+		};
+	}
+}), [["__scopeId", "data-v-92737893"]]);
+//#endregion
+//#region src/families/editor/rich-text/rich-text-content.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$2 = [
+	"id",
+	"aria-label",
+	"aria-labelledby",
+	"aria-describedby",
+	"spellcheck",
+	"data-empty",
+	"data-placeholder",
+	"innerHTML"
+];
+//#endregion
+//#region src/families/editor/rich-text/rich-text-content.vue
+var rich_text_content_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "rich-text-content",
+	props: {
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaLabelledby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaDescribedby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		placeholder: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		spellcheck: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const editor = richTextContext.use();
+		const element = useTemplateRef("element");
+		const html = computed(() => richTextToHtml(editor.state.value.schema, editor.state.value.doc, { editor: true }));
+		const empty = computed(() => {
+			const blocks = editor.state.value.doc.content;
+			const first = blocks[0];
+			return blocks.length === 1 && first !== void 0 && first.content.every((node) => "text" in node && node.text === "");
+		});
+		let composing = false;
+		let compositionSelection = null;
+		let restoring = false;
+		function syncFromDom() {
+			if (!element.value || composing || restoring) return;
+			const selection = readDomSelection(element.value);
+			if (!selection) return;
+			const current = editor.state.value.selection;
+			if (comparePositions(selection.anchor, current.anchor) !== 0 || comparePositions(selection.head, current.head) !== 0) editor.select(selection);
+		}
+		function restoreSelection() {
+			if (!element.value || composing || element.value.ownerDocument.activeElement !== element.value) return;
+			restoring = true;
+			try {
+				writeDomSelection(element.value, editor.state.value.selection);
+			} finally {
+				restoring = false;
+			}
+		}
+		watch(() => editor.state.value, () => void nextTick(restoreSelection), { flush: "post" });
+		function run(command) {
+			editor.run(command);
+		}
+		function onBeforeinput(event) {
+			if (!editor.editable.value) {
+				event.preventDefault();
+				return;
+			}
+			if (event.inputType === "insertCompositionText" || composing) return;
+			event.preventDefault();
+			syncFromDom();
+			const commands = editor.commands;
+			switch (event.inputType) {
+				case "insertText":
+				case "insertReplacementText":
+					if (event.data) editor.typeText(event.data);
+					break;
+				case "insertParagraph":
+					run(commands.splitBlock);
+					break;
+				case "insertLineBreak":
+					if (!editor.run(commands.insertInline("hardBreak"))) run(commands.splitBlock);
+					break;
+				case "deleteContentBackward":
+					run(commands.deleteBackward("character"));
+					break;
+				case "deleteWordBackward":
+					run(commands.deleteBackward("word"));
+					break;
+				case "deleteContentForward":
+					run(commands.deleteForward("character"));
+					break;
+				case "deleteWordForward":
+					run(commands.deleteForward("word"));
+					break;
+				case "deleteByCut":
+				case "deleteContent":
+					run(commands.deleteSelection);
+					break;
+				case "formatBold":
+					run(commands.toggleMark("bold"));
+					break;
+				case "formatItalic":
+					run(commands.toggleMark("italic"));
+					break;
+				case "formatUnderline":
+					run(commands.toggleMark("underline"));
+					break;
+				case "historyUndo":
+					run(commands.undo);
+					break;
+				case "historyRedo":
+					run(commands.redo);
+					break;
+				default: break;
+			}
+		}
+		function onKeydown(event) {
+			if (event.isComposing || composing || event.defaultPrevented) return;
+			const name = richTextKeyName(event);
+			if (name === "Alt-F10") {
+				const [first] = editor.toolbars.value;
+				if (first?.()) event.preventDefault();
+				return;
+			}
+			if (!editor.editable.value) return;
+			syncFromDom();
+			if (editor.runKey(name)) event.preventDefault();
+		}
+		function onPaste(event) {
+			event.preventDefault();
+			if (!editor.editable.value) return;
+			const data = event.clipboardData;
+			if (!data) return;
+			syncFromDom();
+			const schema = editor.state.value.schema;
+			const htmlData = data.getData("text/html");
+			const textData = data.getData("text/plain");
+			const fragment = htmlData && element.value ? richTextFromHtml(schema, htmlData, { document: element.value.ownerDocument }) : textData ? richTextDocFromText(schema, textData) : null;
+			if (fragment) run(editor.commands.insertContent(fragment));
+		}
+		function onCut(event) {
+			const selection = element.value?.ownerDocument.getSelection();
+			if (!element.value || !selection || selection.rangeCount === 0 || !event.clipboardData) return;
+			event.preventDefault();
+			const container = element.value.ownerDocument.createElement("div");
+			container.append(selection.getRangeAt(0).cloneContents());
+			event.clipboardData.setData("text/html", container.innerHTML);
+			event.clipboardData.setData("text/plain", selection.toString());
+			if (editor.editable.value && !isCollapsed(editor.state.value.selection)) {
+				syncFromDom();
+				run(editor.commands.deleteSelection);
+			}
+		}
+		function onCompositionstart() {
+			syncFromDom();
+			composing = true;
+			compositionSelection = editor.state.value.selection;
+		}
+		function onCompositionend(event) {
+			composing = false;
+			const selection = compositionSelection;
+			compositionSelection = null;
+			if (selection) editor.select(selection);
+			const inserted = event.data ? editor.run(editor.commands.insertText(event.data)) : false;
+			nextTick(() => {
+				if (!inserted && element.value) element.value.innerHTML = html.value;
+				restoreSelection();
+			});
+		}
+		function onSelectionchange() {
+			if (element.value && element.value.ownerDocument.activeElement === element.value) syncFromDom();
+		}
+		function onDragstart(event) {
+			event.preventDefault();
+		}
+		onMounted(() => {
+			editor.contentElement.value = element.value;
+			element.value?.ownerDocument.addEventListener("selectionchange", onSelectionchange);
+		});
+		onUnmounted(() => {
+			element.value?.ownerDocument.removeEventListener("selectionchange", onSelectionchange);
+			if (editor.contentElement.value === element.value) editor.contentElement.value = null;
+		});
+		const contentProps = computed(() => ({
+			role: "textbox",
+			contenteditable: editor.editable.value,
+			tabindex: 0,
+			"aria-multiline": true,
+			"aria-readonly": editor.editable.value ? void 0 : true,
+			"aria-placeholder": empty.value ? __props.placeholder : void 0,
+			onBeforeinput,
+			onBlur: () => {
+				editor.focused.value = false;
+			},
+			onCompositionend,
+			onCompositionstart,
+			onCut,
+			onDragstart,
+			onDrop: onDragstart,
+			onFocus: () => {
+				editor.focused.value = true;
+				syncFromDom();
+			},
+			onKeydown,
+			onPaste
+		}));
+		function focus() {
+			element.value?.focus({ preventScroll: true });
+		}
+		__expose({
+			element,
+			focus
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createCommentVNode(" eslint-disable-next-line vue/no-v-html -- markup comes from richTextToHtml: text is escaped and attributes pass the schema's sanitizing render specs "), createElementVNode("div", mergeProps({
+				id: unref(editor).contentId.value,
+				ref_key: "element",
+				ref: element
+			}, contentProps.value, {
+				"aria-label": __props.ariaLabel,
+				"aria-labelledby": __props.ariaLabelledby,
+				"aria-describedby": __props.ariaDescribedby,
+				spellcheck: __props.spellcheck ? "true" : "false",
+				"data-vize-ui": "rich-text-content",
+				part: "content",
+				"data-empty": empty.value ? "true" : void 0,
+				"data-placeholder": __props.placeholder,
+				innerHTML: html.value
+			}), null, 16, _hoisted_1$2)], 2112);
+		};
+	}
+}), [["__scopeId", "data-v-f834c1a7"]]);
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$1 = ["aria-label", "aria-controls"];
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar.vue
+var rich_text_toolbar_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "rich-text-toolbar",
+	props: { ariaLabel: {
+		type: String,
+		required: false,
+		default: "Formatting"
+	} },
+	setup(__props, { expose: __expose }) {
+		const editor = richTextContext.use();
+		const element = useTemplateRef("element");
+		const toolbar = useRichTextToolbar(editor, element);
+		const toolbarProps = computed(() => ({
+			role: "toolbar",
+			"aria-orientation": "horizontal",
+			onKeydown: toolbar.onKeydown
+		}));
+		__expose({ element });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "element",
+				ref: element
+			}, toolbarProps.value, {
+				"aria-label": __props.ariaLabel,
+				"aria-controls": unref(editor).contentId.value,
+				"data-vize-ui": "rich-text-toolbar",
+				part: "toolbar"
+			}), [renderSlot(_ctx.$slots, "default", {}, void 0, true)], 16, _hoisted_1$1);
+		};
+	}
+}), [["__scopeId", "data-v-da012c62"]]);
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar-button.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"aria-label",
+	"aria-pressed",
+	"aria-disabled",
+	"data-active",
+	"data-disabled"
+];
+//#endregion
+//#region src/families/editor/rich-text/rich-text-toolbar-button.vue
+var rich_text_toolbar_button_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "rich-text-toolbar-button",
+	props: {
+		command: {
+			type: Function,
+			required: true
+		},
+		active: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		}
+	},
+	setup(__props) {
+		const editor = richTextContext.use();
+		const toolbar = richTextToolbarContext.useOptional();
+		const element = useTemplateRef("element");
+		const key = useDeterministicId({ hint: "rich-text-tool" });
+		const unavailable = computed(() => __props.disabled || !editor.can(__props.command));
+		const pressed = computed(() => __props.active ? __props.active(editor.state.value) : null);
+		const registration = toolbar?.registry.register({
+			key: key.value,
+			value: null,
+			element,
+			disabled: () => unavailable.value
+		});
+		onScopeDispose(() => registration?.unregister());
+		const tabStop = computed(() => {
+			if (!toolbar) return true;
+			return (toolbar.registry.activeKey.value ?? toolbar.registry.navigableItems.value[0]?.key) === key.value;
+		});
+		function onClick() {
+			if (unavailable.value) return;
+			editor.run(__props.command);
+			editor.focus();
+		}
+		const buttonProps = computed(() => ({
+			tabindex: tabStop.value ? 0 : -1,
+			onMousedown: (event) => event.preventDefault(),
+			onFocus: () => toolbar?.registry.setActiveKey(key.value),
+			onClick
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("button", mergeProps({
+				ref_key: "element",
+				ref: element
+			}, buttonProps.value, {
+				type: "button",
+				"aria-label": __props.ariaLabel,
+				"aria-pressed": pressed.value === null ? void 0 : pressed.value ? "true" : "false",
+				"aria-disabled": unavailable.value ? "true" : void 0,
+				"data-vize-ui": "rich-text-toolbar-button",
+				part: "toolbar-button",
+				"data-active": pressed.value ? "true" : void 0,
+				"data-disabled": unavailable.value ? "true" : void 0
+			}), [renderSlot(_ctx.$slots, "default", {
+				active: pressed.value === true,
+				disabled: unavailable.value
+			}, void 0, true)], 16, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-8934f908"]]);
+//#endregion
+//#region src/families/editor/rich-text/rich-text-schema.ts
+const schemaDiagnostic = "VIZE_UI_RICH_TEXT_SCHEMA";
+const reservedNames = new Set(["doc", "text"]);
+/**
+* Validate and freeze a schema. Node and mark names, roles, and attribute
+* types stay literal, so documents and commands are typed from it.
+*
+* ```ts
+* const schema = defineRichTextSchema({
+*   nodes: { paragraph: paragraphSpec(), heading: headingSpec(), image: imageSpec() },
+*   marks: { bold: boldSpec(), link: linkSpec() },
+* });
+* ```
+*/
+function defineRichTextSchema(definition) {
+	const names = Object.keys(definition.nodes);
+	for (const name of [...names, ...Object.keys(definition.marks)]) if (reservedNames.has(name) || !/^[A-Za-z][\w-]*$/u.test(name)) throw new TypeError(`${schemaDiagnostic}: "${name}" is not a valid node or mark name`);
+	const textblocks = names.filter((name) => definition.nodes[name]?.role === "textblock");
+	const defaultBlock = definition.defaultBlock ?? textblocks[0];
+	if (defaultBlock === void 0 || definition.nodes[defaultBlock]?.role !== "textblock") throw new TypeError(`${schemaDiagnostic}: the default block must be a textblock node`);
+	if (names.some((name) => definition.nodes[name]?.role === "list") !== names.some((name) => definition.nodes[name]?.role === "listItem")) throw new TypeError(`${schemaDiagnostic}: list and listItem nodes must be declared together`);
+	return Object.freeze({
+		nodes: definition.nodes,
+		marks: definition.marks,
+		defaultBlock
+	});
+}
+/** Declare a custom node type with inferred role and attributes. */
+function richTextNode(spec) {
+	return Object.freeze(spec);
+}
+/** Declare a custom mark type with inferred attributes. */
+function richTextMark(spec) {
+	return Object.freeze(spec);
+}
+const safeUrl = /^(?:https?:|mailto:|tel:|\/|\.{0,2}\/|#|[^:]*$)/iu;
+const safeImageUrl = /^(?:https?:|data:image\/(?:png|gif|jpe?g|webp|avif);|\/|\.{0,2}\/|[^:]*$)/iu;
+/** Whether a link target uses a safe scheme (http(s), mailto, tel, or relative). */
+function isSafeUrl(value) {
+	return safeUrl.test(value.trim());
+}
+/** Whether an image source uses a safe scheme (http(s), raster data URLs, or relative). */
+function isSafeImageUrl(value) {
+	return safeImageUrl.test(value.trim());
+}
+/** Paragraph textblock. */
+function paragraphSpec() {
+	return richTextNode({
+		role: "textblock",
+		defaults: {},
+		render: () => ({ tag: "p" }),
+		parse: [{ tag: "p" }, { tag: "div" }]
+	});
+}
+/** Heading textblock with a `level` attribute (1–6). */
+function headingSpec() {
+	return richTextNode({
+		role: "textblock",
+		defaults: { level: 1 },
+		render: ({ level }) => ({ tag: `h${Math.min(6, Math.max(1, Math.trunc(level)))}` }),
+		parse: [
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		].map((level) => ({
+			tag: `h${level}`,
+			attrs: () => ({ level })
+		}))
+	});
+}
+/** Code block textblock (plain text, no marks). */
+function codeBlockSpec() {
+	return richTextNode({
+		role: "textblock",
+		code: true,
+		defaults: { language: null },
+		render: ({ language }) => ({
+			tag: "pre",
+			attrs: { "data-language": language }
+		}),
+		parse: [{
+			tag: "pre",
+			attrs: (element) => ({ language: element.getAttribute("data-language") })
+		}]
+	});
+}
+/** Blockquote container. */
+function blockquoteSpec() {
+	return richTextNode({
+		role: "container",
+		defaults: {},
+		render: () => ({ tag: "blockquote" }),
+		parse: [{ tag: "blockquote" }]
+	});
+}
+/** Bullet list. */
+function bulletListSpec() {
+	return richTextNode({
+		role: "list",
+		defaults: {},
+		render: () => ({ tag: "ul" }),
+		parse: [{ tag: "ul" }]
+	});
+}
+/** Ordered list with a `start` attribute. */
+function orderedListSpec() {
+	return richTextNode({
+		role: "list",
+		defaults: { start: 1 },
+		render: ({ start }) => ({
+			tag: "ol",
+			attrs: { start: start === 1 ? null : String(start) }
+		}),
+		parse: [{
+			tag: "ol",
+			attrs: (element) => {
+				const start = Number(element.getAttribute("start") ?? 1);
+				return { start: Number.isSafeInteger(start) ? start : 1 };
+			}
+		}]
+	});
+}
+/** List item. */
+function listItemSpec() {
+	return richTextNode({
+		role: "listItem",
+		defaults: {},
+		render: () => ({ tag: "li" }),
+		parse: [{ tag: "li" }]
+	});
+}
+/** Inline image with sanitized `src`. */
+function imageSpec() {
+	return richTextNode({
+		role: "inline",
+		defaults: {
+			src: "",
+			alt: ""
+		},
+		render: ({ src, alt }) => ({
+			tag: "img",
+			attrs: {
+				src: isSafeImageUrl(src) ? src : null,
+				alt
+			}
+		}),
+		parse: [{
+			tag: "img",
+			attrs: (element) => {
+				const src = element.getAttribute("src") ?? "";
+				return isSafeImageUrl(src) && src !== "" ? {
+					src,
+					alt: element.getAttribute("alt") ?? ""
+				} : null;
+			}
+		}]
+	});
+}
+/** Inline hard line break. */
+function hardBreakSpec() {
+	return richTextNode({
+		role: "inline",
+		defaults: {},
+		render: () => ({ tag: "br" }),
+		parse: [{ tag: "br" }]
+	});
+}
+/** Bold mark. */
+function boldSpec() {
+	return richTextMark({
+		defaults: {},
+		render: () => ({ tag: "strong" }),
+		parse: [{ tag: "strong" }, { tag: "b" }]
+	});
+}
+/** Italic mark. */
+function italicSpec() {
+	return richTextMark({
+		defaults: {},
+		render: () => ({ tag: "em" }),
+		parse: [{ tag: "em" }, { tag: "i" }]
+	});
+}
+/** Underline mark. */
+function underlineSpec() {
+	return richTextMark({
+		defaults: {},
+		render: () => ({ tag: "u" }),
+		parse: [{ tag: "u" }]
+	});
+}
+/** Strikethrough mark. */
+function strikeSpec() {
+	return richTextMark({
+		defaults: {},
+		render: () => ({ tag: "s" }),
+		parse: [
+			{ tag: "s" },
+			{ tag: "del" },
+			{ tag: "strike" }
+		]
+	});
+}
+/** Inline code mark. */
+function codeSpec() {
+	return richTextMark({
+		defaults: {},
+		render: () => ({ tag: "code" }),
+		parse: [{ tag: "code" }]
+	});
+}
+/** Link mark with a sanitized `href`; not inclusive, so typing after a link leaves it. */
+function linkSpec() {
+	return richTextMark({
+		inclusive: false,
+		defaults: { href: "" },
+		render: ({ href }) => ({
+			tag: "a",
+			attrs: {
+				href: isSafeUrl(href) ? href : null,
+				rel: "noopener noreferrer"
+			}
+		}),
+		parse: [{
+			tag: "a",
+			attrs: (element) => {
+				const href = element.getAttribute("href") ?? "";
+				return href !== "" && isSafeUrl(href) ? { href } : null;
+			}
+		}]
+	});
+}
+/** A schema with every built-in node and mark. */
+function createDefaultRichTextSchema() {
+	return defineRichTextSchema({
+		nodes: {
+			paragraph: paragraphSpec(),
+			heading: headingSpec(),
+			blockquote: blockquoteSpec(),
+			codeBlock: codeBlockSpec(),
+			bulletList: bulletListSpec(),
+			orderedList: orderedListSpec(),
+			listItem: listItemSpec(),
+			image: imageSpec(),
+			hardBreak: hardBreakSpec()
+		},
+		marks: {
+			bold: boldSpec(),
+			italic: italicSpec(),
+			underline: underlineSpec(),
+			strike: strikeSpec(),
+			code: codeSpec(),
+			link: linkSpec()
+		}
+	});
+}
+//#endregion
+export { emptyRichTextDoc as $, rich_text_root_default as A, activeMarks as B, rich_text_toolbar_default as C, positionFromDom as D, domFromPosition as E, insertTextWithRules as F, isWrappedIn as G, createUntypedRichTextCommands as H, markInputRule as I, redo as J, createRichTextState as K, escapeHtml as L, richTextKeyName as M, blockInputRule as N, readDomSelection as O, defaultRichTextInputRules as P, assertRichTextDoc as Q, richTextFromHtml as R, rich_text_toolbar_button_default as S, rich_text_bubble_menu_default as T, isBlockActive as U, createRichTextCommands as V, isMarkActive as W, toRtState as X, toRichTextState as Y, undo as Z, paragraphSpec as _, codeSpec as a, strikeSpec as b, hardBreakSpec as c, isSafeImageUrl as d, isRichTextDoc as et, isSafeUrl as f, orderedListSpec as g, listItemSpec as h, codeBlockSpec as i, defaultRichTextKeymap as j, writeDomSelection as k, headingSpec as l, linkSpec as m, boldSpec as n, textContent as nt, createDefaultRichTextSchema as o, italicSpec as p, createTransaction as q, bulletListSpec as r, validateRichTextDoc as rt, defineRichTextSchema as s, blockquoteSpec as t, richTextDocFromText as tt, imageSpec as u, richTextMark as v, rich_text_content_default as w, underlineSpec as x, richTextNode as y, richTextToHtml as z };