rapier-markdown-kit 1.1.104 → 1.2.5

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

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: MIT
+import {words, letter, within, prev, next} from './tokens.mjs';
+
+// Exact source records for a range: lines, then words, then characters, or structural parts when supplied.
+export function walker(c) {
+  const {before, after, spend, safe, budget, raw, chars, code, segmenter, tokens, matches} = c;
+  function record(a0, a1, b0, b1, unit, part, coarse = false) {
+    if (a1 - a0 === b1 - b0 && before.slice(a0, a1) === after.slice(b0, b1)) return;
+    // Internal records: before, after, coarse, concern, transported fragments.
+    c.result.push([[a0, a1], [b0, b1], coarse, [a0 === a1 ? 2 : b0 === b1 ? 0 : 1, part?.kind || unit, part?.name]]);
+  }
+
+  // A line deletion or insertion holding whole named parts and only blank text besides is one record per part,
+  // cut at line starts, so each keeps its own name (and its callers' breaks).
+  function name(from, ownersA, ownersB) {
+    for (let r = from; r < c.result.length; r++) {
+      const [[a0, a1], [b0, b1]] = c.result[r], side = a0 === a1 ? 1 : b0 === b1 ? 0 : -1;
+      if (side < 0) continue;
+      const [s0, s1] = c.result[r][side], text = side ? after : before;
+      const parts = (side ? ownersB : ownersA).filter(part => part?.name && part.start >= s0 && part.end <= s1);
+      if (!parts.length || !spend(s1 - s0)) continue;
+      let blank = text.slice(s0, parts[0].start);
+      for (let k = 1; k <= parts.length; k++) blank += text.slice(parts[k - 1].end, parts[k]?.start ?? s1);
+      if (/\S/.test(blank)) continue;
+      const rows = parts.map((part, k) => {
+        const start = k ? Math.max(parts[k - 1].end, text.lastIndexOf('\n', part.start - 1) + 1) : s0;
+        return [start, part];
+      });
+      c.result.splice(r, 1, ...rows.map(([start, part], k) => {
+        const end = rows[k + 1]?.[0] ?? s1, here = [side ? [a0, a0] : [start, end], side ? [start, end] : [b0, b0]];
+        return [here[0], here[1], false, [side ? 2 : 0, part.kind, part.name]];
+      }));
+      r += rows.length - 1;
+    }
+  }
+
+  // A search step scans at most one fixed-size source chunk.
+  function common(a, b, end, step) {
+    let n = 0;
+    while (n < end && spend()) {
+      const stop = Math.min(end, n + 256);
+      while (n < stop && before.charCodeAt(a) === after.charCodeAt(b)) { n++; a += step; b += step; }
+      if (n < stop) break;
+    }
+    return n;
+  }
+
+  function walk(a0, a1, b0, b1, level, ap, bp, context) {
+    if (a1 - a0 === b1 - b0 && before.slice(a0, a1) === after.slice(b0, b1)) return;
+    if (!spend()) { record(a0, a1, b0, b1, 'block', context, true); return; }
+    const structural = level <= 0 && level > -128 && (ap?.length || bp?.length);
+    if (!structural && raw !== 'word') {
+      let n = common(a0, b0, Math.min(a1 - a0, b1 - b0), 1);
+      while (n && (!safe(before, a0 + n) || !safe(after, b0 + n) || !raw && level < 3 && (within(before, a0 + n) || within(after, b0 + n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
+      if (level === 1 && n) {
+        const next = Math.max(0, before.lastIndexOf('\n', a0 + n - 1) + 1 - a0);
+        spend(Math.ceil((n - next) / 256)); n = next;
+      }
+      a0 += n; b0 += n;
+      n = common(a1 - 1, b1 - 1, Math.min(a1 - a0, b1 - b0), -1);
+      while (n && (!safe(before, a1 - n) || !safe(after, b1 - n) || !raw && level < 3 && (within(before, a1 - n) || within(after, b1 - n)))) {
+        if (!spend()) { n = 0; break; } n--;
+      }
+      if (level === 1) while (n && (before[a1 - n - 1] !== '\n' || after[b1 - n - 1] !== '\n' || before[a1 - n] === '\n' || after[b1 - n] === '\n')) { if (!spend()) { n = 0; break; } n--; }
+      a1 -= n; b1 -= n;
+      if (budget.left < 0) { record(a0, a1, b0, b1, 'block', context, true); return; }
+    }
+    let unit = level >= 3 ? 'char' : level === 2 ? 'word' : 'line';
+    if (!raw && level === 2 && a1 - a0 + b1 - b0 <= 4 && [...before.slice(a0, a1), ...after.slice(b0, b1)].length <= 2 &&
+    letter(prev(before, a0) || prev(after, b0)) && letter(next(before, a1) || next(after, b1))) unit = 'char';
+    if (!structural && (a0 === a1 || b0 === b1)) { record(a0, a1, b0, b1, unit, context); return; }
+    const left = tokens(before, a0, a1, structural ? 0 : Math.max(1, level), ap);
+    const right = tokens(after, b0, b1, structural ? 0 : Math.max(1, level), bp);
+    if (!left || !right) { record(a0, a1, b0, b1, unit, context, true); return; }
+    const [a, x, ownersA] = left, [b, y, ownersB] = right, pairs = matches(a, b);
+    let ai = 0, bi = 0;
+    for (let i = 0; i <= a.length; i++) {
+      const j = i === a.length ? b.length : pairs[i];
+      if (j === undefined) continue;
+      const x0 = x[ai], x1 = x[i], y0 = y[bi], y1 = y[j];
+      if (ai < i || bi < j) {
+        if (budget.left < 0 || pairs.coarse?.has(ai)) record(x0, x1, y0, y1, unit, context, true);
+        else if (structural && (ai === i || bi === j)) {
+          for (let k = ai; k < i; k++) record(x[k], x[k + 1], y0, y0, unit, ownersA[k] || context);
+          for (let k = bi; k < j; k++) record(x1, x1, y[k], y[k + 1], unit, ownersB[k] || context);
+        } else if (structural) {
+          const p = ownersA[ai], q = ownersB[bi];
+          if (i - ai === 1 && j - bi === 1 && p && q && p.kind === q.kind) walk(x0, x1, y0, y1, level - 1, p.children, q.children, q);
+          else {
+            const from = c.result.length;
+            walk(x0, x1, y0, y1, 1, null, null, context);
+            name(from, ownersA.slice(ai, i), ownersB.slice(bi, j));
+          }
+        } else if (level < 2 && raw !== 'line') lines(x.slice(ai, i + 1), y.slice(bi, j + 1), context);
+        else if (level === 2 && chars && !raw && i - ai <= 1 && j - bi <= 1 && x1 - x0 + y1 - y0 < 100) {
+          // A changed token is replaced whole unless the caller asks for the characters inside it.
+          walk(x0, x1, y0, y1, 3, null, null, context);
+        } else record(x0, x1, y0, y1, unit, context);
+      }
+      if (i < a.length) {
+        const p = ownersA[i], q = ownersB[j];
+        if ((p || q || level <= 1 && !raw) && before.slice(x[i], x[i + 1]) !== after.slice(y[j], y[j + 1]))
+          walk(x[i], x[i + 1], y[j], y[j + 1], p || q ? level - 1 : 3, p?.children, q?.children, q || p || context);
+      }
+      ai = i + 1; bi = j + 1;
+    }
+  }
+
+  // Unequal lines pair in order by shared words. A line sharing under a quarter of its words with every candidate is
+  // replaced whole: an inserted line never borrows a neighbour's words, and a rewrite never reads as stray fragments.
+  function lines(x, y, context) {
+    const n = x.length - 1, m = y.length - 1;
+    if (n * m > 4096 || !spend(n * m + x[n] - x[0] + y[m] - y[0])) return row(x[0], x[n], y[0], y[m], context);
+    // A renamed name's sites count as shared words.
+    if (!c.renames) {
+      c.renames = [[], []];
+      for (const [p, old] of c.aliases || []) if (before.slice(...old.nameAt) !== after.slice(...p.nameAt)) {
+        c.renames[0].push(old.nameAt, ...c.la.filter(l => l.key === old.key).map(l => l.at));
+        c.renames[1].push(p.nameAt, ...c.lb.filter(l => l.key === p.key).map(l => l.at));
+      }
+    }
+    const weight = (side, a, b) => {
+      const counts = new Map(), text = side ? after : before;
+      for (const [c, d] of words(segmenter, text.slice(a, b))) counts.set(text.slice(a + c, a + d), (counts.get(text.slice(a + c, a + d)) || 0) + d - c);
+      return [counts, [...counts.values()].reduce((n, v) => n + v, 0), c.renames[side].reduce((n, at) => n + Math.max(0, Math.min(b, at[1]) - Math.max(a, at[0])), 0)];
+    };
+    const left = x.slice(0, -1).map((at, k) => weight(0, at, x[k + 1])), right = y.slice(0, -1).map((at, k) => weight(1, at, y[k + 1]));
+    const best = Array.from({length: n + 1}, () => new Float64Array(m + 1)), pairs = [];
+    for (let k = 1; k <= n; k++) for (let l = 1; l <= m; l++) {
+      const [a, sa, ra] = left[k - 1], [b, sb, rb] = right[l - 1];
+      let shared = sa || sb ? Math.max(ra, rb) : 0.5;
+      for (const [key, v] of a) shared += Math.min(v, b.get(key) || 0);
+      best[k][l] = Math.max(best[k - 1][l], best[k][l - 1], shared * 4 > Math.max(sa, sb) && best[k - 1][l - 1] + shared);
+    }
+    for (let k = n, l = m; k && l;) {
+      if (best[k][l] === best[k - 1][l]) k--;
+      else if (best[k][l] === best[k][l - 1]) l--;
+      else pairs.unshift([--k, --l]);
+    }
+    let k = 0, l = 0;
+    for (const [p, q] of [...pairs, [n, m]]) {
+      // A merge compares one line against one line by character, whatever they share.
+      if (raw === 'char' && p - k === 1 && q - l === 1) row(x[k], x[p], y[l], y[q], context);
+      else if (k < p || l < q) record(x[k], x[p], y[l], y[q], 'line', context);
+      if (p < n) row(x[p], x[p + 1], y[q], y[q + 1], context);
+      k = p + 1; l = q + 1;
+    }
+  }
+
+  // A table row with the same number of cells on both sides changes cell by cell; a character diff stays in its line.
+  function row(a0, a1, b0, b1, context) {
+    if (raw === 'char') return walk(a0, a1, b0, b1, 3, null, null, context);
+    const cells = (text, a, b) => /^[ \t]*\|/.test(text.slice(a, b)) && [...text.slice(a, b).matchAll(/(?<!\\)\|/g)].map(m => a + m.index);
+    const p = !code && cells(before, a0, a1), q = p && cells(after, b0, b1);
+    if (!q || p.length !== q.length || !spend(p.length)) return walk(a0, a1, b0, b1, 2, null, null, context);
+    for (let k = 0; k <= p.length; k++) walk(k ? p[k - 1] + 1 : a0, p[k] ?? a1, k ? q[k - 1] + 1 : b0, q[k] ?? b1, 2, null, null, context);
+  }
+
+  // Surviving source pieces keep the occurrence witnessed by the host.
+  function operations(rows) {
+    if (!Array.isArray(rows)) return null;
+    const pieces = [[0, before.length]];
+    let length = before.length, steps = 1e7;
+    const verify = n => {
+      if ((steps -= n) >= 0) return true;
+      budget.left = -1; return false;
+    };
+    const split = at => {
+      let position = 0;
+      for (let i = 0; i < pieces.length; i++) {
+        const [start, end, text] = pieces[i], size = end - start;
+        if (position === at) return i;
+        if (position + size > at) {
+          const n = at - position;
+          pieces.splice(i, 1, [start, start + n, text], [start + n, end, text]);
+          return i + 1;
+        }
+        position += size;
+      }
+      return pieces.length;
+    };
+    for (const row of rows) {
+      if (!row || !Number.isSafeInteger(row.pos) || typeof row.removed !== 'string' || typeof row.inserted !== 'string' ||
+        row.pos < 0 || row.pos + row.removed.length > length || !verify(pieces.length * 2 + 1)) return null;
+      const left = split(row.pos), right = split(row.pos + row.removed.length);
+      let at = 0;
+      for (let i = left; i < right; i++) {
+        const [start, end, text = before] = pieces[i];
+        if (!row.removed.startsWith(text.slice(start, end), at)) return null;
+        at += end - start;
+      }
+      if (row.removed === row.inserted) continue;
+      pieces.splice(left, right - left, [0, row.inserted.length, row.inserted]);
+      length += row.inserted.length - row.removed.length;
+    }
+    if (length !== after.length) return null;
+    const spans = [];
+    let a = 0, b = 0, at = 0;
+    for (const [start, end, text] of pieces) {
+      const size = end - start;
+      if (!verify(1) || !after.startsWith((text ?? before).slice(start, end), at)) return null;
+      if (text === undefined) {
+        let x = start, y = at, tail = end;
+        while (x < tail && (!safe(before, x) || !safe(after, y))) { x++; y++; if (!verify(1)) return null; }
+        while (tail > x && (!safe(before, tail) || !safe(after, at + tail - start))) { tail--; if (!verify(1)) return null; }
+        if (tail > x) {
+          if (a !== x || b !== y) spans.push([a, x, b, y]);
+          a = tail; b = at + tail - start;
+        }
+      }
+      at += size;
+    }
+    if (a !== before.length || b !== after.length) spans.push([a, before.length, b, after.length]);
+    return spans;
+  }
+  return {record, name, walk, operations};
+}

package/dist/spec/document-fonts.mjs

@@ -9,7 +9,7 @@ import {normalizeFontFamily, fontFamilyCss, FONT_STACKS, typography} from './md-
 export const CSS_GENERIC_FONT_FAMILIES = Object.freeze(['serif', 'sans-serif', 'monospace', 'cursive', 'fantasy', 'system-ui',
   'ui-serif', 'ui-sans-serif', 'ui-monospace', 'ui-rounded', 'emoji', 'math', 'fangsong', 'initial', 'revert', 'revert-layer']);
 
-// Also relocated into the parse worker. No decoding or external resource loading happens here.
+// No decoding or external resource loading happens here.
 export function fontDataUrl(url) {
 	if (typeof url !== 'string') return null;
 	const match = /^data:font\/(woff2|woff|ttf|otf);base64,([A-Za-z0-9+/]+={0,2})$/i.exec(url);

package/dist/spec/document-settings.mjs

@@ -1,14 +1,13 @@
 // 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,
+// The live view reads fontsize, the three font scopes and linestretch. 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) {
@@ -41,7 +40,7 @@ const PAPERS = Object.freeze({
 });
 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,
+	papersize: null, geometry: null, pagestyle: null,
 });
 
 function unquote(value) {
@@ -53,7 +52,7 @@ 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;
+	if (!Number.isFinite(number) || number < 0) 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;
@@ -214,97 +213,6 @@ function fieldsOf(source) {
 	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;
@@ -348,94 +256,37 @@ export function readDocumentSettings(markdown) {
 	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,
+		fontsize, mainfont, sansfont, monofont, defaultfont, linestretch, 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 removeLine = (line, end) => {
 		const suffix = source.slice(end, line.end);
-		changes.push({start: line.start, end: line.next, text: suffix.trimStart().startsWith('#') ? ' '.repeat(indent) + suffix + line.eol : ''});
+		changes.push({start: line.start, end: line.next, text: suffix.trimStart().startsWith('#') ? 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);
+		if (!font && !['fontsize', 'linestretch'].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);
+		const value = supplied === null ? null : font ? documentFont(supplied) : key === 'fontsize' ? fontSize(supplied) : leading(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;
+		const encoded = value === null ? '' : font ? JSON.stringify(value.family) : key === 'fontsize' ? value.step : String(value.factor);
+		if (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 (key === 'fontsize' && value !== null && fontSize(encoded)?.unit !== value.unit) refuse(key);
 		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);
@@ -472,10 +323,6 @@ export function documentSettingsStyle(settings, defaultFont) {
 	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)));