@aicayzer/inkkit 0.1.1 → 0.1.2

package/dist/chunks/{core-CYp5ONPO.js → core-Dyg5rJLT.js}

@@ -31143,6 +31143,11 @@ function mermaidPreview(onError) {
 	}));
 }
 //#endregion
+//#region src/hard-break.ts
+function htmlBreakAt(position) {
+	return position.parent.type.name === "heading" && position.parent.attrs.form !== "setext" || position.depth > 1 && /^table_(cell|header)$/.test(position.node(-1).type.name);
+}
+//#endregion
 //#region node_modules/.pnpm/rope-sequence@1.3.4/node_modules/rope-sequence/dist/index.js
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence() {};
@@ -39501,6 +39506,194 @@ var cursor = [
 	})
 ].flat();
 //#endregion
+//#region src/smart-punctuation.ts
+/**
+* Smart punctuation: the quote or dash being typed becomes a curly quote or a dash.
+*
+* - `"` and `'` open after the start of a block, a line break, whitespace, an opening bracket, a
+*   dash or another opening quote, and close everywhere else. A `'` between letters is an
+*   apostrophe, which is the closing form.
+* - `--` gives an en dash and `---` an em dash: the third hyphen turns the en dash that the second
+*   one made into an em dash. Only a hyphen that text input has just inserted counts as the first
+*   of the two, so a hyphen already in the note, or typed before the caret moved, stays one.
+* - A quote that a dead key made arrives as a composition. When the composition commits exactly
+*   that quote at the caret, it follows the same rules.
+*
+* These are input rules, so only the character being typed changes, Backspace and Undo straight
+* after restore what was typed, and nothing in a note is rewritten. The editor answers
+* `smartPunctuationCtx` with the current option, so turning it on or off needs no new editor.
+*/
+var smartPunctuationCtx = $ctx(() => false, "inkkitSmartPunctuation");
+/** Set on the transaction of each rule that this file makes. */
+var smartRule = "inkkitSmartPunctuation";
+var enDash = "–";
+var emDash = "—";
+/** What may come before a quote for it to open. */
+var opensAfter = /[\s([{<\u2013\u2014\u2018\u201C]/u;
+/**
+* Markdown that a person is typing out in a line of text, not words: a code span, a link
+* destination, a web address, a wiki link or footnote label, an HTML tag or comment and a
+* reference definition. Smart punctuation leaves a line alone while one is open, because the
+* curly character would change what the Markdown means.
+*/
+var typingSyntax = [
+	(before) => (before.match(/`+/g)?.length ?? 0) % 2 === 1,
+	(before) => /\]\([^)]*$/.test(before),
+	(before) => /\[\[[^\]]*$/.test(before),
+	(before) => /\[\^[^\]]*$/.test(before),
+	(before) => /(?:^|[^\w])(?:[a-z][a-z0-9+.-]*:\/\/|www\.|mailto:)\S*$/i.test(before),
+	(before) => /(?:^|[^\w])<[A-Za-z!/?][^>]*$/.test(before),
+	(before) => /^\s*\[[^\]]+\]:/.test(before)
+];
+/**
+* The text of the block before `pos`, with each code span and each non-text node as one
+* placeholder, so that a backtick or `<` inside code is not syntax being typed.
+*/
+function textBefore(state, pos) {
+	const $pos = state.doc.resolve(pos);
+	let text = "";
+	$pos.parent.forEach((child, offset) => {
+		if (offset >= $pos.parentOffset) return;
+		text += child.isText && !child.marks.some((mark) => mark.type.spec.code) ? child.text.slice(0, $pos.parentOffset - offset) : "";
+	});
+	return text;
+}
+var input = new PluginKey("inkkitSmartPunctuationInput");
+/** The text a transaction inserted, when it is one step that inserts text at `at` and nothing else. */
+function insertedAt(tr, at) {
+	const [step] = tr.steps;
+	if (tr.steps.length !== 1 || !(step instanceof ReplaceStep)) return void 0;
+	if (step.from !== at || step.slice.openStart || step.slice.openEnd) return void 0;
+	return step.slice.content.textBetween(0, step.slice.content.size);
+}
+var inputTracking = $prose(() => new Plugin({
+	key: input,
+	state: {
+		init: () => ({
+			pending: null,
+			hyphen: null,
+			composition: null,
+			composedQuote: null
+		}),
+		apply(tr, value) {
+			const { pending, composition } = value;
+			value.pending = value.hyphen = value.composedQuote = null;
+			if (tr.getMeta(hyphenReceived)) value.hyphen = tr.selection.from;
+			if (!tr.docChanged) return value;
+			if (pending !== null && insertedAt(tr, pending) === "-") value.hyphen = pending + 1;
+			if (composition) {
+				value.composition = null;
+				const text = insertedAt(tr, composition.pos);
+				if (tr.getMeta("composition") !== void 0 && (text === "\"" || text === "'") && tr.doc.content.size === composition.size + 1) value.composedQuote = composition.pos + 1;
+			}
+			return value;
+		}
+	},
+	props: {
+		handleTextInput(view, from, _to, text) {
+			input.getState(view.state).pending = text === "-" ? from : null;
+			return false;
+		},
+		handleDOMEvents: { compositionstart(view) {
+			const { from, empty } = view.state.selection;
+			const tracked = input.getState(view.state);
+			tracked.composedQuote = null;
+			tracked.composition = empty ? {
+				pos: from,
+				size: view.state.doc.content.size
+			} : null;
+			return false;
+		} }
+	}
+}));
+/** Set on a transaction that inserted text ending in a hyphen, whatever else came with it. */
+var hyphenReceived = "inkkitHyphenReceived";
+/** Marks a transaction that inserted text ending in a hyphen that no rule changed. */
+function insertedHyphen(tr) {
+	return tr.setMeta(hyphenReceived, true);
+}
+/**
+* The state that input rules see for text that arrived in one piece, which holds only what the
+* rules need: it follows the document, with the tracking plugin when the editor has one. When
+* `rest` ends in a hyphen, the last character follows a hyphen that came in the same piece.
+*/
+function chunkState(state, config, rest) {
+	const tracker = input.get(state);
+	const prepared = EditorState.create({
+		...config,
+		plugins: tracker ? [tracker] : []
+	});
+	return tracker && rest.endsWith("-") ? prepared.apply(insertedHyphen(prepared.tr)) : prepared;
+}
+/**
+* Whether a rule may change what `match` found at `pos`: the option is on, the last character of
+* the match is the one being typed, which is not in the document yet, and the text is ordinary,
+* with no Markdown being typed. The input rules plugin also runs every rule when a composition
+* ends, over text that is all in the document; that is not typing, and is left alone.
+*/
+function applies(on, state, match, pos) {
+	if (!on()) return false;
+	const typed = pos + match[0].length - 1 === state.selection.from;
+	const composed = !typed && match[0].length === 1 && input.getState(state)?.composedQuote === state.selection.from && pos === state.selection.from - 1;
+	if (!typed && !composed) return false;
+	const $pos = state.doc.resolve(pos);
+	if ($pos.parent.type.spec.code || !$pos.parent.inlineContent) return false;
+	if ((state.storedMarks ?? $pos.marks()).some((mark) => mark.type.spec.code)) return false;
+	const before = textBefore(state, pos);
+	return !typingSyntax.some((open) => open(before));
+}
+function opensHere(state, pos) {
+	const node = state.doc.resolve(pos).nodeBefore;
+	if (!node) return true;
+	if (node.isText) {
+		const text = node.text ?? "";
+		return opensAfter.test(String.fromCodePoint(text.codePointAt(text.length - 1)));
+	}
+	return node.type.name === "hardbreak";
+}
+/** The input rule that ran at the last change, when nothing has happened since. */
+function lastRule(state) {
+	for (const plugin of state.plugins) if (plugin.spec.isInputRules) {
+		const stored = plugin.getState(state);
+		if (stored) return stored;
+	}
+}
+var quotes$1 = {
+	"\"": ["“", "”"],
+	"'": ["‘", "’"]
+};
+var smartPunctuation = [
+	smartPunctuationCtx,
+	inputTracking,
+	$inputRule((ctx) => 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) => {
+		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) => {
+		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 }))
+].flat();
+/**
+* Undo straight after a smart quote or dash puts back the character that was typed, as Backspace
+* does for any input rule. The replacement joins the typing's history step, so the next Undo
+* removes the typing and not the curly character. Returns whether it applied.
+*/
+var undoSmartPunctuation = (state, dispatch) => {
+	const rule = lastRule(state);
+	if (!rule?.transform.getMeta(smartRule)) return false;
+	return undoInputRule(state, dispatch && ((tr) => dispatch(tr.setMeta("appendedTransaction", rule.transform))));
+};
+//#endregion
 //#region src/text-input.ts
 var isInputRules = (plugin) => plugin.spec.isInputRules === true;
 /**
@@ -39530,12 +39723,12 @@ function insertTextChunk(view, from, to, text, deflt) {
 		return true;
 	}
 	const rules = state.plugins.filter(isInputRules);
-	const prepared = EditorState.create({
+	const prepared = chunkState(state, {
 		schema: state.schema,
 		doc: tr.doc,
 		selection: TextSelection.create(tr.doc, at),
 		storedMarks: state.storedMarks ?? (from === to ? $from.marks() : $from.marksAcross($to))
-	});
+	}, rest);
 	let ruled;
 	const preparedView = Object.create(view, {
 		state: { value: prepared },
@@ -39544,7 +39737,8 @@ function insertTextChunk(view, from, to, text, deflt) {
 		} }
 	});
 	if (!rules.some((rule) => rule.props.handleTextInput?.call(rule, preparedView, at, at, last, () => prepared.tr.insertText(last, at)))) {
-		view.dispatch(deflt().scrollIntoView());
+		const plain = deflt().scrollIntoView();
+		view.dispatch(last === "-" ? insertedHyphen(plain) : plain);
 		return true;
 	}
 	if (ruled) {
@@ -44241,7 +44435,7 @@ function lineBreakHTML(value) {
 	].includes(value.trim());
 }
 function restoreInlineBreaks(node) {
-	if ((node.type === "paragraph" || node.type === "heading") && node.children.length > 1 || node.type === "tableCell") node.children = node.children.map((child) => child.type === "html" && lineBreakHTML(child.value) ? {
+	if (node.type === "paragraph" && node.children.length > 1 || node.type === "heading" || node.type === "tableCell") node.children = node.children.map((child) => child.type === "html" && lineBreakHTML(child.value) ? {
 		type: "break",
 		data: { inkkitHTMLBreak: true },
 		position: child.position
@@ -44499,6 +44693,39 @@ function relabel(text, offsets, marker) {
 	}
 	return text;
 }
+var parentKey = (node) => `${node.type}:${node.position.start.offset}`;
+function reorderedWithin(node, reorder) {
+	if (!reorder) return false;
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	if (start == null || end == null) return false;
+	for (const key of reorder.keys()) {
+		const at = Number(key.slice(key.lastIndexOf(":") + 1));
+		if (at >= start && at < end) return true;
+	}
+	return false;
+}
+/**
+* An item of an ordered list moved from `original`'s place to `place`'s, which
+* takes the number written there, so the numbers keep their order. Lines after
+* the first that are indented to the item's content move with it when the
+* number's width changes.
+*/
+function renumberItem(text, source, original, place) {
+	const own = /^\d{1,9}/.exec(text)?.[0];
+	const number = /^\d{1,9}/.exec(source.slice(place.position.start.offset))?.[0];
+	if (!own || !number || own === number) return text;
+	const start = original.position.start.offset;
+	const content = original.children?.[0]?.position?.start.offset;
+	const lines = text.split(/(?<=\n)/);
+	const prefix = source.slice(source.lastIndexOf("\n", start - 1) + 1, start);
+	const indent = content == null ? -1 : content - start;
+	const first = lines[0];
+	if (indent < 0 || first.slice(0, indent).includes("\n")) return text;
+	const from = prefix + " ".repeat(indent);
+	const to = prefix + " ".repeat(indent + number.length - own.length);
+	return [number + first.slice(own.length), ...lines.slice(1).map((line) => line.startsWith(from) ? to + line.slice(from.length) : line)].join("");
+}
 function authoredMarker(list, source) {
 	const at = list.children?.[0]?.position?.start.offset;
 	return at == null ? void 0 : markerAt(source, at)?.marker;
@@ -44740,11 +44967,18 @@ function runOffsets(nodes, text, from, to) {
 	let decoded = "";
 	const offsets = [from];
 	const links = [];
+	const breaks = /* @__PURE__ */ new Set();
 	let at = from;
+	let afterBreak = false;
 	for (const node of nodes) {
 		const start = node.position?.start.offset;
 		const end = node.position?.end.offset;
-		if (start !== at || end == null) return void 0;
+		if (start == null || end == null) return void 0;
+		if (afterBreak && start >= at && /^[ \t>]*$/.test(text.slice(at, start))) {
+			at = start;
+			offsets[offsets.length - 1] = start;
+		}
+		if (start !== at) return void 0;
 		const raw = text.slice(start, end);
 		if (node.type === "link") {
 			const label = inlineText(node);
@@ -44758,13 +44992,19 @@ function runOffsets(nodes, text, from, to) {
 			if (!read || read.decoded !== lf(node.value ?? "")) return void 0;
 			decoded += read.decoded;
 			offsets.push(...read.offsets.slice(1).map((offset) => start + offset));
+		} else if (node.type === "break") {
+			breaks.add(decoded.length);
+			decoded += "\n";
+			offsets.push(end);
 		} else return void 0;
+		afterBreak = node.type === "break";
 		at = end;
 	}
 	return at === to ? {
 		decoded,
 		offsets,
-		links
+		links,
+		breaks
 	} : void 0;
 }
 function retainRun(before, after, source, canonical, [from, to], [newFrom, newTo]) {
@@ -44774,9 +45014,9 @@ function retainRun(before, after, source, canonical, [from, to], [newFrom, newTo
 	const a = old.decoded;
 	const b = now.decoded;
 	let prefix = 0;
-	while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix]) prefix++;
+	while (prefix < a.length && prefix < b.length && a[prefix] === b[prefix] && old.breaks.has(prefix) === now.breaks.has(prefix)) prefix++;
 	let suffix = 0;
-	while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
+	while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix] && old.breaks.has(a.length - 1 - suffix) === now.breaks.has(b.length - 1 - suffix)) suffix++;
 	for (let widened = true; widened;) {
 		widened = false;
 		for (const [links, length] of [[old.links, a.length], [now.links, b.length]]) for (const [start, end] of links) if (start <= length - suffix && end >= prefix) {
@@ -44790,7 +45030,7 @@ function retainRun(before, after, source, canonical, [from, to], [newFrom, newTo
 			}
 		}
 	}
-	return source.slice(from, old.offsets[prefix]) + canonical.slice(now.offsets[prefix], now.offsets[b.length - suffix]) + source.slice(old.offsets[a.length - suffix], to);
+	return source.slice(from, old.offsets[prefix]) + canonical.slice(now.offsets[prefix], now.offsets[b.length - suffix]) + (now.breaks.has(b.length - suffix - 1) ? retainBoundaryText(source.slice(old.offsets[a.length - suffix], to), canonical.slice(now.offsets[b.length - suffix], newTo), true) : source.slice(old.offsets[a.length - suffix], to));
 }
 function retainText(raw, before, after, inTable = false, written, beside = [false, false]) {
 	before = lf(before);
@@ -44812,14 +45052,38 @@ function retainText(raw, before, after, inTable = false, written, beside = [fals
 	}).join("");
 	return raw.slice(0, offsets[prefix]) + inserted + raw.slice(offsets[before.length - suffix]);
 }
-function retainBoundaryWhitespace(raw, canonical) {
+function retainBoundaryText(raw, canonical, afterBreak = false) {
+	if (afterBreak) {
+		const opening = /^(?:\d+)?(?:\\.)+/.exec(canonical)?.[0];
+		const written = opening ? decodedOffsets(opening) : void 0;
+		const original = written ? decodedOffsets(raw, true) : void 0;
+		if (written && original?.decoded.startsWith(written.decoded)) raw = opening + raw.slice(original.offsets[written.decoded.length]);
+	}
 	const token = "(?:[ \\t]|&#(?:[xX]0*(?:20|9)|0*(?:32|9));|&Tab;)";
 	const decoded = (value) => (value.match(new RegExp(token, "g")) ?? []).map((value) => value === "	" || /(?:9;|Tab;)$/.test(value) ? "	" : " ").join("");
 	const encode = (value) => value.replace(/[ \t]/g, (value) => value === "	" ? "&#x9;" : "&#x20;");
-	const start = /^[ \t]+/.exec(raw)?.[0];
+	if (raw.includes("\n")) {
+		const lines = raw.split(/(\r?\n)/);
+		const written = canonical.split(/\r?\n/);
+		if (lines.length === written.length * 2 - 1) return lines.map((line, index) => {
+			if (index % 2) return line;
+			const canonicalLine = written[index / 2];
+			const gutter = (value) => /^(?:[ \t]*>)*/.exec(value)?.[0] ?? "";
+			const prefix = gutter(line);
+			const canonicalPrefix = gutter(canonicalLine);
+			if (prefix.replace(/[ \t]/g, "") !== canonicalPrefix.replace(/[ \t]/g, "")) return line;
+			const canonicalBody = canonicalLine.slice(canonicalPrefix.length);
+			return prefix + retainBoundaryText(line.slice(prefix.length), canonicalBody);
+		}).join("");
+	}
 	const rawStart = new RegExp(`^${token}+`).exec(raw)?.[0];
 	const encodedStart = new RegExp(`^${token}+`).exec(canonical)?.[0];
-	if (start && rawStart && encodedStart?.includes("&") && decoded(rawStart) === decoded(encodedStart)) raw = encode(start) + raw.slice(start.length);
+	if (rawStart && encodedStart?.includes("&")) {
+		const content = decoded(encodedStart.slice(encodedStart.indexOf("&")));
+		const parts = rawStart.match(new RegExp(token, "g"));
+		const from = parts.length - content.length;
+		if (from >= 0 && decoded(parts.slice(from).join("")) === content) raw = parts.map((part, index) => index < from ? part : encode(part)).join("") + raw.slice(rawStart.length);
+	}
 	const end = /[ \t]+$/.exec(raw)?.[0];
 	const rawEnd = new RegExp(`${token}+$`).exec(raw)?.[0];
 	const encodedEnd = new RegExp(`${token}+$`).exec(canonical)?.[0];
@@ -44982,7 +45246,7 @@ function markLiterals(raw, transformed, blocks = []) {
 	};
 	raw.children.forEach(mark);
 }
-function retainSource(before, after, source, canonical, lineEnding, inTable = false, width, beside = [false, false], joined = []) {
+function retainSource(before, after, source, canonical, lineEnding, inTable = false, width, beside = [false, false], joined = [], reorder, afterBreak = false) {
 	if (literals$1.has(after)) return withEnding(retainLiteral(source.slice(before.position.start.offset, before.position.end.offset), literalForms.get(before), lf(canonical.slice(after.position.start.offset, after.position.end.offset))), lineEnding);
 	if (before.type === "list" && after.type === "list" && before.ordered && after.ordered && !numbered.has(before) && before.position?.start.offset != null) {
 		const own = {
@@ -44990,7 +45254,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 			start: after.start
 		};
 		numbered.add(own);
-		const text = retainSource(own, after, source, canonical, lineEnding, inTable, width, beside, joined);
+		const text = retainSource(own, after, source, canonical, lineEnding, inTable, width, beside, joined, reorder);
 		const at = before.position.start.offset;
 		const prefix = source.slice(source.lastIndexOf("\n", at - 1) + 1, at).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 		let count = 0, previous = 0, number = 0;
@@ -45008,7 +45272,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		const text = retainSource({
 			...before,
 			checked: after.checked
-		}, after, source, canonical, lineEnding, inTable, width, beside, joined);
+		}, after, source, canonical, lineEnding, inTable, width, beside, joined, reorder);
 		const box = /^((?:[-*+]|\d{1,9}[.)])[ \t]+\[)[ xX](\])/.exec(text);
 		if (box) return box[1] + (after.checked ? "x" : " ") + text.slice(box[1].length + 1);
 	}
@@ -45073,8 +45337,8 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		const to = first.position.end.offset - start;
 		return retained.startsWith(source.slice(start, before.children[1].position.start.offset)) ? retained.slice(0, from) + "<br />" + retained.slice(to) : retained;
 	}
-	if (before.type === "text" && after.type === "text") return retainBoundaryWhitespace(withEnding(retainText(raw, before.value, after.value, inTable, canonical.slice(newStart, newEnd), beside), lineEnding), canonical.slice(newStart, newEnd));
-	if (signature(before) === signature(after) && ownShape(before) === ownShape(after) && !holdsLiteral(after)) return raw;
+	if (before.type === "text" && after.type === "text") return retainBoundaryText(withEnding(retainText(raw, before.value, after.value, inTable, canonical.slice(newStart, newEnd), beside), lineEnding), canonical.slice(newStart, newEnd), afterBreak);
+	if (signature(before) === signature(after) && ownShape(before) === ownShape(after) && !holdsLiteral(after) && !reorderedWithin(before, reorder)) return raw;
 	const marker = sameList(before, after) ? authoredMarker(before, source) : void 0;
 	const located = (nodes) => nodes.every((node) => node.position?.start.offset != null);
 	if (before.type === after.type && ownShape(before) === ownShape(after) && before.children && after.children && before.children.length === after.children.length && located(before.children) && located(after.children)) {
@@ -45082,15 +45346,17 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		let previous;
 		const same = (candidate, incoming) => signature(candidate) === signature(incoming) && ownShape(candidate) === ownShape(incoming);
 		const reorderable = before.type === "table" || before.type === "tableRow";
+		const moves = reorder?.get(parentKey(before));
 		const retained = new Set(reorderable ? before.children.flatMap((child, index) => same(child, after.children[index]) ? [index] : []) : []);
 		before.children.forEach((child, index) => {
 			const incoming = after.children[index];
-			const movedIndex = !reorderable ? -1 : same(child, incoming) ? index : before.children.findIndex((candidate, candidateIndex) => !retained.has(candidateIndex) && same(candidate, incoming));
+			const carried = moves?.get(index);
+			const movedIndex = !reorderable ? carried !== void 0 && before.children[carried] !== void 0 && same(before.children[carried], incoming) ? carried : -1 : same(child, incoming) ? index : before.children.findIndex((candidate, candidateIndex) => !retained.has(candidateIndex) && same(candidate, incoming));
 			const original = movedIndex < 0 ? child : before.children[movedIndex];
 			if (movedIndex >= 0) retained.add(movedIndex);
 			const childStart = child.position?.start.offset, childEnd = child.position?.end.offset;
 			if (childStart == null || childEnd == null) throw new PreservationError("A source token has no location");
-			let retainedSource = rewrittenAddress(before.type, before.children, movedIndex < 0 ? index : movedIndex, after.children, index, source, canonical) ? canonical.slice(incoming.position.start.offset, incoming.position.end.offset) : incoming.type === "list" && !sameList(original, incoming) ? withEnding(canonicalSlice(void 0, [incoming], canonical, incoming.position.start.offset, incoming.position.end.offset, previous, authoredNeighbour(before.children[index + 1], after.children[index + 1], source)), lineEnding) : retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === "tableCell", before.type === "table" ? before.children[0]?.children?.length : void 0, [after.children[index - 1]?.type === "link", after.children[index + 1]?.type === "link"]);
+			let retainedSource = rewrittenAddress(before.type, before.children, movedIndex < 0 ? index : movedIndex, after.children, index, source, canonical) ? canonical.slice(incoming.position.start.offset, incoming.position.end.offset) : incoming.type === "list" && !sameList(original, incoming) ? withEnding(canonicalSlice(void 0, [incoming], canonical, incoming.position.start.offset, incoming.position.end.offset, previous, authoredNeighbour(before.children[index + 1], after.children[index + 1], source)), lineEnding) : retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === "tableCell", before.type === "table" ? before.children[0]?.children?.length : void 0, [after.children[index - 1]?.type === "link", after.children[index + 1]?.type === "link"], [], reorder, after.children[index - 1]?.type === "break");
 			if (before.type === "tableRow" && movedIndex >= 0 && movedIndex !== index) {
 				const originalFrom = original.children?.[0]?.position?.start.offset;
 				const originalTo = original.children?.at(-1)?.position?.end.offset;
@@ -45098,6 +45364,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 				const to = child.children?.at(-1)?.position?.end.offset;
 				retainedSource = originalFrom != null && originalTo != null && from != null && to != null ? source.slice(childStart, from) + source.slice(originalFrom, originalTo) + source.slice(to, childEnd) : withEnding(canonical.slice(incoming.position.start.offset, incoming.position.end.offset), lineEnding);
 			}
+			if (!reorderable && before.ordered && movedIndex >= 0 && movedIndex !== index) retainedSource = renumberItem(retainedSource, source, original, child);
 			if (marker) retainedSource = relabel(retainedSource, [0], marker);
 			previous = incoming.type !== "list" ? void 0 : authoredNeighbour(original, incoming, source) ?? {
 				ordered: incoming.ordered,
@@ -45114,11 +45381,11 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		while (suffix < before.children.length - prefix && suffix < after.children.length - prefix && signature(before.children[before.children.length - 1 - suffix]) === signature(after.children[after.children.length - 1 - suffix])) suffix++;
 		if (prefix && rewrittenAddress(before.type, before.children, prefix - 1, after.children, prefix - 1, source, canonical)) prefix--;
 		if (suffix && rewrittenAddress(before.type, before.children, before.children.length - suffix, after.children, after.children.length - suffix, source, canonical)) suffix--;
-		const cell = before.type === "tableCell" && before.children.length > 0 && after.children.length > 0;
-		const first = cell ? before.children[0].position?.start.offset : start;
-		const last = cell ? before.children.at(-1).position?.end.offset : end;
-		const newFirst = cell ? after.children[0].position?.start.offset : newStart;
-		const newLast = cell ? after.children.at(-1).position?.end.offset : newEnd;
+		const wrapped = (before.type === "tableCell" || formatting.has(before.type)) && before.children.length > 0 && after.children.length > 0;
+		const first = wrapped ? before.children[0].position?.start.offset : start;
+		const last = wrapped ? before.children.at(-1).position?.end.offset : end;
+		const newFirst = wrapped ? after.children[0].position?.start.offset : newStart;
+		const newLast = wrapped ? after.children.at(-1).position?.end.offset : newEnd;
 		const ending = (node) => {
 			const last = node.children?.at(-1);
 			return last && (node.type === "list" || node.type === "listItem" && last.type === "list") ? ending(last) : node;
@@ -45133,7 +45400,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 			const changes = after.children.slice(prefix, after.children.length - suffix);
 			const previous = authoredNeighbour(before.children[prefix - 1], after.children[prefix - 1], source);
 			const next = authoredNeighbour(before.children[before.children.length - suffix], after.children[after.children.length - suffix], source);
-			return source.slice(start, first) + retainBoundaryWhitespace(source.slice(first, from) + withEnding((inlineParents.has(before.type) ? retainRun(changed, changes, source, canonical, [from, to], [newFrom, newTo]) : retainParts(marker, [...changed, ...joined], changes, source, canonical, newFrom, newTo, lineEnding, previous, next)) ?? canonicalSlice(marker, changes, canonical, newFrom, newTo, previous, next), lineEnding) + source.slice(to, last), canonical.slice(newFirst, newLast)) + source.slice(last, end);
+			return source.slice(start, first) + retainBoundaryText(source.slice(first, from) + withEnding((inlineParents.has(before.type) ? retainRun(changed, changes, source, canonical, [from, to], [newFrom, newTo]) : retainParts(marker, [...changed, ...joined], changes, source, canonical, newFrom, newTo, lineEnding, previous, next)) ?? canonicalSlice(marker, changes, canonical, newFrom, newTo, previous, next), lineEnding) + (inlineParents.has(before.type) ? retainBoundaryText(source.slice(to, last), canonical.slice(newTo, newLast), after.children[after.children.length - suffix - 1]?.type === "break") : source.slice(to, last)), canonical.slice(newFirst, newLast)) + source.slice(last, end);
 		}
 	}
 	const lastAfter = after.children?.at(-1)?.position?.end.offset;
@@ -45229,7 +45496,13 @@ function semanticSignature(doc) {
 		const content = value.content;
 		if (!content) return value;
 		const tokens = [];
-		for (const child of content) {
+		for (const [index, child] of content.entries()) {
+			const attrs = child.attrs;
+			const next = content[index + 1];
+			if (child.type === "hardbreak" && attrs?.isInline === false && next?.type === "comment_inline" && next.attrs?.syntax === "html") child.attrs = {
+				...attrs,
+				isHTML: true
+			};
 			if (child.type !== "text") {
 				tokens.push(clean(child));
 				continue;
@@ -45441,6 +45714,11 @@ function similarity(left, right) {
 	while (suffix < limit - prefix && left[left.length - 1 - suffix] === right[right.length - 1 - suffix]) suffix++;
 	return prefix + suffix;
 }
+var nothingCarried = {
+	moved: /* @__PURE__ */ new Map(),
+	children: false,
+	within: /* @__PURE__ */ new Set()
+};
 /** Retains the loaded source of blocks the edit leaves alone. */
 var Preservation = class Preservation {
 	ctx;
@@ -45456,6 +45734,8 @@ var Preservation = class Preservation {
 	itemEdits = /* @__PURE__ */ new WeakMap();
 	regionEdits = /* @__PURE__ */ new WeakMap();
 	definitionNodes = /* @__PURE__ */ new Map();
+	moves;
+	origins;
 	nestedLiterals = /* @__PURE__ */ new Set();
 	literalsRead = /* @__PURE__ */ new WeakSet();
 	definitionSources;
@@ -45521,12 +45801,12 @@ var Preservation = class Preservation {
 			throw new PreservationError("Cannot read Markdown for preservation", { cause });
 		}
 	}
-	retainBlock(block, after, canonical, joined = []) {
+	retainBlock(block, after, canonical, joined = [], reorder) {
 		const offset = this.source.startsWith("") ? 1 : 0;
 		const start = block.ast.position?.start.offset;
 		if (start == null) throw new PreservationError("A source block has no location");
 		this.readNestedLiterals(block);
-		return this.source.slice(block.start, start + offset) + retainSource(block.ast, after, this.source.slice(offset), canonical, this.lineEnding, false, void 0, void 0, joined);
+		return this.source.slice(block.start, start + offset) + retainSource(block.ast, after, this.source.slice(offset), canonical, this.lineEnding, false, void 0, void 0, joined, reorder);
 	}
 	readNestedLiterals(block) {
 		if (!this.nestedLiterals.size || this.literalsRead.has(block)) return;
@@ -45567,7 +45847,8 @@ var Preservation = class Preservation {
 		for (let index = 0; index <= doc.childCount; index++) {
 			const node = index < doc.childCount ? doc.child(index) : void 0;
 			const before = node && this.baseline.child(index);
-			if (!node || node === before || node.eq(before)) {
+			if (node && node !== before && this.moves?.has(node)) return void 0;
+			if (!node || node === before || node.eq(before) && !this.carries(node)) {
 				if (run.length > 1 && !this.pairedInPlace(doc, run)) return void 0;
 				run = [];
 				continue;
@@ -45713,19 +45994,24 @@ var Preservation = class Preservation {
 			if (other !== index && candidate.type === node.type && candidate.childCount === node.childCount && candidate.textContent === node.textContent) return void 0;
 		}
 		const marker = authoredMarker(list, source);
+		const reorder = this.moves ? this.carriedChildren(node, index) : void 0;
+		const carried = reorder?.get(parentKey(list));
 		let output = "";
 		let previous = block.start;
 		for (let at = 0; at < node.childCount; at++) {
 			const item = node.child(at);
 			const original = before.child(at);
-			if (item === original || item.eq(original)) continue;
+			if (item === original || item.eq(original) && !this.carries(item)) continue;
+			const moved = carried?.get(at);
+			const from = moved !== void 0 && list.children[moved] ? moved : void 0;
 			let retained = this.itemEdits.get(item);
-			if (retained?.index !== index || retained.item !== at) {
-				const text = this.localItem(node, item, before.child(at), list.children[at], source, marker);
+			if (retained?.index !== index || retained.item !== at || retained.from !== from) {
+				const text = from === void 0 ? this.localItem(node, item, before.child(at), list.children[at], source, marker, reorder) : this.movedItem(node, item, list, list.children[from], list.children[at], source, marker);
 				if (text === void 0) return void 0;
 				retained = {
 					index,
 					item: at,
+					from,
 					text
 				};
 				this.itemEdits.set(item, retained);
@@ -45736,18 +46022,17 @@ var Preservation = class Preservation {
 		}
 		return output + this.source.slice(previous, block.end);
 	}
-	localItem(list, item, before, ast, source, marker) {
-		const start = ast.position.start.offset;
-		const end = ast.position.end.offset;
-		if (!item.sameMarkup(before) || !sameBlocks(item, before) || !Preservation.plainInline(item) || !Preservation.plainInline(before) || !this.inContext(source.slice(start, end))) return void 0;
-		const local = this.canonicalTree(form(write(this.ctx, list.type.schema.topNodeType.create(null, [list.type.create(list.attrs, [item])]))));
-		const after = local?.node.children?.[0];
-		if (!local || local.node.children.length !== 1 || !after) return void 0;
-		let text = retainSource(ast, {
-			...after,
-			spread: ast.spread
-		}, source, local.canonical, this.lineEnding);
+	movedItem(node, item, list, original, place, source, marker) {
+		const start = original.position.start.offset;
+		const end = original.position.end.offset;
+		if (!Preservation.plainInline(item) || !this.inContext(source.slice(start, end))) return void 0;
+		let text = source.slice(start, end);
+		if (list.ordered) text = renumberItem(text, source, original, place);
 		if (marker) text = relabel(text, [0], marker);
+		return this.readsAsItem(node, item, text, place, source);
+	}
+	readsAsItem(list, item, text, ast, source) {
+		const start = ast.position.start.offset;
 		const content = ast.children?.[0]?.position?.start.offset;
 		if (content == null || !text.startsWith(source.slice(start, content))) return void 0;
 		if (/^(?:[-*+]|\d{1,9}[.)])[ \t]*(?:\r?\n|$)/.test(text)) return void 0;
@@ -45760,6 +46045,20 @@ var Preservation = class Preservation {
 		const { label: _l, spread: _s, ...expected } = item.attrs;
 		return reread.type === item.type && JSON.stringify(attrs) === JSON.stringify(expected) && reread.content.eq(item.content) ? text : void 0;
 	}
+	localItem(list, item, before, ast, source, marker, reorder) {
+		const start = ast.position.start.offset;
+		const end = ast.position.end.offset;
+		if (!item.sameMarkup(before) || !sameBlocks(item, before) || !Preservation.plainInline(item) || !Preservation.plainInline(before) || !this.inContext(source.slice(start, end))) return void 0;
+		const local = this.canonicalTree(form(write(this.ctx, list.type.schema.topNodeType.create(null, [list.type.create(list.attrs, [item])]))));
+		const after = local?.node.children?.[0];
+		if (!local || local.node.children.length !== 1 || !after) return void 0;
+		let text = retainSource(ast, {
+			...after,
+			spread: ast.spread
+		}, source, local.canonical, this.lineEnding, false, void 0, void 0, [], reorder);
+		if (marker) text = relabel(text, [0], marker);
+		return this.readsAsItem(list, item, text, ast, source);
+	}
 	separateLists(doc, pieces, kept, positions, current) {
 		const kind = (index) => {
 			const name = doc.maybeChild(index)?.type.name;
@@ -45779,7 +46078,7 @@ var Preservation = class Preservation {
 			return true;
 		};
 		const cost = (index) => {
-			if (kept[index] === "canonical") return 1;
+			if (kept[index] === "canonical" || kept[index] === "moved") return 1;
 			if (kept[index] === "edited") return 10;
 			const own = marker(index);
 			const sides = [-1, 1].map((step) => inPlace(index, step));
@@ -45842,7 +46141,18 @@ var Preservation = class Preservation {
 		const reread = read(relabelled);
 		return reread.length === 1 && signature(reread[0]) === signature(list) && markerAt(relabelled, list.children[0].position.start.offset)?.marker === marker ? relabelled : void 0;
 	}
-	serialize(doc) {
+	/** `moved` holds the nodes block moves carried. A moved node that is still a
+	*  node of the loaded document keeps that node's source where it reads the
+	*  same; every other edit is saved without it. */
+	serialize(doc, moved) {
+		this.moves = moved;
+		try {
+			return this.serializeWith(doc);
+		} finally {
+			this.moves = void 0;
+		}
+	}
+	serializeWith(doc) {
 		if (this.unchanged(doc)) return this.source;
 		let local;
 		try {
@@ -45864,10 +46174,20 @@ var Preservation = class Preservation {
 		for (let index = 0; index < doc.childCount; index++) {
 			const node = doc.child(index);
 			const before = this.baseline.child(index);
-			if (node !== before && !node.eq(before)) return false;
+			if (node !== before && (!node.eq(before) || this.carries(node))) return false;
 		}
 		return true;
 	}
+	carries(node) {
+		const moves = this.moves;
+		if (!moves) return false;
+		let found = moves.has(node);
+		node.descendants((child) => {
+			found ||= moves.has(child);
+			return !found && !child.isTextblock;
+		});
+		return found;
+	}
 	checked(doc, text) {
 		if (!crossCheck.enabled) return text;
 		crossCheck.compared++;
@@ -45900,7 +46220,7 @@ var Preservation = class Preservation {
 		const previous = positions[index - 1];
 		return previous != null && position === previous + 1 && block ? this.source.slice(this.blocks[previous].end, block.start) : this.lineEnding.repeat(2);
 	}
-	build(doc, positions, current, from, to, canonical, tree) {
+	build(doc, positions, current, carried, from, to, canonical, tree) {
 		const transformed = (index) => tree.transformed.children[index - from];
 		if (tree) {
 			const failed = [];
@@ -45928,12 +46248,13 @@ var Preservation = class Preservation {
 		for (let index = from; index < to; index++) {
 			const text = current[index];
 			const position = positions[index];
-			const block = position == null ? void 0 : this.blocks[position];
+			const moved = carried.moved.get(index);
+			const block = position == null ? moved === void 0 ? void 0 : this.blocks[moved] : this.blocks[position];
 			gaps.push(this.gap(index, positions));
-			const kind = block && block.form === text ? "unchanged" : block && tree ? "edited" : "canonical";
+			const kind = block && block.form === text && !carried.within.has(index) ? position == null ? "moved" : "unchanged" : block && tree && position != null ? "edited" : "canonical";
 			kept.push(kind);
 			const node = tree ? positionalNode(tree.raw, transformed(index)) : void 0;
-			pieces.push(kind === "unchanged" ? this.source.slice(block.start, block.end) : kind === "edited" ? this.retainBlock(block, node, canonical, this.around(positions, index).filter((other) => !paired.has(other) && other.ast.type === block.ast.type).flatMap((other) => other.ast.children ?? [])) : (node && this.retainPart(positions, index, node, canonical, taken)) ?? restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), withEnding(text, this.lineEnding)));
+			pieces.push(kind === "unchanged" || kind === "moved" ? this.source.slice(block.start, block.end) : kind === "edited" ? this.retainBlock(block, node, canonical, this.around(positions, index).filter((other) => !paired.has(other) && other.ast.type === block.ast.type).flatMap((other) => other.ast.children ?? []), carried.children ? this.carriedChildren(doc.child(index), position) : void 0) : (node && this.retainPart(positions, index, node, canonical, taken)) ?? restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), withEnding(text, this.lineEnding)));
 		}
 		return {
 			gaps,
@@ -45977,10 +46298,10 @@ var Preservation = class Preservation {
 			extra
 		};
 	}
-	runs(positions, current) {
+	runs(positions, current, within = nothingCarried.within) {
 		const unchanged = (index) => {
 			const position = positions[index];
-			return position != null && this.blocks[position].form === current[index];
+			return position != null && this.blocks[position].form === current[index] && !within.has(index);
 		};
 		const consecutive = (index) => index === 0 ? positions[0] === 0 : positions[index] != null && positions[index - 1] != null && positions[index] === positions[index - 1] + 1;
 		const runs = [];
@@ -46010,7 +46331,7 @@ var Preservation = class Preservation {
 			return true;
 		});
 	}
-	runPieces(doc, positions, current, run) {
+	runPieces(doc, positions, current, carried, run) {
 		const from = run.previous === void 0 ? 0 : run.previous + 1;
 		const to = run.next ?? doc.childCount;
 		if (from === to) return {
@@ -46021,26 +46342,27 @@ var Preservation = class Preservation {
 		const nodes = [];
 		for (let index = from; index < to; index++) nodes.push(doc.child(index));
 		const { canonical, tree } = from === 0 && to === doc.childCount ? this.canonicalDocument(doc) : this.canonicalBlocks(doc, nodes);
-		return this.build(doc, positions, current, from, to, canonical, tree);
+		return this.build(doc, positions, current, carried, from, to, canonical, tree);
 	}
 	regions(doc) {
 		if (!doc.childCount || this.baseline.childCount !== this.blocks.length || !doc.sameMarkup(this.baseline) || this.definitionSources === void 0) return void 0;
 		const current = [];
 		doc.forEach((node) => current.push(this.formOf(node)));
 		let positions;
+		let carried;
 		try {
-			positions = correspondence(this.blockForms, current);
+			({positions, carried} = this.pairing(doc, current));
 		} catch {
 			return;
 		}
-		const runs = this.runs(positions, current);
+		const runs = this.runs(positions, current, carried.within);
 		if (runs.some((run) => run.previous === void 0 && run.next === void 0) || !this.readAlone(doc, positions, runs)) return void 0;
 		let output = "";
 		let at = 0;
 		for (const run of runs) {
 			const from = run.previous === void 0 ? 0 : this.blocks[positions[run.previous]].end;
 			const to = run.next === void 0 ? this.source.length : this.blocks[positions[run.next]].start;
-			const text = this.region(doc, positions, current, run);
+			const text = this.region(doc, positions, current, carried, run);
 			if (text === void 0) return void 0;
 			output += this.source.slice(at, from) + text;
 			at = to;
@@ -46051,7 +46373,7 @@ var Preservation = class Preservation {
 		if (frontmatter !== sourceFrontmatter(bom(this.source)) || doc.firstChild?.type.name === "hr" && frontmatter?.startsWith("---")) return void 0;
 		return output;
 	}
-	region(doc, positions, current, run) {
+	region(doc, positions, current, carried, run) {
 		const from = run.previous === void 0 ? 0 : run.previous + 1;
 		const to = run.next ?? doc.childCount;
 		const nodes = [];
@@ -46062,7 +46384,7 @@ var Preservation = class Preservation {
 		const identity = [
 			original(run.previous),
 			original(run.next),
-			...positions.slice(from, to)
+			...Array.from({ length: to - from }, (_, at) => positions[from + at] ?? `m${carried.moved.get(from + at) ?? ""}`)
 		].join();
 		const cached = this.regionEdits.get(key);
 		if (cached && cached.identity === identity && cached.nodes.length === nodes.length + neighbours.length && [...nodes, ...neighbours].every((node, index) => cached.nodes[index] === node)) return cached.text;
@@ -46071,10 +46393,10 @@ var Preservation = class Preservation {
 			return name === "bullet_list" || name === "ordered_list" ? name : void 0;
 		};
 		for (let index = Math.max(1, from); index <= Math.min(to, doc.childCount - 1); index++) if (list(index) && list(index) === list(index - 1)) return void 0;
-		const { gaps, pieces } = this.runPieces(doc, positions, current, run);
+		const { gaps, pieces } = this.runPieces(doc, positions, current, carried, run);
 		let text = pieces.map((piece, index) => gaps[index] + piece).join("");
 		if (run.next !== void 0) text += this.gap(run.next, positions);
-		else text += positions[doc.childCount - 1] === this.blocks.length - 1 ? this.source.slice(this.blocks.at(-1).end) : finalCodeEnding(doc) ?? this.lineEnding;
+		else text += this.endsAsAuthored(positions, carried) ? this.source.slice(this.blocks.at(-1).end) : finalCodeEnding(doc) ?? this.lineEnding;
 		const slice = (index) => {
 			if (index === void 0) return "";
 			const block = this.blocks[positions[index]];
@@ -46134,26 +46456,21 @@ var Preservation = class Preservation {
 			if (canonical === "") return this.source.startsWith("") ? "" : "";
 			const current = [];
 			doc.forEach((node) => current.push(this.formOf(node)));
-			const positions = correspondence(this.blockForms, current);
-			const gaps = current.map((_, index) => this.gap(index, positions));
-			const pieces = positions.map((position) => position == null ? "" : this.source.slice(this.blocks[position].start, this.blocks[position].end));
-			const kept = current.map(() => "unchanged");
-			const runs = this.runs(positions, current);
-			for (const run of this.readAlone(doc, positions, runs) ? runs : [{}]) {
-				const from = run.previous === void 0 ? 0 : run.previous + 1;
-				const written = this.runPieces(doc, positions, current, run);
-				written.pieces.forEach((piece, index) => {
-					pieces[from + index] = piece;
-					kept[from + index] = written.kept[index];
-				});
+			const pairing = this.pairing(doc, current);
+			const carries = pairing.carried.moved.size > 0 || pairing.carried.children;
+			if (carries) {
+				let output;
+				try {
+					output = this.writeDocument(doc, current, pairing);
+				} catch {
+					output = void 0;
+				}
+				if (output !== void 0 && this.reopens(doc, output, canonical)) return output;
 			}
-			const previous = positions.at(-1);
-			this.separateLists(doc, pieces, kept, positions, current);
-			let output = pieces.map((piece, index) => gaps[index] + piece).join("");
-			if (previous === this.blocks.length - 1 && this.blocks.length) output += this.source.slice(this.blocks[previous].end);
-			else if (output) output += finalCodeEnding(doc) ?? this.lineEnding;
-			const bom = output.startsWith("") ? 1 : 0;
-			if (doc.firstChild?.type.name === "hr" && sourceFrontmatter(output.slice(bom))?.startsWith("---")) output = output.slice(0, bom) + "***" + output.slice(bom + 3);
+			const output = this.writeDocument(doc, current, carries ? {
+				positions: correspondence(this.blockForms, current),
+				carried: nothingCarried
+			} : pairing);
 			if (this.reopens(doc, output, canonical)) return output;
 			throw new PreservationError("The edited Markdown cannot be reopened without changing its content");
 		} catch (cause) {
@@ -46161,6 +46478,157 @@ var Preservation = class Preservation {
 			throw new PreservationError("Cannot preserve the edited Markdown", { cause });
 		}
 	}
+	writeDocument(doc, current, { positions, carried }) {
+		const gaps = current.map((_, index) => this.gap(index, positions));
+		const pieces = positions.map((position) => position == null ? "" : this.source.slice(this.blocks[position].start, this.blocks[position].end));
+		const kept = current.map(() => "unchanged");
+		const runs = this.runs(positions, current, carried.within);
+		for (const run of this.readAlone(doc, positions, runs) ? runs : [{}]) {
+			const from = run.previous === void 0 ? 0 : run.previous + 1;
+			const written = this.runPieces(doc, positions, current, carried, run);
+			written.pieces.forEach((piece, index) => {
+				pieces[from + index] = piece;
+				kept[from + index] = written.kept[index];
+			});
+		}
+		positions.at(-1);
+		this.separateLists(doc, pieces, kept, positions, current);
+		let output = pieces.map((piece, index) => gaps[index] + piece).join("");
+		if (this.endsAsAuthored(positions, carried)) output += this.source.slice(this.blocks.at(-1).end);
+		else if (output) output += finalCodeEnding(doc) ?? this.lineEnding;
+		const bom = output.startsWith("") ? 1 : 0;
+		if (doc.firstChild?.type.name === "hr" && sourceFrontmatter(output.slice(bom))?.startsWith("---")) output = output.slice(0, bom) + "***" + output.slice(bom + 3);
+		return output;
+	}
+	originIndex() {
+		if (this.origins) return this.origins;
+		const origins = /* @__PURE__ */ new WeakMap();
+		const visit = (node, path) => node.forEach((child, _, index) => {
+			const at = [...path, index];
+			origins.set(child, at);
+			if (!child.isTextblock && !child.isLeaf && child.type.name !== "table") visit(child, at);
+		});
+		visit(this.baseline, []);
+		return this.origins = origins;
+	}
+	pairing(doc, current) {
+		const moves = this.moves;
+		if (!moves || this.baseline.childCount !== this.blocks.length) return {
+			positions: correspondence(this.blockForms, current),
+			carried: nothingCarried
+		};
+		const origins = this.originIndex();
+		const pinned = /* @__PURE__ */ new Map();
+		doc.forEach((node, _, index) => {
+			if (moves.has(node)) {
+				const origin = origins.get(node);
+				if (origin?.length === 1) pinned.set(index, origin[0]);
+			}
+		});
+		if (!pinned.size) {
+			const positions = correspondence(this.blockForms, current);
+			return {
+				positions,
+				carried: {
+					moved: pinned,
+					children: true,
+					within: this.within(doc, positions, current)
+				}
+			};
+		}
+		const taken = new Set(pinned.values());
+		const before = this.blocks.flatMap((_, index) => taken.has(index) ? [] : [index]);
+		const after = current.flatMap((_, index) => pinned.has(index) ? [] : [index]);
+		const present = /* @__PURE__ */ new Map();
+		for (const index of after) {
+			const origin = origins.get(doc.child(index));
+			if (origin?.length === 1) present.set(index, origin[0]);
+		}
+		const kept = new Set(present.values());
+		const matched = correspondence(before.map((index) => kept.has(index) ? `${this.blockForms[index]}\u0000${index}` : this.blockForms[index]), after.map((index) => present.has(index) ? `${current[index]}\u0000${present.get(index)}` : current[index]));
+		const positions = new Array(current.length);
+		after.forEach((index, at) => {
+			const match = matched[at];
+			if (match !== void 0) positions[index] = before[match];
+		});
+		const next = new Array(current.length);
+		let following = this.blocks.length;
+		for (let index = current.length - 1; index >= 0; index--) {
+			next[index] = following;
+			if (positions[index] !== void 0) following = positions[index];
+		}
+		const own = (index) => {
+			const origin = origins.get(doc.child(index));
+			return origin?.length === 1 ? origin[0] : void 0;
+		};
+		const above = new Array(current.length);
+		let upper = this.blocks.length;
+		for (let index = current.length - 1; index >= 0; index--) {
+			above[index] = upper;
+			upper = own(index) ?? upper;
+		}
+		const moved = /* @__PURE__ */ new Map();
+		let last = -1;
+		let lower = -1;
+		for (let index = 0; index < current.length; index++) {
+			const origin = pinned.get(index);
+			const inOrder = origin > lower && origin < above[index];
+			lower = own(index) ?? lower;
+			if (origin === void 0) {
+				if (positions[index] !== void 0) last = positions[index];
+			} else if (origin > last && origin < next[index] && inOrder) {
+				positions[index] = origin;
+				last = origin;
+			} else moved.set(index, origin);
+		}
+		return {
+			positions,
+			carried: {
+				moved,
+				children: true,
+				within: this.within(doc, positions, current)
+			}
+		};
+	}
+	endsAsAuthored(positions, carried) {
+		const end = this.blocks.length - 1;
+		if (end < 0) return false;
+		if (positions.at(-1) === end) return true;
+		return carried.moved.has(positions.length - 1) && [...carried.moved.values()].includes(end);
+	}
+	within(doc, positions, current) {
+		const within = /* @__PURE__ */ new Set();
+		positions.forEach((position, index) => {
+			const node = doc.child(index);
+			if (position !== void 0 && this.blocks[position].form === current[index] && node !== this.baseline.child(position) && this.carries(node)) within.add(index);
+		});
+		return within;
+	}
+	carriedChildren(node, original) {
+		const moves = this.moves;
+		if (!moves || this.baseline.childCount !== this.blocks.length) return;
+		const origins = this.originIndex();
+		let reorder;
+		const walk = (current, path, ast) => {
+			if (!ast?.children || ast.position?.start.offset == null) return;
+			current.forEach((child, _, index) => {
+				let from = index;
+				const origin = moves.has(child) ? origins.get(child) : void 0;
+				if (origin?.length === path.length + 1 && origin.every((step, at) => at === path.length || step === path[at])) {
+					from = origin.at(-1);
+					if (from !== index) {
+						reorder ??= /* @__PURE__ */ new Map();
+						const key = parentKey(ast);
+						if (!reorder.has(key)) reorder.set(key, /* @__PURE__ */ new Map());
+						reorder.get(key).set(index, from);
+					}
+				}
+				if (!child.isTextblock && !child.isLeaf && child.type.name !== "table") walk(child, [...path, from], ast.children[from]);
+			});
+		};
+		walk(node, [original], this.blocks[original].ast);
+		return reorder;
+	}
 };
 //#endregion
 //#region src/autolink.ts
@@ -46210,14 +46678,8 @@ function read(ctx, sources, texts) {
 function literals(ctx, texts) {
 	const possible = texts.map((text) => /www\.|https?:\/\/|@/i.test(text));
 	const candidates = texts.filter((_, index) => possible[index]);
-	const escaped = candidates.map((text) => text.replace(/[\\`[\]<>]/g, "\\$&"));
-	const raw = read(ctx, candidates, candidates);
-	const changed = candidates.flatMap((text, index) => escaped[index] === text ? [] : [index]);
-	const written = read(ctx, changed.map((index) => escaped[index]), changed.map((index) => candidates[index]));
-	changed.forEach((index, at) => {
-		if (JSON.stringify(written[at]) !== JSON.stringify(raw[index])) raw[index] = void 0;
-	});
-	return texts.map((_, index) => possible[index] ? raw.shift() : []);
+	const found = read(ctx, candidates.map((text) => text.replace(/[\\`[\]<>]/g, "\\$&")), candidates);
+	return texts.map((_, index) => possible[index] ? found.shift() : []);
 }
 function angleHref(text) {
 	if (/^[a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s<>\u0000-\u001f]*$/.test(text)) return text;
@@ -46249,7 +46711,7 @@ function wantedLinks(ctx, chars, from, to) {
 	}
 	const free = (index) => {
 		const char = chars[index];
-		return char !== void 0 && (released.has(index) || char.form !== "angle" && !(char.link && !char.form));
+		return char !== void 0 && !char.marks.some((mark) => mark.type.spec.code) && (released.has(index) || char.form !== "angle" && !(char.link && !char.form));
 	};
 	const spans = [];
 	for (let index = 0; index < chars.length;) {
@@ -46419,9 +46881,96 @@ var autolinkLiterals = $prose((ctx) => new Plugin({
 	}
 }));
 //#endregion
+//#region src/inline-code.ts
+var held = new PluginKey("storedInlineCode");
+function finish(state, pending, code) {
+	const { selection } = state;
+	if (state.storedMarks || !selection.empty || selection.from !== pending.to) return null;
+	const tr = state.tr;
+	if (pending.from < pending.to) tr.addMark(pending.from, pending.to, code.create());
+	return tr.setStoredMarks(pending.marks);
+}
+var storedInlineCode = $prose((ctx) => {
+	const type = () => inlineCodeSchema.type(ctx);
+	let composing;
+	return new Plugin({
+		key: held,
+		state: {
+			init: () => null,
+			apply(tr, value, old) {
+				const id = tr.getMeta("composition");
+				if (id === void 0) return tr.docChanged || tr.selectionSet || tr.storedMarksSet ? null : value;
+				const marks = old.storedMarks;
+				const start = value?.id === id ? value : marks && type().isInSet(marks) ? {
+					marks,
+					id,
+					from: old.selection.from,
+					to: 0
+				} : null;
+				if (!start) return null;
+				let to = value?.id === id ? tr.mapping.map(start.to, 1) : start.from;
+				tr.mapping.maps.forEach((map, index) => map.forEach((_from, _to, _start, end) => {
+					to = Math.max(to, tr.mapping.slice(index + 1).map(end, 1));
+				}));
+				return {
+					...start,
+					to
+				};
+			}
+		},
+		view: (view) => {
+			composing = view;
+			return { destroy() {
+				composing = void 0;
+			} };
+		},
+		props: { handleDOMEvents: { compositionend(view) {
+			Promise.resolve().then(() => void 0).then(() => {
+				if (view.isDestroyed || view.composing) return;
+				const pending = held.getState(view.state);
+				const tr = pending && finish(view.state, pending, type());
+				if (tr) view.dispatch(tr.setMeta("appendedTransaction", tr));
+			});
+			return false;
+		} } },
+		appendTransaction(transactions, oldState, newState) {
+			const code = type();
+			const stored = oldState.storedMarks;
+			if (!stored || !code.isInSet(stored) || composing?.composing || transactions.some((tr) => tr.getMeta("composition"))) return null;
+			const { $from } = newState.selection;
+			if ($from.start() !== oldState.selection.$from.start()) return newState.storedMarks && code.isInSet(newState.storedMarks) ? newState.tr.setStoredMarks(code.removeFromSet(newState.storedMarks)) : null;
+			const before = $from.nodeBefore;
+			if (newState.storedMarks || !transactions.some((tr) => tr.docChanged) || !newState.selection.empty || !before?.isText || !code.isInSet(before.marks)) return null;
+			return newState.tr.setStoredMarks(stored);
+		}
+	});
+});
+//#endregion
 //#region src/source.ts
 var sourceAttribute = "inkkitSource";
+var completedLines = /* @__PURE__ */ new WeakMap();
+function completedSource(node) {
+	const cached = completedLines.get(node);
+	if (cached) return cached;
+	let result = node;
+	if (node.type.name === "paragraph" || node.type.name === "heading" && node.attrs.form === "setext") {
+		let end = node.content.size;
+		for (let index = node.childCount - 1; index >= 0; index--) {
+			const child = node.child(index);
+			if (child.type.name !== "hardbreak" || child.attrs.isInline || child.attrs.isHTML) break;
+			end -= child.nodeSize;
+		}
+		if (end !== node.content.size) result = node.copy(node.content.cut(0, end));
+	} else if (!node.isLeaf && !node.isTextblock) {
+		const children = [];
+		node.forEach((child) => children.push(completedSource(child)));
+		if (children.some((child, index) => child !== node.child(index))) result = node.copy(Fragment.fromArray(children));
+	}
+	completedLines.set(node, result);
+	return result;
+}
 function cleanSourceDoc(doc) {
+	doc = completedSource(doc);
 	return doc.attrs["inkkitSource"] == null ? doc : doc.type.create({
 		...doc.attrs,
 		[sourceAttribute]: null
@@ -48564,6 +49113,7 @@ function writesBare(node, index, ancestors) {
 	const follows = (parent, text) => {
 		if (text.type !== "text") return false;
 		const run = /^\S*/.exec(text.value)[0];
+		if (!node.url.startsWith("mailto:") && blocks$2.has(parent.type) && parent.children.at(-1) === text && /^[ \t]+$/.test(text.value.slice(run.length))) return false;
 		return trailing.test(run) && (run.length < text.value.length || blocks$2.has(parent.type) && parent.children.at(-1) === text);
 	};
 	const side = (step) => {
@@ -48723,6 +49273,10 @@ function remarkDialect() {
 			]
 		}],
 		handlers: {
+			break(node, parent, state, info) {
+				const next = parent?.children[parent.children.indexOf(node) + 1];
+				return next?.type === "inkkitCommentInline" && next.syntax === "html" ? "<br />" : handle.break(node, parent, state, info);
+			},
 			text(node, parent, state, info) {
 				const value = handle.text(node, parent, state, info);
 				if (!state.stack.includes("tableCell") || parent?.type !== "paragraph" && parent?.type !== "tableCell") return value;
@@ -48754,12 +49308,11 @@ function padShortRows(node) {
 	if ("children" in node) node.children.forEach(padShortRows);
 }
 var remarkDialectPlugin = $remark("remarkDialect", () => remarkDialect);
-var commonmarkWithLiteralReferences = commonmark.filter((plugin) => !remarkInlineLinkPlugin.includes(plugin) && plugin !== hardbreakClearMarkPlugin && plugin !== syncHeadingIdPlugin && plugin !== createCodeBlockInputRule);
+var commonmarkWithLiteralReferences = commonmark.filter((plugin) => !remarkInlineLinkPlugin.includes(plugin) && plugin !== hardbreakClearMarkPlugin && !hardbreakKeymap.some((part) => part === plugin) && plugin !== syncHeadingIdPlugin && plugin !== createCodeBlockInputRule);
 var breaksWithoutMarks = $prose((ctx) => new Plugin({
 	key: new PluginKey("inkkitBreaksWithoutMarks"),
 	appendTransaction(transactions, oldState, newState) {
 		if (!transactions.some((tr) => tr.docChanged)) return null;
-		const inserted = transactions.some((tr) => tr.getMeta("hardbreak"));
 		const start = oldState.doc.content.findDiffStart(newState.doc.content);
 		if (start == null) return null;
 		const end = oldState.doc.content.findDiffEnd(newState.doc.content).b;
@@ -48767,7 +49320,7 @@ var breaksWithoutMarks = $prose((ctx) => new Plugin({
 		const tr = newState.tr;
 		newState.doc.nodesBetween(start, Math.max(start, end), (node, pos) => {
 			if (node.type !== type) return;
-			for (const mark of node.marks) if (inserted || mark.type.spec.code) tr.removeMark(pos, pos + 1, mark.type);
+			for (const mark of node.marks) if (mark.type.spec.code) tr.removeMark(pos, pos + 1, mark.type);
 		});
 		return tr.steps.length ? tr : null;
 	}
@@ -48801,6 +49354,36 @@ var preserveSpacerParagraphs = paragraphSchema.extendSchema((base) => (ctx) => {
 		}
 	};
 });
+var headingsWithBreaks = headingSchema.extendSchema((base) => (ctx) => {
+	const schema = base(ctx);
+	return {
+		...schema,
+		attrs: {
+			...schema.attrs,
+			form: { default: "atx" }
+		},
+		parseMarkdown: {
+			...schema.parseMarkdown,
+			runner(state, node, type) {
+				const position = node.position;
+				state.openNode(type, {
+					level: node.depth,
+					form: position && position.end.line > position.start.line ? "setext" : "atx"
+				});
+				state.next(node.children);
+				state.closeNode();
+			}
+		},
+		toMarkdown: {
+			...schema.toMarkdown,
+			runner(state, node) {
+				state.openNode("heading", void 0, { depth: node.attrs.level });
+				state.next(node.content);
+				state.closeNode();
+			}
+		}
+	};
+});
 var visibleSoftbreaks = hardbreakSchema.extendSchema((base) => (ctx) => {
 	const schema = base(ctx);
 	return {
@@ -48897,10 +49480,14 @@ function cellToMarkdown(base) {
 		}
 	};
 }
-var cellBreakKeymap = $prose(() => keymap$3({ "Shift-Enter": (state, dispatch) => {
+var breakKeymap = $prose(() => keymap$3({ "Shift-Enter": (state, dispatch, view) => {
 	const { $from } = state.selection;
-	if (!/^table_(cell|header)$/.test($from.node(-1)?.type.name ?? "")) return false;
-	dispatch?.(state.tr.replaceSelectionWith(state.schema.nodes.hardbreak.create({ isHTML: true }), false).scrollIntoView());
+	if (!(state.selection instanceof TextSelection) || $from.parent.type.spec.code) return false;
+	const isHTML = htmlBreakAt($from);
+	if (dispatch) {
+		dispatch(closeHistory(state.tr).replaceSelectionWith(state.schema.nodes.hardbreak.create({ isHTML }), false).scrollIntoView());
+		if (view) dispatch(closeHistory(view.state.tr).setMeta("addToHistory", false));
+	}
 	return true;
 } }));
 var listItems = extendListItemSchemaForTask.extendSchema((previous) => (ctx) => {
@@ -48986,7 +49573,7 @@ var tables = [
 ].flat();
 function createDialect(images, wikiLinks = false, files = false) {
 	return [
-		cellBreakKeymap,
+		breakKeymap,
 		remarkCodeFences,
 		remarkReferencesPlugin,
 		remarkLinkFormsPlugin,
@@ -49014,9 +49601,11 @@ function createDialect(images, wikiLinks = false, files = false) {
 		joinKeepingSourceKeymap,
 		preserveSpacerParagraphs,
 		visibleSoftbreaks,
+		headingsWithBreaks,
 		normalizedImages,
 		imageBlocks,
 		autolinkLiterals,
+		storedInlineCode,
 		breaksWithoutMarks,
 		listItems,
 		strikethroughAttr,
@@ -49025,6 +49614,7 @@ function createDialect(images, wikiLinks = false, files = false) {
 		strikethroughKeymap,
 		toggleStrikethroughCommand,
 		wrapInTaskListInputRule,
+		smartPunctuation,
 		remarkDialectPlugin,
 		tables,
 		literalBlock,
@@ -49305,7 +49895,7 @@ function selectionContent(doc, content) {
 	return content.append(Fragment.fromArray(extra));
 }
 function selectionMarkdown(ctx, doc, content) {
-	return serialize(ctx, doc.type.create(null, selectionContent(doc, content)));
+	return serialize(ctx, cleanSourceDoc(doc.type.create(null, selectionContent(doc, content))));
 }
 function referenceMetadata(ctx, doc, content) {
 	doc = doc.copy(shareableFragment(doc.content));
@@ -49899,9 +50489,116 @@ function tableAvailability(ctx) {
 	available.sortRows = [...body].sort((a, b) => compareCells(a.key, b.key, "text", "ascending") || a.index - b.index).some((row, index) => row !== body[index]);
 	return available;
 }
+/** Trims the whitespace at both ends of a cell's inline content. */
+function trimCell(nodes) {
+	const trimmed = [...nodes];
+	for (const [edge, trim] of [[0, (text) => text.trimStart()], [-1, (text) => text.trimEnd()]]) for (;;) {
+		const node = trimmed.at(edge);
+		if (!node?.text) break;
+		const text = trim(node.text);
+		if (text) {
+			trimmed.splice(edge < 0 ? trimmed.length - 1 : 0, 1, node.type.schema.text(text, node.marks));
+			break;
+		}
+		trimmed.splice(edge < 0 ? trimmed.length - 1 : 0, 1);
+	}
+	return trimmed;
+}
+/**
+* The cells of a paragraph that is one table row typed as Markdown, such as `| Name | Date |`: it
+* starts and ends with a pipe and holds at least two cells. A pipe written `\|` or inside inline
+* code belongs to its cell. Returns nothing for any other paragraph, including one with a line
+* break or an inline node, which a cell could not hold the same way.
+*/
+function typedRowCells(paragraph) {
+	const rows = [[]];
+	for (let index = 0; index < paragraph.childCount; index++) {
+		const child = paragraph.child(index);
+		if (!child.isText || /[\r\n]/.test(child.text)) return void 0;
+		if (child.marks.some((mark) => mark.type.spec.code)) {
+			rows.at(-1).push(child);
+			continue;
+		}
+		let piece = "", slashes = 0;
+		const flush = () => {
+			if (piece) rows.at(-1).push(child.type.schema.text(piece, child.marks));
+			piece = "";
+		};
+		for (const character of child.text) if (character !== "|") {
+			slashes = character === "\\" ? slashes + 1 : 0;
+			piece += character;
+		} else if (slashes % 2) {
+			piece = piece.slice(0, -1) + character;
+			slashes = 0;
+		} else {
+			flush();
+			rows.push([]);
+			slashes = 0;
+		}
+		flush();
+	}
+	const blank = (cell) => cell.every((node) => node.isText && !node.text.trim());
+	if (rows.length < 4 || !blank(rows[0]) || !blank(rows.at(-1))) return void 0;
+	const cells = rows.slice(1, -1);
+	return cells.length <= 100 ? cells.map(trimCell) : void 0;
+}
+/**
+* Turns the paragraph holding the caret at its end into a table when it is a typed table row: the
+* typed cells are the header, one empty row follows, and the caret is in its first cell. It builds
+* the table `table('insert')` does and replaces the paragraph in one undo step of its own, so Undo
+* restores the typed line with the caret at its end.
+*/
+function typedRowToTable(ctx) {
+	return (state, dispatch) => {
+		const view = ctx.get(editorViewCtx);
+		const { $cursor } = state.selection;
+		if (!$cursor || !view.editable || view.composing || $cursor.parent.type.name !== "paragraph" || $cursor.parentOffset !== $cursor.parent.content.size || $cursor.depth < 1) return false;
+		const cells = typedRowCells($cursor.parent);
+		if (!cells) return false;
+		const template = createTable(ctx, 2, cells.length);
+		const [head, ...rest] = [template.child(0), template.child(1)];
+		const paragraph = state.schema.nodes.paragraph;
+		let table;
+		try {
+			table = template.copy(Fragment.from([head.copy(Fragment.fromArray(cells.map((cell, column) => {
+				return head.child(column).copy(Fragment.from(paragraph.create(null, cell)));
+			}))), ...rest]));
+			table.check();
+		} catch {
+			return false;
+		}
+		const index = $cursor.index(-1), parent = $cursor.node(-1);
+		const replaces = parent.canReplaceWith(index, index + 1, table.type);
+		if (!replaces && (parent.attrs.checked != null || !parent.canReplaceWith(index + 1, index + 1, table.type))) return false;
+		if (dispatch) {
+			const tr = state.tr;
+			if (replaces) tr.replaceWith($cursor.before(), $cursor.after(), table);
+			else {
+				tr.delete($cursor.start(), $cursor.end());
+				tr.insert($cursor.start() + 1, table);
+			}
+			const body = (replaces ? $cursor.before() : $cursor.start() + 1) + 1 + table.child(0).nodeSize;
+			tr.setSelection(Selection.findFrom(tr.doc.resolve(body), 1, true));
+			dispatchTableOperation(view, tr);
+		}
+		return true;
+	};
+}
 var tablePlugins = [
 	moveRowCommand,
 	moveColCommand,
+	$shortcut((ctx) => ({
+		Enter: {
+			key: "Enter",
+			onRun: () => typedRowToTable(ctx),
+			priority: 60
+		},
+		Tab: {
+			key: "Tab",
+			onRun: () => typedRowToTable(ctx),
+			priority: 60
+		}
+	})),
 	$prose(() => keymap$3({
 		Tab: goToNextCell(1),
 		"Shift-Tab": goToNextCell(-1)
@@ -50970,6 +51667,101 @@ function literalVisibleRanges(plain, viewport) {
 	}) ?? [];
 }
 //#endregion
+//#region src/block-move.ts
+var containers = /* @__PURE__ */ new Set([
+	"doc",
+	"blockquote",
+	"inkkit_callout",
+	"bullet_list",
+	"ordered_list",
+	"footnote_definition"
+]);
+var tableParts = /* @__PURE__ */ new Set([
+	"table",
+	"table_row",
+	"table_header_row",
+	"table_cell",
+	"table_header"
+]);
+/** On a move's transaction, the blocks it carried, so their source can go
+*  with them. */
+var carriedBlocks = new PluginKey("carriedBlocks");
+var frontMatter = (node) => node.type.name === "literal_markdown" && /^(?:---|\+\+\+)[ \t]*\r?\n/.test(node.textContent);
+/**
+* The move a selection makes, or `'boundary'` when its blocks are already
+* first or last in their container, or `undefined` when it has no blocks to
+* move, such as in a table, where the table's own row moves apply.
+*/
+function plan(state, direction) {
+	const { $from, $to } = state.selection;
+	for (const $pos of [$from, $to]) for (let depth = $pos.depth; depth > 0; depth--) if (tableParts.has($pos.node(depth).type.name)) return void 0;
+	const range = $from.blockRange($to, (node) => containers.has(node.type.name));
+	if (!range) return void 0;
+	const container = range.parent;
+	const first = range.depth === 0 && frontMatter(container.child(0)) ? 1 : 0;
+	if (range.startIndex < first) return void 0;
+	const hidden = (index) => !commentsVisible(state) && container.child(index).type.name === "comment_block";
+	const up = direction === "up";
+	let index = up ? range.startIndex - 1 : range.endIndex;
+	const step = up ? -1 : 1;
+	const inside = (index) => up ? index >= first : index < container.childCount;
+	while (inside(index) && hidden(index)) index += step;
+	if (!inside(index)) return "boundary";
+	const past = up ? [index, range.startIndex] : [range.endIndex, index + 1];
+	return {
+		depth: range.depth,
+		start: range.startIndex,
+		end: range.endIndex,
+		past
+	};
+}
+/** Whether `moveBlock` would move the blocks at the selection. */
+function canMoveBlock(state, direction) {
+	return typeof plan(state, direction) === "object";
+}
+/**
+* `'move'` when `moveBlock` would move the blocks at the selection,
+* `'boundary'` when they are already first or last in their container, and
+* undefined when there are none to move, as in a table.
+*/
+function blockMove(state, direction) {
+	const move = plan(state, direction);
+	return typeof move === "object" ? "move" : move;
+}
+/**
+* Moves the blocks at the selection past their neighbour in `direction`, as
+* one step that keeps the moved and the passed nodes as they are, so their
+* authored source travels with them. Returns undefined when nothing moves.
+*/
+function moveBlockTransaction(state, direction) {
+	const move = plan(state, direction);
+	if (typeof move !== "object") return void 0;
+	const { depth, start, end, past } = move;
+	const $at = state.selection.$from;
+	const container = $at.node(depth);
+	const offset = (index) => $at.posAtIndex(index, depth);
+	const children = (from, to) => {
+		const nodes = [];
+		for (let index = from; index < to; index++) nodes.push(container.child(index));
+		return nodes;
+	};
+	const moved = children(start, end);
+	const passed = children(past[0], past[1]);
+	const up = direction === "up";
+	const from = offset(up ? past[0] : start);
+	const to = offset(up ? end : past[1]);
+	const reordered = up ? [...moved, ...passed] : [...passed, ...moved];
+	const tr = state.tr.replaceWith(from, to, Fragment.fromArray(reordered)).setMeta(carriedBlocks, reordered);
+	const shift = up ? -passed.reduce((size, node) => size + node.nodeSize, 0) : passed.reduce((size, node) => size + node.nodeSize, 0);
+	tr.setSelection(shifted(state.selection, tr.doc, shift));
+	return tr.scrollIntoView();
+}
+function shifted(selection, doc, shift) {
+	if (selection instanceof NodeSelection) return NodeSelection.create(doc, selection.from + shift);
+	if (selection instanceof TextSelection) return TextSelection.create(doc, selection.anchor + shift, selection.head + shift);
+	return Selection.near(doc.resolve(selection.head + shift));
+}
+//#endregion
 //#region src/scroll.ts
 /** Rounds a distance away from zero, to a whole number of pixels. */
 var scrollOutward = (distance) => distance > 0 ? Math.ceil(distance) : Math.floor(distance);
@@ -53106,9 +53898,10 @@ function replacementSlice(state, from, to, value) {
 	if (start.parent.type.spec.code) {
 		if (value) nodes.push(state.schema.text(value, marks));
 	} else {
+		const isHTML = htmlBreakAt(start);
 		const lines = value.split("\n");
 		lines.forEach((line, index) => {
-			if (index) nodes.push(state.schema.nodes.hardbreak.create({ isHTML: index === lines.length - 1 && line === "" }, null, marks));
+			if (index) nodes.push(state.schema.nodes.hardbreak.create({ isHTML }, null, index === lines.length - 1 && line === "" ? [] : marks));
 			if (line) nodes.push(state.schema.text(line, marks));
 		});
 	}
@@ -53154,8 +53947,8 @@ function replaceFormattedRange(view, from, to, replacement, preflight) {
 	const start = view.state.doc.resolve(from);
 	const end = view.state.doc.resolve(to);
 	let textOnly = start.parent === end.parent && start.parent.inlineContent;
-	view.state.doc.nodesBetween(from, to, (node) => {
-		if (!node.isText && !node.isTextblock) textOnly = false;
+	if (textOnly) start.parent.nodesBetween(start.parentOffset, end.parentOffset, (node) => {
+		if (!node.isText) textOnly = false;
 	});
 	if (!textOnly) throw new InkKitError("invalid-range", "Replacement requires literal text within one block");
 	const value = replacement.replace(/\r\n?/g, "\n");
@@ -53704,6 +54497,8 @@ var shortcutNames = [
 	...formatShortcuts,
 	"undo",
 	"redo",
+	"moveBlockUp",
+	"moveBlockDown",
 	...tableCommands.map(tableShortcut)
 ];
 /** Checks a keymap and drops omitted entries, so a `null` binding keeps its default. */
@@ -53732,11 +54527,13 @@ function textInputPreferences(value, name) {
 	const record = expectRecord(value, name, [
 		"spellcheck",
 		"autocorrect",
-		"autocapitalize"
+		"autocapitalize",
+		"smartPunctuation"
 	]);
 	return {
 		spellcheck: optionalBoolean(record.spellcheck, `${name}.spellcheck`),
 		autocorrect: optionalBoolean(record.autocorrect, `${name}.autocorrect`),
+		smartPunctuation: optionalBoolean(record.smartPunctuation, `${name}.smartPunctuation`),
 		autocapitalize: isOmitted(record.autocapitalize) ? void 0 : expectOneOf(record.autocapitalize, autocapitalizeValues, `${name}.autocapitalize`)
 	};
 }
@@ -54150,6 +54947,7 @@ var InkKitEditor = class InkKitEditor {
 	ready = false;
 	destroyed = false;
 	preservation;
+	carried;
 	pasteController;
 	plain;
 	root;
@@ -54180,7 +54978,7 @@ var InkKitEditor = class InkKitEditor {
 	changePlugin = $prose(() => new Plugin({
 		key: new PluginKey("documentChanges"),
 		view: () => ({ update: (view, previous) => {
-			if (this.loading || view.state.doc.eq(previous.doc)) return;
+			if (this.loading || this.sameDocument(view.state.doc, previous.doc)) return;
 			if (this.syncingSource) {
 				this.mediaPolicy();
 				return;
@@ -54442,7 +55240,7 @@ var InkKitEditor = class InkKitEditor {
 		}
 		this.publishCommandState();
 	}
-	/** Replaces the input hints. A field left out leaves the browser's behavior. Throws `composition`
+	/** Replaces the input preferences. A field left out takes its default. Throws `composition`
 	*  during text composition. */
 	setTextInputPreferences(preferences) {
 		this.assertAlive();
@@ -54542,7 +55340,9 @@ var InkKitEditor = class InkKitEditor {
 				insertFootnote: formatted,
 				editReferenceDefinition: formatted && referenceDefinitions(state.doc).size > 0,
 				format,
-				table: tables
+				table: tables,
+				moveBlockUp: formatted && canMoveBlock(state, "up"),
+				moveBlockDown: formatted && canMoveBlock(state, "down")
 			}
 		};
 	}
@@ -54564,6 +55364,17 @@ var InkKitEditor = class InkKitEditor {
 		range = new NodeRange(state.doc.resolve($from.before(depth)), state.doc.resolve($from.after(depth)), depth - 1);
 		return !!findWrapping(range, type);
 	}
+	historyInputPlugin = $prose(() => new Plugin({
+		key: new PluginKey("inkkitHistoryInput"),
+		props: { handleDOMEvents: { beforeinput: (_view, event) => {
+			if (!this.writable) return false;
+			const name = event.inputType === "historyUndo" ? "undo" : event.inputType === "historyRedo" ? "redo" : void 0;
+			if (!name) return false;
+			event.preventDefault();
+			if (this.ready && this.commandState().commands[name]) this.forPerson(() => this[name](), true);
+			return true;
+		} } }
+	}));
 	policyPlugin = $prose(() => new Plugin({
 		key: new PluginKey("inkkitInputPolicy"),
 		filterTransaction: (tr) => this.loading || this.writable || this.syncingSource || !tr.docChanged && !tr.storedMarksSet,
@@ -54618,7 +55429,7 @@ var InkKitEditor = class InkKitEditor {
 					this.sourcePreservations.set(provenance, preservation);
 				}
 			}
-			text = preservation.serialize(cleanSourceDoc(doc));
+			text = preservation.serialize(cleanSourceDoc(doc), this.carried);
 		} catch (error) {
 			throw coded(error, "preservation");
 		}
@@ -54834,7 +55645,7 @@ var InkKitEditor = class InkKitEditor {
 		this.assertMutation(expectedGeneration);
 		if (this.literalSurface && this.stepTypedSource("undo")) return true;
 		const view = this.editor.ctx.get(editorViewCtx);
-		const undone = undo(view.state, view.dispatch);
+		const undone = !this.literalSurface && undoSmartPunctuation(view.state, view.dispatch) || undo(view.state, view.dispatch);
 		if (undone) {
 			if (this.literalSurface && this.undoneSteps.length) this.formattedUndone++;
 			else this.undoneSteps = [];
@@ -55000,10 +55811,11 @@ var InkKitEditor = class InkKitEditor {
 				const { schema } = view.state;
 				const marks = view.state.storedMarks ?? (view.state.selection.empty ? view.state.selection.$from.marks() : view.state.selection.$from.marksAcross(view.state.selection.$to)) ?? [];
 				const children = [];
+				const isHTML = !inHiddenComment && htmlBreakAt(view.state.selection.$from);
 				const lines = text.replace(/\r\n?/g, "\n").split("\n");
 				lines.forEach((line, index) => {
 					const finalBreak = index === lines.length - 1 && line === "";
-					if (index) children.push(schema.nodes.hardbreak.create({ isHTML: finalBreak }, null, finalBreak ? [] : marks));
+					if (index) children.push(schema.nodes.hardbreak.create({ isHTML }, null, finalBreak ? [] : marks));
 					if (line) children.push(schema.text(line, marks));
 				});
 				if (!children.length) {
@@ -55013,8 +55825,9 @@ var InkKitEditor = class InkKitEditor {
 				const paragraph = schema.nodes.paragraph.create(null, children);
 				const transaction = inHiddenComment ? insertAfterHiddenComment(view.state, Fragment.from(paragraph)) : view.state.tr.replaceSelection(new Slice(Fragment.from(paragraph), 1, 1)).scrollIntoView();
 				if (!transaction) return;
-				this.currentText(transaction.doc);
-				view.dispatch(transaction);
+				const isolated = lines.length > 1;
+				view.dispatch(isolated ? closeHistory(transaction) : transaction);
+				if (isolated) view.dispatch(closeHistory(view.state.tr).setMeta("addToHistory", false));
 			}
 		}
 	}
@@ -55027,6 +55840,21 @@ var InkKitEditor = class InkKitEditor {
 		if (this.literalSurface) return false;
 		return tableCommand(this.editor.ctx, command, options);
 	}
+	/** Moves the blocks at the selection one place up or down in their list, quote, callout, footnote
+	*  or note, as one undo step. Returns whether they moved: false in source and TXT modes, in a
+	*  table, and when they are already first or last. */
+	moveBlock(direction, expectedGeneration) {
+		this.assertAlive();
+		expectOneOf(direction, ["up", "down"], "direction");
+		this.assertMutation(expectedGeneration);
+		if (this.literalSurface) return false;
+		const view = this.editor.ctx.get(editorViewCtx);
+		const tr = moveBlockTransaction(view.state, direction);
+		if (!tr) return false;
+		view.dispatch(closeHistory(tr));
+		view.dispatch(closeHistory(view.state.tr).setMeta("addToHistory", false));
+		return true;
+	}
 	/** Cancels pending work and releases the editor. It never rejects. Afterwards every other member
 	*  throws `destroyed`. */
 	async destroy() {
@@ -55122,6 +55950,7 @@ var InkKitEditor = class InkKitEditor {
 		instance.editor = await Editor.make().config((ctx) => {
 			ctx.set(rootCtx, root);
 			ctx.set(authoredSourcesCtx.key, (doc, positions) => instance.authoredSources(doc, positions));
+			ctx.set(smartPunctuationCtx.key, () => instance.inputPreferences.smartPunctuation === true);
 			ctx.update(labelsCtx.key, () => ({
 				...defaultLabels,
 				...options.labels
@@ -55159,6 +55988,7 @@ var InkKitEditor = class InkKitEditor {
 				...options,
 				dispatchTransaction: function(tr) {
 					if (instance.call?.refusal && tr.docChanged) return;
+					for (const node of tr.getMeta(carriedBlocks) ?? []) (instance.carried ??= /* @__PURE__ */ new WeakSet()).add(node);
 					const applied = this.state.applyTransaction(tr);
 					let next = applied.state;
 					if (!instance.loading) {
@@ -55187,7 +56017,7 @@ var InkKitEditor = class InkKitEditor {
 					return true;
 				}
 			}));
-		}).use(labelsCtx).use(instance.pasteController.plugin).use(visibleClipboard).use(instance.keymapPlugin).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(tablePlugins).use(tableBlock).use(instance.changePlugin).use(history).use(clipboard).use(cursor).use(taskListPlugin).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(listItemShiftTab).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(events.copy ? codeCopyPlugin((text) => events.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-BW9W8PtS.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview((error) => instance.report(error))).use(selectionPlugin).use($prose(() => search())).use(instance.policyPlugin).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
+		}).use(labelsCtx).use(instance.pasteController.plugin).use(visibleClipboard).use(instance.keymapPlugin).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(tablePlugins).use(tableBlock).use(instance.changePlugin).use(instance.historyInputPlugin).use(history).use(clipboard).use(cursor).use(taskListPlugin).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(listItemShiftTab).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(events.copy ? codeCopyPlugin((text) => events.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-DQC71L-N.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview((error) => instance.report(error))).use(selectionPlugin).use($prose(() => search())).use(instance.policyPlugin).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
 			capture: () => instance.adapterCapture(),
 			active: () => instance.ready && !instance.destroyed && !instance.literalSurface,
 			labels: {
@@ -55602,12 +56432,24 @@ var InkKitEditor = class InkKitEditor {
 		if (reveal) this.revealTextRange(range);
 		this.publishCommandState();
 	}
+	/** Whether two documents are the same note. A move of blocks that read alike, such as a setext
+	*  heading and the same heading written with `#`, gives an equal document with other source. */
+	sameDocument(after, before) {
+		if (after === before) return true;
+		if (!after.eq(before)) return false;
+		if (!this.carried || !this.preservation) return true;
+		try {
+			return this.currentText(after) === this.currentText(before);
+		} catch {
+			return false;
+		}
+	}
 	/** Throws when a document reached by an edit, after every appended normalisation, cannot be
 	*  saved as preserved Markdown. Dispatch and the replacement commands share this check.
 	*  `written` is false for history steps and source replacement, which restore or supply a
 	*  document that may hold comment text the formatted editor would refuse to accept typed. */
 	assertPreserved(before, after, written = true) {
-		if (this.literalSurface || after.eq(before)) return;
+		if (this.literalSurface || this.sameDocument(after, before)) return;
 		if (written) assertCommentsEndWhereWritten(before, after);
 		if (this.preservation) this.currentText(after);
 	}
@@ -55784,6 +56626,7 @@ var InkKitEditor = class InkKitEditor {
 			this.loading = false;
 		}
 		this.preservation = preservation;
+		this.carried = void 0;
 		this.lastMarkdown = markdown;
 		const { doc } = view.state;
 		const $end = doc.resolve(doc.content.size);
@@ -55975,14 +56818,17 @@ var InkKitEditor = class InkKitEditor {
 		this.releaseFocus();
 	}
 	/** Replaces every binding. Keys are in ProseMirror's notation. A key given to two shortcuts goes
-	*  to the later one, in the order history, formatting, tables, so it lands the same way every
-	*  time. */
+	*  to the later one, in the order history, formatting, block moves, tables, so it lands the same
+	*  way every time. A table binding passes a key it shares with a block move to the move outside
+	*  a table. */
 	setKeymap(keymap) {
 		this.assertAlive();
 		keymap = keymapBindings(keymap, "keymap");
 		this.configuredKeys = {
 			undo: ["Mod-z"],
 			redo: ["Mod-y", "Shift-Mod-z"],
+			moveBlockUp: ["Alt-ArrowUp"],
+			moveBlockDown: ["Alt-ArrowDown"],
 			tableExit: ["Mod-Enter", "Enter"],
 			...keymap
 		};
@@ -56002,11 +56848,19 @@ var InkKitEditor = class InkKitEditor {
 			this.forPerson(() => this.format(name), false);
 			return true;
 		};
-		for (const command of tableCommands) for (const key of this.configuredKeys[tableShortcut(command)] ?? []) bindings[key] = () => {
-			if (!this.ready || !this.commandState().commands.table[command]) return false;
+		const moves = {};
+		for (const [name, direction] of [["moveBlockUp", "up"], ["moveBlockDown", "down"]]) for (const key of this.configuredKeys[name] ?? []) moves[key] = bindings[key] = (state) => {
+			if (!this.ready || !this.writable || this.literalSurface) return false;
+			const move = blockMove(state, direction);
+			if (!move) return false;
+			if (move === "move" && !this.composing && !this.pasteController.pending) this.forPerson(() => this.moveBlock(direction), false);
+			return true;
+		};
+		for (const command of tableCommands) for (const key of this.configuredKeys[tableShortcut(command)] ?? []) bindings[key] = (state, dispatch, view) => {
+			if (!this.ready || !this.commandState().commands.table[command]) return moves[key]?.(state, dispatch, view) ?? false;
 			return this.forPerson(() => this.table(command), true);
 		};
-		this.readOnlyKeys = keydownHandler(Object.fromEntries(Object.keys(bindings).map((key) => [key, () => {
+		this.readOnlyKeys = keydownHandler(Object.fromEntries(Object.keys(bindings).filter((key) => !moves[key]).map((key) => [key, () => {
 			throw new InkKitError("read-only", "The editor is read-only");
 		}])));
 		this.keys = keydownHandler(bindings);
@@ -56464,6 +57318,7 @@ var InkKitEditor = class InkKitEditor {
 			"replaceAll",
 			"format",
 			"table",
+			"moveBlock",
 			"insertText",
 			"keyDown",
 			"insertPaths",