rapier-markdown-kit 1.1.99 → 1.1.101

package/dist/kit/ledger/transport.mjs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 // Paired source placement, shared by live editing and canonical-history proof.
 import {_rapierTransformSplices, _rapierValidAuthored, _rapierHistoryEffects} from './journal-records.mjs';
+import {projectInverseSource} from './inverse-source.mjs';
 import {sha256} from './hash.mjs';
 import {canonicalJSON} from './data.mjs';
 
@@ -169,7 +170,38 @@ function authoredReplay(base, records, append = null) {
   const origins = new Map(), byId = new Map(), originalOrder = [], cache = new Map(), frontier = new Set();
   const effects = _rapierHistoryEffects(append ? [...records, append] : records);
   if (!effects.ok) throw new RangeError('canonical_origin_invalid');
-  let source = base;
+  const referenced = new Set();
+  let sharedInverses = false;
+  for (const refs of effects.references.values()) for (const id of refs) {
+    if (referenced.has(id)) sharedInverses = true;
+    referenced.add(id);
+  }
+  const projectInverse = (text, placed, id) => {
+    const refs = effects.references.get(id), before = _rapierHistoryEffects(placed);
+    const after = _rapierHistoryEffects([...placed, {transaction: {id, sourceTransactionIds: refs}}]);
+    if (!before.ok || !after.ok) throw new RangeError('canonical_origin_invalid');
+    const result = projectInverseSource({source: text, initialSource: base,
+      rows: placed.map(record => ({record, splices: record.splices})), effects: before}, new Set(refs), after);
+    if (!result.ok) throw new RangeError('canonical_origin_invalid');
+    return result;
+  };
+  // Only immutable text digests are reused, within this one replay. Every
+  // authored-source comparison and physical placement proof still runs.
+  const textHashes = new Map();
+  const hashText = text => {
+    if (typeof text !== 'string') return sha256(text);
+    let digest = textHashes.get(text);
+    if (digest === undefined) { digest = sha256(text); textHashes.set(text, digest); }
+    return digest;
+  };
+  const same = (a, b) => canonicalJSON(a) === canonicalJSON(b);
+  // Only owner-created ordered views of already admitted string IDs use this.
+  const sameIds = (a, b) => {
+    if (a.length !== b.length) return false;
+    for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+    return true;
+  };
+  let source = base, linearPrefix = 0;
   for (const record of append ? [...records, append] : records) {
     const id = record.transaction.id;
     if (byId.has(id)) throw new RangeError('canonical_origin_invalid');
@@ -189,6 +221,11 @@ function authoredReplay(base, records, append = null) {
     })()))) throw new RangeError('canonical_origin_invalid');
     const refs = effects.references.get(id) || [];
     if (refs.some(id => !seen.has(id))) throw new RangeError('canonical_origin_invalid');
+    // An explicit origin can prove the same linear placement as an implicit one.
+    // Preserve the origin, but do not reconstruct every growing prefix to prove it again.
+    if (linearPrefix === originalOrder.length && same(origin.basis, [...frontier].sort()) &&
+        same(origin.splices, record.splices) && (!Object.hasOwn(record, 'authored') || origin.source === sha256(source)))
+      linearPrefix++;
     for (const prior of seen) frontier.delete(prior); frontier.add(id);
     origins.set(id, origin); byId.set(id, record); originalOrder.push(id);
     if (record !== append) {
@@ -196,7 +233,6 @@ function authoredReplay(base, records, append = null) {
       if (source === null) throw new RangeError('canonical_origin_invalid');
     }
   }
-  const same = (a, b) => canonicalJSON(a) === canonicalJSON(b);
   const ordered = (ids, selected = null) => {
     const order = [], known = new Set(ids), waiting = new Map(), dependents = new Map(), ready = [];
     const rank = id => selected ? Number(selected.has(id)) : Number(origins.get(id).splices.some(row => row.removed.length));
@@ -229,17 +265,60 @@ function authoredReplay(base, records, append = null) {
       closure.add(prior); pending.push(...origins.get(prior).basis); }
     return closure;
   };
