@openpresentation/opf-pptx 0.9.1 → 0.11.0

package/dist/media-provenance.js

@@ -0,0 +1,237 @@
+import {XMLParser} from 'fast-xml-parser';
+import {validatePresentation} from '@openpresentation/opf';
+import {attachTextTags, decodeTextTag} from './code-provenance.js';
+import {sourceLineParagraphs} from './text-provenance.js';
+
+// A video payload exports as the preview's placeholder: a frame, a play badge,
+// a play triangle and caption lines (FF-29). PPTX has no native field for the
+// OPF video value, so every shape of the group carries one OPF_MEDIA_V1 shape
+// tag unless provenance is off. Full-mode frames hold storable authored values;
+// references-only frames carry no source or metadata. Import recognizes an
+// unchanged, fully tagged group and rebuilds the video block; any other tagged
+// group drops only its tagged decoration shapes, keeps the caption text and
+// reports invalid-media-provenance. A shape name alone never removes a shape.
+const TAG = 'OPF_MEDIA_V1', REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
+const ROLES = ['frame', 'badge', 'play', 'caption'];
+const MAX_VALUE_BYTES = 256 * 1024;
+const parser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', parseTagValue: false, trimValues: false});
+const decoder = new TextDecoder('utf-8', {fatal: true}), encoder = new TextEncoder();
+const array = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const canonical = value => JSON.stringify(value, (_key, item) => object(item) ? Object.fromEntries(Object.keys(item).sort().map(key => [key, item[key]])) : item);
+const sizeOf = value => encoder.encode(JSON.stringify(value)).byteLength;
+const sourceOf = value => typeof value === 'string' ? value : value?.src;
+const webSource = source => typeof source === 'string' && /^https?:\/\//i.test(source) ? source : null;
+const hasData = value => typeof value === 'string' ? /^data:/i.test(value) : Array.isArray(value) ? value.some(hasData) : object(value) && Object.values(value).some(hasData);
+const mediaPath = path => typeof path === 'string' && /^slides\.\d+\.(?:blocks\.\d+\.)*video$/.test(path);
+const currentPath = (path, slideIndex) => path.replace(/^slides\.\d+/, `slides.${slideIndex}`);
+
+// Exact emitted-line change detection, not authentication: tags remain writable.
+// Full mode stores no caption words here. References-only carries line
+// structure alone and derives its caption from the current native text.
+export function mediaTextFingerprint(text) {
+  let a = 0xdeadbeef, b = 0x41c6ce57;
+  for (let index = 0; index < text.length; index++) {
+    a = Math.imul(a ^ text.charCodeAt(index), 2654435761);
+    b = Math.imul(b ^ text.charCodeAt(index), 1597334677);
+  }
+  return `${text.length}:${(a >>> 0).toString(16).padStart(8, '0')}${(b >>> 0).toString(16).padStart(8, '0')}`;
+}
+
+function resolvedSource(value, assets) {
+  let source = sourceOf(value);
+  const seen = new Set();
+  while (typeof source === 'string' && source.startsWith('asset:')) {
+    const id = source.slice(6);
+    if (seen.has(id) || !Object.hasOwn(assets, id)) return undefined;
+    seen.add(id);
+    source = sourceOf(assets[id]);
+  }
+  return source;
+}
+
+/** The caption the placeholder shows: title, else source, else "Media". */
+export function mediaCaption(value) {
+  const asset = typeof value === 'string' ? {src: value} : object(value) ? value : {src: ''};
+  return asset.title || asset.src || 'Media';
+}
+
+/**
+ * The frame record: the authored value and, in 'full' provenance mode, the
+ * asset registry entries it references (without data: sources), so an
+ * `asset:` reference still resolves after import. Data: sources and oversized
+ * values are omitted with a diagnostic. References-only stores only identity;
+ * its imported value comes from the current native hyperlink and caption.
+ */
+export function mediaFrameRecord(value, path, presentation, mode, report = () => {}) {
+  const record = {v: 1, role: 'frame', path};
+  if (mode === 'references-only') return {...record, nativeOnly: true};
+  const omit = reason => {
+    report({code: 'media-provenance-omitted', path, message: `The video value is not stored in the PPTX because ${reason}; import keeps current native content.`});
+    // Late checks run after video/assets are added. Omission is identity-only.
+    return {v: 1, role: 'frame', path, omitted: true};
+  };
+  if (hasData(value)) return omit('it embeds a data: source without an exported media part');
+  if (sizeOf(value) > MAX_VALUE_BYTES) return omit('it exceeds the media provenance size limit');
+  record.video = value;
+  if (mode === 'full') {
+    const assets = Object.create(null);
+    let source = typeof value === 'string' ? value : value?.src;
+    for (let depth = 0; typeof source === 'string' && source.startsWith('asset:') && depth < 8; depth++) {
+      const id = source.slice(6), asset = presentation.assets?.[id];
+      if (asset === undefined || Object.hasOwn(assets, id) || hasData(asset) || sizeOf(asset) > MAX_VALUE_BYTES) return omit('a referenced asset cannot be stored');
+      assets[id] = asset;
+      source = typeof asset === 'string' ? asset : asset?.src;
+    }
+    if (Object.keys(assets).length) record.assets = assets;
+    if (resolvedSource(value, assets) === undefined) return omit('a referenced asset cannot be resolved');
+  }
+  if (sizeOf(record) > MAX_VALUE_BYTES) return omit('it exceeds the media provenance size limit');
+  return record;
+}
+
+export function attachMediaTags(entries, records) {
+  attachTextTags(entries, records, TAG, 'opfMedia', 'media');
+}
+
+function readTags(shape, relationships, entries) {
+  const tags = [];
+  let unreadable = false;
+  for (const link of array(shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'])) {
+    const rel = relationships.get(link['r:id']);
+    if (rel?.type !== REL || rel.targetMode === 'External' || !entries[rel.path]) { unreadable = true; continue; }
+    try { tags.push(...array(parser.parse(decoder.decode(entries[rel.path]))['p:tagLst']?.['p:tag'])); } catch { unreadable = true; }
+  }
+  return {tags, unreadable};
+}
+
+const validAsset = (id, asset) => /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id) && validatePresentation({$schema: 'https://openpresentation.org/schema/opf/v1', name: 'Media', assets: {[id]: asset}, slides: [{title: 'Media'}]}).valid;
+const validVideo = value => validatePresentation({$schema: 'https://openpresentation.org/schema/opf/v1', name: 'Media', slides: [{video: value}]}).valid;
+
+/**
+ * Returns {items, consumed, assets}. items are {shape, payload} for restored
+ * video blocks (the frame supplies the position); consumed holds every shape
+ * import must skip; assets are registry entries to add when absent.
+ */
+export function importMediaGroups(shapes, paragraphs, relationships, entries, slideIndex, report, registry = Object.create(null)) {
+  const groups = new Map(), items = [], consumed = new Set(), assets = Object.create(null), captionShapes = new Set();
+  for (const [index, shape] of shapes.entries()) {
+    const {tags, unreadable} = readTags(shape, relationships, entries);
+    const own = tags.filter(tag => String(tag.name ?? '').toUpperCase() === TAG);
+    if (!own.length) continue;
+    let record = null;
+    try {
+      if (unreadable || own.length !== 1 || tags.some(tag => /^OPF_/i.test(tag.name ?? '') && String(tag.name).toUpperCase() !== TAG)) throw Error('ambiguous');
+      if (typeof own[0].val !== 'string' || own[0].val.length > MAX_VALUE_BYTES * 2) throw Error('oversized');
+      record = decodeTextTag(own[0].val);
+      if (!object(record) || record.v !== 1 || !ROLES.includes(record.role) || !mediaPath(record.path)) throw Error('invalid');
+      const allowed = ['v', 'role', 'path', ...(record.role === 'frame' ? ['video', 'assets', 'omitted', 'nativeOnly'] : record.role === 'caption' ? ['line', 'count', 'boundary', 'separator', 'fingerprint'] : [])];
+      if (Object.keys(record).some(key => !allowed.includes(key))) throw Error('unknown field');
+      if (record.role === 'caption' && (record.boundary !== undefined && !['hard', 'soft', 'end'].includes(record.boundary) || record.separator !== undefined && (typeof record.separator !== 'string' || !/^(?:\r\n|\r|\n)?$/.test(record.separator)) || record.fingerprint !== undefined && (typeof record.fingerprint !== 'string' || !/^\d+:[0-9a-f]{16}$/.test(record.fingerprint)))) throw Error('invalid caption evidence');
+      if (record.role === 'frame' && (record.omitted !== undefined && record.omitted !== true || record.nativeOnly !== undefined && record.nativeOnly !== true || (record.omitted || record.nativeOnly) && (Object.hasOwn(record, 'video') || Object.hasOwn(record, 'assets')) || record.omitted && record.nativeOnly)) throw Error('inconsistent frame');
+    } catch { record = null; }
+    const key = record?.path ?? `slides.${slideIndex}`;
+    if (!groups.has(key)) groups.set(key, {path: key, members: [], invalid: false});
+    const group = groups.get(key);
+    if (!record) { group.invalid = true; group.members.push({index, shape, role: null}); continue; }
+    if (record.role === 'caption') captionShapes.add(shape);
+    group.members.push({index, shape, record, role: record.role});
+  }
+  for (const group of groups.values()) {
+    const name = (member, suffix) => member.shape['p:nvSpPr']?.['p:cNvPr']?.name === `OPF media ${group.path} ${suffix}`;
+    const text = member => (paragraphs[member.index] ?? []).map(paragraph => paragraph.text).join('\n');
+    const byRole = role => group.members.filter(member => member.role === role);
+    const [frame] = byRole('frame'), captions = byRole('caption').sort((a, b) => a.record.line - b.record.line);
+    const decorations = group.members.filter(member => ['frame', 'badge', 'play'].includes(member.role));
+    const path = currentPath(group.path, slideIndex);
+    // Current characters supply the text. Soft wraps insert nothing; full
+    // source separators retain CR/LF spelling. Restricted mode has only
+    // structural hard breaks, represented as LF without hidden source bytes.
+    let caption;
+    if (captions.length && captions.every((member, index) => member.record.line === index && member.record.count === captions.length && name(member, `caption line ${index}`))) try {
+      caption = sourceLineParagraphs(captions.map(member => {
+        let data = frame?.record.nativeOnly === true
+          ? {boundary: member.record.boundary, separator: member.record.boundary === 'hard' ? '\n' : ''}
+          : member.record;
+        // Parent full tags omitted separators. Explicit soft/end inserts no
+        // character; an old hard boundary cannot establish CR/LF spelling.
+        if (!Object.hasOwn(data, 'separator') && ['soft', 'end'].includes(data.boundary)) data = {...data, separator: ''};
+        return {index: member.index, data};
+      }), paragraphs)[0].text;
+    } catch { /* Missing or damaged boundaries use current native fallback. */ }
+    const links = array(frame?.shape['p:nvSpPr']?.['p:cNvPr']?.['a:hlinkClick']);
+    const rel = links.length === 1 ? relationships.get(links[0]['r:id']) : undefined;
+    const href = rel?.type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink' && rel.targetMode === 'External' ? webSource(rel.target) : null;
+    let reason = null, video, restoredAssets;
+    if (group.invalid) reason = 'a media tag is ambiguous or unreadable';
+    else if (byRole('frame').length !== 1 || byRole('badge').length !== 1 || byRole('play').length !== 1 || !captions.length) reason = 'placeholder shapes were removed or duplicated';
+    else if (!decorations.every(member => name(member, member.role) && !text(member)) || !captions.every(member => name(member, `caption line ${member.record.line}`))) reason = 'placeholder shapes were renamed or given text';
+    else if (!captions.every((member, index) => member.record.line === index && member.record.count === captions.length)) reason = 'caption lines were removed or duplicated';
+    else if (links.length && !href) reason = 'the native hyperlink is ambiguous or unsupported';
+    else if (caption === undefined) reason = 'its caption source boundaries are missing or invalid';
+    else if (frame.record.nativeOnly === true) {
+      if (!href) reason = 'no native web hyperlink is available';
+      else if (caption === '') reason = 'its current caption was cleared';
+      else video = caption === href ? href : {src: href, title: caption};
+    }
+    else if (frame.record.omitted || !Object.hasOwn(frame.record, 'video')) reason = 'the video value was omitted at export';
+    else if (!validVideo(frame.record.video)) reason = 'the stored video value is not valid OPF';
+    else if (hasData(frame.record.video) || hasData(frame.record.assets)) reason = 'the stored video contains an unsupported data: source';
+    else if (frame.record.assets !== undefined && (!object(frame.record.assets) || !Object.entries(frame.record.assets).every(([id, asset]) => validAsset(id, asset)))) reason = 'the stored assets are not valid OPF';
+    else {
+      const source = resolvedSource(frame.record.video, frame.record.assets ?? {});
+      const needed = new Set();
+      let reference = sourceOf(frame.record.video);
+      while (typeof reference === 'string' && reference.startsWith('asset:') && !needed.has(reference.slice(6))) {
+        const id = reference.slice(6);
+        needed.add(id);
+        reference = sourceOf(frame.record.assets?.[id]);
+      }
+      if (Object.keys(frame.record.assets ?? {}).some(id => !needed.has(id))) reason = 'the stored assets contain unrelated entries';
+      else if (source === undefined) reason = 'the stored asset reference cannot be resolved';
+      else if (webSource(source) !== href) {
+        if (!href) reason = 'its source hyperlink was removed';
+        else if (caption === '') reason = 'its current caption was cleared';
+        else {
+          // Preserve the current URL and caption; hidden metadata describes the old source.
+          video = caption === href ? href : {src: href, title: caption};
+          report({code: 'media-source-changed', path, message: `The video hyperlink at ${path} changed; import keeps the current URL and caption.`});
+        }
+      }
+      else if (!captions.every(member => typeof member.record.fingerprint === 'string' && mediaTextFingerprint(text(member)) === member.record.fingerprint)) reason = 'its caption text was edited or exact caption evidence is missing';
+      // Line evidence is not authentication: bind the stored authored title
+      // to exact current characters and validated boundaries as well.
+      else if (caption !== mediaCaption(frame.record.video)) reason = 'its stored caption disagrees with current native text';
+      else if (!href && caption !== source) reason = 'its source has no current native hyperlink or source caption';
+      else {
+        const conflict = Object.entries(frame.record.assets ?? {}).some(([id, asset]) => Object.hasOwn(registry, id) && canonical(registry[id]) !== canonical(asset));
+        if (conflict && !href) reason = 'its stored assets conflict with another video';
+        else if (conflict && caption === '') reason = 'its current caption was cleared';
+        else if (conflict) {
+          video = caption === href ? href : {src: href, title: caption};
+          report({code: 'media-asset-conflict', path, message: `Stored asset IDs at ${path} conflict with another video; import keeps this placeholder's current URL and caption.`});
+        }
+        else { video = structuredClone(frame.record.video); restoredAssets = frame.record.assets; }
+      }
+    }
+    if (!reason) {
+      for (const member of group.members) consumed.add(member.shape);
+      items.push({shape: frame.shape, payload: {type: 'video', video}});
+      if (object(restoredAssets)) for (const [id, asset] of Object.entries(restoredAssets)) {
+        registry[id] = structuredClone(asset);
+        assets[id] = structuredClone(asset);
+      }
+      continue;
+    }
+    // Tagged decoration carries no content; caption lines stay ordinary text.
+    for (const member of group.members) if (member.role && member.role !== 'caption' && !text(member)) consumed.add(member.shape);
+    // Preserve the current frame URL independently of failed tag evidence.
+    // Decoration links never supply authority. Other schemes remain inert.
+    if (rel?.type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink' && rel.targetMode === 'External' && typeof rel.target === 'string') {
+      items.push({shape: frame.shape, payload: {type: 'text', text: href ? [{text: href, link: href}] : rel.target}});
+    }
+    report({code: 'invalid-media-provenance', path,
+      message: `The video placeholder at ${path} was not restored as a video because ${reason}. Its current caption stays as text and its current frame URL is retained as linked text when it is a web URL.`});
+  }
+  return {items, consumed, assets, captionShapes};
+}

