rapier-markdown-kit 1.1.104 → 1.2.3

package/dist/layout/model.mjs

@@ -251,13 +251,11 @@ export function bandsProfile(bands) {
 export function serializeProfile(profile, count = shapeGrid) {
   if (!profile) return '';
   const bands = [];
-  let any = false;
   for (let index = 0; index < count; index++) {
     const t = (index + .5) / count;
     let runs = profile.runsAt ? profile.runsAt(t) : null;
     if (!runs) { const span = profile.spanAt ? profile.spanAt(t) : null; runs = span ? [span] : []; }
     const clean = (runs || []).map(([a, b]) => [Math.max(0, Math.min(1, +a)), Math.max(0, Math.min(1, +b))]).filter(([a, b]) => Number.isFinite(a) && Number.isFinite(b) && b > a);
-    if (clean.length) any = true;
     bands.push(clean.map(([a, b]) => {
       let left = Math.round(a * 1e4), right = Math.round(b * 1e4);
       // A narrow occupied run must not round to an invalid zero-width descriptor.
@@ -265,13 +263,13 @@ export function serializeProfile(profile, count = shapeGrid) {
       return (left / 1e4) + '-' + (right / 1e4);
     }).join(','));
   }
-  return any ? bands.join('|') : '';
+  return bands.join('|');
 }
 
 export function parseProfile(text) {
-  if (typeof text !== 'string' || !text) return null;
+  if (typeof text !== 'string' || !text || text.length > 262144) return null;
   const bands = text.split('|').map(band => band ? band.split(',').map(run => run.split('-').map(Number)) : []);
-  if (bands.length < 2 || bands.some(band => band.some(run => run.length !== 2 || !run.every(Number.isFinite) || run[0] < 0 || run[1] > 1 || run[1] <= run[0]))) return null;
+  if (bands.length < 2 || bands.length > 192 || bands.some(band => band.length > 192 || band.some(run => run.length !== 2 || !run.every(Number.isFinite) || run[0] < 0 || run[1] > 1 || run[1] <= run[0]))) return null;
   return bandsProfile(bands);
 }
 
@@ -309,9 +307,13 @@ export function pictureSlices(profile, x, y, width, height, scale = 1) {
         return span ? [span] : [];
       }).filter(run => Number.isFinite(run[0]) && Number.isFinite(run[1]) && run[1] > run[0])
         .sort((a, b) => a[0] - b[0]);
-      // Words wrap the outer contour: a band reserves from its leftmost ink to its rightmost, so no word lands
-      // inside a hollow outline or between two strokes of one picture.
-      const merged = runs.length ? [[runs[0][0], Math.max(...runs.map(run => run[1]))]] : [];
+      // Preserve transparent holes and gaps; only overlapping runs share an obstacle.
+      const merged = [];
+      for (const run of runs) {
+        const tail = merged.at(-1);
+        if (tail && run[0] <= tail[1]) tail[1] = Math.max(tail[1], run[1]);
+        else merged.push([...run]);
+      }
       const current = new Map();
       for (const [left, right] of merged) {
         const key = left + ':' + right;

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

@@ -68,7 +68,7 @@ export function diff(before, after, options = {}) {
   const initial = budget.left, raw = options._unit;
   let result = [], code = options.as === 'code', structures, pa, pb, la, lb, aliases;
   const spend = (n = 1) => (budget.left -= n) >= 0;
-  const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c);
+  const letter = c => c && /[\p{L}\p{M}\p{N}_]/u.test(c), within = (text, at) => letter(text[at - 1]) && letter(text[at]);
   const overlaps = (a, b) => a[0] < b[1] && a[1] > b[0];
   const inside = (c, a, b) => [a, b].every((range, side) => c[side][0] === c[side][1] ||
     c[side][0] >= range[0] && c[side][1] <= range[1]);
@@ -146,7 +146,11 @@ export function diff(before, after, options = {}) {
         if (!count) continue;
         // A chain is admitted only after visiting every candidate. Reject a
         // search whose mandatory visits cannot fit before allocating its nodes.
-        if ((unique || count) > Math.min(131072 - nodes, budget.left)) { budget.left = -1; continue; }
+        if ((unique || count) > Math.min(131072 - nodes, budget.left)) {
+          // Repetitive text has too many equal pairs; a shortest script needs no anchors.
+          if (!shortest(a, b, a0, a1, b0, b1, found) && budget.left >= 0) (found.coarse ||= new Set()).add(a0);
+          continue;
+        }
       }
       search: for (let i = a0; i < a1; i++) {
         const list = positions[a[i]];
@@ -178,6 +182,27 @@ export function diff(before, after, options = {}) {
     return found;
   }
 
+  // Myers' greedy search: O((N + M) D) steps; each frontier is kept for the backward pass.
+  function shortest(a, b, a0, a1, b0, b1, found) {
+    const n = a1 - a0, m = b1 - b0, v = new Int32Array(2 * (n + m) + 3), o = n + m + 1, trace = [];
+    for (let d = 0; d <= 2048 && spend(2 * d + 1); d++) {
+      trace.push(v.slice(o - d, o + d + 1));
+      for (let k = -d; k <= d; k += 2) {
+        let x = k === -d || k !== d && v[o + k - 1] < v[o + k + 1] ? v[o + k + 1] : v[o + k - 1] + 1, y = x - k;
+        while (x < n && y < m && a[a0 + x] === b[b0 + y] && spend()) { x++; y++; }
+        v[o + k] = x;
+        if (x < n || y < m) continue;
+        for (x = n, y = m; d >= 0; d--) {
+          const w = trace[d], k = x - y, prev = k === -d || k !== d && w[d + k - 1] < w[d + k + 1] ? k + 1 : k - 1;
+          const px = d ? w[d + prev] : 0, py = px - prev;
+          while (x > px && y > py) if (a[a0 + --x] === b[b0 + --y]) found[a0 + x] = b0 + y;
+          x = px; y = py;
+        }
+        return true;
+      }
+    }
+  }
+
   // A search step scans at most one fixed-size source chunk.
   function common(a, b, end, step) {
     let n = 0;
@@ -195,14 +220,18 @@ export function diff(before, after, options = {}) {
     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))) { if (!spend()) { n = 0; break; } n--; }
+      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))) { if (!spend()) { n = 0; break; } n--; }
+      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; }
@@ -220,7 +249,7 @@ export function diff(before, after, options = {}) {
       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) record(x0, x1, y0, y1, unit, context, true);
