@meowdown/core 0.64.1 → 0.64.3

package/dist/index.d.ts

@@ -246,31 +246,59 @@ interface MdMathAttrs {
   formula: string;
 }
 /**
- * mdPack keys for units that store no extra data; their own marks carry it.
- */
-type MdPackSimpleKey = 'bold' | 'italic' | 'code' | 'strike' | 'highlight' | 'autolink' | 'math' | 'wikilink' | 'image' | 'file';
-/**
- * Content-derived identity of one inline syntax unit. Adjacent units of the
- * same kind are kept apart by it (so they do not merge into one mark run), and
- * it stays stable when unrelated text in the block is edited, so editing one
- * unit never re-marks the others. `data` carries the unit's parsed payload (a
- * link's `href`/`title`) so callers read it off the mark instead of re-parsing
- * the text. The parser sets `slot: 1` on a unit whose pack would otherwise
- * equal the pack of the unit ending exactly where it starts; equal packs would
- * merge the two units into one mark run and one mark view.
- */
-type MdPackAttrs = ({
+ * Content-derived identity of one inline syntax unit.
+ *
+ * - `key`: the unit's kind. It keeps adjacent same-kind units apart and stays
+ *   stable when unrelated text in the block is edited, so editing one unit
+ *   never re-marks the others.
+ * - `data`: the unit's parsed data, read off the mark instead of
+ *   re-parsing the text.
+ * - `slot`: `1` when the pack would otherwise equal the pack of the unit
+ *   ending exactly where this one starts; equal packs would merge the two
+ *   units into one mark run and one mark view.
+ * - `revealInFocus`/`revealInHide`: the mark modes in which the unit's
+ *   source reveals around the caret.
+ */
+type MdPackAttrs = {
+  key: 'italic' | 'bold' | 'code' | 'del' | 'highlight';
+  data?: null;
+  slot?: 1 | null;
+  revealInFocus: true;
+  revealInHide?: null;
+} | {
   key: 'link';
   data: {
+    form: 'inline' | 'reference';
     href: string;
     title: string;
-    reference?: true;
+  } | {
+    form: 'angle';
+    href: string;
+  };
+  slot?: 1 | null;
+  revealInFocus: true;
+  revealInHide?: null;
+} | {
+  key: 'link';
+  data: {
+    form: 'bare';
+    href: string;
   };
+  slot?: 1 | null;
+  revealInFocus?: null;
+  revealInHide?: null;
+} | {
+  key: 'math';
+  data?: null;
+  slot?: 1 | null;
+  revealInFocus: true;
+  revealInHide: true;
 } | {
-  key: MdPackSimpleKey;
+  key: 'wikilink' | 'image' | 'file';
   data?: null;
-}) & {
   slot?: 1 | null;
+  revealInFocus?: null;
+  revealInHide?: null;
 };
 //#endregion
 //#region src/utils/range.d.ts
@@ -280,7 +308,7 @@ interface PositionRange {
 }
 //#endregion
 //#region src/extensions/get-link-unit-at.d.ts
-interface LinkUnit {
+interface LinkUnitBase {
   /**
    * Whole inline link, reference link, or autolink range.
    */
@@ -292,14 +320,6 @@ interface LinkUnit {
    * whose collapsed glyphs measure at bogus coordinates.
    */
   text: PositionRange;
-  /**
-   * Interior of `[ ]`. Absent for an autolink.
-   */
-  label?: PositionRange;
-  /**
-   * Interior of `( )`. What `updateLink` rewrites. Absent for an autolink.
-   */
-  dest?: PositionRange;
   /**
    * The link URL. Could be an empty string.
    */
@@ -309,6 +329,25 @@ interface LinkUnit {
    */
   title: string;
 }
+type LinkUnit = (LinkUnitBase & {
+  form: 'inline';
+  /**
+   * Interior of `[ ]`.
+   */
+  label: PositionRange;
+  /**
+   * Interior of `( )`. What `updateLink` rewrites.
+   */
+  dest: PositionRange;
+}) | (LinkUnitBase & {
+  /**
+   * A reference link or autolink resolves an href but has no editable
+   * label/dest.
+   */
+  form: 'reference' | 'angle' | 'bare';
+  label?: undefined;
+  dest?: undefined;
+});
 /**
  * The link covering `pos`, with its sub-ranges (`label`, `dest`) and parsed
  * `href`/`title`. The single query the commands and the hover/click handlers

package/dist/index.js

@@ -88,22 +88,25 @@ function hasPointerSelectionTransaction(transactions) {
 function isMarkOfType(mark, name) {
 	return mark.type.name === name;
 }
-const SYNTAX_MARK_NAMES = /* @__PURE__ */ new Set([
+function isMarkOfTypes(mark, names) {
+	return names.includes(mark.type.name);
+}
+const SYNTAX_MARK_NAMES = [
 	"mdMark",
 	"mdLinkUri",
 	"mdLinkTitle"
-]);
-const ATOM_MARK_NAMES = /* @__PURE__ */ new Set([
+];
+const ATOM_MARK_NAMES = [
 	"mdWikilink",
 	"mdImage",
 	"mdFile",
 	"mdMath"
-]);
-const ATOM_PACK_KEYS = /* @__PURE__ */ new Set([
-	"wikilink",
-	"image",
-	"file"
-]);
+];
+const ATOM_SOURCE_MARK_NAMES = [
+	"mdImage",
+	"mdWikilink",
+	"mdFile"
+];
 
 //#endregion
 //#region src/extensions/mark-mode.ts
@@ -123,9 +126,8 @@ function createMarkModePlugin(initialMode) {
 				return { "data-mark-mode": getCurrentMarkMode(state) ?? initialMode };
 			},
 			decorations: (state) => {
-				const mode = getCurrentMarkMode(state);
-				if (mode === "focus") return computeFocusDecorations(state);
-				if (mode === "hide") return computeMathRevealDecorations(state);
+				const mode = getCurrentMarkMode(state) ?? initialMode;
+				return mode === "focus" || mode === "hide" ? computeRevealDecorations(state, mode) : void 0;
 			}
 		}
 	});
@@ -137,9 +139,6 @@ function setMarkMode(mode) {
 		return true;
 	};
 }