package/dist/native-text-style.js

@@ -0,0 +1,71 @@
+import {readBackgroundColor} from './background.js';
+import {splitWeightFace} from './font-weights.js';
+
+const boolean = value => ['1','true','on'].includes(value) ? true : ['0','false','off'].includes(value) ? false : undefined;
+
+const themeFamilies = context => ['a:majorFont', 'a:minorFont'].map(key => context.fonts?.[key]?.['a:latin']?.typeface?.trim().toLowerCase()).filter(Boolean);
+
+export function nativeRunStyle(properties, context, relationships, report, kind = 'table') {
+  const result = {};
+  for (const [native, opf] of [['b','bold'], ['i','italic']]) {
+    const value = boolean(properties[native]);
+    if (value !== undefined) result[opf] = value;
+  }
+  for (const [native, opf] of [['u','underline'], ['strike','strikethrough']]) {
+    if (properties[native] !== undefined) result[opf] = properties[native] !== 'none' && properties[native] !== 'noStrike';
+  }
+  const size = Number(properties.sz);
+  if (Number.isFinite(size) && size > 0) result.fontSize = size / 100;
+  const baseline = Number(properties.baseline);
+  if (Number.isFinite(baseline)) {
+    result.superscript = baseline > 0;
+    result.subscript = baseline < 0;
+  }
+  const font = properties['a:latin']?.typeface;
+  if (properties['a:latin'] && !font) report(`unsupported-${kind}-font`, 'The native text font has no usable Latin face or theme reference.');
+  if (font) {
+    const match = font.match(/^\+(mj|mn)-(lt|ea|cs)$/);
+    const family = match ? context.fonts?.[match[1] === 'mj' ? 'a:majorFont' : 'a:minorFont']?.[{lt:'a:latin',ea:'a:ea',cs:'a:cs'}[match[2]]]?.typeface : font;
+    if (family) {
+      result.fontFamily = family;
+      // The exporter writes a bundled family's weight faces (Roboto SemiBold) under their
+      // native style-link names. OPF runs carry the family plus bold, never the face name.
+      // A typeface that is itself a theme font was authored as a family; leave it as is.
+      const face = themeFamilies(context).includes(family.trim().toLowerCase()) ? undefined : splitWeightFace(family);
+      if (face) {
+        result.fontFamily = face.family;
+        if (face.weight >= 600) result.bold = true;
+        if (face.italic) result.italic = true;
+        if (face.weight !== 400 && face.weight !== 700) report(`approximate-${kind}-font-weight`, 'OPF text runs represent regular or bold only; the native weight face was imported as its family, with bold for weights of 600 and above.');
+      }
+    } else report(`unsupported-${kind}-font`, 'The theme font reference could not be resolved from this archive.');
+  }
+  if (properties['a:solidFill']) {
+    const color = readBackgroundColor(properties['a:solidFill'], context);
+    if (color) result.color = color.hex + (color.alpha < 1 ? Math.round(color.alpha * 255).toString(16).padStart(2, '0').toUpperCase() : '');
+    else report(`unsupported-${kind}-text-color`, 'The native text color or its transforms could not be resolved.');
+  } else if (properties['a:noFill']) {
+    result.color = '#00000000';
+  }
+  if (['a:gradFill','a:blipFill','a:pattFill','a:grpFill'].some(key => properties[key])) report(`unsupported-${kind}-text-fill`, 'Only solid native text fills are represented by OPF runs.');
+  const hyperlink = properties['a:hlinkClick'];
+  if (hyperlink) {
+    const relationship = relationships.get(hyperlink['r:id']);
+    if (relationship?.type.endsWith('/hyperlink') && relationship.targetMode === 'External' && relationship.target && !hyperlink.action) result.link = relationship.target;
+    else report(`unsupported-${kind}-link`, 'The native hyperlink action or relationship cannot be represented as a URL.');
+  }
+  return result;
+}
+
+// Merge at the native property level before conversion: an explicit normal run
+// overrides a bold paragraph default, and a new fill replaces the inherited fill.
+export function mergeNativeRunProperties(...levels) {
+  const result = {};
+  const fills = ['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill','_opfUnresolvedTableFill'];
+  for (const level of levels) {
+    if (!level) continue;
+    if (fills.some(key => Object.hasOwn(level, key))) for (const key of fills) delete result[key];
+    Object.assign(result, level);
+  }
+  return result;
+}

