rapier-markdown-kit 1.1.79 → 1.1.81

package/dist/kit/render-print.mjs

@@ -61,6 +61,9 @@ function _rapierPrintWillFont(markers) {
 		u16(segments.length * 2 - power * 2), segments.map(s => u16(s[1])), u16(0), segments.map(s => u16(s[0])),
 		segments.map(s => u16(s[2])), segments.map(() => u16(0)));
 	const full = cat(u16(12), u16(0), u32(16 + wide.length * 12), u32(0), u32(wide.length), wide.map(g => cat(u32(g.start), u32(g.end), u32(g.glyph))));
+	const cmap = narrow.length <= 0xffff
+		? cat(u16(0), u16(2), u16(3), u16(1), u32(20), u16(3), u16(10), u32(20 + narrow.length), narrow, full)
+		: cat(u16(0), u16(1), u16(3), u16(10), u32(12), full);
 	const outline = cat(u16(1), u16(0), u16(-2), u16(10), u16(2), u16(2), u16(0), [1, 1, 1], u16(0), u16(10), u16(-5), u16(-2), u16(4), u16(-2), [0]);
 	const utf16 = text => Array.from(text, ch => u16(ch.charCodeAt(0)));
 	const names = [[1, 'RapierWill'], [2, 'Regular'], [4, 'RapierWill Regular'], [6, 'RapierWill-Regular']];
@@ -70,7 +73,7 @@ function _rapierPrintWillFont(markers) {
 			u16(50), u16(300), u16(0), new Array(10).fill(0), u32(0), u32(0), u32(0), u32(0), [78, 79, 78, 69], u16(0x40),
 			u16(order.find(code => code < 0xffff) || 0x20), u16(order.filter(code => code < 0xffff).pop() || 0x20), u16(500), u16(-500), u16(0),
 			u16(500), u16(500), u32(1), u32(0), u16(500), u16(700), u16(0), u16(32), u16(0)),
-		cmap: cat(u16(0), u16(2), u16(3), u16(1), u32(20), u16(3), u16(10), u32(20 + narrow.length), narrow, full),
+		cmap,
 		glyf: Array.from({ length: count }, () => outline).flat(),
 		head: cat(u32(0x00010000), u32(0x00010000), u32(0), u32(0x5f0f3cf5), u16(1), u16(1000), new Array(16).fill(0), u16(0), u16(-2), u16(10), u16(2),
 			u16(0), u16(8), u16(2), u16(1), u16(0)),
