rapier-markdown-kit 1.1.32 → 1.1.50

package/README.md

@@ -217,7 +217,7 @@ node node_modules/rapier-markdown-kit/dist/kit/conformance/run.mjs
 
 Thirteen small documents, each with the line boxes Rapier's own export produced for it. **Preservation**: every
 layout comment round-trips exactly (12 of 12 that carry one). **Presentation**: how closely the planned lines match
-(4 agree within 2px, 9 are close with a named cause, none differ; `dist/kit/conformance/README.md`).
+(3 agree within 2px, 10 are close with a named cause, none differ; `dist/kit/conformance/README.md`).
 `--impl path/to/module.mjs` runs another implementation against the same documents; `--tolerance 2` sets the pixel
 tolerance.
 

package/dist/kit/conformance/README.md

@@ -1,7 +1,7 @@
 # The conformance kit
 
 Thirteen small documents, each covering one placement fact from [the Markdown
-standard](../../docs/markdown-standard.md): inline (no layout comment), width/x/align, `wrap=around`
+standard](https://rapier.website/markdown-standard): inline (no layout comment), width/x/align, `wrap=around`
 with a real alpha silhouette, `wrap=box`, `behind`, `front`, `rotate=` on a plain raster, a foreign
 SVG "drawing" already turned in its own bytes, a ring drawing whose unfilled interior takes a line of
 text, both-sides wrapping around a centred picture, the neighbour search skipping a second, unrelated
@@ -75,18 +75,18 @@ Prints two separate tables (preservation and presentation are different claims):
 - **Presentation** — does the planned line count and each line's left/right agree with the recorded
   fact, within `--tolerance` pixels (default 2). This depends entirely on the measurer supplied;
   `run.mjs`'s own default (`measurer.mjs`, R77) replays Rapier's real Pretext trace wherever one was
-  captured, falling back to the character-glyph sum only where none exists. Current result: **4/13
-  AGREE outright** (`04-wrap-box`, `07-rotate-raster`, `10-both-sides`, `12-heading-barrier` — every
+  captured, falling back to the character-glyph sum only where none exists. Current result: **3/13
+  AGREE outright** (`04-wrap-box`, `10-both-sides`, `12-heading-barrier` — every
   one a case where the compared edge is pure obstacle-slot geometry, unaffected by text fidelity
-  either way), **9 CLOSE, 0 DIFFERS**, each CLOSE row's cause named rather than left as "close
+  either way), **10 CLOSE, 0 DIFFERS**, each CLOSE row's cause named rather than left as "close
   enough": `01-inline`/`02-width-x-align`/`05-behind`/`06-front` have no real trace at all (see
   `measurements` above) so still rest on the character-sum fallback; `03-wrap-around-silhouette`,
   `11-neighbour-skips-image` and `13-rtl-text` run Pretext for real during export (`13-rtl-text` at
   100% — every query of its own answered from the real trace) yet still carry a small, constant
-  left-edge delta (5.18px) that is a picture-obstacle *geometry* fact, not a text one: their
+  left-edge delta (9.64px) that is a picture-obstacle *geometry* fact, not a text one: their
   `profileHint` is a hand-computed, quantized alpha-band descriptor for a picture Rapier's own export
   never serializes an occupancy descriptor for, and that descriptor's own precision — not the
-  measurer — is the residual gap. `09-drawing-ring-interior` plans the recorded 14 lines, but one row
+  measurer — is the residual gap. `07-rotate-raster` and `08-drawing-rotation` have right-edge geometry deltas of 4.48px and 5.31px, with no measurer calls. `09-drawing-ring-interior` plans the recorded 14 lines, but one row
   differs by a whole slot (115.08px left, 292.09px right): its recorded trace, taken before a word
   that must break inside itself was given the widest slot of its row, cuts "ordinary" into "ordinar"
   and "y" in the ring's narrow left slot, where the planner now leaves that slot empty and sets the

package/dist/kit/conformance/run.mjs

