rapier-markdown-kit 1.1.0

package/dist/agent/vendor/pretext/measurement.js

@@ -0,0 +1,189 @@
+/*! Pretext 0.0.9 | MIT | Copyright (c) 2026 Pretext contributors */
+import { getSharedGraphemeSegmenter } from './analysis.js';
+let measureContext = null;
+const segmentMetricCaches = new Map();
+let cachedEngineProfile = null;
+const MAX_PREFIX_FIT_GRAPHEMES = 96;
+const emojiPresentationRe = /\p{Emoji_Presentation}/u;
+const maybeEmojiRe = /[\p{Emoji_Presentation}\p{Extended_Pictographic}\p{Regional_Indicator}\uFE0F\u20E3]/u;
+const emojiCorrectionCache = new Map();
+export function getMeasureContext() {
+    if (measureContext !== null) return measureContext;
+    if (typeof OffscreenCanvas !== 'undefined') {
+        measureContext = new OffscreenCanvas(1, 1).getContext('2d');
+        return measureContext;
+    }
+    if (typeof document !== 'undefined') {
+        measureContext = document.createElement('canvas').getContext('2d');
+        return measureContext;
+    }
+    throw new Error('Text measurement requires OffscreenCanvas or a DOM canvas context.');
+}
+export function getSegmentMetricCache(font) {
+    let cache = segmentMetricCaches.get(font);
+    if (!cache) {
+        cache = new Map();
+        segmentMetricCaches.set(font, cache);
+    }
+    return cache;
+}
+export function getSegmentMetrics(seg, cache) {
+    let metrics = cache.get(seg);
+    if (metrics === undefined) {
+        const ctx = getMeasureContext();
+        metrics = {
+            width: ctx.measureText(seg).width
+        };
+        cache.set(seg, metrics);
+    }
+    return metrics;
+}
+export function getEngineProfile() {
+    if (cachedEngineProfile !== null) return cachedEngineProfile;
+    if (typeof navigator === 'undefined') {
+        cachedEngineProfile = {
+            geckoAsciiLineBreaks: false,
+            lineFitEpsilon: 0.005,
+            carryCJKAfterClosingQuote: false,
+            breakKeepAllAfterPunctuation: true,
+            preferPrefixWidthsForBreakableRuns: false
+        };
+        return cachedEngineProfile;
+    }
+    const ua = navigator.userAgent;
+    const vendor = navigator.vendor;
+    const isSafari = vendor === 'Apple Computer, Inc.' && ua.includes('Safari/') && !ua.includes('Chrome/') && !ua.includes('Chromium/') && !ua.includes('CriOS/') && !ua.includes('FxiOS/') && !ua.includes('EdgiOS/');
+    const isChromium = ua.includes('Chrome/') || ua.includes('Chromium/') || ua.includes('CriOS/') || ua.includes('Edg/');
+    const isGecko = ua.includes('Firefox/') && !ua.includes('FxiOS/');
+    cachedEngineProfile = {
+        geckoAsciiLineBreaks: isGecko,
+        lineFitEpsilon: isSafari ? 1 / 64 : 0.005,
+        carryCJKAfterClosingQuote: isChromium,
+        breakKeepAllAfterPunctuation: !isSafari,
+        preferPrefixWidthsForBreakableRuns: isSafari
+    };
+    return cachedEngineProfile;
+}
+export function parseFontSize(font) {
+    const m = font.match(/(?:^|\D)(\d+(?:\.\d+)?)\s*px/);
+    return m ? parseFloat(m[1]) : 16;
+}
+function isEmojiGrapheme(g) {
+    return emojiPresentationRe.test(g) || g.includes('\uFE0F');
+}
+export function textMayContainEmoji(text) {
+    return maybeEmojiRe.test(text);
+}
+function getEmojiCorrection(font) {
+    let correction = emojiCorrectionCache.get(font);
+    if (correction !== undefined) return correction;
+    const fontSize = parseFontSize(font);
+    const ctx = getMeasureContext();
+    ctx.font = font;
+    const canvasW = ctx.measureText('\u{1F600}').width;
+    correction = 0;
+    if (canvasW > fontSize + 0.5 && typeof document !== 'undefined' && document.body !== null) {
+        const span = document.createElement('span');
+        span.style.font = font;
+        span.style.display = 'inline-block';
+        span.style.visibility = 'hidden';
+        span.style.position = 'absolute';
+        span.textContent = '\u{1F600}';
+        document.body.appendChild(span);
+        const domW = span.getBoundingClientRect().width;
+        document.body.removeChild(span);
+        if (canvasW - domW > 0.5) {
+            correction = canvasW - domW;
+        }
+    }
+    emojiCorrectionCache.set(font, correction);
+    return correction;
+}
+function countEmojiGraphemes(text) {
+    let count = 0;
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    for (const g of graphemeSegmenter.segment(text)){
+        if (isEmojiGrapheme(g.segment)) count++;
+    }
+    return count;
+}
+function getEmojiCount(seg, metrics) {
+    if (metrics.emojiCount === undefined) {
+        metrics.emojiCount = countEmojiGraphemes(seg);
+    }
+    return metrics.emojiCount;
+}
+export function getCorrectedSegmentWidth(seg, metrics, emojiCorrection) {
+    if (emojiCorrection === 0) return metrics.width;
+    return metrics.width - getEmojiCount(seg, metrics) * emojiCorrection;
+}
+export function getSegmentBreakableFitAdvances(seg, metrics, cache, emojiCorrection, mode) {
+    if (metrics.breakableFitAdvances !== undefined && metrics.breakableFitMode === mode) {
+        return metrics.breakableFitAdvances;
+    }
+    metrics.breakableFitMode = mode;
+    const graphemeSegmenter = getSharedGraphemeSegmenter();
+    const graphemes = [];
+    for (const gs of graphemeSegmenter.segment(seg)){
+        graphemes.push(gs.segment);
+    }
+    if (graphemes.length <= 1) {
+        metrics.breakableFitAdvances = null;
+        return metrics.breakableFitAdvances;
+    }
+    if (mode === 'sum-graphemes') {
+        const advances = [];
+        for (const grapheme of graphemes){
+            const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+            advances.push(getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection));
+        }
+        metrics.breakableFitAdvances = advances;
+        return metrics.breakableFitAdvances;
+    }
+    if (mode === 'pair-context' || graphemes.length > MAX_PREFIX_FIT_GRAPHEMES) {
+        const advances = [];
+        let previousGrapheme = null;
+        let previousWidth = 0;
+        for (const grapheme of graphemes){
+            const graphemeMetrics = getSegmentMetrics(grapheme, cache);
+            const currentWidth = getCorrectedSegmentWidth(grapheme, graphemeMetrics, emojiCorrection);
+            if (previousGrapheme === null) {
+                advances.push(currentWidth);
+            } else {
+                const pair = previousGrapheme + grapheme;
+                const pairMetrics = getSegmentMetrics(pair, cache);
+                advances.push(getCorrectedSegmentWidth(pair, pairMetrics, emojiCorrection) - previousWidth);
+            }
+            previousGrapheme = grapheme;
+            previousWidth = currentWidth;
+        }
+        metrics.breakableFitAdvances = advances;
+        return metrics.breakableFitAdvances;
+    }
+    const advances = [];
+    let prefix = '';
+    let prefixWidth = 0;
+    for (const grapheme of graphemes){
+        prefix += grapheme;
+        const prefixMetrics = getSegmentMetrics(prefix, cache);
+        const nextPrefixWidth = getCorrectedSegmentWidth(prefix, prefixMetrics, emojiCorrection);
+        advances.push(nextPrefixWidth - prefixWidth);
+        prefixWidth = nextPrefixWidth;
+    }
+    metrics.breakableFitAdvances = advances;
+    return metrics.breakableFitAdvances;
+}
+export function getFontMeasurementState(font, needsEmojiCorrection) {
+    const ctx = getMeasureContext();
+    ctx.font = font;
+    const cache = getSegmentMetricCache(font);
+    const emojiCorrection = needsEmojiCorrection ? getEmojiCorrection(font) : 0;
+    return {
+        cache,
+        emojiCorrection
+    };
+}
+export function clearMeasurementCaches() {
+    segmentMetricCaches.clear();
+    emojiCorrectionCache.clear();
+}

