rapier-markdown-kit 1.2.45 → 1.2.48

package/dist/kit/render-markdown.mjs

@@ -715,7 +715,7 @@ function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 	}
 	root.innerHTML = sanitizeRapierHtml(rendered, options.page ? 'source' : 'export');
 	if (cutAt >= 0) _rapierAppendNestingCut(root, markdown, cutAt);
-	_rapierApplyBlockDirection(root);
+	_rapierApplyBlockDirection(root, false, options);
 
 	_rapierAssignHeadingSlugs(root, RAPIER_RENDERED_HEADING_SELECTOR, false, options.carry?.slugs, options.carry?.headingIds);
 	_rapierDisambiguateRenderedAnchors(root);
@@ -791,7 +791,7 @@ async function _rapierRenderSemanticRootAsync(canonical, metadata, options = {})
 		if (html) append();
 		if (cutAt >= 0) _rapierAppendNestingCut(root, markdown, cutAt);
 		parsed = tokens = env = labels = null;
-		await finishAsync(_rapierSemanticDecorations(root, options.carry), work);
+		await finishAsync(_rapierSemanticDecorations(root, options.carry, options), work);
 		await pause(work, .6);
 		complete = true;
 		return root;
@@ -846,8 +846,8 @@ function _rapierReadPartDecorations(canonical, metadata, options = {}) {
 	return Object.freeze({headingIds, captionStart});
 }
 
