@openpresentation/opf-pptx 0.11.2 → 0.11.4

package/dist/index.d.ts

@@ -39,13 +39,28 @@ export interface MediaProvenanceDiagnostic { code: "media-provenance-omitted"; p
 export interface ChartDataUnplottableDiagnostic { code: "chart-data-unplottable"; path: string; message: string; reason: "data-not-inline" | "no-rows" | "no-columns" | "single-column-not-numeric" }
 /** Content with no PowerPoint export (an empty table, an unsupported payload) is replaced by a plain-language placeholder frame. */
 export interface ContentPlaceholderDiagnostic { code: "content-placeholder"; path: string; message: string; reason: "table-has-no-rows" | "unsupported-payload" }
-/** The chart data was reshaped to export a native chart: a histogram's values were binned, or a single value column was plotted against row numbers. */
 export interface WatermarkNotExportedDiagnostic { code: "watermark-not-exported"; path: string; message: string }
-export interface ChartDataAdaptedDiagnostic { code: "chart-data-adapted"; path: string; message: string; adaptation: "histogram-binned" | "row-numbers" }
+/**
+ * The chart data was reshaped to export a native chart: a single value column was plotted against row numbers; a one-series construct
+ * (pie, doughnut, and with `chartex: "native"` treemap, histogram, pareto, waterfall, funnel, map) kept only its first series; by default
+ * a chartex chart type was written as a clustered column chart (`chartex-fallback`) and a one-column histogram was binned into counts
+ * (`histogram-binned`).
+ */
+export interface ChartDataAdaptedDiagnostic { code: "chart-data-adapted"; path: string; message: string; adaptation: "histogram-binned" | "row-numbers" | "series-dropped" | "chartex-fallback" }
+/** With `chartex: "native"`, a map chart (`world`) is exported as a chartex regionMap without cached geography: PowerPoint fetches the region shapes from Bing Maps online, so the map may show no regions offline. */
+export interface ChartMapGeodataDiagnostic { code: "chart-map-geodata"; path: string; message: string }
 
 export interface ToPptxOptions {
   /** Default compatible converts WebP to a static PNG. Preserve embeds original WebP bytes. */
   imageFormat?: "compatible" | "preserve";
+  /**
+   * How the chartex chart types (treemap, histogram, pareto, box-and-whisker, waterfall, funnel, world) are exported.
+   * "fallback" (default) writes the clustered column chart of the data and reports `chart-data-adapted` (`chartex-fallback`,
+   * `histogram-binned`). "native" writes Office 2016 chartex parts (`cx:chartSpace`, style parts, an `mc:AlternateContent`
+   * frame with the clustered column chart as fallback). Native chartex is opt-in pending native PowerPoint confirmation (FF-22b);
+   * the default flips once that check passes. Import of chartex parts is always on.
+   */
+  chartex?: "native" | "fallback";
   /**
    * OPF_DOCUMENT_V1 / OPF_SLIDE_V1 customer-data tags that let fromPptx restore
    * catalog references, layout ids and authoring metadata (docs/document-roundtrip.md).
@@ -58,7 +73,7 @@ export interface ToPptxOptions {
   /** Match preview/pagination clearance around supplied vector text outlines; default 1. */
   textRasterPadding?: number;
   /** Layout diagnostics, `media-provenance-omitted` when video data cannot be stored, plus `unresolved-font-scheme` (once per reference path) when a font-scheme id matches no record and the default `aptos` scheme is used as the base. */
-  onDiagnostic?: (diagnostic: LayoutDiagnostic | FontSchemeDiagnostic | MediaProvenanceDiagnostic | ChartDataUnplottableDiagnostic | ChartDataAdaptedDiagnostic | ContentPlaceholderDiagnostic | WatermarkNotExportedDiagnostic) => void;
+  onDiagnostic?: (diagnostic: LayoutDiagnostic | FontSchemeDiagnostic | MediaProvenanceDiagnostic | ChartDataUnplottableDiagnostic | ChartDataAdaptedDiagnostic | ChartMapGeodataDiagnostic | ContentPlaceholderDiagnostic | WatermarkNotExportedDiagnostic) => void;
   baseDir?: string;
   compressionLevel?: number;
   imageResolver?: (src: string, context: ImageResolverContext) => ImageResolverResult | Promise<ImageResolverResult | null | undefined> | null | undefined;

package/dist/index.js

@@ -4,6 +4,7 @@ import {importTableFrames} from './table-import.js';
 import {applyChartFonts, applyPitchFamilies, finalizeFontsUsed, fontPitchFamilies} from './package-fonts.js';
 import {readChartCategoryHeading,writeChartCategoryHeading} from './chart-workbook.js';
 import {CHARTEX_FALLBACK,resolveChartType,chartTypeFromNative,applyChartConstruct,NATIVE_CHART_ELEMENTS} from './chart-types.js';
+import {attachChartexParts,chartFromChartex,CHARTEX_GRAPHIC_DATA_URI} from './chartex.js';
 import {attachCodeTags, codeManifest, importCodeGroups, nativeShapeParagraphs, nativeTextShapes} from './code-provenance.js';
 import {attachMetricTags,metricManifest,importMetricGroups} from './metric-provenance.js';
 import {attachCardTags,importCardFrames} from './card-provenance.js';
@@ -11,6 +12,7 @@ import {attachMediaTags,importMediaGroups,mediaCaption,mediaFrameRecord,mediaTex
 import {attachHeadingTags,importHeadingGroups} from './heading-provenance.js';
 import {attachPlainTextTags,importPlainTextGroups} from './text-provenance.js';
 import {attachTimelineTags,timelineManifest,importTimelineGroups} from './timeline-provenance.js';
+import {attachQuoteTags,quoteManifest,importQuoteGroups} from './quote-provenance.js';
 import {attachFurnitureTags, furnitureManifest, importFurniture, staticDateFallback} from './furniture-provenance.js';
 import {applyDocumentProvenance, attachDocumentProvenance, documentProvenance, restoreDocumentProvenance} from './document-provenance.js';
 import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType} from './furniture-fields.js';
@@ -217,6 +219,7 @@ export async function toPptx(input, options = {}) {
   context.headingTags = new Map();
   context.plainTextTags = new Map();
   context.timelineTags = new Map();
+  context.quoteTags = new Map();
   context.furnitureTags = new Map();
   context.furnitureFields = new Map();
   context.furnitureManifests = new Map();
@@ -224,7 +227,14 @@ export async function toPptx(input, options = {}) {
   context.metricTags = new Map();
   context.chartHeadings = new Map();
   context.chartFonts = new Map();
+  context.chartex = new Map();
   context.imageFormat = options.imageFormat ?? "compatible";
+  // Native chartex parts are opt-in until the native PowerPoint check confirms them (FF-22b); the default keeps the
+  // clustered column export of the chartex chart types.
+  if (options.chartex !== undefined && !['native', 'fallback'].includes(options.chartex)) {
+    throw new OPFPptxError('invalid-chartex-mode', 'chartex must be native or fallback.', {path: 'options.chartex'});
+  }
+  context.chartexMode = options.chartex ?? 'fallback';
   Object.assign(context, exportTheme(presentation, context));
   context.reportedFontSchemes = new Set();
   // Document references and metadata tags (FF-32, docs/document-roundtrip.md).
@@ -512,6 +522,7 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
     }),
     diagnostic => options.onDiagnostic?.({...diagnostic, path: slideImagePath}));
   if (slideImage.design) slide.design = {...slide.design, ...slideImage.design};
+  if (slideImage.image) slide.image = slideImage.image;
   nativeContext.slideImagePictures = slideImage.consumed;
   nativeContext.slideImageShapes = slideImage.consumedShapes;
   const watermarkPath = `slides.${slideIndex}.design.watermark`;
@@ -576,6 +587,7 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
   const headings=importHeadingGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
   const plainText=importPlainTextGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
   const timelines=importTimelineGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
+  const quotes=importQuoteGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.quote`}));
   for(const group of [...headings.items,...plainText.items]) {
     const item=importShape(group.shapes[0],dimensions,group.paragraphs,true);
     if(item){
@@ -589,12 +601,17 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     let union;for(const bound of bounds){if(!union)union={...bound};else{const x=Math.min(union.x,bound.x),y=Math.min(union.y,bound.y);union={x,y,w:Math.max(union.x+union.w,bound.x+bound.w)-x,h:Math.max(union.y+union.h,bound.y+bound.h)-y};}}
     items.push({kind:'timeline',sourceText:true,bounds:union,payload:group.payload});
   }
+  for(const group of quotes.items){
+    const bounds=group.shapes.map(shape=>shapeBounds(shape['p:spPr']?.['a:xfrm'])).filter(Boolean);
+    let union;for(const bound of bounds){if(!union)union={...bound};else{const x=Math.min(union.x,bound.x),y=Math.min(union.y,bound.y);union={x,y,w:Math.max(union.x+union.w,bound.x+bound.w)-x,h:Math.max(union.y+union.h,bound.y+bound.h)-y};}}
+    items.push({kind:'quote',bounds:union,payload:group.payload});
+  }
   for (const item of code.items) items.push({kind:'code',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload});
   for (const item of metric.items) items.push({kind:'metric',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload});
   for (const item of media.items) items.push({kind:'media',sourceText:item.payload.type==='text',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload});
   for (const [index,shape] of shapes.entries()) {
     if (furniture.text.has(index) || nativeContext.slideImageShapes?.has(index)) continue;
-    if (code.consumed.has(shape)||metric.consumed.has(shape)||cards.has(shape)||media.consumed.has(shape)||headings.consumed.has(shape)||plainText.consumed.has(shape)||timelines.consumed.has(shape)) continue;
+    if (code.consumed.has(shape)||metric.consumed.has(shape)||cards.has(shape)||media.consumed.has(shape)||headings.consumed.has(shape)||plainText.consumed.has(shape)||timelines.consumed.has(shape)||quotes.consumed.has(shape)) continue;
     const ordinaryBody = Object.hasOwn(shape, 'p:txBody') && !shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'];
     const item = importShape(shape, dimensions, paragraphs[index], ordinaryBody || furniture.taggedText.has(index) || media.captionShapes.has(shape));
     if (item && ordinaryBody) item.readNativeBody = () => readBody(index);
@@ -613,6 +630,15 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     const item = importGraphicFrame(entries, frame, slidePath, relationships, tables[index]);
     if (item) items.push(item);
   }
+  // A chartex chart is an mc:AlternateContent: the choice frame references the cx:chartSpace part; the fallback is a classic chart frame
+  // (this exporter) or a text shape (PowerPoint). The choice is read first and the fallback only when it names no OPF chart type.
+  for (const alternate of asArray(tree?.["mc:AlternateContent"])) {
+    const choice = asArray(alternate?.["mc:Choice"]).map((node) => node?.["p:graphicFrame"]).find(Boolean);
+    const fallback = asArray(alternate?.["mc:Fallback"]).map((node) => node?.["p:graphicFrame"]).find(Boolean);
+    const chosen = choice ? importGraphicFrame(entries, choice, slidePath, relationships) : null;
+    const item = chosen?.payload?.type === "chart" ? chosen : fallback ? importGraphicFrame(entries, fallback, slidePath, relationships) : chosen;
+    if (item && item.kind !== "unknown") items.push(item);
+  }
 
   for (const [index, picture] of nativeContext.pictures.entries()) {
     if (furniture.pictures.has(index) || nativeContext.slideImagePictures?.has(index) || nativeContext.watermarkPictures?.has(index)) continue;
@@ -668,9 +694,12 @@ function importGraphicFrame(entries, frame, slidePath, relationships, importedTa
     };
   }
 
-  const chartRelId = graphicData?.["c:chart"]?.["r:id"];
+  const chartExRelId = graphicData?.uri === CHARTEX_GRAPHIC_DATA_URI ? graphicData?.["cx:chart"]?.["r:id"] : undefined;
+  const chartRelId = graphicData?.["c:chart"]?.["r:id"] ?? chartExRelId;
   if (chartRelId) {
-    const chart = chartFromRelationship(entries, slidePath, relationships, chartRelId);
+    const chart = chartExRelId
+      ? chartexFromRelationship(entries, relationships, chartExRelId)
+      : chartFromRelationship(entries, slidePath, relationships, chartRelId);
     return {
       kind: "chart",
       bounds,
@@ -904,6 +933,23 @@ function scatterFromSeries(entries, chartPart, series, budget, cachePath) {
   return { type: "scatter", data: { columns: ["Point", readChartCategoryHeading(entries, chartPart) ?? "X", ...names], rows } };
 }
 
+// A chartex part (cx:chartSpace): the series layoutIds name the kept OPF chart
+// type and the cached dimensions restore the category-major data, under the
+// same bounds as the classic chart cache.
+function chartexFromRelationship(entries, relationships, relId) {
+  const relationship = relationships.get(relId);
+  if (!relationship?.path || !entries[relationship.path]) return null;
+  const doc = parseRequiredXml(entries, relationship.path);
+  return chartFromChartex(doc, {
+    heading: readChartCategoryHeading(entries, relationship.path),
+    limits: {points: MAX_CHART_CACHE_POINTS, cells: MAX_CHART_CACHE_CELLS},
+    path: relationship.path,
+    invalid: (message, location) => {
+      throw new OPFPptxError('invalid-chart-cache', `Invalid chart cache: ${message}. Repair the chart data before importing.`, {path: location ?? relationship.path});
+    }
+  });
+}
+
 function firstChartNode(plotArea) {
   // Map the native construct back to the kept OPF chart type id (FF-22).
   for (const element of NATIVE_CHART_ELEMENTS) {
@@ -1424,7 +1470,7 @@ async function addPayload(slide, presentation, payload, region, path, context, o
       addMetricPayload(slide, payload.metric,metricLayout,context,path);
       break;
     case "quote":
-      addQuotePayload(slide, quoteLayout, context, options, path);
+      addQuotePayload(slide, payload.quote, quoteLayout, context, options, path);
       break;
     case "timeline":
       addTimelinePayload(slide, payload.timeline, timelineLayout, context, options, path);
@@ -1604,7 +1650,9 @@ async function addSlideImage(slide, presentation, image, slideIndex, context, op
       : image.recolor?.type === 'duotone' ? { type: 'duotone', dark: paint(image.recolor.dark, '000000'), light: paint(image.recolor.light, 'FFFFFF') } : null,
     overlay: image.overlay ? { ...paint(image.overlay.color, context.colors.text), opacity: image.overlay.opacity, box: image.overlay.box, shape: image.overlay.shape } : null,
   };
-  context.slideImages.set(objectName, { slide: `slides.${slideIndex}`, box, fill: image.fill, path: image.sourcePath, treatment: { ...treatment, position: image.position }, effects });
+  // FF-53: a root `image` with the slide image's source is the slide image (core `replacesContent`); the
+  // manifest records that so an unchanged picture imports back as both design.slideImage and slide.image.
+  context.slideImages.set(objectName, { slide: `slides.${slideIndex}`, box, fill: image.fill, path: image.sourcePath, treatment: { ...treatment, position: image.position }, effects, content: image.replacesContent === true });
   slide.addImage({ ...resolved, objectName, ...box, altText: image.alt ?? assetAlt(image.value, presentation) });
   // The overlay scrim is a separate native shape directly above the picture.
   if (effects.overlay) {
@@ -1614,7 +1662,7 @@ async function addSlideImage(slide, presentation, image, slideIndex, context, op
 }
 
 function addChartPayload(slide, chart, region, context, options = {}, path = "chart") {
-  const chartData = toPptxChartData(chart);
+  const chartData = toPptxChartData(chart, context.chartexMode);
   if (!chartData.series) {
     // Never lose a chart silently: the placeholder frame stands in for it, and a diagnostic names the reason.
     options.onDiagnostic?.({code: "chart-data-unplottable", path, message: chartData.message, reason: chartData.reason});
@@ -1633,6 +1681,16 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   const circular = chartData.type === 'pie' || chartData.type === 'doughnut';
   context.chartHeadings.set(objectName,{heading:chartData.type === 'scatter' ? undefined : chartData.heading ?? chart.data.columns[0],labelColor,spec:chartData.spec});
   context.chartFonts.set(objectName,{heading:context.fonts.heading,body:context.fonts.body});
+  const palette = CHART_COLORS.map(color=>normalizeHex(chartColorForFill(panelFill,`#${color}`)));
+  if (chartData.chartex) {
+    // The native chartex part is added when the package is normalized (attachChartexParts); the classic chart below becomes its fallback.
+    // PptxGenJS rewrites the series it is given (labels become nested levels), so the chartex part keeps its own copy.
+    const series = chartData.series.map((entry) => ({name: entry.name, labels: [...entry.labels], values: [...entry.values]}));
+    context.chartex.set(objectName, {spec: chartData.chartex, series, hasCategories: chartData.hasCategories, fill, labelColor, gridColor: context.colors.border, font: context.fonts.body, palette});
+    if (chartData.chartex.layoutId === 'regionMap') {
+      options.onDiagnostic?.({code: "chart-map-geodata", path, message: `The '${stringifyText(chart.type)}' chart is exported as a native PowerPoint map (chartex regionMap) without cached geography: PowerPoint matches the category names to regions and fetches their shapes from Bing Maps when the deck is opened online, so the map shows no regions offline or where Office map data is disabled. The clustered column fallback shows the same values in other readers.`});
+    }
+  }
   const percent = chartData.spec.grouping === 'percentStacked';
   slide.addChart(chartData.type, chartData.series, {
     objectName,
@@ -1642,7 +1700,7 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     h: region.h,
     showLegend: circular || chartData.series.length > (chartData.type === 'scatter' ? 2 : 1),
     showTitle: false,
-    chartColors: CHART_COLORS.map(color=>normalizeHex(chartColorForFill(panelFill,`#${color}`))),
+    chartColors: palette,
     chartArea: {fill:{...fill},roundedCorners:false},
     // Paint alpha once in the chart area, rather than stacking two alpha fills.
     plotArea: {fill:{color:null}},
@@ -1785,12 +1843,13 @@ function addMeasuredPayloadText(slide, text, box, context, options, config) {
   for (const [index, line] of fit.lines.entries()) {
     const link = config.links?.[sourceLineIndex];
     if (fit.sourceLines?.[index]?.boundary === 'hard') sourceLineIndex += 1;
-    if (!line&&!config.heading&&!config.sourceText&&!config.timeline&&!config.keepEmpty) continue;
+    if (!line&&!config.heading&&!config.sourceText&&!config.timeline&&!config.quote&&!config.keepEmpty) continue;
     const alignment=fit.placement?.alignment??config.align??context.contentAlignment??'left',placed=fit.placement?.lines[index],factor=alignment==='right'?1:alignment==='center'?.5:0;
     const sourceLine=fit.sourceLines?.[index],boundary=sourceLine?{boundary:sourceLine.boundary,separator:String(text).slice(sourceLine.end,sourceLine.nextStart)}:{};
-    const objectName=config.heading?`OPF heading ${config.path} line ${index}`:config.timeline?`OPF timeline ${config.timeline.group} part ${config.timeline.part} line ${index}`:config.sourceText?`OPF text ${config.path} line ${index}`:config.objectName?`${config.objectName} line ${index}`:undefined;
+    const objectName=config.heading?`OPF heading ${config.path} line ${index}`:config.timeline?`OPF timeline ${config.timeline.group} part ${config.timeline.part} line ${index}`:config.quote?`OPF quote ${config.quote.group} part ${config.quote.part} line ${index}`:config.sourceText?`OPF text ${config.path} line ${index}`:config.objectName?`${config.objectName} line ${index}`:undefined;
     if(config.heading)context.headingTags.set(objectName,{v:1,group:config.path,field:config.heading,line:index,count:fit.lines.length,...boundary});
     else if(config.timeline)context.timelineTags.set(objectName,{v:1,role:'text',group:config.timeline.group,part:config.timeline.part,line:index,count:fit.lines.length,...boundary,...(config.timeline.part===0&&index===0?{anchor:config.timeline.anchor}:{})});
+    else if(config.quote)context.quoteTags.set(objectName,{v:1,role:'text',group:config.quote.group,part:config.quote.part,line:index,count:fit.lines.length,...boundary,...(config.quote.part===0&&index===0?{anchor:config.quote.anchor}:{})});
     else if(config.furniture){
       context.furnitureTags.set(objectName,{v:1,role:'text',...config.furniture,line:index,count:fit.lines.length,...boundary});
       if(config.liveFields?.[index]?.length)context.furnitureFields.set(objectName,{text:line,fields:config.liveFields[index]});
@@ -1909,13 +1968,16 @@ function addMetricPayload(slide,value,layout,context,path) {
   }
 }
 
-function addQuotePayload(slide, layout, context, options, path) {
+function addQuotePayload(slide, value, layout, context, options, path) {
   if (!layout) throw new OPFPptxError('missing-quote-layout', 'Quote export requires a coordinated core build with shared quote geometry.', {path});
-  for (const part of layout.parts) {
-    if (!part.fit) throw new OPFPptxError('layout-overflow', 'Quote content has no usable internal space; increase its cell size before exporting.', {path:part.path,issues:layout.diagnostics});
+  for (const part of layout.parts) if (!part.fit) throw new OPFPptxError('layout-overflow', 'Quote content has no usable internal space; increase its cell size before exporting.', {path:part.path,issues:layout.diagnostics});
+  // Every line shape is tagged (OPF_QUOTE_V1) so an unchanged export re-imports as a quote payload (FF-57).
+  const group=String(context.quoteTags.size),anchor=quoteManifest(value,layout);
+  for (const [index,part] of layout.parts.entries()) {
     addMeasuredPayloadText(slide,part.text,part.box,context,options,{
       path:part.path,fit:part.fit,textStyle:part.style,diagnosticsHandled:true,
       color:part.role==='footer'?context.mutedColor:context.textColor,
+      quote:{group,part:index,anchor},
     });
   }
 }
@@ -2164,7 +2226,7 @@ function textRuns(value, context, fallbackFontSize) {
  * into equal-width bins and exported as a column chart of the counts, every other type plots the values against
  * their row numbers. `adapted` names that transformation so it is reported, never silent.
  */
-function toPptxChartData(chart) {
+function toPptxChartData(chart, chartexMode = 'fallback') {
   const data = chart?.data;
   const unplottable = (reason, summary, message) => ({reason, summary, message: `${message} No native chart was exported; a placeholder frame stands in for it.`});
   if (!data || !Array.isArray(data.columns) || !Array.isArray(data.rows)) {
@@ -2173,15 +2235,19 @@ function toPptxChartData(chart) {
   if (data.rows.length === 0) return unplottable("no-rows", "The chart has no data rows.", "The chart data has no rows.");
   if (data.columns.length === 0) return unplottable("no-columns", "The chart has no data columns.", "The chart data has no columns.");
   const resolved = resolveChartType(chart.type).spec;
-  // Chartex types (treemap, box & whisker, waterfall, ...) have no classic construct here: they export as a clustered column chart, never silently.
-  const chartex = resolved.family === 'chartex';
-  const spec = chartex ? CHARTEX_FALLBACK : resolved;
+  // A chartex type (treemap, histogram, pareto, box & whisker, waterfall, funnel, map) has no classic construct. With
+  // `chartex: 'native'` it is written as its cx:chartSpace part and the clustered column chart of the same data is its
+  // mc:Fallback (src/chartex.js); by default (pending the native PowerPoint check, FF-22b) it exports as the clustered
+  // column chart alone and reports chartex-fallback, never silently.
+  const native = chartexMode === 'native';
+  const chartex = resolved.family === 'chartex' && native ? resolved : null;
+  const spec = resolved.family === 'chartex' ? CHARTEX_FALLBACK : resolved;
   const typeName = stringifyText(chart.type);
   const adaptations = [];
-  if (chartex) {
+  if (resolved.family === 'chartex' && !native) {
     adaptations.push({adaptation: "chartex-fallback", message: `The '${typeName}' chart is a PowerPoint extension (chartex) chart that this exporter does not write; its data is exported as a native clustered column chart instead.`});
   }
-  const mapped = {type: spec.pptx, spec, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined};
+  const mapped = {type: spec.pptx, spec, chartex, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined};
   if (data.columns.length === 1) {
     const heading = stringifyText(data.columns[0]);
     const cell = (row) => Array.isArray(row) ? row[0] : row;
@@ -2192,7 +2258,7 @@ function toPptxChartData(chart) {
     }
     const skipped = data.rows.length - points.length;
     const skippedNote = skipped ? ` (${skipped} non-numeric ${skipped === 1 ? "cell was" : "cells were"} skipped)` : "";
-    if (String(chart.type ?? "").toLowerCase() === "histogram") {
+    if (!native && String(chart.type ?? "").toLowerCase() === "histogram") {
       const bins = histogramBins(points.map((point) => point.value));
       return {
         type: "bar", spec: CHARTEX_FALLBACK, barDir: "col", barGrouping: "clustered", heading: "Bin",
@@ -2209,8 +2275,10 @@ function toPptxChartData(chart) {
     const series = mapped.type === "scatter"
       ? [{name: "Row", labels, values: points.map((point) => point.row)}, {name: heading, labels, values: numbers}]
       : [{name: heading, labels, values: numbers}];
+    // A native histogram or Pareto chart bins the values themselves (PowerPoint's automatic bins); only its classic fallback plots them against row numbers.
+    if (chartex?.binning) return {...mapped, series, heading: "Row", hasCategories: false, adaptations};
     adaptations.push({adaptation: "row-numbers", message: `The chart's single data column '${heading}' has no category column, so its ${points.length} values${skippedNote} are plotted against their row numbers.`});
-    return {...mapped, series, heading: "Row", adaptations};
+    return {...mapped, series, heading: "Row", hasCategories: true, adaptations};
   }
 
   const labels = data.rows.map((row) => stringifyText(row?.[0]));
@@ -2219,18 +2287,19 @@ function toPptxChartData(chart) {
     labels,
     values: data.rows.map((row) => numericValue(row?.[seriesIndex + 1]))
   }));
-  if (spec.family === 'circular' && series.length > 1) {
-    // A pie or doughnut plots one series; name the ones left out instead of dropping them silently.
-    const dropped = series.slice(1).map((entry) => `'${entry.name}'`);
+  const plotted = spec.family === 'circular' ? 1 : chartex ? chartex.series : Infinity;
+  if (series.length > plotted) {
+    // A pie, doughnut or single-series chartex construct plots one series; name the ones left out instead of dropping them silently.
+    const dropped = series.slice(plotted).map((entry) => `'${entry.name}'`);
     adaptations.push({adaptation: "series-dropped", message: `The ${typeName} chart plots one series, so its first series '${series[0].name}' is exported and the other ${dropped.length} (${dropped.join(", ")}) ${dropped.length === 1 ? "is" : "are"} not.`});
-    series = series.slice(0, 1);
+    series = series.slice(0, plotted);
   }
   if (spec.family === 'xy' && series.length === 1) {
     // [Point, X, Y...] carries its own X column; a lone value column is plotted against the row numbers.
     series = [{name: 'X', labels, values: data.rows.map((_, index) => index + 1)}, ...series];
     adaptations.push({adaptation: "row-numbers", message: `The scatter chart has no X column (a point label column and one value column), so its ${data.rows.length} values are plotted against their row numbers.`});
   }
-  return {type: spec.pptx, spec, series, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined, adaptations};
+  return {...mapped, series, hasCategories: true, adaptations};
 }
 
 
@@ -2238,6 +2307,7 @@ function toPptxChartData(chart) {
  * Equal-width bins (Sturges' count, at most 50) from the minimum to the maximum; every bin but the last is [low, high).
  * Arithmetic stays finite for any finite input (values of +-1e308 and denormals included): the bin edges are
  * computed by interpolating the edges rather than from a width, and a value is placed by comparing it with the edges.
+ * Used by the default (fallback) histogram export only; the native chartex histogram bins in PowerPoint.
  */
 function histogramBins(values) {
   const min = values.reduce((a, b) => Math.min(a, b)), max = values.reduce((a, b) => Math.max(a, b));
@@ -2253,7 +2323,7 @@ function histogramBins(values) {
   // Labels carry six significant digits, and more when that would make two bins read alike.
   for (let precision = 6; ; precision++) {
     const format = (value) => String(Number(value.toPrecision(precision)));
-    const labels = bins.map((bin) => min === max ? format(min) : `${format(bin.low)}\u2013${format(bin.high)}`);
+    const labels = bins.map((bin) => min === max ? format(min) : `${format(bin.low)}–${format(bin.high)}`);
     if (new Set(labels).size === labels.length) return bins.map((bin, index) => ({...bin, label: labels[index]}));
     if (precision === 17) return bins.map((bin, index) => ({...bin, label: `${labels[index]} (bin ${index + 1})`}));
   }
@@ -2467,6 +2537,7 @@ async function normalizePptxZip(raw, context) {
   attachHeadingTags(entries,context.headingTags);
   attachPlainTextTags(entries,context.plainTextTags);
   attachTimelineTags(entries,context.timelineTags);
+  attachQuoteTags(entries,context.quoteTags);
   attachFurnitureFields(entries,context.furnitureFields);
   attachFurnitureTags(entries,context.furnitureTags,context.furnitureManifests);
   for(const [part,bytes]of Object.entries(entries)){
@@ -2486,6 +2557,12 @@ async function normalizePptxZip(raw, context) {
     }
   }
   applyChartFonts(entries,context.chartFonts,parseRelationships);
+  // Chartex charts: the native cx:chartSpace part, its style parts and the mc:AlternateContent frame (the classic chart above is the fallback).
+  try {
+    attachChartexParts(entries, context.chartex, parseRelationships);
+  } catch (error) {
+    throw new OPFPptxError('packaging-failed', `Chartex chart parts could not be attached: ${errorMessage(error)}`);
+  }
   applyPitchFamilies(entries,context.fontPitch);
   const imageSources = new Map();
   for (const [part, bytes] of Object.entries(entries)) {
@@ -2535,7 +2612,7 @@ async function normalizePptxZip(raw, context) {
     if (!slide) continue;
     context.partSlides.set(part, Number(slide[1]) - 1);
     for (const relationship of parseRelationships(entries, part).values()) {
-      if (/\/(?:chart|notesSlide)$/.test(relationship.type)) context.partSlides.set(relationship.path, Number(slide[1]) - 1);
+      if (/\/(?:chart|chartEx|notesSlide)$/.test(relationship.type)) context.partSlides.set(relationship.path, Number(slide[1]) - 1);
     }
   }
   const output = {};

package/dist/quote-provenance.js

@@ -0,0 +1,89 @@
+import {XMLParser} from 'fast-xml-parser';
+import {validatePresentation} from '@openpresentation/opf';
+import {attachTextTags,decodeTextTag} from './code-provenance.js';
+import {sourceLineParagraphs} from './text-provenance.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.
+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 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');
+
+// 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.
+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}))};
+}
+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.');
+  const roles=manifest.parts.map(part=>part?.role);
+  if(roles[0]!=='body'||(roles.length===2&&roles[1]!=='footer'))throw Error('Invalid quote parts.');
+  let count=0;
+  for(const part of manifest.parts){
+    if(!Number.isSafeInteger(part.lines)||part.lines<1||part.lines>10000)throw Error('Invalid quote line count.');
+    count+=part.lines;
+  }
+  if(count>10000)throw Error('Too many quote source lines.');
+  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.');
+  }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.
+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};
+  }
+  return {attribution:text.slice(0,at),source:text.slice(at+SEPARATOR.length)};
+}
+
+export function importQuoteGroups(shapes,paragraphs,relationships,entries,report) {
+  const groups=new Map(),consumed=new Set(),items=[];
+  for(const [index,shape]of shapes.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])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);
+    }catch{report({code:'invalid-quote-provenance',message:'Invalid quote tags; ordinary import retains current native text.'});}
+  }
+  for(const group of groups.values())try{
+    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.');
+    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.');
+      const {part,line}=item.data;
+      if(item.data.role!=='text'||!Number.isSafeInteger(part)||!Number.isSafeInteger(line)||part<0||line<0||!manifest.parts[part]||line>=manifest.parts[part].lines||item.data.count!==manifest.parts[part].lines||ordered[part][line])throw Error('Ambiguous quote source line.');
+      ordered[part][line]=item;
+    }
+    const [body,footer]=ordered.map(lines=>sourceLineParagraphs(lines,paragraphs)[0].text),local=[];
+    let quote={text:unwrap(body)};
+    if(footer)quote={...quote,...footerFields(footer,manifest.footer,diagnostic=>local.push(diagnostic))};
+    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.');
+    for(const item of group)consumed.add(item.shape);
+    items.push({shapes:group.map(item=>item.shape),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.'});
+  }catch(error){report({code:'invalid-quote-provenance',message:`${error.message} Ordinary import retains current native text without restoring old source words.`});}
+  return {consumed,items};
+}

package/dist/script-fonts.js

@@ -64,23 +64,23 @@ const escapeAttribute = value => String(value).replace(/[&<>"']/g, char => ({"&"
  * language's own per-script supplement. Only the supplement's script entry
  * changes; the rest of the vendored per-script list is FF-08's call.
  *
- * For a language written in the latin slot (Latin, Cyrillic, Greek and others) the
- * vendored empty ea/cs stay empty unless the design font scheme sets that
- * slot explicitly. Filling them with the latin family is gated on FF-05 (core
- * script-font-model.md): it did not remove PowerPoint's nameless/Aptos font
- * entries, and empty slots keep PowerPoint's per-script theme fallback for
- * East Asian or complex-script text typed later. Other languages fill both.
+ * FF-49: a slot is written only when a script font is actually selected for it,
+ * that is when the resolver's source for that slot is not `latin`: the design
+ * font scheme's explicit `eastAsian`/`complexScript`, the scheme's own script
+ * family, or the language's script font (Model C). Every other slot keeps the
+ * vendored empty typeface, exactly as Office's own themes leave it, so PowerPoint
+ * picks its per-language default for script text typed later and the package
+ * names nothing the author did not select (core script-font-model.md, "Theme
+ * slots (FF-49)"). Latin, Cyrillic and Greek decks keep both slots empty, and a
+ * Japanese deck writes `ea` only.
  */
 export function themeScriptFonts(xml, plan) {
   const {heading, body, supplement} = plan.deck;
   for (const [tag, slots, family] of [["majorFont", heading, supplement?.heading], ["minorFont", body, supplement?.body]]) {
     xml = xml.replace(new RegExp(`<a:${tag}>[\\s\\S]*?</a:${tag}>`), block => {
-      // With no script-specific choice the slot repeats the theme's own latin
-      // face exactly as written, as the run slots do.
-      const latin = /<a:latin typeface="([^"]*)"/.exec(block)?.[1];
       for (const [element, slot] of SCRIPT_SLOTS) {
-        if (plan.deck.scriptRole === "latin" && plan.deck.sources[slot] !== "fontScheme") continue;
-        const face = plan.deck.sources[slot] === "latin" && latin ? latin : escapeAttribute(slots[slot]);
+        if (plan.deck.sources[slot] === "latin") continue;
+        const face = escapeAttribute(slots[slot]);
         block = block.replace(new RegExp(`<a:${element}\\b[^>]*/>`), `<a:${element} typeface="${face}"/>`);
       }
       if (supplement && family) {
@@ -158,7 +158,7 @@ export function partScriptFonts(path, xml, plan, slideIndex) {
     xml = xml.replace(/<p:(sp|graphicFrame)>[\s\S]*?<\/p:\1>/g, shape =>
       runScriptFonts(shape, resolved, /<p:cNvPr\b[^>]*\bname="OPF heading /.test(shape)));
     if (plan.rtl) xml = paragraphRtl(xml, plan.deck.direction);
-  } else if (/^ppt\/(?:charts\/chart|notesSlides\/notesSlide)\d+\.xml$/.test(path)) {
+  } else if (/^ppt\/(?:charts\/chart(?:Ex)?|notesSlides\/notesSlide)\d+\.xml$/.test(path)) {
     xml = runScriptFonts(xml, resolved, false);
     if (plan.rtl && path.startsWith("ppt/notesSlides/")) xml = paragraphRtl(xml, plan.deck.direction);
   } else if (plan.rtl && /^ppt\/(?:slideMasters\/slideMaster\d+|slideLayouts\/slideLayout\d+|notesMasters\/notesMaster\d+|presentation)\.xml$/.test(path)) {

package/dist/slide-image-provenance.js

@@ -71,6 +71,7 @@ export function placeSlideImages(entries, images, metadataFor, fail) {
       }
       const node = parser.parse(picture)['p:pic'];
       manifests.set(name, {v:1, slide:image.slide, position:image.treatment.position, fill:image.fill, treatment:image.treatment,
+        ...(image.content === true ? {content:true} : {}),
         properties:node['p:spPr'], blipFill:blipFillIdentity(node['p:blipFill'])});
       return picture;
     });
@@ -129,6 +130,7 @@ export function importSlideImage(pictures, shapes, relationships, entries, slide
     if (unreadable || others || own.length !== 1) throw Error('Ambiguous slide image identity.');
     const manifest = decodeTextTag(own[0].val);
     if (manifest?.v !== 1 || manifest.slide !== `slides.${slideIndex}` || !['crop', 'fit'].includes(manifest.fill) || !validTreatment(manifest.treatment, manifest.position)) throw Error('Invalid slide image manifest.');
+    if (manifest.content !== undefined && manifest.content !== true) throw Error('Invalid slide image content flag.');
     if (picture['p:nvPicPr']?.['p:cNvPr']?.name !== slideImageName(manifest.slide)) throw Error('Slide image identity changed.');
     if (canonical(picture['p:spPr']) !== canonical(manifest.properties) || canonical(blipFillIdentity(picture['p:blipFill'])) !== canonical(manifest.blipFill)) throw Error('Slide image geometry or effects changed.');
     const item = readPicture(picture);
@@ -144,7 +146,11 @@ export function importSlideImage(pictures, shapes, relationships, entries, slide
         report({code:'invalid-slide-image-provenance', message:'The tagged OPF slide image overlay is missing, edited or ambiguous. The slide image is recovered without its overlay; any remaining native shape is imported as ordinary content.'});
       } else consumedShapes.add(overlay);
     }
-    return {consumed, consumedShapes, design: {slideImage: {...treatment, src}, ...(manifest.fill === 'fit' ? {imageFill: 'fit'} : {})}};
+    // FF-53: a picture that replaced the slide's root `image` (same source as the slide image) restores that
+    // payload too, so the round trip keeps `slide.image` with its alt text as well as design.slideImage.
+    const alt = item.payload.image.alt;
+    const content = manifest.content === true ? {image: {src, ...(typeof alt === 'string' && alt ? {alt} : {})}} : {};
+    return {consumed, consumedShapes, design: {slideImage: {...treatment, src}, ...(manifest.fill === 'fit' ? {imageFill: 'fit'} : {})}, ...content};
   } catch {
     invalid();
     return {consumed, consumedShapes};

package/dist/typeface-inventory.js

@@ -9,7 +9,7 @@ import {unzipSync} from 'fflate';
 // rich-text `rFont`) and the docProps/app.xml "Fonts Used" list.
 // checkPptxTypefaces() then applies the owner font policy: a package names only
 // the fonts its author chose, plus theme references that resolve to them, empty
-// theme script slots (FF-05) and the documented theme script supplements.
+// theme script slots when no script font was selected (as in Office's themes; FF-49 checks a selected slot through options.themeScripts) and the documented theme script supplements.
 
 const decoder = new TextDecoder();
 const NESTED_PACKAGE = /\.(?:xlsx|xlsm|docx|pptx)$/i;
@@ -96,8 +96,18 @@ export function checkPptxTypefaces(input, options = {}) {
   const violations = [];
   const fail = (entry, reason, details = {}) => violations.push({reason, part: entry.part, element: entry.element, typeface: entry.typeface, ...details});
   const emptyAllowed = entry => allowEmpty && entry.theme && (entry.element === 'ea' || entry.element === 'cs');
+  // FF-49: options.themeScripts names the East Asian / complex-script families the author selected for the
+  // presentation theme, {major: {ea, cs}, minor: {ea, cs}}. A selected slot must carry exactly that family (an
+  // empty or different one is a violation); a slot with nothing selected may stay empty, as in Office's own themes.
+  const themeSlot = entry => entry.theme && !entry.part.includes('!/') && (entry.element === 'ea' || entry.element === 'cs')
+    ? options.themeScripts?.[entry.theme]?.[entry.element] || '' : '';
   const pitches = new Map();
   for (const entry of inventory.typefaces) {
+    const wanted = themeSlot(entry);
+    if (wanted && entry.typeface !== wanted) {
+      fail(entry, 'theme-script-slot', {expected: wanted});
+      continue;
+    }
     const reference = THEME_REFERENCE.exec(entry.typeface);
     if (reference) {
       if (entry.resolved === null) fail(entry, 'unresolved-theme-reference');