rapier-markdown-kit 1.2.46 → 1.2.48

package/README.md

@@ -81,7 +81,9 @@ editor's own seam: each needs a `host` that supplies its DOM, Markdown, picture,
 `createRenderStyles`, `createRenderSanitizer` and `createPrintRenderer`, plus the explicit font helpers
 `exportFontCss`, `requireDocumentFonts`, `fontRequests`, `waitForFonts` and `waitForFontRequests`. These are the
 functions used by the editor and exported pages. Each factory takes explicit host dependencies
-in its first argument. `style.css` is the
+in its first argument. Refined print paragraphs use the host's retained `RapierArtifactLayoutDependencies`
+(the same factory graph used by standalone HTML). They initialize in the print document so its own font set
+owns every measurement. Missing factories or a blocked initialization refuse the export. `style.css` is the
 MIT `spec/markdown-style.css`, including the numbered-list, checkbox, callout, table,
 footnote and picture-layout treatment.
 

package/dist/kit/artifact-modules.mjs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+export 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');
+}
+
+export function printTypography(root, dependencies) {
+  if (!root.querySelector('p[data-md-hyphens="auto"],p[data-md-lines],p[data-md-hanging="on"],p[data-rapier-typography]')) return null;
+  const fail = () => Object.assign(new Error('The print document could not initialize its typography.'), {code: 'pdf_typography_unavailable'});
+  if (!dependencies?.factories?.['layout/typography.mjs']) throw fail();
+  const document = root.ownerDocument, script = document.createElement('script');
+  script.textContent = '(() => { const modules = Object.create(null);\n' + _rapierArtifactFactoryModules(dependencies, 'layout') +
+    '\ndocument.currentScript.rapierTypography = modules["layout/typography.mjs"].createTypography();\n})();';
+  try {
+    document.head.append(script);
+    if (!script.rapierTypography) throw fail();
+    return script.rapierTypography;
+  } finally { script.remove(); }
+}

package/dist/kit/export-fonts.mjs