-function* _rapierSemanticDecorations(root, carry = null) {
-	yield* _rapierApplyBlockDirectionSteps(root); yield;
+function* _rapierSemanticDecorations(root, carry = null, options = {}) {
+	yield* _rapierApplyBlockDirectionSteps(root, false, options); yield;
 	yield* _rapierAssignHeadingSlugsSteps(root, RAPIER_RENDERED_HEADING_SELECTOR, false, carry?.slugs, carry?.headingIds); yield;
 	yield* _rapierDisambiguateRenderedAnchorsSteps(root); yield;
 	for (const code of root.querySelectorAll('pre > code')) { _rapierNormalizeCodeElement(code); yield; }
@@ -1159,14 +1159,20 @@ function _rapierRawHtmlFragment(source, rewrite, parser) {
 	return out;
 }
 
-function _rapierApplyBlockDirection(root) { return finish(_rapierApplyBlockDirectionSteps(root)); }
+function _rapierApplyBlockDirection(root, includeRoot = false, options = {}) { return finish(_rapierApplyBlockDirectionSteps(root, includeRoot, options)); }
 
-function* _rapierApplyBlockDirectionSteps(root) {
+function* _rapierApplyBlockDirectionSteps(root, includeRoot = false, {authoredTableDirection = false} = {}) {
 	if (!root || typeof root.querySelectorAll !== 'function') return;
+	const tableContainers = new Set();
+	if (authoredTableDirection) for (const table of root.querySelectorAll('table')) {
+		for (let parent = table.parentElement; parent && parent !== root && !tableContainers.has(parent); parent = parent.parentElement) {
+			tableContainers.add(parent); yield;
+		}
+	}
 	const blocks = new Set(_RAPIER_DIR_BLOCKS.split(',')), elements = root.ownerDocument.createTreeWalker(root, 1);
-	for (let el = elements.nextNode(); el; el = elements.nextNode()) {
+	for (let el = includeRoot ? root : elements.nextNode(); el; el = elements.nextNode()) {
 		yield;
-		if (!blocks.has(el.localName)) continue;
+		if (!blocks.has(el.localName) || tableContainers.has(el)) continue;
 		let literal = false;
 		for (let parent = el.parentElement; parent; parent = parent.parentElement)
 			if (parent.localName === 'pre' || parent.localName === 'code') { literal = true; break; }

package/dist/kit/render-print.mjs

@@ -2,11 +2,12 @@
 import {collectPdfVectors} from './pdf-vectors.mjs';
 import {collectPdfGlyphs} from './pdf-glyphs.mjs';
 import {pdfFontSources, waitForFonts} from './export-fonts.mjs';
-import {apply as applyTypography} from '../layout/typography.mjs';
+import {printTypography} from './artifact-modules.mjs';
 import {documentLanguage, pageSizeOf, paperForLanguage} from '../spec/document-settings.mjs';
 import {applyPrintCapitals} from './print-capitals.mjs';
 import {stripOneTerminator as _rapierWillStripOneTerminator} from '../agent/will.mjs';
 import {quotedWillSpan} from '../spec/md-marks.mjs';
+import {PDF_SOURCE_DIGEST, pdfSourceDigest} from './pdf-source-digest.mjs';
 const RAPIER_WILL_SENTINEL_MARK = '⁣';
 // SPDX-License-Identifier: MIT
 function createPrintRenderer(runtime) {
@@ -229,7 +230,8 @@ async function _rapierWritePrintPdf({root, css, fontCss = '', canonical, bom = f
 	if (bodyWidth < 1 || bodyHeight < 1) refuse('pdf_page_geometry_invalid');
 	const tiled = bodyWidth > CAPTURE_EDGE || bodyHeight > CAPTURE_EDGE || bodyWidth * bodyHeight > CAPTURE_PIXELS;
 	const frame = document.createElement('iframe');
-	let vectors, backdrop = null, nativeGlyphs, filmSession;
+	let vectors, backdrop = null, nativeGlyphs, filmSession, typography;
+	const omitted = [];
 	let rejectAbort;
 	const aborted = new Promise((_, reject) => { rejectAbort = reject; });
 	aborted.catch(() => {});
@@ -281,7 +283,18 @@ async function _rapierWritePrintPdf({root, css, fontCss = '', canonical, bom = f
 		main.getBoundingClientRect();
 		if (fontCss) await step(waitForFonts(main, {fontCss, css, settings}));
 		await step(into.fonts.ready);
-		for (const image of main.querySelectorAll('img')) { image.loading = 'eager'; await step(image.decode()); }
+		for (const image of main.querySelectorAll('img')) {
+			image.loading = 'eager';
+			try { await step(image.decode()); }
+			catch (error) {
+				if (error?.name !== 'EncodingError') throw error;
+				const source = image.getAttribute('src') || '';
+				omitted.push(source.startsWith('data:') ? image.getAttribute('alt') || 'a picture' : source.slice(0, 120));
+				const holder = image.closest('p,figure');
+				image.remove();
+				if (holder && !holder.textContent.trim() && !holder.querySelector('img,svg,math,table,pre')) holder.remove();
+			}
+		}
 		wrapMasks(main);
 		check();
 		for (const node of [main, ...main.querySelectorAll('*')]) {
@@ -303,7 +316,8 @@ async function _rapierWritePrintPdf({root, css, fontCss = '', canonical, bom = f
 			main.style.setProperty(name, value, 'important');
 		globalThis.RapierMath?.fit(main);
 		applyPrintCapitals(main);
-		applyTypography(main, {all: true});
+		typography = printTypography(main, globalThis.RapierArtifactLayoutDependencies);
+		typography?.apply(main, {all: true});
 		ink?.(main);
 		const count = Math.max(1, Math.ceil((main.scrollWidth - 1) / bodyWidth));
 		if (!Number.isSafeInteger(count)) refuse('pdf_page_geometry_invalid');
@@ -421,9 +435,9 @@ async function _rapierWritePrintPdf({root, css, fontCss = '', canonical, bom = f
 		const bytes = await writeRasterPdf({pages, textPages, linkPages, vectorPages: vectors.pages, canonical, bom, filename, title, font, width, height, margins, backdrop: backdrop?.pages[0] || null,
 			pixelWidth: bodyWidth, pixelHeight: bodyHeight, pageNumbers: settings?.pagestyle === 'plain', maxBytes, check});
 		check();
-		return {bytes, pages: count, painted: nativeGlyphs.painted};
+		return {bytes, pages: count, painted: nativeGlyphs.painted, omitted};
 	} catch (error) { throw spoken(error); }
-	finally { filmSession?.close(); backdrop?.restore(); vectors?.restore(); nativeGlyphs?.restore(); signal?.removeEventListener('abort', abort); frame.remove(); }
+	finally { filmSession?.close(); backdrop?.restore(); vectors?.restore(); nativeGlyphs?.restore(); typography?.retire(frame.contentDocument); signal?.removeEventListener('abort', abort); frame.remove(); }
 }
 
 async function _rapierPrintTextPages(main, pageWidth, count, check, origin = main.getBoundingClientRect(), nativeNodes = null, markerNodes = null) {
@@ -442,6 +456,18 @@ async function _rapierPrintTextPages(main, pageWidth, count, check, origin = mai
         }
 		const marker = markerNodes?.get(node);
 		if (marker && marker.page < count) pages[marker.page].push({...marker, block: node, carrier: null, marker: true});
+		const taskItem = node.nodeType === 1 && node.matches('input[type="checkbox"]') && node.closest('li');
+		const taskParent = taskItem && node.parentElement;
+		if (taskItem && taskParent.firstElementChild === node && (taskParent === taskItem || taskParent.localName === 'p' && taskParent.parentElement === taskItem && taskItem.firstElementChild === taskParent)) {
+			const box = node.getBoundingClientRect(), style = into.defaultView.getComputedStyle(node);
+			if (box.width > 0 && box.height > 0 && style.visibility !== 'hidden' && style.visibility !== 'collapse') {
+				const page = Math.max(0, Math.min(count - 1, Math.floor((box.left - origin.left + .01) / pageWidth)));
+				const size = parseFloat(style.fontSize) || 16, width = Math.min(size, box.width), height = Math.min(size, box.height);
+				const text = node.checked ? '[x] ' : '[ ] ', part = {text, x: box.left - origin.left - page * pageWidth + (box.width - width) / 2,
+					y: box.top - origin.top + (box.height - height) / 2, width, height};
+				pages[page].push({...part, parts: [part], block: taskItem, carrier: null, marker: true});
+			}
+		}
 		const formula = node.nodeType === 1 && node.matches('.math-rendered[data-math-src]') && node.querySelector('svg');
 		if (node.nodeType === 1 && !formula || node.nodeType === 3 && element.closest('.math-rendered[data-math-src]')) continue;
 		let value;
@@ -885,7 +911,8 @@ async function writeRasterPdf({pages, textPages, linkPages = [], vectorPages = [
 		cursor += (id + ' 0 obj\n').length + objects[id].length + 8;
 	}
 	const xrefAt = cursor;
-	const xref = encode('xref\n0 ' + objects.length + '\n0000000000 65535 f \n' + offsets.slice(1).map(at => String(at).padStart(10, '0') + ' 00000 n \n').join('') + 'trailer\n<< /Size ' + objects.length + ' /Root 1 0 R /Info ' + info + ' 0 R >>\nstartxref\n' + xrefAt + '\n%%EOF\n');
+	const table = 'xref\n0 ' + objects.length + '\n0000000000 65535 f \n' + offsets.slice(1).map(at => String(at).padStart(10, '0') + ' 00000 n \n').join('') + 'trailer\n<< /Size ' + objects.length + ' /Root 1 0 R /Info ' + info + ' 0 R ' + PDF_SOURCE_DIGEST + ' >>\nstartxref\n' + xrefAt + '\n%%EOF\n';
+	const xref = encode(table), digestAt = xrefAt + table.indexOf(PDF_SOURCE_DIGEST) + PDF_SOURCE_DIGEST.indexOf('<') + 1;
 	if (cursor + xref.length > maxBytes) fail('export_too_large');
 	const bytes = new Uint8Array(cursor + xref.length);
 	bytes.set(header, 0);
@@ -899,6 +926,8 @@ async function writeRasterPdf({pages, textPages, linkPages = [], vectorPages = [
 		bytes.set(suffix, at); at += suffix.length;
 	}
 	bytes.set(xref, at);
+	bytes.set(encode(await pdfSourceDigest(bytes, digestAt, bytes.length - 1)), digestAt);
+	check();
 	return bytes;
 }
 export {createPrintRenderer, applyPrintCapitals, RAPIER_WILL_SENTINEL_MARK as sentinel};

package/dist/kit/render.mjs

@@ -9,6 +9,7 @@ import {createLineMeasurer, linesHeight} from '../layout/model.mjs';
 import {markPrintCapitals, createPrintCapitals, followingPrintProse} from './print-capitals.mjs';
 import {freezePublishedInk} from './render-ink.mjs';
 import {isTemplatePage, isPageBorderLayout} from '../spec/template-page.mjs';
+import {_rapierArtifactFactoryModules} from './artifact-modules.mjs';
 export function positionNativeDiagram(drawing) {
   const surface=drawing?.closest?.('.diagram-block,.diagram-live-preview');
   if(!surface?.clientWidth)return;
@@ -49,8 +50,7 @@ async function _rapierBuildArtifact(options, providedContext) {
 	const opts = options || {};
 	const context = providedContext || _rapierBuildInterchangeContext(opts);
 	const preference = _rapierArtifactPreference('theme', ['system', 'light', 'dark']);
-	const theme = opts.print ? 'light' : preference === 'system'
-		? (globalThis.matchMedia?.('(prefers-color-scheme: dark)').matches ? 'dark' : 'light') : preference;
+	const theme = opts.print ? 'light' : preference;
 	const metadata = context.metadata;
 	const base = context.baseName;
 	const work = context.work || opts.work;
@@ -113,8 +113,8 @@ async function _rapierBuildArtifact(options, providedContext) {
 	const styledRoot = work ? await _rapierProjectStyledRootAsync(context.semanticRoot, styledOptions)
 		: _rapierProjectStyledRoot(context.semanticRoot, styledOptions);
 	styledRoot.setAttribute('lang', language);
-	const darkPaper = theme === 'dark' && _rapierArtifactPreference('invertImageAlpha', ['true', 'false']) !== 'false';
-	const templatePage = _rapierTemplatePage(context.canonical, settings, styledRoot, darkPaper);
+	const paperTheme = _rapierArtifactPreference('invertImageAlpha', ['true', 'false']) !== 'false' ? theme : 'light';
+	const templatePage = _rapierTemplatePage(context.canonical, settings, styledRoot, paperTheme);
 	if (completePage && typeof _rapierFinalizeExportCode === 'function') await _rapierFinalizeExportCode(styledRoot);
 	if (!opts.print) _rapierAnnotateExportBoxPolygons(styledRoot);
 	if (completePage || opts.print) {
@@ -204,7 +204,7 @@ async function _rapierBuildArtifact(options, providedContext) {
 	};
 }
 
-function _rapierTemplatePage(canonical, settings, root, darkPaper = false) {
+function _rapierTemplatePage(canonical, settings, root, paperTheme = 'light') {
 	if (!isTemplatePage(canonical)) return null;
 	const paper = pageSizeOf(settings);
 	let url = '';
@@ -219,9 +219,11 @@ function _rapierTemplatePage(canonical, settings, root, darkPaper = false) {
 	const margins = ['top', 'right', 'bottom', 'left'].map(side => (settings?.geometry?.[side] ?? 1440) / 15);
 	const padding = margins.map(value => value + 'px').join(' ');
 	const ground = 'background:var(--rapier-template-border) 0 0/100% 100% no-repeat';
-	const shown = darkPaper && globalThis.RapierImageAssets.dataImage(url)?.codec === 'image/svg+xml' ? _rapierDarkPaperSvgUrl(url, '#fafafa') : url;
+	const shown = paperTheme !== 'light' && globalThis.RapierImageAssets.dataImage(url)?.codec === 'image/svg+xml' ? _rapierDarkPaperSvgUrl(url, '#fafafa') : url;
+	const screenInk = shown !== url ? '@media screen' + (paperTheme === 'system' ? ' and (prefers-color-scheme:dark)' : '')
+		+ '{:root{--rapier-template-border:url("' + shown + '")}}\n' : '';
 	const css = ':root{--rapier-template-border:url("' + url + '")}\n'
-		+ '@media screen{' + (shown !== url ? ':root{--rapier-template-border:url("' + shown + '")}' : '') + '.rapier-template-border{display:none}body{background:var(--md-color-inset)}.rapier-page{box-sizing:border-box;width:min(100%,' + width + 'px);min-height:' + height + 'px;margin:0 auto;padding:' + padding
+		+ screenInk + '@media screen{.rapier-template-border{display:none}body{background:var(--md-color-inset)}.rapier-page{box-sizing:border-box;width:min(100%,' + width + 'px);min-height:' + height + 'px;margin:0 auto;padding:' + padding
 		+ ';background:var(--rapier-template-border) 0 0/100% ' + height + 'px repeat-y,var(--md-color-bg);color:var(--md-color-text)}}\n'
 		+ '@media screen and (max-width:' + width + 'px){.rapier-page{min-height:auto;aspect-ratio:' + width + '/' + height + ';padding:'
 		+ margins.map(value => 'min(' + value + 'px,' + Number((value / width * 100).toFixed(4)) + '%)').join(' ') + ';background-size:100% auto,auto}}\n'
@@ -347,9 +349,14 @@ function* _rapierProjectStyledRootSteps(semanticRoot, options) {
 			yield;
 			cache.innerHTML = sanitizeRapierHtml(cache.innerHTML, 'export');
 		}
-		return root;
 	}
-	return yield* cleanTree(root, sanitizeRapierHtml, 'export');
+	const admitted = opts.sanitized ? root : yield* cleanTree(root, sanitizeRapierHtml, 'export');
+	for (const list of admitted.querySelectorAll('ol[start]')) {
+		yield;
+		const start = list.getAttribute('start');
+		if (/^-?\d{1,9}$/.test(start)) list.style.setProperty('counter-reset', 'rapier-ol ' + (Number(start) - 1));
+	}
+	return admitted;
 }
 
 function _rapierDocxRenderStyles(root) {
@@ -1279,11 +1286,6 @@ function _rapierImageOpenRunsList(tokens) {
 	return list;
 }
 
-function _rapierArtifactFactoryModules(dependencies, group) {
-  const paths = dependencies.groups && dependencies.groups[group] ? dependencies.groups[group] : Object.keys(dependencies.factories);
-  return paths.map(path => 'modules[' + JSON.stringify(path) + '] = (' + Function.prototype.toString.call(dependencies.factories[path]) + ')();').join('\n');
-}
-
 function _rapierProjectArtifactLayout(root, metadata, geometry, preparation) {
   if (!root || !metadata || !geometry || !preparation) return null;
   const doc = root.ownerDocument, view = doc.defaultView;

package/dist/kit/typography.d.mts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+import type {RichTextItem, PreparationOptions, Rect, SlotsForBand, SlotSequence, FlowPlan,
+  FlowFragment, FlowSlot} from './model.mjs';
+
+export interface TypographyApplyResult {
+  changed: number;
+  released: number;
+  pending: boolean;
+  prepared: number;
+}
+export interface InitialRange {start: number; end: number; text: string}
+export interface TypographySlotInput {
+  width: number;
+  top: number;
+  obstacles: readonly Rect[];
+  lineHeight: number;
+  minWidth: number;
+  slotsForBand: SlotsForBand;
+  slotSequence: SlotSequence;
+  columnsFilled(slots: readonly FlowSlot[], placed: readonly FlowSlot[]): boolean;
+  justify: boolean;
+  hyphenate: boolean;
+}
+export interface DerivedFlowFragment extends FlowFragment {
+  derive: true;
+  glyph?: string;
+}
+export interface TypographyController {
+  /** Pending work requires a subsequent call after the host yields. */
+  apply(root: Element | Document | DocumentFragment, options?: {all?: boolean; editing?: boolean}): TypographyApplyResult;
+  clear(root: Element | Document | DocumentFragment, options?: {forget?: boolean; keepSelection?: boolean}): void;
+  clearSelection(root: Element | Document | DocumentFragment): number;
+  firstLineEnd(paragraph: Element | null | undefined): number | null;
+  initialRange(input: string | Pick<Node, 'textContent'> | null | undefined): InitialRange | null;
+  protectInitial(root: Element | Document | DocumentFragment): void;
+  invalidateFonts(document?: Document | null): number;
+  retire(root: Element | Document | DocumentFragment, options?: {documentChanged?: boolean}): void;
+  slotPlan(paragraph: Element, items: readonly RichTextItem[],
+    options: Pick<PreparationOptions, 'language' | 'wordBreak'>, input: TypographySlotInput): FlowPlan<DerivedFlowFragment> | null;
+}
+/** Creates an independent disposable DOM projection owner; it never changes Markdown source. */
+export function createTypography(): TypographyController;

package/dist/kit/will.d.mts

@@ -2,7 +2,7 @@
 // Will/1: permissions a Markdown document gives agents, as HTML comments on their own lines.
 //   <!-- will/1 keep -->  ...  <!-- /will -->     keep: no change; append: add after the region's text only; edit: any change
 export type WillLaw = 'keep' | 'append' | 'edit';
-export type WillFault = 'malformed_marker' | 'unpaired_marker';
+export type WillFault = 'malformed_marker' | 'unpaired_marker' | 'unknown_version' | 'unknown_law' | 'intent_over_bound';
 /** A paired region; `start` to `end` is its text between the marker lines (UTF-16 offsets). */
 export interface WillRegion {
   index: number; law: WillLaw; intent: string | null;
@@ -40,6 +40,29 @@ export function willMarkerOf(line: string): WillMarker | null;
 export function terminatorWidth(last: number, prior: number): number;
 /** The text without one trailing line terminator. */
 export function stripOneTerminator(text: string): string;
+/** A sequential source edit in UTF-16 coordinates; removed must match the current source. */
+export interface WillSplice {pos: number; removed: string; inserted: string;}
+export interface WillRestoreOptions {
+  /** Exact splice objects the host has proved undo its own earlier act; text equality is not authority. */
+  restores?: readonly WillSplice[] | null;
+}
+export interface WillTransitionOptions extends WillRestoreOptions {
+  /** Optional output map populated with admitted contiguous append-tail inverse rows. */
+  restored?: Map<number, WillSplice[]> | null;
+}
+export type WillTransitionRefusal =
+  | {law: 'keep'; rule: 'before_faulted' | 'result_faulted'; faults: {mode: WillFault; line: number}[]; start: number; end: number}
+  | {law: WillLaw; rule: 'marker_span_touched'; editIndex: number; region: number; start: number; end: number}
+  | {law: 'keep'; rule: 'marker_sequence_mismatch'; start: number; end: number}
+  | {law: 'keep' | 'append'; rule: 'law_violated'; region: number; start: number; end: number};
+/** Maps a resulting UTF-16 offset back through sequential rows; -1 means it lies in inserted text. */
+export function willOffsetBefore(rows: readonly WillSplice[], offset: number): number;
+/** Checks marker identity and body laws after the host has proved the sequential splices. Null admits the transition. */
+export function willTransition(beforeText: string, afterText: string, splices: readonly WillSplice[],
+  markerSplices?: readonly WillSplice[], options?: WillTransitionOptions): WillTransitionRefusal | null;
+export type WillEvaluation =
+  | {outcome: 'applied'}
+  | {outcome: 'invalid'; reason: 'precondition'; rule: 'invalid_unicode' | 'malformed_splice' | 'out_of_range_splice' | 'source_mismatch'}
+  | ({outcome: 'refused'; reason: 'document_law'} & WillTransitionRefusal);
 /** Judges sequential UTF-16 source splices, including the resulting marker identities and protected text. */
-export function evaluateWill(beforeText: string, splices: {pos: number; removed: string; inserted: string}[]):
-  {outcome: 'applied'} | {outcome: 'invalid' | 'refused'; reason: string; rule: string; law?: WillLaw; region?: number};
+export function evaluateWill(beforeText: string, splices: readonly WillSplice[], options?: WillRestoreOptions): WillEvaluation;

package/dist/layout/initial-range.mjs

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+let graphemes;
+export const segment = text => (graphemes ||= new Intl.Segmenter(undefined, {granularity: 'grapheme'})).segment(text);
+export const opening = /^[\p{Ps}\p{Pi}\p{Pf}"']+$/u;
+
+export function initialRange(input) {
+  const text = typeof input === 'string' ? input : input?.textContent;
+  if (typeof text !== 'string') return null;
+  const start = /^\s*/u.exec(text)[0].length;
+  if (start === text.length) return null;
+  let end = start;
+  for (const part of segment(text.slice(start))) {
+    if (/^\s/u.test(part.segment)) break;
+    end = start + part.index + part.segment.length;
+    if (!opening.test(part.segment)) break;
+  }
+  return end > start ? {start, end, text: text.slice(start, end)} : null;
+}

package/dist/layout/typography.mjs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 import {createPreparationScope, supportsRichStyle, captureFontAuthority} from './preparation.mjs';
 import {createParagraphFitter} from './paragraph-fit.mjs';
+import {initialRange, segment, opening} from './initial-range.mjs';
 
 export function createTypography() {
   const fitter = createParagraphFitter();
@@ -16,25 +17,8 @@ export function createTypography() {
     if (!value) { value = createPreparationScope(document); documents.set(document, value); }
     return value;
   }
-  let graphemes;
-  const segment = text => (graphemes ||= new Intl.Segmenter(undefined, {granularity: 'grapheme'})).segment(text);
-  const opening = /^[\p{Ps}\p{Pi}\p{Pf}"']+$/u;
   const closing = /^[\p{Pe}\p{Pi}\p{Pf}"'.,;:!?]+$/u;
 
-  function initialRange(input) {
-    const text = typeof input === 'string' ? input : input?.textContent;
-    if (typeof text !== 'string') return null;
-    const start = /^\s*/u.exec(text)[0].length;
-    if (start === text.length) return null;
-    let end = start;
-    for (const part of segment(text.slice(start))) {
-      if (/^\s/u.test(part.segment)) break;
-      end = start + part.index + part.segment.length;
-      if (!opening.test(part.segment)) break;
-    }
-    return end > start ? {start, end, text: text.slice(start, end)} : null;
-  }
-
   const flowFloat = '.rapier-flow-float';
   const own = paragraph => [paragraph, ...[...paragraph.querySelectorAll('*')].filter(element => !element.closest(flowFloat))];
 
@@ -770,7 +754,7 @@ export const apply = typography.apply;
 export const clear = typography.clear;
 export const clearSelection = typography.clearSelection;
 export const firstLineEnd = typography.firstLineEnd;
-export const initialRange = typography.initialRange;
+export {initialRange};
 export const protectInitial = typography.protectInitial;
 export const invalidateFonts = typography.invalidateFonts;
 export const retire = typography.retire;

package/dist/math/delimiters.mjs

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+export function createMathMatcher(source, {singleDollar = false, brackets = true} = {}) {
+  if (typeof source !== 'string') throw new TypeError('Math boundaries require source text.');
+  const markers = new Map(), next = Object.create(null);
+  let slashes = 0, line = 0;
+  for (let at = 0; at < source.length;) {
+    const char = source[at];
+    if (char === '\\') { slashes++; at++; continue; }
+    if (char === '\n' || char === '\r') line++;
+    if (char === '$') {
+      let end = at + 1;
+      while (source[end] === '$') end++;
+      const count = end - at;
+      if (!(slashes & 1) && (count === 2 || count === 1 && singleDollar))
+        markers.set(at, {at, marker: count === 2 ? '$$' : '$', line});
+      at = end;
+    } else {
+      if (brackets && slashes & 1 && '()[]'.includes(char))
+        markers.set(at - 1, {at: at - 1, marker: '\\' + char, line});
+      at++;
+    }
+    slashes = 0;
+  }
+  for (const entry of [...markers.values()].reverse()) {
+    const closing = entry.marker === '\\(' ? '\\)' : entry.marker === '\\[' ? '\\]' : entry.marker;
+    entry.close = next[closing];
+    next[entry.marker] = entry;
+  }
+  return function match(start, limit = source.length) {
+    const open = markers.get(start), close = open?.close;
+    if (!close || open.marker === '\\)' || open.marker === '\\]' || close.at + close.marker.length > limit) return null;
+    const bodyStart = start + open.marker.length, bodyEnd = close.at;
+    if (open.marker === '$' && (open.line !== close.line || bodyStart === bodyEnd ||
+        /\s/.test(source[bodyStart]) || /\s/.test(source[bodyEnd - 1]) || /[0-9]/.test(source[bodyEnd + 1] || ''))) return null;
+    return {start, end: bodyEnd + close.marker.length, bodyStart, bodyEnd,
+      open: open.marker, close: close.marker, displayMode: open.marker === '$$' || open.marker === '\\['};
+  };
+}

package/dist/math/markdown-rules.mjs

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+import {createMathMatcher} from './delimiters.mjs';
+
+export function installMathRules(md, {singleDollar = false, brackets = true, ruleName = 'rapier_math', inLink = false} = {}) {
+  const authored = new WeakMap();
+  md.core.ruler.before('normalize', ruleName + '_source', state => {
+    authored.set(state.tokens, {source: state.src});
+  });
+  md.core.ruler.after('block', ruleName + '_source_release', state => authored.delete(state.tokens));
+  const tokenize = md.block.tokenize;
+  md.block.tokenize = function(state, startLine, endLine) {
+    const first = state.tokens.length;
+    try { return tokenize.call(this, state, startLine, endLine); }
+    finally {
+      for (let index = first; index < state.tokens.length; index++) {
+        const token = state.tokens[index];
+        if (token.type !== 'fence' || !token.map || token.meta?.mathSource !== undefined ||
+            String(token.info || '').trim().split(/\s+/)[0].toLowerCase() !== 'math') continue;
+        const held = authored.get(state.tokens), source = held?.source ?? state.src;
+        let value;
+        if (!state.rapierSourceSlice && source === state.src) value = state.getLines(token.map[0], token.map[1], state.blkIndent, false);
+        else {
+          if (!state.rapierSourceSlice) {
+            const starts = text => [0, ...Array.from(text.matchAll(/\r\n?|\n/g), match => match.index + match[0].length)];
+            held.rawLines ||= starts(source);
+            held.lines ||= starts(state.src);
+          }
+          const view = Object.create(state), parts = [];
+          view.bMarks = []; view.eMarks = [];
+          for (let line = token.map[0]; line < token.map[1]; line++) {
+            const shift = state.rapierSourceSlice ? 0 : held.rawLines[line] - held.lines[line];
+            view.src = state.rapierSourceSlice
+              ? state.rapierSourceSlice(state.bMarks[line], state.eMarks[line])
+              : source.slice(state.bMarks[line] + shift, state.eMarks[line] + shift);
+            view.bMarks[line] = 0; view.eMarks[line] = view.src.length;
+            parts.push(view.getLines(line, line + 1, state.blkIndent, false));
+            if (line + 1 < token.map[1]) parts.push(state.rapierSourceSlice
+              ? state.rapierSourceSlice(state.eMarks[line], state.eMarks[line] + 1)
+              : source.slice(state.eMarks[line] + shift, held.rawLines[line + 1]));
+          }
+          value = parts.join('');
+        }
+        token.meta = {...token.meta, mathSource: value};
+      }
+    }
+  };
+  const renderText = md.renderer.renderInlineAsText;
+  md.renderer.renderInlineAsText = function(tokens, options, env) {
+    return renderText.call(this, tokens.map(token =>
+      token.type === 'math_inline' || token.type === 'math_block'
+        ? {...token, type: 'text', content: token.meta?.mathSource ?? token.content}
+        : token), options, env);
+  };
+  const matchers = new WeakMap();
+  function match(state, at, limit) {
+    let entry = matchers.get(state);
+    if (!entry || entry.source !== state.src) {
+      entry = {source: state.src, match: createMathMatcher(state.src, {singleDollar, brackets})};
+      matchers.set(state, entry);
+    }
+    return entry.match(at, limit);
+  }
+  md.inline.ruler.before('escape', ruleName, (state, silent) => {
+    if (!inLink && state.linkLevel > 0) return false;
+    if (state.src[state.pos] !== '$' && state.src[state.pos] !== '\\') return false;
+    const span = match(state, state.pos, state.posMax);
+    if (!span) return false;
+    if (!silent) {
+      const token = state.push(span.displayMode ? 'math_block' : 'math_inline', '', 0);
+      token.markup = span.open;
+      token.content = state.src.slice(span.bodyStart, span.bodyEnd);
+      token.meta = {mathSource: state.src.slice(span.start, span.end)};
+    }
+    state.pos = span.end;
+    return true;
+  });
+  md.block.ruler.before('fence', ruleName, (state, startLine, endLine, silent) => {
+    if (state.sCount[startLine] - state.blkIndent >= 4) return false;
+    const start = state.bMarks[startLine] + state.tShift[startLine];
+    if (state.src.slice(start, start + 2) !== '$$' && (!brackets || state.src.slice(start, start + 2) !== '\\[')) return false;
+    const span = match(state, start, state.eMarks[endLine - 1]);
+    if (!span?.displayMode) return false;
+    let last = startLine;
+    while (last < endLine && state.eMarks[last] < span.end) last++;
+    if (last >= endLine || span.bodyEnd < state.bMarks[last] + state.tShift[last] ||
+        state.src.slice(span.end, state.eMarks[last]).trim()) return false;
+    if (silent) return true;
+    const parts = [];
+    for (let line = startLine; line <= last; line++) {
+      const from = line === startLine ? span.bodyStart : state.bMarks[line] + state.tShift[line];
+      const to = line === last ? span.bodyEnd : state.eMarks[line];
+      parts.push(state.src.slice(from, to));
+    }
+    const token = state.push('math_block', 'math', 0);
+    token.block = true;
+    token.markup = span.open;
+    token.content = parts.join('\n');
+    token.meta = {mathSource: span.open + token.content + span.close};
+    token.map = [startLine, last + 1];
+    state.line = last + 1;
+    return true;
+  }, {alt: ['paragraph', 'reference', 'blockquote', 'list']});
+}

package/dist/packages/rapier-diff/concerns.mjs

@@ -5,7 +5,7 @@ export function separate(c, endA = c.before.length, endB = c.after.length) {
   const {before, after, safe, raw, spend} = c;
   if (!raw) for (let i = c.result.length - 1; i > 0; i--) {
     const p = c.result[i - 1], q = c.result[i], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1, text = side ? after : before;
-    if (side >= 0 && !/\S/.test(text.slice(...p[side]))) {
+    if (!c.evidence && side >= 0 && !/\S/.test(text.slice(...p[side]))) {
       let n = 0;
       while (p[0][1] + n < q[0][0] && text[p[side][0] + n] === text[p[side][1] + n] && spend()) n++;
       if (p[0][1] + n === q[0][0] && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + n) && safe(k ? after : before, span[1] + n)))
@@ -20,7 +20,7 @@ export function separate(c, endA = c.before.length, endB = c.after.length) {
     keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
     c.result.splice(i - 1, 2, [x, y, false, keep[3]]);
   }
-  if (!raw) for (let i = 0; i < c.result.length; i++) {
+  if (!raw && !c.evidence) for (let i = 0; i < c.result.length; i++) {
     const p = c.result[i], q = c.result[i + 1], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1;
     if (side < 0 || p[2]) continue;
     const text = side ? after : before;