package/dist/agent/vendor/pretext/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/agent/vendor/pretext/rich-inline.js

@@ -0,0 +1,291 @@
+/*! Pretext 0.0.9 | MIT | Copyright (c) 2026 Pretext contributors */
+import { prepareWithSegments } from './layout.js';
+import { buildLineTextFromRange, getLineTextCache } from './line-text.js';
+import { stepPreparedLineGeometry } from './line-break.js';
+import { getFontMeasurementState, getSegmentMetrics } from './measurement.js';
+const EMPTY_LAYOUT_CURSOR = {
+    segmentIndex: 0,
+    graphemeIndex: 0
+};
+const RICH_INLINE_START_CURSOR = {
+    itemIndex: 0,
+    segmentIndex: 0,
+    graphemeIndex: 0
+};
+function getInternalPreparedRichInline(prepared) {
+    return prepared;
+}
+function cloneCursor(cursor) {
+    return {
+        segmentIndex: cursor.segmentIndex,
+        graphemeIndex: cursor.graphemeIndex
+    };
+}
+function isLineStartCursor(cursor) {
+    return cursor.segmentIndex === 0 && cursor.graphemeIndex === 0;
+}
+function isCollapsibleBoundaryWhitespace(code) {
+    return code === 0x20 || code === 0x09 || code === 0x0A || code === 0x0C || code === 0x0D;
+}
+function getCollapsedSpaceWidth(font, letterSpacing) {
+    const { cache } = getFontMeasurementState(font, false);
+    return getSegmentMetrics(' ', cache).width + letterSpacing;
+}
+function measureWholeItem(prepared) {
+    const end = {
+        segmentIndex: 0,
+        graphemeIndex: 0
+    };
+    return stepPreparedLineGeometry(prepared, end, Number.POSITIVE_INFINITY);
+}
+function endsInsideFirstSegment(segmentIndex, graphemeIndex) {
+    return segmentIndex === 0 && graphemeIndex > 0;
+}
+export function prepareRichInline(items) {
+    const preparedItems = Array.from({
+        length: items.length
+    });
+    let pendingGapWidth = null;
+    let breakAfterPreviousItem = false;
+    for(let index = 0; index < items.length; index++){
+        const item = items[index];
+        const letterSpacing = item.letterSpacing ?? 0;
+        let start = 0;
+        while(start < item.text.length && isCollapsibleBoundaryWhitespace(item.text.charCodeAt(start)))start++;
+        if (start === item.text.length) {
+            if (start > 0 && pendingGapWidth === null) {
+                pendingGapWidth = getCollapsedSpaceWidth(item.font, letterSpacing);
+            }
+            continue;
+        }
+        let end = item.text.length;
+        while(end > start && isCollapsibleBoundaryWhitespace(item.text.charCodeAt(end - 1)))end--;
+        const hasLeadingWhitespace = start > 0;
+        const hasTrailingWhitespace = end < item.text.length;
+        const trimmedText = item.text.slice(start, end);
+        const gapBefore = pendingGapWidth ?? (hasLeadingWhitespace ? getCollapsedSpaceWidth(item.font, letterSpacing) : 0);
+        const prepared = prepareWithSegments(trimmedText, item.font, letterSpacing === 0 ? undefined : {
+            letterSpacing
+        });
+        const wholeWidth = measureWholeItem(prepared);
+        const establishesLine = wholeWidth !== null || prepared.kinds.includes('zero-width-break');
+        const preparedItem = {
+            break: item.break ?? 'normal',
+            breakBefore: pendingGapWidth !== null || hasLeadingWhitespace || breakAfterPreviousItem,
+            establishesLine,
+            extraWidth: item.extraWidth ?? 0,
+            gapBefore,
+            naturalWidth: wholeWidth ?? 0,
+            prepared
+        };
+        preparedItems[index] = preparedItem;
+        if (establishesLine) breakAfterPreviousItem = prepared.kinds.at(-1) === 'zero-width-break';
+        pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, letterSpacing) : null;
+    }
+    return {
+        items: preparedItems
+    };
+}
+function stepRichInlineLine(flow, maxWidth, cursor, collectFragment) {
+    if (flow.items.length === 0 || cursor.itemIndex >= flow.items.length) return null;
+    const safeWidth = Math.max(1, maxWidth);
+    let hasContent = false;
+    let lineWidth = 0;
+    let remainingWidth = safeWidth;
+    let itemIndex = cursor.itemIndex;
+    lineLoop: while(itemIndex < flow.items.length){
+        const item = flow.items[itemIndex];
+        if (item === undefined) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        if (!isLineStartCursor(cursor) && cursor.segmentIndex === item.prepared.segments.length && cursor.graphemeIndex === 0) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        if (!item.establishesLine) {
+            collectFragment?.(itemIndex, 0, 0, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+                segmentIndex: item.prepared.segments.length,
+                graphemeIndex: 0
+            });
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        const gapBefore = hasContent ? item.gapBefore : 0;
+        const atItemStart = isLineStartCursor(cursor);
+        if (item.break === 'never') {
+            if (!atItemStart) {
+                itemIndex++;
+                cursor.segmentIndex = 0;
+                cursor.graphemeIndex = 0;
+                continue;
+            }
+            const occupiedWidth = item.naturalWidth + item.extraWidth;
+            const totalWidth = gapBefore + occupiedWidth;
+            if (hasContent && totalWidth > remainingWidth) break lineLoop;
+            collectFragment?.(itemIndex, gapBefore, occupiedWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+                segmentIndex: item.prepared.segments.length,
+                graphemeIndex: 0
+            });
+            hasContent = true;
+            lineWidth += totalWidth;
+            remainingWidth = safeWidth - lineWidth;
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        const reservedWidth = gapBefore + item.extraWidth;
+        if (hasContent && reservedWidth > remainingWidth) break lineLoop;
+        if (atItemStart) {
+            const totalWidth = reservedWidth + item.naturalWidth;
+            if (totalWidth <= remainingWidth) {
+                collectFragment?.(itemIndex, gapBefore, item.naturalWidth + item.extraWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+                    segmentIndex: item.prepared.segments.length,
+                    graphemeIndex: 0
+                });
+                hasContent = true;
+                lineWidth += totalWidth;
+                remainingWidth = safeWidth - lineWidth;
+                itemIndex++;
+                cursor.segmentIndex = 0;
+                cursor.graphemeIndex = 0;
+                continue;
+            }
+        }
+        const availableWidth = Math.max(1, remainingWidth - reservedWidth);
+        const lineEnd = {
+            segmentIndex: cursor.segmentIndex,
+            graphemeIndex: cursor.graphemeIndex
+        };
+        const lineWidthForItem = stepPreparedLineGeometry(item.prepared, lineEnd, availableWidth);
+        if (lineWidthForItem === null) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        if (cursor.segmentIndex === lineEnd.segmentIndex && cursor.graphemeIndex === lineEnd.graphemeIndex) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        const itemOccupiedWidth = lineWidthForItem + item.extraWidth;
+        const lineWidthContribution = gapBefore + itemOccupiedWidth;
+        if (hasContent && atItemStart && lineWidthContribution > remainingWidth) break lineLoop;
+        if (hasContent && atItemStart && item.breakBefore && endsInsideFirstSegment(lineEnd.segmentIndex, lineEnd.graphemeIndex)) {
+            break lineLoop;
+        }
+        collectFragment?.(itemIndex, gapBefore, itemOccupiedWidth, cloneCursor(cursor), {
+            segmentIndex: lineEnd.segmentIndex,
+            graphemeIndex: lineEnd.graphemeIndex
+        });
+        hasContent = true;
+        lineWidth += lineWidthContribution;
+        remainingWidth = safeWidth - lineWidth;
+        if (lineEnd.segmentIndex === item.prepared.segments.length && lineEnd.graphemeIndex === 0) {
+            itemIndex++;
+            cursor.segmentIndex = 0;
+            cursor.graphemeIndex = 0;
+            continue;
+        }
+        cursor.segmentIndex = lineEnd.segmentIndex;
+        cursor.graphemeIndex = lineEnd.graphemeIndex;
+        break;
+    }
+    if (!hasContent) return null;
+    cursor.itemIndex = itemIndex;
+    return lineWidth;
+}
+export function layoutNextRichInlineLineRange(prepared, maxWidth, start = RICH_INLINE_START_CURSOR) {
+    const flow = getInternalPreparedRichInline(prepared);
+    const end = {
+        itemIndex: start.itemIndex,
+        segmentIndex: start.segmentIndex,
+        graphemeIndex: start.graphemeIndex
+    };
+    const fragments = [];
+    const width = stepRichInlineLine(flow, maxWidth, end, (itemIndex, gapBefore, occupiedWidth, fragmentStart, fragmentEnd)=>{
+        fragments.push({
+            itemIndex,
+            gapBefore,
+            occupiedWidth,
+            start: fragmentStart,
+            end: fragmentEnd
+        });
+    });
+    if (width === null) return null;
+    return {
+        fragments,
+        width,
+        end
+    };
+}
+function materializeFragmentText(item, fragment) {
+    return buildLineTextFromRange(item.prepared, getLineTextCache(item.prepared), fragment.start.segmentIndex, fragment.start.graphemeIndex, fragment.end.segmentIndex, fragment.end.graphemeIndex);
+}
+export function materializeRichInlineLineRange(prepared, line) {
+    const flow = getInternalPreparedRichInline(prepared);
+    const fragments = [];
+    for(let i = 0; i < line.fragments.length; i++){
+        const fragment = line.fragments[i];
+        const item = flow.items[fragment.itemIndex];
+        if (item === undefined) throw new Error('Missing rich-text inline item for fragment');
+        fragments.push({
+            itemIndex: fragment.itemIndex,
+            text: materializeFragmentText(item, fragment),
+            gapBefore: fragment.gapBefore,
+            occupiedWidth: fragment.occupiedWidth,
+            start: fragment.start,
+            end: fragment.end
+        });
+    }
+    return {
+        fragments,
+        width: line.width,
+        end: line.end
+    };
+}
+export function walkRichInlineLineRanges(prepared, maxWidth, onLine) {
+    let lineCount = 0;
+    const cursor = {
+        ...RICH_INLINE_START_CURSOR
+    };
+    while(true){
+        const line = layoutNextRichInlineLineRange(prepared, maxWidth, cursor);
+        if (line === null) return lineCount;
+        cursor.itemIndex = line.end.itemIndex;
+        cursor.segmentIndex = line.end.segmentIndex;
+        cursor.graphemeIndex = line.end.graphemeIndex;
+        onLine(line);
+        lineCount++;
+    }
+}
+export function measureRichInlineStats(prepared, maxWidth) {
+    const flow = getInternalPreparedRichInline(prepared);
+    let lineCount = 0;
+    let maxLineWidth = 0;
+    const cursor = {
+        itemIndex: 0,
+        segmentIndex: 0,
+        graphemeIndex: 0
+    };
+    while(true){
+        const lineWidth = stepRichInlineLine(flow, maxWidth, cursor);
+        if (lineWidth === null) {
+            return {
+                lineCount,
+                maxLineWidth
+            };
+        }
+        lineCount++;
+        if (lineWidth > maxLineWidth) maxLineWidth = lineWidth;
+    }
+}

