rapier-markdown-kit 1.1.98 → 1.1.101

package/dist/spec/document-settings.mjs

@@ -0,0 +1,494 @@
+// SPDX-License-Identifier: MIT
+// One reader of document-wide settings and the inherited font snapshot.
+// Framing stays in spec/frontmatter.mjs. Reading never rewrites source.
+// The live view reads fontsize, the three font scopes, linestretch and space. It ignores papersize,
+// geometry and pagestyle: a scroll has no page. Word and the PDF read all of them.
+import {frontMatterFrame, frontMatterLine} from './frontmatter.mjs';
+import {normalizeFontFamily, fontFamilyCss, FONT_STACKS} from './md-marks.mjs';
+
+// Twelve points are one reference unit (16 px at the default reading scale).
+const NUMBER = /^(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+const SPACE = Object.freeze({paragraph: .5, heading: Object.freeze([1.5, .5]), block: 1});
+export const DOCUMENT_LEADING = 1.75 / 1.1;
+
+function measure(value, positive = false) {
+	const text = unquote(value);
+	const number = NUMBER.test(text) ? Number(text) : NaN;
+	return Number.isFinite(number) && number >= 0 && (!positive || number > 0) ? number : null;
+}
+
+function fontSize(value) {
+	const match = /^(\d+(?:\.\d*)?|\.\d+)\s*(pt|px)$/i.exec(unquote(value));
+	if (!match) return null;
+	const number = measure(match[1], true), unit = match[2].toLowerCase();
+	if (number === null) return null;
+	const points = unit === 'pt' ? number : number * .75;
+	return Object.freeze({step: number + unit, unit: points / 12,
+		css: 'calc(' + number + ' / ' + (unit === 'pt' ? 12 : 16) + ' * var(--md-unit))', halfPoints: points * 2});
+}
+
+function leading(value) {
+	const factor = measure(value, true);
+	return factor === null ? null : Object.freeze({step: String(factor), factor,
+		css: 'calc(var(--md-text-body) * ' + factor + ')', line: Math.round(factor * 240)});
+}
+
+const PAPERS = Object.freeze({
+	letter: Object.freeze({name: 'letter', width: 12240, height: 15840, css: 'letter'}),
+	a4: Object.freeze({name: 'a4', width: 11906, height: 16838, css: 'A4'}),
+	a5: Object.freeze({name: 'a5', width: 8391, height: 11906, css: 'A5'}),
+	legal: Object.freeze({name: 'legal', width: 12240, height: 20160, css: 'legal'}),
+});
+const EMPTY = Object.freeze({
+	title: null, subtitle: null, lang: null, fontsize: null, mainfont: null, sansfont: null, monofont: null, defaultfont: null, linestretch: null,
+	papersize: null, geometry: null, pagestyle: null, space: null,
+});
+
+function unquote(value) {
+	const text = String(value == null ? '' : value).trim();
+	return text[0] === '"' || text[0] === "'" ? quotedValue(text) ?? text : text;
+}
+
+function marginOf(value) {
+	const match = /^margin\s*=\s*(\d+(?:\.\d+)?)(cm|mm|in|pt)$/i.exec(unquote(value));
+	if (!match) return null;
+	const number = Number(match[1]);
+	if (!Number.isFinite(number) || number < 0 || number > 6) return null;
+	const unit = match[2].toLowerCase();
+	const twips = Math.round(unit === 'in' ? number * 1440 : unit === 'pt' ? number * 20 : unit === 'cm' ? number * 1440 / 2.54 : number * 1440 / 25.4);
+	if (!Number.isSafeInteger(twips) || twips < 0 || twips > 1440 * 6) return null;
+	return Object.freeze({margin: match[1] + unit, twips});
+}
+
+// Token spans retain the source's quotes, comments and collection punctuation.
+function quotedEnd(text, start = 0, limit = text.length) {
+	const quote = text[start];
+	for (let at = start + 1; at < limit; at++) {
+		if (text[at] === '\\' && quote === '"') at++;
+		else if (text[at] === quote) {
+			if (quote === "'" && text[at + 1] === "'") at++;
+			else return at + 1;
+		}
+	}
+	return null;
+}
+
+function quotedValue(text) {
+	if (quotedEnd(text) !== text.length) return null;
+	if (text[0] === "'") return text.slice(1, -1).replace(/''/g, "'");
+	const escapes = {'0': '\0', a: '\x07', b: '\b', t: '\t', n: '\n', v: '\v', f: '\f', r: '\r', e: '\x1b', ' ': ' ', '"': '"', '/': '/', '\\': '\\', N: '\x85', _: '\xa0', L: '\u2028', P: '\u2029'};
+	let value = '';
+	for (let at = 1; at < text.length - 1; at++) {
+		if (text[at] !== '\\') { value += text[at]; continue; }
+		const code = text[++at], width = code === 'x' ? 2 : code === 'u' ? 4 : code === 'U' ? 8 : 0;
+		if (width) {
+			const digits = text.slice(at + 1, at + width + 1), point = Number.parseInt(digits, 16);
+			if (digits.length !== width || !/^[\da-f]+$/i.test(digits) || point > 0x10ffff || point >= 0xd800 && point <= 0xdfff) return null;
+			value += String.fromCodePoint(point); at += width;
+		} else if (Object.hasOwn(escapes, code)) value += escapes[code];
+		else return null;
+	}
+	return value;
+}
+
+function keyOf(text) {
+	return (text[0] === '"' || text[0] === "'" ? quotedValue(text) : text)?.toLowerCase() ?? null;
+}
+
+function flowEnd(text, start, limit = text.length) {
+	const stack = [text[start] === '{' ? '}' : ']'];
+	for (let at = start + 1; at < limit; at++) {
+		const char = text[at];
+		if ((char === '"' || char === "'") && /[\s:[{,]/.test(text[at - 1])) {
+			const end = quotedEnd(text, at, limit);
+			if (end === null) return null;
+			at = end - 1;
+		} else if (char === '#' && /\s/.test(text[at - 1])) {
+			while (at < limit && text[at] !== '\r' && text[at] !== '\n') at++;
+		} else if (char === '[' || char === '{') stack.push(char === '{' ? '}' : ']');
+		else if (char === ']' || char === '}') {
+			if (stack.pop() !== char) return null;
+			if (!stack.length) return at + 1;
+		}
+	}
+	return null;
+}
+
+function fieldLine(line, indented = false) {
+	const indent = /^ */.exec(line.text)[0].length;
+	if (indented ? !indent : !!indent) return null;
+	let end = indent, key;
+	if (line.text[end] === '"' || line.text[end] === "'") {
+		end = quotedEnd(line.text, end);
+		if (end === null) return null;
+		key = keyOf(line.text.slice(indent, end));
+		while (/[ \t]/.test(line.text[end] || 'x')) end++;
+		if (line.text[end] !== ':') return null;
+	} else {
+		end = line.text.indexOf(':', indent);
+		if (end < 0 || end + 1 < line.text.length && !/[\s\[\]{},]/.test(line.text[end + 1])) return null;
+		const raw = line.text.slice(indent, end).trimEnd();
+		if (!raw || /^[?\[\]{},&*!|>]/.test(raw) || /\s#/.test(raw)) return null;
+		key = keyOf(raw);
+	}
+	let start = line.start + end + 1;
+	while (start < line.end && /[ \t]/.test(line.text[start - line.start])) start++;
+	return {key, start, end: start, line, indent, children: [], opaque: key === null, invalid: false};
+}
+
+function valueSpan(source, field, limit) {
+	let at = field.start;
+	const first = source[at];
+	// Tags and anchors may name other YAML values. They are retained, never rewritten by a control.
+	if (first === '&' || first === '*' || first === '!') {
+		field.opaque = true;
+		while (at < field.line.end && /[&*!]/.test(source[at])) {
+			while (at < field.line.end && !/\s/.test(source[at])) at++;
+			while (at < field.line.end && /[ \t]/.test(source[at])) at++;
+		}
+	}
+	const quoted = source[at] === '"' || source[at] === "'", flow = source[at] === '[' || source[at] === '{';
+	let end;
+	if (quoted || flow) {
+		end = quoted ? quotedEnd(source, at, limit) : flowEnd(source, at, limit);
+		if (end === null) { field.invalid = true; field.end = field.line.end; return field; }
+		const tailLine = frontMatterLine(source, end);
+		if (!/^[ \t]*(?:#.*)?$/.test(source.slice(end, Math.min(limit, tailLine.end)))) field.invalid = true;
+		field.multiline = end > field.line.end;
+	} else {
+		end = field.line.end;
+		for (let i = at; i < end; i++) if (source[i] === '#' && (i === at || /\s/.test(source[i - 1]))) { end = i; break; }
+		while (end > at && /[ \t]/.test(source[end - 1])) end--;
+	}
+	field.end = end;
+	field.block = /^[|>][+\-1-9]*$/.test(source.slice(at, field.end));
+	return field;
+}
+
+function mapFields(source, lines, indent) {
+	const fields = [];
+	let invalid = false, current = null;
+	const limit = lines.at(-1)?.end ?? 0;
+	for (const line of lines) {
+		if (current?.multiline && line.start < current.end) continue;
+		if (!line.text.trim() || /^\s*#/.test(line.text)) continue;
+		const ownIndent = /^ */.exec(line.text)[0].length;
+		if (ownIndent > indent && current) { current.children.push(line); continue; }
+		if (ownIndent !== indent) { invalid = true; continue; }
+		const field = fieldLine(line, indent > 0);
+		if (!field) { invalid = true; continue; }
+		current = valueSpan(source, field, limit);
+		if (field.invalid || field.key === null) invalid = true;
+		fields.push(field);
+	}
+	return {fields, invalid};
+}
+
+// An append must never enter an unclosed collection or quoted value, including one under an unrelated key.
+function structureIsClosed(source, lines) {
+	let blockIndent = null, through = 0;
+	const limit = lines.at(-1)?.end ?? 0;
+	for (const line of lines) {
+		if (line.start < through || !line.text.trim() || /^\s*#/.test(line.text)) continue;
+		const indent = /^ */.exec(line.text)[0].length;
+		if (blockIndent !== null && indent > blockIndent) continue;
+		blockIndent = null;
+		let offset = indent;
+		while (/^-\s/.test(line.text.slice(offset))) offset += /^-[ \t]*/.exec(line.text.slice(offset))[0].length;
+		const content = {...line, start: line.start + offset, text: line.text.slice(offset)};
+		const field = fieldLine(content) || {start: content.start, line: content, children: []};
+		const span = valueSpan(source, field, limit);
+		if (span.invalid || field.key === null) return false;
+		if (span.block) blockIndent = indent;
+		if (span.multiline) through = span.end;
+	}
+	return true;
+}
+
+function fieldsOf(source) {
+	const frame = frontMatterFrame(source), lines = [];
+	if (frame.closing) for (let at = frame.opening.next; at < frame.closing.start;) {
+		const line = frontMatterLine(source, at); lines.push(line); at = line.next;
+	}
+	const parsed = mapFields(source, lines, 0);
+	return {frame, fields: parsed.fields, invalid: parsed.invalid || !structureIsClosed(source, lines)};
+}
+
+function flowItems(source, start, stop) {
+	const items = [];
+	for (let at = start; at < stop;) {
+		if (!source.slice(at, stop).trim()) break;
+		let end = at;
+		for (; end < stop; end++) {
+			const char = source[end];
+			if ((char === '"' || char === "'") && (end === at || /[\s:[{,]/.test(source[end - 1]))) {
+				const next = quotedEnd(source, end, stop);
+				if (next === null) return null;
+				end = next - 1;
+			} else if (char === '[' || char === '{') {
+				const next = flowEnd(source, end, stop);
+				if (next === null) return null;
+				end = next - 1;
+			} else if (char === ',') break;
+		}
+		if (!source.slice(at, end).trim()) return null;
+		items.push({start: at, end, comma: end < stop ? end : null});
+		at = end + 1;
+	}
+	return items;
+}
+
+function spaceFields(source, field) {
+	if (!field || field.opaque || field.invalid || field.multiline) return null;
+	const value = source.slice(field.start, field.end);
+	if (value.startsWith('{') && value.endsWith('}') && !field.children.length) {
+		const chunks = flowItems(source, field.start + 1, field.end - 1), fields = [];
+		if (!chunks) return null;
+		for (const chunk of chunks) {
+			const start = chunk.start + source.slice(chunk.start, chunk.end).match(/^\s*/)[0].length;
+			const line = {start, end: chunk.end, next: chunk.end, text: source.slice(start, chunk.end), eol: ''};
+			const item = fieldLine(line);
+			if (!item) return null;
+			valueSpan(source, item, chunk.end);
+			if (item.invalid || item.key === null) return null;
+			fields.push({...item, entryStart: chunk.start, entryEnd: chunk.end, comma: chunk.comma});
+		}
+		return {fields, flow: true};
+	}
+	if (value) return null;
+	if (!field.children.length) return {fields: [], flow: false};
+	const indent = /^ */.exec(field.children[0].text)[0].length;
+	const parsed = mapFields(source, field.children, indent);
+	return parsed.invalid ? null : {...parsed, flow: false, indent};
+}
+
+function headingParts(source, field) {
+	if (field.opaque || field.invalid || field.multiline) return null;
+	let spans;
+	if (field.children.length) {
+		if (field.start !== field.end) return null;
+		let indent = null;
+		spans = field.children.map(line => {
+			const match = /^( +)-[ \t]+/.exec(line.text);
+			if (!match || indent !== null && match[1].length !== indent) return null;
+			indent = match[1].length;
+			const span = valueSpan(source, {start: line.start + match[0].length, line, children: []}, line.end);
+			return span.invalid || span.opaque ? null : span;
+		});
+	} else {
+		if (source[field.start] !== '[' || source[field.end - 1] !== ']') return null;
+		spans = flowItems(source, field.start + 1, field.end - 1);
+	}
+	if (!spans || spans.length !== 2 || spans.some(span => !span)) return null;
+	const values = spans.map(span => measure(source.slice(span.start, span.end)));
+	return values.includes(null) ? null : {values, spans};
+}
+
+function spaceOf(source, field) {
+	const parsed = spaceFields(source, field);
+	if (!parsed) return null;
+	const value = {...SPACE}, seen = new Set();
+	for (const item of parsed.fields) {
+		if (seen.has(item.key)) return null;
+		seen.add(item.key);
+		if (!Object.hasOwn(SPACE, item.key)) continue;
+		if (item.key === 'heading') {
+			const pair = headingParts(source, item);
+			if (!pair) return null;
+			value.heading = Object.freeze(pair.values);
+		} else {
+			if (item.children.length || item.opaque || item.invalid || item.multiline) return null;
+			value[item.key] = measure(source.slice(item.start, item.end));
+			if (value[item.key] === null) return null;
+		}
+	}
+	return Object.keys(SPACE).some(key => seen.has(key)) ? Object.freeze(value) : null;
+}
+
+export function documentFont(value) {
+	const family = normalizeFontFamily(value);
+	if (!family) return null;
+	const named = Object.hasOwn(FONT_STACKS, family.toLowerCase()) ? FONT_STACKS[family.toLowerCase()] : null;
+	return Object.freeze(named ? {...named, family} : {family, stack: 'named', css: fontFamilyCss(family), word: family});
+}
+
+// Font controls use the same source spans as the other document settings.
+export function writeDocumentFontSetting(markdown, key, value) {
+	if (!['mainfont', 'sansfont', 'monofont', 'defaultfont'].includes(key)) throw new TypeError('font: unknown document key');
+	const family = value == null ? null : normalizeFontFamily(value);
+	if (value != null && !family) throw new TypeError('font: use one family name');
+	return updateDocumentSettings(markdown, {[key]: family});
+}
+
+// A language tag is metadata, never CSS or markup. Its source spelling stays untouched.
+export function languageTag(value) {
+	if (typeof value !== 'string' || value.length > 128 || !/^[a-z]{2,8}(?:-[a-z0-9]{1,8})*$/i.test(value)) return null;
+	try { return Intl.getCanonicalLocales(value)[0] || null; }
+	catch (_) { return null; }
+}
+
+export function documentLanguage(settings, device = globalThis.navigator?.language) {
+	return languageTag(settings?.lang) || languageTag(device) || 'en';
+}
+
+// Unrecognized fields remain authored bytes. A duplicate key has no single value.
+export function readDocumentSettings(markdown) {
+	const source = String(markdown ?? ''), {frame, fields} = fieldsOf(source);
+	if (!frame.closing) return EMPTY;
+	const field = name => { const matches = fields.filter(item => item.key === name); return matches.length === 1 ? matches[0] : null; };
+	const take = name => { const item = field(name); return item && !item.children.length && !item.opaque && !item.invalid && !item.multiline && !item.block ? unquote(source.slice(item.start, item.end)) : null; };
+	const fontsize = fontSize(take('fontsize'));
+	const mainfont = documentFont(take('mainfont'));
+	const sansfont = documentFont(take('sansfont'));
+	const monofont = documentFont(take('monofont'));
+	const defaultfont = documentFont(take('defaultfont'));
+	const linestretch = leading(take('linestretch'));
+	const papersize = PAPERS[String(take('papersize') || '').toLowerCase()] || null;
+	const geometry = take('geometry') != null ? marginOf(take('geometry')) : null;
+	const page = String(take('pagestyle') || '').toLowerCase();
+	return Object.freeze({
+		title: take('title') || null, subtitle: take('subtitle') || null, lang: languageTag(take('lang')),
+		fontsize, mainfont, sansfont, monofont, defaultfont, linestretch, space: spaceOf(source, field('space')), papersize, geometry,
+		pagestyle: page === 'plain' || page === 'empty' ? page : null,
+	});
+}
+
+function spaceValue(value) {
+	if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !Object.hasOwn(SPACE, key))) return null;
+	const result = {...SPACE, ...value};
+	if (!Array.isArray(result.heading) || result.heading.length !== 2) return null;
+	return [result.paragraph, ...result.heading, result.block].every(number => typeof number === 'number' && Number.isFinite(number) && number >= 0) ? result : null;
+}
+
+// Change only supplied settings. Unrelated YAML, comments, line endings, BOM and body are never reprinted.
+export function updateDocumentSettings(markdown, patch) {
+	const source = String(markdown ?? ''), parsed = fieldsOf(source), {frame, fields} = parsed, before = readDocumentSettings(source);
+	const changes = [], append = [];
+	const eol = frame.closing ? frame.opening.eol : (source.match(/\r\n|\r|\n/) || ['\n'])[0];
+	const encodeSpace = value => '{ paragraph: ' + value.paragraph + ', heading: [' + value.heading.join(', ') + '], block: ' + value.block + ' }';
+	const same = (left, right) => Math.abs(left - right) <= Number.EPSILON * Math.max(Math.abs(left), Math.abs(right)) * 4;
+	const refuse = key => { throw new RangeError('Edit this setting in source: ' + key); };
+	const removeLine = (line, end, indent = 0) => {
+		const suffix = source.slice(end, line.end);
+		changes.push({start: line.start, end: line.next, text: suffix.trimStart().startsWith('#') ? ' '.repeat(indent) + suffix + line.eol : ''});
+	};
+	const replaceValue = (field, text) => changes.push({start: field.start, end: field.end,
+		text: (source[field.start - 1] === ':' ? ' ' : '') + text + (source[field.end] === '#' ? ' ' : '')});
+	for (const [key, supplied] of Object.entries(patch || {})) {
+		const font = ['mainfont', 'sansfont', 'monofont', 'defaultfont'].includes(key);
+		if (!font && !['fontsize', 'linestretch', 'space'].includes(key)) throw new TypeError('Unknown document setting: ' + key);
+		const matches = fields.filter(item => item.key === key);
+		if (matches.length > 1) throw new RangeError('Duplicate document setting: ' + key);
+		const field = matches[0];
+		const value = supplied === null ? null : font ? documentFont(supplied) : key === 'fontsize' ? fontSize(supplied) : key === 'linestretch' ? leading(supplied) : spaceValue(supplied);
+		if (supplied !== null && !value) throw new TypeError('Invalid document setting: ' + key);
+		const encoded = value === null ? '' : font ? JSON.stringify(value.family) : key === 'fontsize' ? value.step : key === 'linestretch' ? String(value.factor) : encodeSpace(value);
+		if (key !== 'space' && value !== null && before[key] && (font ? before[key].family === value.family : key === 'fontsize' ? same(before.fontsize.unit, value.unit) : before.linestretch.factor === value.factor)) continue;
+		if (!field) { if (value !== null) append.push(key + ': ' + encoded + eol); continue; }
+		if (field.opaque || field.invalid || field.multiline || field.block) refuse(key);
+		if (key === 'space') {
+			const map = spaceFields(source, field);
+			if (!map) refuse(key);
+			const known = map.fields.filter(item => Object.hasOwn(SPACE, item.key));
+			if (new Set(map.fields.map(item => item.key)).size !== map.fields.length) throw new RangeError('Duplicate document setting: space');
+			if (known.length && !before.space) refuse(key);
+			if (value === null) {
+				const unknown = map.fields.length !== known.length;
+				for (const item of known) {
+					if (map.flow) {
+						if (unknown) changes.push({start: item.entryStart, end: item.comma === null ? item.entryEnd : item.comma + 1, text: ''});
+					} else {
+						for (const child of item.children) {
+							const own = headingParts(source, item)?.spans.find(span => span.line === child);
+							if (!own) refuse(key);
+							removeLine(child, own.end, /^ */.exec(child.text)[0].length);
+						}
+						removeLine(item.line, item.end, item.indent);
+					}
+				}
+				if (!unknown) removeLine(field.line, field.end);
+				continue;
+			}
+			if (before.space && encodeSpace(before.space) === encoded) continue;
+			if (!map.fields.length) { replaceValue(field, encoded); continue; }
+			const missing = [];
+			for (const name of Object.keys(SPACE)) {
+				if (before.space && JSON.stringify(before.space[name]) === JSON.stringify(value[name])) continue;
+				const item = map.fields.find(item => item.key === name);
+				const text = name === 'heading' ? '[' + value.heading.join(', ') + ']' : String(value[name]);
+				if (!item) { missing.push(name + ': ' + text); continue; }
+				if (name === 'heading') {
+					const pair = headingParts(source, item);
+					for (let i = 0; i < 2; i++) if (pair.values[i] !== value.heading[i]) {
+						const span = pair.spans[i], raw = source.slice(span.start, span.end);
+						changes.push({start: span.start + raw.length - raw.trimStart().length, end: span.end - raw.length + raw.trimEnd().length, text: String(value.heading[i])});
+					}
+				} else replaceValue(item, text);
+			}
+			if (missing.length) {
+				if (map.flow) {
+					const last = map.fields.at(-1);
+					changes.push({start: field.end - 1, end: field.end - 1, text: (last.comma === null ? ', ' : ' ') + missing.join(', ')});
+				} else {
+					const last = field.children.at(-1), indent = ' '.repeat(map.indent);
+					changes.push({start: last.next, end: last.next, text: missing.map(item => indent + item + eol).join('')});
+				}
+			}
+			continue;
+		}
+		if (field.children.length) refuse(key);
+		if (value === null) removeLine(field.line, field.end);
+		else replaceValue(field, encoded);
+	}
+	if (!changes.length && !append.length) return source;
+	if (parsed.invalid) throw new RangeError('Edit this front matter in source before changing settings');
+	if (!frame.closing) {
+		if (/^--- *$/.test(frame.opening.text) && frame.opening.eol) throw new RangeError('Close the front matter before changing settings');
+		return frame.bom + '---' + eol + append.join('') + '---' + eol + source.slice(frame.bom.length);
+	}
+	if (append.length) changes.push({start: frame.closing.start, end: frame.closing.start, text: append.join('')});
+	let next = source;
+	for (const change of changes.sort((a, b) => b.start - a.start || b.end - a.end)) next = next.slice(0, change.start) + change.text + next.slice(change.end);
+	return next;
+}
+
+// The page's <title>, the PDF's document title. Subtitle follows the title.
+// An absent title returns '' so the caller keeps the filename.
+export function documentTitle(settings) {
+	if (!settings || !settings.title) return '';
+	return settings.subtitle ? settings.title + ' \u2014 ' + settings.subtitle : settings.title;
+}
+
+// A supplied personal default replaces only the inherited snapshot. Explicit scopes win.
+// Omitted means use the portable source; null means the reader's factory default.
+export function documentSettingsFonts(settings, defaultFont) {
+	const inherited = defaultFont === undefined ? settings?.defaultfont : documentFont(defaultFont);
+	const main = settings?.mainfont || inherited;
+	return {main, sans: settings?.sansfont || main, mono: settings?.monofont};
+}
+
+export function documentSettingsStyle(settings, defaultFont) {
+	if (!settings) return '';
+	const decls = [];
+	if (settings.fontsize) decls.push('--md-text-body:' + settings.fontsize.css);
+	if (settings.linestretch || settings.fontsize) decls.push('--md-line:calc(var(--md-text-body) * ' + (settings.linestretch?.factor ?? DOCUMENT_LEADING) + ')');
+	if (settings.space) {
+		decls.push('--md-space-paragraph:' + settings.space.paragraph, '--md-space-heading-before:' + settings.space.heading[0],
+			'--md-space-heading-after:' + settings.space.heading[1], '--md-space-block:' + settings.space.block);
+	}
+	const {main, sans, mono} = documentSettingsFonts(settings, defaultFont);
+	if (sans) decls.push('--md-font-sans:' + (sans.css || fontFamilyCss(sans.family)));
+	if (main) decls.push('font-family:' + (main.css || fontFamilyCss(main.family)));
+	if (mono) decls.push('--md-font-mono:' + (mono.css || fontFamilyCss(mono.family)));
+	return decls.length ? '.md-render{' + decls.join(';') + '}' : '';
+}
+
+// Null when the page keys do not change the print sheet. The view never asks.
+// The default rule stays the writer's own: size:auto; margin:12mm 14mm 14mm.
+export function documentSettingsPageRule(settings) {
+	if (!settings || (!settings.papersize && !settings.geometry && settings.pagestyle !== 'plain')) return null;
+	const size = settings.papersize ? settings.papersize.css : 'auto';
+	const margin = settings.geometry ? settings.geometry.margin : '12mm 14mm 14mm';
+	const numbers = settings.pagestyle === 'plain' ? '@bottom-center{content:counter(page)}' : '';
+	return '@page{size:' + size + ';margin:' + margin + (numbers ? ';' + numbers : '') + '}';
+}

package/dist/spec/frontmatter.mjs

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+// Framing owns only offsets. No field interpretation or source normalization belongs here.
+export function frontMatterLine(text, start) {
+	let end = start;
+	while (end < text.length && text[end] !== '\r' && text[end] !== '\n') end++;
+	const eol = text[end] === '\r' && text[end + 1] === '\n' ? '\r\n' : text[end] === '\r' || text[end] === '\n' ? text[end] : '';
+	return {start, end, next: end + eol.length, text: text.slice(start, end), eol};
+}
+
+export function frontMatterFrame(text) {
+	if (typeof text !== 'string') throw new TypeError('Front matter needs text');
+	const bom = text[0] === '\uFEFF' ? '\uFEFF' : '';
+	const opening = frontMatterLine(text, bom.length);
+	let closing = null;
+	if (/^--- *$/.test(opening.text) && opening.eol) {
+		for (let at = opening.next; at < text.length;) {
+			const line = frontMatterLine(text, at);
+			if (/^(?:---|\.\.\.) *$/.test(line.text)) { closing = line; break; }
+			at = line.next;
+		}
+	}
+	return {bom, opening, closing};
+}
+
+export function splitOpeningFrontmatter(markdown) {
+	const source = String(markdown == null ? '' : markdown);
+	const {closing} = frontMatterFrame(source);
+	const bodyOffset = closing ? closing.next : 0;
+	return {frontmatter: closing ? source.slice(0, bodyOffset) : null, body: source.slice(bodyOffset), bodyOffset};
+}