package/dist/package-fonts.js

@@ -0,0 +1,161 @@
+import {unzipSync, zipSync} from 'fflate';
+import {inventoryPptxTypefaces, packageFontsUsed, headingPairs, titlesOfParts} from './typeface-inventory.js';
+
+// Package-level font post-processing (FF-08, font-fidelity-everywhere). The
+// vendored PptxGenJS bytes stay untouched; these passes rewrite its output so
+// the package names only the fonts the document chose:
+// - chart text properties (data labels, axes, legend, titles) use the chart's
+//   body font in latin/ea/cs instead of the hard-coded Arial;
+// - each chart's embedded workbook uses the same fonts in its styles and
+//   theme, with no Office script supplements;
+// - run pitchFamily follows the font's catalog type (monospace is fixed pitch);
+// - docProps/app.xml "Fonts Used" lists the fonts the package actually uses.
+
+const decoder = new TextDecoder(), encoder = new TextEncoder();
+const text = bytes => decoder.decode(bytes);
+const escapeXml = value => String(value).replace(/[&<>"']/g, char => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;'}[char]));
+
+// OOXML pitchFamily: low bits are the pitch (1 fixed, 2 variable), high bits
+// the family (0x10 roman, 0x20 swiss, 0x30 modern). These are the values
+// PowerPoint writes for Consolas/Courier New, Georgia/Times New Roman and
+// Calibri/Arial respectively.
+export const PITCH_FAMILY = Object.freeze({monospace: 49, serif: 18, 'sans-serif': 34});
+
+// family -> pitchFamily. A scheme's type describes its major/minor families,
+// not inline heading/body overrides. Each slide's resolved scheme wins, then
+// catalog records where every record agrees, then the code role (monospace).
+// Families with no known type keep the vendor value.
+export function fontPitchFamilies(slideFonts, records) {
+  const pitch = new Map();
+  const typed = record => [record?.major, record?.minor].filter(family => typeof family === 'string' && family).map(family => [family, PITCH_FAMILY[record.type]]);
+  for (const fonts of slideFonts) for (const [family, value] of typed(fonts.scheme)) if (value !== undefined && !pitch.has(family)) pitch.set(family, value);
+  const catalog = new Map();
+  for (const record of records) for (const [family, value] of typed(record)) catalog.set(family, catalog.has(family) && catalog.get(family) !== value ? undefined : value);
+  for (const [family, value] of catalog) if (value !== undefined && !pitch.has(family)) pitch.set(family, value);
+  for (const fonts of slideFonts) if (fonts.code && !pitch.has(fonts.code)) pitch.set(fonts.code, PITCH_FAMILY.monospace);
+  return pitch;
+}
+
+export function writePitchFamilies(xml, pitch) {
+  if (!pitch.size || !xml.includes('pitchFamily=')) return xml;
+  return xml.replace(/<a:(latin|ea|cs|sym|buFont)\b([^<>]*?)\/>/g, (node, element, attributes) => {
+    const face = /\btypeface="([^"]*)"/.exec(attributes)?.[1];
+    if (face === undefined || !/\bpitchFamily="/.test(attributes)) return node;
+    const value = pitch.get(unescapeFace(face));
+    if (value === undefined) return node;
+    return `<a:${element}${attributes.replace(/\bpitchFamily="[^"]*"/, `pitchFamily="${value}"`)}/>`;
+  });
+}
+
+// Chart parts: every text property element names the chart font in all three
+// script slots, in schema order (after fills/underline, before sym/hlink/rtl).
+export function writeChartFonts(xml, family) {
+  const face = escapeXml(family);
+  const slots = `<a:latin typeface="${face}"/><a:ea typeface="${face}"/><a:cs typeface="${face}"/>`;
+  return xml.replace(/<a:(defRPr|rPr)\b([^<>]*?)(?:\/>|>([\s\S]*?)<\/a:\1>)/g, (node, element, attributes, body) => {
+    if (attributes.endsWith('/')) attributes = attributes.slice(0, -1);
+    const content = (body ?? '').replace(/<a:(latin|ea|cs)\b[^<>]*?(?:\/>|>\s*<\/a:\1>)/g, '');
+    const tail = /<a:(?:sym|hlinkClick|hlinkMouseOver|rtl|extLst)\b/.exec(content);
+    const at = tail ? tail.index : content.length;
+    return `<a:${element}${attributes}>${content.slice(0, at)}${slots}${content.slice(at)}</a:${element}>`;
+  });
+}
+
+// Embedded chart workbook: every SpreadsheetML font uses the chart body font
+// (each <font> in styles.xml, whether under <fonts>, <dxfs> or elsewhere, and
+// any rich-text <rFont> in shared strings or sheets); the workbook theme uses
+// the chart heading/body fonts with empty ea/cs slots and no Office script
+// supplements. Parts without fonts are kept byte for byte.
+export function writeWorkbookFonts(bytes, fonts) {
+  const entries = unzipSync(bytes);
+  const styles = entries['xl/styles.xml'], theme = entries['xl/theme/theme1.xml'];
+  const setVal = node => node.replace(/\bval="[^"]*"/, `val="${escapeXml(fonts.body)}"`);
+  if (styles) {
+    entries['xl/styles.xml'] = encoder.encode(text(styles).replace(/<font\b[^>]*>[\s\S]*?<\/font>/g, font =>
+      font.replace(/<name\b[^>]*?\bval="[^"]*"/g, setVal)));
+  }
+  for (const path of Object.keys(entries)) {
+    if (!/^xl\/(?:sharedStrings|worksheets\/[^/]+)\.xml$/.test(path)) continue;
+    const xml = text(entries[path]);
+    if (xml.includes('<rFont')) entries[path] = encoder.encode(xml.replace(/<rFont\b[^>]*?\bval="[^"]*"/g, setVal));
+  }
+  if (theme) {
+    const collection = (name, family) => `<a:${name}><a:latin typeface="${escapeXml(family)}"/><a:ea typeface=""/><a:cs typeface=""/></a:${name}>`;
+    entries['xl/theme/theme1.xml'] = encoder.encode(text(theme)
+      .replace(/<a:majorFont>[\s\S]*?<\/a:majorFont>/, collection('majorFont', fonts.heading))
+      .replace(/<a:minorFont>[\s\S]*?<\/a:minorFont>/, collection('minorFont', fonts.body)));
+  }
+  // The caller's package normalization rezips nested packages deterministically.
+  return zipSync(entries, {level: 0});
+}
+
+// Rewrites chart parts and their workbooks for charts the exporter created,
+// found through each slide's chart graphic frames (per-slide fonts apply).
+export function applyChartFonts(entries, chartFonts, parseRelationships) {
+  if (!chartFonts.size) return;
+  for (const part of Object.keys(entries)) {
+    if (!/^ppt\/slides\/slide\d+\.xml$/.test(part)) continue;
+    const relationships = parseRelationships(entries, part);
+    for (const [frame] of text(entries[part]).matchAll(/<p:graphicFrame>[\s\S]*?<\/p:graphicFrame>/g)) {
+      const fonts = chartFonts.get(frame.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1]);
+      const chartPart = relationships.get(frame.match(/<c:chart\b[^>]*\br:id="([^"]+)"/)?.[1])?.path;
+      if (!fonts || !chartPart || !entries[chartPart]) continue;
+      entries[chartPart] = encoder.encode(writeChartFonts(text(entries[chartPart]), fonts.body));
+      for (const relationship of parseRelationships(entries, chartPart).values()) {
+        if (relationship.type.endsWith('/package') && /\.xlsx$/i.test(relationship.path) && entries[relationship.path]) {
+          entries[relationship.path] = writeWorkbookFonts(entries[relationship.path], fonts);
+        }
+      }
+    }
+  }
+}
+
+export function applyPitchFamilies(entries, pitch) {
+  for (const part of Object.keys(entries)) {
+    if (/^ppt\/.*\.xml$/.test(part)) {
+      const xml = text(entries[part]), next = writePitchFamilies(xml, pitch);
+      if (next !== xml) entries[part] = encoder.encode(next);
+    }
+  }
+}
+
+// docProps/app.xml: regenerate the "Fonts Used" group of HeadingPairs and
+// TitlesOfParts from the fonts the finished package uses, and name the theme
+// the way the theme part does. Other groups (slide titles) are kept.
+export function writeFontsUsed(appXml, fonts, themeName) {
+  const pairs = headingPairs(appXml), titles = titlesOfParts(appXml);
+  if (!pairs || !titles) return appXml;
+  const groups = [];
+  let offset = 0;
+  for (const [name, count] of pairs) {
+    groups.push([name, titles.slice(offset, offset + count)]);
+    offset += count;
+  }
+  const fontsGroup = groups.find(([name]) => name === 'Fonts Used');
+  if (fontsGroup) fontsGroup[1] = fonts;
+  else groups.unshift(['Fonts Used', fonts]);
+  const themeGroup = groups.find(([name]) => name === 'Theme');
+  if (themeGroup && themeName && themeGroup[1].length === 1) themeGroup[1] = [themeName];
+  const kept = groups.filter(([, items]) => items.length);
+  const variants = kept.map(([name, items]) => `<vt:variant><vt:lpstr>${escapeXml(name)}</vt:lpstr></vt:variant><vt:variant><vt:i4>${items.length}</vt:i4></vt:variant>`).join('');
+  const items = kept.flatMap(([, list]) => list).map(item => `<vt:lpstr>${escapeXml(item)}</vt:lpstr>`).join('');
+  return appXml
+    .replace(/<HeadingPairs>[\s\S]*?<\/HeadingPairs>/, `<HeadingPairs><vt:vector size="${kept.length * 2}" baseType="variant">${variants}</vt:vector></HeadingPairs>`)
+    .replace(/<TitlesOfParts>[\s\S]*?<\/TitlesOfParts>/, `<TitlesOfParts><vt:vector size="${kept.reduce((sum, [, list]) => sum + list.length, 0)}" baseType="lpstr">${items}</vt:vector></TitlesOfParts>`);
+}
+
+// Runs on the normalized output map (path -> [bytes, options]) after every
+// other part rewrite, so the list reflects the final theme and slides.
+export function finalizeFontsUsed(output) {
+  const app = output['docProps/app.xml'];
+  if (!app) return;
+  const parts = {};
+  for (const [path, [bytes]] of Object.entries(output)) if (/^ppt\/.*\.xml$/.test(path)) parts[path] = bytes;
+  const fonts = packageFontsUsed(inventoryPptxTypefaces(parts, {nested: false}));
+  const themeName = /<a:theme\b[^>]*\bname="([^"]*)"/.exec(parts['ppt/theme/theme1.xml'] ? text(parts['ppt/theme/theme1.xml']) : '')?.[1];
+  output['docProps/app.xml'] = [encoder.encode(writeFontsUsed(text(app[0]), fonts, themeName === undefined ? undefined : unescapeFace(themeName))), app[1]];
+}
+
+function unescapeFace(value) {
+  return value.replace(/&(amp|lt|gt|quot|apos);/g, (_, name) => ({amp: '&', lt: '<', gt: '>', quot: '"', apos: "'"}[name]));
+}