@openpresentation/opf-pptx 0.13.2 → 0.14.0

package/dist/media-provenance.js

@@ -1,5 +1,5 @@
 import {XMLParser} from 'fast-xml-parser';
-import {validatePresentation} from '@openpresentation/opf';
+import {isValidFormat} from './format-check.js';
 import {attachTextTags, decodeTextTag} from './code-provenance.js';
 import {sourceLineParagraphs} from './text-provenance.js';
 
@@ -105,8 +105,8 @@ function readTags(shape, relationships, entries) {
   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;
+const validAsset = (id, asset) => /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id) && isValidFormat({$schema: 'https://openpresentation.org/schema/opf/v1', name: 'Media', assets: {[id]: asset}, slides: [{title: 'Media'}]});
+const validVideo = value => isValidFormat({$schema: 'https://openpresentation.org/schema/opf/v1', name: 'Media', slides: [{video: value}]});
 
 /**
  * Returns {items, consumed, assets}. items are {shape, payload} for restored

package/dist/metric-provenance.js

@@ -1,5 +1,5 @@
 import {XMLParser} from 'fast-xml-parser';
-import {validatePresentation} from '@openpresentation/opf';
+import {isValidFormat} from './format-check.js';
 import {attachTextTags,decodeTextTag} from './code-provenance.js';
 
 const TAG='OPF_METRIC_V1',REL='http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
@@ -17,7 +17,7 @@ export function metricManifest(value,layout,group) {
 export function attachMetricTags(entries,records,descriptions) {return attachTextTags(entries,records,TAG,'opfMetric','metric',{descriptions});}
 
 function validateManifest(manifest) {
-  if (!validatePresentation({slides:[{metric:manifest.value}]}).valid) throw new Error('Invalid metric source.');
+  if (!isValidFormat({slides:[{metric:manifest.value}]})) throw new Error('Invalid metric source.');
   const roles=scalar(manifest.value)?['value']:['value','unit','label','description','delta','trend'].filter(role=>manifest.value[role]!==undefined);
   if (!Array.isArray(manifest.parts)||manifest.parts.length!==roles.length||manifest.part!==0||manifest.line!==0) throw new Error('Invalid metric parts.');
   for (const [index,part] of manifest.parts.entries()) {
@@ -87,7 +87,7 @@ export function importMetricGroups(shapes,paragraphs,relationships,entries,repor
       if (typeof original!==typeof value[part.role]) typeChanges.push(part.role);
     }
     const metric=scalar(manifest.value)?value.value:value;
-    if (!validatePresentation({slides:[{metric}]}).valid) throw new Error('Edited native text cannot form a valid metric.');
+    if (!isValidFormat({slides:[{metric}]})) throw new Error('Edited native text cannot form a valid metric.');
     for (const item of group) consumed.add(item.shape);
     items.push({shape:anchor.shape,payload:{type:'metric',metric}});
     if (typeChanges.length) report({code:'metric-value-type-changed',message:`Edited numeric ${typeChanges.join(', ')} retained as literal text to avoid discarding spelling or precision.`});

package/dist/native-text-style.js

@@ -70,6 +70,8 @@ export function nativeRunStyle(properties, context, relationships, report, kind
     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.');
   }
+  // A link in the theme hyperlink color (what the export writes for a link with no color of its own) is a link with no color.
+  if (result.link && result._opfScheme === 'hyperlink') { delete result.color; delete result._opfScheme; }
   return result;
 }
 

package/dist/package-fonts.js

@@ -1,5 +1,5 @@
 import {unzipSync, zipSync} from 'fflate';
-import {inventoryPptxTypefaces, packageFontsUsed, headingPairs, titlesOfParts} from './typeface-inventory.js';
+import {inventoryTypefaces, 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
@@ -152,7 +152,7 @@ export function finalizeFontsUsed(output) {
   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 fonts = packageFontsUsed(inventoryTypefaces(parts, {nested: false}));
   const themeNames = Object.keys(parts).filter(path => /^ppt\/theme\/theme\d+\.xml$/.test(path)).sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]))
     .map(path => /<a:theme\b[^>]*\bname="([^"]*)"/.exec(text(parts[path]))?.[1]).filter(name => name !== undefined).map(unescapeFace);
   output['docProps/app.xml'] = [encoder.encode(writeFontsUsed(text(app[0]), fonts, themeNames)), app[1]];

package/dist/quote-provenance.js

@@ -1,24 +1,39 @@
 import {XMLParser} from 'fast-xml-parser';
-import {validatePresentation} from '@openpresentation/opf';
+import {isValidFormat} from './format-check.js';
 import {attachTextTags,decodeTextTag} from './code-provenance.js';
 import {sourceLineParagraphs} from './text-provenance.js';
+import {cleanBase,headingValue,joinRichLines,unwrapQuoteRuns} from './rich-heading.js';
 
 // FF-57: a `quote` payload exports as native text lines (a body part and an optional footer part). Each line shape carries an
 // OPF_QUOTE_V1 tag, so an unchanged export imports back as {quote: ...} instead of loose text blocks. Like timelines, only topology
 // and line boundaries are stored: every word comes from the current native text, so a cleared or edited quote cannot bring back
 // old words, and a group that no longer matches its manifest degrades to ordinary text blocks with a diagnostic.
+// FA-12: a quote with a `photo` also exports one native picture (an ellipse), tagged with the same group; import restores `photo` from
+// that picture's current bytes and description, and `role` from the footer.
 const TAG='OPF_QUOTE_V1',REL='http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
-const SEPARATOR=' - ',FIELDS=['attribution','source'],FOOTERS=['["attribution"]','["source"]','["attribution","source"]'];
+const SEPARATOR=' - ',FIELDS=['attribution','role','source'];
+// Every non-empty footer field list, in core's order (attribution, role, source).
+const FOOTERS=['["attribution"]','["role"]','["source"]','["attribution","role"]','["attribution","source"]','["role","source"]','["attribution","role","source"]'];
+// Core joins the role to the line above with a line break and the source with " - ".
+const separatorBefore=field=>field==='role'?'\n':SEPARATOR;
 const parser=new XMLParser({ignoreAttributes:false,attributeNamePrefix:'',parseTagValue:false,trimValues:false});
 const decoder=new TextDecoder('utf-8',{fatal:true}),array=value=>value===undefined?[]:Array.isArray(value)?value:[value];
-export const attachQuoteTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfQuote','quote');
+export const attachQuoteTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfQuote','quote',{pictures:true});
+export const quotePhotoName=group=>`OPF quote photo ${group}`;
 
-// The manifest rides on the first body line. `footer` lists which fields the footer part joins (core writes "attribution - source",
-// skipping an absent field) and, when both are present, where the separator starts, so an unchanged footer splits back exactly.
+// The manifest rides on the first body line. `footer` lists which fields the footer part joins (core writes the attribution, the role
+// on its own line and the source after " - ", skipping an absent field) and, from two fields on, where each separator starts, so an
+// unchanged footer splits back exactly. `photo` records that a headshot picture belongs to the quote.
 export function quoteManifest(value,layout) {
   const shorthand=typeof value==='string',fields=shorthand?[]:FIELDS.filter(field=>value[field]);
-  return {shorthand,...(fields.length?{footer:{fields,...(fields.length===2?{split:value.attribution.length}:{})}}:{}),
-    parts:layout.parts.map(part=>({role:part.role,lines:part.fit.sourceLines.length}))};
+  const splits=[];let length=0;
+  for(const [index,field] of fields.entries()){
+    if(index>0){splits.push(length);length+=separatorBefore(field).length;}
+    length+=value[field].length;
+  }
+  return {shorthand,...(fields.length?{footer:{fields,...(fields.length>1?{splits}:{})}}:{}),...(layout.photo?{photo:true}:{}),
+    // A rich body (FA-10) has richLines instead of sourceLines; both write one native shape per fitted line.
+    parts:layout.parts.map(part=>({role:part.role,lines:(part.fit.sourceLines??part.fit.lines).length}))};
 }
 function validateManifest(manifest) {
   if(!manifest||typeof manifest.shorthand!=='boolean'||!Array.isArray(manifest.parts)||manifest.parts.length<1||manifest.parts.length>2)throw Error('Invalid quote topology.');
@@ -30,44 +45,59 @@ function validateManifest(manifest) {
     count+=part.lines;
   }
   if(count>10000)throw Error('Too many quote source lines.');
+  if(manifest.photo!==undefined&&(manifest.photo!==true||manifest.shorthand))throw Error('Invalid quote photo.');
   const footer=manifest.footer;
   if(roles.length===2){
     if(manifest.shorthand||!footer||!FOOTERS.includes(JSON.stringify(footer.fields)))throw Error('Invalid quote footer fields.');
-    if(footer.fields.length===2?!Number.isSafeInteger(footer.split)||footer.split<1:footer.split!==undefined)throw Error('Invalid quote footer split.');
+    const splits=footer.splits;
+    if(footer.fields.length>1?!Array.isArray(splits)||splits.length!==footer.fields.length-1||splits.some(at=>!Number.isSafeInteger(at)||at<0):splits!==undefined)throw Error('Invalid quote footer split.');
   }else if(footer!==undefined)throw Error('Invalid quote footer.');
   return count;
 }
 
 const unwrap=text=>text.length>=2&&text.startsWith('"')&&text.endsWith('"')?text.slice(1,-1):text;
-// Split the current footer text back into fields. A footer edited so the recorded separator no longer matches splits at its
-// first separator; one with none keeps everything as the attribution.
+// Split the current footer text back into fields. A separator whose recorded position no longer matches is searched for from the end of
+// the previous field; a footer with a missing separator keeps everything as the attribution.
 function footerFields(text,footer,report) {
-  if(footer.fields.length===1)return {[footer.fields[0]]:text};
-  const at=text.startsWith(SEPARATOR,footer.split)?footer.split:text.indexOf(SEPARATOR);
-  if(at<0){
-    report({code:'quote-footer-merged',message:'The quote footer no longer separates attribution from source; the current text is kept as the attribution.'});
-    return {attribution:text};
+  const {fields}=footer;
+  if(fields.length===1)return {[fields[0]]:text};
+  const out={};let from=0;
+  for(let index=1;index<fields.length;index++){
+    const separator=separatorBefore(fields[index]),recorded=footer.splits[index-1];
+    const at=recorded>=from&&text.startsWith(separator,recorded)?recorded:text.indexOf(separator,from);
+    if(at<0){
+      report({code:'quote-footer-merged',message:'The quote footer no longer separates its attribution, role and source; the current text is kept as the attribution.'});
+      return {attribution:text};
+    }
+    out[fields[index-1]]=text.slice(from,at);from=at+separator.length;
   }
-  return {attribution:text.slice(0,at),source:text.slice(at+SEPARATOR.length)};
+  out[fields.at(-1)]=text.slice(from);
+  return out;
 }
 
-export function importQuoteGroups(shapes,paragraphs,relationships,entries,report) {
-  const groups=new Map(),consumed=new Set(),items=[];
-  for(const [index,shape]of shapes.entries()){
+// `pictures` and `readPicture` (the ordinary picture importer) restore the headshot of a quote with a photo.
+// `readBody` (optional) is the native body reader: with it the quote text keeps its native run formatting as TextRun[] (FA-10).
+export function importQuoteGroups(shapes,paragraphs,relationships,entries,report,pictures=[],readPicture=()=>undefined,readBody) {
+  const groups=new Map(),consumed=new Set(),consumedPictures=new Set(),items=[];
+  const candidates=[...shapes.map((shape,index)=>({index,shape,container:shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']})),
+    ...pictures.map((picture,index)=>({index,picture,container:picture['p:nvPicPr']?.['p:nvPr']?.['p:custDataLst']}))];
+  for(const {index,shape,picture,container}of candidates){
     const tags=[];let unreadable=false;
-    for(const link of array(shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'])){
+    for(const link of array(container?.['p:tags'])){
       const rel=relationships.get(link['r:id']);if(rel?.type!==REL||rel.targetMode==='External'||!entries[rel.path])continue;
       try{tags.push(...array(parser.parse(decoder.decode(entries[rel.path]))['p:tagLst']?.['p:tag']));}catch{unreadable=true;}
     }
     for(const tag of tags.filter(tag=>tag.name?.toUpperCase()===TAG))try{
       const data=decodeTextTag(tag.val);if(data?.v!==1||typeof data.group!=='string'||!/^\d{1,12}$/.test(data.group))throw Error('Invalid quote identity.');
-      const group=groups.get(data.group)??[];group.push({shape,index,data,ambiguous:unreadable||tags.filter(tag=>/^OPF_/i.test(tag.name)).length!==1});groups.set(data.group,group);
+      const group=groups.get(data.group)??[];group.push({shape,picture,index,data,ambiguous:unreadable||tags.filter(tag=>/^OPF_/i.test(tag.name)).length!==1});groups.set(data.group,group);
     }catch{report({code:'invalid-quote-provenance',message:'Invalid quote tags; ordinary import retains current native text.'});}
   }
-  for(const group of groups.values())try{
+  for(const members of groups.values())try{
+    const group=members.filter(item=>!item.picture),photos=members.filter(item=>item.picture);
     const anchors=group.filter(item=>item.data.anchor!==undefined);if(anchors.length!==1)throw Error('Missing or duplicated quote anchor.');
     const anchor=anchors[0],manifest=anchor.data.anchor,count=validateManifest(manifest);
     if(anchor.data.role!=='text'||anchor.data.part!==0||anchor.data.line!==0||group.length!==count||new Set(group.map(item=>item.shape)).size!==count)throw Error('Incomplete or duplicated quote lines.');
+    if(photos.length>(manifest.photo?1:0)||photos.some(item=>item.ambiguous||item.data.role!=='photo'||item.picture['p:nvPicPr']?.['p:cNvPr']?.name!==quotePhotoName(anchor.data.group)))throw Error('Invalid quote photo identity.');
     const ordered=manifest.parts.map(part=>Array(part.lines));
     for(const item of group){
       if(item.ambiguous)throw Error('Multiple source identities on one quote shape.');
@@ -77,13 +107,27 @@ export function importQuoteGroups(shapes,paragraphs,relationships,entries,report
     }
     const [body,footer]=ordered.map(lines=>sourceLineParagraphs(lines,paragraphs)[0].text),local=[];
     let quote={text:unwrap(body)};
+    // The body lines are one logical text: rich runs when any word is formatted differently from the rest.
+    // Only a rich export records the body's own look (tag.base); a plain string quote stays a string.
+    const base=cleanBase(ordered[0][0]?.data.base);
+    const richParts=base?joinRichLines(ordered[0],readBody,(line,last)=>last?'':line.data.boundary==='hard'?(line.data.separator||'\n'):''):undefined;
+    const rich=richParts?unwrapQuoteRuns(headingValue(richParts,base)):undefined;
+    // Only when it reads as the same words as the plain path (the native text is authoritative).
+    if(Array.isArray(rich)&&rich.map(run=>typeof run==='string'?run:run.text).join('')===quote.text)quote={text:rich};
     if(footer)quote={...quote,...footerFields(footer,manifest.footer,diagnostic=>local.push(diagnostic))};
+    // The headshot is the current native picture; a deleted or unreadable one is reported, never invented.
+    if(manifest.photo){
+      const image=photos[0]?readPicture(photos[0].picture)?.payload?.image:undefined;
+      if(image)quote={...quote,photo:image};
+      else local.push({code:'quote-photo-missing',message:"The quote's headshot picture is missing or unreadable; the quote is imported without a photo."});
+    }
     if(manifest.shorthand&&Object.keys(quote).length===1)quote=quote.text;
-    if(!validatePresentation({slides:[{quote}]}).valid)throw Error('Current native text does not form a valid quote.');
+    if(!isValidFormat({slides:[{quote}]}))throw Error('Current native text does not form a valid quote.');
     for(const item of group)consumed.add(item.shape);
-    items.push({shapes:group.map(item=>item.shape),payload:{type:'quote',quote}});
+    for(const item of photos)consumedPictures.add(item.picture);
+    items.push({shapes:group.map(item=>item.shape),pictures:photos.map(item=>item.picture),payload:{type:'quote',quote}});
     for(const diagnostic of local)report(diagnostic);
-    report({code:'quote-import-reflow',message:'Quote text, attribution and source were recovered from the current native text. Native formatting, positions and font theme are not reconstructed; review the reflowed quote.'});
+    report({code:'quote-import-reflow',message:'Quote text, attribution, role, source and photo were recovered from the current native text and picture. Native formatting, positions and font theme are not reconstructed; review the reflowed quote.'});
   }catch(error){report({code:'invalid-quote-provenance',message:`${error.message} Ordinary import retains current native text without restoring old source words.`});}
-  return {consumed,items};
+  return {consumed,consumedPictures,items};
 }

package/dist/rich-heading.js

@@ -0,0 +1,119 @@
+// Rich headline text on import (FA-10): the title, subtitle, tag and quote body as `string | TextRun[]`.
+//
+// A heading or quote body is read from its current native runs, the way body text is (src/body-text-import.js): formatting that
+// is only the heading's own look (the size, family, weight and colour every run of it shares) is not authored run style, so a
+// uniform heading is a plain string and a heading with a differently formatted word is TextRun[] that carries only what
+// differs. Links are content, never defaults. Tagged line shapes (the export writes one native text box per laid-out line)
+// are joined with the boundaries their tags record; soft wraps insert nothing and hard boundaries keep their separator.
+
+import {splitWeightFace} from './font-weights.js';
+
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+// The run properties that describe how a heading looks. `link` and `text` are never defaults.
+const LOOK = ['bold', 'italic', 'underline', 'strikethrough', 'superscript', 'subscript', 'fontSize', 'fontFamily', 'color', '_opfScheme'];
+
+const asParts = value => Array.isArray(value) ? value : value === undefined ? [] : [value];
+
+/**
+ * The raw runs of an ordered group of native line shapes. `readBody(shapeIndex)` is the native body reader (paragraphs with
+ * `richText`); `separatorOf(item, last)` is the text between this line and the next ('' for a soft wrap). Returns undefined when a
+ * shape has no readable body, so the caller keeps the plain text path.
+ */
+export function joinRichLines(ordered, readBody, separatorOf) {
+  const parts = [];
+  for (const [position, item] of ordered.entries()) {
+    const body = readBody?.(item.index);
+    if (!Array.isArray(body) || !body.length) return undefined;
+    body.forEach((paragraph, index) => {
+      if (index) parts.push('\n');
+      parts.push(...asParts(paragraph.richText ?? paragraph.text));
+    });
+    const separator = separatorOf(item, position === ordered.length - 1);
+    if (separator) parts.push(separator);
+  }
+  return parts;
+}
+
+const styleKey = run => JSON.stringify(Object.keys(run).filter(key => key !== 'text').sort().map(key => [key, run[key]]));
+const BOOLEANS = ['bold', 'italic', 'underline', 'strikethrough', 'superscript', 'subscript'];
+const sameColor = (a, b) => typeof a === 'string' && typeof b === 'string' && a.slice(0, 7).toUpperCase() === b.slice(0, 7).toUpperCase();
+const sameFamily = (a, b) => typeof a === 'string' && typeof b === 'string' && (a.trim().toLowerCase() === b.trim().toLowerCase() || splitWeightFace(b)?.family.toLowerCase() === a.trim().toLowerCase());
+// Whether a run's value for a look property is the heading's own default (what the exporter wrote on every run).
+const isDefault = {
+  bold: (value, base) => value === base.bold,
+  color: (value, base) => sameColor(value, base.color),
+  fontSize: (value, base) => Number.isFinite(value) && Math.abs(value - base.fontSize) <= 0.011,
+  fontFamily: (value, base) => sameFamily(value, base.fontFamily)
+};
+
+/**
+ * `string | TextRun[]` for raw runs. Formatting that is only the heading's own look is not authored run style:
+ * - with `base` (the defaults a tagged export recorded: `{bold, color, fontSize, fontFamily}`) a run's value equal to its default is removed;
+ * - without it (a native shape) a value every run shares is removed;
+ * - a false flag is the absence of the style (a `bold: false` is kept only where the heading is bold by default).
+ * Adjacent runs left with the same formatting merge; no remaining formatting is a plain string. Links are content and are kept.
+ */
+export function headingValue(parts, base) {
+  const runs = parts.map(part => typeof part === 'string' ? {text: part} : {...part}).filter(run => typeof run.text === 'string' && run.text !== '');
+  if (!runs.length) return '';
+  const defaults = base && typeof base === 'object' ? base : undefined;
+  // A hyperlink run is drawn underlined natively; that is the link's look, not an authored underline.
+  for (const run of runs) if (run.link !== undefined && run.underline === true) delete run.underline;
+  // PowerPoint writes no b attribute for a run that is not bold, so where the heading is bold by default an unmarked run is a lighter one.
+  const lineBreak = run => /^[\r\n]+$/.test(run.text);
+  if (defaults?.bold === true) for (const run of runs) if (run.bold !== true && !lineBreak(run)) run.bold = false;
+  for (const key of LOOK) {
+    if (!runs.some(run => run[key] !== undefined)) continue;
+    if (defaults && isDefault[key] && defaults[key === 'fontFamily' ? 'fontFamily' : key] !== undefined) {
+      for (const run of runs) if (run[key] !== undefined && isDefault[key](run[key], defaults)) delete run[key];
+    } else if (!defaults) {
+      // A bare line break between paragraphs carries no formatting of its own and does not count against uniformity.
+      const styled = runs.filter(run => !lineBreak(run));
+      const first = JSON.stringify(styled[0]?.[key]);
+      if (styled.length && styled[0][key] !== undefined && styled.every(run => run[key] !== undefined && JSON.stringify(run[key]) === first)) for (const run of runs) delete run[key];
+    }
+  }
+  for (const key of BOOLEANS) {
+    if (key === 'bold' && (defaults?.bold === true || runs.some(run => run.bold === true))) continue;
+    for (const run of runs) if (run[key] === false) delete run[key];
+  }
+  for (const run of runs) if (run._opfScheme !== undefined && run.color === undefined) delete run._opfScheme;
+  const merged = [];
+  for (const run of runs) {
+    const last = merged.at(-1);
+    if (last && styleKey(last) === styleKey(run)) last.text += run.text;
+    else merged.push(run);
+  }
+  if (merged.every(run => Object.keys(run).length === 1)) return merged.map(run => run.text).join('');
+  return merged.map(run => Object.keys(run).length === 1 ? run.text : run);
+}
+
+/** Remove the opening and closing quotation mark an exported quote body carries (core joins them to the first and last run). */
+export function unwrapQuoteRuns(value) {
+  if (!Array.isArray(value)) return typeof value === 'string' && value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+  const text = run => typeof run === 'string' ? run : run.text;
+  if (!value.length || !text(value[0]).startsWith('"') || !text(value.at(-1)).endsWith('"') || (value.length === 1 && text(value[0]).length < 2)) return value;
+  const runs = value.map(run => typeof run === 'string' ? run : {...run});
+  const edit = (index, change) => {
+    const run = runs[index];
+    if (typeof run === 'string') runs[index] = change(run); else run.text = change(run.text);
+  };
+  edit(0, text => text.slice(1));
+  edit(runs.length - 1, text => text.slice(0, -1));
+  const kept = runs.filter(run => text(run) !== '');
+  if (!kept.length) return '';
+  return kept.every(run => typeof run === 'string') ? kept.join('') : kept;
+}
+
+export const isRichValue = value => Array.isArray(value) && value.some(run => object(run));
+
+/** The recorded defaults of a rich heading or quote body, kept only where each value has the expected type. */
+export function cleanBase(raw) {
+  if (!object(raw)) return undefined;
+  const base = {};
+  if (typeof raw.bold === 'boolean') base.bold = raw.bold;
+  if (typeof raw.color === 'string' && /^#[0-9a-f]{6}$/i.test(raw.color)) base.color = raw.color;
+  if (Number.isFinite(raw.fontSize) && raw.fontSize > 0 && raw.fontSize < 10000) base.fontSize = raw.fontSize;
+  if (typeof raw.fontFamily === 'string' && raw.fontFamily.length > 0 && raw.fontFamily.length <= 200) base.fontFamily = raw.fontFamily;
+  return Object.keys(base).length ? base : undefined;
+}

package/dist/run-colors.js

@@ -46,10 +46,13 @@ export function slideRunSlots(slide) {
     if (Array.isArray(value)) for (const run of value) slots.push(object(run) ? run : null);
     else if (typeof value === 'string') slots.push(null);
   };
+  // FA-10: the heading group (tag, title, subtitle) comes first, when it is TextRun[].
+  for (const field of ['tag', 'title', 'subtitle']) if (Array.isArray(slide[field])) runs(slide[field]);
   for (const leaf of leaves(slide)) {
     for (const field of ROOT_PAYLOAD_FIELDS) {
       const value = leaf[field];
       if (field === 'text') { if (Array.isArray(value)) runs(value); }
+      else if (field === 'quote') { if (object(value) && Array.isArray(value.text)) runs(value.text); }
       else if ((field === 'items' || field === 'bullets') && Array.isArray(value)) {
         for (const item of value) {
           if (Array.isArray(item) || typeof item === 'string') runs(item);

package/dist/script-fonts.js

@@ -4,38 +4,21 @@
 // reads it back on import. Design: core docs/programs/font-fidelity-everywhere/
 // script-font-model.md ("OOXML mapping").
 //
-// Core releases before the resolver (0.11.0 and earlier) export no
-// resolveScriptFonts. The exporter then writes exactly what it wrote before
-// FF-07 (lang="en-US", empty theme ea/cs, no rtl) and reports
-// `language-export-unavailable` for a document that names a language. A core
-// with the resolver but without paragraphDirection() marks no paragraph
-// direction and reports `paragraph-direction-unavailable` for an RTL deck.
-import * as opfCore from "@openpresentation/opf";
-
-const resolver = typeof opfCore.resolveScriptFonts === "function" ? opfCore.resolveScriptFonts : null;
-// RR-05: authored alignment is logical for right-to-left text (`left` is the start edge). Core owns the rule; a core without it
-// reports no line directions either, so the fallback never has anything to flip.
-export const physicalAlignment = typeof opfCore.physicalAlignment === "function" ? opfCore.physicalAlignment : alignment => alignment;
-// The one paragraph-direction rule shared with the renderer (core FF-07).
-const paragraphDirection = typeof opfCore.paragraphDirection === "function" ? opfCore.paragraphDirection : null;
+// When the resolver throws for a deck, the exporter writes what it wrote before FF-07 (lang="en-US", empty theme ea/cs, no
+// rtl) and reports `language-export-unavailable`.
+import {paragraphDirection, physicalAlignment, resolveScriptFonts as resolver} from "@openpresentation/opf/composition";
 
-const SCRIPT_SLOTS = [["ea", "eastAsian"], ["cs", "complexScript"]];
+// RR-05: authored alignment is logical for right-to-left text (`left` is the start edge). Core owns the rule, and the
+// paragraph-direction rule is the one the renderer shares (core FF-07).
+export {physicalAlignment};
 
-/** Whether the installed core exports the FF-18 language/script resolver. */
-export function scriptFontsAvailable() {
-  return resolver !== null;
-}
+const SCRIPT_SLOTS = [["ea", "eastAsian"], ["cs", "complexScript"]];
 
 /**
  * Resolve the deck (slide 0, which also sets the theme) and every slide.
- * Returns null when core has no resolver.
+ * Returns null when the resolver throws for the deck.
  */
 export function planScriptFonts(presentation, report) {
-  if (!resolver) {
-    if (presentation.language !== undefined) report?.({code: "language-export-unavailable", path: "language",
-      message: "The installed @openpresentation/opf has no resolveScriptFonts, so the PPTX keeps lang=\"en-US\", empty theme East Asian/complex-script fonts and left-to-right paragraphs. Use a core release with the FF-18 language model."});
-    return null;
-  }
   const count = Array.isArray(presentation.slides) ? presentation.slides.length : 0;
   let slides, deck;
   try {
@@ -51,15 +34,63 @@ export function planScriptFonts(presentation, report) {
     report?.({code: "language-unresolved", path: "language",
       message: `The presentation language could not be resolved locally (a URL, pkg: reference or unknown id), so the PPTX uses ${deck.lang}.`});
   }
-  let rtl = deck.rtl;
-  if (rtl && !paragraphDirection) {
-    rtl = false;
-    report?.({code: "paragraph-direction-unavailable", path: "language",
-      message: "The installed @openpresentation/opf has no paragraphDirection, so right-to-left paragraphs are not marked; the preview and export must share that rule. Use a core release that exports it."});
-  }
   // opf-pptx#168: which slides have notes (a presentation has one notes master; see reportPerSlideNotesScriptFonts).
   const notes = (presentation.slides ?? []).map(slide => typeof slide?.notes === "string" ? slide.notes.trim() !== "" : Boolean(slide?.notes));
-  return {deck, slides, notes, report, lang: deck.lang, rtl, contentEastAsian: contentEastAsianFonts(presentation, deck, report)};
+  return {deck, slides, notes, report, lang: deck.lang, rtl: deck.rtl, presentation, contentEastAsian: contentEastAsianFonts(presentation, deck, report)};
+}
+
+/**
+ * FA-13: the OOXML tag a run's own `lang` (TextRun.lang) is written with: core's curated tag for the language (fr becomes
+ * fr-FR), or undefined when it is the deck language (the run then follows the deck). Without a plan the tag is written as given.
+ */
+export function runLanguageTag(plan, tag) {
+  if (typeof tag !== "string" || !tag) return undefined;
+  if (!plan) return tag.toLowerCase() === "en-us" ? undefined : tag;
+  const cache = plan.runLanguages ??= new Map();
+  if (!cache.has(tag)) {
+    let lang = tag;
+    try {
+      const resolved = resolver(plan.presentation, {language: tag});
+      if (resolved.languageSource !== "default") lang = resolved.lang;
+    } catch { /* an unresolvable tag is written as given */ }
+    cache.set(tag, lang.toLowerCase() === String(plan.lang).toLowerCase() ? undefined : lang);
+  }
+  return cache.get(tag);
+}
+
+/**
+ * FA-13: a run with its own language (TextRun.lang) names the East Asian and complex-script faces of that language, so a Han
+ * run tagged ja-JP draws in the Japanese face and one tagged zh-CN in the Simplified Chinese face, as the preview does. Only a
+ * slot with a script-specific font for the run's language is written; every other run keeps following the theme. Runs the
+ * exporter writes carry no ea/cs of their own (stripRunScriptFonts), so this runs after that strip. `xml` is a slide part.
+ */
+export function runLanguageFonts(xml, plan, slideIndex) {
+  if (!plan || !xml.includes(' altLang="en-US"')) return xml;
+  return xml.replace(/<p:(sp|graphicFrame)>[\s\S]*?<\/p:\1>/g, shape => {
+    const heading = /<p:cNvPr\b[^>]*\bname="OPF heading /.test(shape);
+    return shape.replace(OWN_LANGUAGE_RUN, (run, lang) => {
+      const resolved = runScriptPlan(plan, slideIndex, lang);
+      if (!resolved) return run;
+      const slots = heading ? resolved.heading : resolved.body;
+      const latin = /<a:latin typeface="([^"]*)"/.exec(run)?.[1];
+      const insert = SCRIPT_SLOTS.map(([element, slot]) => {
+        const face = slots?.[slot];
+        return resolved.sources?.[slot] !== "latin" && face && escapeAttribute(face) !== latin && !new RegExp(`<a:${element}\\b`).test(run) ? `<a:${element} typeface="${escapeAttribute(face)}"/>` : "";
+      }).join("");
+      return insert ? run.replace(/(<a:latin\b[^>]*\/>)/, `$1${insert}`) : run;
+    });
+  });
+}
+
+/** The script fonts of one slide for a run language (FA-13), memoized; undefined when the language cannot be resolved. */
+function runScriptPlan(plan, slideIndex, lang) {
+  const cache = plan.runScripts ??= new Map(), key = `${slideIndex}|${lang}`;
+  if (!cache.has(key)) {
+    let resolved;
+    try { resolved = resolver(plan.presentation, {slideIndex, language: lang}); } catch { resolved = undefined; }
+    cache.set(key, resolved && resolved.languageSource !== "default" ? resolved : undefined);
+  }
+  return cache.get(key);
 }
 
 // ---------------------------------------------------------------------------
@@ -274,7 +305,9 @@ function runScriptFonts(xml, resolved, headingShape) {
   });
 }
 
-const RUN_LANGUAGE = /(<a:(?:rPr|endParaRPr|defRPr)\b[^>]*?\slang=")en-US(")/g;
+// A run with its own language (TextRun.lang, FA-13) is written with an altLang attribute; the deck language never replaces it.
+const RUN_LANGUAGE = /(<a:(?:rPr|endParaRPr|defRPr)\b[^>]*?\slang=")en-US("(?! altLang="))/g;
+const OWN_LANGUAGE_RUN = /<a:rPr\b[^>]*?\slang="([^"]+)" altLang="en-US"[^>]*[^/]>[\s\S]*?<\/a:rPr>/g;
 
 const decodeText = value => value.replace(/&(?:#(\d+)|#x([0-9a-f]+)|(amp|lt|gt|quot|apos));/gi, (entity, decimal, hex, name) =>
   decimal ? String.fromCodePoint(Number(decimal)) : hex ? String.fromCodePoint(parseInt(hex, 16)) : {amp: "&", lt: "<", gt: ">", quot: "\"", apos: "'"}[name.toLowerCase()]);
@@ -397,8 +430,7 @@ const attribute = (xml, name) => new RegExp(`\\s${name}="([^"]*)"`).exec(xml)?.[
  * used when that record exports exactly this tag again: an exact BCP-47 tag,
  * then a curated `ooxmlLang` (preferring the same primary language). A tag
  * that core still resolves to a catalog record (for example en-NZ to English)
- * is imported as the tag itself, so it round-trips. Without core's resolver,
- * a record whose tag is the primary language alone is accepted too.
+ * is imported as the tag itself, so it round-trips.
  * Returns {language, record, shared} or null when nothing matches.
  */
 export function matchCatalogLanguage(lang, catalogs) {
@@ -406,19 +438,15 @@ export function matchCatalogLanguage(lang, catalogs) {
   const key = lang.toLowerCase(), primary = key.split("-")[0];
   const lower = value => typeof value === "string" ? value.toLowerCase() : undefined;
   const shared = records.filter(record => lower(record.bcp47) === key || lower(record.ooxmlLang) === key);
-  const exports = record => !resolver || resolver({language: record.id}).lang.toLowerCase() === key;
+  const exports = record => resolver({language: record.id}).lang.toLowerCase() === key;
   const record = shared.find(record => lower(record.bcp47) === key && exports(record))
     ?? shared.find(record => lower(record.bcp47)?.split("-")[0] === primary && exports(record))
     ?? shared.find(exports);
   if (record) return {language: record.id, record, shared};
-  if (resolver) {
-    const resolved = resolver({language: lang});
-    // A tag core cannot resolve falls back to its default language; that is no match.
-    const matched = resolved.languageSource !== "default" && resolved.languageId && records.find(candidate => candidate.id === resolved.languageId);
-    return matched ? {language: lang, record: matched, shared: []} : null;
-  }
-  const byPrimary = records.find(candidate => lower(candidate.bcp47) === primary);
-  return byPrimary ? {language: byPrimary.id, record: byPrimary, shared: []} : null;
+  const resolved = resolver({language: lang});
+  // A tag core cannot resolve falls back to its default language; that is no match.
+  const matched = resolved.languageSource !== "default" && resolved.languageId && records.find(candidate => candidate.id === resolved.languageId);
+  return matched ? {language: lang, record: matched, shared: []} : null;
 }
 
 /**
@@ -454,7 +482,7 @@ export function observeLanguage({slides, theme, themePath, slideThemes, catalogs
  */
 export function reconcileLanguage(groups, observed, report) {
   const index = groups.findIndex(item => item.field === "language");
-  if (index < 0 || observed.lang === undefined || !resolver) return groups;
+  if (index < 0 || observed.lang === undefined) return groups;
   const stored = groups[index].ops.find(op => op.path?.length === 1 && op.path[0] === "language")?.value;
   if (stored === undefined) return groups;
   const resolved = resolver({language: stored});
@@ -474,7 +502,7 @@ export function reconcileLanguage(groups, observed, report) {
 /** Whether the language observed in the runs is written right to left. */
 export function observedRtl(observed) {
   if (observed.lang === undefined) return false;
-  try { return resolver ? resolver({language: observed.language}).rtl === true : observed.match?.record.direction === "rtl"; } catch { return false; }
+  try { return resolver({language: observed.language}).rtl === true; } catch { return false; }
 }
 
 export function languageDiagnostics(imported, observed, report) {
@@ -488,7 +516,7 @@ export function languageDiagnostics(imported, observed, report) {
   const languages = observedRtl(observed) ? ranked.filter(([tag]) => tag === lang || tag !== "en-US") : ranked;
   if (languages.length > 1) {
     report({code: "mixed-run-languages", path: "language",
-      message: `Runs use ${languages.length} languages (${languages.map(([tag, count]) => `${tag} x${count}`).join(", ")}). OPF has one presentation language, so ${lang} was imported.`});
+      message: `Runs use ${languages.length} languages (${languages.map(([tag, count]) => `${tag} x${count}`).join(", ")}). OPF has one presentation language, so ${lang} was imported; a run in another language keeps it as its own lang where the text imports as rich text.`});
   }
   const kept = imported.language === observed.language;
   if (kept && !match) report({code: "language-uncatalogued", path: "language", message: `Run language ${lang} matches no languages catalog record; it was imported as a BCP-47 tag.`});
@@ -496,14 +524,13 @@ export function languageDiagnostics(imported, observed, report) {
     report({code: "language-ambiguous", path: "language",
       message: `Run language ${lang} is the OOXML tag of ${match.shared.map(record => record.id).join(", ")}; ${match.language} was imported.`});
   }
-  const resolved = resolver ? resolver(imported) : null;
-  const rtl = resolved ? resolved.rtl : match?.record.direction === "rtl";
-  if (rtlParagraphs && !rtl) {
+  const resolved = resolver(imported);
+  if (rtlParagraphs && !resolved.rtl) {
     report({code: "rtl-language-mismatch", path: "language", message: `${rtlParagraphs} right-to-left paragraph(s) do not match the left-to-right language ${typeof imported.language === "string" ? imported.language : lang}; paragraph direction is not imported separately.`});
   }
   // The presentation theme carries the first slide's script fonts (planScriptFonts), so it is compared with that slide.
   let themeResolved = resolved;
-  if (resolver && imported.slides?.length) { try { themeResolved = resolver(imported, {slideIndex: 0}); } catch { themeResolved = resolved; } }
+  if (imported.slides?.length) { try { themeResolved = resolver(imported, {slideIndex: 0}); } catch { themeResolved = resolved; } }
   if (theme && themeResolved) {
     for (const {tag, slot, face} of themeScriptMismatches(theme, themeResolved)) {
       report({code: "script-font-not-imported", path: "design.fontScheme",
@@ -511,7 +538,7 @@ export function languageDiagnostics(imported, observed, report) {
     }
   }
   // opf-pptx#168: a slide on another slide master carries its own script fonts in that master's theme.
-  if (resolver && Array.isArray(observed.slideThemes)) {
+  if (Array.isArray(observed.slideThemes)) {
     observed.slideThemes.forEach((slideTheme, index) => {
       if (!slideTheme || slideTheme.path === observed.themePath) return;
       let slideResolved;
@@ -553,8 +580,8 @@ export function stripRunScriptFonts(xml) {
 }
 
 /**
- * Without core's resolver the theme's East Asian slot still repeats the latin family of its font group, which keeps
- * the paragraph end marks from reading an empty font (see themeScriptFonts).
+ * When the resolver throws for a deck (see planScriptFonts) the theme's East Asian slot still repeats the latin family of
+ * its font group, which keeps the paragraph end marks from reading an empty font (see themeScriptFonts).
  */
 export function themeEastAsianFromLatin(xml) {
   return xml.replace(/<a:(majorFont|minorFont)>[\s\S]*?<\/a:\1>/g, block => {

package/dist/theme-colors.js

@@ -36,7 +36,7 @@ const VENDOR_VALUES = new Set(['tx1', 'tx2', 'bg1', 'bg2', 'accent1', 'accent2',
 const ROLE_SLOTS = Object.freeze({
   primary: ['accent1'],
   secondary: ['accent2'],
-  accent: ['accent1', 'accent3'],
+  accent: ['accent3'],
   text: ['dark1', 'light1'],
   textSecondary: ['dark2', 'light2'],
   surface: ['light2', 'dark2'],