@aicayzer/inkkit 0.1.3 → 0.1.4

package/README.md

@@ -9,6 +9,17 @@ A Markdown editor for the web and for apps that host a web view. It edits format
 - Images and files through your own storage adapter
 - Your app owns the toolbar, menus, files and appearance
 
+## How it works
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/aicayzer/inkkit/main/docs/images/how-inkkit-works-dark.svg">
+  <img src="https://raw.githubusercontent.com/aicayzer/inkkit/main/docs/images/how-inkkit-works.svg" width="800" alt="An ordinary Markdown editor rebuilds the whole file when it saves, so list markers, spacing and escaping change. InkKit loads the file and edits it formatted with Milkdown. A preservation layer between Milkdown and the file saves a note you open and leave byte for byte unchanged. After an edit, it keeps unchanged blocks as their original bytes, writes only edited blocks with Milkdown, and reads the result back. If it reopens as the same document, the edit is kept and saved. If not, the edit is refused and the note stays as it was. Your app owns the files, storage, toolbar and appearance.">
+</picture>
+
+A formatted Markdown editor usually rebuilds the whole file when it saves, so opening and saving a note can change list markers, spacing and escaping that you never touched. InkKit adds a preservation layer between [Milkdown](https://milkdown.dev) and the file. A note that you open and leave is saved byte for byte unchanged, and after an edit only the blocks you edited are rewritten. InkKit reads the result of each edit back and refuses the edit if it would not reopen as the same document.
+
+For the exact guarantees, see [Preservation](https://github.com/aicayzer/inkkit/blob/main/docs/preservation.md).
+
 ## Install
 
 ```sh

package/dist/chunks/{core-Bvj0PMMi.js → core-DP-izJDM.js}

@@ -35086,6 +35086,194 @@ var references = [
 	}))
 ].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/linked-syntax.ts
 var fromTable = (raw) => raw.replace(/(\\*)\|/g, (_match, escapes) => `${"\\".repeat(Math.floor(escapes.length / 2))}|`);
 var toTable = (raw) => raw.replace(/(\\*)\|/g, (_match, escapes) => `${"\\".repeat(escapes.length * 2 + 1)}|`);
@@ -35277,6 +35465,76 @@ var wikiLinkSchema = $node("inkkit_wiki_link", () => ({
 		}
 	}
 }));
+var composed = new PluginKey("inkkitWikiLinkComposition");
+/**
+* Lets the rule below tell a `]` that a composition committed from text that was already in the
+* note: ProseMirror runs every input rule when a composition ends, with nothing typed.
+*/
+var wikiLinkComposition = $prose(() => new Plugin({
+	key: composed,
+	state: {
+		init: () => ({
+			composition: null,
+			closing: null
+		}),
+		apply(tr, value) {
+			const { composition } = value;
+			value.closing = null;
+			if (!tr.docChanged || !composition) return value;
+			if (tr.getMeta("composition") === void 0) value.composition = null;
+			else if (insertedAt(tr, composition.pos) === "]" && tr.doc.content.size === composition.size + 1) value.closing = composition.pos + 1;
+			return value;
+		}
+	},
+	props: { handleDOMEvents: { compositionstart(view) {
+		const { from, empty } = view.state.selection;
+		const tracked = composed.getState(view.state);
+		tracked.closing = null;
+		tracked.composition = empty ? {
+			pos: from,
+			size: view.state.doc.content.size
+		} : null;
+		return false;
+	} } }
+}));
+/**
+* Turns `[[target]]`, as the person types its last bracket, into the wiki link
+* it reads as when the note is opened, so the note keeps the characters that
+* were typed. Left as text, the brackets save as `\[\[target]]`, which no
+* other tool reads as a link. The last bracket has to be the one just typed,
+* or committed by a composition: text already in the note, such as escaped
+* brackets, is never changed, and that includes the run of every rule when a
+* composition ends.
+*/
+var wikiLinkInputRule = $inputRule(() => new InputRule(/\[\[(?:\\.|[^[\]\\\ufffc])*\]\]$/, (state, match, start, end) => {
+	const { schema, doc } = state;
+	const type = schema.nodes.inkkit_wiki_link;
+	const caret = state.selection.from;
+	if (start + match[0].length - 1 !== caret && !(start + match[0].length === caret && composed.getState(state)?.closing === caret)) return null;
+	const $start = doc.resolve(start);
+	const parent = $start.parent;
+	if (!type || !parent.inlineContent || !parent.canReplaceWith($start.index(), $start.index(), type) || /[!\\[]/.test(doc.textBetween(Math.max($start.start(), start - 1), start))) return null;
+	let marks;
+	let plain = true;
+	doc.nodesBetween(start, end, (node) => {
+		if (!node.isInline) return;
+		if (!node.isText) plain = false;
+		else if (marks && !Mark.sameSet(marks, node.marks)) plain = false;
+		else marks ??= node.marks;
+	});
+	if (!plain || !marks || marks.some((mark) => ["inlineCode", "link"].includes(mark.type.name)) || state.storedMarks && !Mark.sameSet(state.storedMarks, marks)) return null;
+	let inTable = false;
+	for (let depth = $start.depth; depth > 0; depth--) if (["table_cell", "table_header"].includes($start.node(depth).type.name)) inTable = true;
+	const parsed = parseLinkedSyntax(inTable ? toTable(match[0]) : match[0], inTable);
+	if (!parsed || parsed.embed) return null;
+	return state.tr.replaceWith(start, end, type.create({
+		raw: parsed.raw,
+		target: parsed.target,
+		fragment: parsed.fragment,
+		label: parsed.label,
+		inTable: parsed.inTable
+	}, void 0, marks));
+}, { inCodeMark: false }));
 function linkedSyntax(wikiLinks, files) {
 	const syntax = { text: {} };
 	if (wikiLinks) syntax.text[91] = {
@@ -44433,194 +44691,6 @@ 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;
 /**
@@ -45125,14 +45195,25 @@ var literalBlock = $node("literal_markdown", (ctx) => ({
 }));
 //#endregion
 //#region src/preserve.ts
+var linkFormsMatter = false;
+function withLinkForms(run) {
+	const before = linkFormsMatter;
+	linkFormsMatter = true;
+	try {
+		return run();
+	} finally {
+		linkFormsMatter = before;
+	}
+}
 function signature(node) {
 	return JSON.stringify(ordered(node), function(key, value) {
+		const holder = this;
+		if (key === "data" && holder.type === "link" && linkFormsMatter) return { inkkitLinkForm: value?.inkkitLinkForm };
 		if ([
 			"position",
 			"data",
 			"marker"
 		].includes(key)) return void 0;
-		const holder = this;
 		if (key === "value" && holder.type === "html" && lineBreakHTML(value)) return "<br />";
 		if (key === "children" && holder.type === "tableRow") {
 			let end = value.length;
@@ -45955,7 +46036,17 @@ function parseDoc(ctx, text) {
 }
 function parseTree(ctx, text) {
 	preservationWork.characters += text.length;
-	return ctx.get(remarkCtx).parse(text);
+	const tree = ctx.get(remarkCtx).parse(text);
+	const body = text.replace(/^\uFEFF/, "");
+	const visit = (node) => {
+		if (node.type === "link") node.data = {
+			...node.data,
+			inkkitLinkForm: linkForm(node, body)
+		};
+		node.children?.forEach(visit);
+	};
+	visit(tree);
+	return tree;
 }
 function write(ctx, doc) {
 	const text = serialize(ctx, doc);
@@ -46233,6 +46324,7 @@ var Preservation = class Preservation {
 	blocks = [];
 	lineEnding;
 	originalForms = /* @__PURE__ */ new Set();
+	linkEdits = false;
 	blockForms = [];
 	forms = /* @__PURE__ */ new WeakMap();
 	blockEdits = /* @__PURE__ */ new WeakMap();
@@ -46759,7 +46851,7 @@ var Preservation = class Preservation {
 			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" || 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)));
+			pieces.push(kind === "unchanged" || kind === "moved" ? this.source.slice(block.start, block.end) : kind === "edited" ? this.retainingForms(block, doc.child(index), () => 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,
@@ -46955,6 +47047,31 @@ var Preservation = class Preservation {
 		for (let index = 0; index < nodes.length; index++) rewritten.push(again.child(index));
 		return actual === normalized(write(this.ctx, read.type.create(null, rewritten)));
 	}
+	withLinkEdits(run) {
+		this.linkEdits = true;
+		try {
+			return run();
+		} finally {
+			this.linkEdits = false;
+		}
+	}
+	retainingForms(block, node, retain) {
+		if (!this.linkEdits) return retain();
+		const forms = (value) => {
+			const found = [];
+			let previous;
+			value.descendants((child) => {
+				if (!child.isText) return true;
+				const link = child.marks.find((mark) => mark.type.name === "link");
+				if (link && !previous?.eq(link)) found.push(link.attrs.form ?? null);
+				previous = link;
+				return false;
+			});
+			return JSON.stringify(found);
+		};
+		const original = this.baseline.maybeChild(this.blocks.indexOf(block));
+		return !original || this.baseline.childCount !== this.blocks.length || forms(original) !== forms(node) ? withLinkForms(retain) : retain();
+	}
 	wholeDocument(doc) {
 		try {
 			const canonical = write(this.ctx, doc);
@@ -46963,20 +47080,24 @@ var Preservation = class Preservation {
 			doc.forEach((node) => current.push(this.formOf(node)));
 			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;
+			const attempt = () => {
+				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;
 				}
-				if (output !== void 0 && this.reopens(doc, output, canonical)) return output;
-			}
-			const output = this.writeDocument(doc, current, carries ? {
-				positions: correspondence(this.blockForms, current),
-				carried: nothingCarried
-			} : pairing);
-			if (this.reopens(doc, output, canonical)) return output;
+				const output = this.writeDocument(doc, current, carries ? {
+					positions: correspondence(this.blockForms, current),
+					carried: nothingCarried
+				} : pairing);
+				return this.reopens(doc, output, canonical) ? output : void 0;
+			};
+			const output = attempt() ?? this.withLinkEdits(attempt);
+			if (output !== void 0) return output;
 			throw new PreservationError("The edited Markdown cannot be reopened without changing its content");
 		} catch (cause) {
 			if (cause instanceof PreservationError) throw cause;
@@ -47180,16 +47301,126 @@ function read(ctx, sources, texts) {
 		return valid ? found : void 0;
 	});
 }
+function literalFormattingLinks(text) {
+	if (!/[*_~`]/.test(text) || /[<>]/.test(text)) return void 0;
+	const tree = fromMarkdown(`x ${text}`, {
+		extensions: [gfmAutolinkLiteral(), { disable: { null: [
+			"attention",
+			"codeText",
+			"htmlText",
+			"labelStartLink",
+			"labelStartImage",
+			"characterEscape",
+			"characterReference",
+			"autolink"
+		] } }],
+		mdastExtensions: [gfmAutolinkLiteralFromMarkdown()]
+	});
+	const paragraph = tree.children[0];
+	if (tree.children.length !== 1 || paragraph?.type !== "paragraph") return void 0;
+	const found = [];
+	let readable = "";
+	for (const child of paragraph.children) if (child.type === "text") readable += child.value;
+	else if (child.type === "link" && child.children.every((node) => node.type === "text")) {
+		const start = readable.length - 2;
+		for (const node of child.children) if (node.type === "text") readable += node.value;
+		found.push([
+			start,
+			readable.length - 2,
+			child.url
+		]);
+	} else return void 0;
+	return readable === `x ${text}` ? found : void 0;
+}
 function literals(ctx, texts) {
 	const possible = texts.map((text) => /www\.|https?:\/\/|@/i.test(text));
 	const candidates = texts.filter((_, index) => possible[index]);
 	const found = read(ctx, candidates.map((text) => text.replace(/[\\`[\]<>]/g, "\\$&")), candidates);
-	return texts.map((_, index) => possible[index] ? found.shift() : []);
+	return texts.map((text, index) => possible[index] ? endAtBackticks(ctx, found.shift() ?? literalFormattingLinks(text), text) : []);
+}
+function endAtBackticks(ctx, found, text) {
+	if (!found) return found;
+	const result = [];
+	for (const [start, end, href] of found) {
+		const parts = text.slice(start, end).split("`");
+		if (parts.length === 1) {
+			result.push([
+				start,
+				end,
+				href
+			]);
+			continue;
+		}
+		let at = start;
+		literals(ctx, parts).forEach((links, index) => {
+			for (const [from, to, target] of links ?? []) result.push([
+				at + from,
+				at + to,
+				target
+			]);
+			at += parts[index].length + 1;
+		});
+	}
+	return result;
 }
 function angleHref(text) {
 	if (/^[a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s<>\u0000-\u001f]*$/.test(text)) return text;
 	if (/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(text)) return `mailto:${text}`;
 }
+function completedAngle(tr, chars, from, to) {
+	if (to !== from + 1) return void 0;
+	const end = chars.findIndex((char) => char?.pos === from);
+	const closing = chars[end];
+	if (closing?.text !== ">" || closing.marks.some((mark) => mark.type.spec.code) || closing.link && closing.form !== "literal") return void 0;
+	let start = end - 1;
+	for (; start >= 0; start--) {
+		const char = chars[start];
+		if (!char || char.marks.some((mark) => mark.type.spec.code) || char.link && char.form !== "literal" || !sameMarks(char.marks, closing.marks) || /[\s>]/.test(char.text)) return void 0;
+		if (char.text === "<") break;
+	}
+	if (start < 0) return void 0;
+	const href = angleHref(chars.slice(start + 1, end).map((char) => char.text).join(""));
+	if (!href) return void 0;
+	const opening = chars[start].pos;
+	return tr.delete(from, to).delete(opening, opening + 1).addMark(opening, from - 1, tr.doc.type.schema.marks.link.create({
+		href,
+		form: "angle"
+	})).removeStoredMark(tr.doc.type.schema.marks.link);
+}
+function closeAngleEnds(tr, transactions) {
+	const steps = transactions.flatMap((transaction) => transaction.steps.map((step, index) => ({
+		doc: transaction.docs[index],
+		map: step.getMap()
+	})));
+	steps.forEach(({ doc, map }, index) => {
+		const remaining = new Mapping(steps.slice(index + 1).map(({ map }) => map));
+		map.forEach((from, to, start, end) => {
+			if (from !== to || start === end) return;
+			const at = doc.resolve(from);
+			const before = at.nodeBefore?.marks.find((mark) => mark.attrs.form === "angle");
+			const after = at.nodeAfter?.marks.find((mark) => mark.attrs.form === "angle");
+			if (before && after && before.eq(after)) return;
+			for (const mark of [before, after]) if (mark) tr.removeMark(remaining.map(start, 1), remaining.map(end, -1), mark);
+		});
+	});
+}
+function codeAngles(tr, edited) {
+	const spans = [];
+	for (const block of edited) tr.doc.nodesBetween(block.pos, block.pos + block.block.nodeSize, (node, pos) => {
+		if (!node.isText || !node.marks.some((mark) => mark.type.spec.code)) return;
+		const link = node.marks.find((mark) => mark.attrs.form === "angle");
+		if (link) spans.push({
+			from: pos,
+			to: pos + node.nodeSize,
+			marks: node.marks.filter((mark) => mark !== link)
+		});
+	});
+	for (const { from, to, marks } of spans.reverse()) {
+		tr.removeMark(from, to, tr.doc.type.schema.marks.link);
+		tr.insert(to, tr.doc.type.schema.text(">", marks));
+		tr.insert(from, tr.doc.type.schema.text("<", marks));
+	}
+}
 function wantedLinks(ctx, chars, from, to) {
 	const wanted = /* @__PURE__ */ new Map();
 	const released = /* @__PURE__ */ new Set();
@@ -47214,6 +47445,20 @@ function wantedLinks(ctx, chars, from, to) {
 		}
 		index = end;
 	}
+	const codeAddress = (index) => {
+		const char = chars[index];
+		return char?.form === "literal" && char.marks.some((mark) => mark.type.spec.code);
+	};
+	for (let index = 0; index < chars.length;) {
+		if (!codeAddress(index)) {
+			index++;
+			continue;
+		}
+		let end = index + 1;
+		while (end < chars.length && codeAddress(end)) end++;
+		if (end >= from && index <= to) for (let at = index; at < end; at++) wanted.set(at, null);
+		index = end;
+	}
 	const free = (index) => {
 		const char = chars[index];
 		return char !== void 0 && !char.marks.some((mark) => mark.type.spec.code) && (released.has(index) || char.form !== "angle" && !(char.link && !char.form));
@@ -47360,8 +47605,25 @@ var autolinkLiterals = $prose((ctx) => new Plugin({
 	key: new PluginKey("autolinkLiterals"),
 	appendTransaction(transactions, oldState, newState) {
 		if (!transactions.some((tr) => tr.docChanged)) return null;
+		const base = newState.tr;
+		const written = transactions.every(isWrittenEdit);
+		if (written) {
+			closeAngleEnds(base, transactions);
+			codeAngles(base, editedBlocks(oldState.doc, base.doc));
+		}
+		let edited = editedBlocks(oldState.doc, base.doc);
+		if (written && edited.length === 1) {
+			const { pos, block, from, to } = edited[0];
+			const start = base.steps.length;
+			if (completedAngle(base, characters(block, pos + 1), from, to)) {
+				edited = editedBlocks(oldState.doc, base.doc);
+				const mapping = base.mapping.slice(start);
+				edited[0].from = Math.min(edited[0].from, mapping.map(from, -1));
+				edited[0].to = Math.max(edited[0].to, mapping.map(to, 1));
+			}
+		}
 		const blocks = [];
-		for (const { pos, block, from, to } of editedBlocks(oldState.doc, newState.doc)) {
+		for (const { pos, block, from, to } of edited) {
 			const chars = characters(block, pos + 1);
 			const index = (at) => {
 				const found = chars.findIndex((char) => char !== void 0 && char.pos >= at);
@@ -47374,15 +47636,32 @@ var autolinkLiterals = $prose((ctx) => new Plugin({
 				wanted
 			});
 		}
-		if (!blocks.length) return null;
-		let tr = linked(newState.tr, blocks);
-		const failed = blocks.filter((block) => !readsBack(ctx, tr, block.pos));
-		if (!failed.length) return tr;
-		for (const block of failed) for (const [at, want] of block.wanted) if (want?.form === "literal") block.wanted.set(at, null);
-		tr = linked(newState.tr, blocks);
-		const kept = blocks.filter((block) => readsBack(ctx, tr, block.pos));
-		if (kept.length === blocks.length) return tr;
-		return kept.length ? linked(newState.tr, kept) : null;
+		if (!base.steps.length && !blocks.length) return null;
+		const stored = base.storedMarks ?? newState.storedMarks;
+		const finish = (tr) => {
+			if (stored) tr.setStoredMarks(stored);
+			if (!tr.steps.length) return null;
+			for (const plugin of newState.plugins) if (plugin.spec.isInputRules) for (const transaction of transactions) {
+				const meta = transaction.getMeta(plugin);
+				if (meta !== void 0) tr.setMeta(plugin, meta);
+			}
+			return tr;
+		};
+		const attempt = (wanted) => {
+			const tr = newState.tr;
+			for (const step of base.steps) tr.step(step);
+			tr.setSelection(base.selection.getBookmark().resolve(tr.doc));
+			return linked(tr, wanted);
+		};
+		let tr = attempt(blocks);
+		const failed = edited.filter((block) => !readsBack(ctx, tr, block.pos));
+		if (!failed.length) return finish(tr);
+		for (const block of blocks) if (failed.some(({ pos }) => pos === block.pos)) {
+			for (const [at, want] of block.wanted) if (want?.form === "literal") block.wanted.set(at, null);
+		}
+		tr = attempt(blocks);
+		if (edited.every((block) => readsBack(ctx, tr, block.pos))) return finish(tr);
+		return null;
 	}
 }));
 //#endregion
@@ -49720,7 +49999,8 @@ function formattedOutside(node) {
 	};
 	return result;
 }
-function written(node) {
+function written(node, inTable = false) {
+	if (inTable && node.url.includes("|")) return "brackets";
 	if (bracketLinks.has(node)) return "brackets";
 	const form = formOf(node);
 	if (form === "literal" && bareLinks.has(node)) return "bare";
@@ -49736,12 +50016,12 @@ function withResourceLink(state, resourceLink, write) {
 	}
 }
 var link = (node, parent, state, info) => {
-	const form = written(node);
+	const form = written(node, state.stack.includes("tableCell"));
 	if (form === "bare") return node.children[0].value;
 	return withResourceLink(state, form === "brackets", () => handle.link(node, parent, state, info));
 };
 link.peek = (node, parent, state) => {
-	const form = written(node);
+	const form = written(node, state.stack.includes("tableCell"));
 	if (form === "bare") return node.children[0].value[0];
 	return withResourceLink(state, form === "brackets", () => handle.link.peek(node, parent, state));
 };
@@ -50096,7 +50376,11 @@ function createDialect(images, wikiLinks = false, files = false) {
 			}
 		})),
 		references,
-		wikiLinks ? wikiLinkSchema : [],
+		wikiLinks ? [
+			wikiLinkSchema,
+			wikiLinkComposition,
+			wikiLinkInputRule
+		] : [],
 		callouts,
 		comments,
 		hiddenCommentEditing,
@@ -56557,7 +56841,7 @@ var InkKitEditor = class InkKitEditor {
 					return true;
 				}
 			}));
-		}).use(labelsCtx).use(instance.pasteController.plugin).use(visibleClipboard).use($prose(() => instance.suggestions.plugin())).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-yHFoKkKz.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($prose(() => instance.suggestions.plugin())).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-DOQk0Eyj.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: {

package/dist/chunks/{highlight-yHFoKkKz.js → highlight-DOQk0Eyj.js}

@@ -1,4 +1,4 @@
-import { a as Decoration, c as PluginKey, d as __toESM, i as $prose, o as DecorationSet, s as Plugin, u as __commonJSMin } from "./core-Bvj0PMMi.js";
+import { a as Decoration, c as PluginKey, d as __toESM, i as $prose, o as DecorationSet, s as Plugin, u as __commonJSMin } from "./core-DP-izJDM.js";
 //#region node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/arduino.js
 /** @type LanguageFn */
 function cPlusPlus(hljs) {

package/dist/core.js

@@ -1,2 +1,2 @@
-import { r as InkKitError, t as InkKitEditor } from "./chunks/core-Bvj0PMMi.js";
+import { r as InkKitError, t as InkKitEditor } from "./chunks/core-DP-izJDM.js";
 export { InkKitEditor, InkKitError };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerMermaid, r as InkKitError, t as InkKitEditor } from "./chunks/core-Bvj0PMMi.js";
+import { n as registerMermaid, r as InkKitError, t as InkKitEditor } from "./chunks/core-DP-izJDM.js";
 //#region src/index.ts
 registerMermaid(async () => (await import("mermaid")).default);
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicayzer/inkkit",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",