rapier-markdown-kit 1.2.40 → 1.2.42

package/dist/agent/will.mjs

@@ -215,7 +215,7 @@ export function willTransition(beforeText, afterText, splices, markerSplices = s
 	return null;
 }
 
-export function evaluateWill(beforeText, splices) {
+export function evaluateWill(beforeText, splices, {restores = null} = {}) {
 	const invalid = rule => ({outcome: 'invalid', reason: 'precondition', rule});
 	if (typeof beforeText !== 'string' || !beforeText.isWellFormed()) return invalid('invalid_unicode');
 	if (!Array.isArray(splices)) return invalid('malformed_splice');
@@ -231,7 +231,7 @@ export function evaluateWill(beforeText, splices) {
 		if (afterText.slice(row.pos, end) !== row.removed) return invalid('source_mismatch');
 		afterText = afterText.slice(0, row.pos) + row.inserted + afterText.slice(end);
 	}
-	const refusal = splices.length && willTransition(beforeText, afterText, splices);
+	const refusal = splices.length && willTransition(beforeText, afterText, splices, splices, {restores});
 	return refusal ? {outcome: 'refused', reason: 'document_law', ...refusal} : {outcome: 'applied'};
 }
 

package/dist/kit/ledger/data.mjs

@@ -44,11 +44,13 @@ function* quoted(text, whole = true) {
   }
   yield '"';
 }
-function* dataParts(value, depth, active, sorted) {
+function* dataParts(value, depth, active, sorted, known = null) {
   if (typeof value === 'string') { yield* quoted(value); return; }
   if (value === null || typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value) && !Object.is(value, -0)) {
     yield JSON.stringify(value); return;
   }
+  const text = known?.(value, depth);
+  if (text !== undefined) { yield text; return; }
   const {array, descriptors, keys} = fields(value, depth, active, sorted);
   active.add(value);
   yield array ? '[' : '{';
@@ -56,14 +58,65 @@ function* dataParts(value, depth, active, sorted) {
     if (i) yield ',';
     const key = keys[i];
     if (!array) { yield* quoted(key, false); yield ':'; }
-    yield* dataParts(descriptors[key].value, depth + 1, active, sorted);
+    yield* dataParts(descriptors[key].value, depth + 1, active, sorted, known);
   }
   yield array ? ']' : '}';
   active.delete(value);
 }
 export function canonicalParts(value, depth = 0, active = new Set()) { return dataParts(value, depth, active, true); }
 export function jsonParts(value) { return dataParts(value, 0, new Set(), false); }
+export function jsonPartsKnown(value, known) { return dataParts(value, 0, new Set(), false, known); }
+export function jsonTextAt(value, depth) { return Array.from(dataParts(value, depth, new Set(), false)).join(''); }
 export function canonicalJSON(value, depth = 0, active = new Set()) { return Array.from(canonicalParts(value, depth, active)).join(''); }