@@ -114,7 +114,7 @@ console.log(`reads CLOSE rather than AGREE, none of them "close enough": (a) no
 console.log(`-- their picture pushes no flow obstacle, so layout/interchange.js's own prepare() never calls Pretext for this paragraph during export (see`);
 console.log(`measurer.mjs) -- the from-scratch character-sum approximation disagrees with real shaping by a bounded, named amount; (b) 03/11/13 DO run`);
 console.log(`Pretext for real (hits > 0, 13-rtl-text at 100% -- every query answered from the real trace) yet still carry a small, constant left-edge delta`);
-console.log(`(5.18px, unchanged from before this measurer existed) -- a picture-obstacle geometry fact, not a text one: these`);
+console.log(`(9.64px today, a constant from before this measurer existed) -- a picture-obstacle geometry fact, not a text one: these`);
 console.log(`fixtures' profileHint is a hand-computed, quantized alpha band descriptor for a raster Rapier's own export never serialized an occupancy`);
 console.log(`descriptor for (conformance/README.md, "profileHint"), and that descriptor's own precision -- not this lane's measurer -- is the residual gap; (c) 09 plans the recorded 14 lines but one row`);
 console.log(`differs by a whole slot: its recorded trace cuts a word in the ring's narrow left slot, and the planner now gives a word that must break inside itself`);

package/dist/layout/model.mjs

@@ -27,10 +27,12 @@ function normalize(raw) {
   return {text: pieces.join(''), offsets, trimStart: start, trimEnd: end};
 }
 
-export function prepareRun(raw, font, letterSpacing = 0) {
+export function prepareRun(raw, font, letterSpacing = 0, measured = null) {
   if (typeof raw !== 'string' || typeof font !== 'string' || !font.trim() || !finite(letterSpacing)) return null;
   const normalized = normalize(raw);
-  const prepared = prepareWithSegments(normalized.text, font, {letterSpacing});
+  // A paragraph's rich-inline plan has already measured this run. Map those same segments to source
+  // instead of measuring and segmenting it again; standalone callers still prepare their own run.
+  const prepared = measured || prepareWithSegments(normalized.text, font, {letterSpacing});
   if (!Array.isArray(prepared.segments) || prepared.segments.join('') !== normalized.text) return null;
   const segmentOffsets = [0];
   for (const segment of prepared.segments) segmentOffsets.push(segmentOffsets.at(-1) + segment.length);

package/dist/spec/md-marks.mjs

@@ -1,12 +1,75 @@
 // SPDX-License-Identifier: MIT
 // The one place these literal grammars are written (docs/markdown-standard.md, "Text colour", "Page break").
 
-const TEXT_COLOR_NAMES = Object.freeze({ green: '#1c7547', red: '#b32034', blue: '#175dc4', gold: '#865818', purple: '#7924d7' });
+// The exported page retains this reader alone. The editor uses the same closure, then adds its writers and scans.
+const inkReader = () => {
+	// SPDX-License-Identifier: MIT
+	const TEXT_COLOR_NAMES = Object.freeze({ green: '#1c7547', red: '#b32034', blue: '#175dc4', gold: '#865818', purple: '#7924d7' });
+
+	const COLOR_NAME_ALT = Object.keys(TEXT_COLOR_NAMES).join('|');
+	const COLOR_VALUE = '(?:#[0-9a-f]{6}|' + COLOR_NAME_ALT + ')';
+
+	// Ink (docs/markdown-standard.md, "Ink"; the design docs/briefs/ink.md): a pen stroke that stays with the words it
+	// marks, a paired comment with the colour span's shape. The opener holds the stroke:
+	//   <!--ink KIND [NUMBER] [COLOUR] [box=W,H] [at=X,Y] [PATH]-->words<!--/ink-->
+	// KIND is the stroke's kind, decided once when it was lifted; COLOUR is exactly the colour span's value, red when
+	// absent; box is the frame's size when the stroke was drawn and at the frame's offset from the words' box, both in
+	// hundredths of an em; PATH is the stroke, its first point absolute in the frame and the rest as moves, hundredths of an
+	// em. One spelling: the fields in this order, one space between, integers only. A comment that does not read this way
+	// is ordinary comment text and marks nothing. Ink pairs do not nest in each other. Arrow/end alone take a pairing
+	// number, an end takes no other data; under, strike and arrow may omit a path for a line derived from their words.
+	const INK_KINDS = Object.freeze(['under', 'strike', 'ring', 'bracket', 'free', 'arrow', 'end']);
+
+	const INK_PATH_MAX = 160;
+	const INK_INT_MAX = 999999;
+	const INK_INT = '-?\\d{1,6}';
+	const INK_OPEN_BODY = '(' + INK_KINDS.join('|') + ')(?: ([1-9]\\d{0,5}))?(?: (' + COLOR_VALUE + '))?(?: box=(\\d{1,6}),(\\d{1,6}))?(?: at=(' + INK_INT + '),(' + INK_INT + '))?'
+		+ '(?: (' + INK_INT + ',' + INK_INT + '(?: ' + INK_INT + ',' + INK_INT + ')*))?';
+	const INK_OPEN_PATTERN = '<!--ink ' + INK_OPEN_BODY + '-->';
+
+	// Relocated into the parse Worker by .toString() with parseInkOpen and isInkClose (engine.js _buildParseWorkerSource):
+	// reads only its parameter and the planted INK_PATH_MAX, INK_INT_MAX and TEXT_COLOR_NAMES; parseInkOpen reads
+	// INK_OPEN_PATTERN and this function; isInkClose reads INK_CLOSE.
+	function readInkMatch(match) {
+		const linked = match[1] === 'arrow' || match[1] === 'end';
+		if (linked !== (match[2] != null) || (!linked && match[1] !== 'under' && match[1] !== 'strike' && match[8] == null)) return null;
+		if (match[1] === 'end' && match.slice(3, 9).some(value => value != null)) return null;
+		const moves = match[8] == null ? [] : match[8].split(' ').map(pair => pair.split(',').map(Number));
+		if (moves.length > INK_PATH_MAX) return null;
+		const path = moves.length ? [moves[0]] : [];
+		for (let i = 1; i < moves.length; i++) {
+			const point = [path[i - 1][0] + moves[i][0], path[i - 1][1] + moves[i][1]];
+			if (Math.abs(point[0]) > INK_INT_MAX || Math.abs(point[1]) > INK_INT_MAX) return null;
+			path.push(point);
+		}
+		const colour = match[3] || null;
+		return Object.freeze({
+			kind: match[1],
+			...(linked ? { id: Number(match[2]) } : {}),
+			hex: colour == null ? null : (colour.charCodeAt(0) === 0x23 ? colour : TEXT_COLOR_NAMES[colour]),
+			box: match[4] == null ? null : [Number(match[4]), Number(match[5])],
+			at: match[6] == null ? null : [Number(match[6]), Number(match[7])],
+			path,
+		});
+	}
+
+	function parseInkOpen(comment) {
+		if (typeof comment !== 'string') return null;
+		const match = new RegExp('^' + INK_OPEN_PATTERN + '$').exec(comment);
+		return match && readInkMatch(match);
+	}
+
+	function parseInkBody(body) {
+		return typeof body === 'string' ? parseInkOpen('<!--ink ' + body + '-->') : null;
+	}
+	return { TEXT_COLOR_NAMES, COLOR_NAME_ALT, COLOR_VALUE, INK_KINDS, INK_PATH_MAX, INK_INT_MAX, INK_OPEN_PATTERN, readInkMatch, parseInkOpen, parseInkBody };
+};
+const { TEXT_COLOR_NAMES, COLOR_NAME_ALT, COLOR_VALUE, INK_KINDS, INK_PATH_MAX, INK_INT_MAX, INK_OPEN_PATTERN, readInkMatch, parseInkOpen, parseInkBody } = inkReader();
+export { readInkMatch, parseInkOpen, parseInkBody };
+
 const TEXT_COLOR_HEX_TO_NAME = Object.freeze(
 	Object.fromEntries(Object.entries(TEXT_COLOR_NAMES).map(([name, hex]) => [hex, name]))
 );
-const COLOR_NAME_ALT = Object.keys(TEXT_COLOR_NAMES).join('|');
-const COLOR_VALUE = '(?:#[0-9a-f]{6}|' + COLOR_NAME_ALT + ')';
 const COLOR_CLOSE = '<!--/c-->';
 const PAGE_BREAK_MARKER = '<!--md-break:v1 page-->';
 
@@ -67,24 +130,8 @@ export function hasColorMarker(text) {
 	return new RegExp('<!--(?:c ' + COLOR_VALUE + '|/c)-->').test(String(text == null ? '' : text));
 }
 
-// Ink (docs/markdown-standard.md, "Ink"; the design docs/briefs/ink.md): a pen stroke that stays with the words it
-// marks, a paired comment with the colour span's shape. The opener holds the stroke:
-//   <!--ink KIND [COLOUR] [box=W,H] [at=X,Y] PATH-->words<!--/ink-->
-// KIND is the stroke's kind, decided once when it was lifted; COLOUR is exactly the colour span's value, red when
-// absent; box is the frame's size when the stroke was drawn and at the frame's offset from the words' box, both in
-// hundredths of an em; PATH is the stroke, its first point absolute in the frame and the rest as moves, hundredths of an
-// em. One spelling: the fields in this order, one space between, integers only. A comment that does not read this way
-// is ordinary comment text and marks nothing. Ink pairs do not nest in each other.
-const INK_KINDS = Object.freeze(['under', 'strike', 'ring', 'bracket', 'free']);
 const INK_CLOSE = '<!--/ink-->';
-const INK_PATH_MAX = 160;
-const INK_INT_MAX = 999999;
-const INK_INT = '-?\\d{1,6}';
-const INK_OPEN_BODY = '(' + INK_KINDS.join('|') + ')(?: (' + COLOR_VALUE + '))?(?: box=(\\d{1,6}),(\\d{1,6}))?(?: at=(' + INK_INT + '),(' + INK_INT + '))?'
-	+ ' (' + INK_INT + ',' + INK_INT + '(?: ' + INK_INT + ',' + INK_INT + ')*)';
-const INK_OPEN_PATTERN = '<!--ink ' + INK_OPEN_BODY + '-->';
-
-export { INK_KINDS, INK_CLOSE, INK_PATH_MAX, INK_INT_MAX };
+export { INK_KINDS, INK_CLOSE, INK_PATH_MAX, INK_INT_MAX, INK_OPEN_PATTERN };
 
 const inkInt = (value, name) => {
 	if (!Number.isInteger(value) || Math.abs(value) > INK_INT_MAX) throw new TypeError('ink: ' + name + ' must be an integer within ' + INK_INT_MAX);
@@ -97,11 +144,18 @@ const inkPair = (value, name, nonNegative = false) => {
 	return pair;
 };
 
-// {kind, hex?, box?, at?, path} to the opener; the path's points are absolute in the frame and become moves after the
+// {kind, id?, hex?, box?, at?, path?} to the opener; the path's points are absolute in the frame and become moves after the
 // first. Refuses with a TypeError rather than writing a spelling the reader would not read.
 export function formatInkOpen(mark) {
 	if (!mark || typeof mark !== 'object') throw new TypeError('ink: a mark is an object');
 	if (!INK_KINDS.includes(mark.kind)) throw new TypeError('ink: the kind is one of ' + INK_KINDS.join(', '));
+	const linked = mark.kind === 'arrow' || mark.kind === 'end';
+	if (linked ? !Number.isInteger(mark.id) || mark.id <= 0 || mark.id > INK_INT_MAX : mark.id != null) throw new TypeError('ink: only an arrow or its end has a positive pairing number');
+	const id = linked ? ' ' + mark.id : '';
+	if (mark.kind === 'end') {
+		if (mark.hex != null || mark.box != null || mark.at != null || (mark.path != null && (!Array.isArray(mark.path) || mark.path.length))) throw new TypeError('ink: an arrow end holds only its pairing number');
+		return '<!--ink end' + id + '-->';
+	}
 	let colour = '';
 	if (mark.hex != null) {
 		const value = TEXT_COLOR_HEX_TO_NAME[mark.hex] || mark.hex;
@@ -110,36 +164,19 @@ export function formatInkOpen(mark) {
 	}
 	const box = mark.box == null ? '' : ' box=' + inkPair(mark.box, 'box', true).join(',');
 	const at = mark.at == null ? '' : ' at=' + inkPair(mark.at, 'at').join(',');
-	if (!Array.isArray(mark.path) || !mark.path.length || mark.path.length > INK_PATH_MAX) throw new TypeError('ink: the path holds 1 to ' + INK_PATH_MAX + ' points');
-	const points = mark.path.map(point => inkPair(point, 'path'));
-	const moves = [points[0].join(',')];
+	const optionalPath = linked || mark.kind === 'under' || mark.kind === 'strike';
+	const path = mark.path == null && optionalPath ? [] : mark.path;
+	if (!Array.isArray(path) || (!path.length && !optionalPath) || path.length > INK_PATH_MAX) throw new TypeError('ink: the path holds 1 to ' + INK_PATH_MAX + ' points, or is absent on an arrow, underline or strike');
+	const points = path.map(point => inkPair(point, 'path'));
+	const moves = points.length ? [points[0].join(',')] : [];
 	for (let i = 1; i < points.length; i++) moves.push([inkInt(points[i][0] - points[i - 1][0], 'path move'), inkInt(points[i][1] - points[i - 1][1], 'path move')].join(','));
-	return '<!--ink ' + mark.kind + colour + box + at + ' ' + moves.join(' ') + '-->';
+	return '<!--ink ' + mark.kind + id + colour + box + at + (moves.length ? ' ' + moves.join(' ') : '') + '-->';
 }
 
 export function formatInkRun(mark, content) {
 	return formatInkOpen(mark) + content + INK_CLOSE;
 }
 
-function readInkMatch(match) {
-	const moves = match[7].split(' ').map(pair => pair.split(',').map(Number));
-	if (moves.length > INK_PATH_MAX) return null;
-	const path = [moves[0]];
-	for (let i = 1; i < moves.length; i++) {
-		const point = [path[i - 1][0] + moves[i][0], path[i - 1][1] + moves[i][1]];
-		if (Math.abs(point[0]) > INK_INT_MAX || Math.abs(point[1]) > INK_INT_MAX) return null;
-		path.push(point);
-	}
-	const colour = match[2] || null;
-	return Object.freeze({
-		kind: match[1],
-		hex: colour == null ? null : (colour.charCodeAt(0) === 0x23 ? colour : TEXT_COLOR_NAMES[colour]),
-		box: match[3] == null ? null : [Number(match[3]), Number(match[4])],
-		at: match[5] == null ? null : [Number(match[5]), Number(match[6])],
-		path,
-	});
-}
-
 // Returns {mark, length in UTF-16 units} or null; not end-anchored.
 export function matchInkOpen(text) {
 	if (typeof text !== 'string') return null;
@@ -149,12 +186,6 @@ export function matchInkOpen(text) {
 	return mark && { mark, length: match[0].length };
 }
 
-export function parseInkOpen(comment) {
-	if (typeof comment !== 'string') return null;
-	const match = new RegExp('^' + INK_OPEN_PATTERN + '$').exec(comment);
-	return match && readInkMatch(match);
-}
-
 // The opener's body is what a rendered span carries (a renderer's sanitizer drops an attribute whose value holds the
 // comment's own close): the opener after `<!--ink ` and before `-->`, so the attribute reads `under red box=… 0,95 …`,
 // and only a body that reads as a mark goes back. Read and write through the same grammar, so an invalid body cannot
@@ -164,9 +195,6 @@ export function inkOpenBody(opener) {
 	const match = new RegExp('^' + INK_OPEN_PATTERN + '$').exec(opener);
 	return match && readInkMatch(match) ? opener.slice(8, -3) : null;
 }
-export function parseInkBody(body) {
-	return typeof body === 'string' ? parseInkOpen('<!--ink ' + body + '-->') : null;
-}
 export function formatInkOpenFromBody(body) {
 	return parseInkBody(body) ? '<!--ink ' + body + '-->' : null;
 }
@@ -190,43 +218,129 @@ export function scanInkMarkers(source) {
 	return markers;
 }
 
-// The runs: an opener and the next closer with no opener between them. A marker that pairs with nothing is text
+// Ink nests so independent strokes can share the same words. A marker that pairs with nothing is text
 // (it shows nothing and marks nothing) and is listed under strays.
-export function pairInkMarkers(source) {
-	return pairMarkers(source, 'ink');
+export function pairInkMarkers(source, markers = null) {
+	return pairMarkers(source, 'ink', markers);
 }
 
-// Colour keeps the first opener, as its inline parser does; ink replaces an unclosed opener.
-// Neither kind nests in itself. The shared range shape lets custody owners treat both alike.
-export function pairMarkers(source, kind) {
+// A document parser may supply its semantic markers, leaving literal code comments untouched.
+// Local inline parsing and source planners need an endpoint's span even when its mate is in another block.
+export function pairInkSpans(source, markers = null) {
+	return pairSpanMarkers(source, 'ink', markers);
+}
+
+// Colour keeps its first opener; ink pairs each closer with the innermost opener. The shared range
+// shape lets custody owners keep every independent stroke, including strokes on identical words.
+export function pairMarkers(source, kind, markers = null) {
+	const paired = pairSpanMarkers(source, kind, markers);
+	if (kind !== 'ink') return paired;
+	const groups = new Map();
+	const groupFor = id => {
+		if (!groups.has(id)) groups.set(id, { id, tail: null, head: null, count: 0 });
+		return groups.get(id);
+	};
+	for (const run of paired.runs) if (run.mark.id != null) {
+		const group = groupFor(run.mark.id);
+		group.count++;
+		group[run.mark.kind === 'arrow' ? 'tail' : 'head'] = run;
+	}
+	for (const marker of paired.strays) if (marker.mark?.id != null) groupFor(marker.mark.id).count++;
+	const arrows = [...groups.values()].filter(group => group.count === 2 && group.tail && group.head)
+		.map(({id, tail, head}) => ({id, tail, head}));
+	const complete = new Set(arrows.map(arrow => arrow.id)), runs = [], strays = paired.strays.slice();
+	for (const run of paired.runs) {
+		if (run.mark.id == null || complete.has(run.mark.id)) { runs.push(run); continue; }
+		strays.push({ start: run.start, end: run.innerStart, mark: run.mark, close: false },
+			{ start: run.innerEnd, end: run.end, mark: null, close: true, arrowId: run.mark.id });
+	}
+	strays.sort((a, b) => a.start - b.start);
+	return { runs, strays, arrows };
+}
+
+function pairSpanMarkers(source, kind, markers = null) {
 	if (kind !== 'ink' && kind !== 'color') throw new TypeError('Unknown paired marker kind');
 	const color = kind === 'color';
-	const runs = [], strays = [];
-	let open = null;
-	for (const marker of color ? scanColorMarkers(source) : scanInkMarkers(source)) {
+	const runs = [], strays = [], stack = [];
+	for (const marker of markers || (color ? scanColorMarkers(source) : scanInkMarkers(source))) {
 		if (color ? marker.hex !== null : !marker.close) {
-			if (open) {
-				strays.push(color ? marker : open);
-				if (color) continue;
-			}
-			open = marker;
+			if (color && stack.length) { strays.push(marker); continue; }
+			stack.push(marker);
 			continue;
 		}
+		const open = stack.pop();
 		if (!open) { strays.push(marker); continue; }
 		runs.push({ start: open.start, end: marker.end, innerStart: open.end, innerEnd: marker.start,
 			...(color ? { hex: open.hex } : { mark: open.mark }) });
-		open = null;
 	}
-	if (open) strays.push(open);
+	strays.push(...stack);
+	runs.sort((a, b) => a.start - b.start);
+	strays.sort((a, b) => a.start - b.start);
 	return { runs, strays };
 }
 
+// Copy carries an arrow only when both complete anchor words are selected. A partial selection removes just
+// its endpoint comments from the copied slice, including a comment clipped at the selection's boundary.
+export function sliceInkArrows(source, start = 0, end = String(source ?? '').length, markers = null) {
+	const text = String(source ?? '');
+	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > text.length) throw new RangeError('ink: invalid source slice');
+	const kept = new Set();
+	for (const arrow of pairInkMarkers(text, markers).arrows) {
+		if (![arrow.tail, arrow.head].every(run => run.innerStart >= start && run.innerEnd <= end && run.innerStart < run.innerEnd)) continue;
+		kept.add(arrow.id);
+		start = Math.min(start, arrow.tail.start, arrow.head.start);
+		end = Math.max(end, arrow.tail.end, arrow.head.end);
+	}
+	const spans = pairInkSpans(text, markers), cuts = [];
+	for (const run of spans.runs) if (run.mark.id != null && !kept.has(run.mark.id)) cuts.push(
+		{ start: run.start, end: run.innerStart }, { start: run.innerEnd, end: run.end });
+	for (const marker of spans.strays) if (marker.mark?.id != null) cuts.push(marker);
+	let result = '', at = start;
+	for (const cut of cuts.sort((a, b) => a.start - b.start)) {
+		if (cut.end <= at || cut.start >= end) continue;
+		result += text.slice(at, Math.max(at, cut.start));
+		at = Math.min(end, cut.end);
+	}
+	return result + text.slice(at, end);
+}
+
+// The paste owns only its incoming markers: an orphan cannot adopt an existing document's endpoint, and a
+// complete pair with an occupied number gets a new number in both openers without rewriting its stroke bytes.
+export function prepareInkPaste(source, existing = '', markers = null) {
+	const text = String(source ?? ''), paired = pairInkMarkers(text, markers), edits = [];
+	for (const marker of paired.strays) if (marker.mark?.id != null || marker.arrowId != null) edits.push({ start: marker.start, end: marker.end, text: '' });
+	const occupied = new Set(scanInkMarkers(existing).filter(marker => marker.mark?.id != null).map(marker => marker.mark.id));
+	const reserved = new Set([...occupied, ...paired.arrows.map(arrow => arrow.id)]);
+	let next = 1;
+	for (const arrow of paired.arrows) {
+		const runs = [arrow.tail, arrow.head];
+		if (runs.some(run => run.innerStart === run.innerEnd)) {
+			for (const run of runs) edits.push({ start: run.start, end: run.innerStart, text: '' }, { start: run.innerEnd, end: run.end, text: '' });
+			continue;
+		}
+		if (!occupied.has(arrow.id)) continue;
+		while (reserved.has(next) && next <= INK_INT_MAX) next++;
+		if (next > INK_INT_MAX) throw new RangeError('ink: no unused arrow pairing number');
+		reserved.add(next);
+		for (const run of runs) {
+			const prefix = '<!--ink ' + run.mark.kind + ' ';
+			edits.push({ start: run.start + prefix.length, end: run.start + prefix.length + String(arrow.id).length, text: String(next) });
+		}
+	}
+	let result = text;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+	return result;
+}
+
 export function stripInkMarkers(text) {
-	return String(text == null ? '' : text).replace(new RegExp(INK_OPEN_PATTERN + '|' + INK_CLOSE.replace(/[-]/g, '\\-'), 'g'), '');
+	const source = String(text == null ? '' : text);
+	let result = '', at = 0;
+	for (const marker of scanInkMarkers(source)) { result += source.slice(at, marker.start); at = marker.end; }
+	return result + source.slice(at);
 }
 
 export function hasInkMarker(text) {
-	return new RegExp(INK_OPEN_PATTERN + '|' + INK_CLOSE.replace(/[-]/g, '\\-')).test(String(text == null ? '' : text));
+	return scanInkMarkers(text).length > 0;
 }
 
 // The only spelling.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapier-markdown-kit",
-  "version": "1.1.32",
+  "version": "1.1.50",
   "description": "Read, write and style Self-contained Markdown: the universal stylesheet, picture layout, text marks, picture appendix, line planner and Will/1 markers. MIT, no dependencies.",
   "author": "Jack Skipworth",
   "license": "MIT",

package/style.css

@@ -471,7 +471,8 @@
 .md-render ol>li::before{
 	content:counter(rapier-ol);
 	position:absolute;
-	inset-inline-start:-2.75rem; top:0;
+	/* The circle is centred on the item's first line: the li's own padding, plus half of what the 2rem circle is taller than one line. */
+	inset-inline-start:-2.75rem; top:calc(0.15rem + (var(--md-line) - 2rem) / 2);
 	width:2rem; height:2rem;
 	display:flex; align-items:center; justify-content:center;
 	border:2px solid var(--md-color-line);
@@ -483,7 +484,8 @@
 	box-sizing:border-box;
 	z-index:1;
 }
-.md-render ol>li:not(:last-child)::after{
+.md-render ol>li:not(:last-child)::after,
+.md-render ol[data-rapier-list-continues]>li:last-child::after{
 	content:'';
 	position:absolute;
 
@@ -493,6 +495,20 @@
 	border-inline-start:3px dotted var(--md-color-line);
 	z-index:0;
 }
+/* A heading between two parts of one numbered list (the second part's start follows the first's last number;
+   _rapierMarkListContinuations marks them): the heading stands on the margin the item text stands on, and the dotted
+   line runs on, out of the first part's last item, down the heading's own height, to the next circle. */
+.md-render ol[data-rapier-list-continues]>li:last-child::after{bottom:calc(-1 * var(--md-line))}
+.md-render :is(h1,h2,h3,h4,h5,h6)[data-rapier-list-through]{position:relative;padding-inline-start:2.75rem}
+.md-render :is(h1,h2,h3,h4,h5,h6)[data-rapier-list-through]::before{
+	content:'';
+	position:absolute;
+	inset-inline-start:calc(1rem - 1.5px);
+	top:0;
+	bottom:calc(var(--md-line) / -2);
+	border-inline-start:3px dotted var(--md-color-line);
+	z-index:0;
+}
 .md-render li{margin:0 0 calc(var(--md-line) / 4)}
 .md-render li:last-child{margin-bottom:0}
 .md-render li>ul,.md-render li>ol{margin:calc(var(--md-line) / 4) 0 0}
@@ -556,6 +572,7 @@
 }
 .md-render strong{font-weight:var(--md-fw-semibold)}
 .md-render em{font-style:italic}
+.md-render :not(pre)>code{line-height:1}
 .md-render code{font-family:var(--md-font-mono);font-size:0.85em;
 	background:var(--md-color-inset);border:1px solid var(--md-color-border);padding:1px 5px}
 .md-render pre{margin:0 0 var(--md-line);padding:var(--md-space-3) var(--md-space-4);
@@ -755,6 +772,12 @@
 	 pre-computed --md-color-dark here, so the common case survives even a round-trip that kept
 	 data-md-color but dropped style, exactly like highlight's own swatch constants. */
 .md-render [data-md-color]{--md-color-dark:var(--md-color);color:light-dark(var(--md-color),var(--md-color-dark))}
+/* Ink (docs/markdown-standard.md, "Ink"): the span shows nothing; the ink layer draws the stroke over the words it marks. */
+.md-render span.rapier-ink-mark{all:unset;display:inline}
+.rapier-ink-layer{--md-ink:#b32034;--md-ink-dark:#b32034;position:relative;display:block;width:0;height:0;margin:0;padding:0;border:0;overflow:visible;pointer-events:none;z-index:3}
+.rapier-ink-layer svg{position:absolute;display:block;margin:0;padding:0;overflow:visible}
+.rapier-ink-layer path{fill:light-dark(var(--md-ink),var(--md-ink-dark));stroke:none;opacity:.92}
+@media print{.rapier-ink-layer path{fill:var(--md-ink)}}
 .md-render [data-md-color="#1c7547"]{--md-color-dark:#70c390}
 .md-render [data-md-color="#b32034"]{--md-color-dark:#ff8385}
 .md-render [data-md-color="#175dc4"]{--md-color-dark:#7bafff}
@@ -799,6 +822,13 @@
 /* A wide table scrolls inside its wrap; the wrap carries the block's line, so a scrollbar sits under the table, not a line below it. */
 .md-render .table-scroll-wrap{width:100%;margin:0 0 var(--md-line);overflow-x:auto;-webkit-overflow-scrolling:touch;padding-bottom:2px}
 .md-render .table-scroll-wrap table{min-width:100%;margin-bottom:0}
+/* Single-axis overflow leaves vertical sticky positioning with the document's scroller.
+   Older engines keep the ordinary sideways wrapper; screen-only rules leave print unchanged. */
+@media screen{
+	.md-render{--md-table-header-top:0px}
+	.md-render .table-scroll-wrap{overflow:auto clip}
+	.md-render thead{position:sticky;top:var(--md-table-header-top,0px);z-index:2;background:var(--md-color-bg)}
+}
 @media print{
   .md-render [data-md-break]{border:0!important;height:0!important;margin:0!important;break-before:page;page-break-before:always}
   .md-render [data-md-break]::after{content:none!important}