package/dist/agent/will.mjs

@@ -0,0 +1,167 @@
+// Rapier Will/1 grammar and range laws. SPDX-License-Identifier: MIT.
+const _RAPIER_WILL_INTENT_LIMIT = 512;
+
+const _RAPIER_WILL_LAWS = Object.freeze({ edit: true, append: true, keep: true });
+const _RAPIER_WILL_OPENER_PREFIX = '<!-- will/';
+const _RAPIER_WILL_CLOSER_PREFIX = '<!-- /will';
+const _RAPIER_WILL_CLOSER_EXACT = '<!-- /will -->';
+const _RAPIER_WILL_CLOSE_SUFFIX = ' -->';
+const _RAPIER_WILL_UNSPACED_OPENER = '<!--will/';
+const _RAPIER_WILL_UNSPACED_CLOSER = '<!--/will';
+
+function hasWillMarkers(text) {
+	return /^<!-- ?(?:will\/|\/will)/m.test(String(text == null ? '' : text));
+}
+
+function _rapierWillMarkerOf(content) {
+	const line = String(content == null ? '' : content);
+	if (line.startsWith(_RAPIER_WILL_CLOSER_PREFIX)) {
+		if (line !== _RAPIER_WILL_CLOSER_EXACT) {
+			return { kind: 'near', fault: 'malformed_marker', law: '', intent: null, content: line };
+		}
+		return { kind: 'close', law: '', intent: null, content: line };
+	}
+	if (!line.startsWith(_RAPIER_WILL_OPENER_PREFIX)) {
+		if (line.startsWith(_RAPIER_WILL_UNSPACED_OPENER) || line.startsWith(_RAPIER_WILL_UNSPACED_CLOSER)) {
+			return { kind: 'near', fault: 'malformed_marker', law: '', intent: null, content: line };
+		}
+		return null;
+	}
+	const near = fault => ({ kind: 'near', fault, law: '', intent: null, content: line });
+	if (!line.endsWith(_RAPIER_WILL_CLOSE_SUFFIX)) return near('malformed_marker');
+	const middle = line.slice(_RAPIER_WILL_OPENER_PREFIX.length,
+		line.length - _RAPIER_WILL_CLOSE_SUFFIX.length);
+	const gap = middle.indexOf(' ');
+	if ((gap < 0 ? middle : middle.slice(0, gap)) !== '1') return near('unknown_version');
+	if (gap < 0) return near('malformed_marker');
+	const rest = middle.slice(gap + 1);
+	const word = (/^[^:\s]*/.exec(rest))[0];
+	if (!word) return near('malformed_marker');
+	let intent;
+	if (rest === word) intent = null;
+	else if (rest.startsWith(word + ': ')) intent = rest.slice(word.length + 2);
+	else return near('malformed_marker');
+	if (!Object.prototype.hasOwnProperty.call(_RAPIER_WILL_LAWS, word)) return near('unknown_law');
+	if (intent !== null) {
+		if (!intent.length || intent.indexOf('--') >= 0) return near('malformed_marker');
+		if ([...intent].length > _RAPIER_WILL_INTENT_LIMIT) return near('intent_over_bound');
+	}
+	// The words after the colon are document data, never permission (R85b); willGovern alone decides.
+	return { kind: 'open', law: word, intent, content: line };
+}
+
+// Scan CR, CRLF and LF lines directly into Will's reducer, including a trailing empty line.
+// Offsets remain authored UTF-16 coordinates; no editor helper or whole-document line tables.
+function _rapierWillParse(text) {
+	const source = String(text == null ? '' : text);
+	const will = {
+		present: false, fault: '', faults: [], blocks: [], markers: [], regions: [], text: source,
+	};
+	let open = null;
+	for (let index = 0, start = 0; start <= source.length; index++) {
+		let contentEnd = start;
+		while (contentEnd < source.length && source.charCodeAt(contentEnd) !== 13 && source.charCodeAt(contentEnd) !== 10) contentEnd++;
+		let lineEnd = contentEnd;
+		if (lineEnd < source.length) {
+			lineEnd++;
+			if (source.charCodeAt(contentEnd) === 13 && source.charCodeAt(lineEnd) === 10) lineEnd++;
+		}
+		const row = { start, contentEnd, lineEnd };
+		start = contentEnd < source.length ? lineEnd : source.length + 1;
+		const marker = _rapierWillMarkerOf(source.slice(row.start, row.contentEnd));
+		if (!marker) continue;
+		will.present = true;
+		will.blocks.push({ start: row.start, end: row.lineEnd });
+		const stamped = {
+			...marker, line: index, start: row.start, end: row.lineEnd, contentEnd: row.contentEnd,
+		};
+		if (marker.kind === 'near') {
+			will.faults.push({ mode: marker.fault, line: index, start: row.start, end: row.lineEnd });
+			continue;
+		}
+		if (marker.kind === 'close') {
+			if (!open) {
+				will.faults.push({ mode: 'unpaired_marker', line: index, start: row.start, end: row.lineEnd });
+				continue;
+			}
+			will.markers.push(open, stamped);
+			will.regions.push({
+				index: will.regions.length, law: open.law, intent: open.intent,
+				openerLine: open.line, openerStart: open.start, openerEnd: open.end,
+				openerContentEnd: open.contentEnd,
+				closerLine: index, closerStart: stamped.start, closerEnd: stamped.end,
+				start: open.end, end: stamped.start,
+			});
+			open = null;
+			continue;
+		}
+		if (open) {
+			will.faults.push({ mode: 'unpaired_marker', line: index, start: row.start, end: row.lineEnd });
+			continue;
+		}
+		open = stamped;
+	}
+	if (open) will.faults.push({ mode: 'unpaired_marker', line: open.line, start: open.start, end: open.end });
+	will.faults.sort((a, b) => a.start - b.start);
+	will.fault = will.faults.length ? will.faults[0].mode : '';
+	return will;
+}
+
+function _rapierWillRegionsIn(will, start, end) {
+	const found = [];
+	for (const region of will.regions) {
+		const touches = start === end
+			? start >= region.start && start <= region.end
+			: start < region.end && region.start < end;
+		if (touches) found.push(region);
+	}
+	return found;
+}
+
+function _rapierWillTouchesMarker(will, start, end) {
+	const touches = (from, to) => start === end
+		? start > from && start < to
+		: start < to && from < end;
+	for (const region of will.regions) {
+		if (touches(region.openerStart, region.openerEnd) ||
+				touches(region.closerStart, region.closerEnd)) return region;
+	}
+	for (const block of will.blocks) if (touches(block.start, block.end)) return { law: 'keep' };
+	return null;
+}
+
+function _rapierWillGovern(will, start, end) {
+	if (will.faults.length) return 'keep';
+	if (_rapierWillTouchesMarker(will, start, end)) return 'keep';
+	let law = 'edit';
+	for (const region of _rapierWillRegionsIn(will, start, end)) {
+		if (region.law === 'keep') return 'keep';
+		if (region.law === 'append') law = 'append';
+	}
+	return law;
+}
+
+function _rapierWillIntentOf(will, start, end) {
+	if (!will.present || will.faults.length) return '';
+	const found = _rapierWillRegionsIn(will, start, end);
+	if (found.length !== 1) return '';
+	const region = found[0];
+	// Disclosed with the region's law, never in place of it: under keep and append the words widen nothing.
+	return region.intent && start >= region.start && end <= region.end ? region.intent : '';
+}
+
+
+function _rapierWillTerminatorWidth(last, prior) {
+	if (last === 10) return prior === 13 ? 2 : 1;
+	if (last === 13) return 1;
+	return 0;
+}
+
+function _rapierWillStripOneTerminator(text) {
+	const end = text.length;
+	return end ? text.slice(0, end - _rapierWillTerminatorWidth(
+		text.charCodeAt(end - 1), end >= 2 ? text.charCodeAt(end - 2) : -1)) : text;
+}
+
+
+export { hasWillMarkers, _rapierWillParse as parseWill, _rapierWillMarkerOf as willMarkerOf, _rapierWillRegionsIn as willRegionsIn, _rapierWillTouchesMarker as willTouchesMarker, _rapierWillGovern as willGovern, _rapierWillIntentOf as willIntentOf, _rapierWillStripOneTerminator as stripOneTerminator, _rapierWillTerminatorWidth as terminatorWidth };

package/dist/kit/assets.mjs

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MIT
+// Re-export from ../spec/md-assets.mjs only: ../images/assets.mjs pulls AGPL decoders into the MIT graph (tools/check-kit.mjs).
+export * from '../spec/md-assets.mjs';