+        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);
@@ -233,12 +262,9 @@ export function diff(before, after, options = {}) {
           const start = result.length;
           walk(x0, x1, y0, y1, 3, null, null, context);
           const edits = result.slice(start);
+          // A letter-sized correction stays a letter; any other word change marks the whole word.
           if (edits.length !== 1 || edits[0][0][1] - edits[0][0][0] + edits[0][1][1] - edits[0][1][0] > Math.max(2, (x1 - x0 + y1 - y0) / 3)) {
-            const reading = [[x0, x1], [y0, y1]], group = [edits[0][3][0], context?.kind || 'word', edits[0][3][2], reading];
-            for (const edit of edits) {
-              if (group[0] !== edit[3][0]) group[0] = 1;
-              edit[3] = group;
-            }
+            result.length = start; record(x0, x1, y0, y1, unit, context);
           }
         } else record(x0, x1, y0, y1, unit, context);
       }
@@ -328,6 +354,23 @@ export function diff(before, after, options = {}) {
   else walk(0, before.length, 0, after.length, structures ? 0 : raw === 'char' ? 3 : raw === 'word' ? 2 : 1,
     structures?.[0]?.parts, structures?.[1]?.parts);
 
+  // A separator-only piece beside another edit joins it; equal separators at its ends stay unchanged.
+  if (!raw) for (let i = result.length - 1; i > 0; i--) {
+    const p = result[i - 1], q = result[i], side = p[0][0] === p[0][1] ? 1 : p[1][0] === p[1][1] ? 0 : -1, text = side ? after : before;
+    if (side >= 0 && !/\S/.test(text.slice(...p[side]))) {
+      let n = 0;
+      while (p[0][1] + n < q[0][0] && text[p[side][0] + n] === text[p[side][1] + n]) n++;
+      if (p[0][1] + n === q[0][0] && p.slice(0, 2).every((span, k) => safe(k ? after : before, span[0] + n) && safe(k ? after : before, span[1] + n)))
+        for (const span of p.slice(0, 2)) { span[0] += n; span[1] += n; }
+    }
+    if (p[2] || q[2] || p[0][1] !== q[0][0] || p[1][1] !== q[1][0] ||
+      ![p, q].some(r => !/\S/.test(before.slice(...r[0]) + after.slice(...r[1])))) continue;
+    const x = [p[0][0], q[0][1]], y = [p[1][0], q[1][1]], keep = /\S/.test(before.slice(...q[0]) + after.slice(...q[1])) ? q : p;
+    while (x[0] < x[1] && y[0] < y[1] && /\s/.test(before[x[1] - 1]) && before[x[1] - 1] === after[y[1] - 1] &&
+      safe(before, x[1] - 1) && safe(after, y[1] - 1)) { x[1]--; y[1]--; }
+    keep[3][0] = x[0] === x[1] ? 2 : y[0] === y[1] ? 0 : 1;
+    result.splice(i - 1, 2, [x, y, false, keep[3]]);
+  }
   try { if (!raw && budget.left >= 0) {
     const check = n => { if (!spend(n)) throw null; };
     // Split transported text at wording boundaries; positions and words own distinct edits.
@@ -353,11 +396,14 @@ export function diff(before, after, options = {}) {
         if (n * 5 > Math.max(prior.length, key.length) * 3 && n >= score) { old = n === score ? null : candidate; score = n; }
       }
       if (!old || old[4]) continue;
-      const x = [...old[0]], y = [...item[1]], left = before.slice(...x).match(/\s*$/)[0], right = after.slice(...y).match(/\s*$/)[0];
-      let common = 0;
-      while (common < Math.min(left.length, right.length) && left[common] === right[common]) common++;
-      if (common && safe(before, x[1] - left.length + common) && safe(after, y[1] - right.length + common)) {
-        x[1] -= left.length - common; y[1] -= right.length - common;
+      // Separators that only one end carries stay outside the transported text.
+      const x = [...old[0]], y = [...item[1]];
+      for (const end of [0, 1]) {
+        const pattern = end ? /\s*$/ : /^\s*/, left = before.slice(...x).match(pattern)[0], right = after.slice(...y).match(pattern)[0];
+        let common = 0;
+        while (common < Math.min(left.length, right.length) && left.at(end ? common : -1 - common) === right.at(end ? common : -1 - common)) common++;
+        const dx = (left.length - common) * (end ? -1 : 1), dy = (right.length - common) * (end ? -1 : 1);
+        if (safe(before, x[end] + dx) && safe(after, y[end] + dy)) { x[end] += dx; y[end] += dy; }
       }
       const outer = result; result = [];
       walk(...x, ...y, 1);
@@ -371,7 +417,8 @@ export function diff(before, after, options = {}) {
         if (a0 < a1) old[4].push([[a0, a1], [old[1][0], old[1][0]], false, group]);
         if (b0 < b1) item[4].push([[item[0][0], item[0][0]], [b0, b1], false, group]);
       };
-      let a = old[0][0], b = item[1][0], wording;
+      fragment(old[0][0], x[0], 0, 0, [0, 'char']); fragment(0, 0, item[1][0], y[0], [2, 'char']);
+      let a = x[0], b = y[0], wording;
       for (const edit of inner) {
         if (edit[3][3]) wording = edit[3];
         else if (a !== edit[0][0] || b !== edit[1][0]) wording = [edit[3][0], edit[3][1]];
@@ -428,6 +475,14 @@ export function diff(before, after, options = {}) {
     result = result.flatMap(item => item[4] || [item]);
   }
 
+  // Whole-word replacements separated only by spaces read and restore as one phrase.
+  if (!raw && !code) for (let i = result.length - 1; i > 0; i--) {
+    const p = result[i - 1], q = result[i], gap = before.slice(p[0][1], q[0][0]);
+    if (p[3][0] !== 1 || q[3][0] !== 1 || p[3][3] || q[3][3] || p[2] || q[2] || !/^[^\S\r\n]+$/.test(gap) ||
+      gap !== after.slice(p[1][1], q[1][0]) || within(before, p[0][0]) || within(after, p[1][0]) ||
+      within(before, q[0][1]) || within(after, q[1][1])) continue;
+    p[0][1] = q[0][1]; p[1][1] = q[1][1]; result.splice(i, 1);
+  }
   const changes = [], edits = [];
   let normalized;
   const meaning = structures?.[0]?.meaning;
@@ -453,9 +508,11 @@ export function diff(before, after, options = {}) {
     if (!raw && !group[3]) group[3] = [[...item[0]], [...item[1]]];
     if (!group[4]) {
       const context = group[3];
+      // Context completes a word only where an edge falls inside it.
       if (!raw) for (const [text, span] of [[before, context[0]], [after, context[1]]]) {
-        while (span[0] && spend() && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
-        while (span[1] < text.length && spend() && letter(text[span[1]]) && safe(text, span[1] + 1)) span[1]++;
+        const start = within(text, span[0]), end = within(text, span[1]);
+        while (start && span[0] && spend() && letter(text[span[0] - 1]) && safe(text, span[0] - 1)) span[0]--;
+        while (end && span[1] < text.length && spend() && letter(text[span[1]]) && safe(text, span[1] + 1)) span[1]++;
       }
       group[4] = []; changes.push(group);
       if (format) group[0] = 5;
@@ -463,20 +520,6 @@ export function diff(before, after, options = {}) {
     group[4].push(edits.length);
     edits.push({before: item[0], after: item[1], ...(item[2] ? {coarse: true} : {})});
   }
-  if (!raw && !structures && !code && !evidence) for (let i = 0; i < changes.length; i++) {
-    let end = i + 1;
-    for (; end < changes.length; end++) {
-      const a = changes[end - 1], b = changes[end];
-      const gap = before.slice(a[3][0][1], b[3][0][0]);
-      if (a[0] !== 1 || b[0] !== 1 || a[1] !== 'word' || b[1] !== 'word' ||
-        /\S|\r|\n/.test(gap) || gap !== after.slice(a[3][1][1], b[3][1][0])) break;
-    }
-    if (end - i < 4) continue;
-    const group = changes[i]; group[1] = 'sentence';
-    for (const next of changes.splice(i + 1, end - i - 1)) {
-      group[4].push(...next[4]); group[3][0][1] = next[3][0][1]; group[3][1][1] = next[3][1][1];
-    }
-  }
   if (structures && !raw && budget.left >= 0) {
     const oldNames = new Set(pa.filter(p => p.nameAt).map(p => p.name)), newNames = new Set(pb.filter(p => p.nameAt).map(p => p.name));
     for (const change of changes) {

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)));