@@ -93,7 +96,7 @@ function _rapierPrintWillFont(markers) {
 	const file = cat(u32(0x00010000), u16(tags.length), u16((1 << tableSelect) * 16), u16(tableSelect), u16(tags.length * 16 - (1 << tableSelect) * 16), directory, tags.map(tag => padded(tables[tag])));
 	const headAt = 12 + tags.length * 16 + tags.slice(0, tags.indexOf('head')).reduce((total, tag) => total + padded(tables[tag]).length, 0);
 	file.splice(headAt + 8, 4, ...u32((0xb1b0afba - sum(file)) >>> 0));
-	return { family: 'RapierWillCarrier', bytes: Uint8Array.from(file), size };
+	return { family: 'RapierWillCarrier', bytes: Uint8Array.from(file), size, codes: order };
 }
 
 function _rapierPrintWillMetrics(markers) {
@@ -160,6 +163,264 @@ function _rapierPrintWillPageCss() {
 		+ '}';
 }
 
-  return {_rapierWillSentinelPlan, _rapierPrintWillAdmit, _rapierPrintWillFont, _rapierPrintWillMetrics, _rapierPrintWillPlace, _rapierPrintWillLost, _rapierPrintWillPageCss};
+// The capture's own limits (agent/visual.mjs VISUAL_LIMITS): the longest edge and the most pixels one capture returns.
+const CAPTURE_EDGE = 4096, CAPTURE_PIXELS = 4 * 1024 * 1024;
+
+async function _rapierWritePrintPdf({root, css, canonical, filename, title, settings}, {capture, signal, current, maxBytes = 8 * 1024 * 1024} = {}) {
+	const refuse = code => { throw Object.assign(new Error(code), {code}); };
+	const check = () => {
+		if (signal?.aborted) refuse('cancelled');
+		if (current?.() === false) refuse('document_changed');
+	};
+	if (!root?.ownerDocument || typeof capture !== 'function') refuse('pdf_render_unavailable');
+	// The native printer chooses its default paper. A file made without a printer uses A4,
+	// with the same explicit document settings and default margins as the print artifact.
+	const paper = settings?.papersize || {width: 11906, height: 16838};
+	const width = paper.width / 20, height = paper.height / 20;
+	const margin = settings?.geometry ? settings.geometry.twips / 20 : null;
+	const margins = {top: margin ?? 12 * 72 / 25.4, right: margin ?? 14 * 72 / 25.4,
+		bottom: margin ?? 14 * 72 / 25.4, left: margin ?? 14 * 72 / 25.4};
+	const bodyWidth = Math.floor((width - margins.left - margins.right) * 4 / 3);
+	const bodyHeight = Math.floor((height - margins.top - margins.bottom) * 4 / 3);
+	if (bodyWidth < 1 || bodyHeight < 1 || bodyWidth * bodyHeight > 4 * 1024 * 1024) refuse('pdf_page_geometry_invalid');
+	const frame = document.createElement('iframe');
+	let rejectAbort;
+	const aborted = new Promise((_, reject) => { rejectAbort = reject; });
+	aborted.catch(() => {});
+	const abort = () => rejectAbort(Object.assign(new Error('cancelled'), {code: 'cancelled'}));
+	signal?.addEventListener('abort', abort, {once: true});
+	const step = async work => {
+		check();
+		let timer;
+		try {
+			const timeout = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(Object.assign(new Error('pdf_render_timeout'), {code: 'pdf_render_timeout'})), 15000);
+			});
+			const value = await Promise.race([work, aborted, timeout]); check(); return value;
+		} finally { clearTimeout(timer); }
+	};
+	frame.setAttribute('aria-hidden', 'true');
+	frame.style.cssText = `position:fixed;left:-100000px;top:0;width:${bodyWidth}px;height:${bodyHeight}px;border:0;pointer-events:none`;
+	document.body.append(frame);
+	try {
+		check();
+		const into = frame.contentDocument;
+		if (!into?.body) refuse('pdf_render_unavailable');
+		into.documentElement.setAttribute('data-rapier-theme', 'light');
+		into.documentElement.setAttribute('data-highlights', document.documentElement.getAttribute('data-highlights') || 'standard');
+		into.body.className = 'light';
+		const sheet = into.createElement('style'); sheet.textContent = String(css || ''); into.head.append(sheet);
+		const printRules = [];
+		const collect = rules => {
+			for (const rule of rules) {
+				if (rule.media?.mediaText === 'print') printRules.push(...Array.from(rule.cssRules, item => item.cssText));
+				else if (rule.cssRules && !rule.media) collect(rule.cssRules);
+			}
+		};
+		collect(sheet.sheet.cssRules);
+		const printed = into.createElement('style');
+		printed.textContent = printRules.join('\n') + `\nhtml,body{width:${bodyWidth}px!important;height:${bodyHeight}px!important;margin:0!important;padding:0!important;overflow:visible!important}`;
+		into.head.append(printed);
+		const surface = into.createElement('div'), strip = into.createElement('div');
+		surface.style.cssText = `width:${bodyWidth}px;height:${bodyHeight}px;overflow:hidden;position:relative;background:#fff`;
+		strip.style.cssText = `width:${bodyWidth}px;height:${bodyHeight}px;position:relative`;
+		strip.append(root); surface.append(strip); into.body.append(surface);
+		const main = root.querySelector('main');
+		if (!main) refuse('pdf_render_unavailable');
+		// A file for paper is light whatever the person's own scheme: the page's text takes its colour scheme from this attribute.
+		main.setAttribute('data-md-theme', 'light');
+		for (const details of main.querySelectorAll('details')) details.open = true;
+		main.getBoundingClientRect();
+		await step(into.fonts.ready);
+		for (const image of main.querySelectorAll('img')) { image.loading = 'eager'; await step(image.decode()); }
+		check();
+		// The print sheet owns the words and styles. CSS fragmentation supplies the file's
+		// pages without a print dialog; its break constraints become column constraints here.
+		for (const node of [main, ...main.querySelectorAll('*')]) {
+			const style = into.defaultView.getComputedStyle(node);
+			for (const name of ['break-before', 'break-after', 'break-inside']) {
+				const value = style.getPropertyValue(name);
+				if (value.includes('page')) node.style.setProperty(name, value.replace('page', 'column'), 'important');
+			}
+		}
+		for (const [name, value] of Object.entries({width: bodyWidth + 'px', height: bodyHeight + 'px',
+			'max-width': 'none', 'min-height': '0', padding: '0', margin: '0', overflow: 'visible',
+			'column-width': bodyWidth + 'px', 'column-gap': '0', 'column-count': 'auto', 'column-fill': 'auto'}))
+			main.style.setProperty(name, value, 'important');
+		const count = Math.max(1, Math.ceil((main.scrollWidth - 1) / bodyWidth));
+		if (!Number.isSafeInteger(count)) refuse('pdf_page_geometry_invalid');
+		const textPages = await _rapierPrintTextPages(main, bodyWidth, count, check);
+		const text = textPages.flatMap(page => page.map(run => run.text));
+		const glyphs = new Set();
+		for (const line of text) for (const character of line) {
+			glyphs.add(character);
+			if (glyphs.size > 65000) refuse('pdf_text_glyph_limit');
+		}
+		const font = _rapierPrintWillFont(text);
+		strip.style.width = count * bodyWidth + 'px';
+		// A capture costs the whole document, however little of it the clip takes, so the pages that carry no picture share captures: as many to one
+		// as the capture's own limits allow, fewer when the capture refuses its size. A page with a picture is captured alone, so the picture keeps
+		// the capture's byte limit to itself.
+		let share = main.querySelector('img,svg,canvas,video,picture') ? 1
+			: Math.max(1, Math.min(Math.floor(CAPTURE_EDGE / bodyWidth), Math.floor(CAPTURE_PIXELS / (bodyWidth * bodyHeight))));
+		const pages = [];
+		let imageBytes = 0;
+		for (let first = 0; first < count;) {
+			check();
+			const span = Math.min(share, count - first);
+			surface.style.width = span * bodyWidth + 'px';
+			strip.style.transform = `translateX(${-first * bodyWidth}px)`;
+			let captured;
+			try { captured = await capture({root: surface, clip: {x: 0, y: 0, width: span * bodyWidth, height: bodyHeight}, signal, current}); }
+			catch (error) {
+				if (error?.code === 'visual_too_large' && span > 1) { share = Math.ceil(span / 2); continue; }
+				throw error;
+			}
+			check();
+			const image = new into.defaultView.Image();
+			image.src = 'data:' + captured.mimeType + ';base64,' + captured.data;
+			try {
+				await step(image.decode());
+				for (let offset = 0; offset < span; offset++) {
+					const canvas = into.createElement('canvas'); canvas.width = bodyWidth; canvas.height = bodyHeight;
+					try {
+						const context = canvas.getContext('2d', {alpha: false});
+						if (!context) refuse('pdf_render_unavailable');
+						context.fillStyle = '#fff'; context.fillRect(0, 0, bodyWidth, bodyHeight);
+						context.drawImage(image, offset * bodyWidth, 0, bodyWidth, bodyHeight, 0, 0, bodyWidth, bodyHeight);
+						const blob = await step(new Promise(resolve => canvas.toBlob(resolve, 'image/jpeg', 0.95)));
+						if (!blob) refuse('pdf_render_unavailable');
+						imageBytes += blob.size;
+						if (imageBytes > maxBytes) refuse('export_too_large');
+						pages.push(new Uint8Array(await blob.arrayBuffer()));
+					} finally { canvas.width = canvas.height = 0; }
+				}
+			} finally { image.src = ''; }
+			first += span;
+		}
+		check();
+		const bytes = await writeRasterPdf({pages, textPages, canonical, filename, title, font, width, height, margins,
+			pixelWidth: bodyWidth, pixelHeight: bodyHeight, pageNumbers: settings?.pagestyle === 'plain', maxBytes, check});
+		check();
+		return {bytes, pages: count};
+	} finally { signal?.removeEventListener('abort', abort); frame.remove(); }
+}
+
+// Ranges locate the actual text fragments after column layout. Splitting a text node at
+// its line and page boundaries keeps a PDF search on the page that carries those words.
+async function _rapierPrintTextPages(main, pageWidth, count, check) {
+	const into = main.ownerDocument, origin = main.getBoundingClientRect();
+	const pages = Array.from({length: count}, () => []), walker = into.createTreeWalker(main, 4);
+	const range = into.createRange();
+	let nodes = 0, operations = 0;
+	for (let node; (node = walker.nextNode());) {
+		if (++nodes % 128 === 0) { await new Promise(resolve => setTimeout(resolve, 0)); check(); }
+		const style = into.defaultView.getComputedStyle(node.parentElement);
+		if (style.visibility === 'hidden' || style.visibility === 'collapse') continue;
+		const preserve = /pre|break-spaces/.test(style.whiteSpace);
+		const block = node.parentElement.closest('p,h1,h2,h3,h4,h5,h6,li,pre,td,th,figcaption,blockquote,.rapier-will-carrier') || node.parentElement;
+		const carrier = node.parentElement.closest('.rapier-will-carrier');
+		const value = node.data;
+		const pageOf = x => Math.max(0, Math.min(count - 1, Math.floor((x - origin.left + .01) / pageWidth)));
+		const visit = (start, end) => {
+			if (++operations % 128 === 0) check();
+			range.setStart(node, start); range.setEnd(node, end);
+			const rects = Array.from(range.getClientRects()).filter(rect => rect.width > 0 && rect.height > 0);
+			if (!rects.length) return;
+			const first = rects[0], page = pageOf(first.left);
+			const oneLine = rects.every(rect => pageOf(rect.left) === page && pageOf(rect.right - .02) === page && Math.abs(rect.top - first.top) < .5);
+			let middle = Math.floor((start + end) / 2);
+			if (middle > start && /[\uD800-\uDBFF]/.test(value[middle - 1]) && /[\uDC00-\uDFFF]/.test(value[middle])) middle--;
+			if (!oneLine && middle > start && middle < end) { visit(start, middle); visit(middle, end); return; }
+			let text = value.slice(start, end);
+			text = preserve ? text.replace(/\r\n?|\n/g, '') : text.replace(/[ \t\r\n\f]+/g, ' ');
+			if (!text) return;
+			const x = Math.min(...rects.map(rect => rect.left)) - origin.left - page * pageWidth;
+			const y = Math.min(...rects.map(rect => rect.top)) - origin.top;
+			const right = Math.max(...rects.map(rect => rect.right)) - origin.left - page * pageWidth;
+			const bottom = Math.max(...rects.map(rect => rect.bottom)) - origin.top;
+			const last = pages[page].at(-1);
+			if (last && last.block === block && last.carrier === carrier && Math.abs(last.y - y) < Math.max(2, Math.min(last.height, bottom - y) * .2)) {
+				last.text = preserve ? last.text + text : (last.text + text).replace(/[ \t\r\n\f]+/g, ' ');
+				last.width = Math.max(last.x + last.width, right) - Math.min(last.x, x);
+				last.height = Math.max(last.y + last.height, bottom) - Math.min(last.y, y);
+				last.x = Math.min(last.x, x); last.y = Math.min(last.y, y);
+			} else pages[page].push({text, x, y, width: right - x, height: bottom - y, block, carrier});
+		};
+		visit(0, value.length);
+	}
+	check();
+	return pages.map(page => page.map(({block, carrier, ...run}) => run));
+}
+
+  return {_rapierWillSentinelPlan, _rapierPrintWillAdmit, _rapierPrintWillFont, _rapierPrintWillMetrics, _rapierPrintWillPlace, _rapierPrintWillLost, _rapierPrintWillPageCss, _rapierWritePrintPdf};
+}
+
+// A standard PDF page tree, image streams, Unicode text and an associated source file.
+// It accepts already-rendered pages, so there is no second document grammar or layout engine.
+async function writeRasterPdf({pages, textPages, canonical, filename, title, font, width, height, margins, pixelWidth, pixelHeight, pageNumbers, maxBytes, check}) {
+	const encoder = new TextEncoder(), encode = value => encoder.encode(value);
+	const fail = code => { throw Object.assign(new Error(code), {code}); };
+	const concat = parts => {
+		const length = parts.reduce((sum, part) => sum + part.length, 0), bytes = new Uint8Array(length);
+		let at = 0; for (const part of parts) {bytes.set(part, at); at += part.length;} return bytes;
+	};
+	const compressed = async bytes => {
+		check();
+		const pipe = new Blob([bytes]).stream().pipeThrough(new CompressionStream('deflate'));
+		const result = new Uint8Array(await new Response(pipe).arrayBuffer()); check(); return result;
+	};
+	const objects = [null, null, null];
+	let used = 0;
+	const put = (id, bytes) => {
+		bytes = typeof bytes === 'string' ? encode(bytes) : bytes;
+		used += bytes.length + 32; if (used > maxBytes) fail('export_too_large'); objects[id] = bytes; return id;
+	};
+	const add = bytes => {objects.push(null); return put(objects.length - 1, bytes);};
+	const stream = (dict, bytes) => add(concat([encode('<<' + dict + ' /Length ' + bytes.length + '>>\nstream\n'), bytes, encode('\nendstream')]));
+	const hex = value => Array.from({length: value.length}, (_, index) => value.charCodeAt(index).toString(16).padStart(4, '0')).join('');
+	const literal = value => '(' + String(value).replace(/[\\()\r\n]/g, character => ({'\\': '\\\\', '(': '\\(', ')': '\\)', '\r': '\\r', '\n': '\\n'}[character])) + ')';
+	const source = encoder.encode(canonical);
+	const embedded = stream('/Type /EmbeddedFile /Subtype /text#2Fplain /Params <</Size ' + source.length + '>> /Filter /FlateDecode', await compressed(source));
+	const file = add('<< /Type /Filespec /F ' + literal(String(filename).replace(/[^\x20-\x7e]/g, '_')) + ' /UF <feff' + hex(filename) + '> /AFRelationship /Source /EF << /F ' + embedded + ' 0 R /UF ' + embedded + ' 0 R >> >>');
+	const codes = new Map(font.codes.map((code, index) => [code, index + 1]));
+	const rows = font.codes.map((code, index) => '<' + (index + 1).toString(16).padStart(4, '0') + '> <' + hex(String.fromCodePoint(code)) + '>');
+	let cmap = '/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n/CMapName /RapierText def\n/CMapType 2 def\n1 begincodespacerange\n<0000> <ffff>\nendcodespacerange\n';
+	for (let at = 0; at < rows.length; at += 100) cmap += Math.min(100, rows.length - at) + ' beginbfchar\n' + rows.slice(at, at + 100).join('\n') + '\nendbfchar\n';
+	cmap += 'endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend';
+	const mapping = stream('/Filter /FlateDecode', await compressed(encode(cmap)));
+	const fontFile = stream('/Length1 ' + font.bytes.length + ' /Filter /FlateDecode', await compressed(font.bytes));
+	const descriptor = add('<< /Type /FontDescriptor /FontName /RapierText /Flags 4 /FontBBox [0 -2 10 2] /ItalicAngle 0 /Ascent 500 /Descent -500 /CapHeight 500 /StemV 80 /FontFile2 ' + fontFile + ' 0 R >>');
+	const descendant = add('<< /Type /Font /Subtype /CIDFontType2 /BaseFont /RapierText /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor ' + descriptor + ' 0 R /DW 500 /CIDToGIDMap /Identity >>');
+	const type = add('<< /Type /Font /Subtype /Type0 /BaseFont /RapierText /Encoding /Identity-H /DescendantFonts [' + descendant + ' 0 R] /ToUnicode ' + mapping + ' 0 R >>');
+	const numberFont = pageNumbers ? add('<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>') : null;
+	const kids = [], decimal = value => Number(value.toFixed(4));
+	for (let index = 0; index < pages.length; index++) {
+		check();
+		const picture = stream('/Type /XObject /Subtype /Image /Width ' + pixelWidth + ' /Height ' + pixelHeight + ' /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode', pages[index]);
+		let commands = 'q\n' + [decimal(pixelWidth * .75), 0, 0, decimal(pixelHeight * .75), decimal(margins.left), decimal(height - margins.top - pixelHeight * .75)].join(' ') + ' cm\n/Im0 Do\nQ\n';
+		for (const run of textPages[index]) {
+			const characters = Array.from(run.text);
+			const value = characters.map(character => codes.get(character.codePointAt(0)).toString(16).padStart(4, '0')).join('');
+			const size = Math.max(.1, run.height * .75);
+			const scale = run.width * .75 / (characters.length * size * .5) * 100;
+			commands += `BT\n/F1 ${decimal(size)} Tf\n${decimal(scale)} Tz\n3 Tr\n1 0 0 1 ${decimal(margins.left + run.x * .75)} ${decimal(height - margins.top - (run.y + run.height * .8) * .75)} Tm\n<${value}> Tj\nET\n`;
+		}
+		if (numberFont) commands += `BT\n/F2 9 Tf\n0 Tr\n1 0 0 1 ${decimal(width / 2 - String(index + 1).length * 2.5)} ${decimal(margins.bottom / 2)} Tm\n(${index + 1}) Tj\nET\n`;
+		const content = stream('/Filter /FlateDecode', await compressed(encode(commands)));
+		kids.push(add('<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ' + decimal(width) + ' ' + decimal(height) + '] /Resources << /XObject << /Im0 ' + picture + ' 0 R >> /Font << /F1 ' + type + ' 0 R' + (numberFont ? ' /F2 ' + numberFont + ' 0 R' : '') + ' >> >> /Contents ' + content + ' 0 R >>'));
+	}
+	put(2, '<< /Type /Pages /Count ' + kids.length + ' /Kids [' + kids.map(id => id + ' 0 R').join(' ') + '] >>');
+	put(1, '<< /Type /Catalog /Pages 2 0 R /Names << /EmbeddedFiles << /Names [<feff' + hex(filename) + '> ' + file + ' 0 R] >> >> /AF [' + file + ' 0 R] >>');
+	const info = add('<< /Producer (Rapier) /Title <feff' + hex(title || filename.replace(/\.[^.]*$/, '')) + '> >>');
+	const parts = [encode('%PDF-1.7\n%\u00e2\u00e3\u00cf\u00d3\n')], offsets = [0];
+	let length = parts[0].length;
+	for (let id = 1; id < objects.length; id++) {
+		offsets.push(length);
+		const body = concat([encode(id + ' 0 obj\n'), objects[id], encode('\nendobj\n')]); parts.push(body); length += body.length;
+	}
+	const xref = length;
+	parts.push(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' + xref + '\n%%EOF\n'));
+	const bytes = concat(parts); if (bytes.length > maxBytes) fail('export_too_large'); return bytes;
 }
 export {createPrintRenderer, RAPIER_WILL_SENTINEL_MARK as sentinel};

package/dist/kit/render-sanitize.mjs

@@ -1,24 +1,40 @@
 // SPDX-License-Identifier: MIT
 const RAPIER_SANITIZE_FORBID_TAGS = Object.freeze(['form', 'style', 'dialog', 'template', 'iframe']);
 const RAPIER_SANITIZE_FORBID_ATTR = Object.freeze(['action', 'formaction', 'form', 'for']);
+// The document profiles use one allowlist in a browser and in an inert server parser.
+const RAPIER_SANITIZE_PROFILES = Object.freeze({
+	htmlTags: Object.freeze(["a","abbr","acronym","address","area","article","aside","audio","b","bdi","bdo","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","content","data","datalist","dd","decorator","del","details","dfn","dialog","dir","div","dl","dt","element","em","fieldset","figcaption","figure","font","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","img","input","ins","kbd","label","legend","li","main","map","mark","marquee","menu","menuitem","meter","nav","nobr","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","search","section","select","shadow","slot","small","source","spacer","span","strike","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","tr","track","tt","u","ul","var","video","wbr"]),
+	svgTags: Object.freeze(["svg","a","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","circle","clippath","defs","desc","ellipse","enterkeyhint","exportparts","filter","font","g","glyph","glyphref","hkern","image","inputmode","line","lineargradient","marker","mask","metadata","mpath","part","path","pattern","polygon","polyline","radialgradient","rect","stop","style","switch","symbol","text","textpath","title","tref","tspan","view","vkern"]),
+	mathTags: Object.freeze(["math","menclose","merror","mfenced","mfrac","mglyph","mi","mlabeledtr","mmultiscripts","mn","mo","mover","mpadded","mphantom","mroot","mrow","ms","mspace","msqrt","mstyle","msub","msup","msubsup","mtable","mtd","mtext","mtr","munder","munderover","mprescripts"]),
+	htmlAttributes: Object.freeze(["accept","action","align","alt","autocapitalize","autocomplete","autopictureinpicture","autoplay","background","bgcolor","border","capture","cellpadding","cellspacing","checked","cite","class","clear","color","cols","colspan","command","commandfor","controls","controlslist","coords","crossorigin","datetime","decoding","default","dir","disabled","disablepictureinpicture","disableremoteplayback","download","draggable","enctype","enterkeyhint","exportparts","face","for","headers","height","hidden","high","href","hreflang","id","inert","inputmode","integrity","ismap","kind","label","lang","list","loading","loop","low","max","maxlength","media","method","min","minlength","multiple","muted","name","nonce","noshade","novalidate","nowrap","open","optimum","part","pattern","placeholder","playsinline","popover","popovertarget","popovertargetaction","poster","preload","pubdate","radiogroup","readonly","rel","required","rev","reversed","role","rows","rowspan","spellcheck","scope","selected","shape","size","sizes","slot","span","srclang","start","src","srcset","step","style","summary","tabindex","title","translate","type","usemap","valign","value","width","wrap","xmlns"]),
+	svgAttributes: Object.freeze(["accent-height","accumulate","additive","alignment-baseline","amplitude","ascent","attributename","attributetype","azimuth","basefrequency","baseline-shift","begin","bias","by","class","clip","clippathunits","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","cx","cy","d","dx","dy","diffuseconstant","direction","display","divisor","dominant-baseline","dur","edgemode","elevation","end","exponent","fill","fill-opacity","fill-rule","filter","filterunits","flood-color","flood-opacity","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","fx","fy","g1","g2","glyph-name","glyphref","gradientunits","gradienttransform","height","href","id","image-rendering","in","in2","intercept","k","k1","k2","k3","k4","kerning","keypoints","keysplines","keytimes","lang","lengthadjust","letter-spacing","kernelmatrix","kernelunitlength","lighting-color","local","marker-end","marker-mid","marker-start","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","max","mask","mask-type","media","method","mode","min","name","numoctaves","offset","operator","opacity","order","orient","orientation","origin","overflow","paint-order","path","pathlength","patterncontentunits","patterntransform","patternunits","pointer-events","points","preservealpha","preserveaspectratio","primitiveunits","r","rx","ry","radius","refx","refy","repeatcount","repeatdur","restart","result","rotate","scale","seed","shape-rendering","slope","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke","stroke-width","style","surfacescale","systemlanguage","tabindex","tablevalues","targetx","targety","transform","transform-origin","text-anchor","text-decoration","text-orientation","text-rendering","textlength","type","u1","u2","unicode","values","vector-effect","viewbox","visibility","version","vert-adv-y","vert-origin-x","vert-origin-y","width","word-spacing","wrap","writing-mode","xchannelselector","ychannelselector","x","x1","x2","xmlns","y","y1","y2","z","zoomandpan"]),
+	mathAttributes: Object.freeze(["accent","accentunder","align","bevelled","close","columnalign","columnlines","columnspacing","columnspan","denomalign","depth","dir","display","displaystyle","encoding","fence","frame","height","href","id","largeop","length","linethickness","lquote","lspace","mathbackground","mathcolor","mathsize","mathvariant","maxsize","minsize","movablelimits","notation","numalign","open","rowalign","rowlines","rowspacing","rowspan","rspace","rquote","scriptlevel","scriptminsize","scriptsizemultiplier","selection","separator","separators","stretchy","subscriptshift","supscriptshift","symmetric","voffset","width","xmlns"]),
+	xmlAttributes: Object.freeze(["xlink:href","xml:id","xlink:title","xml:space","xmlns:xlink"]),
+});
+const RAPIER_SANITIZE_DROP_CONTENTS = Object.freeze('annotation-xml.audio.colgroup.desc.foreignobject.head.iframe.math.mi.mn.mo.ms.mtext.noembed.noframes.noscript.plaintext.script.selectedcontent.style.svg.template.thead.title.video.xmp'.split('.'));
+function _rapierSanitizeProfile(...kinds) {
+	return {ALLOWED_TAGS: Object.freeze(['#text', ...new Set(kinds.flatMap(kind => RAPIER_SANITIZE_PROFILES[kind + 'Tags']))]),
+		ALLOWED_ATTR: Object.freeze([...new Set(kinds.flatMap(kind => RAPIER_SANITIZE_PROFILES[kind + 'Attributes']).concat(kinds.some(kind => kind !== 'html') ? RAPIER_SANITIZE_PROFILES.xmlAttributes : []))]),
+		FORBID_CONTENTS: RAPIER_SANITIZE_DROP_CONTENTS};
+}
 const RAPIER_SANITIZE_OPTIONS = Object.freeze({
 	render: Object.freeze({
-		USE_PROFILES: { html: true, svg: true, mathMl: true },
+		..._rapierSanitizeProfile('html', 'svg', 'math'),
 		FORBID_TAGS: RAPIER_SANITIZE_FORBID_TAGS,
 		FORBID_ATTR: RAPIER_SANITIZE_FORBID_ATTR,
 	}),
 	paste: Object.freeze({
-		USE_PROFILES: { html: true },
+		..._rapierSanitizeProfile('html'),
 		FORBID_TAGS: RAPIER_SANITIZE_FORBID_TAGS,
 		FORBID_ATTR: RAPIER_SANITIZE_FORBID_ATTR,
 	}),
 	snippet: Object.freeze({
-		USE_PROFILES: { html: true },
+		..._rapierSanitizeProfile('html'),
 		FORBID_TAGS: RAPIER_SANITIZE_FORBID_TAGS,
 		FORBID_ATTR: Object.freeze([...'style']),
 	}),
 	diagram: Object.freeze({
-		USE_PROFILES: { html: true, svg: true },
+		..._rapierSanitizeProfile('html', 'svg'),
 		FORBID_TAGS: Object.freeze(['form', 'dialog', 'template', 'iframe', 'script', 'foreignobject']),
 		FORBID_ATTR: RAPIER_SANITIZE_FORBID_ATTR,
 	}),
@@ -66,9 +82,98 @@ function prepareMathSource(input, DOMParser) {
 	return sourceRoot ? root.outerHTML : root;
 }
 
+// An inert parser and a string sanitizer use the same profile as DOMPurify. Neither port may
+// execute document scripts or fetch resources. HTML5 parsing precedes filtering so foreign
+// content, entities and malformed table markup cross the same boundary as a browser's parser.
+function createInertHtmlSanitizer({parseFragment, serialize, sanitizeHtml, safeRasterDataUrl}) {
+	if (![parseFragment, serialize, sanitizeHtml, safeRasterDataUrl].every(port => typeof port === 'function'))
+		throw new TypeError('The inert HTML sanitizer requires every parser and filtering port');
+	const uri = /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
+	const uriSafe = new Set(['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
+	const schemes = ['http', 'https', 'ftp', 'ftps', 'mailto', 'tel', 'callto', 'sms', 'cid', 'xmpp', 'matrix'];
+	const htmlNamespace = 'http://www.w3.org/1999/xhtml', svgNamespace = 'http://www.w3.org/2000/svg', mathNamespace = 'http://www.w3.org/1998/Math/MathML';
+	const svgTags = new Set(RAPIER_SANITIZE_PROFILES.svgTags), mathTags = new Set(RAPIER_SANITIZE_PROFILES.mathTags);
+	const mathIntegration = new Set(['mi', 'mo', 'mn', 'ms', 'mtext']), htmlIntegration = new Set(['annotation-xml']);
+	const sharedHtmlSvg = new Set(['title', 'style', 'font', 'a', 'script']);
+	// DOMPurify's default namespace admission applies in addition to its tag profile. In
+	// particular a MathML name parsed as HTML, or HTML inside SVG desc, is not admitted.
+	const validNamespace = (node, parent) => {
+		const tag = node.tagName.toLowerCase(), parentTag = (parent.tagName || 'template').toLowerCase();
+		const namespace = node.namespaceURI, parentNamespace = parent.namespaceURI || htmlNamespace;
+		if (namespace === svgNamespace) return parentNamespace === htmlNamespace ? tag === 'svg'
+			: parentNamespace === mathNamespace ? tag === 'svg' && (parentTag === 'annotation-xml' || mathIntegration.has(parentTag)) : svgTags.has(tag);
+		if (namespace === mathNamespace) return parentNamespace === htmlNamespace ? tag === 'math'
+			: parentNamespace === svgNamespace ? tag === 'math' && htmlIntegration.has(parentTag) : mathTags.has(tag);
+		return namespace === htmlNamespace && !(parentNamespace === svgNamespace && !htmlIntegration.has(parentTag))
+			&& !(parentNamespace === mathNamespace && !mathIntegration.has(parentTag))
+			&& !mathTags.has(tag) && (sharedHtmlSvg.has(tag) || !svgTags.has(tag));
+	};
+	return function sanitize(value, context = 'render') {
+		const selected = context === 'raw' || context === 'export' || context === 'source' || RAPIER_SANITIZE_OPTIONS[context] ? context : 'render';
+		const options = RAPIER_SANITIZE_OPTIONS[selected] || RAPIER_SANITIZE_OPTIONS.render;
+		const forbiddenTags = new Set(options.FORBID_TAGS || []), forbiddenAttributes = new Set(options.FORBID_ATTR || []);
+		const tags = new Set(options.ALLOWED_TAGS.filter(tag => tag !== '#text' && !forbiddenTags.has(tag)));
+		const attributes = new Set(options.ALLOWED_ATTR);
+		const tree = parseFragment(String(value == null ? '' : value));
+		const dropContents = new Set(RAPIER_SANITIZE_DROP_CONTENTS);
+		const admitTree = parent => {
+			for (let index = 0; index < (parent.childNodes || []).length;) {
+				const node = parent.childNodes[index], tag = node.tagName?.toLowerCase();
+				if (tag && !tags.has(tag)) {
+					const children = dropContents.has(tag) ? [] : node.childNodes || [];
+					for (const child of children) child.parentNode = parent;
+					parent.childNodes.splice(index, 1, ...children);
+					continue;
+				}
+				if (tag && !validNamespace(node, parent) || node.nodeName === '#comment') {
+					parent.childNodes.splice(index, 1); continue;
+				}
+				admitTree(node); index++;
+			}
+		};
+		admitTree(tree);
+		const admitNames = node => {
+			if (node.tagName && tags.has(node.tagName.toLowerCase())) tags.add(node.tagName);
+			for (const child of node.childNodes || []) admitNames(child);
+		};
+		admitNames(tree);
+		const cleaned = sanitizeHtml(serialize(tree), {
+			allowedTags: [...tags], allowedAttributes: false,
+			disallowedTagsMode: 'discard', nonTextTags: RAPIER_SANITIZE_DROP_CONTENTS,
+			allowedSchemes: schemes, allowedSchemesByTag: {img: [...schemes, 'data']},
+			allowedSchemesAppliedToAttributes: ['href', 'src', 'xlink:href', 'cite', 'background', 'poster'],
+			parseStyleAttributes: false,
+			parser: {lowerCaseTags: false, lowerCaseAttributeNames: false, decodeEntities: true},
+			transformTags: {'*': (tagName, input) => {
+				const attribs = Object.create(null), tag = tagName.toLowerCase();
+				for (const [name, inputValue] of Object.entries(input)) {
+					const key = name.toLowerCase();
+					const value = name === 'value' ? inputValue : inputValue.trim();
+					if (forbiddenAttributes.has(key) || key.startsWith('on')) continue;
+					if (/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i.test(value)
+						|| key === 'attributename' && value.includes('href')) continue;
+					const data = /^data-[\-\w.\u00b7-\uffff]+$/.test(key), aria = /^aria-[\-\w]+$/.test(key);
+					const pageBreak = key === 'contenteditable' && value === 'false' && tag === 'div' && input['data-md-break'] === 'page';
+					if (!(data && selected !== 'raw') && !aria && !pageBreak && !attributes.has(key)) continue;
+					const compact = value.replace(/[\u0000-\u0020\u00a0\u1680\u180e\u2000-\u2029\u205f\u3000]/g, '');
+					if (!data && !aria && !pageBreak && !uriSafe.has(key) && compact) {
+						if (/^data:/i.test(compact)) {
+							if (key !== 'src' || tag !== 'img' || !safeRasterDataUrl(compact)) continue;
+						} else if (!uri.test(compact)) continue;
+					}
+					attribs[name] = value;
+				}
+				if ((tag === 'a' || tag === 'area') && attribs.target?.trim().toLowerCase() === '_blank') attribs.rel = 'noopener noreferrer';
+				return {tagName, attribs};
+			}},
+		});
+		return serialize(parseFragment(cleaned));
+	};
+}
+
 // The document's renderer. DOM, codecs and host state are explicit inputs.
 function createRenderSanitizer(runtime) {
-  const {CSSStyleSheet, DOMPurify, RAPIER_RASTER_DATA_URL_RE, URL, _rapierCssDeclaration, _rapierDropRemoteDeclarations, _rapierRemoteContent, _rapierRuleDescriptorIsRemote, _rapierSanitizeRuntime, _rapierVerifyRasterBytes, document, globalThis, location} = runtime;
+  const {CSSStyleSheet, DOMPurify, RAPIER_RASTER_DATA_URL_RE, URL, _rapierCssDeclaration, _rapierDropRemoteDeclarations, _rapierRemoteContent, _rapierRuleDescriptorIsRemote, _rapierSanitizeRuntime, document, globalThis, location} = runtime;
 
 // Only the diagram reader and its styled export admit static foreignObject labels. The
 // ordinary SVG reader still rejects HTML subdocuments. The export class selects scope;
@@ -257,7 +362,10 @@ function sanitizeRapierHtml(value, context = 'render') {
 	let options = selected === 'raw' ? { ...RAPIER_SANITIZE_OPTIONS.render, ALLOW_DATA_ATTR: false } : RAPIER_SANITIZE_OPTIONS[selected] || RAPIER_SANITIZE_OPTIONS.render;
 	const labels = selected === 'diagram' || selected === 'export';
 	if (labels) {
-		options = {...options, USE_PROFILES: {...options.USE_PROFILES, mathMl: true}, ADD_TAGS: ['foreignobject'],
+		// DOMPurify's USE_PROFILES replaces explicit allowlists. Add MathML to the
+		// selected profile without discarding its admitted HTML and SVG vocabulary.
+		options = {...options, ALLOWED_TAGS: [...new Set([...options.ALLOWED_TAGS, ...RAPIER_SANITIZE_PROFILES.mathTags])],
+			ALLOWED_ATTR: [...new Set([...options.ALLOWED_ATTR, ...RAPIER_SANITIZE_PROFILES.mathAttributes])], ADD_TAGS: ['foreignobject'],
 			HTML_INTEGRATION_POINTS: {foreignobject: true}, FORBID_TAGS: options.FORBID_TAGS.filter(tag => tag !== 'foreignobject')};
 		DOMPurify.addHook('uponSanitizeElement', diagramLabelElement);
 		DOMPurify.addHook('uponSanitizeAttribute', diagramLabelAttribute);
@@ -356,6 +464,18 @@ function _rapierDropRemoteRules(rules, owner) {
 	}
 }
 
-  return {_rapierInstallSanitizeHooks, sanitizeRapierHtml, diagramLabelStyle, escapeRapierHtmlText, _rapierChromeOwnsId, _rapierSafeRasterDataUrl, _rapierCssPresentationIsRemote, _rapierRemoteSubresourceOrigin, _rapierStyleWithoutRemoteUrls, _rapierStylesheetWithoutRemoteUrls, _rapierDropRemoteRules};
+function _rapierVerifyRasterBytes(bytes, mime) {
+	if (mime === 'image/jxl') return globalThis.RapierImageAssets.isJxl(bytes);
+
+	// declaration, doctype or generator/license comment before <svg itself, of whatever length its
+
+	if (mime === 'image/svg+xml') return /<svg[\s>]/i.test(new TextDecoder('utf-8', {fatal: false}).decode(bytes));
+	if (mime === 'image/png') return bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47 && bytes[4] === 0x0d && bytes[5] === 0x0a && bytes[6] === 0x1a && bytes[7] === 0x0a;
+	if (mime === 'image/jpeg') return bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff;
+	if (mime === 'image/webp') return bytes.length >= 12 && String.fromCharCode(...bytes.slice(0, 4)) === 'RIFF' && String.fromCharCode(...bytes.slice(8, 12)) === 'WEBP';
+	return false;
+}
+
+  return {_rapierVerifyRasterBytes, _rapierInstallSanitizeHooks, sanitizeRapierHtml, diagramLabelStyle, escapeRapierHtmlText, _rapierChromeOwnsId, _rapierSafeRasterDataUrl, _rapierCssPresentationIsRemote, _rapierRemoteSubresourceOrigin, _rapierStyleWithoutRemoteUrls, _rapierStylesheetWithoutRemoteUrls, _rapierDropRemoteRules};
 }
-export {RAPIER_SANITIZE_FORBID_TAGS as forbidTags, RAPIER_SANITIZE_FORBID_ATTR as forbidAttributes, createRenderSanitizer, RAPIER_SANITIZE_OPTIONS as options, prepareMathSource};
+export {RAPIER_SANITIZE_FORBID_TAGS as forbidTags, RAPIER_SANITIZE_FORBID_ATTR as forbidAttributes, createRenderSanitizer, createInertHtmlSanitizer, RAPIER_SANITIZE_OPTIONS as options, prepareMathSource};

package/dist/kit/render-styles.mjs

@@ -2,12 +2,12 @@
 // The document's renderer. DOM, codecs and host state are explicit inputs.
 function createRenderStyles(runtime) {
   const {_rapierArtifactAccent, _rapierStyleText} = runtime;
-function _rapierArtifactThemeCss() {
+function _rapierArtifactThemeCss(houseDefaults = false) {
 	// Geometry and the selected accent belong to this page; palette and type belong to the
 	// MIT reference sheet. Only the optional code lexer still reads the app token names.
-	const accent = _rapierArtifactAccent();
+	const accent = houseDefaults ? '' : ':root,.md-render{--md-color-accent:' + _rapierArtifactAccent() + '}';
 	return `
-:root,.md-render{--md-color-accent:${accent}}
+${accent}
 html[data-rapier-theme="dark"]{color-scheme:dark}
 html[data-rapier-theme="light"]{color-scheme:light}
 html[data-rapier-theme="system"]{color-scheme:light dark}
@@ -71,11 +71,11 @@ function _rapierDocumentPrintCss(hostSelector) {
 }`;
 }
 
-function _rapierArtifactStyles(theme, includeFonts, printMode) {
+function _rapierArtifactStyles(theme, includeFonts, printMode, houseDefaults = false) {
 	const parts = [];
 	if (includeFonts) parts.push(_rapierStyleText('rapier-font-style'));
 	parts.push(_rapierStyleText('rapier-content-style'));
-	parts.push(_rapierArtifactThemeCss());
+	parts.push(_rapierArtifactThemeCss(houseDefaults));
 	// Where the faces do not ride (the written page's policy carries no font-src), the reader's own sans is
 	// matched to Geist's metrics: one family per system face, src:local() only (fetched by nothing, so the
 	// policy is untouched), size-adjust from Geist's weighted average advance over the face's own (Geist 467