@@ -165,7 +165,6 @@ function fontSource(bytes) {
 
 function writeFace(face, source) {
   const properties = {...face.properties, src: source};
-  delete properties['unicode-range'];
   return '@font-face{' + Object.entries(properties).map(([name, value]) => name + ':' + value).join(';') + '}';
 }
 
@@ -188,8 +187,29 @@ function fontRuns(root, {settings, css = '', fontCss = '', faces = fontFaces(fon
         '--md-font-main': settings?.mainfont?.css || settings?.sansfont?.css || FAMILY,
         '--md-font-mono': settings?.monofont?.css || MONO}};
     const computed = new WeakMap();
-    let priorFace = null, priorStyle = '';
-    const breakRun = () => { priorFace = null; priorStyle = ''; };
+    let pending = null, segmenter;
+    const breakRun = () => {
+      if (!pending) return;
+      const {text, families, state} = pending;
+      let prior = new Set();
+      for (const {segment} of (segmenter ||= new Intl.Segmenter(undefined, {granularity: 'grapheme'})).segment(text)) {
+        const selected = new Set();
+        for (const character of segment) for (const family of families) {
+          const candidates = faces.filter(face => face.family === family && unicodeIncludes(face, character));
+          if (!candidates.length) continue;
+          candidates.sort((a, b) => stretchOrder(a, b, state['font-stretch']) ||
+            styleDistance(a, state['font-style']) - styleDistance(b, state['font-style']) ||
+            weightDistance(a, state['font-weight']) - weightDistance(b, state['font-weight']));
+          selected.add(candidates[0]); break;
+        }
+        for (const face of selected) {
+          if (prior.has(face)) face.runs[face.runs.length - 1] += segment;
+          else face.runs.push(segment);
+        }
+        prior = selected;
+      }
+      pending = null;
+    };
     function styleOf(element) {
       if (computed.has(element)) return computed.get(element);
       const parent = element === root ? initial : styleOf(element.parentElement || root);
@@ -231,22 +251,10 @@ function fontRuns(root, {settings, css = '', fontCss = '', faces = fontFaces(fon
       else if (state['text-transform'] === 'capitalize') text = text.replace(/(^|\s)(\p{L})/gu, (_, gap, letter) => gap + letter.toUpperCase());
       const families = splitCss(state['font-family'], ',').filter(name => /^\s*['"]/.test(name) || !CSS_GENERIC_FONT_FAMILIES.includes(unquote(name).toLowerCase()))
         .map(name => unquote(name).toLowerCase());
-      const runStyle = [state['font-weight'], state['font-style'], state['font-stretch']].join('/');
-      for (const character of text) {
-        let selected = null;
-        for (const family of families) {
-          const candidates = faces.filter(face => face.family === family && unicodeIncludes(face, character));
-          if (!candidates.length) continue;
-          candidates.sort((a, b) => stretchOrder(a, b, state['font-stretch']) ||
-            styleDistance(a, state['font-style']) - styleDistance(b, state['font-style']) ||
-            weightDistance(a, state['font-weight']) - weightDistance(b, state['font-weight']));
-          selected = candidates[0]; break;
-        }
-        if (!selected) { breakRun(); continue; }
-        if (selected === priorFace && runStyle === priorStyle) selected.runs[selected.runs.length - 1] += character;
-        else selected.runs.push(character);
-        priorFace = selected; priorStyle = runStyle;
-      }
+      const key = JSON.stringify([families, state['font-weight'], state['font-style'], state['font-stretch']]);
+      if (pending?.key !== key) breakRun();
+      if (pending) pending.text += text;
+      else pending = {text, families, state, key};
     }
     function walk(element) {
       const name = element.localName?.toLowerCase();
@@ -277,6 +285,7 @@ function fontRuns(root, {settings, css = '', fontCss = '', faces = fontFaces(fon
       if (boundary) breakRun();
     }
     walk(root);
+    breakRun();
   } finally {
     if (oldClass == null) root.removeAttribute('class'); else root.setAttribute('class', oldClass);
   }

package/dist/kit/ledger/carried.mjs

@@ -56,11 +56,19 @@ export function documentTrailer(text, options) {
 export function writeDocument(text, options) {
   return text + documentTrailer(text, options);
 }
+function trailerOpening(source) {
+  const marker = '<!-- rapier-carried/1', at = source.lastIndexOf(marker);
+  if (at < 0) return null;
+  if (source.slice(at - 2, at + marker.length + 1) === OPEN) return {start: at - 2, body: at + marker.length + 1};
+  const before = /(?:\r\n|\r|\n){2}$/.exec(source.slice(Math.max(0, at - 4), at));
+  const after = /^(?:\r\n|\r|\n)/.exec(source.slice(at + marker.length, at + marker.length + 2));
+  return before && after ? {start: at - before[0].length, body: at + marker.length + after[0].length} : null;
+}
 function unfinishedTrailer(source) {
-  if (!source.includes(OPEN)) return false;
-  const at = source.lastIndexOf(OPEN);
+  const opening = trailerOpening(source);
+  if (!opening) return false;
   let fence = null;
-  for (const line of source.slice(0, at).split('\n')) {
+  for (const line of source.slice(0, opening.start).split(/\r\n?|\n/)) {
     const found = /^ {0,3}(`{3,}|~{3,})/.exec(line);
     if (!found) continue;
     if (!fence) fence = found[1];
@@ -69,17 +77,18 @@ function unfinishedTrailer(source) {
   return !fence;
 }
 export function readDocument(source) {
-  if (!source.endsWith(CLOSE)) {
+  const closing = /(?:\r\n|\r|\n)-->(?:\r\n|\r|\n)$/.exec(source.slice(-7));
+  if (!closing) {
     if (unfinishedTrailer(source)) throw fault('unfinished document metadata');
     return {text: source, ledger: null, authorship: null};
   }
-  const at = source.lastIndexOf(OPEN);
-  if (at < 0) return {text: source, ledger: null, authorship: null};
+  const opening = trailerOpening(source);
+  if (!opening) return {text: source, ledger: null, authorship: null};
   let parts;
-  try { parts = JSON.parse(source.slice(at + OPEN.length, -CLOSE.length)); }
+  try { parts = JSON.parse(source.slice(opening.body, -closing[0].length)); }
   catch (_) { throw fault('invalid document metadata'); }
   if (!parts || Object.keys(parts).length !== 2 || !Object.hasOwn(parts, 'ledger') || !Object.hasOwn(parts, 'authorship')) throw fault('invalid document parts');
-  const text = source.slice(0, at);
+  const text = source.slice(0, opening.start);
   return {text, ...validateParts(text, parts)};
 }
 

package/dist/kit/ledger/source.mjs

@@ -70,13 +70,42 @@ function sourceString(node) {
 }
 const replacements = new WeakMap(), texts = new WeakMap(), edits = new WeakMap();
 export const sourceEdit = source => edits.get(source) || null;
+const INITIAL_LEAF_CHARS = 16384;
 export class HistorySource {
 	#root;
-	constructor(text) { this.#root = sourceLeaf(text); Object.freeze(this); }
+	constructor(text) {
+		if (typeof text === 'string' && text.length > INITIAL_LEAF_CHARS) {
+			const leaves = [];
+			for (let from = 0; from < text.length;) {
+				let to = Math.min(text.length, from + INITIAL_LEAF_CHARS);
+				if (to < text.length && (text.charCodeAt(to - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(to) & 0xfc00) === 0xdc00) to++;
+				leaves.push(sourceLeaf(text, from, to));
+				from = to;
+			}
+			const build = (from, to) => from === to ? null : to - from === 1 ? leaves[from]
+				: sourceNode(build(from, (from + to) >> 1), build((from + to) >> 1, to));
+			this.#root = build(0, leaves.length);
+		} else this.#root = sourceLeaf(text);
+		Object.freeze(this);
+	}
 	static owns(value) { return value !== null && typeof value === 'object' && #root in value; }
 	static #fromRoot(root) { const source = new HistorySource(''); source.#root = root; return source; }
 	static fromParts(parts) {
-		const leaves = Array.from(parts, text => sourceLeaf(text)).filter(Boolean);
+		const leaves = [];
+		for (const text of parts) {
+			if (typeof text !== 'string') throw new TypeError('source string required');
+			if (text.length <= INITIAL_LEAF_CHARS) {
+				const leaf = sourceLeaf(text);
+				if (leaf) leaves.push(leaf);
+				continue;
+			}
+			for (let from = 0; from < text.length;) {
+				let to = Math.min(text.length, from + INITIAL_LEAF_CHARS);
+				if (to < text.length && (text.charCodeAt(to - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(to) & 0xfc00) === 0xdc00) to++;
+				leaves.push(sourceLeaf(text, from, to));
+				from = to;
+			}
+		}
 		const build = (from, to) => from === to ? null : to - from === 1 ? leaves[from]
 			: sourceNode(build(from, Math.floor((from + to) / 2)), build(Math.floor((from + to) / 2), to));
 		return HistorySource.#fromRoot(build(0, leaves.length));

package/dist/kit/pdf-source-digest.mjs

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+export const PDF_SOURCE_DIGEST = '/RapierSourceDigest <' + '0'.repeat(64) + '>';
+
+export async function pdfSourceDigest(bytes, start, end) {
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || start + 64 > end || end > bytes.length)
+    throw new Error('Invalid PDF source digest range.');
+  const bound = bytes.slice(0, end);
+  bound.fill(48, start, start + 64);
+  return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', bound)), byte => byte.toString(16).padStart(2, '0')).join('');
+}

package/dist/kit/pdf-source.mjs

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: MIT
+import {PDF_SOURCE_DIGEST, pdfSourceDigest} from './pdf-source-digest.mjs';
 function pdfStructure(input) {
   const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
   const fail = () => { throw Object.assign(new Error('The PDF source could not be attached.'), {code: 'pdf_source_invalid'}); };
@@ -116,10 +117,12 @@ export async function attachPdfSource(input, {source, filename, maxBytes = Infin
     table += place ? String(place.at).padStart(10, '0') + ' ' + String(place.generation).padStart(5, '0') + ' n \n' : '0000000000 00000 f \n';
   }
   const identity = trailer.fields.get('ID');
-  table += 'trailer\n<< /Size ' + totalSize + ' /Root ' + rootId + ' ' + generation + ' R /Info ' + infoId + ' 0 R' + (identity ? ' /ID ' + identity.value : '') + ' >>\nstartxref\n' + length + '\n%%EOF\n';
+  table += 'trailer\n<< /Size ' + totalSize + ' /Root ' + rootId + ' ' + generation + ' R /Info ' + infoId + ' 0 R' + (identity ? ' /ID ' + identity.value : '') + ' ' + PDF_SOURCE_DIGEST + ' >>\nstartxref\n' + length + '\n%%EOF\n';
+  const digestAt = length + table.indexOf(PDF_SOURCE_DIGEST) + PDF_SOURCE_DIGEST.indexOf('<') + 1;
   parts.push(ascii(table)); length += table.length;
   if (length > maxBytes) throw Object.assign(new Error('The exported file exceeds the file limit.'), {code: 'export_too_large'});
   const result = new Uint8Array(length); let at = 0;
   for (const chunk of parts) { result.set(chunk, at); at += chunk.length; }
+  result.set(encode.encode(await pdfSourceDigest(result, digestAt, result.length - 1)), digestAt);
   check(); return result;
 }

package/dist/kit/pdf-vectors.mjs

@@ -157,14 +157,15 @@ export async function collectPdfVectors(main, {width, height, count, capture, si
         const wrap = document.createElement('div');
         wrap.style.cssText = `position:fixed;left:0;top:0;width:${box.width}px;height:${box.height}px;pointer-events:none;background:transparent`;
         clone.style.setProperty('width', box.width + 'px', 'important'); clone.style.setProperty('height', box.height + 'px', 'important');
-        wrap.append(clone); document.body.append(wrap);
+        const surface = document.createElement('div'); surface.style.cssText = 'width:100%;height:100%';
+        surface.append(clone); wrap.attachShadow({mode: 'open'}).append(surface); document.body.append(wrap);
         try {
           const plainText = node.localName === 'text' && window.getComputedStyle(node).filter === 'none' && window.getComputedStyle(node).textShadow === 'none';
           const bounds = plainText ? node.getBoundingClientRect() : box;
           const left = Math.max(0, bounds.left - box.left - 2), top = Math.max(0, bounds.top - box.top - 2);
           const right = Math.min(box.width, bounds.right - box.left + 2), bottom = Math.min(box.height, bounds.bottom - box.top + 2);
           if (!(right > left && bottom > top)) return;
-          const result = await capture({root: wrap, clip: {x: left, y: top, width: right - left, height: bottom - top}, transparent: true, scale: 2, signal, current, pixels: true}); check();
+          const result = await capture({root: surface, clip: {x: left, y: top, width: right - left, height: bottom - top}, transparent: true, scale: 2, signal, current, pixels: true}); check();
           if (result?.rgb instanceof Uint8Array && result?.alpha instanceof Uint8Array) {
             return {image: {rgb: await compress(result.rgb), alpha: await compress(result.alpha), width: result.width, height: result.height}, x: box.left - origin.left + left, y: box.top - origin.top + top, width: right - left, height: bottom - top};
           }

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;
@@ -348,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) {
@@ -1280,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/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/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;

package/dist/spec/document-fonts.mjs

@@ -18,12 +18,19 @@ function parserFor(parser) {
 	return md;
 }
 
+const sourceMetadataFields = ['license', 'origin'];
+function sourceMetadata(value) {
+	return Object.fromEntries(sourceMetadataFields.filter(field => value[field] != null).map(field => [field, value[field]]));
+}
+
 function faceOf(value) {
 	const family = normalizeFontFamily(value?.family), style = value?.style || 'normal';
 	const weight = value?.weight ?? 400, stretch = value?.stretch ?? 100;
 	if (!family || !['normal', 'italic', 'oblique'].includes(style) || !Number.isFinite(weight) || weight < 1 || weight > 1000 ||
 		!Number.isFinite(stretch) || stretch <= 0 || stretch > 1000) return null;
 	const result = {family, style, weight, stretch};
+	if (value.subsetted != null && typeof value.subsetted !== 'boolean') return null;
+	if (value.subsetted === true || value.subset?.subset === true) result.subsetted = true;
 	if (value.weightRange != null) {
 		const range = value.weightRange;
 		if (!Array.isArray(range) || range.length !== 2 || range.some(number => !Number.isFinite(number) || number < 1 || number > 1000) || range[0] > range[1]) return null;
@@ -44,6 +51,25 @@ function faceOf(value) {
 		if (!/^f[0-9a-f]{24}$/.test(value.sourceId)) return null;
 		result.sourceId = value.sourceId;
 	}
+	if (value.license != null) {
+		const license = value.license;
+		if (!license || !['OFL-1.0', 'OFL-1.1', 'Apache-2.0', 'Ubuntu-font-1.0'].includes(license.id) ||
+			typeof license.text !== 'string' || !license.text.trim() || new TextEncoder().encode(license.text).length > 128 * 1024 ||
+			typeof license.url !== 'string' || typeof license.sri !== 'string' || !/^sha384-[A-Za-z0-9+/]{64}$/.test(license.sri)) return null;
+		let url;
+		try { url = new URL(license.url); } catch (_) { return null; }
+		if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash) return null;
+		result.license = {id: license.id, text: license.text, url: license.url, sri: license.sri};
+	}
+	if (value.origin != null) {
+		const origin = value.origin;
+		if (!result.license || result.subsetted || !origin || origin.catalog !== 'google-fonts' ||
+			typeof origin.family !== 'string' || !/^[a-z0-9][a-z0-9-]{0,95}$/.test(origin.family) ||
+			typeof origin.version !== 'string' || !origin.version || origin.version.length > 128 || /[\u0000-\u001f\u007f]/u.test(origin.version) ||
+			typeof origin.file !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\.woff2$/.test(origin.file) ||
+			typeof origin.sri !== 'string' || !/^sha384-[A-Za-z0-9+/]{64}$/.test(origin.sri)) return null;
+		result.origin = {catalog: origin.catalog, family: origin.family, version: origin.version, file: origin.file, sri: origin.sri};
+	}
 	return result;
 }
 
@@ -63,7 +89,7 @@ export function readFontAssets(markdown, parser) {
 		else if (source[at] === '\n') starts.push(at + 1);
 	}
 	md.block.parse(frame.body.replace(/\r\n?/g, '\n').replace(/\0/g, '\ufffd'), md, env, tokens);
-	const labels = new Set(), faces = new Set();
+	const labels = new Set(), faces = new Set(), metadata = new Map(), faceMetadata = new Map(), subsetUrls = new Set();
 	for (const token of tokens) {
 		if (token.type !== 'reference_definition' || !token.map) continue;
 		const id = token.meta.label, first = !labels.has(id);
@@ -79,18 +105,33 @@ export function readFontAssets(markdown, parser) {
 		if (!match) continue;
 		const label = md.utils.unescapeAll(match[1]);
 		if (!data) { refused.push({name: label, reason: 'The font reference must contain an embedded font.'}); continue; }
-		let metadata = {family: label.slice(5)};
+		let definitionMetadata = {family: label.slice(5)};
 		if (definition.title) {
-			try { metadata = JSON.parse(definition.title); }
+			try { definitionMetadata = JSON.parse(definition.title); }
 			catch (_) { refused.push({name: label, reason: 'The font reference has invalid metadata.'}); continue; }
 		}
-		const face = faceOf(metadata);
+		const face = faceOf(definitionMetadata);
 		if (!face) { refused.push({name: label, reason: 'The font reference has invalid metadata.'}); continue; }
 		const key = fontAssetKey(face), active = first && !faces.has(key);
+		const conflict = sourceMetadataFields.find(field => face[field] && [metadata.get(url)?.[field], faceMetadata.get(key)?.[field]]
+			.some(prior => prior && JSON.stringify(prior) !== JSON.stringify(face[field])));
+		if (conflict) { refused.push({name: label, reason: 'The font references have conflicting ' + conflict + ' metadata.'}); continue; }
+		if (face.subsetted && metadata.get(url)?.origin || face.origin && subsetUrls.has(url)) {
+			refused.push({name: label, reason: 'A font subset cannot claim an original catalog file.'}); continue;
+		}
+		metadata.set(url, {...metadata.get(url), ...sourceMetadata(face)});
+		faceMetadata.set(key, {...faceMetadata.get(key), ...sourceMetadata(face)});
+		if (face.subsetted) subsetUrls.add(url);
 		const row = {...face, ...data, url, label, id, key, source: raw, start, end, next, active, topLevel: token.level === 0};
 		blocks.push(row);
 		if (active) { assets.push(row); faces.add(key); }
 	}
+	for (let index = 0; index < assets.length; index++) {
+		const asset = assets[index], declared = metadata.get(asset.url);
+		for (const field of sourceMetadataFields) if (!asset[field] && declared?.[field])
+			assets[index] = {...assets[index], [field]: declared[field]};
+		if (subsetUrls.has(asset.url) && !asset.subsetted) assets[index] = {...assets[index], subsetted: true};
+	}
 	return {assets, blocks, refused, references: env.references || Object.create(null)};
 }
 
@@ -113,13 +154,26 @@ function escapeFontLabel(label) {
 }
 
 export function writeFontAssets(markdown, assets, parser) {
-	const source = String(markdown ?? ''), md = parserFor(parser), index = readFontAssets(source, md), wanted = new Map();
+	const source = String(markdown ?? ''), md = parserFor(parser), index = readFontAssets(source, md), wanted = new Map(), metadata = new Map(), subsetUrls = new Set();
 	for (const asset of assets || []) {
-		const key = fontAssetKey(asset);
+		const key = fontAssetKey(asset), face = faceOf(asset);
 		if (!key || !fontDataUrl(asset?.url)) throw new TypeError('font: invalid embedded asset');
 		if (wanted.has(key) && wanted.get(key).url !== asset.url) throw new TypeError('font: one file owns each family face');
+		const conflict = sourceMetadataFields.find(field => face[field] && metadata.get(asset.url)?.[field] &&
+			JSON.stringify(metadata.get(asset.url)[field]) !== JSON.stringify(face[field]));
+		if (conflict) throw new TypeError('font: conflicting ' + conflict + ' metadata');
+		if (face.subsetted && metadata.get(asset.url)?.origin || face.origin && subsetUrls.has(asset.url))
+			throw new TypeError('font: a subset cannot claim an original catalog file');
+		metadata.set(asset.url, {...metadata.get(asset.url), ...sourceMetadata(face)});
+		if (face.subsetted) subsetUrls.add(asset.url);
 		wanted.set(key, asset);
 	}
+	for (const [key, asset] of wanted) {
+		const declared = metadata.get(asset.url);
+		for (const field of sourceMetadataFields) if (!asset[field] && declared?.[field])
+			wanted.set(key, {...wanted.get(key), [field]: declared[field]});
+		if (subsetUrls.has(asset.url) && !asset.subsetted) wanted.set(key, {...wanted.get(key), subsetted: true});
+	}
 	const edits = [], consumed = new Set(), labels = new Set(Object.keys(index.references));
 	const retired = index.assets.filter(row => !wanted.has(row.key));
 	for (const row of index.blocks) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapier-markdown-kit",
-  "version": "1.2.46",
+  "version": "1.2.48",
   "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",