+const ownedRows = new WeakSet(), rowCanonical = new Map();
+let rowCanonicalChars = 0;
+const ROW_CANONICAL_LIMIT = 32 * 1024 * 1024;
+function freezeData(value) {
+  if (!value || typeof value !== 'object' || ownedRows.has(value) || ownedLedgers.has(value)) return value;
+  for (const key of Object.keys(value)) freezeData(value[key]);
+  return Object.freeze(value);
+}
+export function ownRow(row) { if (!ownedRows.has(row)) { freezeData(row); ownedRows.add(row); } return row; }
+const ownedLedgers = new WeakSet();
+export function ownLedger(ledger) {
+  if (ledger && typeof ledger === 'object' && !ownedLedgers.has(ledger)) { freezeData(ledger); ownedLedgers.add(ledger); }
+  return ledger;
+}
+export function isOwnedLedger(ledger) { return !!ledger && ownedLedgers.has(ledger); }
+const rowText = new WeakMap();
+function canonicalRow(row, depth) {
+  if (!ownedRows.has(row)) return canonicalJSON(row, depth);
+  const own = rowText.get(row);
+  if (own?.depth === depth) return own.json;
+  const json = keyedRow(row, depth);
+  rowText.set(row, {depth, json});
+  return json;
+}
+function keyedRow(row, depth) {
+  const id = typeof row.transaction?.id === 'string' ? row.transaction.id : null, seen = JSON.stringify(row);
+  const hit = id === null ? null : rowCanonical.get(id);
+  if (hit && hit.depth === depth && hit.seen.includes(seen)) return hit.json;
+  const json = canonicalJSON(row, depth);
+  if (id !== null && 2 * seen.length + json.length <= ROW_CANONICAL_LIMIT / 4) {
+    const size = entry => entry.seen.reduce((sum, text) => sum + text.length, entry.json.length);
+    const seenAlso = hit && hit.depth === depth && hit.json === json ? [hit.seen.at(-1), seen] : [seen];
+    if (hit) { rowCanonical.delete(id); rowCanonicalChars -= size(hit); }
+    const entry = {depth, seen: seenAlso, json};
+    rowCanonical.set(id, entry); rowCanonicalChars += size(entry);
+    for (const [key, value] of rowCanonical) {
+      if (rowCanonicalChars <= ROW_CANONICAL_LIMIT) break;
+      rowCanonical.delete(key); rowCanonicalChars -= size(value);
+    }
+  }
+  return json;
+}
+export function* canonicalRowsParts(rows, depth = 0) {
+  const {array, keys} = fields(rows, depth, new Set());
+  if (!array) { yield* canonicalParts(rows, depth); return; }
+  yield '[';
+  for (let i = 0; i < keys.length; i++) { if (i) yield ','; yield canonicalRow(rows[keys[i]], depth + 1); }
+  yield ']';
+}
 export function exactKeys(value, keys) {
   return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
 }

package/dist/kit/ledger/format.mjs

@@ -4,7 +4,7 @@ import {pictureHistorySplices} from './history.mjs';
 import {HistorySource} from './source.mjs';
 import {authoredHistory} from './transport.mjs';
 import {textRoot, rootAfter, sha256, sha256PartsAsync, createSHA256} from './hash.mjs';
-import {canonicalJSON, canonicalParts, plainData, documentText, utf8Length, exactKeys, nonnegative, fault} from './data.mjs';
+import {canonicalJSON, canonicalParts, canonicalRowsParts, ownRow, ownLedger, isOwnedLedger, plainData, documentText, utf8Length, exactKeys, nonnegative, fault} from './data.mjs';
 import {diff} from '../../packages/rapier-diff/diff.mjs';
 import {minimalHistorySplice} from './inverse-source.mjs';
 import {evaluateWill} from '../../agent/will.mjs';
@@ -27,32 +27,47 @@ function* checkedRecords(ledger, prepared) {
   }
   if (ledger.head.revision !== revision || ledger.head.root !== root) throw fault('history does not describe this document');
 }
+function* envelopeParts(envelope) {
+  const keys = Object.keys(envelope).sort();
+  yield '{';
+  for (let i = 0; i < keys.length; i++) {
+    if (i) yield ',';
+    yield JSON.stringify(keys[i]); yield ':';
+    yield* keys[i] === 'records' ? canonicalRowsParts(envelope.records, 1) : canonicalParts(envelope[keys[i]], 1, new Set());
+  }
+  yield '}';
+}
 const proofs = new WeakMap();
