@threadlabs/looma 0.31.0 → 0.31.2

package/editor/chunks/extensions.js

@@ -1,6 +1,6 @@
 import { n as TABLE_CELL_BACKGROUND_PRESETS } from "./table-backgrounds.js";
 import { _ as parseLoomaAttributes, b as splitLoomaFrontmatter, c as LOOMA_CONTAINER_NAMES, d as formatLoomaAttributes, f as loomaCodeFence, g as normalizeLoomaChipTone, h as normalizeLoomaCalloutTone, i as referenceDisplay, l as applyLoomaCodeNotation, m as loomaHeadingSlug, n as LoomaReferencePresentation, p as loomaContainerMarker, r as getReferenceDisplay, s as LOOMA_CHIP_TONES, t as LoomaReference, u as assignLoomaHeadingIds, v as parseLoomaFenceInfo, y as readLoomaAttributes } from "./reference-display.js";
-import { Extension, Mark, Node as Node$1, callOrReturn, canInsertNode, combineTransactionSteps, escapeForRegEx, findChildren, findChildrenInRange, findParentNodeClosestToPos, getAttributes, getChangedRanges, getExtensionField, getMarksBetween, getText, getTextSerializersFromSchema, isNodeEmpty, isNodeSelection, markInputRule, markPasteRule, mergeAttributes, nodeInputRule, textInputRule, textblockTypeInputRule, wrappingInputRule } from "@tiptap/core";
+import { Extension, InputRule, Mark, Node as Node$1, PasteRule, callOrReturn, canInsertNode, combineTransactionSteps, escapeForRegEx, findChildren, findChildrenInRange, findParentNodeClosestToPos, getAttributes, getChangedRanges, getExtensionField, getMarksBetween, getText, getTextSerializersFromSchema, isNodeEmpty, isNodeSelection, markInputRule, markPasteRule, mergeAttributes, nodeInputRule, textInputRule, textblockTypeInputRule, wrappingInputRule } from "@tiptap/core";
 import { NodeSelection, Plugin, PluginKey, Selection, TextSelection } from "@tiptap/pm/state";
 import { Decoration, DecorationSet } from "@tiptap/pm/view";
 import { DOMParser, DOMSerializer, Fragment, Node as Node$2, Slice } from "@tiptap/pm/model";