-  const canonicalOrder = ordered(originalOrder), firstExplicit = (append ? [...records, append] : records).findIndex(record => Object.hasOwn(record, 'authored'));
-  const implicitPrefix = firstExplicit < 0 ? records.length : firstExplicit;
-  const materialize = order => {
-    const key = canonicalJSON(order);
+  const canonicalOrder = ordered(originalOrder);
+  // Only the three immediate fresh-spread call sites use this entry. Nothing
+  // retains allocation trust after an array has crossed an observable method.
+  const literalKey = order => {
+    // An input iterator can supply arbitrary values. Preserve the whole-array
+    // depth/refusal path before any per-string encoding in that case.
+    for (let index = 0; index < order.length; index++)
+      if (typeof order[index] !== 'string') return canonicalJSON(order);
+    // Keep each canonical primitive encoder call and its serializer behavior.
+    return '[' + Array.from({length: order.length}, (_, index) => canonicalJSON(order[index])).join(',') + ']';
+  };
+  const materialize = (order, rawSubmitted = false) => materializeKey(order, canonicalJSON(order), rawSubmitted);
+  const materializeLiteral = order => materializeKey(order, literalKey(order), false);
+  const materializeKey = (order, key, rawSubmitted) => {
     if (cache.has(key)) return cache.get(key);
-    const placed = [], ids = new Set(), sourceIndices = new Map(); let text = base;
+    let prefixEnds = null;
+    const prefixKey = length => {
+      // The original submitted array keeps its existing slice/species/data gate.
+      // Only this module's own order allocations use the validated key string.
+      if (rawSubmitted) return canonicalJSON(order.slice(0, length));
+      if (!prefixEnds) {
+        prefixEnds = [1];
+        let quoted = false, depth = 0;
+        // Scan canonical JSON only: an escaped code unit cannot end a string,
+        // and commas inside strings or nested values cannot split this array.
+        for (let at = 1; at < key.length - 1; at++) {
+          const code = key.charCodeAt(at);
+          if (quoted) {
+            if (code === 92) at++;
+            else if (code === 34) quoted = false;
+          } else if (code === 34) quoted = true;
+          else if (code === 91 || code === 123) depth++;
+          else if (code === 93 || code === 125) depth--;
+          else if (code === 44 && depth === 0) prefixEnds.push(at);
+        }
+        if (key.length > 2) prefixEnds.push(key.length - 1);
+      }
+      return length === prefixEnds.length - 1 ? key : key.slice(0, prefixEnds[length]) + ']';
+    };
+    let placed = [], ids = new Set(), sourceIndices = new Map(), text = base;
     if (!order.length) { const empty = {text, records: [], sourceIndices}; cache.set(key, empty); return empty; }
-    // An implicit linear prefix already is its authored view. Replay it once;
+    // A proved linear prefix already is its authored view. Replay it once;
     // reconstructing every growing prefix adds no evidence.
     let prefix = 0;
-    while (prefix < order.length && prefix < implicitPrefix && order[prefix] === originalOrder[prefix]) {
+    // Resume only an exact ordered prefix already proved in this replay. Copy its
+    // mutable containers before extending it; transported rows retain their placement.
+    for (let length = order.length - 1; length > 0; length--) {
+      const prior = cache.get(prefixKey(length));
+      if (!prior) continue;
+      placed = prior.records.slice(); ids = new Set(order.slice(0, length));
+      sourceIndices = new Map(prior.sourceIndices); text = prior.text; prefix = length;
+      break;
+    }
+    while (prefix < order.length && prefix < linearPrefix && order[prefix] === originalOrder[prefix]) {
       const record = byId.get(order[prefix]); text = _rapierTransformSplices(text, record.splices);
       if (text === null) throw new RangeError('canonical_origin_invalid');
       placed.push(record); ids.add(order[prefix++]);
@@ -249,28 +328,53 @@ function authoredReplay(base, records, append = null) {
       const original = byId.get(id), origin = origins.get(id);
       if (!original || ids.has(id) || origin.basis.some(prior => !ids.has(prior)))
         throw new RangeError('canonical_origin_invalid');
-      const closure = closureOf(origin.basis), basisOrder = canonicalOrder.filter(prior => closure.has(prior)), basis = materialize(basisOrder);
-      if (sha256(basis.text) !== origin.source) throw new RangeError('canonical_origin_invalid');
+      const closure = closureOf(origin.basis);
+      if (closure.size === ids.size && [...closure].every(prior => ids.has(prior))) {
+        // The current view already is the complete authored context. There are no
+        // independent rows to cross, even when earlier acts were concurrent.
+        if (hashText(text) !== origin.source) throw new RangeError('canonical_origin_invalid');
+        const next = _rapierTransformSplices(text, origin.splices);
+        if (next === null) throw new RangeError('canonical_origin_invalid');
+        placed.push({...original, splices: origin.splices}); text = next; ids.add(id);
+        if (original.derivedCommentIndex != null) sourceIndices.set(id, origin.splices.map((_, index) => index));
+        cache.set(prefixKey(placed.length), {text, records: placed.slice(), sourceIndices: new Map(sourceIndices)});
+        continue;
+      }
+      const basisOrder = canonicalOrder.filter(prior => closure.has(prior)), basis = materialize(basisOrder);
+      if (hashText(basis.text) !== origin.source) throw new RangeError('canonical_origin_invalid');
       // Reconstruct causal context before crossing it. Physical gaps may already
       // have collapsed under a deletion; they cannot choose concurrent ordering.
-      const contextOrder = canonicalOrder.filter(prior => ids.has(prior)), context = same(contextOrder, [...ids]) ? {text, records: placed} : materialize(contextOrder);
+      const contextOrder = canonicalOrder.filter(prior => ids.has(prior)), context = sameIds(contextOrder, [...ids]) ? {text, records: placed} : materialize(contextOrder);
       if (context.text !== text) throw new RangeError('canonical_origin_invalid');
       const alignedOrder = [...basisOrder, ...contextOrder.filter(prior => !closure.has(prior))];
-      const aligned = same(alignedOrder, [...ids]) ? {text, records: placed} : materialize(alignedOrder);
+      const aligned = sameIds(alignedOrder, [...ids]) ? {text, records: placed} : materializeLiteral(alignedOrder);
       if (aligned.text !== text) throw new RangeError('canonical_origin_invalid');
       const crossed = aligned.records.slice(basisOrder.length);
-      const moved = transposeRecord(basis.text, origin.splices, id, crossed);
+      let moved;
+      if (sharedInverses && effects.references.get(id)?.length) {
+        // Each inverse retains its own targets. First prove the exact intention
+        // in its causal source, then place that choice in the accepted effect
+        // graph. Another inverse may already suppress the same original bytes.
+        const authored = projectInverse(basis.text, basis.records, id);
+        if (!same(origin.splices, authored.splices) ||
+            _rapierTransformSplices(basis.text, origin.splices) !== authored.after)
+          throw new RangeError('canonical_origin_invalid');
+        const accepted = projectInverse(text, aligned.records, id);
+        moved = {text: accepted.after, splices: accepted.splices};
+      } else moved = transposeRecord(basis.text, origin.splices, id, crossed);
       if (_rapierTransformSplices(text, moved.splices) !== moved.text) throw new RangeError('canonical_origin_invalid');
       placed.push({...original, splices: moved.splices}); text = moved.text; ids.add(id);
       if (original.derivedCommentIndex != null) sourceIndices.set(id, moved.sourceIndices);
-      cache.set(canonicalJSON(order.slice(0, placed.length)), {text, records: placed.slice(), sourceIndices: new Map(sourceIndices)});
+      cache.set(prefixKey(placed.length), {text, records: placed.slice(), sourceIndices: new Map(sourceIndices)});
     }
     const value = {text, records: placed, sourceIndices}; cache.set(key, value); return value;
   };
   const physicalOrder = append ? originalOrder.slice(0, -1) : originalOrder, physical = materialize(physicalOrder);
   if (physical.text !== source || physical.records.some((row, index) => !same(row.splices, records[index].splices)))
     throw new RangeError('canonical_origin_invalid');
-  return {source, origins, originalOrder, materialize, ordered};
+  // Raw submission is selected here by a private call site, never an input flag.
+  return {source, origins, originalOrder, materialize, materializeLiteral,
+    materializeSubmitted: order => materialize(order, true), ordered};
 }
 
 export function authoredHistory(base, records, selected = null) {
@@ -306,13 +410,13 @@ export function authoredSourceReader(base, records) {
 export function transposeAuthored(base, records, incoming, submitted) {
   if (!incoming.authored || !Array.isArray(submitted)) throw new RangeError('canonical_origin_invalid');
   const replay = authoredReplay(base, records, incoming), id = incoming.transaction.id;
-  const authored = replay.materialize([...submitted, id]);
+  const authored = replay.materializeLiteral([...submitted, id]);
   if (canonicalJSON(authored.records.at(-1).splices) !== canonicalJSON(incoming.splices))
     throw new RangeError('canonical_origin_invalid');
   const accepted = replay.materialize(replay.originalOrder), known = new Set([...submitted, id]);
-  const reciprocal = replay.materialize([...submitted, id, ...replay.ordered(replay.originalOrder).filter(prior => !known.has(prior))]);
+  const reciprocal = replay.materializeLiteral([...submitted, id, ...replay.ordered(replay.originalOrder).filter(prior => !known.has(prior))]);
   if (reciprocal.text !== accepted.text) throw new RangeError('canonical_origin_invalid');
   return {text: accepted.text, splices: accepted.records.at(-1).splices,
-    submittedBefore: replay.materialize(submitted).text, submitted: authored.text,
+    submittedBefore: replay.materializeSubmitted(submitted).text, submitted: authored.text,
     against: reciprocal.records.slice(submitted.length + 1)};
 }

package/dist/kit/pdf-glyphs.mjs

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+// The licensed static faces retain the shipped variable font's exact glyphs and metrics.
+// Browser ranges own placement; unsupported shaping stays in the original page paint.
+
+const fontCache = new Map();
+const familyName = value => value.trim().replace(/^['"]|['"]$/g, '');
+
+function readFont(asset) {
+  if (fontCache.has(asset)) return fontCache.get(asset);
+  const bytes = Uint8Array.from(atob(asset.data), character => character.charCodeAt(0));
+  const view = new DataView(bytes.buffer), u16 = at => view.getUint16(at), i16 = at => view.getInt16(at), u32 = at => view.getUint32(at);
+  const tag = at => String.fromCharCode(...bytes.subarray(at, at + 4)), tables = new Map();
+  for (let at = 12, end = 12 + u16(4) * 16; at < end; at += 16) tables.set(tag(at), {at: u32(at + 8), length: u32(at + 12)});
+  const head = tables.get('head').at, hhea = tables.get('hhea').at, hmtx = tables.get('hmtx').at, cmap = tables.get('cmap').at;
+  const units = u16(head + 18), metricCount = u16(hhea + 34), glyphCount = u16(tables.get('maxp').at + 4);
+  let mapping = null;
+  for (let i = 0; i < u16(cmap + 2); i++) {
+    const at = cmap + 4 + i * 8, platform = u16(at), encoding = u16(at + 2), table = cmap + u32(at + 4), format = u16(table);
+    if ((platform === 0 || (platform === 3 && [1, 10].includes(encoding))) && [4, 12].includes(format))
+      if (!mapping || format > mapping.format) mapping = {at: table, format};
+  }
+  if (!mapping) throw new Error('The embedded PDF font has no Unicode character map.');
+  const glyph = code => {
+    const at = mapping.at;
+    if (mapping.format === 12) {
+      let low = 0, high = u32(at + 12) - 1;
+      while (low <= high) {const middle = (low + high) >> 1, row = at + 16 + middle * 12;
+        if (code < u32(row)) high = middle - 1; else if (code > u32(row + 4)) low = middle + 1; else return u32(row + 8) + code - u32(row);}
+      return 0;
+    }
+    if (code > 0xffff) return 0;
+    const count = u16(at + 6) / 2, ends = at + 14, starts = ends + count * 2 + 2, deltas = starts + count * 2, offsets = deltas + count * 2;
+    let low = 0, high = count - 1;
+    while (low < high) {const middle = (low + high) >> 1; if (u16(ends + middle * 2) < code) low = middle + 1; else high = middle;}
+    if (code < u16(starts + low * 2) || code > u16(ends + low * 2)) return 0;
+    const offset = u16(offsets + low * 2), delta = i16(deltas + low * 2);
+    if (!offset) return (code + delta) & 0xffff;
+    const id = u16(offsets + low * 2 + offset + (code - u16(starts + low * 2)) * 2);
+    return id ? (id + delta) & 0xffff : 0;
+  };
+  const coverage = at => {
+    const rows = [];
+    if (u16(at) === 1) for (let i = 0; i < u16(at + 2); i++) rows.push(u16(at + 4 + i * 2));
+    else if (u16(at) === 2) for (let i = 0; i < u16(at + 2); i++) {const row = at + 4 + i * 6; for (let id = u16(row); id <= u16(row + 2); id++) rows[u16(row + 4) + id - u16(row)] = id;}
+    else throw new Error('Unsupported embedded font coverage.');
+    return rows;
+  };
+  const ligatures = [], gsub = tables.get('GSUB')?.at;
+  if (gsub) {
+    const features = gsub + u16(gsub + 6), lookups = gsub + u16(gsub + 8);
+    for (let i = 0; i < u16(features); i++) {
+      const record = features + 2 + i * 6; if (tag(record) !== 'liga') continue;
+      const feature = features + u16(record + 4);
+      for (let j = 0; j < u16(feature + 2); j++) {
+        const lookup = lookups + u16(lookups + 2 + u16(feature + 4 + j * 2) * 2), rows = new Map();
+        if (u16(lookup) !== 4 || (u16(lookup + 2) & ~8)) throw new Error('Unsupported embedded font ligature lookup.');
+        for (let k = 0; k < u16(lookup + 4); k++) {
+          const sub = lookup + u16(lookup + 6 + k * 2); if (u16(sub) !== 1) throw new Error('Unsupported embedded font ligature table.');
+          const covered = coverage(sub + u16(sub + 2));
+          for (let n = 0; n < u16(sub + 4); n++) {
+            const set = sub + u16(sub + 6 + n * 2), values = [];
+            for (let l = 0; l < u16(set); l++) {const item = set + u16(set + 2 + l * 2); values.push({glyph: u16(item), components: Array.from({length: u16(item + 2) - 1}, (_, m) => u16(item + 4 + m * 2))});}
+            rows.set(covered[n], values);
+          }
+        }
+        ligatures.push(rows);
+      }
+    }
+  }
+  const os2 = tables.get('OS/2');
+  const font = {asset, bytes, units, glyph, ligatures, glyphCount, advance: id => u16(hmtx + Math.min(id, metricCount - 1) * 4),
+    bbox: [36, 38, 40, 42].map(offset => i16(head + offset)), ascent: i16(hhea + 4), descent: i16(hhea + 6),
+    capHeight: os2 && os2.length >= 90 && u16(os2.at) >= 2 ? i16(os2.at + 88) : i16(hhea + 4)};
+  fontCache.set(asset, font); return font;
+}
+
+function shape(value, font, preserve, ligatures) {
+  const result = [];
+  for (let at = 0; at < value.length;) {
+    const code = value.codePointAt(at), character = String.fromCodePoint(code), start = at;
+    if (/[\p{Mark}\p{Format}]/u.test(character) || (/[\p{Letter}]/u.test(character) && !/\p{Script=Latin}/u.test(character)) || code === 0xfb01 || code === 0xfb02) return null;
+    at += character.length;
+    if (!preserve && /[ \t\r\n\f]/.test(character)) {while (at < value.length && /[ \t\r\n\f]/.test(value[at])) at++;}
+    const text = preserve ? character.replace(/[\r\n]/g, '') : /[ \t\r\n\f]/.test(character) ? ' ' : character;
+    const glyph = font.glyph(/[\t\r\n\f]/.test(character) ? 32 : code);
+    if (!glyph || glyph >= font.glyphCount) return null;
+    result.push({start, end: at, text, glyph});
+  }
+  if (ligatures) for (const lookup of font.ligatures) for (let i = 0; i < result.length; i++) {
+    const found = lookup.get(result[i].glyph)?.find(row => row.components.every((id, offset) => result[i + offset + 1]?.glyph === id));
+    if (found) {const held = result.splice(i, found.components.length + 1); result.splice(i, 0, {start: held[0].start, end: held.at(-1).end, text: held.map(row => row.text).join(''), glyph: found.glyph});}
+  }
+  return result;
+}
+
+export async function collectPdfGlyphs(main, {width, check, faces = []}) {
+  const document = main.ownerDocument, window = document.defaultView, origin = main.getBoundingClientRect();
+  const nodes = new Map(), hidden = [], canvas = document.createElement('canvas'); canvas.width = canvas.height = 1;
+  const context = canvas.getContext('2d', {willReadFrequently: true});
+  const restore = () => {for (const row of hidden) {if (row.value) row.node.style.setProperty('-webkit-text-fill-color', row.value, row.priority); else row.node.style.removeProperty('-webkit-text-fill-color');} canvas.width = canvas.height = 0;};
+  if (!context) return {nodes, restore};
+  const colorCache = new Map(), styles = new Map(), styleOf = node => {if (!styles.has(node)) styles.set(node, window.getComputedStyle(node)); return styles.get(node);};
+  const color = value => {if (!colorCache.has(value)) {context.clearRect(0, 0, 1, 1); context.fillStyle = value; context.fillRect(0, 0, 1, 1); colorCache.set(value, Array.from(context.getImageData(0, 0, 1, 1).data, item => item / 255));} return colorCache.get(value);};
+  const safe = node => {
+    for (let parent = node; parent; parent = parent.parentElement) {
+      const style = styleOf(parent);
+      if (style.visibility !== 'visible' || style.display === 'none' || style.transform !== 'none' || style.filter !== 'none' || style.mixBlendMode !== 'normal'
+        || ['absolute', 'fixed', 'sticky'].includes(style.position) || style.zIndex !== 'auto'
+        || Number(style.opacity) !== 1 || style.clip !== 'auto' || style.clipPath !== 'none' || style.maskImage !== 'none'
+        || (parent !== main && (style.overflowX !== 'visible' || style.overflowY !== 'visible'))) return false;
+      if (parent === main) break;
+    }
+    return true;
+  };
+  try {
+    let visited = 0;
+    for (const element of main.querySelectorAll('*')) {
+      if (++visited % 128 === 0) {await new Promise(resolve => setTimeout(resolve, 0)); check();}
+      // Leaving the existing element in place preserves selectors, counters, line breaking and inline marks.
+      // Keep preformatted blocks, their inline struts and syntax paint together.
+      if (element.namespaceURI !== 'http://www.w3.org/1999/xhtml' || element.children.length || element.closest('svg,pre,.rapier-will-carrier') || element.localName === 'li') continue;
+      const textNodes = Array.from(element.childNodes).filter(node => node.nodeType === 3);
+      if (textNodes.length !== 1 || !textNodes[0].data.trim() || !safe(element)) continue;
+      const language = (element.closest('[lang]')?.getAttribute('lang') || document.documentElement.lang || '').toLowerCase();
+      if (language && !/^en(?:-|$)/.test(language)) continue;
+      const style = styleOf(element), family = familyName(style.fontFamily.split(',')[0]), weight = Number(style.fontWeight), size = Number.parseFloat(style.fontSize);
+      if (!['Geist', 'Geist Mono'].includes(family) || style.fontStyle !== 'normal' || style.direction !== 'ltr' || style.writingMode !== 'horizontal-tb'
+        || style.textTransform !== 'none' || style.textShadow !== 'none' || style.hyphens === 'auto' || Number.parseFloat(style.webkitTextStrokeWidth) > 0
+        || ['fontFeatureSettings', 'fontVariationSettings', 'fontVariantAlternates', 'fontVariantCaps', 'fontVariantNumeric', 'fontVariantEastAsian', 'fontVariantPosition'].some(name => style[name] && style[name] !== 'normal')
+        || (style.fontSizeAdjust && style.fontSizeAdjust !== 'none') || !['normal', '100%'].includes(style.fontStretch) || style.textRendering === 'optimizeSpeed'
+        || !['normal', 'none', 'no-common-ligatures'].includes(style.fontVariantLigatures) || !(size > 0)) continue;
+      const generated = ['::before', '::after'].some(pseudo => !['none', 'normal', '""', "''"].includes(window.getComputedStyle(element, pseudo).content));
+      const altered = ['::first-letter', '::first-line'].some(pseudo => {const held = window.getComputedStyle(element, pseudo); return ['fontFamily', 'fontWeight', 'fontSize', 'fontStyle', 'fontVariantCaps', 'color'].some(name => held[name] !== style[name]);});
+      if (generated || altered || !Array.from(document.fonts).some(face => familyName(face.family) === family && face.status === 'loaded')) continue;
+      const asset = faces.find(face => face.family === family && face.weight === weight);
+      if (!asset) continue;
+      const font = readFont(asset), preserve = /pre|break-spaces/.test(style.whiteSpace), node = textNodes[0];
+      const shaped = shape(node.data, font, preserve, style.fontVariantLigatures === 'normal' && !(Number.parseFloat(style.letterSpacing) || 0));
+      if (!shaped) continue;
+      context.font = [style.fontStyle, style.fontWeight, style.fontSize, style.fontFamily].join(' ');
+      const metrics = context.measureText('Hg'), ascent = metrics.fontBoundingBoxAscent;
+      if (!Number.isFinite(ascent)) continue;
+      const rgba = color(style.webkitTextFillColor || style.color), range = document.createRange();
+      let valid = true;
+      for (const item of shaped) {
+        range.setStart(node, item.start); range.setEnd(node, item.end);
+        const rects = Array.from(range.getClientRects()).filter(rect => rect.height > 0), first = rects[0];
+        if (!first || rects.some(rect => Math.abs(rect.top - first.top) > .25)) {valid = false; break;}
+        const page = Math.max(0, Math.floor((first.left - origin.left + .01) / width));
+        Object.assign(item, {font, size, rgba, x: first.left - origin.left - page * width, baseline: first.top - origin.top + ascent});
+      }
+      if (!valid) continue;
+      nodes.set(node, shaped);
+      hidden.push({node: element, value: element.style.getPropertyValue('-webkit-text-fill-color'), priority: element.style.getPropertyPriority('-webkit-text-fill-color')});
+      element.style.setProperty('-webkit-text-fill-color', 'transparent', 'important');
+    }
+    check(); return {nodes, restore};
+  } catch (error) {restore(); throw error;}
+}

package/dist/kit/pdf-vectors.mjs

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: MIT
+// SVG keeps its geometry in PDF; only paint operations that need browser compositing are rasterized.
+const SVG = 'http://www.w3.org/2000/svg';
+const number = value => Number(Number(value).toFixed(6));
+const nums = values => values.map(number).join(' ');
+const unsupported = () => { throw new Error('SVG operation needs browser compositing'); };
+
+function pathCommands(value) {
+  const tokens = String(value).match(/[a-zA-Z]|[+-]?(?:\d*\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/g) || [];
+  if (String(value).replace(/[a-zA-Z]|[+-]?(?:\d*\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?|[\s,]+/g, '')) unsupported();
+  const counts = {M: 2, L: 2, H: 1, V: 1, C: 6, S: 4, Q: 4, T: 2, A: 7};
+  let at = 0, command = '', previous = '', x = 0, y = 0, startX = 0, startY = 0, controlX = 0, controlY = 0, out = '';
+  const emit = (kind, values) => { if (!values.every(Number.isFinite)) unsupported(); out += nums(values) + ' ' + kind + '\n'; };
+  while (at < tokens.length) {
+    if (/^[A-Za-z]$/.test(tokens[at])) command = tokens[at++];
+    if (!command) unsupported();
+    const kind = command.toUpperCase(), relative = command !== kind;
+    if (kind === 'Z') { out += 'h\n'; x = startX; y = startY; previous = 'Z'; command = ''; continue; }
+    const size = counts[kind]; if (!size || at + size > tokens.length) unsupported();
+    const p = tokens.slice(at, at + size).map(Number); if (!p.every(Number.isFinite)) unsupported(); at += size;
+    const px = offset => p[offset] + (relative ? x : 0), py = offset => p[offset] + (relative ? y : 0);
+    let nextX, nextY;
+    if (kind === 'M' || kind === 'L') {
+      nextX = px(0); nextY = py(1); emit(kind === 'M' ? 'm' : 'l', [nextX, nextY]);
+      if (kind === 'M') { startX = nextX; startY = nextY; command = relative ? 'l' : 'L'; }
+    } else if (kind === 'H') { nextX = px(0); nextY = y; emit('l', [nextX, nextY]); }
+    else if (kind === 'V') { nextX = x; nextY = py(0); emit('l', [nextX, nextY]); }
+    else if (kind === 'C') {
+      nextX = px(4); nextY = py(5); controlX = px(2); controlY = py(3);
+      emit('c', [px(0), py(1), controlX, controlY, nextX, nextY]);
+    } else if (kind === 'S') {
+      nextX = px(2); nextY = py(3);
+      const firstX = /[CS]/.test(previous) ? 2 * x - controlX : x, firstY = /[CS]/.test(previous) ? 2 * y - controlY : y;
+      controlX = px(0); controlY = py(1); emit('c', [firstX, firstY, controlX, controlY, nextX, nextY]);
+    } else if (kind === 'Q' || kind === 'T') {
+      const qx = kind === 'Q' ? px(0) : /[QT]/.test(previous) ? 2 * x - controlX : x;
+      const qy = kind === 'Q' ? py(1) : /[QT]/.test(previous) ? 2 * y - controlY : y;
+      nextX = px(kind === 'Q' ? 2 : 0); nextY = py(kind === 'Q' ? 3 : 1);
+      emit('c', [x + (qx - x) * 2 / 3, y + (qy - y) * 2 / 3, nextX + (qx - nextX) * 2 / 3, nextY + (qy - nextY) * 2 / 3, nextX, nextY]);
+      controlX = qx; controlY = qy;
+    } else {
+      nextX = px(5); nextY = py(6);
+      let rx = Math.abs(p[0]), ry = Math.abs(p[1]);
+      if (![0, 1].includes(p[3]) || ![0, 1].includes(p[4])) unsupported();
+      if (!rx || !ry) emit('l', [nextX, nextY]);
+      else if (nextX !== x || nextY !== y) {
+        const angle = p[2] * Math.PI / 180, c = Math.cos(angle), s = Math.sin(angle);
+        const dx = (x - nextX) / 2, dy = (y - nextY) / 2, u = c * dx + s * dy, v = -s * dx + c * dy;
+        const fit = u * u / (rx * rx) + v * v / (ry * ry);
+        if (fit > 1) { const scale = Math.sqrt(fit); rx *= scale; ry *= scale; }
+        const denominator = rx * rx * v * v + ry * ry * u * u;
+        const scale = (p[3] === p[4] ? -1 : 1) * Math.sqrt(Math.max(0, (rx * rx * ry * ry - denominator) / denominator));
+        const cu = scale * rx * v / ry, cv = -scale * ry * u / rx;
+        const cx = c * cu - s * cv + (x + nextX) / 2, cy = s * cu + c * cv + (y + nextY) / 2;
+        let start = Math.atan2((v - cv) / ry, (u - cu) / rx), end = Math.atan2((-v - cv) / ry, (-u - cu) / rx), sweep = end - start;
+        if (p[4] && sweep < 0) sweep += 2 * Math.PI; else if (!p[4] && sweep > 0) sweep -= 2 * Math.PI;
+        const steps = Math.ceil(Math.abs(sweep) / (Math.PI / 2)), step = sweep / steps;
+        const point = t => [cx + c * rx * Math.cos(t) - s * ry * Math.sin(t), cy + s * rx * Math.cos(t) + c * ry * Math.sin(t)];
+        const tangent = t => [-c * rx * Math.sin(t) - s * ry * Math.cos(t), -s * rx * Math.sin(t) + c * ry * Math.cos(t)];
+        for (let i = 0; i < steps; i++) {
+          const finish = start + step, alpha = 4 / 3 * Math.tan(step / 4), first = point(start), last = point(finish), a = tangent(start), b = tangent(finish);
+          emit('c', [first[0] + alpha * a[0], first[1] + alpha * a[1], last[0] - alpha * b[0], last[1] - alpha * b[1], ...last]); start = finish;
+        }
+      }
+    }
+    x = nextX; y = nextY; previous = kind;
+  }
+  return out;
+}
+
+function geometry(node) {
+  const value = name => { const property = node[name]?.baseVal; return property && typeof property.value === 'number' ? property.value : Number(node.getAttribute(name) || 0); };
+  const kind = node.localName;
+  if (kind === 'path') return pathCommands(node.getAttribute('d') || '');
+  if (kind === 'line') return nums([value('x1'), value('y1')]) + ' m\n' + nums([value('x2'), value('y2')]) + ' l\n';
+  if (kind === 'polyline' || kind === 'polygon') {
+    const points = Array.from({length: node.points.numberOfItems}, (_, i) => node.points.getItem(i));
+    return points.map((point, i) => nums([point.x, point.y]) + (i ? ' l\n' : ' m\n')).join('') + (kind === 'polygon' ? 'h\n' : '');
+  }
+  if (kind === 'rect') {
+    const x = value('x'), y = value('y'), width = value('width'), height = value('height');
+    if (!(width > 0 && height > 0)) return '';
+    let rx = value('rx'), ry = value('ry'); if (!node.hasAttribute('rx')) rx = ry; if (!node.hasAttribute('ry')) ry = rx;
+    rx = Math.min(rx, width / 2); ry = Math.min(ry, height / 2);
+    if (!(rx > 0 && ry > 0)) return nums([x, y, width, height]) + ' re\n';
+    return pathCommands(`M${x + rx} ${y}H${x + width - rx}A${rx} ${ry} 0 0 1 ${x + width} ${y + ry}V${y + height - ry}A${rx} ${ry} 0 0 1 ${x + width - rx} ${y + height}H${x + rx}A${rx} ${ry} 0 0 1 ${x} ${y + height - ry}V${y + ry}A${rx} ${ry} 0 0 1 ${x + rx} ${y}Z`);
+  }
+  if (kind === 'circle' || kind === 'ellipse') {
+    const cx = value('cx'), cy = value('cy'), rx = value(kind === 'circle' ? 'r' : 'rx'), ry = value(kind === 'circle' ? 'r' : 'ry');
+    if (!(rx > 0 && ry > 0)) return '';
+    return pathCommands(`M${cx - rx} ${cy}A${rx} ${ry} 0 1 0 ${cx + rx} ${cy}A${rx} ${ry} 0 1 0 ${cx - rx} ${cy}Z`);
+  }
+  unsupported();
+}
+
+export async function collectPdfVectors(main, {width, height, count, capture, signal, current, check, maxBytes, sanitizeSvg}) {
+  const document = main.ownerDocument, window = document.defaultView, origin = main.getBoundingClientRect();
+  const pages = Array.from({length: count}, () => []), hidden = [], temporary = [], textRoots = [];
+  const colorCanvas = document.createElement('canvas'); colorCanvas.width = colorCanvas.height = 1;
+  const colorContext = colorCanvas.getContext('2d', {willReadFrequently: true});
+  if (!colorContext) return {pages, textRoots, restore() {}};
+  const colors = new Map();
+  let rasterBytes = 0, visited = 0;
+  const compress = async bytes => {
+    const result = new Uint8Array(await new Response(new Blob([bytes]).stream().pipeThrough(new CompressionStream('deflate'))).arrayBuffer());
+    check(); rasterBytes += result.length;
+    if (rasterBytes > maxBytes) throw Object.assign(new Error('The exported file exceeds the file limit.'), {code: 'export_too_large'});
+    return result;
+  };
+  const color = text => {
+    if (text === 'none') return null;
+    if (text.includes('url(')) unsupported();
+    if (!colors.has(text)) { colorContext.clearRect(0, 0, 1, 1); colorContext.fillStyle = text; colorContext.fillRect(0, 0, 1, 1); colors.set(text, Array.from(colorContext.getImageData(0, 0, 1, 1).data, n => n / 255)); }
+    return colors.get(text);
+  };
+  const restore = () => { for (const {node, value, priority} of hidden) {if (value) node.style.setProperty('visibility', value, priority); else node.style.removeProperty('visibility');} for (const node of temporary) node.remove(); colorCanvas.width = colorCanvas.height = 0; };
+  const roots = Array.from(main.querySelectorAll('svg,img')).filter(node => node.localName === 'img' || !node.ownerSVGElement);
+  try {
+    for (const original of roots) {
+      check();
+      let root = original, mount = null;
+      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;
+        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;
+        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`;
+        mount.append(root); document.body.append(mount); temporary.push(mount); await document.fonts.ready;
+        textRoots.push(root);
+      }
+      const box = root.getBoundingClientRect(), nodes = [root, ...root.querySelectorAll('*')], sequence = [];
+      const raster = async node => {
+        const clone = root.cloneNode(true), copies = [clone, ...clone.querySelectorAll('*')];
+        const selected = copies[nodes.indexOf(node)];
+        for (let held = selected; held && held !== clone; held = held.parentElement)
+          for (const sibling of Array.from(held.parentElement.children)) if (sibling !== held && !['defs', 'style', 'metadata', 'title', 'desc'].includes(sibling.localName)) sibling.remove();
+        const wrap = document.createElement('div');
+        wrap.style.cssText = `position:fixed;left:0;top:0;width:${box.width}px;height:${box.height}px;pointer-events:none;background:transparent`;
+        clone.style.setProperty('width', box.width + 'px', 'important'); clone.style.setProperty('height', box.height + 'px', 'important');
+        wrap.append(clone); document.body.append(wrap);
+        try {
+          const plainText = node.localName === 'text' && window.getComputedStyle(node).filter === 'none' && window.getComputedStyle(node).textShadow === 'none';
+          const bounds = plainText ? node.getBoundingClientRect() : box;
+          const left = Math.max(0, bounds.left - box.left - 2), top = Math.max(0, bounds.top - box.top - 2);
+          const right = Math.min(box.width, bounds.right - box.left + 2), bottom = Math.min(box.height, bounds.bottom - box.top + 2);
+          if (!(right > left && bottom > top)) return;
+          const result = await capture({root: wrap, clip: {x: left, y: top, width: right - left, height: bottom - top}, transparent: true, scale: 2, signal, current}); check();
+          const image = new window.Image(); image.src = 'data:' + result.mimeType + ';base64,' + result.data; await image.decode(); check();
+          const canvas = document.createElement('canvas'); canvas.width = image.naturalWidth; canvas.height = image.naturalHeight;
+          try {
+            const context = canvas.getContext('2d', {willReadFrequently: true}); if (!context) throw new Error('PDF image conversion is unavailable.'); context.drawImage(image, 0, 0);
+            const rgba = context.getImageData(0, 0, canvas.width, canvas.height).data, rgb = new Uint8Array(canvas.width * canvas.height * 3), alpha = new Uint8Array(canvas.width * canvas.height);
+            for (let i = 0, p = 0; i < rgba.length; i += 4, p++) {rgb.set(rgba.subarray(i, i + 3), p * 3); alpha[p] = rgba[i + 3];}
+            return {image: {rgb: await compress(rgb), alpha: await compress(alpha), width: canvas.width, height: canvas.height}, x: box.left - origin.left + left, y: box.top - origin.top + top, width: right - left, height: bottom - top};
+          } finally {canvas.width = canvas.height = 0; image.src = '';}
+        } finally {wrap.remove();}
+      };
+      let geometries = 0;
+      const walk = async node => {
+        if (++visited % 128 === 0) {await new Promise(resolve => setTimeout(resolve, 0)); check();}
+        const style = window.getComputedStyle(node), kind = node.localName;
+        if (['defs', 'style', 'metadata', 'title', 'desc'].includes(kind) || style.display === 'none' || style.visibility === 'hidden') return;
+        const group = ['svg', 'g', 'a'].includes(kind);
+        if (style.filter !== 'none' || style.mask !== 'none' || style.clipPath !== 'none' || style.mixBlendMode !== 'normal' || (group && Number(style.opacity) !== 1)) { sequence.push({raster: node}); return; }
+        if (group) {for (const child of node.children) await walk(child); return;}
+        let path, fill, stroke;
+        try {
+          path = geometry(node); fill = color(style.fill);
+          // SVG zero-width strokes are absent; PDF's zero width instead paints a hairline.
+          stroke = Number.parseFloat(style.strokeWidth) === 0 ? null : color(style.stroke);
+          if (style.vectorEffect !== 'none' || style.markerStart !== 'none' || style.markerMid !== 'none' || style.markerEnd !== 'none' || style.paintOrder !== 'normal') unsupported();
+        } 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;
+        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) {
+          const dash = style.strokeDasharray === 'none' ? [] : style.strokeDasharray.split(/[ ,]+/).map(Number.parseFloat);
+          let factor = 1; const authoredLength = Number(node.getAttribute('pathLength'));
+          if (authoredLength > 0 && typeof node.getTotalLength === 'function') factor = node.getTotalLength() / authoredLength;
+          commands += nums(stroke.slice(0, 3)) + ' RG\n' + number(Number.parseFloat(style.strokeWidth)) + ' w\n' + ({butt: 0, round: 1, square: 2}[style.strokeLinecap] ?? 0) + ' J\n' + ({miter: 0, round: 1, bevel: 2}[style.strokeLinejoin] ?? 0) + ' j\n' + number(Number(style.strokeMiterlimit)) + ' M\n[' + nums(dash.map(n => n * factor)) + '] ' + number(Number.parseFloat(style.strokeDashoffset) * factor) + ' d\n';
+        }
+        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) 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}});
+      hidden.push({node: original, value: original.style.getPropertyValue('visibility'), priority: original.style.getPropertyPriority('visibility')}); original.style.setProperty('visibility', 'hidden', 'important');
+    }
+    return {pages, textRoots, restore};
+  } catch (error) {restore(); throw error;}
+}