@meowdown/core 0.64.1 → 0.64.2

package/dist/index.d.ts

@@ -246,31 +246,47 @@ 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' | 'autolink';
+  data?: null;
+  slot?: 1 | null;
+  revealInFocus: true;
+  revealInHide?: null;
+} | {
   key: 'link';
   data: {
     href: string;
     title: string;
-    reference?: true;
+    isReference: boolean;
   };
+  slot?: 1 | null;
+  revealInFocus: true;
+  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

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;
@@ -360,28 +357,30 @@ function getMarkRangeAt(state, pos, markName, attrs) {
 	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;
+		const range = ATOM_MARK_NAMES.includes(name) ? getAtomUnitRange(state, $pos, name) : getMarkRange($pos, name, attrs);
+		if (range) return range;
 	}
 }
 /**
-* 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 +423,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 +442,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 +779,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 +2841,17 @@ 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";
+		case LEZER_NODE_IDS.Autolink: return "autolink";
+		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).
@@ -2922,16 +2923,13 @@ 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);
@@ -3083,17 +3081,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: {
+			href,
+			title,
+			isReference
+		},
+		revealInFocus: true
 	});
 	const base = [...parentMarks, pack];
 	let pos = node.from;
@@ -3192,7 +3187,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()]);
@@ -3723,7 +3722,9 @@ function defineMdPack() {
 		attrs: {
 			key: {},
 			data: { default: null },
-			slot: { default: null }
+			slot: { default: null },
+			revealInFocus: { default: null },
+			revealInHide: { default: null }
 		},
 		toDOM: (mark) => {
 			return [
@@ -4126,7 +4127,8 @@ function getLinkUnitAt(state, pos) {
 			title: ""
 		};
 	}
-	if (packAttrs.data.reference === true) {
+	const linkData = packAttrs.data;
+	if (linkData.isReference) {
 		const text = linkText == null ? {
 			from: unit.from,
 			to: unit.to
@@ -4140,8 +4142,8 @@ function getLinkUnitAt(state, pos) {
 				to: unit.to
 			},
 			text,
-			href: packAttrs.data.href,
-			title: packAttrs.data.title
+			href: linkData.href,
+			title: linkData.title
 		};
 	}
 	const uri = lastMarkRunIn(state, unit, "mdLinkUri");
@@ -4162,8 +4164,8 @@ function getLinkUnitAt(state, pos) {
 			from: destFrom,
 			to: unit.to - 1
 		},
-		href: packAttrs.data.href,
-		title: packAttrs.data.title
+		href: linkData.href,
+		title: linkData.title
 	};
 }
 
@@ -7900,7 +7902,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.2",
   "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.2"
   },
   "devDependencies": {
     "@ocavue/tsconfig": "^0.7.1",