-function defineMarkMode(mode) {
-	return union(definePlugin(createMarkModePlugin(mode)), defineCommands({ setMarkMode }));
-}
 /**
 * The active mark mode. `defineEditorExtension` always applies
 * `defineMarkMode`, so this is `undefined` only for a state built without it.
@@ -147,51 +146,49 @@ function defineMarkMode(mode) {
 function getMarkMode(state) {
 	return markModeKey.getState(state);
 }
-/**
-* In focus mode, reveal the markdown syntax of the inline unit under the caret.
-*
-* Every revealable unit (emphasis, strong, code, strikethrough, link, autolink,
-* image) carries one `mdPack` mark spanning it, so a single boundary-inclusive
-* `getMarkRange` finds the unit, returning the outermost when units nest. One
-* decoration over its range flips the hidden punctuation/url/source visible via
-* the `.show` CSS rule. Because the range covers the whole unit, a caret at
-* either edge (e.g. right after a link's `)`) still reveals it. Atom packs
-* (`ATOM_PACK_KEYS`) and `#tag` never reveal.
-*/
-function computeFocusDecorations(state) {
-	return computeRevealDecorations(state, void 0);
-}
-/**
-* In hide mode, reveal only the math unit under the caret. A math unit hides
-* its whole source (content included), so it is the one construct that must
-* still reveal in hide mode to stay editable; everything else follows the
-* hide-mode contract and never reveals.
-*/
-function computeMathRevealDecorations(state) {
-	return computeRevealDecorations(state, { key: "math" });
-}
-function computeRevealDecorations(state, packAttrs) {
-	const { selection } = state;
-	if (!selection.empty) return DecorationSet.empty;
-	const $pos = selection.$head;
+function findRevealablePack($pos, mode, direction) {
 	const { parent } = $pos;
-	if (!parent.isTextblock || parent.type.spec.code) return DecorationSet.empty;
-	const range = getRevealablePackRange(state, $pos, packAttrs);
-	if (!range) return DecorationSet.empty;
-	return DecorationSet.create(state.doc, [Decoration.inline(range.from, range.to, { class: "show" })]);
+	if (!parent.isTextblock || parent.type.spec.code) return;
+	const node = direction === -1 ? $pos.nodeBefore : $pos.nodeAfter;
+	for (const mark of node?.marks ?? []) if (isMarkOfType(mark, "mdPack")) {
+		const attrs = mark.attrs;
+		if (mode === "focus" && attrs.revealInFocus || mode === "hide" && attrs.revealInHide) return mark;
+	}
 }
-function isAtomPack(mark) {
-	return ATOM_PACK_KEYS.has(mark.attrs.key);
+/**
+* Reveal the markdown syntax of the inline units the selection touches: the
+* unit before its start and the unit after its end, which for a caret are
+* the two units meeting at it.
+*
+* Every unit carries one `mdPack` mark spanning it, so one `getMarkRange`
+* per probed pack expands it to its whole unit, and one decoration over
+* each range flips the hidden punctuation/url/source visible via the `.show`
+* CSS rule. The two probes land on the same unit when the selection sits
+* inside one (equal ranges dedupe to one decoration), and on two units at a
+* shared boundary, so the characters an edit would touch are never hidden.
+* `#tag` carries no pack and never reveals.
+*/
+function computeRevealDecorations(state, mode) {
+	const { $from, $to } = state.selection;
+	const packBefore = findRevealablePack($from, mode, -1);
+	const packAfter = findRevealablePack($to, mode, 1);
+	const ranges = [];
+	for (const [$pos, pack] of [[$from, packBefore], [$to, packAfter]]) {
+		if (!pack) continue;
+		const range = getMarkRange($pos, "mdPack", pack.attrs);
+		if (!range) continue;
+		if (ranges.some((r) => r.from === range.from && r.to === range.to)) continue;
+		ranges.push({
+			from: range.from,
+			to: range.to
+		});
+	}
+	if (ranges.length === 0) return;
+	const decorations = ranges.map((range) => Decoration.inline(range.from, range.to, { class: "show" }));
+	return DecorationSet.create(state.doc, decorations);
 }
-function getRevealablePackRange(state, $pos, packAttrs) {
-	const packType = getMarkType(state.schema, "mdPack");
-	const range = getMarkRange($pos, packType, packAttrs);
-	if (!range) return;
-	if (!isAtomPack(range.mark)) return range;
-	if ($pos.parentOffset === 0) return;
-	const before = getMarkRange(state.doc.resolve($pos.pos - 1), packType, packAttrs);
-	if (!before || before.to !== $pos.pos || isAtomPack(before.mark)) return;
-	return before;
+function defineMarkMode(mode) {
+	return union(definePlugin(createMarkModePlugin(mode)), defineCommands({ setMarkMode }));
 }
 
 //#endregion
@@ -206,7 +203,7 @@ function getCharMarks(state, pos) {
 function isHiddenChar(state, pos) {
 	const marks = getCharMarks(state, pos);
 	if (marks == null) return false;
-	return marks.some((mark) => SYNTAX_MARK_NAMES.has(mark.type.name));
+	return marks.some((mark) => isMarkOfTypes(mark, SYNTAX_MARK_NAMES));
 }
 function isInsideNonCodeTextblock(state, pos) {
 	if (pos < 0 || pos > state.doc.content.size) return false;
@@ -350,38 +347,35 @@ function resolvePosition(state, pos) {
 	return $pos;
 }
 /**
-* Returns the run of the first listed mark covering `pos`, or `undefined` when
-* none covers it. `attrs` narrows the match to marks whose attributes contain
-* it, which is how a caller picks one level out of a nested stack of the same
-* mark.
+* Returns the run of the mark covering `pos`, or `undefined` when none covers
+* it. `attrs` narrows the match to marks whose attributes contain it, which
+* is how a caller picks one level out of a nested stack of the same mark.
 */
 function getMarkRangeAt(state, pos, markName, attrs) {
 	const $pos = resolvePosition(state, pos);
 	if (!$pos) return;
-	const markNames = Array.isArray(markName) ? markName : [markName];
-	for (const name of markNames) {
-		const range = getMarkRange($pos, name, attrs);
-		if (range) return ATOM_MARK_NAMES.has(name) ? clampToUnitRange(state, $pos, range) : range;
-	}
+	return ATOM_MARK_NAMES.includes(markName) ? getAtomUnitRange(state, $pos, markName) : getMarkRange($pos, markName, attrs);
 }
 /**
-* Two identical adjacent units carry equal atom marks (only their packs differ,
-* by `slot`), so `getMarkRange`'s eq-based expansion runs across both. Clamp
-* the range to the matched child's own unit: the innermost pack covering its
-* first character. A child without a pack (a document not produced by the
-* inline parser) keeps the unclamped range.
+* The range of the atom unit touching `$pos`, preferring the child to the
+* right like `getMarkRange`. Two identical adjacent units carry equal atom
+* marks, so eq-based expansion would run across both; the unit boundary comes
+* from the innermost pack instead, which `slot` keeps distinct. A text node
+* without a pack (a document not produced by the inline parser) falls back to
+* the eq-based range. Does not support `attrs` filtering.
 */
-function clampToUnitRange(state, $pos, range) {
+function getAtomUnitRange(state, $pos, name) {
 	const parent = $pos.parent;
 	const after = parent.childAfter($pos.parentOffset);
-	const matched = after.node && range.mark.isInSet(after.node.marks) ? after : parent.childBefore($pos.parentOffset);
-	if (!matched.node) return range;
+	const matched = after.node && after.node.marks.some((mark) => isMarkOfType(mark, name)) ? after : parent.childBefore($pos.parentOffset);
+	const mark = matched.node?.marks.find((candidate) => isMarkOfType(candidate, name));
+	if (!matched.node || mark == null) return;
 	const pack = getInnermostPackRangeAt(state, $pos.start() + matched.offset);
-	if (!pack) return range;
+	if (!pack) return getMarkRange($pos, name);
 	return {
-		from: Math.max(range.from, pack.from),
-		to: Math.min(range.to, pack.to),
-		mark: range.mark
+		from: pack.from,
+		to: pack.to,
+		mark
 	};
 }
 /**
@@ -424,15 +418,6 @@ function getMarkRangeStrictlyAround(state, pos, markNames) {
 
 //#endregion
 //#region src/extensions/atom-mark-navigation.ts
-/**
-* The source marks whose mark views hide the raw text behind a rendered
-* preview (`.md-atom-view-preview`) and act as one caret stop.
-*/
-const ATOM_SOURCE_MARK_NAMES = [
-	"mdImage",
-	"mdWikilink",
-	"mdFile"
-];
 function getActiveMarkNames(marks, state) {
 	const mode = getMarkMode(state);
 	if (!mode) return [];
@@ -452,7 +437,7 @@ function getSelectedRange(state, markNames) {
 */
 function getSelectedAtomRange(state) {
 	if (!getMarkMode(state)) return;
-	return getSelectedRange(state, [...ATOM_SOURCE_MARK_NAMES]);
+	return getSelectedRange(state, ATOM_SOURCE_MARK_NAMES);
 }
 function findSelectionAcrossBlockBoundary(state, pos, markNames, direction) {
 	const $pos = state.doc.resolve(pos);
@@ -789,13 +774,13 @@ function parsePositiveInteger(raw) {
 //#endregion
 //#region src/extensions/inline-runs.ts
 function findAtomMark(marks) {
-	return marks.find((mark) => ATOM_MARK_NAMES.has(mark.type.name));
+	return marks.find((mark) => isMarkOfTypes(mark, ATOM_MARK_NAMES));
 }
 function findOwnPackMark(marks) {
 	return marks.findLast((mark) => isMarkOfType(mark, "mdPack"));
 }
 function hasSyntaxMark(marks) {
-	return marks.some((mark) => SYNTAX_MARK_NAMES.has(mark.type.name));
+	return marks.some((mark) => isMarkOfTypes(mark, SYNTAX_MARK_NAMES));
 }
 /**
 * Group a textblock's text nodes into atom units and plain runs. A unit's
@@ -2851,6 +2836,16 @@ const MARK_NAME_BY_TYPE_ID = /* @__PURE__ */ new Map([
 	[LEZER_NODE_IDS.Hashtag, "mdTag"],
 	[LEZER_NODE_IDS.WikilinkMark, "mdMark"]
 ]);
+function getGenericPackKey(type) {
+	switch (type) {
+		case LEZER_NODE_IDS.Emphasis: return "italic";
+		case LEZER_NODE_IDS.StrongEmphasis: return "bold";
+		case LEZER_NODE_IDS.InlineCode: return "code";
+		case LEZER_NODE_IDS.Strikethrough: return "del";
+		case LEZER_NODE_IDS.Highlight: return "highlight";
+		default: return;
+	}
+}
 /**
 * Walk a textblock's inline content and produce a list of mark chunks
 * with positions relative to the start of `text` (i.e. zero-based).
@@ -2913,6 +2908,7 @@ function walkNode(node, parentMarks, text, marks, out, options, context) {
 		case LEZER_NODE_IDS.Wikilink: return walkWikilink(node, parentMarks, text, marks, out);
 		case LEZER_NODE_IDS.WikiEmbed: return walkWikiEmbed(node, parentMarks, text, marks, out, options);
 		case LEZER_NODE_IDS.InlineMath: return walkMath(node, parentMarks, text, marks, out);
+		case LEZER_NODE_IDS.Autolink: return walkAutolink(node, parentMarks, text, marks, out);
 		case LEZER_NODE_IDS.URL: return walkURL(node, parentMarks, text, marks, out);
 		default: return walkGenericNode(node, parentMarks, text, marks, out, options, context);
 	}
@@ -2922,29 +2918,67 @@ function walkNode(node, parentMarks, text, marks, out, options, context) {
 * syntax marks, then recurses into its children.
 */
 function walkGenericNode(node, parentMarks, text, marks, out, options, context) {
-	const type = node.type;
-	let packKey;
-	if (type === LEZER_NODE_IDS.Emphasis) packKey = "italic";
-	else if (type === LEZER_NODE_IDS.StrongEmphasis) packKey = "bold";
-	else if (type === LEZER_NODE_IDS.InlineCode) packKey = "code";
-	else if (type === LEZER_NODE_IDS.Strikethrough) packKey = "strike";
-	else if (type === LEZER_NODE_IDS.Highlight) packKey = "highlight";
-	else if (type === LEZER_NODE_IDS.Autolink) packKey = "autolink";
-	const base = packKey ? [...parentMarks, createUnitPack(marks, out, parentMarks, node.from, { key: packKey })] : parentMarks;
-	const maybeMarkName = MARK_NAME_BY_TYPE_ID.get(type);
+	const packKey = getGenericPackKey(node.type);
+	const packMark = packKey && createUnitPack(marks, out, parentMarks, node.from, {
+		key: packKey,
+		revealInFocus: true
+	});
+	const base = packMark ? [...parentMarks, packMark] : parentMarks;
+	const maybeMarkName = MARK_NAME_BY_TYPE_ID.get(node.type);
 	const childMarks = maybeMarkName ? [...base, marks[maybeMarkName].create()] : base;
 	if (node.children.length === 0) emit(out, node.from, node.to, childMarks);
 	else walk(node.children, childMarks, node.from, node.to, text, marks, out, options, context);
 }
 /**
-* A standalone `URL` node is a GFM autolink (the address part of a real
-* `[text](url)` is handled inside `walkResolvedLink`, not here). Linkify the
-* shapes we recognize; anything else keeps the muted `mdLinkUri`.
+* Special walker for an angle autolink `<url>`. The unit's `href` lives on
+* its pack, computed from the `URL` child (`''` when the address is not
+* linkable, in which case the URL keeps the muted `mdLinkUri`). The children
+* are only the `<`/`>` marks and the `URL`, consumed right here: the `URL`
+* is a component of this unit, never a unit of its own.
+*/
+function walkAutolink(node, parentMarks, text, marks, out) {
+	const urlNode = node.children.find((child) => child.type === LEZER_NODE_IDS.URL);
+	const href = urlNode ? getAutolinkHref(text.slice(urlNode.from, urlNode.to)) ?? "" : "";
+	const base = [...parentMarks, createUnitPack(marks, out, parentMarks, node.from, {
+		key: "link",
+		data: {
+			form: "angle",
+			href
+		},
+		revealInFocus: true
+	})];
+	let pos = node.from;
+	for (const child of node.children) {
+		if (child.from > pos) emit(out, pos, child.from, base);
+		const childMark = child.type === LEZER_NODE_IDS.URL ? href ? marks.mdLinkText.create({ href }) : marks.mdLinkUri.create() : marks.mdMark.create();
+		emit(out, child.from, child.to, [...base, childMark]);
+		pos = child.to;
+	}
+	if (pos < node.to) emit(out, pos, node.to, base);
+}
+/**
+* A `URL` node reaching this walker is a standalone GFM autolink: the address
+* part of a `[text](url)` link is consumed by `walkResolvedLink`, and an
+* angle autolink's URL by `walkAutolink`. Linkify the shapes we recognize,
+* packing each as its own unit; anything else keeps the muted `mdLinkUri`.
 */
 function walkURL(node, parentMarks, text, marks, out) {
 	const href = getAutolinkHref(text.slice(node.from, node.to));
-	const mark = href ? marks.mdLinkText.create({ href }) : marks.mdLinkUri.create();
-	emit(out, node.from, node.to, [...parentMarks, mark]);
+	if (!href) {
+		emit(out, node.from, node.to, [...parentMarks, marks.mdLinkUri.create()]);
+		return;
+	}
+	emit(out, node.from, node.to, [
+		...parentMarks,
+		createUnitPack(marks, out, parentMarks, node.from, {
+			key: "link",
+			data: {
+				form: "bare",
+				href
+			}
+		}),
+		marks.mdLinkText.create({ href })
+	]);
 }
 function walkLink(node, parentMarks, text, marks, out, options, context) {
 	const parts = scanLinkParts(node);
@@ -2968,6 +3002,9 @@ function walkLink(node, parentMarks, text, marks, out, options, context) {
 * Locate the pieces of a `Link` node in Lezer's flat child list:
 *   LinkMark `[`, [label children], LinkMark `]`, LinkMark `(`, URL,
 *   optional LinkTitle, LinkMark `)`.
+*
+* An autolink inside the label also emits a `URL` child, so only a `URL`
+* after the second `LinkMark` (the `]` closing the label) is the destination.
 */
 function scanLinkParts(node) {
 	let labelFrom = -1;
@@ -2984,7 +3021,7 @@ function scanLinkParts(node) {
 			bracketCount++;
 			if (bracketCount === 1) labelFrom = child.to;
 			if (bracketCount === 2) labelTo = child.from;
-		} else if (urlNode == null && childType === LEZER_NODE_IDS.URL) urlNode = child;
+		} else if (urlNode == null && bracketCount >= 2 && childType === LEZER_NODE_IDS.URL) urlNode = child;
 		else if (titleNode == null && childType === LEZER_NODE_IDS.LinkTitle) titleNode = child;
 		else if (referenceLabelNode == null && childType === LEZER_NODE_IDS.LinkLabel) referenceLabelNode = child;
 	}
@@ -3083,17 +3120,14 @@ function walkResolvedLink(node, parts, resolution, parentMarks, text, marks, out
 	const { href, title, isReference } = resolution;
 	const linkTextMark = marks.mdLinkText.create({ href });
 	const inLabel = (pos) => labelEnd >= 0 && pos < labelEnd;
-	const data = isReference ? {
-		href,
-		title,
-		reference: true
-	} : {
-		href,
-		title
-	};
 	const pack = createUnitPack(marks, out, parentMarks, node.from, {
 		key: "link",
-		data
+		data: {
+			form: isReference ? "reference" : "inline",
+			href,
+			title
+		},
+		revealInFocus: true
 	});
 	const base = [...parentMarks, pack];
 	let pos = node.from;
@@ -3123,6 +3157,11 @@ function walkResolvedLink(node, parts, resolution, parentMarks, text, marks, out
 			pos = child.to;
 			continue;
 		}
+		if (child.type === LEZER_NODE_IDS.URL && inLabel(child.from)) {
+			emit(out, child.from, child.to, baseForChild);
+			pos = child.to;
+			continue;
+		}
 		const maybeMarkName = MARK_NAME_BY_TYPE_ID.get(child.type);
 		const childMarks = maybeMarkName ? [...baseForChild, marks[maybeMarkName].create()] : baseForChild;
 		if (child.children.length === 0) emit(out, child.from, child.to, childMarks);
@@ -3192,7 +3231,11 @@ function walkMath(node, parentMarks, text, marks, out) {
 	const formula = text.slice(markNodes[0].to, markNodes[1].from);
 	const base = [
 		...parentMarks,
-		createUnitPack(marks, out, parentMarks, node.from, { key: "math" }),
+		createUnitPack(marks, out, parentMarks, node.from, {
+			key: "math",
+			revealInFocus: true,
+			revealInHide: true
+		}),
 		marks.mdMath.create({ formula })
 	];
 	emit(out, node.from, markNodes[0].to, [...base, marks.mdMark.create()]);
@@ -3710,10 +3753,11 @@ function defineMdMath() {
 }
 /**
 * Wraps a whole inline unit. For a revealable unit (emphasis, strong, code,
-* strikethrough, link, autolink, math) focus mode reveals the unit with one
-* range lookup instead of stitching its punctuation back together; an atom
-* unit (wikilink, image, file) carries it purely as unit identity.
-* `excludes: ''` lets nested units carry two of these marks at once.
+* strikethrough, inline and angle link, math) focus mode reveals the unit
+* with one range lookup instead of stitching its punctuation back together;
+* a unit that never reveals (wikilink, image, file, bare autolink) carries
+* it as unit identity. `excludes: ''` lets nested units carry two of these
+* marks at once.
 */
 function defineMdPack() {
 	return defineMarkSpec({
@@ -3723,7 +3767,9 @@ function defineMdPack() {
 		attrs: {
 			key: {},
 			data: { default: null },
-			slot: { default: null }
+			slot: { default: null },
+			revealInFocus: { default: null },
+			revealInHide: { default: null }
 		},
 		toDOM: (mark) => {
 			return [
@@ -4105,66 +4151,66 @@ function lastMarkRunIn(state, range, markName) {
 * the `mdLinkUri` run locates the `( )` body.
 */
 function getLinkUnitAt(state, pos) {
-	const linkText = getMarkRangeAt(state, pos, "mdLinkText");
-	const pack = getMarkRangeAt(state, pos, "mdPack", { key: "link" }) ?? getMarkRangeAt(state, pos, "mdPack", { key: "autolink" });
-	const unit = pack ?? linkText;
+	const unit = getMarkRangeAt(state, pos, "mdPack", { key: "link" });
 	if (!unit) return;
-	const packAttrs = pack?.mark.attrs;
-	const href = (linkText?.mark.attrs)?.href ?? "";
-	if (!pack || packAttrs?.key !== "link") {
-		const unitRange = {
-			from: unit.from,
-			to: unit.to
+	const { data } = unit.mark.attrs;
+	const unitRange = {
+		from: unit.from,
+		to: unit.to
+	};
+	switch (data.form) {
+		case "bare": return {
+			form: "bare",
+			unit: unitRange,
+			text: unitRange,
+			href: data.href,
+			title: ""
 		};
-		return {
+		case "angle": return {
+			form: "angle",
 			unit: unitRange,
-			text: packAttrs?.key === "autolink" ? lastMarkRunIn(state, unitRange, "mdLinkText") ?? {
+			text: {
 				from: unit.from + 1,
 				to: unit.to - 1
-			} : unitRange,
-			href,
-			title: ""
-		};
-	}
-	if (packAttrs.data.reference === true) {
-		const text = linkText == null ? {
-			from: unit.from,
-			to: unit.to
-		} : {
-			from: linkText.from + 1,
-			to: linkText.to
-		};
-		return {
-			unit: {
-				from: unit.from,
-				to: unit.to
 			},
-			text,
-			href: packAttrs.data.href,
-			title: packAttrs.data.title
+			href: data.href,
+			title: ""
 		};
+		case "reference": {
+			const linkText = getMarkRangeAt(state, pos, "mdLinkText");
+			return {
+				form: "reference",
+				unit: unitRange,
+				text: linkText == null ? unitRange : {
+					from: linkText.from + 1,
+					to: linkText.to
+				},
+				href: data.href,
+				title: data.title
+			};
+		}
+		case "inline": {
+			const uri = lastMarkRunIn(state, unitRange, "mdLinkUri");
+			const closeBracket = uri ? uri.from - 2 : unit.to - 3;
+			const destFrom = uri ? uri.from : unit.to - 1;
+			const label = {
+				from: unit.from + 1,
+				to: closeBracket
+			};
+			return {
+				form: "inline",
+				unit: unitRange,
+				text: label,
+				label,
+				dest: {
+					from: destFrom,
+					to: unit.to - 1
+				},
+				href: data.href,
+				title: data.title
+			};
+		}
 	}
-	const uri = lastMarkRunIn(state, unit, "mdLinkUri");
-	const closeBracket = uri ? uri.from - 2 : unit.to - 3;
-	const destFrom = uri ? uri.from : unit.to - 1;
-	const label = {
-		from: unit.from + 1,
-		to: closeBracket
-	};
-	return {
-		unit: {
-			from: unit.from,
-			to: unit.to
-		},
-		text: label,
-		label,
-		dest: {
-			from: destFrom,
-			to: unit.to - 1
-		},
-		href: packAttrs.data.href,
-		title: packAttrs.data.title
-	};
 }
 
 //#endregion
@@ -4224,7 +4270,7 @@ function insertLink({ href, title, wrapText = true } = {}) {
 function updateLink(attrs) {
 	return (state, dispatch) => {
 		const link = getLinkUnitAt(state, state.selection.from);
-		if (!link?.dest) return false;
+		if (link?.form !== "inline") return false;
 		const dest = destText(normalizeHref(attrs.href ?? link.href), attrs.title ?? link.title);
 		if (dispatch) dispatch(state.tr.insertText(dest, link.dest.from, link.dest.to).scrollIntoView());
 		return true;
@@ -4236,7 +4282,7 @@ function updateLink(attrs) {
 function removeLink() {
 	return (state, dispatch) => {
 		const link = getLinkUnitAt(state, state.selection.from);
-		if (!link?.label) return false;
+		if (link?.form !== "inline") return false;
 		if (dispatch) dispatch(state.tr.delete(link.label.to, link.unit.to).delete(link.unit.from, link.label.from).scrollIntoView());
 		return true;
 	};
@@ -4252,7 +4298,7 @@ function openLinkEdit(onLinkEdit) {
 	return (state, dispatch, view) => {
 		const link = getLinkUnitAt(state, state.selection.from);
 		if (link) {
-			if (link.label == null || link.dest == null) return false;
+			if (link.form !== "inline") return false;
 			if (dispatch && view) {
 				const { unit: { from, to } } = link;
 				dispatch(state.tr.setSelection(TextSelection.create(state.doc, from, to)).scrollIntoView());
@@ -7900,7 +7946,7 @@ function cleanTextFromSlice(slice, options = {}) {
 		blockNode.descendants((textNode) => {
 			if (!textNode.isText || !textNode.text) return true;
 			const textNodeMarks = textNode.marks.map((mark) => mark.type.name);
-			if (!(textNodeMarks.some((markName) => SYNTAX_MARK_NAMES.has(markName)) && !(options.preserveMathSource && textNodeMarks.includes("mdMath")))) parts.push(textNode.text);
+			if (!(textNodeMarks.some((markName) => SYNTAX_MARK_NAMES.includes(markName)) && !(options.preserveMathSource && textNodeMarks.includes("mdMath")))) parts.push(textNode.text);
 			return false;
 		});
 		blocks.push(parts.join(""));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meowdown/core",
   "type": "module",
-  "version": "0.64.1",
+  "version": "0.64.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
     "remark-stringify": "^11.0.0",
     "unicode-by-name": "^0.2.0",
     "unified": "^11.0.5",
-    "@meowdown/markdown": "^0.64.1"
+    "@meowdown/markdown": "^0.64.3"
   },
   "devDependencies": {
     "@ocavue/tsconfig": "^0.7.1",