@@ -477,13 +477,180 @@ var LoomaFigcaption = Node$1.create({
 //#endregion
 //#region src/editor/extensions/footnote.ts
 var labelFrom = (href, prefix) => href?.startsWith(`#${prefix}`) ? href.slice(prefix.length + 1) : null;
+/** A footnote label as Looma Markdown reads it in `[^label]`: no whitespace and no `]`. */
+var LOOMA_FOOTNOTE_LABEL = /^[^\s\]]+$/;
+var REFERENCE = "loomaFootnoteReference";
+var NOTES = "loomaFootnotes";
+var NOTE = "loomaFootnote";
+var isLabel = (label) => LOOMA_FOOTNOTE_LABEL.test(label);
+/** Every label a reference or note in `doc` uses. */
+function usedLabels(doc) {
+	const labels = /* @__PURE__ */ new Set();
+	doc.descendants((node) => {
+		if (node.type.name === REFERENCE || node.type.name === NOTE) labels.add(String(node.attrs.label));
+	});
+	return labels;
+}
+/**
+* The first note for `label` in `doc` and its position.
+* @failure Returns null when no note has that label.
+*/
+function findLoomaFootnote(doc, label) {
+	let found = null;
+	doc.descendants((node, position) => {
+		if (found) return false;
+		if (node.type.name === NOTE && node.attrs.label === label) {
+			found = {
+				node,
+				position
+			};
+			return false;
+		}
+	});
+	return found;
+}
+function mapReferences(node, change) {
+	if (node.type.name === REFERENCE) return change(node);
+	if (node.isLeaf) return node;
+	const children = [];
+	node.content.forEach((child) => children.push(mapReferences(child, change)));
+	return node.copy(Fragment.from(children));
+}
+function noteAt(doc, position) {
+	const $position = doc.resolve(position);
+	for (let depth = $position.depth; depth > 0; depth--) {
+		const node = $position.node(depth);
+		if (node.type.name === NOTE) return {
+			node,
+			start: $position.before(depth)
+		};
+	}
+	return null;
+}
+/**
+* Keeps footnotes on Looma Markdown's rule, so the saved HTML is the HTML Looma Markdown renders for
+* the same document. Notes are numbered by first reference, in the text and then in the notes, and
+* every reference carries its note's number and its place among that note's references. The notes
+* live in one `loomaFootnotes` section at the end of the document, in number order. A note no
+* reference points to leaves the document; a reference with no note gets one back, the note it last
+* had in this editor (so cutting a reference and pasting it keeps its note) or an empty one.
+* @invariant Changing nothing but text inside a note never rebuilds the section.
+*/
+function footnoteTransaction(state, known) {
+	const { doc, schema } = state;
+	const sections = [];
+	const notes = /* @__PURE__ */ new Map();
+	const body = [];
+	doc.descendants((node, position) => {
+		if (node.type.name === NOTES) {
+			sections.push({
+				node,
+				position
+			});
+			node.forEach((note) => {
+				if (!notes.has(note.attrs.label)) notes.set(note.attrs.label, note);
+			});
+			return false;
+		}
+		if (node.type.name === REFERENCE) body.push({
+			node,
+			position
+		});
+	});
+	if (!sections.length && !body.length) return null;
+	const order = [];
+	const counts = /* @__PURE__ */ new Map();
+	const numbered = (reference) => {
+		const label = String(reference.attrs.label);
+		if (!counts.has(label)) order.push(label);
+		counts.set(label, (counts.get(label) ?? 0) + 1);
+		const attrs = {
+			...reference.attrs,
+			number: order.indexOf(label) + 1,
+			occurrence: counts.get(label)
+		};
+		return attrs.number === reference.attrs.number && attrs.occurrence === reference.attrs.occurrence ? reference : reference.type.create(attrs, null, reference.marks);
+	};
+	const transaction = state.tr;
+	for (const { node, position } of body) {
+		const next = numbered(node);
+		if (next !== node) transaction.setNodeMarkup(position, void 0, next.attrs);
+	}
+	const built = [];
+	for (let index = 0; index < order.length; index++) {
+		const label = order[index];
+		const note = notes.get(label) ?? known.get(label) ?? schema.nodes[NOTE].create({ label }, schema.nodes.paragraph.create());
+		built.push(mapReferences(note, numbered));
+	}
+	const wanted = built.map((note) => note.attrs.count === counts.get(note.attrs.label) ? note : note.type.create({
+		...note.attrs,
+		count: counts.get(note.attrs.label)
+	}, note.content));
+	for (const note of [...notes.values(), ...wanted]) known.set(note.attrs.label, note);
+	const section = wanted.length ? schema.nodes[NOTES].create(null, wanted) : null;
+	const last = doc.lastChild?.type.name === NOTES ? {
+		node: doc.lastChild,
+		position: doc.content.size - doc.lastChild.nodeSize
+	} : null;
+	if (!(section && last && sections.length === 1 && last.node.eq(section)) && (sections.length || section)) {
+		const { selection } = state;
+		const inside = noteAt(doc, selection.from);
+		const keep = inside && selection.to <= inside.start + inside.node.nodeSize ? {
+			label: inside.node.attrs.label,
+			start: inside.start
+		} : null;
+		for (const { node, position } of [...sections].reverse()) if (node !== last?.node) transaction.delete(position, position + node.nodeSize);
+		if (last) {
+			const position = transaction.mapping.map(last.position);
+			if (section) transaction.replaceWith(position, position + last.node.nodeSize, section);
+			else transaction.delete(position, position + last.node.nodeSize);
+		} else if (section) transaction.insert(transaction.doc.content.size, section);
+		const moved = keep && findLoomaFootnote(transaction.doc, keep.label);
+		if (keep && moved) {
+			const json = selection.toJSON();
+			json.anchor += moved.position - keep.start;
+			if (json.head !== void 0) json.head += moved.position - keep.start;
+			try {
+				transaction.setSelection(Selection.fromJSON(transaction.doc, json));
+			} catch {}
+		}
+	}
+	return transaction.docChanged ? transaction : null;
+}
+function appendBackLinks(item, label, number, count) {
+	const document = item.ownerDocument;
+	let paragraph = item.lastElementChild;
+	if (paragraph?.nodeName !== "P") item.append(paragraph = document.createElement("p"));
+	for (let occurrence = 1; occurrence <= count; occurrence++) {
+		const link = document.createElement("a");
+		link.setAttribute("href", `#fnref:${label}${occurrence > 1 ? `:${occurrence}` : ""}`);
+		link.setAttribute("data-footnote-backref", "");
+		link.setAttribute("aria-label", `Back to reference ${number}${occurrence > 1 ? `-${occurrence}` : ""}`);
+		link.append("↩");
+		if (occurrence > 1) link.append(Object.assign(document.createElement("sup"), { textContent: String(occurrence) }));
+		paragraph.append(" ", link);
+	}
+}
+var FootnoteSerializer = class extends DOMSerializer {
+	serializeFragment(fragment, options = {}, target) {
+		const dom = super.serializeFragment(fragment, options, target);
+		fragment.forEach((node, _offset, index) => {
+			if (node.type.name === NOTE) appendBackLinks(dom.childNodes[index], String(node.attrs.label), index + 1, Number(node.attrs.count) || 1);
+		});
+		return dom;
+	}
+};
+function installSerializer(schema) {
+	if (!(schema.cached.domSerializer instanceof FootnoteSerializer)) schema.cached.domSerializer = new FootnoteSerializer(DOMSerializer.nodesFromSchema(schema), DOMSerializer.marksFromSchema(schema));
+}
 /**
-* A footnote reference, `[^label]`, saved as `<sup><a data-footnote-ref>`.
-* @invariant `label` names its note. `number` and `occurrence` are the note's number and this
-* reference's place among the note's references, as the document had them when it loaded.
+* A footnote reference, `[^label]`, saved as `<sup><a data-footnote-ref>`. Typing or pasting
+* `[^label]` makes one; the note it needs is created with it.
+* @invariant `label` names its note. `number` and `occurrence`, the note's number and this
+* reference's place among the note's references, follow the document's order on every change.
 */
 var LoomaFootnoteReference = Node$1.create({
-	name: "loomaFootnoteReference",
+	name: REFERENCE,
 	group: "inline",
 	inline: true,
 	atom: true,
@@ -531,16 +698,59 @@ var LoomaFootnoteReference = Node$1.create({
 	},
 	renderText({ node }) {
 		return `[^${node.attrs.label}]`;
+	},
+	addInputRules() {
+		return [new InputRule({
+			find: /\[\^([^\s\]]+)\]$/,
+			handler: ({ state, range, match }) => {
+				state.tr.replaceWith(range.from, range.to, this.type.create({ label: match[1] }));
+			}
+		})];
+	},
+	addPasteRules() {
+		return [new PasteRule({
+			find: /\[\^([^\s\]]+)\]/g,
+			handler: ({ state, range, match }) => {
+				state.tr.replaceWith(range.from, range.to, this.type.create({ label: match[1] }));
+			}
+		})];
+	},
+	addNodeView() {
+		return ({ node, editor }) => {
+			const dom = document.createElement("sup");
+			dom.dataset.loomaFootnoteRef = "";
+			dom.contentEditable = "false";
+			dom.setAttribute("role", "button");
+			dom.setAttribute("aria-haspopup", "dialog");
+			dom.setAttribute("aria-disabled", String(!editor.isEditable));
+			dom.tabIndex = 0;
+			const number = dom.appendChild(document.createElement("a"));
+			const update = (next) => {
+				if (next.type !== node.type) return false;
+				const shown = String(next.attrs.number ?? next.attrs.label);
+				dom.dataset.label = String(next.attrs.label);
+				if (number.textContent !== shown) number.textContent = shown;
+				dom.setAttribute("aria-label", `Footnote ${shown}`);
+				return true;
+			};
+			update(node);
+			return {
+				dom,
+				update,
+				stopEvent: (event) => event.type === "click" || event.type === "keydown"
+			};
+		};
 	}
 });
 /**
 * The document's notes, saved as `<section data-footnotes>` with its `<ol>`.
-* @invariant It holds only footnotes; Markdown writes it as definitions after the text.
+* @invariant It holds only footnotes and stays the document's last block, one section in number order.
+* @ownership It owns footnote numbering and the back-links in serialized HTML for the whole editor.
 */
 var LoomaFootnotes = Node$1.create({
-	name: "loomaFootnotes",
+	name: NOTES,
 	group: "block",
-	content: "loomaFootnote+",
+	content: `${NOTE}+`,
 	isolating: true,
 	parseHTML() {
 		return [{
@@ -565,29 +775,121 @@ var LoomaFootnotes = Node$1.create({
 			],
 			["ol", 0]
 		];
+	},
+	onBeforeCreate() {
+		installSerializer(this.editor.schema);
+	},
+	onCreate() {
+		const transaction = footnoteTransaction(this.editor.state, this.storage.known);
+		if (transaction) this.editor.view.dispatch(transaction.setMeta("addToHistory", false));
+	},
+	addStorage: () => ({ known: /* @__PURE__ */ new Map() }),
+	addProseMirrorPlugins() {
+		return [new Plugin({
+			appendTransaction: (transactions, _oldState, state) => transactions.some((transaction) => transaction.docChanged) ? footnoteTransaction(state, this.storage.known) : null,
+			props: { transformPasted: (slice) => {
+				const kept = [];
+				slice.content.forEach((node) => {
+					if (node.type.name === NOTES) node.forEach((note) => {
+						this.storage.known.set(note.attrs.label, note);
+					});
+					else kept.push(node);
+				});
+				if (!kept.length || kept.length === slice.content.childCount) return slice;
+				const content = Fragment.from(kept);
+				const open = Slice.maxOpen(content);
+				return new Slice(content, kept[0] === slice.content.firstChild ? slice.openStart : open.openStart, kept.at(-1) === slice.content.lastChild ? slice.openEnd : open.openEnd);
+			} }
+		})];
+	},
+	addCommands() {
+		return {
+			insertLoomaFootnote: (label) => ({ state, tr, dispatch }) => {
+				const name = label ?? (() => {
+					const used = usedLabels(state.doc);
+					let next = 1;
+					while (used.has(String(next))) next++;
+					return String(next);
+				})();
+				const { $from, $to } = state.selection;
+				if (!isLabel(name) || !$from.parent.canReplaceWith($from.index(), $to.index(), state.schema.nodes[REFERENCE])) return false;
+				if (!dispatch) return true;
+				tr.replaceSelectionWith(state.schema.nodes[REFERENCE].create({ label: name }));
+				if (!findLoomaFootnote(tr.doc, name)) {
+					const note = state.schema.nodes[NOTE].create({ label: name }, state.schema.nodes.paragraph.create());
+					if (tr.doc.lastChild?.type.name === NOTES) tr.insert(tr.doc.content.size - 1, note);
+					else tr.insert(tr.doc.content.size, state.schema.nodes[NOTES].create(null, note));
+					tr.setSelection(TextSelection.create(tr.doc, tr.doc.content.size - 3));
+				}
+				tr.scrollIntoView();
+				return true;
+			},
+			renameLoomaFootnote: (from, to) => ({ state, tr, dispatch }) => {
+				if (!isLabel(to) || usedLabels(state.doc).has(to) || !findLoomaFootnote(state.doc, from)) return false;
+				if (dispatch) state.doc.descendants((node, position) => {
+					if ((node.type.name === REFERENCE || node.type.name === NOTE) && node.attrs.label === from) tr.setNodeMarkup(position, void 0, {
+						...node.attrs,
+						label: to
+					});
+				});
+				return true;
+			},
+			goToLoomaFootnote: () => ({ state, tr, dispatch }) => {
+				const { selection } = state;
+				const reference = selection instanceof NodeSelection ? selection.node : selection.empty ? selection.$from.nodeBefore : null;
+				if (reference?.type.name === REFERENCE) {
+					const note = findLoomaFootnote(state.doc, reference.attrs.label);
+					if (!note) return false;
+					if (dispatch) tr.setSelection(Selection.near(state.doc.resolve(note.position + note.node.nodeSize - 1), -1)).scrollIntoView();
+					return true;
+				}
+				const note = noteAt(state.doc, selection.from);
+				let first = -1;
+				if (note) state.doc.descendants((node, position) => {
+					if (first >= 0) return false;
+					if (node.type.name === REFERENCE && node.attrs.label === note.node.attrs.label) first = position;
+				});
+				if (first < 0) return false;
+				if (dispatch) tr.setSelection(TextSelection.create(state.doc, first + 1)).scrollIntoView();
+				return true;
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-Alt-f": () => this.editor.commands.insertLoomaFootnote(),
+			"Mod-Alt-n": () => this.editor.commands.goToLoomaFootnote()
+		};
 	}
 });
 /**
 * One note, `[^label]: …`, saved as `<li id="fn:label">`.
-* @invariant It exists only inside `LoomaFootnotes`. Its back-links are presentation that Looma
-* Markdown renders, so the editor reads past them and saves none.
+* @invariant It exists only inside `LoomaFootnotes`. `count` is how many references point to it. Its
+* back-links are presentation: the editor reads past them and writes them only into saved HTML.
 */
 var LoomaFootnote = Node$1.create({
-	name: "loomaFootnote",
+	name: NOTE,
 	content: "block+",
 	defining: true,
 	addAttributes() {
-		return { label: {
-			default: "",
-			parseHTML: (element) => labelFrom(`#${element.id}`, "fn:") ?? "",
-			renderHTML: () => ({})
-		} };
+		return {
+			label: {
+				default: "",
+				parseHTML: (element) => labelFrom(`#${element.id}`, "fn:") ?? "",
+				renderHTML: () => ({})
+			},
+			count: {
+				default: 1,
+				parseHTML: (element) => element.querySelectorAll("a[data-footnote-backref]").length || 1,
+				renderHTML: () => ({})
+			}
+		};
 	},
 	parseHTML() {
 		return [{
 			tag: "li",
 			priority: 1100,
-			context: "loomaFootnotes/"
+			context: `${NOTES}/`
 		}, {
 			tag: "a[data-footnote-backref]",
 			priority: 1100,
@@ -10392,7 +10694,8 @@ function looksLikeMarkdown(value) {
 			"image",
 			"strong_open",
 			"looma_chip",
-			"looma_mention"
+			"looma_mention",
+			"looma_footnote_ref"
 		].includes(child.type)));
 	});
 }
@@ -10476,8 +10779,11 @@ var LoomaSmartPaste = Extension.create({
 			const plainText = event.clipboardData.getData("text/plain");
 			if (!plainText.trim()) return false;
 			if (hasRichClipboardStructure(event.clipboardData.getData("text/html"))) return false;
-			const slice = documentSlice(view.state.schema, plainText);
+			let slice = documentSlice(view.state.schema, plainText);
 			if (!slice) return false;
+			view.someProp("transformPasted", (transform) => {
+				slice = transform(slice, view, true);
+			});
 			if (slice.size === 0) return true;
 			const transaction = view.state.tr.replaceSelection(slice).scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste");
 			view.dispatch(transaction);
@@ -10849,6 +11155,26 @@ var TableHeader = Node$1.create({
 });
 //#endregion
 //#region src/editor/extensions/table-formatting.ts
+/** Table chrome lives outside the horizontal scroller, within the table's document block. */
+var LoomaTableView = class extends TableView {
+	toolbarHost;
+	constructor(node, cellMinWidth) {
+		super(node, cellMinWidth);
+		const scroller = this.dom;
+		this.dom = document.createElement("div");
+		this.dom.dataset.loomaTableBlock = "";
+		this.toolbarHost = document.createElement("div");
+		this.toolbarHost.dataset.loomaTableToolbarHost = "";
+		this.toolbarHost.contentEditable = "false";
+		this.dom.append(scroller, this.toolbarHost);
+	}
+	ignoreMutation(mutation) {
+		return mutation.type !== "selection" && this.toolbarHost.contains(mutation.target) || super.ignoreMutation(mutation);
+	}
+	stopEvent(event) {
+		return event.target instanceof globalThis.Node && this.toolbarHost.contains(event.target);
+	}
+};
 /**
 * Looma's table behavior policy: resizable columns, stable minimum cell width,
 * and no independently resizable trailing column. The narrow handle is also a
@@ -10859,6 +11185,7 @@ var TableHeader = Node$1.create({
 */
 var LoomaTable = Table.configure({
 	resizable: true,
+	View: LoomaTableView,
 	handleWidth: 3,
 	cellMinWidth: 112,
 	lastColumnResizable: false
@@ -11785,6 +12112,20 @@ function getDefaultSlashCommands(onOpenImagePicker, onOpenChipEditor, onOpenLink
 				editor.chain().focus().deleteRange(range).insertLoomaTableOfContents().run();
 			}
 		},
+		{
+			title: "Footnote",
+			description: "Numbered note at the end of the document",
+			icon: "superscript",
+			keywords: [
+				"footnote",
+				"note",
+				"reference",
+				"citation"
+			],
+			command: ({ editor, range }) => {
+				editor.chain().focus().deleteRange(range).insertLoomaFootnote().run();
+			}
+		},
 		{
 			title: "Expand",
 			description: "Collapsible section with a summary",
@@ -11852,6 +12193,7 @@ function getDefaultSlashCommands(onOpenImagePicker, onOpenChipEditor, onOpenLink
 			"Image",
 			"Table",
 			"Table of contents",
+			"Footnote",
 			"Expand"
 		].includes(command.title) ? "Insertions" : "Basic blocks",
 		isAvailable: (context) => canRunDefaultCommand(command.title, context)
@@ -11887,6 +12229,7 @@ function canRunDefaultCommand(title, { editor, range }) {
 			withHeaderRow: true
 		}).run();
 		case "Table of contents": return chain.insertLoomaTableOfContents().run();
+		case "Footnote": return chain.insertLoomaFootnote().run();
 		case "Expand": return chain.insertLoomaExpand().run();
 		case "Divider": return chain.setHorizontalRule().run();
 		default: return chain.run();
@@ -12093,4 +12436,4 @@ function createLoomaSlashCommandExtension(options = {}) {
 	});
 }
 //#endregion
-export { LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS as $, filterLoomaMentionItems as A, LoomaFootnote as B, loomaMarkdownToHtml as C, createLoomaMentionExtension as D, LoomaMentionSuggestionPluginKey as E, LoomaTableOfContents as F, LoomaExpand as G, LoomaFootnotes as H, getTableOfContentsEntries as I, LoomaChip as J, revealLoomaExpandAt as K, normalizeTableOfContentsConfig as L, LoomaImage as M, normalizeImageDimension as N, DEFAULT_MENTION_RESULT_LIMIT as O, normalizeImagePlacement as P, LOOMA_ACTIVE_BLOCK_CLASS as Q, LoomaTab as R, loomaMarkdownFromDoc as S, siteRelativeHref as T, LoomaFigcaption as U, LoomaFootnoteReference as V, LoomaFigure as W, LoomaCallout as X, normalizeLoomaChipColor as Y, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS as Z, getActiveTableCellAlignment as _, getActiveTableUiState as a, setActiveTableCellBackground as b, insertTableAtRange as c, LoomaTableKit as d, LoomaActiveBlock as et, getDefaultEditorExtensions as f, LoomaTableHeader as g, LoomaTableCell as h, getDefaultSlashCommands as i, normalizeMentionResultLimit as j, MAX_MENTION_RESULT_LIMIT as k, normalizeActiveTableColumnWidths as l, LoomaTable as m, createLoomaSlashCommandExtension as n, handleTableAction as o, getLoomaTableExtensions as p, LOOMA_CHIP_COLORS as q, filterLoomaSlashCommands as r, handleTableOverlayAction as s, LoomaSlashCommand as t, LoomaActiveBlockPluginKey as tt, shouldShowTextFormattingToolbar as u, getActiveTableCellBackground as v, createSiteRelativeLinks as w, LoomaSmartPaste as x, setActiveTableCellAlignment as y, LoomaTabs as z };
+export { LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS as $, filterLoomaMentionItems as A, LOOMA_FOOTNOTE_LABEL as B, loomaMarkdownToHtml as C, createLoomaMentionExtension as D, LoomaMentionSuggestionPluginKey as E, LoomaTableOfContents as F, LoomaFigcaption as G, LoomaFootnoteReference as H, getTableOfContentsEntries as I, revealLoomaExpandAt as J, LoomaFigure as K, normalizeTableOfContentsConfig as L, LoomaImage as M, normalizeImageDimension as N, DEFAULT_MENTION_RESULT_LIMIT as O, normalizeImagePlacement as P, LoomaCallout as Q, LoomaTab as R, loomaMarkdownFromDoc as S, siteRelativeHref as T, LoomaFootnotes as U, LoomaFootnote as V, findLoomaFootnote as W, LoomaChip as X, LOOMA_CHIP_COLORS as Y, normalizeLoomaChipColor as Z, getActiveTableCellAlignment as _, getActiveTableUiState as a, setActiveTableCellBackground as b, insertTableAtRange as c, LoomaTableKit as d, LOOMA_ACTIVE_BLOCK_CLASS as et, getDefaultEditorExtensions as f, LoomaTableHeader as g, LoomaTableCell as h, getDefaultSlashCommands as i, normalizeMentionResultLimit as j, MAX_MENTION_RESULT_LIMIT as k, normalizeActiveTableColumnWidths as l, LoomaTable as m, createLoomaSlashCommandExtension as n, LoomaActiveBlock as nt, handleTableAction as o, getLoomaTableExtensions as p, LoomaExpand as q, filterLoomaSlashCommands as r, LoomaActiveBlockPluginKey as rt, handleTableOverlayAction as s, LoomaSlashCommand as t, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS as tt, shouldShowTextFormattingToolbar as u, getActiveTableCellBackground as v, createSiteRelativeLinks as w, LoomaSmartPaste as x, setActiveTableCellAlignment as y, LoomaTabs as z };

package/editor/expressmark.js

@@ -408,7 +408,7 @@ function toBareNode(node, path, context) {
 				value: string(attrs.label)
 			};
 		case "loomaFootnotes": return block("container", [], { subType: "footnotes" });
-		case "loomaFootnote": return block("container", ["label"], {
+		case "loomaFootnote": return block("container", ["label", "count"], {
 			subType: "footnote",
 			title: title(string(attrs.label))
 		});

package/editor/extensions/footnote.d.ts

@@ -1,18 +1,51 @@
 import { Node } from "@tiptap/core";
+import { type Node as ProseMirrorNode } from "@tiptap/pm/model";
+/** A footnote label as Looma Markdown reads it in `[^label]`: no whitespace and no `]`. */
+export declare const LOOMA_FOOTNOTE_LABEL: RegExp;
 /**
- * A footnote reference, `[^label]`, saved as `<sup><a data-footnote-ref>`.
- * @invariant `label` names its note. `number` and `occurrence` are the note's number and this
- * reference's place among the note's references, as the document had them when it loaded.
+ * The first note for `label` in `doc` and its position.
+ * @failure Returns null when no note has that label.
+ */
+export declare function findLoomaFootnote(doc: ProseMirrorNode, label: string): {
+    node: ProseMirrorNode;
+    position: number;
+} | null;
+/**
+ * A footnote reference, `[^label]`, saved as `<sup><a data-footnote-ref>`. Typing or pasting
+ * `[^label]` makes one; the note it needs is created with it.
+ * @invariant `label` names its note. `number` and `occurrence`, the note's number and this
+ * reference's place among the note's references, follow the document's order on every change.
  */
 export declare const LoomaFootnoteReference: Node<any, any>;
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        loomaFootnotes: {
+            /**
+             * Inserts a reference at the selection. A new label (the next free number when none is given)
+             * also gets an empty note, and the caret moves into it.
+             */
+            insertLoomaFootnote: (label?: string) => ReturnType;
+            /** Gives a footnote's note and every reference to it a new, unused label. */
+            renameLoomaFootnote: (from: string, to: string) => ReturnType;
+            /**
+             * From a reference (selected, or just before the caret) to the end of its note; from inside a
+             * note to just after its first reference.
+             */
+            goToLoomaFootnote: () => ReturnType;
+        };
+    }
+}
 /**
  * The document's notes, saved as `<section data-footnotes>` with its `<ol>`.
- * @invariant It holds only footnotes; Markdown writes it as definitions after the text.
+ * @invariant It holds only footnotes and stays the document's last block, one section in number order.
+ * @ownership It owns footnote numbering and the back-links in serialized HTML for the whole editor.
  */
-export declare const LoomaFootnotes: Node<any, any>;
+export declare const LoomaFootnotes: Node<any, {
+    known: Map<string, ProseMirrorNode>;
+}>;
 /**
  * One note, `[^label]: …`, saved as `<li id="fn:label">`.
- * @invariant It exists only inside `LoomaFootnotes`. Its back-links are presentation that Looma
- * Markdown renders, so the editor reads past them and saves none.
+ * @invariant It exists only inside `LoomaFootnotes`. `count` is how many references point to it. Its
+ * back-links are presentation: the editor reads past them and writes them only into saved HTML.
  */
 export declare const LoomaFootnote: Node<any, any>;

package/editor/extensions/index.d.ts

@@ -11,7 +11,7 @@ export { LoomaCallout, LOOMA_CALLOUT_TONES, type LoomaCalloutTone, } from "./cal
 export { LoomaChip, LOOMA_CHIP_COLORS, normalizeLoomaChipColor, type LoomaChipColor } from "./chip.js";
 export { LoomaExpand, revealLoomaExpandAt, type LoomaExpandAttributes } from "./expand.js";
 export { LoomaFigcaption, LoomaFigure } from "./figure.js";
-export { LoomaFootnote, LoomaFootnoteReference, LoomaFootnotes } from "./footnote.js";
+export { findLoomaFootnote, LOOMA_FOOTNOTE_LABEL, LoomaFootnote, LoomaFootnoteReference, LoomaFootnotes } from "./footnote.js";
 export { LoomaTab, LoomaTabs } from "./tabs.js";
 export { LoomaTableOfContents, getTableOfContentsEntries, normalizeTableOfContentsConfig, type LoomaTableOfContentsConfig, type LoomaTableOfContentsEntry, type LoomaTableOfContentsFormat, } from "./table-of-contents.js";
 export { getDefaultEditorExtensions, getLoomaTableExtensions, LoomaTableKit, type DefaultEditorExtensionsOptions, type LoomaCodeLanguages, } from "./preset.js";

package/editor/extensions/index.js

@@ -1,4 +1,4 @@
 import { n as TABLE_CELL_BACKGROUND_PRESETS } from "../chunks/table-backgrounds.js";
-import { $ as LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, A as filterLoomaMentionItems, B as LoomaFootnote, C as loomaMarkdownToHtml, D as createLoomaMentionExtension, E as LoomaMentionSuggestionPluginKey, F as LoomaTableOfContents, G as LoomaExpand, H as LoomaFootnotes, I as getTableOfContentsEntries, J as LoomaChip, K as revealLoomaExpandAt, L as normalizeTableOfContentsConfig, M as LoomaImage, N as normalizeImageDimension, O as DEFAULT_MENTION_RESULT_LIMIT, P as normalizeImagePlacement, Q as LOOMA_ACTIVE_BLOCK_CLASS, R as LoomaTab, S as loomaMarkdownFromDoc, T as siteRelativeHref, U as LoomaFigcaption, V as LoomaFootnoteReference, W as LoomaFigure, X as LoomaCallout, Y as normalizeLoomaChipColor, Z as LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, _ as getActiveTableCellAlignment, a as getActiveTableUiState, b as setActiveTableCellBackground, c as insertTableAtRange, d as LoomaTableKit, et as LoomaActiveBlock, f as getDefaultEditorExtensions, g as LoomaTableHeader, h as LoomaTableCell, i as getDefaultSlashCommands, j as normalizeMentionResultLimit, k as MAX_MENTION_RESULT_LIMIT, l as normalizeActiveTableColumnWidths, m as LoomaTable, n as createLoomaSlashCommandExtension, o as handleTableAction, p as getLoomaTableExtensions, q as LOOMA_CHIP_COLORS, r as filterLoomaSlashCommands, s as handleTableOverlayAction, t as LoomaSlashCommand, tt as LoomaActiveBlockPluginKey, u as shouldShowTextFormattingToolbar, v as getActiveTableCellBackground, w as createSiteRelativeLinks, x as LoomaSmartPaste, y as setActiveTableCellAlignment, z as LoomaTabs } from "../chunks/extensions.js";
+import { $ as LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, A as filterLoomaMentionItems, B as LOOMA_FOOTNOTE_LABEL, C as loomaMarkdownToHtml, D as createLoomaMentionExtension, E as LoomaMentionSuggestionPluginKey, F as LoomaTableOfContents, G as LoomaFigcaption, H as LoomaFootnoteReference, I as getTableOfContentsEntries, J as revealLoomaExpandAt, K as LoomaFigure, L as normalizeTableOfContentsConfig, M as LoomaImage, N as normalizeImageDimension, O as DEFAULT_MENTION_RESULT_LIMIT, P as normalizeImagePlacement, Q as LoomaCallout, R as LoomaTab, S as loomaMarkdownFromDoc, T as siteRelativeHref, U as LoomaFootnotes, V as LoomaFootnote, W as findLoomaFootnote, X as LoomaChip, Y as LOOMA_CHIP_COLORS, Z as normalizeLoomaChipColor, _ as getActiveTableCellAlignment, a as getActiveTableUiState, b as setActiveTableCellBackground, c as insertTableAtRange, d as LoomaTableKit, et as LOOMA_ACTIVE_BLOCK_CLASS, f as getDefaultEditorExtensions, g as LoomaTableHeader, h as LoomaTableCell, i as getDefaultSlashCommands, j as normalizeMentionResultLimit, k as MAX_MENTION_RESULT_LIMIT, l as normalizeActiveTableColumnWidths, m as LoomaTable, n as createLoomaSlashCommandExtension, nt as LoomaActiveBlock, o as handleTableAction, p as getLoomaTableExtensions, q as LoomaExpand, r as filterLoomaSlashCommands, rt as LoomaActiveBlockPluginKey, s as handleTableOverlayAction, t as LoomaSlashCommand, tt as LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, u as shouldShowTextFormattingToolbar, v as getActiveTableCellBackground, w as createSiteRelativeLinks, x as LoomaSmartPaste, y as setActiveTableCellAlignment, z as LoomaTabs } from "../chunks/extensions.js";
 import { a as setReferenceDisplay, i as referenceDisplay, n as LoomaReferencePresentation, o as LOOMA_CALLOUT_TONES, r as getReferenceDisplay, t as LoomaReference } from "../chunks/reference-display.js";
-export { DEFAULT_MENTION_RESULT_LIMIT, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, LOOMA_ACTIVE_BLOCK_CLASS, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, LOOMA_CALLOUT_TONES, LOOMA_CHIP_COLORS, LoomaActiveBlock, LoomaActiveBlockPluginKey, LoomaCallout, LoomaChip, LoomaExpand, LoomaFigcaption, LoomaFigure, LoomaFootnote, LoomaFootnoteReference, LoomaFootnotes, LoomaImage, LoomaMentionSuggestionPluginKey, LoomaReference, LoomaReferencePresentation, LoomaSlashCommand, LoomaSmartPaste, LoomaTab, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, LoomaTableOfContents, LoomaTabs, MAX_MENTION_RESULT_LIMIT, TABLE_CELL_BACKGROUND_PRESETS, createLoomaMentionExtension, createLoomaSlashCommandExtension, createSiteRelativeLinks, filterLoomaMentionItems, filterLoomaSlashCommands, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, getReferenceDisplay, getTableOfContentsEntries, handleTableAction, handleTableOverlayAction, insertTableAtRange, loomaMarkdownFromDoc, loomaMarkdownToHtml, normalizeActiveTableColumnWidths, normalizeImageDimension, normalizeImagePlacement, normalizeLoomaChipColor, normalizeMentionResultLimit, normalizeTableOfContentsConfig, referenceDisplay, revealLoomaExpandAt, setActiveTableCellAlignment, setActiveTableCellBackground, setReferenceDisplay, shouldShowTextFormattingToolbar, siteRelativeHref };
+export { DEFAULT_MENTION_RESULT_LIMIT, LOOMA_ACTIVE_BLOCK_BLUR_GRACE_MS, LOOMA_ACTIVE_BLOCK_CLASS, LOOMA_ACTIVE_BLOCK_TYPING_IDLE_MS, LOOMA_CALLOUT_TONES, LOOMA_CHIP_COLORS, LOOMA_FOOTNOTE_LABEL, LoomaActiveBlock, LoomaActiveBlockPluginKey, LoomaCallout, LoomaChip, LoomaExpand, LoomaFigcaption, LoomaFigure, LoomaFootnote, LoomaFootnoteReference, LoomaFootnotes, LoomaImage, LoomaMentionSuggestionPluginKey, LoomaReference, LoomaReferencePresentation, LoomaSlashCommand, LoomaSmartPaste, LoomaTab, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, LoomaTableOfContents, LoomaTabs, MAX_MENTION_RESULT_LIMIT, TABLE_CELL_BACKGROUND_PRESETS, createLoomaMentionExtension, createLoomaSlashCommandExtension, createSiteRelativeLinks, filterLoomaMentionItems, filterLoomaSlashCommands, findLoomaFootnote, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, getReferenceDisplay, getTableOfContentsEntries, handleTableAction, handleTableOverlayAction, insertTableAtRange, loomaMarkdownFromDoc, loomaMarkdownToHtml, normalizeActiveTableColumnWidths, normalizeImageDimension, normalizeImagePlacement, normalizeLoomaChipColor, normalizeMentionResultLimit, normalizeTableOfContentsConfig, referenceDisplay, revealLoomaExpandAt, setActiveTableCellAlignment, setActiveTableCellBackground, setReferenceDisplay, shouldShowTextFormattingToolbar, siteRelativeHref };

package/editor/footnote-editing.d.ts

@@ -0,0 +1,46 @@
+import type { Editor } from "@tiptap/core";
+/** The footnote editor's state: the edited reference's label and its note's text. */
+export interface LoomaFootnoteEditingState {
+    readonly open: boolean;
+    readonly label: string;
+    /** The note's text, its blocks on separate lines. */
+    readonly note: string;
+    /** Whether `note` can be edited as text: the note is one paragraph of unformatted text. */
+    readonly editable: boolean;
+    /** Why the last label offered was not used, or empty. */
+    readonly error: string;
+}
+export declare const LOOMA_FOOTNOTE_EDITING_IDLE: LoomaFootnoteEditingState;
+/**
+ * The footnote editor as a state machine: it opens on one reference, writes the note's text as the
+ * author types it, and renames the footnote everywhere when a new label is committed.
+ *
+ * @ownership The host owns presentation: the popover, its anchor, and focus. This owns which footnote
+ * is edited and the document changes it makes.
+ * @failure A change after the footnote was deleted closes the editor and writes nothing. A label with
+ * a space or `]`, or one another footnote uses, is not applied; `error` says why.
+ */
+export interface LoomaFootnoteEditing {
+    readonly state: LoomaFootnoteEditingState;
+    /** The edited reference's element, for anchoring the editor, or null while it is closed. */
+    readonly element: HTMLElement | null;
+    /** Calls `listener` after every state change; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Opens on the reference at `position`.
+     * @failure Returns false, and stays as it was, when the editor is read-only or no reference is there.
+     */
+    open(position: number): boolean;
+    /** Replaces the note's text; ignored unless `state.editable`. */
+    setNote(note: string): void;
+    rename(label: string): void;
+    /** Closes the editor and moves the caret to the end of the note. */
+    goToNote(): void;
+    close(): void;
+}
+export interface LoomaFootnoteEditingOptions {
+    editor: Editor;
+    /** Read on each opening, so a host can change it while the editor runs. */
+    isEditable: () => boolean;
+}
+export declare function createFootnoteEditing(options: LoomaFootnoteEditingOptions): LoomaFootnoteEditing;

package/editor/icons.d.ts

@@ -65,6 +65,7 @@ export declare const LOOMA_ICONS: {
     settings: IconNode;
     split: IconNode;
     strikethrough: IconNode;
+    superscript: IconNode;
     tag: IconNode;
     table: IconNode;
     trash: IconNode;