@aicayzer/inkkit 0.3.6 → 0.4.0

package/dist/chunks/{core-DtLNFuDg.js → core-Dl4jPn_d.js}

@@ -6759,7 +6759,7 @@ function tokenizeThematicBreak(effects, ok, nok) {
 * } from 'micromark-util-types'
 */
 /** @type {Construct} */
-var list$3 = {
+var list$4 = {
 	continuation: { tokenize: tokenizeListContinuation },
 	exit: tokenizeListEnd,
 	name: "list",
@@ -6879,7 +6879,7 @@ function tokenizeListContinuation(effects, ok, nok) {
 	function notInCurrentItem(code) {
 		self.containerState._closeFlow = true;
 		self.interrupt = void 0;
-		return factorySpace(effects, effects.attempt(list$3, ok, nok), "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code);
+		return factorySpace(effects, effects.attempt(list$4, ok, nok), "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code);
 	}
 }
 /**
@@ -7313,19 +7313,19 @@ var constructs_exports = /* @__PURE__ */ __exportAll({
 });
 /** @satisfies {Extension['document']} */
 var document$1 = {
-	[42]: list$3,
-	[43]: list$3,
-	[45]: list$3,
-	[48]: list$3,
-	[49]: list$3,
-	[50]: list$3,
-	[51]: list$3,
-	[52]: list$3,
-	[53]: list$3,
-	[54]: list$3,
-	[55]: list$3,
-	[56]: list$3,
-	[57]: list$3,
+	[42]: list$4,
+	[43]: list$4,
+	[45]: list$4,
+	[48]: list$4,
+	[49]: list$4,
+	[50]: list$4,
+	[51]: list$4,
+	[52]: list$4,
+	[53]: list$4,
+	[54]: list$4,
+	[55]: list$4,
+	[56]: list$4,
+	[57]: list$4,
 	[62]: blockQuote
 };
 /** @satisfies {Extension['contentInitial']} */
@@ -9452,10 +9452,10 @@ function configure(base, extension) {
 		case "extensions": break;
 		/* c8 ignore next 4 */
 		case "unsafe":
-			list$2(base[key], extension[key]);
+			list$3(base[key], extension[key]);
 			break;
 		case "join":
-			list$2(base[key], extension[key]);
+			list$3(base[key], extension[key]);
 			break;
 		case "handlers":
 			map$2(base[key], extension[key]);
@@ -9476,7 +9476,7 @@ function configure(base, extension) {
 * @returns {undefined}
 *   Nothing.
 */
-function list$2(left, right) {
+function list$3(left, right) {
 	if (right) left.push(...right);
 }
 /**
@@ -11096,7 +11096,7 @@ function checkRule(state) {
 * @returns {string}
 *   Serialized markdown.
 */
-function list$1(node, parent, state, info) {
+function list$2(node, parent, state, info) {
 	const exit = state.enter("list");
 	const bulletCurrent = state.bulletCurrent;
 	/** @type {string} */
@@ -11416,7 +11416,7 @@ var handle = {
 	inlineCode,
 	link: link$1,
 	linkReference,
-	list: list$1,
+	list: list$2,
 	listItem,
 	paragraph: paragraph$1,
 	root: root$1,
@@ -12759,7 +12759,7 @@ function toMarkdown(tree, options) {
 	configure(state, settings);
 	if (state.options.tightDefinitions) state.join.push(joinDefinition);
 	state.handle = zwitch("type", {
-		invalid,
+		invalid: invalid$1,
 		unknown,
 		handlers: state.handlers
 	});
@@ -12806,7 +12806,7 @@ function toMarkdown(tree, options) {
 * @throws {Error}
 *   Always.
 */
-function invalid(value) {
+function invalid$1(value) {
 	throw new Error("Cannot handle value `" + value + "`, expected node");
 }
 /**
@@ -17808,7 +17808,7 @@ var DOMParser$1 = class DOMParser$1 {
 		return schema.cached.domParser || (schema.cached.domParser = new DOMParser$1(schema, DOMParser$1.schemaRules(schema)));
 	}
 };
-var blockTags = {
+var blockTags$1 = {
 	address: true,
 	article: true,
 	aside: true,
@@ -17904,7 +17904,7 @@ var NodeContext = class {
 	inlineContext(node) {
 		if (this.type) return this.type.inlineContent;
 		if (this.content.length) return this.content[0].isInline;
-		return node.parentNode && !blockTags.hasOwnProperty(node.parentNode.nodeName.toLowerCase());
+		return node.parentNode && !blockTags$1.hasOwnProperty(node.parentNode.nodeName.toLowerCase());
 	}
 };
 var ParseContext = class {
@@ -17968,7 +17968,7 @@ var ParseContext = class {
 			if (rule && rule.closeParent) this.open = Math.max(0, this.open - 1);
 			else if (rule && rule.skip.nodeType) dom = rule.skip;
 			let sync, oldNeedsBlock = this.needsBlock;
-			if (blockTags.hasOwnProperty(name)) {
+			if (blockTags$1.hasOwnProperty(name)) {
 				if (top.content.length && top.content[0].isInline && this.open) {
 					this.open--;
 					top = this.top;
@@ -28368,6 +28368,7 @@ var defaultLabels = {
 	slashWarning: "Warning",
 	slashCaution: "Caution",
 	formattedEditor: "Formatted Markdown editor",
+	richTextEditor: "Rich text editor",
 	plainTextEditor: "Plain text editor",
 	sourceEditor: "Markdown source editor",
 	placeholder: "Start typing…",
@@ -28408,6 +28409,33 @@ function editorLabels(ctx) {
 }
 //#endregion
 //#region src/types.ts
+/** The closed list of what a conversion can lose. The API reference describes each one. */
+var formatLossCodes = [
+	"heading",
+	"code-block",
+	"diagram",
+	"quote",
+	"callout",
+	"task",
+	"rule",
+	"footnote",
+	"comment",
+	"highlight",
+	"image",
+	"file",
+	"wiki-link",
+	"literal",
+	"link",
+	"table-alignment",
+	"list-start",
+	"list-item-blocks",
+	"list-depth",
+	"link-underline",
+	"invalid-character",
+	"alignment",
+	"mark-spaces",
+	"empty-line"
+];
 /** Every failure InkKit reports. Hosts branch on `code`; `message` is for logs. When the failure
 *  started elsewhere, such as in an adapter, the host clipboard or the renderer, `cause` holds the
 *  original error. */
@@ -28940,6 +28968,61 @@ function remarkLinkForms() {
 //#endregion
 //#region node_modules/.pnpm/prosemirror-schema-list@1.5.1/node_modules/prosemirror-schema-list/dist/index.js
 /**
+Returns a command function that wraps the selection in a list with
+the given type an attributes. If `dispatch` is null, only return a
+value to indicate whether this is possible, but don't actually
+perform the change.
+*/
+function wrapInList(listType, attrs = null) {
+	return function(state, dispatch) {
+		let { $from, $to } = state.selection;
+		let range = $from.blockRange($to);
+		if (!range) return false;
+		let tr = dispatch ? state.tr : null;
+		if (!wrapRangeInList(tr, range, listType, attrs)) return false;
+		if (dispatch) dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+/**
+Try to wrap the given node range in a list of the given type.
+Return `true` when this is possible, `false` otherwise. When `tr`
+is non-null, the wrapping is added to that transaction. When it is
+`null`, the function only queries whether the wrapping is
+possible.
+*/
+function wrapRangeInList(tr, range, listType, attrs = null) {
+	let doJoin = false, outerRange = range, doc = range.$from.doc;
+	if (range.depth >= 2 && range.$from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
+		if (range.$from.index(range.depth - 1) == 0) return false;
+		let $insert = doc.resolve(range.start - 2);
+		outerRange = new NodeRange($insert, $insert, range.depth);
+		if (range.endIndex < range.parent.childCount) range = new NodeRange(range.$from, doc.resolve(range.$to.end(range.depth)), range.depth);
+		doJoin = true;
+	}
+	let wrap = findWrapping(outerRange, listType, attrs, range);
+	if (!wrap) return false;
+	if (tr) doWrapInList(tr, range, wrap, doJoin, listType);
+	return true;
+}
+function doWrapInList(tr, range, wrappers, joinBefore, listType) {
+	let content = Fragment.empty;
+	for (let i = wrappers.length - 1; i >= 0; i--) content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
+	tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
+	let found = 0;
+	for (let i = 0; i < wrappers.length; i++) if (wrappers[i].type == listType) found = i + 1;
+	let splitDepth = wrappers.length - found;
+	let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
+	for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
+		if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
+			tr.split(splitPos, splitDepth);
+			splitPos += 2 * splitDepth;
+		}
+		splitPos += parent.child(i).nodeSize;
+	}
+	return tr;
+}
+/**
 Build a command that splits a non-empty textblock at the top level
 of a list item by also splitting that list item.
 */
@@ -40191,26 +40274,32 @@ var quotes$1 = {
 	"\"": ["“", "”"],
 	"'": ["‘", "’"]
 };
+/** Input rules that are not Markdown syntax, which apply in every formatted document. */
+var formatNeutralRules = /* @__PURE__ */ new WeakSet();
+function formatNeutral(rule) {
+	formatNeutralRules.add(rule);
+	return rule;
+}
 var smartPunctuation = [
 	smartPunctuationCtx,
 	inputTracking,
-	$inputRule((ctx) => new InputRule(/["']$/, (state, match, start, end) => {
+	$inputRule((ctx) => formatNeutral(new InputRule(/["']$/, (state, match, start, end) => {
 		if (!applies(ctx.get(smartPunctuationCtx.key), state, match, start)) return null;
 		const [opening, closing] = quotes$1[match[0]];
 		return state.tr.insertText(opensHere(state, start) ? opening : closing, start, end).setMeta(smartRule, "quote");
-	}, { inCodeMark: false })),
-	$inputRule((ctx) => new InputRule(/--$/, (state, match, start, end) => {
+	}, { inCodeMark: false }))),
+	$inputRule((ctx) => formatNeutral(new InputRule(/--$/, (state, match, start, end) => {
 		if (!applies(ctx.get(smartPunctuationCtx.key), state, match, start)) return null;
 		if (input.getState(state)?.hyphen !== state.selection.from) return null;
 		const before = textBefore(state, start);
 		if (!before.trim() || before.endsWith("-") || /^\s*\|/.test(before)) return null;
 		return state.tr.insertText(enDash, start, end).setMeta(smartRule, "en");
-	}, { inCodeMark: false })),
-	$inputRule((ctx) => new InputRule(/\u2013-$/, (state, match, start, end) => {
+	}, { inCodeMark: false }))),
+	$inputRule((ctx) => formatNeutral(new InputRule(/\u2013-$/, (state, match, start, end) => {
 		if (!applies(ctx.get(smartPunctuationCtx.key), state, match, start)) return null;
 		if (lastRule(state)?.transform.getMeta(smartRule) !== "en") return null;
 		return state.tr.insertText(emDash, start, end).setMeta(smartRule, "em");
-	}, { inCodeMark: false }))
+	}, { inCodeMark: false })))
 ].flat();
 /**
 * Undo straight after a smart quote or dash puts back the character that was typed, as Backspace
@@ -42702,6 +42791,16 @@ function insertBlocks(view, blocks, point) {
 	view.dispatch(tr.setSelection(TextSelection.create(tr.doc, end)).scrollIntoView());
 }
 //#endregion
+//#region src/format-input.ts
+var markdown = {
+	markdownInput: () => true,
+	richText: () => void 0
+};
+var formatInputCtx = $ctx(markdown, "inkkitFormatInput");
+function formatInput(ctx) {
+	return ctx.isInjected(formatInputCtx.key) ? ctx.get(formatInputCtx.key) : markdown;
+}
+//#endregion
 //#region src/literals.ts
 var unsupported = /* @__PURE__ */ new Set([
 	"html",
@@ -43650,6 +43749,7 @@ function editedBlocks(before, after) {
 var autolinkLiterals = $prose((ctx) => new Plugin({
 	key: new PluginKey("autolinkLiterals"),
 	appendTransaction(transactions, oldState, newState) {
+		if (!formatInput(ctx).markdownInput()) return null;
 		if (!transactions.some((tr) => tr.docChanged)) return null;
 		const base = newState.tr;
 		const written = transactions.every(isWrittenEdit);
@@ -46013,8 +46113,8 @@ function shareFormatting(children) {
 		};
 		const previous = children[index - 1];
 		const next = children[index + 1];
-		const before = previous && same(previous, formatting);
-		const after = next && same(next, formatting);
+		const before = Boolean(previous && same(previous, formatting));
+		const after = Boolean(next && same(next, formatting));
 		if (!before && !after) continue;
 		const merged = {
 			...formatting,
@@ -46271,6 +46371,26 @@ var preserveSpacerParagraphs = paragraphSchema.extendSchema((base) => (ctx) => {
 	const schema = base(ctx);
 	return {
 		...schema,
+		attrs: {
+			...schema.attrs,
+			align: { default: null }
+		},
+		parseDOM: [{ tag: "p" }],
+		toDOM: (node) => {
+			const [tag, attrs, hole] = schema.toDOM(node);
+			return node.attrs.align ? [
+				tag,
+				{
+					...attrs,
+					style: `text-align: ${String(node.attrs.align)}`
+				},
+				hole
+			] : [
+				tag,
+				attrs,
+				hole
+			];
+		},
 		parseMarkdown: {
 			...schema.parseMarkdown,
 			runner(state, node, type) {
@@ -46595,7 +46715,7 @@ function serialize(ctx, doc = ctx.get(editorViewCtx).state.doc) {
 }
 //#endregion
 //#region src/editor-selection.ts
-var markNames = {
+var markNames$1 = {
 	strong: "bold",
 	emphasis: "italic",
 	strike_through: "strikethrough",
@@ -46640,10 +46760,10 @@ function caretState(state) {
 	const active = /* @__PURE__ */ new Set();
 	const marks = empty ? state.storedMarks ?? $from.marks() : [];
 	for (const mark of marks) {
-		const name = markNames[mark.type.name];
+		const name = markNames$1[mark.type.name];
 		if (name) active.add(name);
 	}
-	if (!empty) for (const [name, mark] of Object.entries(markNames)) {
+	if (!empty) for (const [name, mark] of Object.entries(markNames$1)) {
 		const type = state.schema.marks[name];
 		if (type && state.doc.rangeHasMark($from.pos, $to.pos, type)) active.add(mark);
 	}
@@ -46685,9 +46805,10 @@ function blockAt(parent, $from) {
 }
 //#endregion
 //#region src/editor-links.ts
-function checkDestination(ctx, destination, name, linkSchemes) {
+function checkDestination(ctx, destination, name, linkSchemes, markdown = true) {
 	if (destination.trim() === "") throw invalidArgument(`${name} must not be empty`);
 	if (!isSafeLinkTarget(destination, linkSchemes)) throw invalidArgument(`${name} must be relative, or an address with an allowed scheme (http, https, mailto, tel or one of linkSchemes), with no control characters`);
+	if (!markdown) return;
 	const { schema } = ctx.get(editorViewCtx).state;
 	const written = serialize(ctx, schema.node("doc", null, [schema.node("paragraph", null, [schema.text("x", [schema.marks.link.create({ href: destination })])])]));
 	let read;
@@ -47427,6 +47548,22 @@ var EditorClipboard = class {
 			return;
 		}
 		const view = this.runtime.ctx().get(editorViewCtx);
+		const rich = this.runtime.handler().richText;
+		if (rich) {
+			if (!event.clipboardData || view.state.selection.empty) return;
+			event.preventDefault();
+			event.stopPropagation();
+			try {
+				this.runtime.snapshot();
+				const output = rich.copy(view.state, this.runtime.linkSchemes());
+				event.clipboardData.setData("text/plain", output.text);
+				event.clipboardData.setData("text/html", output.html);
+				if (event.type === "cut" && this.runtime.writable()) view.dispatch(view.state.tr.deleteSelection().scrollIntoView());
+			} catch (error) {
+				this.runtime.report(error);
+			}
+			return;
+		}
 		const fragment = commentSelectionContent(view.state.doc, view.state.selection.from, view.state.selection.to, view.state.selection.content().content);
 		const expanded = selectionContent(view.state.doc, fragment);
 		let hasImages = false;
@@ -48988,7 +49125,7 @@ function correspondence(before, after) {
 		if (work.budget < 0) throw tooManyBlocks();
 		const anchors = uniqueAnchors(before, after, b, bEnd, a, aEnd);
 		if (!anchors.length) {
-			align(before, after, b, bEnd, a, aEnd, result, work);
+			align$1(before, after, b, bEnd, a, aEnd, result, work);
 			continue;
 		}
 		for (const anchor of anchors) {
@@ -49053,7 +49190,7 @@ function uniqueAnchors(before, after, b, bEnd, a, aEnd) {
 }
 var INDEL = 2;
 var REPLACE = 3;
-function align(before, after, b, bEnd, a, aEnd, result, work) {
+function align$1(before, after, b, bEnd, a, aEnd, result, work) {
 	const rows = bEnd - b + 1;
 	const columns = aEnd - a + 1;
 	const offset = Math.abs(rows - columns);
@@ -51482,7 +51619,7 @@ function cleanSemantics(container, localIDs) {
 		if (title) element.setAttribute("title", title);
 		if (id && localIDs.has(id)) element.setAttribute("id", id);
 		if (order && /^\d+$/.test(order)) element.setAttribute("start", order);
-		if (/^(left|center|right)$/.test(alignment) && /^(TH|TD)$/.test(element.tagName)) element.setAttribute("style", `text-align: ${alignment}`);
+		if (/^(left|center|right)$/.test(alignment) && /^(TH|TD)$/.test(element.tagName) || /^(center|right|justify)$/.test(alignment) && element.tagName === "P") element.setAttribute("style", `text-align: ${alignment}`);
 	}
 	const walker = document.createTreeWalker(container, NodeFilter.SHOW_COMMENT);
 	const comments = [];
@@ -51601,10 +51738,12 @@ var markdownFormat = {
 	promise: "exact",
 	literalOnly: false,
 	sourceMode: true,
+	formattedLabel: "formattedEditor",
 	literalLabel: "sourceEditor",
 	headings: true,
 	nativeCopy: false,
 	keepsInsertedLineEndings: true,
+	markdownInput: true,
 	load: (ctx, text) => Preservation.read(ctx, text),
 	parse: (ctx, text) => Preservation.read(ctx, text),
 	pendingExport: (ctx, text) => ctx.get(parserCtx)(text),
@@ -51642,6 +51781,1067 @@ var markdownFormat = {
 		};
 	}
 };
+/** The largest first number of an ordered list that RTF writes and reads back unchanged, as
+*  measured with the host's converter. */
+var maximumListStart = 2147483647;
+/** Characters a run never holds: they would change the structure, stand for an attachment or end
+*  the text when RTF is written. */
+var forbidden = /[\u0000\n\r\u000b\u000c\u0085\u2028\u2029\ufffc]/;
+var loneSurrogate = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+/** Why a run cannot hold `text`, or undefined. Loading and editing share the rule. */
+function textProblem(text) {
+	const bad = forbidden.exec(text);
+	if (bad) return `text cannot hold ${scalarName(bad[0])}`;
+	if (loneSurrogate.test(text)) return "text cannot hold a lone surrogate";
+}
+/** Why `href` cannot be a link's address, or undefined. Any address that is not empty and holds
+*  no control character is kept, as the host's converter keeps it; loading, editing, paste and the
+*  converter share the rule. Edits and paste also apply Inkkit's link safety. */
+function linkProblem(href) {
+	if (!href) return "a link needs an address";
+	if (/[\u0000-\u001f\u007f-\u009f]/.test(href)) return "a link address cannot hold a control character";
+	const problem = textProblem(href);
+	return problem && `a link address ${problem.replace(/^text /, "")}`;
+}
+/** The canonical order of marks. */
+var markRank = {
+	bold: 0,
+	italic: 1,
+	underline: 2,
+	strikethrough: 3,
+	superscript: 4,
+	subscript: 5,
+	code: 6,
+	link: 7
+};
+function invalid(path, problem) {
+	throw invalidArgument(`${path}: ${problem}`);
+}
+function record(value, path, keys) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) invalid(path, "must be an object");
+	for (const key of Object.keys(value)) if (!keys.includes(key)) invalid(`${path}.${key}`, "is not a known field");
+	return value;
+}
+function list$1(value, path) {
+	if (!Array.isArray(value)) invalid(path, "must be a list");
+	return value;
+}
+function scalarName(text) {
+	return `U+${text.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+}
+/** Collects inline content in canonical form: adjacent runs with equal marks merge, and each run
+*  is NFC after merging, because joining two NFC strings can leave a sequence that composes. */
+var InlineBuilder = class {
+	content = [];
+	marksKey;
+	text(text, marks) {
+		if (!text) return;
+		const key = JSON.stringify(marks);
+		const last = this.content.at(-1);
+		if (last?.type === "text" && this.marksKey === key) {
+			last.text += text;
+			return;
+		}
+		this.content.push(marks.length ? {
+			type: "text",
+			text,
+			marks: [...marks]
+		} : {
+			type: "text",
+			text
+		});
+		this.marksKey = key;
+	}
+	break() {
+		this.content.push({ type: "break" });
+		this.marksKey = void 0;
+	}
+	finish() {
+		for (const inline of this.content) if (inline.type === "text") inline.text = inline.text.normalize("NFC");
+		return this.content;
+	}
+};
+/** Marks in canonical order. A link's run never also has underline: a link's underline is how it
+*  is drawn, so RTF readers report it on every link. */
+function canonicalMarks(marks) {
+	const sorted = [...marks].sort((a, b) => markRank[a.type] - markRank[b.type]);
+	return sorted.some((mark) => mark.type === "link") ? sorted.filter((mark) => mark.type !== "underline") : sorted;
+}
+function readMarks(value, path) {
+	const sorted = [...list$1(value, path).map((entry, index) => {
+		const at = `${path}[${index}]`;
+		const mark = record(entry, at, ["type", "href"]);
+		const type = mark.type;
+		if (typeof type !== "string" || !(type in markRank)) invalid(`${at}.type`, `unknown mark type ${JSON.stringify(type)}`);
+		if (type === "link") {
+			if (typeof mark.href !== "string") invalid(`${at}.href`, "must be text");
+			return {
+				type: "link",
+				href: mark.href
+			};
+		}
+		if (!isOmitted(mark.href)) invalid(`${at}.href`, "only a link has an address");
+		return { type };
+	})].sort((a, b) => markRank[a.type] - markRank[b.type]);
+	const types = /* @__PURE__ */ new Set();
+	for (const mark of sorted) {
+		if (types.has(mark.type)) invalid(path, `the ${mark.type} mark appears more than once`);
+		types.add(mark.type);
+		const problem = mark.type === "link" ? linkProblem(mark.href) : void 0;
+		if (problem) invalid(path, problem);
+	}
+	if (types.has("superscript") && types.has("subscript")) invalid(path, "a run cannot be both superscript and subscript");
+	return canonicalMarks(sorted);
+}
+function readInlines(value, path) {
+	const builder = new InlineBuilder();
+	list$1(value, path).forEach((entry, index) => {
+		const at = `${path}[${index}]`;
+		const inline = record(entry, at, [
+			"type",
+			"text",
+			"marks"
+		]);
+		if (inline.type === "break") {
+			if (!isOmitted(inline.text) || !isOmitted(inline.marks)) invalid(at, "a break holds no text or marks");
+			builder.break();
+			return;
+		}
+		if (inline.type !== "text") invalid(`${at}.type`, `unknown inline type ${JSON.stringify(inline.type)}`);
+		const text = inline.text;
+		if (typeof text !== "string") invalid(`${at}.text`, "must be text");
+		if (!text) invalid(`${at}.text`, "a text run cannot be empty");
+		const problem = textProblem(text);
+		if (problem) invalid(`${at}.text`, problem);
+		builder.text(text, isOmitted(inline.marks) ? [] : readMarks(inline.marks, `${at}.marks`));
+	});
+	return builder.finish();
+}
+function readBlock(value, path, listDepth) {
+	const block = record(value, path, [
+		"type",
+		"align",
+		"content",
+		"ordered",
+		"start",
+		"items",
+		"rows"
+	]);
+	const only = (...keys) => {
+		for (const key of Object.keys(block)) if (key !== "type" && !keys.includes(key)) invalid(`${path}.${key}`, `a ${String(block.type)} has no ${key}`);
+	};
+	switch (block.type) {
+		case "paragraph": {
+			only("align", "content");
+			const align = block.align;
+			if (!isOmitted(align) && align !== "center" && align !== "right" && align !== "justify") invalid(`${path}.align`, "must be center, right or justify");
+			const content = readInlines(block.content, `${path}.content`);
+			return isOmitted(align) ? {
+				type: "paragraph",
+				content
+			} : {
+				type: "paragraph",
+				align,
+				content
+			};
+		}
+		case "list":
+			only("ordered", "start", "items");
+			return readList(block, path, listDepth + 1);
+		case "table": {
+			only("rows");
+			if (listDepth > 0) invalid(path, "a table cannot be inside a list item");
+			const rows = list$1(block.rows, `${path}.rows`);
+			if (!rows.length) invalid(`${path}.rows`, "a table needs at least one row");
+			const width = list$1(rows[0], `${path}.rows[0]`).length;
+			if (!width) invalid(`${path}.rows[0]`, "a table row needs at least one cell");
+			return {
+				type: "table",
+				rows: rows.map((row, rowIndex) => {
+					const at = `${path}.rows[${rowIndex}]`;
+					const cells = list$1(row, at);
+					if (cells.length !== width) invalid(at, `the row has ${cells.length} cells, but the first row has ${width}`);
+					return cells.map((cell, cellIndex) => {
+						const cellPath = `${at}[${cellIndex}]`;
+						const content = record(cell, cellPath, ["content"]).content;
+						return { content: readInlines(content, `${cellPath}.content`) };
+					});
+				})
+			};
+		}
+		default: invalid(`${path}.type`, `unknown block type ${JSON.stringify(block.type)}`);
+	}
+}
+function readList(block, path, depth) {
+	if (depth > 9) invalid(path, `lists nest deeper than 9 levels`);
+	if (typeof block.ordered !== "boolean") invalid(`${path}.ordered`, "must be true or false");
+	let start;
+	if (!isOmitted(block.start)) {
+		if (!block.ordered) invalid(`${path}.start`, "only an ordered list has a start");
+		if (!Number.isSafeInteger(block.start)) invalid(`${path}.start`, "must be a whole number");
+		if (block.start < 1) invalid(`${path}.start`, "the start must be at least 1");
+		if (block.start > 2147483647) invalid(`${path}.start`, `the start must be at most ${maximumListStart}`);
+		if (block.start !== 1) start = block.start;
+	}
+	const entries = list$1(block.items, `${path}.items`);
+	if (!entries.length) invalid(`${path}.items`, "a list needs at least one item");
+	const items = entries.map((entry, itemIndex) => {
+		const at = `${path}.items[${itemIndex}]`;
+		const blocks = list$1(record(entry, at, ["blocks"]).blocks, `${at}.blocks`);
+		const first = blocks[0];
+		if (!first || typeof first !== "object" || first.type !== "paragraph") invalid(`${at}.blocks[0]`, "a list item must start with a paragraph");
+		return { blocks: blocks.map((child, blockIndex) => {
+			const childPath = `${at}.blocks[${blockIndex}]`;
+			if (blockIndex > 0 && (!child || typeof child !== "object" || child.type !== "list")) invalid(childPath, "after its paragraph, a list item can hold only lists");
+			return readBlock(child, childPath, depth);
+		}) };
+	});
+	return start === void 0 ? {
+		type: "list",
+		ordered: block.ordered,
+		items
+	} : {
+		type: "list",
+		ordered: block.ordered,
+		start,
+		items
+	};
+}
+/**
+* Checks `value` as a version 1 document and returns its canonical form: marks sorted, a link's
+* underline removed, adjacent equal runs merged, runs in NFC, and `start` of 1 left out. Throws
+* `invalid-argument` naming the first problem, under `path`.
+*/
+function readRichTextDocument(value, path) {
+	const document = record(value, path, ["version", "blocks"]);
+	if (document.version !== 1) invalid(`${path}.version`, `version ${JSON.stringify(document.version)} is not supported; the version must be 1`);
+	return {
+		version: 1,
+		blocks: list$1(document.blocks, `${path}.blocks`).map((block, index) => readBlock(block, `${path}.blocks[${index}]`, 0))
+	};
+}
+/** The text that stands for a canonical document inside the editor: its JSON. Two documents are
+*  the same exactly when their texts are. */
+function richTextText(document) {
+	return JSON.stringify(document);
+}
+/** The document a text from `richTextText` stands for, as a new object. */
+function richTextFromText(text) {
+	return JSON.parse(text);
+}
+/** Text from outside a document, such as a paste or another format, as canonical runs: a line or
+*  paragraph separator inside a paragraph becomes a line break, and characters RTF cannot hold as
+*  text become U+FFFD, so that no character disappears. */
+function appendText(builder, text, marks) {
+	text.replace(/[\u0000\ufffc]/g, "�").replace(/[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g, "�").split(/\r\n|[\n\r\u000b\u000c\u0085\u2028\u2029]/).forEach((line, index) => {
+		if (index) builder.break();
+		builder.text(line, marks);
+	});
+}
+/** Typed or pasted text as paragraphs: each paragraph separator ends one, including a final one,
+*  so inserting `'a\n'` leaves the caret in a new paragraph. A line separator is a line break.
+*  Unlike the host's `RichTextDocument(plainText:)`, which reads a file, nothing is trimmed. */
+function textBlocks(text) {
+	if (text === "") return [];
+	return text.split(/\r\n|[\n\r\u000c\u0085\u2029]/).map((line) => {
+		const builder = new InlineBuilder();
+		appendText(builder, line, []);
+		return {
+			type: "paragraph",
+			content: builder.finish()
+		};
+	});
+}
+//#endregion
+//#region src/formats/rich-text-prose.ts
+/** Editor marks by rich text mark, in canonical order. */
+var markNames = {
+	bold: "strong",
+	italic: "emphasis",
+	underline: "underline",
+	strikethrough: "strike_through",
+	superscript: "superscript",
+	subscript: "subscript",
+	code: "inlineCode",
+	link: "link"
+};
+var richMarks$1 = Object.fromEntries(Object.entries(markNames).map(([rich, name]) => [name, rich]));
+/** The editor nodes an RTF document can hold. */
+var allowedNodes = /* @__PURE__ */ new Set([
+	"doc",
+	"paragraph",
+	"text",
+	"hardbreak",
+	"bullet_list",
+	"ordered_list",
+	"list_item",
+	"table",
+	"table_header_row",
+	"table_row",
+	"table_header",
+	"table_cell"
+]);
+function unrepresentable(what) {
+	return new InkKitError("preservation", `The document holds ${what}, which an RTF document cannot hold`);
+}
+function proseMarks(schema, marks = []) {
+	return marks.map((mark) => mark.type === "link" ? schema.marks.link.create({ href: mark.href }) : schema.marks[markNames[mark.type]].create());
+}
+function proseInlines(schema, content, around) {
+	return content.map((inline) => {
+		if (inline.type === "break") return schema.nodes.hardbreak.create({
+			isInline: false,
+			isHTML: false
+		});
+		let marks = [...around];
+		for (const mark of proseMarks(schema, inline.marks)) marks = mark.addToSet(marks);
+		return schema.text(inline.text, marks);
+	});
+}
+function proseParagraph(schema, content, around, align = null) {
+	return schema.nodes.paragraph.create({ align }, proseInlines(schema, content, around));
+}
+/** The editor block for a rich text block. Its text also takes `around`, the marks of text that a
+*  paste replaces. */
+function proseBlock(schema, block, around = []) {
+	switch (block.type) {
+		case "paragraph": return proseParagraph(schema, block.content, around, block.align ?? null);
+		case "list": {
+			const start = block.start ?? 1;
+			const items = block.items.map((item, index) => schema.nodes.list_item.create({
+				label: block.ordered ? `${start + index}.` : "•",
+				listType: block.ordered ? "ordered" : "bullet",
+				spread: false,
+				checked: null
+			}, item.blocks.map((child) => proseBlock(schema, child, around))));
+			return block.ordered ? schema.nodes.ordered_list.create({
+				order: start,
+				spread: false
+			}, items) : schema.nodes.bullet_list.create({ spread: false }, items);
+		}
+		case "table": {
+			const row = (cells, index) => {
+				const header = index === 0;
+				return schema.nodes[header ? "table_header_row" : "table_row"].create(null, cells.rows[index].map((cell) => schema.nodes[header ? "table_header" : "table_cell"].create({ alignment: null }, proseParagraph(schema, cell.content, around))));
+			};
+			return schema.nodes.table.create(null, block.rows.map((_, index) => row(block, index)));
+		}
+	}
+}
+/** The editor document for a canonical rich text document. */
+function richTextToProse(schema, document) {
+	const blocks = document.blocks.map((block) => proseBlock(schema, block));
+	if (!blocks.length) blocks.push(proseParagraph(schema, [], []));
+	return schema.topNodeType.create(null, blocks);
+}
+function richMarksOf(marks) {
+	const result = [];
+	for (const mark of marks) {
+		const type = richMarks$1[mark.type.name];
+		if (!type) throw unrepresentable(`the ${mark.type.name} mark`);
+		result.push(type === "link" ? {
+			type: "link",
+			href: String(mark.attrs.href ?? "")
+		} : { type });
+	}
+	return canonicalMarks(result);
+}
+function richInlines(node) {
+	const builder = new InlineBuilder();
+	node.forEach((child) => {
+		if (child.type.name === "hardbreak") builder.break();
+		else if (child.isText) {
+			const text = child.text;
+			if (textProblem(text)) throw unrepresentable("a separator in its text");
+			const marks = richMarksOf(child.marks);
+			if (marks.some((mark) => mark.type === "link" && linkProblem(mark.href))) throw unrepresentable("a link without an address");
+			builder.text(text, marks);
+		} else throw unrepresentable(`a ${child.type.name}`);
+	});
+	return builder.finish();
+}
+function richParagraph(node, aligned) {
+	if (node.type.name !== "paragraph") throw unrepresentable(`a ${node.type.name}`);
+	const align = node.attrs.align;
+	if (align != null && !aligned) throw unrepresentable("an aligned table cell");
+	if (align != null && align !== "center" && align !== "right" && align !== "justify") throw unrepresentable(`${align} alignment`);
+	const content = richInlines(node);
+	return align == null ? {
+		type: "paragraph",
+		content
+	} : {
+		type: "paragraph",
+		align,
+		content
+	};
+}
+function richBlock(node, listDepth) {
+	switch (node.type.name) {
+		case "paragraph": return richParagraph(node, true);
+		case "bullet_list":
+		case "ordered_list": {
+			const depth = listDepth + 1;
+			if (depth > 9) throw unrepresentable(`lists deeper than 9 levels`);
+			const ordered = node.type.name === "ordered_list";
+			const items = [];
+			node.forEach((item) => {
+				if (item.type.name !== "list_item") throw unrepresentable(`a ${item.type.name}`);
+				if (item.attrs.checked != null) throw unrepresentable("a task");
+				const blocks = [];
+				item.forEach((child, _offset, index) => {
+					if (index === 0) blocks.push(richParagraph(child, true));
+					else if (/^(bullet|ordered)_list$/.test(child.type.name)) blocks.push(richBlock(child, depth));
+					else throw unrepresentable(`a ${child.type.name} in a list item`);
+				});
+				items.push({ blocks });
+			});
+			const start = Number(node.attrs.order ?? 1);
+			if (ordered && (!Number.isSafeInteger(start) || start < 1 || start > 2147483647)) throw unrepresentable(`a list that starts below 1 or above ${maximumListStart}`);
+			return ordered && start !== 1 ? {
+				type: "list",
+				ordered,
+				start,
+				items
+			} : {
+				type: "list",
+				ordered,
+				items
+			};
+		}
+		case "table": {
+			if (listDepth > 0) throw unrepresentable("a table in a list");
+			const rows = [];
+			node.forEach((row) => {
+				const cells = [];
+				row.forEach((cell) => {
+					if (cell.attrs.alignment != null || Number(cell.attrs.colspan ?? 1) !== 1 || Number(cell.attrs.rowspan ?? 1) !== 1) throw unrepresentable("an aligned or merged table cell");
+					if (cell.childCount !== 1) throw unrepresentable("a cell of several blocks");
+					const paragraph = richParagraph(cell.firstChild, false);
+					cells.push({ content: paragraph.content });
+				});
+				rows.push(cells);
+			});
+			if (!rows.length || !rows[0].length || rows.some((row) => row.length !== rows[0].length)) throw unrepresentable("a table with uneven rows");
+			return {
+				type: "table",
+				rows
+			};
+		}
+		default: throw unrepresentable(`a ${node.type.name}`);
+	}
+}
+/** The canonical rich text document for an editor document. Throws `preservation` when the
+*  document holds something RTF cannot. The editor always holds a block, so its one empty
+*  paragraph is an empty document when `emptyAsNone`, as it is when the document loaded empty. */
+function proseToRichText(doc, emptyAsNone = true) {
+	const blocks = [];
+	doc.forEach((node) => blocks.push(richBlock(node, 0)));
+	if (emptyAsNone && blocks.length === 1 && blocks[0].type === "paragraph" && !blocks[0].align && !blocks[0].content.length) blocks.length = 0;
+	return {
+		version: 1,
+		blocks
+	};
+}
+/** Why `node` cannot be in an RTF document at `$depth` lists deep, or undefined. Checks the node
+*  itself and its direct children, not its descendants. */
+function refusal(node, listDepth, inCell) {
+	const name = node.type.name;
+	if (!allowedNodes.has(name)) return name;
+	for (const mark of node.marks) if (!richMarks$1[mark.type.name]) return mark.type.name;
+	if (node.isText && textProblem(node.text)) return "text";
+	const href = node.type.schema.marks.link?.isInSet(node.marks)?.attrs.href;
+	if (href !== void 0 && linkProblem(String(href ?? ""))) return "link";
+	if (name === "paragraph" && node.attrs.align != null && inCell) return "aligned cell";
+	if (name === "list_item") {
+		if (node.attrs.checked != null) return "task";
+		for (let index = 1; index < node.childCount; index++) if (!/^(bullet|ordered)_list$/.test(node.child(index).type.name)) return "list item block";
+	}
+	if ((name === "bullet_list" || name === "ordered_list") && listDepth > 9) return "list depth";
+	const order = Number(node.attrs.order);
+	if (name === "ordered_list" && !(order >= 1 && order <= 2147483647)) return "list start";
+	if (name === "table" && listDepth > 0) return "table in list";
+	if ((name === "table_cell" || name === "table_header") && (node.attrs.alignment != null || Number(node.attrs.colspan ?? 1) !== 1 || Number(node.attrs.rowspan ?? 1) !== 1)) return "cell";
+}
+/** Whether the document a transaction reaches holds only what RTF can, read in the part it
+*  changed and that part's ancestors. */
+function richTextAllows(tr, before) {
+	if (!tr.docChanged) return true;
+	const doc = tr.doc;
+	const start = before.doc.content.findDiffStart(doc.content);
+	if (start == null) return true;
+	const end = before.doc.content.findDiffEnd(doc.content);
+	const to = Math.max(start, end?.b ?? doc.content.size);
+	let allowed = true;
+	const $start = doc.resolve(start);
+	let lists = 0;
+	for (let depth = 1; depth <= $start.depth; depth++) {
+		const node = $start.node(depth);
+		if (/^(bullet|ordered)_list$/.test(node.type.name)) lists++;
+		if (refusal(node, lists, false)) return false;
+	}
+	doc.nodesBetween(start, Math.min(to, doc.content.size), (node, pos) => {
+		if (!allowed) return false;
+		const $pos = doc.resolve(pos);
+		let depth = /^(bullet|ordered)_list$/.test(node.type.name) ? 1 : 0;
+		let inCell = false;
+		for (let level = $pos.depth; level > 0; level--) {
+			const name = $pos.node(level).type.name;
+			if (/^(bullet|ordered)_list$/.test(name)) depth++;
+			if (name === "table_cell" || name === "table_header") inCell = true;
+		}
+		if (refusal(node, depth, inCell)) allowed = false;
+		return allowed;
+	});
+	return allowed;
+}
+/** The ranges of runs that have both a link and underline, which canonical form removes the
+*  underline from, in the part of `doc` from `from` to `to`. */
+function linkedUnderlines(doc, from, to) {
+	const ranges = [];
+	const { link, underline } = doc.type.schema.marks;
+	if (!link || !underline) return ranges;
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.isText && link.isInSet(node.marks) && underline.isInSet(node.marks)) ranges.push({
+			from: pos,
+			to: pos + node.nodeSize
+		});
+	});
+	return ranges;
+}
+/** Whether every character from `from` to `to`, or the caret's marks, is in a link. */
+function inLink(state) {
+	const { link } = state.schema.marks;
+	if (!link) return false;
+	const { from, to, empty, $from } = state.selection;
+	if (empty) return Boolean(link.isInSet(state.storedMarks ?? $from.marks()));
+	let text = false;
+	let all = true;
+	state.doc.nodesBetween(from, to, (node) => {
+		if (!node.isText) return true;
+		text = true;
+		if (!link.isInSet(node.marks)) all = false;
+		return all;
+	});
+	return text && all;
+}
+//#endregion
+//#region src/formats/rich-text-import.ts
+var skipped = /* @__PURE__ */ new Set([
+	"SCRIPT",
+	"STYLE",
+	"TEMPLATE",
+	"NOSCRIPT",
+	"IFRAME",
+	"OBJECT",
+	"EMBED",
+	"HEAD",
+	"TITLE",
+	"META",
+	"LINK",
+	"SVG",
+	"MATH",
+	"IMG",
+	"PICTURE",
+	"VIDEO",
+	"AUDIO",
+	"CANVAS",
+	"BUTTON",
+	"INPUT",
+	"SELECT",
+	"TEXTAREA",
+	"HR"
+]);
+var blockTags = /* @__PURE__ */ new Set([
+	"ADDRESS",
+	"ARTICLE",
+	"ASIDE",
+	"BLOCKQUOTE",
+	"BODY",
+	"CENTER",
+	"DD",
+	"DETAILS",
+	"DIV",
+	"DL",
+	"DT",
+	"FIELDSET",
+	"FIGCAPTION",
+	"FIGURE",
+	"FOOTER",
+	"FORM",
+	"H1",
+	"H2",
+	"H3",
+	"H4",
+	"H5",
+	"H6",
+	"HEADER",
+	"HTML",
+	"LI",
+	"MAIN",
+	"NAV",
+	"OL",
+	"P",
+	"PRE",
+	"SECTION",
+	"SUMMARY",
+	"TABLE",
+	"UL"
+]);
+function withMark(marks, mark) {
+	if (marks.some((held) => held.type === mark.type)) return marks;
+	const other = mark.type === "superscript" ? "subscript" : mark.type === "subscript" ? "superscript" : "";
+	return canonicalMarks([...marks.filter((held) => held.type !== other), mark]);
+}
+function withoutMark(marks, type) {
+	return marks.filter((mark) => mark.type !== type);
+}
+/** The marks an element adds to its text, from its tag and its inline style. */
+function elementMarks(element, marks, schemes) {
+	const tag = element.tagName;
+	if (tag === "B" || tag === "STRONG") marks = withMark(marks, { type: "bold" });
+	if (tag === "I" || tag === "EM" || tag === "CITE" || tag === "DFN" || tag === "VAR") marks = withMark(marks, { type: "italic" });
+	if (tag === "U" || tag === "INS") marks = withMark(marks, { type: "underline" });
+	if (tag === "S" || tag === "DEL" || tag === "STRIKE") marks = withMark(marks, { type: "strikethrough" });
+	if (tag === "SUP") marks = withMark(marks, { type: "superscript" });
+	if (tag === "SUB") marks = withMark(marks, { type: "subscript" });
+	if (tag === "CODE" || tag === "KBD" || tag === "SAMP" || tag === "TT") marks = withMark(marks, { type: "code" });
+	if (tag === "A") {
+		const href = element.getAttribute("href")?.trim();
+		if (href && isSafeLinkTarget(href, schemes) && !linkProblem(href)) marks = withMark(withoutMark(marks, "link"), {
+			type: "link",
+			href
+		});
+	}
+	const style = element instanceof HTMLElement ? element.style : void 0;
+	if (style) {
+		const weight = style.fontWeight;
+		if (weight === "bold" || weight === "bolder" || Number(weight) >= 600) marks = withMark(marks, { type: "bold" });
+		else if (weight === "normal" || weight && Number(weight) < 600) marks = withoutMark(marks, "bold");
+		if (style.fontStyle === "italic" || style.fontStyle === "oblique") marks = withMark(marks, { type: "italic" });
+		else if (style.fontStyle === "normal") marks = withoutMark(marks, "italic");
+		const decoration = `${style.textDecoration} ${style.textDecorationLine}`;
+		if (/underline/.test(decoration)) marks = withMark(marks, { type: "underline" });
+		if (/line-through/.test(decoration)) marks = withMark(marks, { type: "strikethrough" });
+		if (style.verticalAlign === "super") marks = withMark(marks, { type: "superscript" });
+		if (style.verticalAlign === "sub") marks = withMark(marks, { type: "subscript" });
+	}
+	return canonicalMarks(marks);
+}
+function alignment(element) {
+	const value = (element instanceof HTMLElement ? element.style.textAlign : "") || element.getAttribute("align") || (element.tagName === "CENTER" ? "center" : "");
+	return value === "center" || value === "right" || value === "justify" ? value : void 0;
+}
+/** Reads blocks from a DOM, the way a person reads the page. */
+var Reader = class Reader {
+	schemes;
+	depth;
+	blocks = [];
+	inline;
+	align;
+	space;
+	constructor(schemes, depth) {
+		this.schemes = schemes;
+		this.depth = depth;
+	}
+	/** Ends the open paragraph, if any. */
+	flush() {
+		if (!this.inline) return;
+		const content = this.inline.finish();
+		if (content.at(-1)?.type === "break") content.pop();
+		this.blocks.push(this.align ? {
+			type: "paragraph",
+			align: this.align,
+			content
+		} : {
+			type: "paragraph",
+			content
+		});
+		this.inline = void 0;
+		this.align = void 0;
+		this.space = void 0;
+	}
+	open() {
+		this.inline ??= new InlineBuilder();
+		return this.inline;
+	}
+	text(value, marks, pre) {
+		if (pre) {
+			value.split(/\r\n|[\n\r]/).forEach((line, index) => {
+				if (index) this.flush();
+				appendText(this.open(), line, marks);
+			});
+			return;
+		}
+		const collapsed = value.replace(/[ \t\n\r\f]+/g, " ");
+		if (!collapsed) return;
+		if (collapsed === " ") {
+			if (this.inline?.content.length) this.space ??= marks;
+			return;
+		}
+		const builder = this.open();
+		const empty = !builder.content.length;
+		let text = collapsed;
+		if (text.startsWith(" ")) {
+			if (!empty) this.space ??= marks;
+			text = text.slice(1);
+		}
+		if (!text) return;
+		if (this.space) {
+			builder.text(" ", this.space);
+			this.space = void 0;
+		}
+		if (text.endsWith(" ")) {
+			this.space = marks;
+			text = text.slice(0, -1);
+		}
+		appendText(builder, text, marks);
+	}
+	lineBreak() {
+		this.space = void 0;
+		this.open().break();
+	}
+	/** Starts a paragraph that takes `element`'s alignment. */
+	paragraph(element) {
+		this.flush();
+		this.align = alignment(element);
+	}
+	push(block) {
+		this.flush();
+		this.blocks.push(block);
+	}
+	read(node, marks, pre) {
+		if (node.nodeType === Node.TEXT_NODE) {
+			this.text(node.textContent ?? "", marks, pre);
+			return;
+		}
+		if (node.nodeType !== Node.ELEMENT_NODE) return;
+		const element = node;
+		const tag = element.tagName.toUpperCase();
+		if (skipped.has(tag) || element instanceof HTMLElement && element.hidden) return;
+		if (element instanceof HTMLElement && element.style.display === "none") return;
+		if (tag === "BR") {
+			this.lineBreak();
+			return;
+		}
+		if (tag === "UL" || tag === "OL") {
+			this.push(this.list(element, marks));
+			return;
+		}
+		if (tag === "TABLE") {
+			const table = this.depth === 0 && !spansRows(element);
+			const rows = tableRows(element, marks, this.schemes, table);
+			if (!rows.length) return;
+			if (table) this.push({
+				type: "table",
+				rows
+			});
+			else for (const row of rows) {
+				this.paragraph(element);
+				this.open();
+				row.forEach((cell, index) => {
+					if (index) this.open().text("	", []);
+					for (const inline of cell.content) if (inline.type === "break") this.open().break();
+					else this.open().text(inline.text, inline.marks ?? []);
+				});
+				this.flush();
+			}
+			return;
+		}
+		let inner = elementMarks(element, marks, this.schemes);
+		if (/^H[1-6]$/.test(tag)) inner = withMark(inner, { type: "bold" });
+		const block = blockTags.has(tag);
+		if (block) this.paragraph(element);
+		if (tag === "P" || /^H[1-6]$/.test(tag)) this.open();
+		const preformatted = pre || tag === "PRE" || element instanceof HTMLElement && /^pre/.test(element.style.whiteSpace);
+		if (tag === "PRE") inner = withMark(inner, { type: "code" });
+		for (const child of element.childNodes) this.read(child, inner, preformatted);
+		if (block) this.flush();
+	}
+	list(element, marks) {
+		const ordered = element.tagName.toUpperCase() === "OL";
+		const start = Number(element.getAttribute("start") ?? 1);
+		const items = [];
+		const inner = elementMarks(element, marks, this.schemes);
+		for (const child of element.childNodes) {
+			if (child.nodeType === Node.ELEMENT_NODE && child.tagName.toUpperCase() === "LI") {
+				items.push({ blocks: this.item(child, inner) });
+				continue;
+			}
+			const reader = new Reader(this.schemes, this.depth + 1);
+			reader.read(child, inner, false);
+			reader.flush();
+			if (!reader.blocks.length) continue;
+			const blocks = itemBlocks(reader.blocks, this.depth + 1);
+			if (items.length && blocks[0].type === "paragraph" && !blocks[0].content.length) items.at(-1).blocks.push(...blocks.slice(1));
+			else items.push({ blocks });
+		}
+		if (!items.length) items.push({ blocks: [{
+			type: "paragraph",
+			content: []
+		}] });
+		return ordered && Number.isSafeInteger(start) && start > 1 ? {
+			type: "list",
+			ordered,
+			start: Math.min(start, maximumListStart),
+			items
+		} : {
+			type: "list",
+			ordered,
+			items
+		};
+	}
+	item(element, marks) {
+		const reader = new Reader(this.schemes, this.depth + 1);
+		const inner = elementMarks(element, marks, this.schemes);
+		for (const child of element.childNodes) reader.read(child, inner, false);
+		reader.flush();
+		return itemBlocks(reader.blocks, this.depth + 1);
+	}
+};
+/** A list item's blocks as RTF holds them: one paragraph, then lists. Further paragraphs join the
+*  first as lines. Lists keep every level here; the paste lifts those deeper than RTF holds. */
+function itemBlocks(blocks, depth) {
+	const builder = new InlineBuilder();
+	let align;
+	let lines = 0;
+	const nested = [];
+	const line = (content) => {
+		if (lines++) builder.break();
+		for (const inline of content) if (inline.type === "break") builder.break();
+		else builder.text(inline.text, inline.marks ?? []);
+	};
+	const flatten = (block) => {
+		if (block.type === "paragraph") line(block.content);
+		else if (block.type === "list") for (const item of block.items) for (const child of item.blocks) flatten(child);
+		else for (const row of block.rows) for (const cell of row) line(cell.content);
+	};
+	for (const block of blocks) if (block.type === "list") nested.push(block);
+	else if (block.type === "paragraph" && !nested.length) {
+		if (!lines) align = block.align;
+		line(block.content);
+	} else flatten(block);
+	const content = builder.finish();
+	return [align ? {
+		type: "paragraph",
+		align,
+		content
+	} : {
+		type: "paragraph",
+		content
+	}, ...nested];
+}
+/** Whether a cell of `table` itself, not of a table inside it, spans more than one row. */
+function spansRows(table) {
+	return [...table.querySelectorAll("td[rowspan], th[rowspan]")].some((cell) => cell.closest("table") === table && Number(cell.getAttribute("rowspan")) > 1);
+}
+function tableRows(table, marks, schemes, even) {
+	const rows = [];
+	for (const row of table.querySelectorAll("tr")) {
+		if (row.closest("table") !== table) continue;
+		const cells = [];
+		for (const cell of row.children) {
+			if (cell.tagName !== "TD" && cell.tagName !== "TH") continue;
+			const reader = new Reader(schemes, 1);
+			const inner = elementMarks(cell, marks, schemes);
+			for (const child of cell.childNodes) reader.read(child, inner, false);
+			reader.flush();
+			const builder = new InlineBuilder();
+			let lines = 0;
+			const add = (block) => {
+				if (block.type === "paragraph") {
+					if (lines++) builder.break();
+					for (const inline of block.content) if (inline.type === "break") builder.break();
+					else builder.text(inline.text, inline.marks ?? []);
+				} else if (block.type === "list") for (const item of block.items) item.blocks.forEach(add);
+				else for (const nestedRow of block.rows) for (const nestedCell of nestedRow) add({
+					type: "paragraph",
+					content: nestedCell.content
+				});
+			};
+			reader.blocks.forEach(add);
+			const content = builder.finish();
+			const span = Math.max(1, Math.min(100, Number(cell.getAttribute("colspan") ?? 1) || 1));
+			cells.push({ content });
+			for (let index = 1; index < span; index++) cells.push({ content: [] });
+		}
+		if (cells.length) rows.push(cells);
+	}
+	const width = even ? Math.max(0, ...rows.map((row) => row.length)) : 0;
+	for (const row of rows) while (row.length < width) row.push({ content: [] });
+	return rows;
+}
+/** Blocks for pasted HTML. */
+function htmlBlocks(html, schemes) {
+	const parsed = new DOMParser().parseFromString(html, "text/html");
+	const reader = new Reader(schemes, 0);
+	reader.read(parsed.body, [], false);
+	reader.flush();
+	return reader.blocks;
+}
+/** Every block's text as lines of one paragraph, for a place that holds only one, such as a
+*  table cell. */
+function asLines(blocks) {
+	const builder = new InlineBuilder();
+	let lines = 0;
+	const add = (content) => {
+		if (lines++) builder.break();
+		for (const inline of content) if (inline.type === "break") builder.break();
+		else builder.text(inline.text, inline.marks ?? []);
+	};
+	const visit = (block) => {
+		if (block.type === "paragraph") add(block.content);
+		else if (block.type === "list") block.items.forEach((item) => item.blocks.forEach(visit));
+		else block.rows.forEach((row) => add(row.flatMap((cell, index) => index ? [{
+			type: "text",
+			text: "	"
+		}, ...cell.content] : cell.content)));
+	};
+	blocks.forEach(visit);
+	return [{
+		type: "paragraph",
+		content: builder.finish()
+	}];
+}
+/** `list`, at `depth` lists deep, with every level beyond the deepest RTF holds lifted to the
+*  deepest: the items of a list that would be too deep become items of its parent list. */
+function liftDeepLevels(list, depth) {
+	const flat = (deep) => deep.items.flatMap((item) => [{ blocks: [item.blocks[0]] }, ...item.blocks.slice(1).flatMap((nested) => flat(nested))]);
+	return {
+		...list,
+		items: list.items.flatMap((item) => {
+			const [paragraph, ...nested] = item.blocks;
+			const kept = [];
+			const lifted = [];
+			for (const child of nested) if (depth + 1 <= 9) kept.push(liftDeepLevels(child, depth + 1));
+			else lifted.push(...flat(child));
+			return [{ blocks: [paragraph, ...kept] }, ...lifted];
+		})
+	};
+}
+/**
+* A paste of several blocks into a list item, which holds one paragraph: each paragraph becomes
+* an item beside the one at the caret, at its level. The first joins the item at the caret, the
+* text after the caret moves to the last, and a pasted list nests in the item before it.
+*/
+function listItemsSlice(schema, blocks, list, depth, marks) {
+	const empty = {
+		type: "paragraph",
+		content: []
+	};
+	const items = [];
+	for (const block of blocks) if (block.type === "paragraph") items.push({ blocks: [block] });
+	else if (block.type === "list") {
+		if (!items.length) items.push({ blocks: [empty] });
+		items.at(-1).blocks.push(block);
+	} else for (const line of asLines([block])) items.push({ blocks: [line] });
+	if (!items.length || items.at(-1).blocks.length > 1) items.push({ blocks: [empty] });
+	const ordered = list.type.name === "ordered_list";
+	const nodes = liftDeepLevels({
+		type: "list",
+		ordered,
+		items
+	}, depth).items.map((item) => schema.nodes.list_item.create({
+		label: ordered ? "1." : "•",
+		listType: ordered ? "ordered" : "bullet",
+		spread: false,
+		checked: null
+	}, item.blocks.map((block) => proseBlock(schema, block, marks))));
+	return new Slice(Fragment.fromArray(nodes), 2, 2);
+}
+/**
+* The slice that `input` pastes into an RTF document at the selection. Explicit Markdown pastes as
+* its text, unparsed; HTML keeps what RTF can hold; plain text gives a paragraph for each line.
+* Plain text takes the marks of the text it replaces, as typing would.
+*/
+function richTextPaste(input, state, schemes) {
+	const { schema, selection } = state;
+	const { $from, $to } = selection;
+	const html = input.markdown == null && input.html ? htmlBlocks(input.html, schemes) : void 0;
+	const plain = html == null;
+	let blocks = html ?? textBlocks(input.markdown ?? input.text);
+	if (html && !blocks.some((block) => block.type !== "paragraph" || block.content.length)) blocks = textBlocks(input.text);
+	let cell = false;
+	let lists = 0;
+	let list;
+	for (let depth = $from.depth; depth > 0; depth--) {
+		const node = $from.node(depth);
+		const name = node.type.name;
+		if (name === "table_cell" || name === "table_header") cell = true;
+		if (name === "bullet_list" || name === "ordered_list") {
+			lists++;
+			list ??= node;
+		}
+	}
+	if (cell) blocks = asLines(blocks);
+	else blocks = blocks.map((block) => block.type === "list" ? liftDeepLevels(block, lists + 1) : block);
+	const marks = plain ? state.storedMarks ?? ($from.marksAcross($to) ?? $from.marks()).filter((mark) => mark.type.name !== "link") : [];
+	if (list && !cell && !(blocks.length === 1 && blocks[0].type === "paragraph")) return listItemsSlice(schema, blocks, list, lists, marks);
+	const nodes = blocks.map((block) => proseBlock(schema, block, marks));
+	if (!nodes.length) return Slice.empty;
+	const openStart = nodes[0].type.name === "paragraph" ? 1 : 0;
+	const openEnd = nodes.at(-1).type.name === "paragraph" ? 1 : 0;
+	return new Slice(Fragment.fromArray(nodes), openStart, openEnd);
+}
+//#endregion
+//#region src/formats/rich-text.ts
+function source(ctx, text) {
+	const { schema } = ctx.get(editorViewCtx).state;
+	const document = richTextFromText(text);
+	const emptyAsNone = document.blocks.length === 0;
+	return {
+		baseline: richTextToProse(schema, document),
+		serialize: (doc) => richTextText(proseToRichText(doc, emptyAsNone))
+	};
+}
+/** Rich text, which the host converts to and from RTF. The editor holds the canonical JSON as the
+*  document's text. It reaches no Markdown parsing or preservation;
+*  `test/formats/boundary.test.ts` checks its imports. */
+var richTextFormat = {
+	format: "rtf",
+	promise: "structure",
+	literalOnly: false,
+	sourceMode: false,
+	formattedLabel: "richTextEditor",
+	literalLabel: "sourceEditor",
+	headings: false,
+	nativeCopy: false,
+	keepsInsertedLineEndings: false,
+	markdownInput: false,
+	load: source,
+	parse: source,
+	pendingExport: () => void 0,
+	literalPaste: (input) => input.text,
+	richText: {
+		allows: richTextAllows,
+		linkedUnderlines,
+		inLink,
+		paste: richTextPaste,
+		copy(state, linkSchemes) {
+			const content = state.selection.content().content;
+			return clipboardContent(content, state.schema, linkSchemes);
+		}
+	},
+	async print({ doc, signal, output }) {
+		return printableMarkdown(doc.content, output.ctx().get(editorViewCtx).state.schema, void 0, output.context(), void 0, signal);
+	},
+	async clipboard({ all, version, output, assertCurrent }) {
+		const { state } = output.ctx().get(editorViewCtx);
+		const slice = all ? new Slice(state.doc.content, 0, 0) : state.selection.content();
+		const content = slice.content;
+		const markdown = output.richTextMarkdown(slice);
+		const { html } = clipboardContent(content, state.schema, output.linkSchemes());
+		const text = clipboardText(content);
+		assertCurrent();
+		return {
+			...version,
+			text,
+			html,
+			markdown,
+			images: [],
+			diagrams: []
+		};
+	}
+};
 //#endregion
 //#region src/formats/text.ts
 /** A paragraph holding `text`, or an empty one. */
@@ -51656,10 +52856,12 @@ var textFormat = {
 	promise: "exact",
 	literalOnly: true,
 	sourceMode: false,
+	formattedLabel: "formattedEditor",
 	literalLabel: "plainTextEditor",
 	headings: false,
 	nativeCopy: true,
 	keepsInsertedLineEndings: false,
+	markdownInput: false,
 	load: (ctx) => paragraph(ctx, ""),
 	parse: paragraph,
 	pendingExport: () => void 0,
@@ -51681,11 +52883,18 @@ var textFormat = {
 };
 //#endregion
 //#region src/formats/index.ts
-/** Every format Inkkit can open, and the list a host is offered when it chooses none. */
-var documentFormats = ["md", "txt"];
+/** Every format Inkkit can open. */
+var documentFormats = [
+	"md",
+	"txt",
+	"rtf"
+];
+/** The formats a host is offered when it chooses none. */
+var defaultFormats = ["md", "txt"];
 var formatHandlers = {
 	md: markdownFormat,
-	txt: textFormat
+	txt: textFormat,
+	rtf: richTextFormat
 };
 //#endregion
 //#region src/editor-document.ts
@@ -51746,7 +52955,7 @@ var EditorDocument = class {
 					this.sourcePreservations.set(provenance, preservation);
 				}
 			}
-			text = preservation.serialize(cleanSourceDoc(doc), this.carried);
+			text = preservation.serialize(this.handler.richText ? doc : cleanSourceDoc(doc), this.carried);
 		} catch (error) {
 			throw coded(error, "preservation");
 		}
@@ -51793,7 +53002,7 @@ var EditorDocument = class {
 	*/
 	authoredSources(doc, positions) {
 		const none = /* @__PURE__ */ new Map();
-		if (this.runtime.literal() || !positions.length) return none;
+		if (this.runtime.literal() || this.handler.richText || !positions.length) return none;
 		try {
 			let marked = doc;
 			for (let index = positions.length - 1; index >= 0; index--) {
@@ -52305,7 +53514,7 @@ var rejoinLists = $prose(() => keymap$3({ Backspace: (state, dispatch) => {
 		const list = $from.node(-2);
 		const sublist = container.maybeChild(1);
 		const previous = list.maybeChild($from.index(-2) - 1)?.lastChild;
-		if (index !== 0 || container.childCount !== 2 || !sublist || !isList(sublist) || previous?.type !== sublist.type) return false;
+		if (index !== 0 || container.childCount !== 2 || !sublist || !isList$1(sublist) || previous?.type !== sublist.type) return false;
 		if (dispatch) {
 			const at = $from.before(-1);
 			const end = at - 2;
@@ -52317,7 +53526,7 @@ var rejoinLists = $prose(() => keymap$3({ Backspace: (state, dispatch) => {
 	}
 	const before = container.maybeChild(index - 1);
 	const after = container.maybeChild(index + 1);
-	if (!before || !after || !isList(before) || after.type !== before.type) return false;
+	if (!before || !after || !isList$1(before) || after.type !== before.type) return false;
 	if (dispatch) {
 		const at = $from.before();
 		const tr = state.tr.delete(at, $from.after());
@@ -52390,21 +53599,21 @@ var movedListItems = $prose(() => new Plugin({
 }));
 var textInputPolicy = $prose(() => textInputPlugin());
 function outermostListDepth($pos) {
-	for (let depth = 1; depth <= $pos.depth; depth++) if (isList($pos.node(depth))) return depth;
+	for (let depth = 1; depth <= $pos.depth; depth++) if (isList$1($pos.node(depth))) return depth;
 	return null;
 }
 function innermostListDepth($pos) {
-	for (let depth = $pos.depth; depth >= 1; depth--) if (isList($pos.node(depth))) return depth;
+	for (let depth = $pos.depth; depth >= 1; depth--) if (isList$1($pos.node(depth))) return depth;
 	return null;
 }
-function isList(node) {
+function isList$1(node) {
 	return node.type.name === "bullet_list" || node.type.name === "ordered_list";
 }
 function joinLists(tr, start, index) {
 	const $start = tr.doc.resolve(start);
 	const before = $start.parent.maybeChild(index - 1);
 	const after = $start.parent.maybeChild(index);
-	if (before && after && isList(before) && after.type === before.type) tr.join($start.posAtIndex(index));
+	if (before && after && isList$1(before) && after.type === before.type) tr.join($start.posAtIndex(index));
 }
 //#endregion
 //#region src/editor-commands.ts
@@ -52412,7 +53621,67 @@ function headingLevel(command) {
 	const match = /^heading([1-6])$/.exec(command);
 	return match ? Number(match[1]) : void 0;
 }
-function formatAvailability(editor, state, formatted) {
+/** What an RTF document cannot hold: headings, code blocks, quotes, tasks and highlight. Every
+*  other command is available as in Markdown, and alignment only here. */
+var unavailableInRichText = [
+	"heading1",
+	"heading2",
+	"heading3",
+	"heading4",
+	"heading5",
+	"heading6",
+	"paragraph",
+	"highlight",
+	"codeBlock",
+	"quote",
+	"taskList",
+	"toggleTask"
+];
+var alignments = {
+	alignLeft: null,
+	alignCenter: "center",
+	alignRight: "right",
+	alignJustify: "justify"
+};
+function isAlignCommand(command) {
+	return command in alignments;
+}
+/** Calls `found` for each paragraph the selection touches that can take an alignment, which
+*  those in table cells cannot, until it returns false. */
+function eachAlignable(state, found) {
+	const { from, to } = state.selection;
+	let going = true;
+	state.doc.nodesBetween(from, to, (node, pos) => {
+		if (!going || node.type.name === "table") return false;
+		if (node.type.name === "paragraph") going = found(node, pos);
+		return going && !node.isTextblock;
+	});
+}
+function canAlign(state) {
+	let any = false;
+	eachAlignable(state, () => {
+		any = true;
+		return false;
+	});
+	return any;
+}
+/** The alignment of the paragraph that holds the start of the selection. */
+function caretAlignment(state) {
+	const { parent } = state.selection.$from;
+	return parent.type.name === "paragraph" && parent.attrs.align ? parent.attrs.align : "left";
+}
+function formatAvailability(editor, state, formatted, handler) {
+	const available = markdownAvailability(editor, state, formatted);
+	const rich = handler.richText;
+	if (!rich) return available;
+	for (const command of unavailableInRichText) available[command] = false;
+	if (available.underline && rich.inLink(state)) available.underline = false;
+	const align = formatted && canAlign(state);
+	available.alignLeft = available.alignCenter = align;
+	available.alignRight = available.alignJustify = align;
+	return available;
+}
+function markdownAvailability(editor, state, formatted) {
 	const manager = editor.ctx.get(commandsCtx);
 	const check = (key, payload) => formatted && manager.get(key)(payload)(state);
 	const canBecome = (type, level) => formatted && textblockType(editor, type, level)(state);
@@ -52439,9 +53708,27 @@ function formatAvailability(editor, state, formatted) {
 		orderedList: formatted && (innermostListDepth(textBounds(state).$from) != null || check(wrapInOrderedListCommand.key)),
 		taskList: formatted && (innermostListDepth(textBounds(state).$from) != null || check(wrapInBulletListCommand.key)),
 		toggleTask: formatted && taskAtCaret(state) != null,
+		alignLeft: false,
+		alignCenter: false,
+		alignRight: false,
+		alignJustify: false,
 		link: check(toggleLinkCommand.key, {})
 	};
 }
+/** Sets the alignment of the paragraphs the selection touches. */
+function align(editor, command) {
+	const view = editor.ctx.get(editorViewCtx);
+	const value = alignments[command];
+	const tr = view.state.tr;
+	eachAlignable(view.state, (node, pos) => {
+		if (node.attrs.align !== value) tr.setNodeMarkup(pos, void 0, {
+			...node.attrs,
+			align: value
+		});
+		return true;
+	});
+	if (tr.docChanged) view.dispatch(tr);
+}
 function canQuote(editor, state) {
 	const { $from, $to } = textBounds(state);
 	if (quoted($from, $to)) {
@@ -52496,12 +53783,32 @@ function toggleInlineCode(editor) {
 	if (!type.isInSet(selection.$from.marks())) view.dispatch(view.state.tr.addStoredMark(type.create()));
 	else withMarkRunSelected(editor, type, run);
 }
-function list(editor, kind) {
+function list(editor, kind, itemPerBlock) {
 	const view = editor.ctx.get(editorViewCtx);
 	const { state } = view;
 	const { $from } = textBounds(state);
 	const wanted = kind === "bulletList" ? "bullet_list" : "ordered_list";
 	const depth = innermostListDepth($from);
+	if (depth == null && itemPerBlock) {
+		const ordered = wanted === "ordered_list";
+		wrapInList(state.schema.nodes[wanted], ordered ? {
+			order: 1,
+			spread: false
+		} : { spread: false })(state, (tr) => {
+			tr.doc.nodesBetween(tr.mapping.map(state.selection.from), tr.mapping.map(state.selection.to), (node, pos) => {
+				if (node.type.name !== "list_item") return true;
+				tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					listType: ordered ? "ordered" : "bullet",
+					label: ordered ? "1." : "•",
+					spread: false
+				});
+				return false;
+			});
+			view.dispatch(tr);
+		});
+		return;
+	}
 	if (depth == null) {
 		const command = kind === "bulletList" ? wrapInBulletListCommand : wrapInOrderedListCommand;
 		editor.action(callCommand(command.key));
@@ -52560,11 +53867,15 @@ function textblockType(editor, type, attr) {
 	if (type === "heading") return setTextblockType(ctx, headingSchema.type(ctx), { level: Number(attr) });
 	return setTextblockType(ctx, paragraphSchema.type(ctx));
 }
-function applyFormat(editor, command, checked, link) {
+function applyFormat(editor, command, checked, link, itemPerBlock = false) {
 	const view = editor.ctx.get(editorViewCtx);
 	const run = (cmd, payload) => editor.action(callCommand(cmd, payload));
 	const state = caretState(view.state);
 	const become = (type, attr) => textblockType(editor, type, attr)(view.state, view.dispatch);
+	if (isAlignCommand(command)) {
+		align(editor, command);
+		return;
+	}
 	const level = headingLevel(command);
 	if (level != null) {
 		if (state.block.type === "heading" && state.block.level === level) become("paragraph");
@@ -52608,7 +53919,7 @@ function applyFormat(editor, command, checked, link) {
 			break;
 		case "bulletList":
 		case "orderedList":
-			list(editor, command);
+			list(editor, command, itemPerBlock);
 			break;
 		case "taskList":
 			toggleTaskList(editor.ctx);
@@ -55583,6 +56894,7 @@ async function createMilkdownEditor(root, options, runtime) {
 		ctx.set(rootCtx, root);
 		ctx.set(authoredSourcesCtx.key, (doc, positions) => runtime.authoredSources(doc, positions));
 		ctx.set(smartPunctuationCtx.key, () => runtime.smartPunctuation());
+		ctx.set(formatInputCtx.key, runtime.format);
 		ctx.set(linkSchemesCtx.key, runtime.linkSchemes);
 		ctx.update(labelsCtx.key, () => ({
 			...defaultLabels,
@@ -55632,7 +56944,7 @@ async function createMilkdownEditor(root, options, runtime) {
 				return true;
 			}
 		}));
-	}).use(labelsCtx).use(linkSchemesCtx).use(runtime.plugins.paste).use(visibleClipboard).use(runtime.plugins.suggestions).use(runtime.plugins.keymap).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(codeControlCtx).use(codeControlsPlugin(() => runtime.visibleRect())).use(tablePlugins).use(tableBlock).use(runtime.plugins.change).use(runtime.plugins.historyInput).use(history).use(clipboard).use(cursor).use(taskListPlugin((operation) => runtime.mutate(operation))).use(undoTypedRule).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(runtime.copy ? codeCopyPlugin((text) => runtime.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-wulvkYDg.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview(runtime.diagrams, (error) => runtime.report(error))).use(selectionPlugin).use($prose(() => search())).use(runtime.plugins.policy).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
+	}).use(labelsCtx).use(linkSchemesCtx).use(formatInputCtx).use(richTextGuard).use(runtime.plugins.paste).use(visibleClipboard).use(runtime.plugins.suggestions).use(runtime.plugins.keymap).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(codeControlCtx).use(codeControlsPlugin(() => runtime.visibleRect())).use(tablePlugins).use(tableBlock).use(runtime.plugins.change).use(runtime.plugins.historyInput).use(history).use(clipboard).use(cursor).use(taskListPlugin((operation) => runtime.mutate(operation))).use(undoTypedRule).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(runtime.copy ? codeCopyPlugin((text) => runtime.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-4lYN38Zo.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview(runtime.diagrams, (error) => runtime.report(error))).use(selectionPlugin).use($prose(() => search())).use(runtime.plugins.policy).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
 		capture: () => runtime.capture(),
 		active: () => runtime.active(),
 		labels: {
@@ -55648,8 +56960,46 @@ async function createMilkdownEditor(root, options, runtime) {
 			...options.labels
 		},
 		error: (error) => runtime.report(error)
-	}, options.files, runtime.canMutate) : []).create();
+	}, options.files, runtime.canMutate) : []).create().then((editor) => {
+		markdownInputRules(editor.ctx);
+		return editor;
+	});
+}
+/** Markdown input rules, such as `# ` for a heading, do nothing in a format that is not Markdown.
+*  Rules that are not Markdown syntax, such as smart punctuation, keep applying. */
+function markdownInputRules(ctx) {
+	for (const rule of ctx.get(inputRulesCtx)) {
+		if (formatNeutralRules.has(rule)) continue;
+		const held = rule;
+		const handler = held.handler;
+		held.handler = (state, match, start, end) => formatInput(ctx).markdownInput() ? handler(state, match, start, end) : null;
+	}
 }
+/**
+* In a format that holds less than Markdown, such as RTF, refuses any transaction that would bring
+* in a node, mark or structure the format cannot hold, so a disallowed edit changes nothing. A
+* link's underline, which RTF does not keep, is removed in the same step.
+*/
+var richTextGuard = $prose((ctx) => new Plugin({
+	key: new PluginKey("inkkitRichTextGuard"),
+	filterTransaction(tr, state) {
+		const rich = formatInput(ctx).richText();
+		return !rich || rich.allows(tr, state);
+	},
+	appendTransaction(transactions, oldState, newState) {
+		const rich = formatInput(ctx).richText();
+		if (!rich || !transactions.some((tr) => tr.docChanged)) return null;
+		const start = oldState.doc.content.findDiffStart(newState.doc.content);
+		if (start == null) return null;
+		const end = oldState.doc.content.findDiffEnd(newState.doc.content).b;
+		const ranges = rich.linkedUnderlines(newState.doc, start, Math.max(start, end));
+		if (!ranges.length) return null;
+		const tr = newState.tr;
+		for (const { from, to } of ranges) tr.removeMark(from, to, newState.schema.marks.underline);
+		if (newState.storedMarks) tr.setStoredMarks(newState.storedMarks);
+		return tr;
+	}
+}));
 function createDocumentState(ctx, doc) {
 	return EditorState.create(ctx.get(editorStateOptionsCtx)({
 		schema: ctx.get(schemaCtx),
@@ -55662,6 +57012,402 @@ function initialDocumentSelection(state) {
 	return setSearchState(state.tr.setSelection(end), new SearchQuery({ search: "" }));
 }
 //#endregion
+//#region src/formats/convert.ts
+var Losses = class {
+	counts = /* @__PURE__ */ new Map();
+	add(code) {
+		this.counts.set(code, (this.counts.get(code) ?? 0) + 1);
+	}
+	list() {
+		return Object.freeze(formatLossCodes.filter((code) => this.counts.has(code)).map((code) => Object.freeze({
+			code,
+			count: this.counts.get(code)
+		})));
+	}
+};
+var richMarks = {
+	strong: "bold",
+	emphasis: "italic",
+	underline: "underline",
+	strike_through: "strikethrough",
+	superscript: "superscript",
+	subscript: "subscript",
+	inlineCode: "code",
+	link: "link"
+};
+var isList = (node) => node.type.name === "bullet_list" || node.type.name === "ordered_list";
+/** Reads a formatted Markdown document as rich text, counting what RTF cannot hold. */
+var MarkdownReader = class {
+	lost = new Losses();
+	/** Appends text, counting characters RTF can't hold, which become U+FFFD. */
+	append(builder, text, marks) {
+		if (/[\u0000\ufffc]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/.test(text)) this.lost.add("invalid-character");
+		appendText(builder, text, marks);
+	}
+	marks(marks, extra) {
+		const result = [...extra];
+		for (const mark of marks) {
+			const type = richMarks[mark.type.name];
+			if (!type) {
+				if (mark.type.name === "highlight") this.lost.add("highlight");
+				continue;
+			}
+			if (result.some((held) => held.type === type)) continue;
+			if (type === "link") {
+				const href = String(mark.attrs.href ?? "");
+				if (linkProblem(href)) {
+					this.lost.add("link");
+					continue;
+				}
+				result.push({
+					type: "link",
+					href
+				});
+			} else result.push({ type });
+		}
+		if (result.some((mark) => mark.type === "link") && result.some((mark) => mark.type === "underline")) this.lost.add("link-underline");
+		return canonicalMarks(result);
+	}
+	/** Appends a textblock's inline content. */
+	inline(node, builder, extra = []) {
+		node.forEach((child) => {
+			const name = child.type.name;
+			if (child.isText) this.append(builder, child.text, this.marks(child.marks, extra));
+			else if (name === "hardbreak") builder.break();
+			else if (name === "footnote_reference") {
+				this.lost.add("footnote");
+				this.append(builder, `[${String(child.attrs.label)}]`, this.marks(child.marks, extra));
+			} else if (name === "inkkit_wiki_link") {
+				this.lost.add("wiki-link");
+				this.append(builder, String(child.attrs.label || child.attrs.target || child.attrs.raw || ""), this.marks(child.marks, extra));
+			} else if (name === "image") this.lost.add(child.attrs.inkkitFileTarget || child.attrs.inkkitFileRaw ? "file" : "image");
+			else if (name === "comment_inline") this.lost.add("comment");
+			else if (name === "html") {
+				this.lost.add("literal");
+				this.append(builder, String(child.attrs.value ?? ""), this.marks(child.marks, extra));
+			} else if (child.isInline) this.inline(child, builder, extra);
+		});
+	}
+	paragraph(node, extra = []) {
+		const builder = new InlineBuilder();
+		this.inline(node, builder, extra);
+		return {
+			type: "paragraph",
+			content: builder.finish()
+		};
+	}
+	lines(text, marks) {
+		return text.split(/\r\n|[\n\r]/).map((line) => {
+			const builder = new InlineBuilder();
+			this.append(builder, line, marks);
+			return {
+				type: "paragraph",
+				content: builder.finish()
+			};
+		});
+	}
+	/** The blocks for `node`, `depth` lists deep. */
+	blocks(node, depth) {
+		switch (node.type.name) {
+			case "paragraph": return [this.paragraph(node)];
+			case "heading":
+				this.lost.add("heading");
+				return [this.paragraph(node, [{ type: "bold" }])];
+			case "code_block":
+				this.lost.add(String(node.attrs.language).toLowerCase() === "mermaid" ? "diagram" : "code-block");
+				return this.lines(node.textContent, [{ type: "code" }]);
+			case "literal_markdown":
+				this.lost.add("literal");
+				return this.lines(node.textContent, []);
+			case "blockquote":
+			case "inkkit_callout": {
+				this.lost.add(node.type.name === "blockquote" ? "quote" : "callout");
+				const blocks = [];
+				const title = node.attrs.title;
+				if (title) blocks.push(...this.lines(title, [{ type: "bold" }]));
+				node.forEach((child) => blocks.push(...this.blocks(child, depth)));
+				return blocks;
+			}
+			case "footnote_definition": {
+				this.lost.add("footnote");
+				const blocks = [];
+				node.forEach((child) => blocks.push(...this.blocks(child, depth)));
+				const label = `[${String(node.attrs.label)}] `;
+				const first = blocks[0];
+				const builder = new InlineBuilder();
+				builder.text(first?.type === "paragraph" ? label : label.trim(), []);
+				if (first?.type === "paragraph") {
+					for (const inline of first.content) if (inline.type === "break") builder.break();
+					else builder.text(inline.text, inline.marks ?? []);
+					blocks[0] = {
+						...first,
+						content: builder.finish()
+					};
+				} else blocks.unshift({
+					type: "paragraph",
+					content: builder.finish()
+				});
+				return blocks;
+			}
+			case "bullet_list":
+			case "ordered_list": return [this.list(node, depth + 1)];
+			case "table": return depth > 0 ? this.tableLines(node) : [this.table(node)];
+			case "hr":
+				this.lost.add("rule");
+				return [];
+			case "comment_block":
+				this.lost.add("comment");
+				return [];
+			case "image_block":
+				this.lost.add(node.attrs.inkkitFileTarget || node.attrs.inkkitFileRaw ? "file" : "image");
+				return [];
+			case "reference_definition": return [];
+			default: {
+				if (node.isTextblock) return [this.paragraph(node)];
+				const blocks = [];
+				node.forEach((child) => blocks.push(...this.blocks(child, depth)));
+				return blocks;
+			}
+		}
+	}
+	table(node) {
+		let aligned = false;
+		const rows = [];
+		node.forEach((row) => {
+			const cells = [];
+			row.forEach((cell) => {
+				if (cell.attrs.alignment != null) aligned = true;
+				const builder = new InlineBuilder();
+				cell.forEach((child, _offset, index) => {
+					if (index) builder.break();
+					this.inline(child, builder);
+				});
+				cells.push({ content: builder.finish() });
+			});
+			rows.push(cells);
+		});
+		if (aligned) this.lost.add("table-alignment");
+		return {
+			type: "table",
+			rows
+		};
+	}
+	/** A table inside a list item, as lines of tab-separated cells. */
+	tableLines(node) {
+		return this.table(node).rows.map((row) => {
+			const builder = new InlineBuilder();
+			row.forEach((cell, index) => {
+				if (index) builder.text("	", []);
+				for (const inline of cell.content) if (inline.type === "break") builder.break();
+				else builder.text(inline.text, inline.marks ?? []);
+			});
+			return {
+				type: "paragraph",
+				content: builder.finish()
+			};
+		});
+	}
+	list(node, depth) {
+		const ordered = node.type.name === "ordered_list";
+		let start = Number(node.attrs.order ?? 1);
+		if (ordered && !(Number.isSafeInteger(start) && start >= 1)) {
+			this.lost.add("list-start");
+			start = 1;
+		} else if (ordered && start > 2147483647) {
+			this.lost.add("list-start");
+			start = maximumListStart;
+		}
+		const items = [];
+		node.forEach((item) => {
+			if (item.attrs.checked != null) this.lost.add("task");
+			const builder = new InlineBuilder();
+			let lines = 0;
+			const nested = [];
+			let flattened = false;
+			const line = (content) => {
+				if (lines++) builder.break();
+				for (const inline of content) if (inline.type === "break") builder.break();
+				else builder.text(inline.text, inline.marks ?? []);
+			};
+			const flatten = (block) => {
+				if (block.type === "paragraph") line(block.content);
+				else if (block.type === "list") for (const listItem of block.items) listItem.blocks.forEach(flatten);
+				else for (const row of block.rows) for (const cell of row) line(cell.content);
+			};
+			item.forEach((child, _offset, index) => {
+				if (isList(child)) {
+					if (depth < 9) nested.push(...this.blocks(child, depth));
+					else {
+						this.lost.add("list-depth");
+						this.blocks(child, depth).forEach(flatten);
+					}
+					return;
+				}
+				for (const block of this.blocks(child, depth)) {
+					if (index === 0 && !lines && block.type === "paragraph") {
+						line(block.content);
+						continue;
+					}
+					flattened = true;
+					flatten(block);
+				}
+			});
+			if (flattened) this.lost.add("list-item-blocks");
+			items.push({ blocks: [{
+				type: "paragraph",
+				content: builder.finish()
+			}, ...nested] });
+		});
+		return ordered && start !== 1 ? {
+			type: "list",
+			ordered,
+			start,
+			items
+		} : {
+			type: "list",
+			ordered,
+			items
+		};
+	}
+};
+/** A formatted Markdown document as rich text, with what RTF could not hold. */
+function markdownToRichText(doc) {
+	const reader = new MarkdownReader();
+	const blocks = [];
+	doc.forEach((node) => blocks.push(...reader.blocks(node, 0)));
+	if (blocks.length === 1 && blocks[0].type === "paragraph" && !blocks[0].content.length) blocks.length = 0;
+	return {
+		document: {
+			version: 1,
+			blocks
+		},
+		lost: reader.lost.list()
+	};
+}
+/** A rich text document as Markdown, with what Markdown could not hold: alignment. Underline,
+*  superscript and subscript are written as `<u>`, `<sup>` and `<sub>`. */
+function richTextToMarkdown(ctx, document) {
+	const lost = new Losses();
+	const { schema } = ctx.get(editorViewCtx).state;
+	const ready = markdownReady(document, lost);
+	const text = serialize(ctx, htmlBreaksInCells(richTextToProse(schema, ready)));
+	let reread;
+	try {
+		reread = markdownToRichText(ctx.get(parserCtx)(text)).document;
+	} catch {
+		reread = void 0;
+	}
+	if (!reread || !sameDocument(reread, ready)) throw new InkKitError("preservation", "The document could not be written as Markdown that reads back the same");
+	return {
+		text,
+		lost: lost.list()
+	};
+}
+/** Marks that show on a space: moving a space out of one changes what the reader sees. */
+var visibleOnSpace = /* @__PURE__ */ new Set([
+	"underline",
+	"strikethrough",
+	"link"
+]);
+/**
+* `content` as Markdown can write it. An emphasis, strikethrough, link or HTML mark can't start or
+* end with a space, so leading and trailing spaces move outside the run, and a run of only spaces
+* loses its marks. A code span keeps its spaces. Counts `mark-spaces` where a visible mark moved.
+*/
+function markdownInlines(content, lost) {
+	const builder = new InlineBuilder();
+	for (const inline of content) {
+		if (inline.type === "break") {
+			builder.break();
+			continue;
+		}
+		let marks = inline.marks ?? [];
+		if (/^ +$/.test(inline.text) && marks.some((mark) => mark.type === "code")) {
+			const kept = marks.filter((mark) => mark.type === "code");
+			if (marks.some((mark) => mark.type !== "code" && visibleOnSpace.has(mark.type))) lost.add("mark-spaces");
+			marks = kept;
+		}
+		const [, lead, core, trail] = /^( *)([^]*?)( *)$/.exec(inline.text);
+		if (!marks.length || marks.some((mark) => mark.type === "code") || !lead && !trail) {
+			builder.text(inline.text, marks);
+			continue;
+		}
+		if (marks.some((mark) => visibleOnSpace.has(mark.type))) lost.add("mark-spaces");
+		builder.text(lead, []);
+		builder.text(core, marks);
+		builder.text(trail, []);
+	}
+	return builder.finish();
+}
+/**
+* `document` as Markdown can hold it, with what that drops counted in `lost`: alignment, a mark's
+* edge spaces, a paragraph's only line break, which Markdown reads back as an empty paragraph, and
+* empty paragraphs at the end, which Markdown doesn't keep.
+*/
+function markdownReady(document, lost) {
+	const block = (item) => {
+		if (item.type === "paragraph") {
+			if (item.align) lost.add("alignment");
+			let content = markdownInlines(item.content, lost);
+			if (content.length === 1 && content[0].type === "break") {
+				lost.add("empty-line");
+				content = [];
+			}
+			return {
+				type: "paragraph",
+				content
+			};
+		}
+		if (item.type === "list") return {
+			...item,
+			items: item.items.map((listItem) => ({ blocks: listItem.blocks.map(block) }))
+		};
+		return {
+			type: "table",
+			rows: item.rows.map((row) => row.map((cell) => ({ content: markdownInlines(cell.content, lost) })))
+		};
+	};
+	const blocks = document.blocks.map(block);
+	while (blocks.length > 1 && blocks.at(-1).type === "paragraph" && !blocks.at(-1).content.length) {
+		blocks.pop();
+		lost.add("empty-line");
+	}
+	return {
+		version: 1,
+		blocks
+	};
+}
+/** Whether two documents are the same, counting one empty paragraph as an empty document. */
+function sameDocument(a, b) {
+	const text = (document) => JSON.stringify(document.blocks.length === 1 && document.blocks[0].type === "paragraph" && !document.blocks[0].content.length ? [] : document.blocks);
+	return text(a) === text(b);
+}
+/** Markdown for content copied from a rich text document. Unlike a conversion it reports no
+*  losses and isn't read back: a copy may lose alignment. */
+function richContentMarkdown(ctx, content) {
+	const { schema } = ctx.get(editorViewCtx).state;
+	const empty = schema.topNodeType.createAndFill();
+	let doc = new Transform(empty).replace(0, empty.content.size, content).doc;
+	try {
+		doc = richTextToProse(schema, markdownReady(proseToRichText(doc, false), new Losses()));
+	} catch {}
+	return serialize(ctx, htmlBreaksInCells(doc));
+}
+/** `node` with each line break in a table cell written as `<br />`, since a cell is one line of
+*  Markdown. */
+function htmlBreaksInCells(node, inCell = false) {
+	if (node.type.name === "hardbreak") return inCell ? node.type.create({
+		...node.attrs,
+		isHTML: true
+	}, null, node.marks) : node;
+	if (node.isLeaf) return node;
+	const role = node.type.spec.tableRole;
+	const cell = inCell || role === "cell" || role === "header_cell";
+	const children = [];
+	node.forEach((child) => children.push(htmlBreaksInCells(child, cell)));
+	return node.copy(Fragment.fromArray(children));
+}
+//#endregion
 //#region src/paste-html.ts
 var rich = /* @__PURE__ */ new Set([
 	"P",
@@ -56772,6 +58518,14 @@ var PasteController = class {
 				transformPasted: (slice, view, plain) => this.claimed || plain || view.dragging ? slice : importableSlice(this.options.ctx(), slice),
 				handlePaste: (view, event) => {
 					this.claimed = false;
+					if (this.options.richText?.() && event.clipboardData && view.editable) {
+						const data = event.clipboardData;
+						this.run({
+							text: data.getData("text/plain"),
+							html: data.getData("text/html") || void 0
+						}).catch((error) => options.onError?.(error));
+						return true;
+					}
 					const claim = claimsPaste(view, event);
 					if (claim === false) return false;
 					const data = event.clipboardData;
@@ -56876,6 +58630,17 @@ var PasteController = class {
 			},
 			controller: new AbortController()
 		};
+		const rich = this.options.richText?.();
+		if (rich) {
+			const anchor = operation;
+			const state = view.state;
+			const slice = input.plainText ? rich.paste({ text: input.text }, state, this.options.linkSchemes ?? /* @__PURE__ */ new Set()) : rich.paste(input, state, this.options.linkSchemes ?? /* @__PURE__ */ new Set());
+			const tr = state.tr.replaceRange(anchor.from, anchor.to, slice);
+			const end = tr.doc.resolve(tr.mapping.map(anchor.to, 1));
+			this.dispatch(view, tr.setSelection(Selection.near(end, -1)).scrollIntoView());
+			if (slice.size && view.state.doc === state.doc) throw new InkKitError("preservation", "The paste was not applied because the RTF document cannot hold it there");
+			return;
+		}
 		const inCode = () => view.state.doc.resolve(this.anchor(operation).from).parent.type.spec.code;
 		this.active = operation;
 		this.options.onPendingChanged?.();
@@ -57502,6 +59267,10 @@ var formatCommands = [
 	"orderedList",
 	"taskList",
 	"toggleTask",
+	"alignLeft",
+	"alignCenter",
+	"alignRight",
+	"alignJustify",
 	"link"
 ];
 /** Checks a format call's options against its command. */
@@ -57685,16 +59454,49 @@ function hostEvents(value) {
 		};
 	} });
 }
-/** Checks a load's input. A format the host did not offer is refused like an unknown one. */
+/** Checks a load's input. A format the host did not offer is refused like an unknown one, and an
+*  RTF document is checked and put in canonical form. */
 function documentInput(value, offered) {
 	const input = expectRecord(value, "input");
+	const documentId = expectString(input.documentId, "input.documentId");
+	const generation = expectGeneration(input.generation, "input.generation");
+	const format = expectOneOf(input.format, offered, "input.format");
+	if (format === "rtf") {
+		if (!isOmitted(input.text)) throw invalidArgument("input.text must be left out for an RTF document");
+		return {
+			documentId,
+			generation,
+			format,
+			text: richTextText(readRichTextDocument(input.document, "input.document"))
+		};
+	}
+	if (!isOmitted(input.document)) throw invalidArgument(`input.document must be left out for ${format}`);
 	return {
-		documentId: expectString(input.documentId, "input.documentId"),
-		generation: expectGeneration(input.generation, "input.generation"),
-		format: expectOneOf(input.format, offered, "input.format"),
+		documentId,
+		generation,
+		format,
 		text: expectString(input.text, "input.text")
 	};
 }
+/** The public snapshot of the editor's text for a document. */
+function publicSnapshot(saved) {
+	const { documentId, generation, revision, format, text, dirty } = saved;
+	return format === "rtf" ? {
+		documentId,
+		generation,
+		revision,
+		format,
+		document: richTextFromText(text),
+		dirty
+	} : {
+		documentId,
+		generation,
+		revision,
+		format,
+		text,
+		dirty
+	};
+}
 /** A range's shape. Whether its offsets fit the snapshot is `invalid-range`, checked later. */
 function textRange(value, name) {
 	const range = expectRecord(value, name);
@@ -57818,6 +59620,7 @@ var InkKitEditor = class InkKitEditor {
 	output = new EditorOutput({
 		ctx: () => this.editor.ctx,
 		exportDocument: (text) => this.document.exportDocument(text),
+		richTextMarkdown: (content) => richContentMarkdown(this.editor.ctx, content),
 		diagrams: () => this.diagrams,
 		root: () => this.root,
 		handler: () => this.document.handler,
@@ -57837,7 +59640,7 @@ var InkKitEditor = class InkKitEditor {
 		element: () => this.source.element,
 		replaceSelection: (text) => this.source.replaceLiteralSelection(text),
 		writable: () => this.writable,
-		snapshot: () => this.snapshot(),
+		snapshot: () => this.savedText(),
 		prepareSelection: () => this.clipboardSnapshot("selection"),
 		capture: () => this.session.capture(),
 		assertCut: (captured) => this.assertCut(captured),
@@ -57917,7 +59720,7 @@ var InkKitEditor = class InkKitEditor {
 			};
 		} });
 		this.linkSchemes = new Set(options.linkSchemes);
-		this.offered = options.formats ?? documentFormats;
+		this.offered = options.formats ?? defaultFormats;
 		this.formatList = Object.freeze(this.offered.map((format) => Object.freeze({
 			format,
 			promise: formatHandlers[format].promise
@@ -57934,6 +59737,9 @@ var InkKitEditor = class InkKitEditor {
 	}
 	/** What `changed` reports for the document's new text. */
 	changeSnapshot(text) {
+		return publicSnapshot(this.saved(text));
+	}
+	saved(text) {
 		return {
 			...this.session.version(),
 			format: this.document.format,
@@ -57941,6 +59747,11 @@ var InkKitEditor = class InkKitEditor {
 			dirty: text !== this.document.original
 		};
 	}
+	/** The current text, as `snapshot` checks and reads it. */
+	savedText(expectedGeneration) {
+		this.assertCurrent(expectedGeneration);
+		return this.saved(this.document.currentText());
+	}
 	/** Throws unless the document `captured` describes is still current, alive, not composing and
 	*  has no import pending. */
 	assertCaptured(captured, aborted = false) {
@@ -58146,7 +59957,7 @@ var InkKitEditor = class InkKitEditor {
 		this.publishCommandState();
 	}
 	applyInputPolicy() {
-		applyInputPolicy(this.editor.ctx.get(editorViewCtx), this.source.element, this.inputPreferences, this.options.labels?.formattedEditor ?? defaultLabels.formattedEditor, {
+		applyInputPolicy(this.editor.ctx.get(editorViewCtx), this.source.element, this.inputPreferences, this.options.labels?.[this.document.handler.formattedLabel] ?? defaultLabels[this.document.handler.formattedLabel], {
 			writable: () => this.writable,
 			literal: () => this.literalSurface
 		});
@@ -58163,8 +59974,16 @@ var InkKitEditor = class InkKitEditor {
 		const { state } = this.editor.ctx.get(editorViewCtx);
 		const mutable = this.writable && !this.composing && !this.pasteController.pending;
 		const formatted = mutable && !this.literalSurface;
-		const format = formatAvailability(this.editor, state, formatted);
+		const rich = this.document.handler.richText != null;
+		const format = formatAvailability(this.editor, state, formatted, this.document.handler);
 		const tables = formatted ? tableAvailability(this.editor.ctx) : Object.fromEntries(tableCommands.map((name) => [name, false]));
+		if (rich) tables.alignLeft = tables.alignCenter = tables.alignRight = false;
+		const caret = this.literalSurface ? {
+			marks: [],
+			block: { type: "paragraph" },
+			quoted: false
+		} : caretState(state);
+		if (rich) caret.align = caretAlignment(state);
 		return {
 			...this.session.version(),
 			format: this.document.format,
@@ -58172,11 +59991,7 @@ var InkKitEditor = class InkKitEditor {
 			editable: this.writable,
 			composing: this.composing,
 			pending: this.pasteController.pending,
-			caret: this.literalSurface ? {
-				marks: [],
-				block: { type: "paragraph" },
-				quoted: false
-			} : caretState(state),
+			caret,
 			table: this.literalSurface ? void 0 : tableContext(state),
 			commands: {
 				undo: mutable && this.history.canUndo(state),
@@ -58184,12 +59999,12 @@ var InkKitEditor = class InkKitEditor {
 				insertText: mutable,
 				paste: mutable,
 				replace: mutable,
-				replaceSource: mutable,
-				insertImages: formatted && this.canInsertImages,
-				appendImages: formatted && this.canInsertImages,
+				replaceSource: mutable && !rich,
+				insertImages: formatted && !rich && this.canInsertImages,
+				appendImages: formatted && !rich && this.canInsertImages,
 				insertPaths: mutable,
-				insertFootnote: formatted,
-				editReferenceDefinition: formatted && referenceDefinitions(state.doc).size > 0,
+				insertFootnote: formatted && !rich,
+				editReferenceDefinition: formatted && !rich && referenceDefinitions(state.doc).size > 0,
 				format,
 				table: tables,
 				moveBlockUp: formatted && canMoveBlock(state, "up"),
@@ -58197,9 +60012,10 @@ var InkKitEditor = class InkKitEditor {
 			}
 		};
 	}
-	/** An image adapter shows and exports an inserted reference, and so does a file adapter. */
+	/** An image adapter shows and exports an inserted reference, and so does a file adapter. An RTF
+	*  document holds no images. */
 	get canInsertImages() {
-		return !!this.options.images || !!this.options.files;
+		return (!!this.options.images || !!this.options.files) && !this.document.handler.richText;
 	}
 	historyInputPlugin = createHistoryInputPlugin({
 		writable: () => this.writable,
@@ -58238,7 +60054,7 @@ var InkKitEditor = class InkKitEditor {
 				this.history.settleSource();
 				this.history.modeChanged();
 			},
-			text: () => this.snapshot().text,
+			text: () => this.savedText().text,
 			changed: () => {
 				this.mode = mode;
 				this.session.modeChanged();
@@ -58270,6 +60086,7 @@ var InkKitEditor = class InkKitEditor {
 		this.assertAlive();
 		expectString(text, "text");
 		this.assertMutation(expectedGeneration);
+		if (this.document.handler.richText) throw invalidArgument("An RTF document has no source to replace");
 		const changed = this.history.applySource(text, true);
 		if (changed) this.clipboard.clear();
 		return changed;
@@ -58284,22 +60101,52 @@ var InkKitEditor = class InkKitEditor {
 		this.assertMutation(expectedGeneration);
 		return this.history.redo();
 	}
-	/** The complete current text, which is what a host saves. It throws rather than return partial
-	*  text. */
+	/** The complete current document, which is what a host saves. It throws rather than return a
+	*  partial document. */
 	snapshot(expectedGeneration) {
-		this.assertCurrent(expectedGeneration);
-		const text = this.document.currentText();
-		return {
-			...this.session.version(),
-			format: this.document.format,
-			text,
-			dirty: text !== this.document.original
+		return publicSnapshot(this.savedText(expectedGeneration));
+	}
+	/**
+	* The loaded document converted to `format`, which must be offered, with what the conversion
+	* lost. It changes nothing: load the result as a new generation. Markdown converts to RTF and
+	* RTF to Markdown; the same format returns a copy. Throws `invalid-argument` for any other pair.
+	*/
+	convertDocument(format, expectedGeneration) {
+		this.assertAlive();
+		expectOneOf(format, this.offered, "format");
+		const saved = this.savedText(expectedGeneration);
+		const from = saved.format;
+		if (from === format) return from === "rtf" ? {
+			format: "rtf",
+			document: richTextFromText(saved.text),
+			lost: Object.freeze([])
+		} : {
+			format: from,
+			text: saved.text,
+			lost: Object.freeze([])
 		};
+		if (from === "md" && format === "rtf") {
+			const { document, lost } = markdownToRichText(this.document.exportDocument(saved.text));
+			return {
+				format,
+				document,
+				lost
+			};
+		}
+		if (from === "rtf" && format === "md") {
+			const { text, lost } = richTextToMarkdown(this.editor.ctx, richTextFromText(saved.text));
+			return {
+				format,
+				text,
+				lost
+			};
+		}
+		throw invalidArgument(`Inkkit does not convert ${from} to ${format}; ${from === "txt" || format === "txt" ? "the host converts plain text" : "convert through another format"}`);
 	}
 	/** The whole document as standalone HTML for printing. Rejects rather than return partial
 	*  output. */
 	async printableSnapshot(expectedGeneration) {
-		const snapshot = this.snapshot(expectedGeneration);
+		const snapshot = this.savedText(expectedGeneration);
 		const captured = this.session.capture();
 		return this.output.printable(snapshot, captured);
 	}
@@ -58308,7 +60155,7 @@ var InkKitEditor = class InkKitEditor {
 	async clipboardSnapshot(scope, expectedGeneration) {
 		this.assertAlive();
 		const all = (isOmitted(scope) ? "document" : expectOneOf(scope, clipboardScopes, "scope")) === "document";
-		const snapshot = this.snapshot(expectedGeneration);
+		const snapshot = this.savedText(expectedGeneration);
 		const captured = this.session.capture();
 		return this.output.clipboard(snapshot, captured, all);
 	}
@@ -58342,12 +60189,25 @@ var InkKitEditor = class InkKitEditor {
 		expectString(text, "text");
 		this.assertMutation(expectedGeneration);
 		const before = this.session.capture();
+		const doc = this.editor.ctx.get(editorViewCtx).state.doc;
 		this.insertPlainText(text);
+		if (text && this.refusedRichEdit(doc)) throw new InkKitError("preservation", "The text was not pasted because the RTF document cannot hold it there");
 		return !before.isCurrent();
 	}
+	/** Whether an RTF edit that should have changed `before` was refused. */
+	refusedRichEdit(before) {
+		return this.document.handler.richText != null && !this.literalSurface && this.editor.ctx.get(editorViewCtx).state.doc === before;
+	}
 	insertPlainText(text) {
 		if (this.literalSurface) this.source.replaceLiteralSelection(text, true, this.document.handler.keepsInsertedLineEndings);
-		else insertPlainText(this.editor.ctx.get(editorViewCtx), text);
+		else if (this.document.handler.richText) {
+			const view = this.editor.ctx.get(editorViewCtx);
+			const slice = this.document.handler.richText.paste({ text }, view.state, this.linkSchemes);
+			const lines = /[\r\n\u000c\u0085\u2028\u2029\u000b]/.test(text);
+			const tr = view.state.tr.replaceSelection(slice).scrollIntoView();
+			view.dispatch(lines ? closeHistory(tr) : tr);
+			if (lines) view.dispatch(closeHistory(view.state.tr).setMeta("addToHistory", false));
+		} else insertPlainText(this.editor.ctx.get(editorViewCtx), text);
 	}
 	/** Runs a table command and returns whether it applied. False in source and TXT modes, outside a
 	*  table for commands that need one, and at a boundary a move can't cross. */
@@ -58421,15 +60281,13 @@ var InkKitEditor = class InkKitEditor {
 				}
 			} catch (error) {
 				view.updateState(view.state);
-				this.refuse(new InkKitError("preservation", `The edit was not applied because its Markdown could not be preserved: ${error instanceof Error ? error.message : String(error)}`, { cause: error }));
+				this.refuse(new InkKitError("preservation", this.document.handler.richText ? `The edit was not applied because the document could not be saved as RTF: ${error instanceof Error ? error.message : String(error)}` : `The edit was not applied because its Markdown could not be preserved: ${error instanceof Error ? error.message : String(error)}`, { cause: error }));
 				return;
 			}
 		}
 		this.history.didApply(view.state, next);
 		view.updateState(next);
 	}
-	/** Builds the editor in `root`. It has no document until `loadDocument`. Rejects with
-	*  `invalid-argument` for a bad root, handler or option. */
 	static async mount(root, events, options) {
 		if (!(root instanceof HTMLElement)) throw invalidArgument("root must be an HTML element");
 		events = hostEvents(events);
@@ -58448,7 +60306,9 @@ var InkKitEditor = class InkKitEditor {
 			commit: (apply) => instance.facadeCall(apply),
 			literalText: () => instance.literalSurface,
 			editable: () => instance.writable && !instance.literalSurface,
-			onPendingChanged: () => instance.publishCommandState()
+			onPendingChanged: () => instance.publishCommandState(),
+			richText: () => instance.document.handler.richText,
+			linkSchemes: instance.linkSchemes
 		});
 		instance.suggestions = createEditorSuggestions({
 			root,
@@ -58476,6 +60336,10 @@ var InkKitEditor = class InkKitEditor {
 				historyInput: instance.historyInputPlugin,
 				policy: instance.policyPlugin
 			},
+			format: {
+				markdownInput: () => instance.document.handler.markdownInput,
+				richText: () => instance.document.handler.richText
+			},
 			authoredSources: (doc, positions) => instance.document.authoredSources(doc, positions),
 			smartPunctuation: () => instance.inputPreferences.smartPunctuation === true,
 			linkSchemes: instance.linkSchemes,
@@ -58537,9 +60401,9 @@ var InkKitEditor = class InkKitEditor {
 	}
 	/** Replaces the document. The generation must be greater than the loaded one. A failed load
 	*  changes nothing. */
-	loadDocument(input) {
+	loadDocument(document) {
 		this.assertAlive();
-		input = documentInput(input, this.offered);
+		const input = documentInput(document, this.offered);
 		this.session.checkLoad(input.generation, "input.generation");
 		const handler = formatHandlers[input.format];
 		const markdown = handler.literalOnly ? "" : input.text;
@@ -58547,7 +60411,7 @@ var InkKitEditor = class InkKitEditor {
 		try {
 			source = handler.load(this.editor.ctx, markdown);
 		} catch (error) {
-			throw new InkKitError("preservation", "The document was not loaded because its Markdown could not be shown without losing part of it", { cause: error });
+			throw coded(error, "preservation", "The document was not loaded because its Markdown could not be shown without losing part of it");
 		}
 		const container = this.geometry.container;
 		const top = container.scrollTop, left = container.scrollLeft;
@@ -58564,7 +60428,7 @@ var InkKitEditor = class InkKitEditor {
 		this.source.reset();
 		this.search.reset();
 		this.document.handler = handler;
-		this.source.setSourceValue(input.text);
+		this.source.setSourceValue(handler.richText ? "" : input.text);
 		this.source.element.setSelectionRange(this.source.element.value.length, this.source.element.value.length);
 		this.load(markdown, source);
 		this.document.original = input.text;
@@ -58583,9 +60447,9 @@ var InkKitEditor = class InkKitEditor {
 	/** Replaces the document with a newer version of it, keeping the selection, focus, scroll
 	*  position and Markdown editing mode. With `expectedGeneration`, the loaded document must be
 	*  that generation. */
-	reloadDocument(input, expectedGeneration) {
+	reloadDocument(document, expectedGeneration) {
 		this.assertAlive();
-		input = documentInput(input, this.offered);
+		const input = documentInput(document, this.offered);
 		if (!isOmitted(expectedGeneration)) this.assertReady(expectedGeneration);
 		this.session.checkLoad(input.generation, "input.generation");
 		const view = this.editor.ctx.get(editorViewCtx);
@@ -58595,7 +60459,7 @@ var InkKitEditor = class InkKitEditor {
 		const saved = captureReloadSurface(view, this.source.element, this.geometry.container, wasLiteral);
 		this.reportingSuppressed = true;
 		try {
-			this.loadDocument(input);
+			this.loadDocument(document);
 			if (previous.sourceMode && this.document.handler.sourceMode && previousMode === "source") this.setEditingMode("source", input.generation);
 			restoreReloadSurface(view, this.source.element, () => this.literalSurface, saved);
 		} finally {
@@ -58730,7 +60594,8 @@ var InkKitEditor = class InkKitEditor {
 		expectString(search, "search");
 		expectString(replacement, "replacement");
 		this.assertMutation(expectedGeneration);
-		return this.search.replace(search, replacement, false) > 0;
+		const doc = this.editor.ctx.get(editorViewCtx).state.doc;
+		return this.search.replace(search, replacement, false) > 0 && (replacement === search || !this.refusedRichEdit(doc));
 	}
 	/** Replaces every non-overlapping match once and returns how many. */
 	replaceAll(search, replacement, expectedGeneration) {
@@ -58738,7 +60603,9 @@ var InkKitEditor = class InkKitEditor {
 		expectString(search, "search");
 		expectString(replacement, "replacement");
 		this.assertMutation(expectedGeneration);
-		return this.search.replace(search, replacement, true);
+		const doc = this.editor.ctx.get(editorViewCtx).state.doc;
+		const count = this.search.replace(search, replacement, true);
+		return count && replacement !== search && this.refusedRichEdit(doc) ? 0 : count;
 	}
 	outlineContext() {
 		const { documentId, generation, revision, key } = this.session.capture();
@@ -58781,11 +60648,10 @@ var InkKitEditor = class InkKitEditor {
 			this.source.replaceLiteralSelection(text, false);
 			return true;
 		}
-		if (/[\r\n]/.test(text)) {
-			this.pasteAsPlainText(text);
-			return true;
-		}
-		return insertNativeText(this.editor.ctx.get(editorViewCtx), text);
+		const doc = this.editor.ctx.get(editorViewCtx).state.doc;
+		if (/[\r\n]/.test(text)) this.insertPlainText(text);
+		else if (!insertNativeText(this.editor.ctx.get(editorViewCtx), text)) return false;
+		return !(text && this.refusedRichEdit(doc));
 	}
 	/**
 	* A key the host's native input received, run through InkKit's key handling. Returns whether
@@ -58964,12 +60830,14 @@ var InkKitEditor = class InkKitEditor {
 	format(command, options, expectedGeneration) {
 		this.assertAlive();
 		const checked = formatOptions(command, options);
+		if (checked?.destination !== void 0 && this.document.handler.richText) checked.destination = checked.destination.trim();
 		if (checked?.destination !== void 0) this.checkDestination(checked.destination, "options.destination");
 		this.assertMutation(expectedGeneration);
 		if (this.literalSurface) return false;
 		const view = this.editor.ctx.get(editorViewCtx);
 		const before = view.state;
-		applyFormat(this.editor, command, checked, (destination) => this.link(destination));
+		if ((this.document.handler.richText || command.startsWith("align")) && !this.commandState().commands.format[command]) return false;
+		applyFormat(this.editor, command, checked, (destination) => this.link(destination), this.document.handler.richText != null);
 		this.focus();
 		const after = view.state;
 		const marks = (state) => state.storedMarks ?? state.selection.$from.marks();
@@ -58977,11 +60845,14 @@ var InkKitEditor = class InkKitEditor {
 	}
 	/**
 	* Refuses a link destination that is empty, that opens anything but a web, mail or phone address
-	* or a scheme the host listed, or that the Markdown writer cannot save so that it reads back the
-	* same.
+	* or a scheme the host listed, or, in Markdown, that the writer cannot save so that it reads back
+	* the same. In RTF, it also refuses what the rich text link rule refuses.
 	*/
 	checkDestination(destination, name) {
-		checkDestination(this.editor.ctx, destination, name, this.linkSchemes);
+		const rich = this.document.handler.richText != null;
+		checkDestination(this.editor.ctx, destination, name, this.linkSchemes, !rich);
+		const problem = rich ? linkProblem(destination) : void 0;
+		if (problem) throw invalidArgument(`${name}: ${problem}`);
 	}
 	/**
 	* With a destination, sets the link: on the whole link that holds the caret or the selection,
@@ -59000,7 +60871,7 @@ var InkKitEditor = class InkKitEditor {
 		this.checkDestination(expectString(destination, "destination"), "destination");
 		optionalString(title, "title");
 		this.assertMutation(expectedGeneration);
-		if (this.literalSurface) return false;
+		if (this.literalSurface || this.document.handler.richText) return false;
 		return editReferenceDefinition(this.editor.ctx.get(editorViewCtx), label, destination, title);
 	}
 	/** Inserts a footnote reference, and a definition when the label has none, and returns whether
@@ -59010,8 +60881,8 @@ var InkKitEditor = class InkKitEditor {
 		const given = optionalString(label, "label");
 		if (given !== void 0 && !footnoteLabel(given)) throw invalidArgument("A footnote label must be 1 to 999 characters without whitespace, brackets or backslashes");
 		this.assertMutation(expectedGeneration);
-		if (this.literalSurface) return false;
-		insertFootnote(this.editor.ctx.get(editorViewCtx), label, () => this.snapshot().text);
+		if (this.literalSurface || this.document.handler.richText) return false;
+		insertFootnote(this.editor.ctx.get(editorViewCtx), label, () => this.savedText().text);
 		this.focus();
 		return true;
 	}
@@ -59031,6 +60902,7 @@ var InkKitEditor = class InkKitEditor {
 			"loadDocument",
 			"reloadDocument",
 			"snapshot",
+			"convertDocument",
 			"printableSnapshot",
 			"clipboardSnapshot",
 			"paste",
@@ -59094,13 +60966,13 @@ var InkKitEditor = class InkKitEditor {
 			});
 		}
 		const mount = InkKitEditor.mount;
-		InkKitEditor.mount = async (...args) => {
+		InkKitEditor.mount = (async (...args) => {
 			try {
 				return await mount(...args);
 			} catch (error) {
 				throw coded(error);
 			}
-		};
+		});
 	}
 };
 //#endregion