@meowdown/core 0.74.1 → 0.75.0

package/dist/index.d.ts

@@ -808,14 +808,23 @@ type PostEmbedSnapshot = {
 export declare function parsePostEmbedSnapshot(value: unknown): PostEmbedSnapshot | undefined;
 //#endregion
 //#region src/extensions/image.d.ts
-type ImageUrlResolver = (src: string) => string | undefined;
+/**
+ * Maps a markdown `src` to a displayable URL, or `undefined` to skip rendering
+ * that image. May return a `Promise` when the answer needs data that is not
+ * loaded yet: the image appears once it resolves, and a rejection or an
+ * `undefined` result leaves the source without a preview.
+ */
+type ImageUrlResolver = (src: string) => string | undefined | Promise<string | undefined>;
 /**
  * Options for {@link defineImage}.
  */
 interface ImageOptions {
   /**
    * Map a markdown `src` to a displayable URL, or `undefined` to skip rendering
-   * that image. Defaults to `defaultResolveImageUrl`.
+   * that image. May return a `Promise`; while it is pending, an image whose
+   * `width` and `height` are both persisted shows a sized placeholder so the
+   * resolved image does not shift the layout. Defaults to
+   * `defaultResolveImageUrl`.
    */
   resolveImageUrl?: ImageUrlResolver;
   /**
@@ -1482,6 +1491,12 @@ interface LinkHoverOptions {
  * software keyboard.
  */
 export declare function defineLinkHoverHandler(onHoverChange: LinkHoverHandler, { canLeave }?: LinkHoverOptions): PlainExtension;
+/**
+ * Tell the link hover handler that the user dismissed the UI it opened. The
+ * link under the pointer stays silent until the pointer leaves it, so a
+ * pending hover cannot reopen the UI.
+ */
+export declare function dismissLinkHover(state: EditorState): void;
 //#endregion
 //#region src/extensions/link-paste.d.ts
 /**
@@ -1674,4 +1689,4 @@ export declare function getSelectedText(state: EditorState): string;
  */
 export declare function getVirtualElementFromRange(view: EditorView, range: PositionRange): VirtualElement;
 //#endregion
-export { type AcceptPendingReplacementOptions, type CheckRoundTripOptions, type CodeBlockAttrs, type CodeBlockFenceStyle, type CodeToken, type DocToMarkdownOptions, type EditorConfig, type EditorExtension, type EditorExtensionOptions, type ExitBoundaryHandler, type ExitBoundaryOptions, type FileClickHandler, type FileClickPayload, type FileInfo, type FileInfoResolver, type FileLinkOptions, type FileLinkPayload, type FileLinkResolver, type FilePasteHandler, type FilePasteOptions, type FileSaveErrorHandler, type FileViewOptions, type FollowLinkHandlers, type ImageClickHandler, type ImageClickPayload, type ImageOptions, type InlineMarkContext, type InlineMarkOptions, type KaTeXRender, type LanguageItem, type LinkAttrs, type LinkClickHandler, type LinkClickPayload, type LinkCopyHandler, type LinkCopyPayload, type LinkEditHandler, type LinkEditOptions, type LinkHoverHandler, type LinkHoverOptions, type LinkPreview, type LinkPreviewResolver, type LinkUnit, type ListMarker, type MarkChunk, type MarkMode, type MarkName, type MarkdownToDocOptions, type MdFileAttrs, type MdImageAttrs, type MdLinkTextAttrs, type MdMathAttrs, type MdWikilinkAttrs, type MeowdownCodeBlockAttrs, type MeowdownHTMLCommentAttrs, type MeowdownListAttrs, type MeowdownTableCellAttrs, type NodeName, type ParsedWikiEmbed, type PendingReplacement, type PendingReplacementEvent, type PendingReplacementHandler, type PendingReplacementMode, type PendingReplacementOutcome, type PlaceholderOptions, type PositionRange, type PostEmbedSnapshot, Priority, type ReferenceDefinition, type ReferenceDefinitionIndex, type ReferenceDefinitions, type RoundTripFidelity, type SearchStatus, type SearchStatusHandler, type StartPendingReplacementOptions, type TableColumnAlign, type TagClickHandler, type TagClickPayload, type TypedEditor, type TypedMarkBuilders, type VirtualElement, type WikiEmbedOptions, type WikiEmbedResolution, type WikiEmbedResolver, type WikilinkClickHandler, type WikilinkClickPayload, type WikilinkHoverHandler, type WikilinkHoverHit, type WikilinkOptions, type WikilinkPayload, type WikilinkResolution, type WikilinkResolver, type XPostMediaClickHandler, type XPostResolver, type YouTubeVideoClickHandler, type YouTubeVideoResolver, defineCodeBlockPreviewPlugin, definePlaceholder, defineSearchStatusHandler, getSearchStatus, isCodeBlockPreviewHiddenDecoration, withPriority };
+export { type AcceptPendingReplacementOptions, type CheckRoundTripOptions, type CodeBlockAttrs, type CodeBlockFenceStyle, type CodeToken, type DocToMarkdownOptions, type EditorConfig, type EditorExtension, type EditorExtensionOptions, type ExitBoundaryHandler, type ExitBoundaryOptions, type FileClickHandler, type FileClickPayload, type FileInfo, type FileInfoResolver, type FileLinkOptions, type FileLinkPayload, type FileLinkResolver, type FilePasteHandler, type FilePasteOptions, type FileSaveErrorHandler, type FileViewOptions, type FollowLinkHandlers, type ImageClickHandler, type ImageClickPayload, type ImageOptions, type ImageUrlResolver, type InlineMarkContext, type InlineMarkOptions, type KaTeXRender, type LanguageItem, type LinkAttrs, type LinkClickHandler, type LinkClickPayload, type LinkCopyHandler, type LinkCopyPayload, type LinkEditHandler, type LinkEditOptions, type LinkHoverHandler, type LinkHoverOptions, type LinkPreview, type LinkPreviewResolver, type LinkUnit, type ListMarker, type MarkChunk, type MarkMode, type MarkName, type MarkdownToDocOptions, type MdFileAttrs, type MdImageAttrs, type MdLinkTextAttrs, type MdMathAttrs, type MdWikilinkAttrs, type MeowdownCodeBlockAttrs, type MeowdownHTMLCommentAttrs, type MeowdownListAttrs, type MeowdownTableCellAttrs, type NodeName, type ParsedWikiEmbed, type PendingReplacement, type PendingReplacementEvent, type PendingReplacementHandler, type PendingReplacementMode, type PendingReplacementOutcome, type PlaceholderOptions, type PositionRange, type PostEmbedSnapshot, Priority, type ReferenceDefinition, type ReferenceDefinitionIndex, type ReferenceDefinitions, type RoundTripFidelity, type SearchStatus, type SearchStatusHandler, type StartPendingReplacementOptions, type TableColumnAlign, type TagClickHandler, type TagClickPayload, type TypedEditor, type TypedMarkBuilders, type VirtualElement, type WikiEmbedOptions, type WikiEmbedResolution, type WikiEmbedResolver, type WikilinkClickHandler, type WikilinkClickPayload, type WikilinkHoverHandler, type WikilinkHoverHit, type WikilinkOptions, type WikilinkPayload, type WikilinkResolution, type WikilinkResolver, type XPostMediaClickHandler, type XPostResolver, type YouTubeVideoClickHandler, type YouTubeVideoResolver, defineCodeBlockPreviewPlugin, definePlaceholder, defineSearchStatusHandler, getSearchStatus, isCodeBlockPreviewHiddenDecoration, withPriority };

package/dist/index.js

@@ -84,20 +84,86 @@ function getIsComposing() {
 }
 
 //#endregion
-//#region src/utils/transaction.ts
+//#region src/utils/input-modality.ts
+const KEYBOARD_MODALITY_KEYS = /* @__PURE__ */ new Set([
+	"ArrowLeft",
+	"ArrowRight",
+	"ArrowUp",
+	"ArrowDown",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+]);
+let lastIsTouchInput = false;
+let lastIsPointerSelection = false;
+const listeners = /* @__PURE__ */ new Set();
+function setIsTouchInput(isTouchInput) {
+	if (isTouchInput === lastIsTouchInput) return;
+	lastIsTouchInput = isTouchInput;
+	for (const listener of listeners) listener();
+}
+function handlePointerDown(event) {
+	const target = event.target;
+	lastIsPointerSelection = target instanceof Element && !!target.closest(".ProseMirror");
+	const pointerType = event.pointerType;
+	if (pointerType === "mouse") setIsTouchInput(false);
+	else if (pointerType === "touch" || pointerType === "pen") setIsTouchInput(true);
+}
+function handleKeyDown(event) {
+	if (getIsComposing() || event.isComposing) return;
+	lastIsPointerSelection = false;
+	if (KEYBOARD_MODALITY_KEYS.has(event.key) || event.metaKey || event.ctrlKey) setIsTouchInput(false);
+}
+if (typeof window !== "undefined") {
+	window.addEventListener("pointerdown", handlePointerDown, {
+		capture: true,
+		passive: true
+	});
+	window.addEventListener("keydown", handleKeyDown, {
+		capture: true,
+		passive: true
+	});
+}
 /**
-* Whether the given transaction is selection transactions directly caused by mouse or touch input.
+* Whether the user last drove the selection with a finger (or pen) on the
+* screen, as opposed to precise input (hardware keyboard navigation).
 *
-* See https://code.haverbeke.berlin/prosemirror/prosemirror-view/src/tag/1.42.2/src/input.ts#L191
+* Starts as `false` and follows the events; a touch device flips it on the
+* first tap, which necessarily precedes any caret. Only navigation keys and
+* modifier combos flip it back: letter keys are ignored because a software
+* keyboard sends them too, and the software keyboard's own caret gestures (a
+* spacebar long-press drag) reach the page as bare `selectionchange` events
+* with no key or touch events at all, so staying on the previous value is the
+* correct reading for them.
+*/
+function getIsTouchInput() {
+	return lastIsTouchInput;
+}
+/**
+* Whether the next selection change in an editor comes from a pointer: the
+* last `pointerdown` landed inside an editor and no key was pressed since.
+*/
+function getIsPointerSelection() {
+	return lastIsPointerSelection;
+}
+/**
+* Calls `listener` whenever {@link getIsTouchInput} may report a new value.
 */
-function isPointerSelectionTransaction(tr) {
-	return !!tr.getMeta("pointer");
+function onIsTouchInputChange(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
 }
+
+//#endregion
+//#region src/utils/transaction.ts
 /**
 * Whether any of the given transactions are selection transactions directly caused by mouse or touch input.
 */
 function hasPointerSelectionTransaction(transactions) {
-	return transactions.some(isPointerSelectionTransaction);
+	return getIsPointerSelection() && transactions.some((tr) => tr.selectionSet && !tr.docChanged);
 }
 
 //#endregion
@@ -512,9 +578,8 @@ function createCaretSnapPlugin(marks) {
 			if (markNames.length === 0) return null;
 			const selection = newState.selection;
 			if (!isTextSelection(selection)) return null;
-			const isPointer = hasPointerSelectionTransaction(transactions);
 			if (!selection.empty) {
-				if (!isPointer) return null;
+				if (!hasPointerSelectionTransaction(transactions)) return null;
 				const from = getMarkRangeStrictlyAround(newState, selection.from, markNames)?.from ?? selection.from;
 				const to = getMarkRangeStrictlyAround(newState, selection.to, markNames)?.to ?? selection.to;
 				if (from === selection.from && to === selection.to) return null;
@@ -524,6 +589,7 @@ function createCaretSnapPlugin(marks) {
 			}
 			const range = getMarkRangeStrictlyAround(newState, selection.head, markNames);
 			if (!range) return null;
+			const isPointer = hasPointerSelectionTransaction(transactions);
 			const head = getUnitEdge(range, oldState.selection.head, selection.head, isPointer);
 			return newState.tr.setSelection(TextSelection.create(newState.doc, head));
 		}
@@ -614,6 +680,9 @@ function handleMouseDown(view, event) {
 	const { doc } = view.state;
 	const lastBlock = doc.lastChild;
 	if (!lastBlock || acceptsCaretAtEnd(lastBlock)) return false;
+	let bottom = lastBlock;
+	while (bottom && !bottom.isTextblock && !isNodeOfType(bottom, "table")) bottom = bottom.lastChild;
+	if (bottom && bottom.content.size === 0 && acceptsCaretAtEnd(bottom)) return false;
 	const lastBlockDOM = view.nodeDOM(doc.content.size - lastBlock.nodeSize);
 	if (!(lastBlockDOM instanceof HTMLElement)) return false;
 	if (event.clientY <= lastBlockDOM.getBoundingClientRect().bottom) return false;
@@ -628,7 +697,8 @@ function handleMouseDown(view, event) {
 }
 /**
 * A press below the last block appends an empty paragraph and puts the caret
-* in it, when that block would otherwise keep the caret inside itself.
+* in it, when that block would otherwise keep the caret inside itself and
+* does not end in an empty line.
 */
 function defineClickBelow() {
 	return definePlugin(new Plugin({
@@ -3469,8 +3539,8 @@ function createSnapPlugin() {
 			if (getMarkMode(newState) !== "hide") return null;
 			const selection = newState.selection;
 			if (!isTextSelection(selection)) return null;
-			const isPointer = hasPointerSelectionTransaction(transactions);
 			if (selection.empty) {
+				const isPointer = hasPointerSelectionTransaction(transactions);
 				const next = getRestPosition(newState, oldState.selection.head, selection.head, isPointer);
 				if (next === selection.head) return null;
 				return newState.tr.setSelection(TextSelection.create(newState.doc, next));
@@ -3922,12 +3992,8 @@ var ImageMarkView = class {
 		this.#contentDOM.className = "md-image-view-content md-atom-view-content";
 		this.#contentDOM.dataset.testid = "image-source";
 		for (const [name, value] of Object.entries(NON_PROSE_ATTRS)) this.#contentDOM.setAttribute(name, value);
-		const preview = this.#renderPreview();
-		if (preview) {
-			preview.contentEditable = "false";
-			this.#dom.appendChild(preview);
-		}
 		this.#dom.appendChild(this.#contentDOM);
+		this.#mountPreview();
 	}
 	get dom() {
 		return this.#dom;
@@ -3954,22 +4020,67 @@ var ImageMarkView = class {
 		this.#destroyed = true;
 	}
 	/**
-	* Build the inline preview for the image `src`: a post-embed card or a
-	* resizable `<img>`.
+	* Mount the inline preview for the image `src`, if any: a post-embed card, a
+	* resizable `<img>`, or, while an asynchronous resolver is pending and the
+	* size is persisted, an empty box of that size that the image later fills.
 	*/
-	#renderPreview() {
+	#mountPreview() {
 		const { src } = this.#attrs;
-		const wrapper = document.createElement("span");
-		wrapper.className = "md-image-view-preview md-atom-view-preview";
 		const kind = matchEmbed(src);
 		if (kind) {
+			const wrapper = this.#createWrapper();
 			wrapper.dataset.testid = `${kind}-embed`;
 			wrapper.dataset.postEmbed = kind;
 			wrapper.appendChild(this.#buildPostEmbed(kind, src));
-			return wrapper;
+			this.#insertPreview(wrapper);
+			return;
 		}
-		const url = (this.#resolveImageUrl ?? defaultResolveImageUrl)(src);
-		if (!url) return void 0;
+		const resolved = (this.#resolveImageUrl ?? defaultResolveImageUrl)(src);
+		if (resolved instanceof Promise) {
+			const placeholder = this.#hasPersistedSize() ? this.#renderImage(null) : void 0;
+			if (placeholder) this.#insertPreview(placeholder);
+			resolved.then((url) => this.#settle(placeholder, url), () => this.#settle(placeholder, void 0));
+			return;
+		}
+		if (resolved) this.#insertPreview(this.#renderImage(resolved));
+	}
+	#hasPersistedSize() {
+		return this.#attrs.width != null && this.#attrs.height != null;
+	}
+	/**
+	* Apply a resolver's asynchronous answer: fill the placeholder with the
+	* image, mount the image from scratch, or drop the placeholder when there is
+	* nothing to show. A view destroyed in the meantime (its `src` changed, or it
+	* left the document) ignores the answer.
+	*/
+	#settle(placeholder, url) {
+		if (this.#destroyed) return;
+		if (!url) {
+			placeholder?.remove();
+			this.#resizableRoot = void 0;
+			return;
+		}
+		if (placeholder && this.#resizableRoot) this.#attachImage(this.#resizableRoot, url);
+		else this.#insertPreview(this.#renderImage(url));
+	}
+	#createWrapper() {
+		const wrapper = document.createElement("span");
+		wrapper.className = "md-image-view-preview md-atom-view-preview";
+		return wrapper;
+	}
+	/**
+	* Insert a preview in front of the source text.
+	*/
+	#insertPreview(preview) {
+		preview.contentEditable = "false";
+		this.#dom.insertBefore(preview, this.#contentDOM);
+	}
+	/**
+	* The resizable image preview. `null` builds the sized box without its
+	* `<img>`, for an asynchronous resolver to fill through `#attachImage`.
+	*/
+	#renderImage(url) {
+		const wrapper = this.#createWrapper();
 		wrapper.dataset.testid = "image-preview";
 		wrapper.appendChild(this.#buildResizableImage(url));
 		return wrapper;
@@ -4052,6 +4163,25 @@ var ImageMarkView = class {
 		root.className = "md-image-resizable";
 		root.dataset.testid = "image-resizable";
 		root.setAttribute("data-loading", "");
+		applySize(root, this.#attrs.width, this.#attrs.height);
+		const handle = document.createElement("prosekit-resizable-handle");
+		handle.className = "md-image-resize-handle";
+		handle.setAttribute("position", "bottom-right");
+		handle.addEventListener("click", (event) => event.stopPropagation());
+		root.appendChild(handle);
+		root.addEventListener("resizeEnd", (event) => {
+			const { width: nextWidth, height: nextHeight } = event.detail;
+			commitImageSize(this.#view, this.#contentDOM, nextWidth, nextHeight);
+		});
+		this.#resizableRoot = root;
+		if (url != null) this.#attachImage(root, url);
+		return root;
+	}
+	/**
+	* Put the `<img>` for `url` into a resizable root built by
+	* `#buildResizableImage`, in front of its handle.
+	*/
+	#attachImage(root, url) {
 		const image = document.createElement("img");
 		image.src = url;
 		image.alt = this.#attrs.alt;
@@ -4067,19 +4197,8 @@ var ImageMarkView = class {
 		image.addEventListener("error", () => {
 			root.removeAttribute("data-loading");
 		});
-		root.appendChild(image);
-		const handle = document.createElement("prosekit-resizable-handle");
-		handle.className = "md-image-resize-handle";
-		handle.setAttribute("position", "bottom-right");
-		handle.addEventListener("click", (event) => event.stopPropagation());
-		root.appendChild(handle);
-		root.addEventListener("resizeEnd", (event) => {
-			const { width: nextWidth, height: nextHeight } = event.detail;
-			commitImageSize(this.#view, this.#contentDOM, nextWidth, nextHeight);
-		});
-		this.#resizableRoot = root;
+		root.prepend(image);
 		this.#image = image;
-		return root;
 	}
 };
 /**
@@ -8478,32 +8597,29 @@ const EDITOR_KEY_BINDINGS = {
 
 //#endregion
 //#region src/extensions/mark-hover.ts
+const IDLE = { kind: "idle" };
+function getHit(phase) {
+	return phase.kind === "active" || phase.kind === "leaving" ? phase.hit : void 0;
+}
 /**
-* Delegate hover tracking for a rendered mark to the editor root.
-*
-* Movement within a mark is de-duplicated. The active hit is also revalidated
-* after every editor update, so deleting, replacing, or rewriting a hovered
-* mark emits leave even when the pointer itself never moves. Destroying the
-* editor or removing the extension emits leave as well.
-*
-* With `tap`, a touch tap enters too. The browser is the tap recognizer:
-* only a recognized stationary single-finger tap synthesizes the
-* compatibility mouse events and the trailing `click`; scrolls, drags,
-* long-presses, and multi-finger gestures never produce them.
+* The tracked element the pointer is on, if any.
 */
-function defineMarkHoverHandler(config) {
-	const { openDelay, closeDelay, tap } = config;
+function getPointerElement(phase) {
+	switch (phase.kind) {
+		case "pending":
+		case "dismissed": return phase.element;
+		case "active": return phase.hit.element;
+		default: return;
+	}
+}
+function createHoverTracker(config) {
+	const { openDelay, closeDelay } = config;
+	let phase = IDLE;
 	/**
-	* What `onHoverChange` last received, while that is a hit.
+	* Runs exactly while the phase is `pending` or `leaving`.
 	*/
-	let emitted;
 	let timer;
 	/**
-	* The element of a scheduled enter, `null` for a scheduled leave,
-	* `undefined` when nothing is scheduled.
-	*/
-	let scheduledElement;
-	/**
 	* The type of the pointer that spawned the current event sequence:
 	* compatibility mouse events carry no pointer type of their own.
 	*/
@@ -8514,127 +8630,201 @@ function defineMarkHoverHandler(config) {
 	const findPayloadForElement = (view, element) => {
 		return config.findPayloadForElement ? config.findPayloadForElement(view, element) : config.findPayloadAt(view.state, view.posAtDOM(element, 0));
 	};
-	const cancel = () => {
+	/**
+	* The only transition. It restarts the timer the next phase needs and
+	* reports a change of the hit element.
+	*/
+	const go = (next) => {
 		clearTimeout(timer);
-		scheduledElement = void 0;
+		const previousHit = getHit(phase);
+		phase = next;
+		if (next.kind === "pending") timer = setTimeout(finishOpen, openDelay);
+		if (next.kind === "leaving") timer = setTimeout(finishLeave, closeDelay);
+		const hit = getHit(next);
+		if (hit?.element !== previousHit?.element) config.onHoverChange(hit);
 	};
-	const emit = (hit) => {
-		cancel();
-		if (!hit && !emitted) return;
-		emitted = hit;
-		config.onHoverChange(hit);
+	const finishOpen = () => {
+		if (phase.kind !== "pending") return;
+		const { element, view } = phase;
+		const payload = element.isConnected ? findPayloadForElement(view, element) : void 0;
+		go(payload == null ? IDLE : {
+			kind: "active",
+			hit: {
+				payload,
+				element
+			}
+		});
 	};
-	const scheduleLeave = () => {
-		cancel();
-		scheduledElement = null;
-		const fire = () => {
-			if (config.canLeave?.() === false) {
-				timer = setTimeout(fire, closeDelay);
+	const finishLeave = () => {
+		if (phase.kind !== "leaving") return;
+		go(config.canLeave?.() === false ? phase : IDLE);
+	};
+	const startPending = (view, element) => {
+		if (findPayloadForElement(view, element) == null) return;
+		go({
+			kind: "pending",
+			element,
+			view
+		});
+	};
+	const handleOver = (view, event) => {
+		const element = findClosestMark(event.target);
+		if (!element || !view.dom.contains(element)) return;
+		switch (phase.kind) {
+			case "idle": return startPending(view, element);
+			case "pending":
+			case "dismissed":
+				if (element !== phase.element) startPending(view, element);
+				return;
+			case "active":
+			case "leaving": {
+				if (element === phase.hit.element) return go({
+					kind: "active",
+					hit: phase.hit
+				});
+				const payload = findPayloadForElement(view, element);
+				if (payload != null) go({
+					kind: "active",
+					hit: {
+						payload,
+						element
+					}
+				});
 				return;
 			}
-			emit(void 0);
-		};
-		timer = setTimeout(fire, closeDelay);
+		}
+	};
+	const handleOut = (event) => {
+		const element = getPointerElement(phase);
+		if (!element) return;
+		const related = event.relatedTarget;
+		if (related instanceof Node && element.contains(related)) return;
+		go(phase.kind === "active" ? {
+			kind: "leaving",
+			hit: phase.hit
+		} : IDLE);
+	};
+	const handlePointerDown = (event) => {
+		lastPointerType = event.pointerType;
 	};
-	const enter = (view, element) => {
+	const handleMouseDown = (event) => {
+		if (lastPointerType !== "touch" || !findClosestMark(event.target)) return false;
+		event.preventDefault();
+		return true;
+	};
+	const handleClick = (view, event) => {
+		if (lastPointerType !== "touch") return false;
+		const element = findClosestMark(event.target);
+		if (!element || !view.dom.contains(element)) {
+			go(IDLE);
+			return false;
+		}
+		event.preventDefault();
 		const payload = findPayloadForElement(view, element);
-		if (payload == null) return;
-		if (emitted) {
-			emit({
+		if (payload != null) go({
+			kind: "active",
+			hit: {
 				payload,
 				element
-			});
+			}
+		});
+		return true;
+	};
+	const update = (view) => {
+		if (phase.kind === "dismissed") {
+			if (!view.dom.contains(phase.element)) go(IDLE);
 			return;
 		}
-		cancel();
-		scheduledElement = element;
-		timer = setTimeout(() => {
-			const fresh = element.isConnected ? findPayloadForElement(view, element) : void 0;
-			if (fresh == null) {
-				cancel();
-				return;
-			}
-			emit({
-				payload: fresh,
+		if (phase.kind !== "active" && phase.kind !== "leaving") return;
+		const { element } = phase.hit;
+		if (!element.isConnected || !view.dom.contains(element)) return go(IDLE);
+		const payload = findPayloadForElement(view, element);
+		if (payload == null || !config.isSamePayload(phase.hit.payload, payload)) return go(IDLE);
+		phase = {
+			kind: phase.kind,
+			hit: {
+				payload,
 				element
-			});
-		}, openDelay);
+			}
+		};
 	};
-	const handleOver = (view, event) => {
-		const element = findClosestMark(event.target);
-		if (!element || !view.dom.contains(element)) return;
-		if (element === emitted?.element) {
-			if (scheduledElement === null) cancel();
-			return;
+	const dismiss = () => {
+		switch (phase.kind) {
+			case "pending": return go({
+				kind: "dismissed",
+				element: phase.element
+			});
+			case "active": return go({
+				kind: "dismissed",
+				element: phase.hit.element
+			});
+			case "leaving": return go(IDLE);
 		}
-		if (element === scheduledElement) return;
-		enter(view, element);
 	};
-	const handleOut = (event) => {
-		const active = emitted?.element ?? scheduledElement;
-		if (!active) return;
-		const related = event.relatedTarget;
-		if (related instanceof Node && active.contains(related)) return;
-		if (emitted) scheduleLeave();
-		else cancel();
+	return {
+		handleOver,
+		handleOut,
+		handlePointerDown,
+		handleMouseDown,
+		handleClick,
+		update,
+		dismiss,
+		destroy: () => go(IDLE)
 	};
+}
+/**
+* Delegate hover tracking for a rendered mark to the editor root.
+*
+* Movement within a mark is de-duplicated. The active hit is also revalidated
+* after every editor update, so deleting, replacing, or rewriting a hovered
+* mark emits leave even when the pointer itself never moves. Destroying the
+* editor or removing the extension emits leave as well.
+*
+* With `tap`, a touch tap enters too. The browser is the tap recognizer:
+* only a recognized stationary single-finger tap synthesizes the
+* compatibility mouse events and the trailing `click`; scrolls, drags,
+* long-presses, and multi-finger gestures never produce them.
+*
+* The tracker lives in the plugin state, so `key.getState(state)?.dismiss()`
+* reaches the one tracking that editor.
+*/
+function defineMarkHoverHandler(config) {
+	const { key } = config;
 	return definePlugin(new Plugin({
-		key: config.key,
+		key,
+		state: {
+			init: () => createHoverTracker(config),
+			apply: (_tr, tracker) => tracker
+		},
 		props: { handleDOMEvents: {
 			mouseover: (view, event) => {
-				handleOver(view, event);
+				key.getState(view.state)?.handleOver(view, event);
 				return false;
 			},
-			mouseout: (_view, event) => {
-				handleOut(event);
+			mouseout: (view, event) => {
+				key.getState(view.state)?.handleOut(event);
 				return false;
 			},
-			...tap && {
-				pointerdown: (_view, event) => {
-					lastPointerType = event.pointerType;
+			...config.tap && {
+				pointerdown: (view, event) => {
+					key.getState(view.state)?.handlePointerDown(event);
 					return false;
 				},
-				mousedown: (_view, event) => {
-					if (lastPointerType !== "touch" || !findClosestMark(event.target)) return false;
-					event.preventDefault();
-					return true;
+				mousedown: (view, event) => {
+					return key.getState(view.state)?.handleMouseDown(event) ?? false;
 				},
 				click: (view, event) => {
-					if (lastPointerType !== "touch") return false;
-					const element = findClosestMark(event.target);
-					if (!element || !view.dom.contains(element)) {
-						emit(void 0);
-						return false;
-					}
-					event.preventDefault();
-					const payload = findPayloadForElement(view, element);
-					if (payload != null) emit({
-						payload,
-						element
-					});
-					return true;
+					return key.getState(view.state)?.handleClick(view, event) ?? false;
 				}
 			}
 		} },
-		view: () => ({
-			update: (view) => {
-				if (!emitted) return;
-				if (!emitted.element.isConnected || !view.dom.contains(emitted.element)) {
-					emit(void 0);
-					return;
-				}
-				const payload = findPayloadForElement(view, emitted.element);
-				if (payload == null || !config.isSamePayload(emitted.payload, payload)) {
-					emit(void 0);
-					return;
-				}
-				emitted = {
-					...emitted,
-					payload
-				};
-			},
-			destroy: () => emit(void 0)
-		})
+		view: (view) => {
+			const tracker = key.getState(view.state);
+			return {
+				update: (view) => tracker?.update(view),
+				destroy: () => tracker?.destroy()
+			};
+		}
 	}));
 }
 
@@ -8674,6 +8864,14 @@ function defineLinkHoverHandler(onHoverChange, { canLeave } = {}) {
 		onHoverChange
 	});
 }
+/**
+* Tell the link hover handler that the user dismissed the UI it opened. The
+* link under the pointer stays silent until the pointer leaves it, so a
+* pending hover cannot reopen the UI.
+*/
+function dismissLinkHover(state) {
+	linkHoverKey.getState(state)?.dismiss();
+}
 
 //#endregion
 //#region src/utils/force-reflow.ts
@@ -8681,69 +8879,6 @@ function forceReflow(element) {
 	element.offsetWidth;
 }
 
-//#endregion
-//#region src/utils/input-modality.ts
-const KEYBOARD_MODALITY_KEYS = /* @__PURE__ */ new Set([
-	"ArrowLeft",
-	"ArrowRight",
-	"ArrowUp",
-	"ArrowDown",
-	"Home",
-	"End",
-	"PageUp",
-	"PageDown"
-]);
-let lastIsTouchInput = false;
-const listeners = /* @__PURE__ */ new Set();
-function setIsTouchInput(isTouchInput) {
-	if (isTouchInput === lastIsTouchInput) return;
-	lastIsTouchInput = isTouchInput;
-	for (const listener of listeners) listener();
-}
-function handlePointerDown(event) {
-	const pointerType = event.pointerType;
-	if (pointerType === "mouse") setIsTouchInput(false);
-	else if (pointerType === "touch" || pointerType === "pen") setIsTouchInput(true);
-}
-function handleKeyDown(event) {
-	if (getIsComposing() || event.isComposing) return;
-	if (KEYBOARD_MODALITY_KEYS.has(event.key) || event.metaKey || event.ctrlKey) setIsTouchInput(false);
-}
-if (typeof window !== "undefined") {
-	window.addEventListener("pointerdown", handlePointerDown, {
-		capture: true,
-		passive: true
-	});
-	window.addEventListener("keydown", handleKeyDown, {
-		capture: true,
-		passive: true
-	});
-}
-/**
-* Whether the user last drove the selection with a finger (or pen) on the
-* screen, as opposed to precise input (hardware keyboard navigation).
-*
-* Starts as `false` and follows the events; a touch device flips it on the
-* first tap, which necessarily precedes any caret. Only navigation keys and
-* modifier combos flip it back: letter keys are ignored because a software
-* keyboard sends them too, and the software keyboard's own caret gestures (a
-* spacebar long-press drag) reach the page as bare `selectionchange` events
-* with no key or touch events at all, so staying on the previous value is the
-* correct reading for them.
-*/
-function getIsTouchInput() {
-	return lastIsTouchInput;
-}
-/**
-* Calls `listener` whenever {@link getIsTouchInput} may report a new value.
-*/
-function onIsTouchInputChange(listener) {
-	listeners.add(listener);
-	return () => {
-		listeners.delete(listener);
-	};
-}
-
 //#endregion
 //#region src/extensions/virtual-caret.ts
 const key = new PluginKey("meowdown-virtual-caret");
@@ -9041,4 +9176,4 @@ function getVirtualElementFromRange(view, range) {
 }
 
 //#endregion
-export { EDITOR_KEY_BINDINGS, Priority, buildFileMarkdown, checkRoundTrip, codeBlockLanguages, collectReferenceDefinitions, defaultResolveImageUrl, defaultResolveXPost, defaultResolveYouTubeVideo, defineBulletAfterHeading, defineCodeBlockPreviewPlugin, defineCodeBlockSyntaxHighlight, defineEditorExtension, defineEmbedPaste, defineExitBoundaryHandler, defineFileClickHandler, defineFilePaste, defineFileView, defineFollowLinkHandler, defineHTMLComment, defineImage, defineImageClickHandler, defineLinkClickHandler, defineLinkCommands, defineLinkEditKeymap, defineLinkHoverHandler, defineLinkPaste, defineMath, definePendingReplacementHandler, definePlaceholder, defineReadonly, defineSearchStatusHandler, defineSubstitution, defineTagClickHandler, defineViewAttributes, defineVirtualCaret, defineWikilinkClickHandler, defineWikilinkHoverHandler, defineWikilinkTrigger, defineXPostMediaClickHandler, defineYouTubeVideoClickHandler, docToMarkdown, formatFileSize, formatSizedWikiEmbed, getCodeTokens, getEditorConfig, getFileKind, getIsComposing, getLinkText, getLinkUnitAt, getMarkBuilders, getPendingReplacement, getSearchStatus, getSelectedText, getTableColumnAlign, getTextblockDisplayText, getVirtualElementFromRange, inlineTextToMarkChunks, inlineTextToMarkChunksWithContext, insertLink, isCodeBlockPreviewHiddenDecoration, isLinkTextForHref, isMarkOfType, isModEvent, isNodeOfType, isReferenceDefinitionNode, isSelectionInTableCell, loadKaTeX, markdownToDoc, normalizeHref, parsePostEmbedSnapshot, parseWikiEmbed, removeLink, renderMathInto, updateEditorConfig, updateLink, wikiEmbedBasename, withPriority };
+export { EDITOR_KEY_BINDINGS, Priority, buildFileMarkdown, checkRoundTrip, codeBlockLanguages, collectReferenceDefinitions, defaultResolveImageUrl, defaultResolveXPost, defaultResolveYouTubeVideo, defineBulletAfterHeading, defineCodeBlockPreviewPlugin, defineCodeBlockSyntaxHighlight, defineEditorExtension, defineEmbedPaste, defineExitBoundaryHandler, defineFileClickHandler, defineFilePaste, defineFileView, defineFollowLinkHandler, defineHTMLComment, defineImage, defineImageClickHandler, defineLinkClickHandler, defineLinkCommands, defineLinkEditKeymap, defineLinkHoverHandler, defineLinkPaste, defineMath, definePendingReplacementHandler, definePlaceholder, defineReadonly, defineSearchStatusHandler, defineSubstitution, defineTagClickHandler, defineViewAttributes, defineVirtualCaret, defineWikilinkClickHandler, defineWikilinkHoverHandler, defineWikilinkTrigger, defineXPostMediaClickHandler, defineYouTubeVideoClickHandler, dismissLinkHover, docToMarkdown, formatFileSize, formatSizedWikiEmbed, getCodeTokens, getEditorConfig, getFileKind, getIsComposing, getLinkText, getLinkUnitAt, getMarkBuilders, getPendingReplacement, getSearchStatus, getSelectedText, getTableColumnAlign, getTextblockDisplayText, getVirtualElementFromRange, inlineTextToMarkChunks, inlineTextToMarkChunksWithContext, insertLink, isCodeBlockPreviewHiddenDecoration, isLinkTextForHref, isMarkOfType, isModEvent, isNodeOfType, isReferenceDefinitionNode, isSelectionInTableCell, loadKaTeX, markdownToDoc, normalizeHref, parsePostEmbedSnapshot, parseWikiEmbed, removeLink, renderMathInto, updateEditorConfig, updateLink, wikiEmbedBasename, withPriority };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meowdown/core",
   "type": "module",
-  "version": "0.74.1",
+  "version": "0.75.0",
   "license": "MIT",
   "repository": {
     "type": "git",