+function ownedRows(ledger) {
+  if (ledger && Array.isArray(ledger.records)) for (const row of ledger.records) if (row && typeof row === 'object') ownRow(row);
+  return ledger;
+}
 function copiedLedger(input, proof) {
-  if (!proof || !input || typeof input !== 'object') return plainData(input);
+  if (!proof || !input || typeof input !== 'object') return ownedRows(plainData(input));
   const fields = Object.getOwnPropertyDescriptors(input), start = fields.start;
-  if (!start || !Object.hasOwn(start, 'value') || !start.value || typeof start.value !== 'object') return plainData(input);
+  if (!start || !Object.hasOwn(start, 'value') || !start.value || typeof start.value !== 'object') return ownedRows(plainData(input));
   const parts = Object.getOwnPropertyDescriptors(start.value), text = parts.text;
-  if (!text || !Object.hasOwn(text, 'value') || text.value !== proof.startText) return plainData(input);
+  if (!text || !Object.hasOwn(text, 'value') || text.value !== proof.startText) return ownedRows(plainData(input));
   const shell = Object.create(Object.getPrototypeOf(input), {...fields, start: {...start,
     value: Object.create(Object.getPrototypeOf(start.value), {...parts, text: {...text, value: ''}})}});
-  const ledger = plainData(shell);
+  const ledger = ownedRows(plainData(shell));
   ledger.start.text = proof.startText;
   return ledger;
 }
 function ledgerAdmission(input) {
   const held = input && typeof input === 'object' ? proofs.get(input) : undefined;
+  if (held && isOwnedLedger(input)) return {ledger: input, shell: held.shell, proof: held};
   const ledger = copiedLedger(input, held);
   if (!exactKeys(ledger, ['format','documentAuthority','start','records','head','complete','sha256']) || ledger.format !== 'rapier-ledger/2' ||
       typeof ledger.documentAuthority !== 'string' || !ledger.documentAuthority || ledger.documentAuthority.length > 256 ||
       typeof ledger.complete !== 'boolean' || !Array.isArray(ledger.records) ||
       !exactKeys(ledger.start, ['text','revision','root','sha256','metadata']) || !exactKeys(ledger.head, ['revision','root','sha256','metadata'])) throw fault('unsupported or invalid envelope');
-  const shell = canonicalJSON({...ledger, start: {...ledger.start, text: ''}});
+  const shell = Array.from(envelopeParts({...ledger, start: {...ledger.start, text: ''}})).join('');
   const proof = held?.shell === shell && held.startText === ledger.start.text ? held : null;
   return {ledger, shell, proof};
 }
 function ledgerResult(ledger, proof, expectedText, expectedMetadata) {
-  proofs.set(ledger, proof);
+  proofs.set(ledger, proof); ownLedger(ledger);
   const {text, metadata, root, revision, prepared, source} = proof;
   if (expectedMetadata !== undefined && (!_rapierValidMetadata(expectedMetadata) || canonicalJSON(metadata) !== canonicalJSON(expectedMetadata)))
     throw fault('metadata does not describe this document');
@@ -67,7 +82,7 @@ function readLedgerState(input, expectedText, expectedMetadata) {
 }
 function* proveLedger(ledger, native = false) {
   const {sha256: claimed, ...payload} = ledger;
-  if (claimed !== (yield* checksum(canonicalParts(payload), native))) throw fault('envelope checksum differs');
+  if (claimed !== (yield* checksum(envelopeParts(payload), native))) throw fault('envelope checksum differs');
   let text = ledger.start.text, root = ledger.start.root, revision = ledger.start.revision;
   const startFacts = yield* sourceFacts(text, native);
   if (!_rapierValidMetadata(ledger.start.metadata) || !_rapierValidMetadata(ledger.head.metadata)) throw fault('invalid document metadata');
@@ -151,6 +166,10 @@ function* sourceFacts(text, native = false) {
   return {utf8Bytes: bytes, sha256: digest, contentRoot: text.length + ':' +
     (fnv >>> 0).toString(36) + ':' + (((b << 16) | a) >>> 0).toString(36)};
 }
+const expandedRows = new WeakMap();
+const sameSplices = (a, b) => a === b || a.length === b.length &&
+  a.every((row, i) => row.pos === b[i].pos && row.removed === b[i].removed && row.inserted === b[i].inserted);
+const sameEffect = (a, b) => a === b || !!a && !!b && canonicalJSON(a) === canonicalJSON(b);
 function* produceLedger({text, metadata, records, documentAuthority, revision, root, complete = false, earlier = records} = {}, native = false) {
   if (!_rapierValidMetadata(metadata)) throw fault('document metadata required');
   metadata = {...metadata};
@@ -162,10 +181,13 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
   const expanded = [];
   for (const {record, splices: rows, metadata: effect} of prepared.rows) {
     if (!rows || effect === undefined) throw fault('navigation target was not retained');
-    expanded.push({transaction: plainData(record.transaction), splices: rows.map(row => ({pos: row.pos, removed: row.removed, inserted: row.inserted})),
+    const held = expandedRows.get(record);
+    if (held && sameSplices(held.rows, rows) && sameEffect(held.effect, effect)) { expanded.push(held.row); yield; continue; }
+    expanded.push(ownRow({transaction: plainData(record.transaction), splices: rows.map(row => ({pos: row.pos, removed: row.removed, inserted: row.inserted})),
       beforeHash: record.beforeHash, afterHash: record.afterHash, ...(Object.hasOwn(record, 'authored') ? {authored: plainData(record.authored)} : {}), ...(effect ? {metadata: plainData(effect)} : {}),
       ...(record.changeSet && Object.hasOwn(record.changeSet, 'label') ? {changeSet: {label: typeof record.changeSet.label === 'string' ? record.changeSet.label : plainData(record.changeSet.label)}} : {}),
-      ...(record.derivedCommentIndex == null ? {} : {derivedCommentIndex: typeof record.derivedCommentIndex === 'string' ? record.derivedCommentIndex : plainData(record.derivedCommentIndex)})});
+      ...(record.derivedCommentIndex == null ? {} : {derivedCommentIndex: typeof record.derivedCommentIndex === 'string' ? record.derivedCommentIndex : plainData(record.derivedCommentIndex)})}));
+    expandedRows.set(record, {row: expanded.at(-1), rows, effect});
     yield;
   }
   const headBytes = bytes;
@@ -199,8 +221,9 @@ function* produceLedger({text, metadata, records, documentAuthority, revision, r
   }
   const replayedMetadata = prepared.replayMetadata(startMetadata);
   if (!replayedMetadata || canonicalJSON(replayedMetadata) !== canonicalJSON(metadata)) throw fault('metadata does not describe this document');
-  const ledger = {...payload, sha256: yield* checksum(canonicalParts(payload), native)};
-  proofs.set(ledger, {shell: canonicalJSON({...ledger, start: {...ledger.start, text: ''}}), startText,
+  const ledger = {...payload, sha256: yield* checksum(envelopeParts(payload), native)};
+  ownLedger(ledger);
+  proofs.set(ledger, {shell: Array.from(envelopeParts({...ledger, start: {...ledger.start, text: ''}})).join(''), startText,
     text, metadata: {...metadata}, root, revision, prepared: _rapierPrepareHistoryRecords(ledger.records),
     source: new HistorySource(text)});
   return {ledger, contentRoot, utf8Bytes: headBytes};

package/dist/kit/ledger/history.mjs

@@ -363,7 +363,7 @@ export function selectiveUndo(input, actIds, options = {}) {
 		const result = projectInverseSource(transported ? {...prepared, rows, records: transported.records} : prepared, selected, projectedEffects, options);
 		if (!result.ok) return result;
 		if (options.actor?.kind === 'agent' && prepared.metadata.docKind === 'markdown' &&
-			evaluateWill(prepared.source, result.splices).outcome !== 'applied')
+			evaluateWill(prepared.source, result.splices, {restores: result.splices}).outcome !== 'applied')
 			return historyFailure('will_refused');
 		return {...result, actIds: [...requested], sourceTransactionIds: [...selected], metadata, afterMetadata,
 			effectChanged, unchanged: result.after === prepared.source && !metadata && !effectChanged};

package/dist/kit/ledger/inverse-source.mjs

@@ -32,6 +32,8 @@ function historyHunks(row) {
 }
 
 
+const differentActors = (a, b) => !!a && !!b && (a.kind !== b.kind || a.id !== b.id);
+
 export function projectInverseSource(prepared, selected, projectedEffects, options = {}) {
 	const records = prepared.records || prepared.rows.map(({record, splices}) => record.splices === splices ? record : {...record, splices});
 	if (!options.origins && !records.some(record => !prepared.effects.references.get(record.transaction.id)?.length &&
@@ -40,6 +42,7 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 	try {
 		let pieces = prepared.initialSource ? [{text: prepared.initialSource, owner: null, lineage: []}] : [];
 		const all = [], byId = new Map(), byAct = new Map(), processed = [], keptInverseAncestors = new Set();
+		const actorOf = new Map(records.map(record => [record.transaction.id, record.transaction.actor]));
 		const recordsForCover = prepared.records || prepared.rows.map(({record, splices}) => record.splices === splices ? record : {...record, splices});
 		const coverGroups = new Map();
 		let coverOrigins = null;
@@ -280,6 +283,12 @@ export function projectInverseSource(prepared, selected, projectedEffects, optio
 					const id = tx.id + '#' + rowIndex + ':' + index;
 					const lineage = new Set([id]);
 					for (const piece of removed) for (const parent of piece.lineage || piece.mark?.lineage || []) lineage.add(parent);
+					if (!row.removed.length && !count && at > 0 && /[\p{L}\p{N}\p{M}]/u.test(row.inserted)) {
+						const left = pieces[at - 1], right = pieces[at];
+						const inner = left?.text && right?.text && left.owner === right.owner ? byId.get(left.owner) : null;
+						if (inner && inner.actId !== tx.id && inner.removed && differentActors(actorOf.get(inner.actId), tx.actor) && /[\p{L}\p{N}\p{M}]$/u.test(left.text) && /^[\p{L}\p{N}\p{M}]/u.test(right.text))
+							for (const parent of [inner.id, ...(left.lineage || [])]) lineage.add(parent);
+					}
 					const hunk = {id, actId: tx.id, removed: row.removed, inserted: row.inserted, before: removed, derived,
 						chosen, kept: selected.has(tx.id) && !chosen, lineage: [...lineage], supersededBy: new Set(), active: true,
 						...(coverIdsFor(tx.id) ? {coverIds: coverIdsFor(tx.id)} : {})};

package/dist/kit/ledger/journal-records.mjs

@@ -76,7 +76,7 @@ function _rapierValidAuthored(origin) {
 		!/[\uD800-\uDFFF]/u.test(row.removed) && !/[\uD800-\uDFFF]/u.test(row.inserted));
 }
 
-function _rapierRecordIndex(records) {
+function _rapierRecordIndex(records, shared = false) {
 	const byId = new Map(), splices = new Map(), metadata = new Map();
 	for (const record of records) {
 		const id = record?.transaction?.id;
@@ -100,9 +100,12 @@ function _rapierRecordIndex(records) {
 		}
 		cache.set(current, value);
 		for (let i = path.length - 1; i >= 0; i--) {
-			if (path[i].transaction.reverts && value != null) value = effects
-				? Object.fromEntries(Object.entries(value).map(([key, pair]) => [key, {before: pair.after, after: pair.before}]))
-				: value.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
+			if (path[i].transaction.reverts && value != null) {
+				value = effects
+					? Object.fromEntries(Object.entries(value).map(([key, pair]) => [key, {before: pair.after, after: pair.before}]))
+					: value.slice().reverse().map(row => ({pos: row.pos, removed: row.inserted, inserted: row.removed}));
+				if (shared) { for (const row of Object.values(value)) Object.freeze(row); Object.freeze(value); }
+			}
 			cache.set(path[i], value);
 		}
 		return value;
@@ -110,10 +113,27 @@ function _rapierRecordIndex(records) {
 	return {byId, splices: record => resolve(record, false), metadata: record => resolve(record, true)};
 }
 
+const _rapierLedgerIndexes = new WeakMap();
+function _rapierLedgerIndex(ledger) {
+	const records = ledger || [];
+	if (!Array.isArray(records)) return _rapierRecordIndex(records);
+	const held = _rapierLedgerIndexes.get(records);
+	if (held && held.records.length === records.length && held.records.at(-1) === records.at(-1) &&
+		(held.checked || held.records.every((record, at) => record === records[at]))) {
+		if (!held.checked) { held.checked = true; queueMicrotask(() => { held.checked = false; }); }
+		return held.index;
+	}
+	if (!records.every(record => record && typeof record === 'object' && Object.isFrozen(record) && Object.isFrozen(record.transaction ?? {})))
+		return _rapierRecordIndex(records);
+	const index = _rapierRecordIndex(records, true);
+	_rapierLedgerIndexes.set(records, {records: records.slice(), index});
+	return index;
+}
+
 function _rapierRecordSplices(entry, ledger) {
 	try {
 		if (entry && Array.isArray(entry.splices)) return entry.splices;
-		return _rapierRecordIndex(ledger || []).splices(entry);
+		return _rapierLedgerIndex(ledger).splices(entry);
 	} catch (_) { return null; }
 }
 
@@ -163,7 +183,7 @@ function _rapierRecordMetadata(entry, ledger) {
 	try {
 		if (Object.hasOwn(entry, 'metadata')) return _rapierValidMetadataEffect(entry.metadata) ? entry.metadata : undefined;
 		if (Array.isArray(entry.splices)) return null;
-		return _rapierRecordIndex(ledger || []).metadata(entry);
+		return _rapierLedgerIndex(ledger).metadata(entry);
 	} catch (_) { return undefined; }
 }
 
@@ -507,9 +527,10 @@ const _rapierPrepareHistoryRecords = (() => {
 
 const _rapierJournalRecord = (() => {
 	const copies = new WeakMap();
+	const fixed = value => { if (value && typeof value === 'object') { for (const key of Object.keys(value)) fixed(value[key]); Object.freeze(value); } return value; };
 	return record => {
 		let copy = copies.get(record);
-		if (!copy) { copy = JSON.parse(JSON.stringify(record)); copies.set(record, copy); }
+		if (!copy) { copy = fixed(JSON.parse(JSON.stringify(record))); copies.set(record, copy); }
 		return copy;
 	};
 })();

package/dist/kit/render-markdown.mjs

@@ -340,6 +340,7 @@ function initMarkdownIt() {
 	};
 
 	const _fenceDefault = md.renderer.rules.fence;
+	let _mathPromptedOnce = false;
 	{
 		let _diagramPromptedOnce = false;
 		md.renderer.rules.fence = function (tokens, idx, opts, env, self) {
@@ -366,8 +367,16 @@ function initMarkdownIt() {
 			}
 			const provider = env.rapierProviders === false ? null : _rapierProviders.mermaid;
 			const native = globalThis.RapierFlowchart?.parseFlowchart(src).ok === true;
-			const ready = native || !!(provider && provider.status === 'ready' && typeof provider.renderToString === 'function');
-			if (!ready && !provider?.request?.() && env.rapierProviders !== false && !_diagramPromptedOnce) {
+			const diagramReady = native || !!(provider && provider.status === 'ready' && typeof provider.renderToString === 'function');
+			const mathProvider = env.rapierProviders === false ? null : _rapierProviders.math;
+			const mathNeeded = provider?.requiresMath?.(src) === true;
+			const mathReady = !mathNeeded || mathProvider?.status === 'ready';
+			if (!mathReady && !mathProvider?.request?.() && env.rapierProviders !== false && !_mathPromptedOnce) {
+				_mathPromptedOnce = true;
+				try { _rapierUiMath.request(); } catch (_) {}
+			}
+			const ready = diagramReady && mathReady;
+			if (!diagramReady && !provider?.request?.() && env.rapierProviders !== false && !_diagramPromptedOnce) {
 				_diagramPromptedOnce = true;
 				try { _rapierUiDiagram.request(); } catch (_) {}
 			}
@@ -401,7 +410,6 @@ function initMarkdownIt() {
 	preserveEmphasisMarkup('strong_open', 'data-rapier-strong');
 
 	{
-		let _mathPromptedOnce = false;
 		const _renderMath = (src, displayMode, env, authored) => {
 			const marker = displayMode ? '$$' : '$';
 			const source = authored || marker + src + marker, literal = md.utils.escapeHtml(source);
@@ -444,6 +452,10 @@ function initMarkdownIt() {
 	}
 	globalThis.RapierMarkdownLayout.installMarkdownLayout(md);
 	globalThis.RapierImageAssets.configureParser(md, _rapierSplitOpeningFrontmatter);
+	const render = md.renderer.render;
+	md.renderer.render = function (tokens, options, env) {
+		return render.call(this, _rapierCloseOpenDetails(tokens), options, env);
+	};
 }
 
 function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
@@ -470,12 +482,13 @@ function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 	if (wikiLinks) env.rapierWikiLinks = wikiLinks;
 	if (options.mathEquations) env.rapierMathEquations = options.mathEquations;
 	const nesting = md && options.maxNesting > 0 ? options.maxNesting : 0;
-	let rendered;
+	let cutAt = -1, rendered;
 	if (nesting || md && options.closeDetails) {
 		const saved = md.options.maxNesting;
 		if (nesting) md.options.maxNesting = nesting;
 		try {
 			const tokens = md.parse(markdown, env);
+			if (nesting) cutAt = _rapierNestingCutAt(tokens, nesting);
 			rendered = md.renderer.render(options.closeDetails ? _rapierCloseOpenDetails(tokens) : tokens, md.options, env);
 		} finally { md.options.maxNesting = saved; }
 	} else rendered = md
@@ -487,6 +500,7 @@ function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 		rendered = _relabelFootnoteHtml(rendered, labels);
 	}
 	root.innerHTML = sanitizeRapierHtml(rendered, options.page ? 'source' : 'export');
+	if (cutAt >= 0) _rapierAppendNestingCut(root, markdown, cutAt);
 	_rapierApplyBlockDirection(root);
 
 	_rapierAssignHeadingSlugs(root, RAPIER_RENDERED_HEADING_SELECTOR, false);
@@ -500,6 +514,15 @@ function _rapierRenderSemanticRoot(canonical, metadata, options = {}) {
 	return root;
 }
 
+function _rapierAppendNestingCut(root, markdown, cutAt) {
+	const note = root.ownerDocument.createElement('p'), pre = root.ownerDocument.createElement('pre'), code = root.ownerDocument.createElement('code');
+	note.setAttribute('data-rapier-nesting-cut', 'true');
+	note.textContent = 'Nesting is too deep to show here. The rest of the document follows as plain text.';
+	code.textContent = String(markdown).split('\n').slice(cutAt).join('\n');
+	pre.append(code);
+	root.append(note, pre);
+}
+const _rapierNestingCutAt = (tokens, nesting) => { const deepest = tokens.find(token => token.level >= nesting - 1 && token.map); return deepest ? deepest.map[0] + 1 : -1; };
 async function _rapierRenderSemanticRootAsync(canonical, metadata, options = {}) {
 	const work = options.work || options;
 	check(work);
@@ -517,9 +540,9 @@ async function _rapierRenderSemanticRootAsync(canonical, metadata, options = {})
 	let parsed;
 	try { parsed = !wikiLinks && options.parsed || (runtime.parseAsync && !wikiLinks && !nesting ? await runtime.parseAsync(markdown, options) : {tokens: md.parse(markdown, fallbackEnv), env: fallbackEnv}); }
 	finally { md.options.maxNesting = saved; }
-	let {tokens, env} = parsed;
-	if (options.closeDetails) tokens = _rapierCloseOpenDetails(tokens);
-	let labels = env.footnotes?.list?.map((item, index) => String(item?.label || ('inline-' + (index + 1))));
+	let {tokens, env} = parsed, labels = env.footnotes?.list?.map((item, index) => String(item?.label || ('inline-' + (index + 1))));
+	const cutAt = nesting ? _rapierNestingCutAt(tokens, nesting) : -1;
+	tokens = _rapierCloseOpenDetails(tokens);
 	env = {...env, rapierImagePresentation: options.imagePresentation === true};
 	await pause(work, .3);
 	const inert = document.createElement('template').content.ownerDocument;
@@ -546,6 +569,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), work);
 		await pause(work, .6);
@@ -815,7 +839,18 @@ function _rapierCloseOpenDetails(tokens) {
 	const tags = token => {
 		const found = [];
 		if (token.type === 'html_inline') found.push(token.content);
-		else if (token.type === 'html_block') _rapierRawHtmlFragment(token.content, tag => { found.push(tag); return tag; }, md);
+		else if (token.type === 'html_block') {
+			let raw = '';
+			_rapierRawHtmlFragment(token.content, tag => {
+				if (raw) { if (new RegExp('^</' + raw + '[\\t\\n\\f\\r ]*>$', 'i').test(tag)) raw = ''; }
+				else {
+					const literal = /^<(script|style|textarea|title|xmp|iframe|noembed|noframes|plaintext)(?=[\t\n\f\r />])/i.exec(tag);
+					if (literal) raw = literal[1];
+					else found.push(tag);
+				}
+				return tag;
+			}, md);
+		}
 		else if (token.type === 'inline') for (const child of token.children || []) if (child.type === 'html_inline') found.push(child.content);
 		return found;
 	};

package/dist/kit/render-sanitize.mjs

@@ -52,7 +52,7 @@ const DIAGRAM_LABEL_CSS = new Set(('color fill stroke background-color font-fami
 const DOCUMENT_STYLE_PROPERTIES = new Set([...DIAGRAM_LABEL_CSS, ...('background display visibility opacity '
 	+ 'border border-top border-right border-bottom border-left border-color border-style border-width border-collapse border-spacing '
 	+ 'border-top-color border-right-color border-bottom-color border-left-color border-top-width border-right-width border-bottom-width border-left-width '
-	+ 'table-layout caption-side empty-cells list-style-type list-style-position direction unicode-bidi '
+	+ 'table-layout caption-side empty-cells list-style-type list-style-position direction unicode-bidi hyphens '
 	+ 'stroke-width stroke-opacity stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit '
 	+ 'fill-opacity fill-rule clip-rule clip-path filter stop-color stop-opacity text-anchor dominant-baseline alignment-baseline '
 	+ 'paint-order vector-effect shape-rendering color-interpolation color-interpolation-filters').split(' ')]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapier-markdown-kit",
-  "version": "1.2.40",
+  "version": "1.2.42",
   "description": "Read, render and write Self-contained Markdown: one .md file that carries its pictures, drawings and layout, and that any Markdown app can read. HTML renderer, stylesheet, text layout, Will/1 agent permissions, and an edit history with authorship and offline merge. MIT, no dependencies.",
   "keywords": [
     "markdown",

package/style.css

@@ -391,6 +391,14 @@
 	-webkit-mask: var(--md-glyph-task-box) center / 100% 100% no-repeat;
 	mask: var(--md-glyph-task-box) center / 100% 100% no-repeat;
 }
+/* The box is a background through a mask, and two modes drop backgrounds: forced colors (Windows High Contrast) paints them as the page,
+   and print without "background graphics" leaves them out, so the boxes vanished. In those two the same mask is painted in the system's
+   text color and printed as drawn; nowhere else does anything change. */
+.md-render .task-list-item input[type="checkbox"] { -webkit-print-color-adjust: exact; print-color-adjust: exact; }
+@media (forced-colors: active) {
+	.md-render .task-list-item input[type="checkbox"] { forced-color-adjust: none; }
+	.md-render .task-list-item input[type="checkbox"]::before,.md-render .task-list-item input[type="checkbox"]:checked::after { background: CanvasText; }
+}
 .md-render .task-list-item input[type="checkbox"]:checked::before {
 	-webkit-mask-image: var(--md-glyph-task-open);
 	mask-image: var(--md-glyph-task-open);