rapier-markdown-kit 1.2.31 → 1.2.33

package/README.md

@@ -57,7 +57,7 @@ import {parseAssets} from 'rapier-markdown-kit/assets';   // the picture appendi
 ## Choose a Rapier workflow
 
 Rapier is a phone-first Markdown editor for notes, diagrams, drawing and watercolor painting. It runs offline
-as one HTML file on Android, Web and Windows.
+as one HTML file on Android, Web, Windows and Linux.
 
 1. **Work together live.** Connect to `https://mcp.rapier.website/door/mcp`, then call `open` to share one document with the person.
 2. **Deliver an offline editor.** Run `npx rapier-html notes.md` to put the document and editor in one HTML file ([rapier-html](https://github.com/jackskip22/rapier-plugins/tree/main/npm/rapier-html)).
@@ -164,7 +164,7 @@ family name share the host's font namespace. Print retains its existing factory
 
 | Import | What it is |
 | --- | --- |
-| `rapier-markdown-kit/markdown-it` | `md.use(rapierMarkdown)`: the reference style's markup in markdown-it, in one line. |
+| `rapier-markdown-kit/markdown-it` | `md.use(rapierMarkdown)`: the reference style's markup in markdown-it, in one line, with rung 1 of `md-layout:v1` (align, indents, list markers, picture width, lines and opacity, paragraph typography). |
 | `rapier-markdown-kit/parsed` | A frozen, serializable view of completed Markdown tokens, bound to source, revision and grammar. |
 | `rapier-markdown-kit/layout` | The `md-layout:v1` comment a picture carries: parse it, validate it, write it back. |
 | `rapier-markdown-kit/marks` | Unified typography values, span writer and parser installer; preserved color/font comments, ink and page breaks. |

package/dist/kit/ledger/carried.mjs

@@ -50,15 +50,27 @@ const OPEN = '\n\n<!-- rapier-carried/1\n', CLOSE = '\n-->\n';
 export function documentTrailer(text, options) {
   const parts = validateParts(text, options);
   if (!parts.ledger && !parts.authorship) return '';
-  const json = JSON.stringify(parts).replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
+  const json = JSON.stringify(parts).replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/-/g, '\\u002d');
   return OPEN + json + CLOSE;
 }
 export function writeDocument(text, options) {
   return text + documentTrailer(text, options);
 }
+function unfinishedTrailer(source) {
+  const at = source.lastIndexOf(OPEN);
+  if (at < 0) return false;
+  let fence = null;
+  for (const line of source.slice(0, at).split('\n')) {
+    const found = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+    if (!found) continue;
+    if (!fence) fence = found[1];
+    else if (found[1][0] === fence[0] && found[1].length >= fence.length && !line.slice(found[0].length).trim()) fence = null;
+  }
+  return !fence;
+}
 export function readDocument(source) {
   if (!source.endsWith(CLOSE)) {
-    if (source.includes(OPEN)) throw fault('unfinished document metadata');
+    if (unfinishedTrailer(source)) throw fault('unfinished document metadata');
     return {text: source, ledger: null, authorship: null};
   }
   const at = source.lastIndexOf(OPEN);

package/dist/kit/ledger/text-merge.mjs

@@ -272,13 +272,167 @@ function textDeclarations(units) {
 	return [...definitions, ...continuations, ...(text.match(/<!--[\s\S]*?(?:-->|$)/g) || [])].join('\0');
 }
 
+function* textGroups(units, a, b) {
+	const changes = [...a.map(e => ({...e, side: 0})), ...b.map(e => ({...e, side: 1}))].sort((x, y) => x.start - y.start || x.end - y.end || x.side - y.side);
+	for (let i = 0; i < changes.length;) {
+		const group = [changes[i++]], start = group[0].start; let end = group[0].end;
+		while (i < changes.length && (changes[i].start < end || group.some(e => {
+			const next = changes[i];
+			const afterBlock = (edit, insert) => insert.start === insert.end && insert.start === edit.end && edit.start < edit.end && units.slice(edit.start, edit.end).every(unit => textEnvelopeAt(unit));
+			if (afterBlock(e, next) || afterBlock(next, e)) return false;
+			if (e.start === e.end && next.start <= e.start && e.start <= next.end) return true;
+			if (next.start === next.end && e.start <= next.start && next.start <= e.end) return true;
+			return next.start >= e.end && units.slice(e.start, e.end).every(textSpace) &&
+				units.slice(e.end, next.start).every(textSpace) && units.slice(next.start, next.end).every(textSpace);
+		}))) {
+			group.push(changes[i]); end = Math.max(end, changes[i++].end);
+		}
+		const before = units.slice(start, end).join('');
+		const version = side => {
+			let value = '', at = start;
+			for (const e of group.filter(e => e.side === side)) { value += units.slice(at, e.start).join('') + e.text; at = e.end; }
+			return value + units.slice(at, end).join('');
+		};
+		yield {start, end, before, av: version(0), bv: version(1)};
+	}
+}
+
+function textMoves(groups) {
+	const blank = value => !value.trim();
+	const side = (g, which) => which === 0 ? g.av : g.bv;
+	for (const g of groups) {
+		if (g.resolved !== undefined || blank(g.before)) continue;
+		for (const gone of [0, 1]) {
+			const removed = side(g, gone), other = side(g, 1 - gone);
+			if (!blank(removed) || other === g.before) continue;
+			if (other.split(g.before).length === 2) { g.resolved = other.replace(g.before, ''); break; }
+			const homes = groups.filter(h => h !== g && h.resolved === undefined && blank(h.before) && blank(side(h, 1 - gone)) && side(h, gone).trim() === g.before.trim());
+			if (homes.length === 1) {
+				const trailing = side(homes[0], gone).match(/\s*$/)[0], edited = other.replace(/\s*$/, '');
+				g.resolved = ''; homes[0].resolved = side(homes[0], gone).match(/^\s*/)[0] + edited + trailing; break;
+			}
+		}
+	}
+	return groups;
+}
+
+const textLines = text => text.match(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g) || [];
+const textWords = text => text.match(/\s+|\S+/g) || [];
+const TEXT_ITEM = /^( {0,3})(?:[-+*]|\d{1,9}[.)])[ \t]+\S/;
+const TEXT_TAGS = /^(tags|aliases):[ \t]*\[([^\[\]\r\n]*)\][ \t]*(\r\n|\r|\n|$)/;
+function textCounts(text) {
+	const counts = new Map();
+	for (const word of text.match(/[\p{L}\p{N}_]+/gu) || []) counts.set(word, (counts.get(word) || 0) + 1);
+	return counts;
+}
+function textConserved(before, av, bv, merged) {
+	const [b, a, t, m] = [before, av, bv, merged].map(textCounts);
+	for (const word of new Set([...b.keys(), ...a.keys(), ...t.keys(), ...m.keys()])) {
+		const base = b.get(word) || 0, da = (a.get(word) || 0) - base, dt = (t.get(word) || 0) - base, got = (m.get(word) || 0) - base;
+		const both = [da + dt, da, dt];
+		if (da * dt > 0 ? got < Math.min(...both) || got > Math.max(...both) : got !== da + dt) return false;
+	}
+	return true;
+}
+function textRefine(before, av, bv, options, level = 'line') {
+	const merged = textRefineLevel(before, av, bv, options, level);
+	return merged !== null && textConserved(before, av, bv, merged) ? merged : null;
+}
+function textRefineLevel(before, av, bv, options, level) {
+	const split = level === 'line' ? textLines : textWords;
+	const units = split(before), oursUnits = split(av), theirsUnits = split(bv);
+	const reordered = textPermuted(units, oursUnits, theirsUnits);
+	if (reordered !== null) return reordered;
+	const a = textEdits(units, oursUnits), b = textEdits(units, theirsUnits);
+	if (!a || !b) return null;
+	let out = '', pos = 0;
+	for (const g of textGroups(units, a, b)) {
+		out += units.slice(pos, g.start).join('');
+		if (g.av === g.bv) out += g.av;
+		else if (g.av === g.before) out += g.bv;
+		else if (g.bv === g.before) out += g.av;
+		else {
+			const fine = level === 'line' ? textRefineGroup(g, options) : null;
+			if (fine === null) return null;
+			out += fine;
+		}
+		pos = g.end;
+	}
+	return out + units.slice(pos).join('');
+}
+function textPermuted(units, ours, theirs) {
+	const solid = list => list.filter(unit => !textSpace(unit));
+	const baseSolid = solid(units), known = new Map(baseSolid.map((unit, k) => [unit, k]));
+	if (known.size !== baseSolid.length) return null;
+	const reorders = side => { const x = solid(side); return x.length === baseSolid.length && x.every(unit => known.has(unit)) && new Set(x).size === x.length && side.join('') !== units.join(''); };
+	const [first, second] = [reorders(ours), reorders(theirs)];
+	if (first === second) return null;
+	const [moved, changed] = first ? [ours, theirs] : [theirs, ours];
+	const edits = textEdits(units, changed);
+	if (!edits) return null;
+	const replace = new Map(), after = new Map();
+	for (const e of edits) {
+		const inner = []; for (let i = e.start; i < e.end; i++) if (!textSpace(units[i])) inner.push(i);
+		if (!inner.length) {
+			if (!e.text.trim()) continue;
+			let k = -1; for (let i = e.start - 1; i >= 0; i--) if (!textSpace(units[i])) { k = known.get(units[i]); break; }
+			const gap = e.start > 0 && textSpace(units[e.start - 1]);
+			after.set(k, [...(after.get(k) || []), {text: e.text, gap}]);
+		} else if (inner.length === 1) {
+			if (!e.text.trim()) replace.set(known.get(units[inner[0]]), units.slice(e.start, e.end).some(textSpace) ? ' ' : '');
+			else if (units.slice(e.start, e.end).some(textSpace)) return null;
+			else replace.set(known.get(units[inner[0]]), e.text);
+		} else return null;
+	}
+	const out = [], place = (k, from) => {
+		const rows = after.get(k) || [];
+		return rows.filter(row => row.gap === from).map(row => row.text);
+	};
+	out.push(...place(-1, false));
+	for (let i = 0; i < moved.length; i++) {
+		const unit = moved[i];
+		if (textSpace(unit)) { out.push(unit); continue; }
+		const k = known.get(unit);
+		if (replace.get(k) === '' || replace.get(k) === ' ') {
+			if (replace.get(k) === ' ') { if (i + 1 < moved.length && textSpace(moved[i + 1])) i++; else if (out.length && textSpace(out[out.length - 1])) out.pop(); }
+		} else out.push(replace.has(k) ? replace.get(k) : unit);
+		out.push(...place(k, false));
+		if (after.get(k)?.some(row => row.gap)) { if (i + 1 < moved.length && textSpace(moved[i + 1])) out.push(moved[++i]); out.push(...place(k, true)); }
+	}
+	return out.join('');
+}
+
+function textRefineGroup({before, av, bv}, options) {
+	const [first, second] = textDeviceOptions(options), ids = first < second ? [0, 1] : [1, 0];
+	const added = (side, base) => side.startsWith(base) ? side.slice(base.length) : null;
+	const oursAdded = added(av, before), theirsAdded = added(bv, before);
+	if (oursAdded !== null && theirsAdded !== null && textLines(oursAdded + theirsAdded).every(line => TEXT_ITEM.test(line))) {
+		const tail = value => value && !/[\r\n]$/.test(value) ? value + (before.includes('\r\n') ? '\r\n' : '\n') : value;
+		const parts = [tail(oursAdded), tail(theirsAdded)];
+		const last = tail(before) === before ? '' : (before.includes('\r\n') ? '\r\n' : '\n');
+		return before + last + parts[ids[0]] + parts[ids[1]];
+	}
+	const lines = textLines(before);
+	if (lines.length === 1) {
+		const tags = TEXT_TAGS.exec(before), x = TEXT_TAGS.exec(av), y = TEXT_TAGS.exec(bv);
+		if (tags && x && y && x[1] === tags[1] && y[1] === tags[1]) {
+			const list = row => row[2].split(',').map(item => item.trim()).filter(Boolean);
+			const base = list(tags), ours = list(x), theirs = list(y);
+			const kept = base.filter(item => ours.includes(item) && theirs.includes(item));
+			const added = [ours, theirs].map(list => list.filter(item => !base.includes(item)));
+			const joined = [...new Set([...kept, ...added[ids[0]], ...added[ids[1]]])];
+			return tags[1] + ': [' + joined.join(', ') + ']' + tags[3];
+		}
+	}
+	return textRefineLevel(before, av, bv, options, 'word');
+}
 export function mergeText(base, ours, theirs, options = {}) {
 	canonicalNote(ours); canonicalNote(theirs); if (base !== null) canonicalNote(base);
 	const unchanged = value => ({text: value, clean: !value.includes(TEXT_CONFLICT), conflicts: value.includes(TEXT_CONFLICT) ? [{kind: 'existing-conflict', advisory: true}] : []});
 	if (ours === theirs) return unchanged(ours);
 	if (base === ours) return unchanged(theirs);
 	if (base === theirs) return unchanged(ours);
-	const conflicts = []; let text = '';
+	const conflicts = []; let text = '', a, b;
 	const conflict = (before, a, b, kind) => {
 		const ab = inspectTextConflicts(a), bb = inspectTextConflicts(b);
 		const au = textUnits(a), bu = textUnits(b); let first = 0, last = 0;
@@ -316,38 +470,21 @@ export function mergeText(base, ours, theirs, options = {}) {
 	if (base === null) conflict(null, ours, theirs, 'no-ancestor');
 	else if (textDeclarations(oursUnits) !== declared || textDeclarations(theirsUnits) !== declared) conflict(base, ours, theirs, 'document-bindings');
 	else {
-		const a = textEdits(units, oursUnits), b = textEdits(units, theirsUnits);
-		if (!a || !b) conflict(base, ours, theirs, 'ambiguous-alignment-or-budget');
+		const reordered = textPermuted(units, oursUnits, theirsUnits);
+		if (reordered !== null && textConserved(base, ours, theirs, reordered)) text += reordered;
+		else if (!(a = textEdits(units, oursUnits)) || !(b = textEdits(units, theirsUnits))) conflict(base, ours, theirs, 'ambiguous-alignment-or-budget');
 		else {
-			const changes = [...a.map(e => ({...e, side: 0})), ...b.map(e => ({...e, side: 1}))].sort((x, y) => x.start - y.start || x.end - y.end || x.side - y.side);
 			let pos = 0;
-			for (let i = 0; i < changes.length;) {
-				const group = [changes[i++]], start = group[0].start; let end = group[0].end;
-				while (i < changes.length && (changes[i].start < end || group.some(e => {
-					const next = changes[i];
-					const afterBlock = (edit, insert) => insert.start === insert.end && insert.start === edit.end && edit.start < edit.end && units.slice(edit.start, edit.end).every(unit => textEnvelopeAt(unit));
-					if (afterBlock(e, next) || afterBlock(next, e)) return false;
-					if (e.start === e.end && next.start <= e.start && e.start <= next.end) return true;
-					if (next.start === next.end && e.start <= next.start && next.start <= e.end) return true;
-					return next.start >= e.end && units.slice(e.start, e.end).every(textSpace) &&
-						units.slice(e.end, next.start).every(textSpace) && units.slice(next.start, next.end).every(textSpace);
-				}))) {
-					group.push(changes[i]); end = Math.max(end, changes[i++].end);
-				}
+			for (const {start, end, before, av, bv, resolved} of textMoves([...textGroups(units, a, b)])) {
 				text += units.slice(pos, start).join('');
-				const before = units.slice(start, end).join('');
-				const version = side => {
-					let value = '', at = start;
-					for (const e of group.filter(e => e.side === side)) { value += units.slice(at, e.start).join('') + e.text; at = e.end; }
-					return value + units.slice(at, end).join('');
-				};
-				const av = version(0), bv = version(1);
-				if (av === bv) text += av;
+				if (resolved !== undefined) text += resolved;
+				else if (av === bv) text += av;
 				else if (av === before) text += bv;
 				else if (bv === before) text += av;
 				else {
 					const tick = end === start + 1 ? textTick(before, av, bv) : null;
-					if (tick !== null) text += tick; else conflict(before, av, bv, 'text');
+					const fine = tick === null ? textRefine(before, av, bv, options) : null;
+					if (tick !== null) text += tick; else if (fine !== null) text += fine; else conflict(before, av, bv, 'text');
 				}
 				pos = end;
 			}

package/dist/kit/markdown-it.mjs

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-import {parseLayout, imageStyle} from './layout.mjs';
+import {parseLayout, imageStyle, textStyle} from './layout.mjs';
 import {typography, isPageBreakBlock} from './marks.mjs';
 import {installMarkdownImages} from './assets.mjs';
 import {tuneMarkdownEngine} from '../spec/md-engine.mjs';
@@ -26,11 +26,25 @@ export function rapierMarkdown(md) {
       const layout = parseLayout(marker.content);
       if (!layout) continue;
       children.pop();
-      if (layout.align) owner.attrSet('data-md-align', layout.align);
+      if (layout.align && (layout.align !== 'justify' || owner.type === 'paragraph_open')) owner.attrSet('data-md-align', layout.align);
       const visible = children.filter(token => token.type !== 'text' || token.content.trim());
-      if (visible.length === 1 && visible[0].type === 'image' && layout.width) {
-        visible[0].attrSet('style', imageStyle(layout));
-        visible[0].attrSet('data-md-image-width', String(layout.width));
+      const picture = visible.length === 1 && visible[0].type === 'image' ? visible[0]
+        : visible.length === 3 && visible[0].type === 'link_open' && visible[1].type === 'image' && visible[2].type === 'link_close' ? visible[1] : null;
+      if (picture) {
+        if (layout.width != null || layout.lines != null || layout.opacity != null) {
+          const style = imageStyle(layout);
+          if (style) picture.attrSet('style', style);
+          if (layout.width != null) picture.attrSet('data-md-image-width', String(layout.width));
+        }
+        continue;
+      }
+      for (const key of ['first', 'indent', 'before', 'after', 'lines', 'hyphens', 'caps', 'hanging']) if (layout[key]) owner.attrSet('data-md-' + key, String(layout[key]));
+      const style = [textStyle(layout), layout.lines != null ? '--md-drop-lines:' + layout.lines : ''].filter(Boolean).join(';');
+      if (style) owner.attrSet('style', style);
+      const item = state.tokens[i - 2];
+      if (layout.marker && item?.type === 'list_item_open') {
+        item.attrSet('data-md-marker', String(layout.marker));
+        item.attrSet('style', (item.attrGet('style') ? item.attrGet('style') + ';' : '') + textStyle({marker: layout.marker}));
       }
     }
   });

package/dist/kit/pdf-glyphs.mjs

@@ -337,8 +337,8 @@ export async function collectPdfGlyphs(main, {width, check, faces = [], prepareF
         probe.style.setProperty('visibility', 'hidden', 'important'); probe.textContent = String(value); item.prepend(probe);
         const parts = await measure(probe.firstChild, style, font); probe.remove();
         if (!parts.length || parts.some(part => !part.font)) continue;
-        parts.at(-1).text += ' ';
-        markers.set(item, {text: String(value) + ' ', parts, ...Object.fromEntries(['x','y','width','height','page'].map(key => [key, parts[0][key]]))});
+        parts.at(-1).text += '. ';
+        markers.set(item, {text: String(value) + '. ', parts, ...Object.fromEntries(['x','y','width','height','page'].map(key => [key, parts[0][key]]))});
         const id = 'm' + markers.size, old = item.getAttribute('data-rapier-pdf-marker'); item.setAttribute('data-rapier-pdf-marker', id);
         restoreSteps.push(() => old == null ? item.removeAttribute('data-rapier-pdf-marker') : item.setAttribute('data-rapier-pdf-marker', old));
         markerRules.push('[data-rapier-pdf-marker="' + id + '"]::before{-webkit-text-fill-color:transparent!important}');

package/dist/kit/pdf-vectors.mjs

@@ -92,7 +92,7 @@ function geometry(node) {
   unsupported();
 }
 
-export async function collectPdfVectors(main, {width, height, count, capture, signal, current, check, maxBytes, sanitizeSvg, collectText}) {
+export async function collectPdfVectors(main, {width, height, count, capture, signal, current, check, maxBytes, sanitizeSvg, collectText, pictures = false, underlay = false}) {
   const document = main.ownerDocument, window = document.defaultView, origin = main.getBoundingClientRect();
   const pages = Array.from({length: count}, () => []), hidden = [], temporary = [], textRoots = [], textRestores = [];
   const colorCanvas = document.createElement('canvas'); colorCanvas.width = colorCanvas.height = 1;
@@ -117,20 +117,33 @@ export async function collectPdfVectors(main, {width, height, count, capture, si
   try {
     for (const original of roots) {
       check();
-      let root = original, mount = null;
+      let root = original, mount = null, turned = false, groupOpacity = 1, asImage = false, under = false;
       const originalBox = original.getBoundingClientRect();
       if (!(originalBox.width > 0 && originalBox.height > 0)) continue;
       if (original.localName === 'img') {
         if (typeof sanitizeSvg !== 'function') continue;
         const address = original.getAttribute('src') || '', match = /^data:image\/svg\+xml(?:;charset=[^;,]+)?(;base64)?,([\s\S]*)$/i.exec(address);
-        if (!match) continue;
+        if (!match && !(pictures && /^data:image\//i.test(address))) continue;
+        asImage = !match;
+      }
+      if (original.localName === 'img' && !asImage) {
+        const address = original.getAttribute('src') || '', match = /^data:image\/svg\+xml(?:;charset=[^;,]+)?(;base64)?,([\s\S]*)$/i.exec(address);
         let text;
         try {text = match[1] ? new TextDecoder('utf-8', {fatal: true}).decode(Uint8Array.from(atob(match[2]), ch => ch.charCodeAt(0))) : decodeURIComponent(match[2]);} catch (_) {continue;}
         const parsed = new window.DOMParser().parseFromString(sanitizeSvg(text), 'image/svg+xml');
         if (parsed.querySelector('parsererror') || parsed.documentElement.namespaceURI !== SVG) continue;
+        const shown = window.getComputedStyle(original);
+        under = Number(shown.zIndex) < 0;
+        if (under && !underlay) continue;
+        turned = shown.transform !== 'none'; groupOpacity = Number(shown.opacity);
+        const unturnedWidth = turned ? Number.parseFloat(shown.width) : originalBox.width, unturnedHeight = turned ? Number.parseFloat(shown.height) : originalBox.height;
+        if (!(unturnedWidth > 0 && unturnedHeight > 0)) continue;
+        const [originX, originY] = shown.transformOrigin.split(' ').map(Number.parseFloat);
+        if (turned && !(Math.abs(originX - unturnedWidth / 2) < .5 && Math.abs(originY - unturnedHeight / 2) < .5)) continue;
+        const left = originalBox.left + originalBox.width / 2 - unturnedWidth / 2, top = originalBox.top + originalBox.height / 2 - unturnedHeight / 2;
         root = document.importNode(parsed.documentElement, true);
-        root.style.setProperty('width', originalBox.width + 'px', 'important'); root.style.setProperty('height', originalBox.height + 'px', 'important');
-        mount = document.createElement('div'); mount.style.cssText = `position:fixed;left:${originalBox.left}px;top:${originalBox.top}px;width:${originalBox.width}px;height:${originalBox.height}px;pointer-events:none`;
+        root.style.setProperty('width', unturnedWidth + 'px', 'important'); root.style.setProperty('height', unturnedHeight + 'px', 'important');
+        mount = document.createElement('div'); mount.style.cssText = `position:fixed;left:${left}px;top:${top}px;width:${unturnedWidth}px;height:${unturnedHeight}px;pointer-events:none` + (turned ? `;transform:${shown.transform};transform-origin:50% 50%` : '');
         mount.attachShadow({mode: 'open'}).append(root); document.body.append(mount); temporary.push(mount); await document.fonts.ready;
         const glyphs = await collectText?.(root); if (glyphs) textRestores.push(glyphs.restore);
         textRoots.push({root, original, text: glyphs});
@@ -181,7 +194,7 @@ export async function collectPdfVectors(main, {width, height, count, capture, si
         } catch (_) { sequence.push({raster: node}); return; }
         if (!path) return;
         const matrix = node.getScreenCTM(); if (!matrix || ![matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f].every(Number.isFinite)) {sequence.push({raster: node}); return;}
-        const opacity = Number(style.opacity), fillAlpha = fill ? fill[3] * Number(style.fillOpacity) * opacity : 1, strokeAlpha = stroke ? stroke[3] * Number(style.strokeOpacity) * opacity : 1;
+        const opacity = Number(style.opacity) * groupOpacity, fillAlpha = fill ? fill[3] * Number(style.fillOpacity) * opacity : 1, strokeAlpha = stroke ? stroke[3] * Number(style.strokeOpacity) * opacity : 1;
         let commands = nums([matrix.a, matrix.b, matrix.c, matrix.d, matrix.e - origin.left, matrix.f - origin.top]) + ' cm\n';
         if (fill) commands += nums(fill.slice(0, 3)) + ' rg\n';
         if (stroke) {
@@ -193,12 +206,19 @@ export async function collectPdfVectors(main, {width, height, count, capture, si
         commands += path + (fill && stroke ? style.fillRule === 'evenodd' ? 'B*' : 'B' : fill ? style.fillRule === 'evenodd' ? 'f*' : 'f' : stroke ? 'S' : 'n') + '\n';
         sequence.push({commands, fillAlpha, strokeAlpha}); geometries++;
       };
-      await walk(root);
-      if (!geometries && !textRoots.find(entry => entry.root === root)?.text?.nodes.size) continue;
+      if (asImage) sequence.push({raster: root}); else await walk(root);
+      if ((turned || groupOpacity !== 1) && (sequence.some(piece => piece.raster) || textRoots.find(entry => entry.root === root)?.text?.nodes.size)) {
+        const entry = textRoots.find(row => row.root === root);
+        if (entry?.text) textRestores.pop()?.();
+        if (entry) textRoots.splice(textRoots.indexOf(entry), 1);
+        mount?.remove(); temporary.splice(temporary.indexOf(mount), 1);
+        continue;
+      }
+      if (!geometries && !asImage && !textRoots.find(entry => entry.root === root)?.text?.nodes.size) continue;
       const painted = [];
       for (const piece of sequence) {const held = piece.raster ? await raster(piece.raster) : piece; if (held) painted.push(held);}
       const first = Math.max(0, Math.floor((box.left - origin.left + .01) / width)), last = Math.min(count - 1, Math.floor((box.right - origin.left - .01) / width));
-      for (let page = first; page <= last; page++) pages[page].push({sequence: painted, x: -page * width, clip: {x: box.left - origin.left, y: box.top - origin.top, width: box.width, height: box.height}});
+      for (let page = first; page <= last; page++) pages[page].push({sequence: painted, x: -page * width, clip: {x: box.left - origin.left, y: box.top - origin.top, width: box.width, height: box.height}, ...(under && {under: true})});
       hidden.push({node: original, style: original.getAttribute('style')}); original.style.setProperty('visibility', 'hidden', 'important');
     }
     return {pages, textRoots, restore};

package/dist/kit/render-markdown.mjs

@@ -1243,7 +1243,7 @@ function* _rapierProjectPortableNodesSteps(semanticRoot, options) {
 			? (element.style.backgroundColor || RAPIER_PORTABLE_HIGHLIGHT_HEX[String(element.getAttribute('data-rapier-highlight') || '').toLowerCase()] || RAPIER_PORTABLE_HIGHLIGHT_HEX.yellow)
 			: null;
 
-		const isTableCaption = element.tagName === 'P' && element.classList.contains('rapier-table-caption');
+		const isTableCaption = element.tagName === 'P' && (element.classList.contains('rapier-table-caption') || element.classList.contains('rapier-figure-caption'));
 
 		const isPageBreak = element.hasAttribute('data-md-break');
 		for (const attribute of Array.from(element.attributes)) { yield;
@@ -1271,6 +1271,13 @@ function* _rapierProjectPortableNodesSteps(semanticRoot, options) {
 			if (paragraphLayout.before != null) element.style.marginTop = paragraphLayout.before + 'pt';
 			if (paragraphLayout.after != null) element.style.marginBottom = paragraphLayout.after + 'pt';
 		}
+		if (!keepLayoutData && paragraphLayout && /^(?:P|H[1-6])$/.test(element.tagName) && !element.closest('table,pre') && (paragraphLayout.first != null || paragraphLayout.indent != null)) {
+			const indents = {...(paragraphLayout.first != null && {first: paragraphLayout.first}), ...(paragraphLayout.indent != null && {indent: paragraphLayout.indent})};
+			for (const declaration of globalThis.RapierMarkdownLayout.textStyle(indents, {portable: true}).split(';').filter(Boolean)) {
+				const at = declaration.indexOf(':');
+				element.style.setProperty(declaration.slice(0, at), declaration.slice(at + 1));
+			}
+		}
 		if (!keepLayoutData && element.tagName === 'P' && !element.closest('table,pre')) {
 			if (paragraphLayout?.hyphens === 'auto') { element.style.hyphens = 'auto'; element.style.textWrap = 'pretty'; }
 			if (paragraphLayout?.hanging === 'on') element.style.setProperty('hanging-punctuation', 'first allow-end');