@openpresentation/opf-pptx 0.13.2 → 0.15.0

package/dist/background.js

@@ -57,8 +57,6 @@ export function nativeBackgroundFill(background, {width, height}, fallback = 'FF
   }
   if (background.type !== 'gradient') return null;
   const stops = background.gradient?.stops ?? [];
-  if (!stops.length) return '<a:noFill/>';
-  if (stops.length === 1) return `<a:solidFill>${paint(stops[0].color, fallback)}</a:solidFill>`;
   const radians = turn(background.gradient?.angle ?? 0) * Math.PI / 180;
   const c = Math.cos(radians), s = Math.sin(radians), span = Math.abs(c) + Math.abs(s);
   const angle = Math.round(turn(Math.atan2(s / height, c / width) * 180 / Math.PI) * 60000) % 21600000;
@@ -73,39 +71,42 @@ export function nativeBackgroundFill(background, {width, height}, fallback = 'FF
 }
 
 const rectXml = (name, rect = {}) => `<a:${name}${['l', 't', 'r', 'b'].filter(key => rect[key]).map(key => ` ${key}="${rect[key]}"`).join('')}/>`;
-const percent = value => Math.round(value * 100000);
+const percent = value => Math.round(value * 100000) || 0;
 
-// Picture fill for an OPF image background, following the SVG preview:
-// cover crops the centered source to the slide aspect, contain letterboxes it
-// with fill-rectangle insets, and tile repeats square cells of min(w,h)/4
-// from the top-left corner. Each cell holds the image by the deck imageFill
-// (crop = cover, otherwise contain; negative source insets are transparent
-// padding). With dpi="0", DrawingML sizes a tile from the raster's own
-// resolution (PNG pHYs, JPEG JFIF or EXIF; 96 dpi when absent), while the
-// preview draws CSS pixels, so the tile scale compensates on each axis.
+// FA-23: the picture fill of an OPF image background (core SlideComposition.backgroundImage), drawn like the SVG
+// preview. `fitImage` is core's shared fit math (composition `fitImage`), so every engine crops, letterboxes and
+// focuses the same way:
+// - stretch fills the slide (no crop);
+// - cover crops the picture to the slide with the focus point kept in view (a:srcRect, positive insets);
+// - contain centers the whole picture; the fill rectangle insets leave the rest of the slide unfilled;
+// - tile repeats the picture at its intrinsic size (1 picture px = 1 reference px, 1/96 in) from the top-left corner.
+//   With dpi="0", DrawingML sizes a tile from the raster's own resolution (PNG pHYs, JPEG JFIF or EXIF; 96 dpi when
+//   absent), so the tile scale is the raster's dpi / 96 on each axis.
+// A recolor (core backgroundImage.recolor, resolved: {type: 'grayscale'} or {type: 'duotone', dark: {hex}, light: {hex}})
+// is a:grayscl or a:duotone on the blip, then opacity is a:alphaModFix (picture pixels only), as for image blocks.
 export const nativeTileAlignment = {tx: '0', ty: '0', flip: 'none', algn: 'tl'};
-export function nativeTileScale(image, {width, height, imageFill = 'fit'}) {
-  const cell = Math.min(width, height) / 4;
-  const scale = (imageFill === 'crop' ? Math.max : Math.min)(cell / image.width, cell / image.height);
-  return {cell, scale, sx: percent(scale * (image.dpiX ?? 96) / 96), sy: percent(scale * (image.dpiY ?? 96) / 96)};
+export function nativeTileScale(image) {
+  return {sx: percent((image.dpiX ?? 96) / 96), sy: percent((image.dpiY ?? 96) / 96)};
 }
-export function nativeImageBackgroundFill(relationshipId, image, {fit = 'cover', opacity = 1, width, height, imageFill = 'fit'}) {
+export function nativeImageBackgroundFill(relationshipId, image, {fit = 'cover', focus, opacity = 1, recolor, width, height, fitImage}) {
   const alpha = clamp(opacity);
-  const blip = `<a:blip r:embed="${relationshipId}">${alpha === 1 ? '' : `<a:alphaModFix amt="${percent(alpha)}"/>`}</a:blip>`;
+  const recolorXml = recolor?.type === 'grayscale' ? '<a:grayscl/>'
+    : recolor?.type === 'duotone' ? `<a:duotone><a:srgbClr val="${recolor.dark.hex}"></a:srgbClr><a:srgbClr val="${recolor.light.hex}"></a:srgbClr></a:duotone>` : '';
+  const blip = `<a:blip r:embed="${relationshipId}">${recolorXml}${alpha === 1 ? '' : `<a:alphaModFix amt="${percent(alpha)}"/>`}</a:blip>`;
   if (fit === 'tile') {
-    const {cell, scale, sx, sy} = nativeTileScale(image, {width, height, imageFill});
-    const x = percent((1 - cell / (image.width * scale)) / 2), y = percent((1 - cell / (image.height * scale)) / 2);
-    const {tx, ty, flip, algn} = nativeTileAlignment;
-    return `<a:blipFill dpi="0" rotWithShape="1">${blip}${rectXml('srcRect', {l: x, t: y, r: x, b: y})}<a:tile tx="${tx}" ty="${ty}" sx="${sx}" sy="${sy}" flip="${flip}" algn="${algn}"/></a:blipFill>`;
+    const {sx, sy} = nativeTileScale(image), {tx, ty, flip, algn} = nativeTileAlignment;
+    return `<a:blipFill dpi="0" rotWithShape="1">${blip}<a:tile tx="${tx}" ty="${ty}" sx="${sx}" sy="${sy}" flip="${flip}" algn="${algn}"/></a:blipFill>`;
   }
+  if (fit === 'stretch') return `<a:blipFill dpi="0" rotWithShape="1">${blip}<a:stretch><a:fillRect/></a:stretch></a:blipFill>`;
+  const frame = {x: 0, y: 0, width, height};
+  const placed = fitImage(frame, fit, image.width / image.height, focus);
   if (fit === 'contain') {
-    const scale = Math.min(width / image.width, height / image.height);
-    const x = percent((1 - image.width * scale / width) / 2), y = percent((1 - image.height * scale / height) / 2);
-    return `<a:blipFill dpi="0" rotWithShape="1">${blip}<a:srcRect/><a:stretch>${rectXml('fillRect', {l: x, t: y, r: x, b: y})}</a:stretch></a:blipFill>`;
+    const box = placed.image;
+    const inset = {l: percent(box.x / width), t: percent(box.y / height), r: percent((width - box.x - box.width) / width), b: percent((height - box.y - box.height) / height)};
+    return `<a:blipFill dpi="0" rotWithShape="1">${blip}<a:srcRect/><a:stretch>${rectXml('fillRect', inset)}</a:stretch></a:blipFill>`;
   }
-  const scale = Math.max(width / image.width, height / image.height);
-  const x = percent((1 - width / (image.width * scale)) / 2), y = percent((1 - height / (image.height * scale)) / 2);
-  return `<a:blipFill dpi="0" rotWithShape="1">${blip}${rectXml('srcRect', {l: x, t: y, r: x, b: y})}<a:stretch><a:fillRect/></a:stretch></a:blipFill>`;
+  const {left, top, right, bottom} = placed.crop;
+  return `<a:blipFill dpi="0" rotWithShape="1">${blip}${rectXml('srcRect', {l: percent(left), t: percent(top), r: percent(right), b: percent(bottom)})}<a:stretch><a:fillRect/></a:stretch></a:blipFill>`;
 }
 
 // Internal metadata supplied by the ordered XML reader. A Symbol cannot collide
@@ -215,7 +216,8 @@ export function readNativeBackground(properties, {width, height}, report = () =>
     if (!c || !Number.isFinite(position) || position < -.00002 || position > 1.00002) return null;
     return {...c, position: clamp(position)};
   });
-  if (!stops.length || stops.some(stop => !stop)) return unsupported();
+  // The schema needs at least two stops (DrawingML does too).
+  if (stops.length < 2 || stops.some(stop => !stop)) return unsupported();
   const alpha = stops[0].alpha, uniform = stops.every(stop => stop.alpha === alpha);
   return {type: 'gradient', gradient: {angle, stops: stops.map(stop => ({position: stop.position,
     color: stop.hex + (!uniform && stop.alpha !== 1 ? Math.round(stop.alpha * 255).toString(16).padStart(2, '0').toUpperCase() : '')}))},

package/dist/body-text-import.js

@@ -17,7 +17,10 @@ export const joinNativeParagraphs = paragraphs => value(paragraphs.flatMap((para
   ...(index ? ['\n'] : []), ...(Array.isArray(paragraph.richText) ? paragraph.richText : [paragraph.richText ?? paragraph.text])
 ]));
 
-function bodyRunStyle(properties, context, relationships, report) {
+// FA-13: a run language that differs from the deck language comes back as TextRun.lang; a run in the design's code family
+// comes back as an inline code run. `extras` is {deckLang, codeFamily} (either may be absent).
+const RUN_LANG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
+function bodyRunStyle(properties, context, relationships, report, extras = {}) {
   const supported = {...properties};
   for (const key of ['b', 'i']) if (properties[key] !== undefined && !['1','0','true','false','on','off'].includes(properties[key])) {
     report('unsupported-body-text-style', `The native ${key} value is not a supported boolean; current text was retained.`);
@@ -52,10 +55,19 @@ function bodyRunStyle(properties, context, relationships, report) {
     (properties.cap !== undefined && properties.cap !== 'none') || (properties.spc !== undefined && Number(properties.spc) !== 0)) {
     report('unsupported-body-text-style', 'Native text effects, capitalization, spacing or underline decoration are not represented by OPF run properties; current text was retained.');
   }
-  return nativeRunStyle(supported, context, relationships, report, 'body');
+  const style = nativeRunStyle(supported, context, relationships, report, 'body');
+  const lang = properties.lang;
+  if (extras.deckLang && typeof lang === 'string' && RUN_LANG.test(lang) && !/^(?:und|zxx)(?:-|$)/i.test(lang) && lang.toLowerCase() !== extras.deckLang.toLowerCase()) style.lang = lang;
+  const family = typeof style.fontFamily === 'string' ? style.fontFamily.trim().toLowerCase() : undefined;
+  if (family && extras.codeFamily && family === extras.codeFamily.trim().toLowerCase()
+    && !['a:majorFont', 'a:minorFont'].some(key => context.fonts?.[key]?.['a:latin']?.typeface?.trim().toLowerCase() === family)) {
+    style.code = true;
+    delete style.fontFamily;
+  }
+  return style;
 }
 
-export function nativeBodyReader(slidePath, archive, relationships, report) {
+export function nativeBodyReader(slidePath, archive, relationships, report, extras = {}) {
   let bodies, context;
   return index => {
     if (!bodies) {
@@ -80,7 +92,7 @@ export function nativeBodyReader(slidePath, archive, relationships, report) {
         const properties = mergeNativeRunProperties(defaults, drawingObject(node[tag])['a:rPr']);
         // RR-05: a Latin phrase of a right-to-left paragraph is its own en-US run; its East Asian/complex-script slots can render nothing in it, so the face loss is not reported.
         const phrase = nodes(content, 'a:pPr')[0]?.[':@']?.rtl === '1' && properties.lang === 'en-US' && LATIN_ONLY.test(current);
-        const style = bodyRunStyle(properties, context, relationships, (code, message) => { if (!(phrase && code === 'unsupported-body-font')) report({code,message,path}); });
+        const style = bodyRunStyle(properties, context, relationships, (code, message) => { if (!(phrase && code === 'unsupported-body-font')) report({code,message,path}); }, phrase ? {...extras, deckLang: undefined} : extras);
         if (current) runs.push(Object.keys(style).length ? {text:current,...style} : current);
       }
       return {text:runs.map(run => typeof run === 'string' ? run : run.text).join(''), richText:value(runs)};

package/dist/chart-alt.js

@@ -0,0 +1,54 @@
+// FA-09: the text alternative of a chart (`Chart.alt`) is the chart frame's `p:nvGraphicFramePr/p:cNvPr/@descr`, the attribute a
+// picture's alt text uses. An empty `alt` marks the chart decorative, which PowerPoint stores as the `adec:decorative` extension of
+// the same `p:cNvPr` ("Mark as decorative"), not as an empty `descr`: PowerPoint writes `descr=""` for any shape without alt text.
+const DECORATIVE_URI = '{C183D7F6-B498-43B3-948B-1728B52AA6E4}';
+const DECORATIVE_NS = 'http://schemas.microsoft.com/office/drawing/2017/decorative';
+const ESCAPES = {'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;', '\r': '&#13;', '\n': '&#10;', '\t': '&#9;'};
+const escape = value => value.replace(/[&<>"'\r\n\t]/g, char => ESCAPES[char]);
+const decorativeExt = `<a:ext uri="${DECORATIVE_URI}"><adec:decorative xmlns:adec="${DECORATIVE_NS}" val="1"/></a:ext>`;
+const decorativeExtPattern = new RegExp(`<a:ext\\b[^>]*\\buri="${DECORATIVE_URI.replace(/[{}]/g, '\\$&')}"[^>]*>[\\s\\S]*?</a:ext>`, 'g');
+
+// The one a:extLst of a p:cNvPr is edited in place: PowerPoint's own extensions (a16:creationId and others) stay untouched and in
+// order, an earlier decorative ext is replaced and never duplicated, and an extLst left with no ext is removed.
+function withDecorative(body, decorative) {
+  const list = body.match(/<a:extLst(?:\s[^>]*)?(?:\/>|>[\s\S]*?<\/a:extLst>)/);
+  const inner = list ? list[0].replace(/^<a:extLst(?:\s[^>]*)?>|<\/a:extLst>$|^<a:extLst(?:\s[^>]*)?\/>$/g, '').replace(decorativeExtPattern, '') : '';
+  const exts = decorative ? inner + decorativeExt : inner;
+  const next = exts.trim() === '' ? '' : `<a:extLst>${exts}</a:extLst>`;
+  return list ? body.slice(0, list.index) + next + body.slice(list.index + list[0].length) : body + next;
+}
+
+/** Write `alt` on the first `p:cNvPr` of a graphic frame: `descr` for text, the decorative extension for the empty string. */
+export function writeFrameAlt(frame, alt) {
+  const start = frame.match(/<p:cNvPr\b[^>]*?(\/?)>/);
+  if (!start) return frame;
+  const selfClosing = start[1] === '/';
+  const end = selfClosing ? start.index + start[0].length : frame.indexOf('</p:cNvPr>', start.index);
+  if (end < 0) return frame;
+  let tag = start[0].replace(/\sdescr="[^"]*"/, '');
+  const body = withDecorative(selfClosing ? '' : frame.slice(start.index + start[0].length, end), alt === '');
+  if (alt !== '') tag = tag.replace(/\s*\/?>$/, match => ` descr="${escape(alt)}"${match.trim()}`);
+  const tail = selfClosing ? start.index + start[0].length : end + '</p:cNvPr>'.length;
+  const open = selfClosing && body ? tag.replace(/\s*\/>$/, '>') : tag;
+  const close = !selfClosing || body ? '</p:cNvPr>' : '';
+  return `${frame.slice(0, start.index)}${open}${body}${close}${frame.slice(tail)}`;
+}
+
+/** Apply every recorded chart alt to the frames (classic and chartex fallback) of a slide part's XML, matched by frame name. */
+export function applyChartAlt(xml, alts) {
+  return xml.replace(/<p:graphicFrame>[\s\S]*?<\/p:graphicFrame>/g, frame => {
+    const name = frame.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1];
+    return alts.has(name) ? writeFrameAlt(frame, alts.get(name)) : frame;
+  });
+}
+
+const list = value => (Array.isArray(value) ? value : value === undefined || value === null ? [] : [value]);
+
+/** The alt of a parsed `p:cNvPr`: its `descr`, `""` when marked decorative, or undefined. */
+export function readFrameAlt(cNvPr) {
+  if (!cNvPr || typeof cNvPr !== 'object') return undefined;
+  const descr = cNvPr.descr;
+  if (typeof descr === 'string' && descr.trim() !== '') return descr;
+  const decorative = list(list(cNvPr['a:extLst'])[0]?.['a:ext']).some(ext => list(ext?.['adec:decorative']).some(node => node?.val === '1' || node?.val === 'true'));
+  return decorative ? '' : undefined;
+}

package/dist/chart-data.js

@@ -6,59 +6,25 @@
 // c:numFmt and the embedded workbook cell formats (src/chart-workbook.js). A chart without number formats is written
 // exactly as before.
 //
-// Optional core exports are read from the namespace, so a published core before RR-54 still loads: its schema rejects
-// the new fields, so the fallbacks only need the inline positional form, with the same strict number rule.
-import * as opfCore from '@openpresentation/opf';
+// The core functions are re-exported from one place so the exporter and importer read the same ones: core 0.14 always has
+// them, so there is no fallback to fall into.
+import {
+  chartNumber, fromExcelNumberFormat, inlineChartData, inlineTableData, isDatasetRef, resolveChartData, resolveTableData, tableCellDisplayValue, toExcelNumberFormat
+} from '@openpresentation/opf';
 
-const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
-const STRICT_DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-
-/** Core `chartNumber` (strict decimal syntax; everything else is a gap). */
-export const chartNumber = typeof opfCore.chartNumber === 'function' ? opfCore.chartNumber : value => {
-  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
-  if (typeof value !== 'string') return null;
-  const text = value.trim();
-  if (!STRICT_DECIMAL.test(text)) return null;
-  const number = Number(text);
-  return Number.isFinite(number) && (!Number.isInteger(number) || Number.isSafeInteger(number)) ? number : null;
-};
-/** NumberFormat -> Excel format code ("General" when absent). */
-export const excelNumberFormat = typeof opfCore.excelNumberFormat === 'function' ? opfCore.excelNumberFormat : () => 'General';
-/** Excel format code -> NumberFormat, or undefined when it has no exact equivalent. */
-export const numberFormatFromExcel = typeof opfCore.numberFormatFromExcel === 'function' ? opfCore.numberFormatFromExcel : () => undefined;
-export const isDatasetRef = typeof opfCore.isDatasetRef === 'function' ? opfCore.isDatasetRef : value => object(value) && typeof value.dataset === 'string';
-export const inlineChartData = typeof opfCore.inlineChartData === 'function' ? opfCore.inlineChartData : chart => chart;
-export const inlineTableData = typeof opfCore.inlineTableData === 'function' ? opfCore.inlineTableData : table => table;
-export const tableCellDisplayValue = typeof opfCore.tableCellDisplayValue === 'function' ? opfCore.tableCellDisplayValue : cell => cell;
-export const resolveTableData = typeof opfCore.resolveTableData === 'function' ? opfCore.resolveTableData
-  : table => ({...(Array.isArray(table?.columns) ? {columns: table.columns} : {}), rows: Array.isArray(table?.rows) ? table.rows : [], formats: [], diagnostics: []});
-
-const columnName = column => typeof column === 'string' ? column : object(column) && typeof column.name === 'string' ? column.name : '';
-
-// Before RR-54 core: inline positional data only (the schema of that core has no datasets or mapping).
-function positionalChartData(chart) {
-  const data = chart?.data;
-  if (!object(data) || !Array.isArray(data.columns)) return {ok: false, reason: 'no-columns', message: 'The chart data has no columns.', diagnostics: []};
-  if (!data.columns.length) return {ok: false, reason: 'no-columns', message: 'The chart data has no columns.', diagnostics: []};
-  if (!Array.isArray(data.rows) || !data.rows.length) return {ok: false, reason: 'no-rows', message: 'The chart data has no rows.', diagnostics: []};
-  const diagnostics = [];
-  const rows = data.rows.map((row, rowIndex) => data.columns.map((_, index) => {
-    const cell = Array.isArray(row) && index < row.length ? row[index] : null;
-    if (index === 0) return cell === undefined ? null : cell;
-    const number = chartNumber(cell);
-    if (number === null && cell !== null && cell !== undefined && cell !== '') diagnostics.push({code: 'chart-value-not-numeric', severity: 'warning', path: `/data/rows/${rowIndex}/${index}`, message: `chart value ${JSON.stringify(cell)} is not a number; it is plotted as a gap.`});
-    return number;
-  }));
-  return {ok: true, columns: data.columns.map(columnName), formats: data.columns.map(() => undefined), rows, diagnostics};
-}
+export {chartNumber, fromExcelNumberFormat, inlineChartData, inlineTableData, isDatasetRef, resolveChartData, resolveTableData, tableCellDisplayValue, toExcelNumberFormat};
 
-/** Core `resolveChartData`: the canonical positional table [category, (x,) ...series], or {ok: false, reason}. */
-export const resolveChartData = typeof opfCore.resolveChartData === 'function' ? opfCore.resolveChartData : positionalChartData;
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 
-/** True when a chart uses an RR-54 data field that the native cache alone cannot carry back. */
+/**
+ * True when a chart uses an RR-54 data field that the native cache alone cannot carry back, or is a combo chart whose `line` or
+ * `secondaryAxis` exports its series in another order than the data's (FA-15: column series first, then lines), so the record
+ * restores the authored column order.
+ */
 export function chartUsesDataFields(chart) {
   const data = chart?.data;
-  return object(chart) && (chart.mapping !== undefined || isDatasetRef(data) || (object(data) && (data.source !== undefined || (Array.isArray(data.columns) && data.columns.some(object)))));
+  return object(chart) && (chart.mapping !== undefined || isDatasetRef(data) || (object(data) && (data.source !== undefined || (Array.isArray(data.columns) && data.columns.some(object))))
+    || (chart.type === 'combo' && (chart.line !== undefined || chart.secondaryAxis !== undefined)));
 }
 
 /** True when a table is dataset-backed or carries a DataColumn header or a number format. */
@@ -76,7 +42,7 @@ const escapeXml = value => String(value).replace(/&/g, '&amp;').replace(/</g, '&
 /** The Excel code of a NumberFormat, or undefined when it is absent or General (the exporter's default). */
 export function excelCode(format) {
   if (format === undefined) return undefined;
-  const code = excelNumberFormat(format);
+  const code = toExcelNumberFormat(format);
   return code && code !== 'General' ? code : undefined;
 }
 
@@ -85,12 +51,13 @@ export function excelCode(format) {
  *   series  the Excel code of each c:ser, in document order (undefined keeps General);
  *   x       the X column's code (scatter c:xVal and the horizontal value axis);
  *   axis    the value axis code (the first plotted series' format, as Excel does), or undefined to keep the axis;
+ *   secondaryAxis  a combo chart's secondary value axis code (its first series' format, FA-15), or undefined to keep it;
  *   labels  false when the labels show percentages (the percent label keeps PowerPoint's own percent form);
  *   scatter true for an XY chart (two value axes: axPos b/t is X).
  * Every c:numCache of a series takes its code, every c:numFmt of a series' data labels too; the chart group's labels
  * take the first series' code.
  */
-export function applyChartNumberFormats(xml, {series = [], x, axis, labels = true, scatter = false}) {
+export function applyChartNumberFormats(xml, {series = [], x, axis, secondaryAxis, labels = true, scatter = false}) {
   // CT_NumData: formatCode is the cache's first child (PptxGenJS writes none on pie and doughnut series).
   const formatCode = (text, code) => code === undefined ? text : /<c:formatCode>/.test(text)
     ? text.replace(/<c:formatCode>[^<]*<\/c:formatCode>/g, `<c:formatCode>${escapeXml(code)}</c:formatCode>`)
@@ -107,10 +74,18 @@ export function applyChartNumberFormats(xml, {series = [], x, axis, labels = tru
     const result = ser.replace(/<c:(val|yVal|xVal)>[\s\S]*?<\/c:\1>/g, (role, name) => formatCode(role, name === 'xVal' ? x : code));
     return labelFormats(result, code);
   });
-  // The chart group's own label block (outside every c:ser) follows the first series.
-  const grouped = out.split(/(<c:ser>[\s\S]*?<\/c:ser>)/).map((part, position) => position % 2 ? part : labelFormats(part, series[0])).join('');
+  // The chart group's own label block (outside every c:ser) follows the group's first series. Only a combo chart has more than
+  // one group (FA-15: its line groups follow their own first series).
+  let first = 0;
+  const grouped = out.replace(/<c:(barChart|lineChart|areaChart|pieChart|doughnutChart|scatterChart|radarChart)>[\s\S]*?<\/c:\1>/g, group => {
+    const code = series[first];
+    first += group.match(/<c:ser>/g)?.length ?? 0;
+    return group.split(/(<c:ser>[\s\S]*?<\/c:ser>)/).map((part, position) => position % 2 ? part : labelFormats(part, code)).join('');
+  });
+  // The first c:valAx is the value axis; a combo chart's second one is its secondary axis (a scatter chart's two are X and Y).
+  let valueAxis = 0;
   return grouped.replace(/<c:valAx>[\s\S]*?<\/c:valAx>/g, valAx => {
-    const code = scatter && /<c:axPos val="[bt]"\/>/.test(valAx) ? x : axis;
+    const code = scatter ? (/<c:axPos val="[bt]"\/>/.test(valAx) ? x : axis) : valueAxis++ === 0 ? axis : secondaryAxis;
     return code === undefined ? valAx : valAx.replace(/<c:numFmt\b[^>]*\/>/, `<c:numFmt formatCode="${escapeXml(code)}" sourceLinked="0"/>`);
   });
 }
@@ -139,7 +114,7 @@ export function numericRanges(xml, {series = [], x}) {
  */
 export function formatFromCode(code) {
   if (typeof code !== 'string' || code.trim() === '' || /^general$/i.test(code.trim())) return {};
-  const format = numberFormatFromExcel(code);
+  const format = fromExcelNumberFormat(code);
   return format === undefined ? {unmapped: code} : {format};
 }
 

package/dist/chart-highlight.js

@@ -0,0 +1,113 @@
+// FA-14: chart emphasis (`chart.highlight`) in the PPTX export.
+//
+// Core owns what is highlighted (`resolveChartOptions(...).highlight`, `chartHighlightMarks`) and the two colours
+// (`chartHighlightColors`); the preview (opf-render) calls the same functions, so both engines colour the same marks the same way.
+// This module writes them natively into the generated classic chart part:
+//
+//   column, bar, area, scatter, radar   the series colour (c:ser/c:spPr, and c:marker/c:spPr) of every series, accent when the
+//                                       series is named, muted otherwise; clustered and stacked alike;
+//   column and bar, category highlight  one c:dPt (idx, invertIfNegative, bubble3D, spPr) per point whose colour differs from its
+//                                       series' colour;
+//   line                                the series line and marker colour, and for a category highlight one c:dPt with a circular
+//                                       c:marker per highlighted point (a line without markers shows markers only there);
+//   pie, doughnut                       the fill of the c:dPt of every slice, accent for a highlighted category, muted otherwise.
+//
+// The highlight colour is the deck primary: `a:schemeClr val="accent1"` when the deck theme holds exactly that colour (so a theme
+// edit in PowerPoint recolours it), the literal sRGB otherwise (a primary that needed a contrast adjustment against the chart panel).
+// The muted colour is a mix of the panel and the text colour, which no single scheme colour with lumMod/lumOff reproduces, so it is
+// an sRGB literal. A chart without a highlight never reaches this module, so its parts are unchanged.
+import {chartHighlightColors, chartHighlightMarks} from '@openpresentation/opf/composition';
+
+const srgb = hex => `<a:srgbClr val="${String(hex).replace(/^#/, '').toUpperCase()}"/>`;
+
+/**
+ * The highlight of an exported chart: `{kind, marks, accent, muted, seriesFills, pointFills}` or undefined.
+ * `options` is core's `resolveChartOptions` result, `data` the resolved chart data (`columns`, `hasX`, `rows`), `kind` the chart's option
+ * kind, `panelFill` and `labelColor` the chart panel and text colours (as the preview uses them), `primary` the deck primary and
+ * `scheme` its scheme value when the theme holds it exactly (core's colour for the accent is compared with it here).
+ *
+ * Colours are `{hex, xml}`: `hex` (RRGGBB) feeds the data label contrast, `xml` is the DrawingML colour element.
+ */
+export function chartHighlightPlan({options, data, kind, panelFill, labelColor, primary, schemeFor}) {
+  if (!options?.highlight || !data) return undefined;
+  const marks = chartHighlightMarks(options.highlight, data);
+  if (!marks) return undefined;
+  const colors = chartHighlightColors(panelFill, primary, `#${labelColor}`);
+  const accentHex = colors.accent.replace(/^#/, '').toUpperCase();
+  const scheme = schemeFor?.(colors.accent);
+  const accent = {hex: accentHex, xml: scheme ? `<a:schemeClr val="${scheme}"/>` : srgb(accentHex)};
+  const muted = {hex: colors.muted.replace(/^#/, '').toUpperCase(), xml: srgb(colors.muted)};
+  const seriesColor = index => marks.series[index] ? accent : muted;
+  const markColor = (series, row) => marks.series[series] || marks.categories[row] ? accent : muted;
+  const circular = kind === 'pie' || kind === 'doughnut';
+  return {
+    kind, marks, accent, muted, seriesColor, markColor, circular,
+    // The series colours (data label contrast of a series-level label) and, where marks differ within a series, the point colours.
+    seriesFills: Array.from({length: marks.series.length}, (_, index) => seriesColor(index).hex),
+    pointFills: series => circular ? marks.categories.map(row => (row ? accent : muted).hex)
+      : kind === 'bar' && marks.categories.some(Boolean) ? marks.categories.map((_, row) => markColor(series, row).hex) : undefined,
+  };
+}
+
+const fill = color => `<a:solidFill>${color.xml}</a:solidFill>`;
+const recolor = (block, color) => block.replace(/<a:solidFill>[\s\S]*?<\/a:solidFill>/g, fill(color));
+
+// The series' own c:spPr: the first one, which precedes c:marker, c:dPt, c:dLbls and the data references in CT_*Ser.
+function seriesProperties(ser) {
+  const at = ser.indexOf('<c:spPr>');
+  const limit = ['<c:marker>', '<c:dPt>', '<c:dLbls>', '<c:cat>', '<c:xVal>', '<c:val>'].map(tag => ser.indexOf(tag)).filter(index => index >= 0);
+  if (at < 0 || limit.some(index => index < at)) throw new Error('A generated chart series carries no series properties.');
+  return at;
+}
+
+function recolorSeries(ser, color) {
+  const at = seriesProperties(ser);
+  const end = ser.indexOf('</c:spPr>', at) + '</c:spPr>'.length;
+  let out = ser.slice(0, at) + recolor(ser.slice(at, end), color) + ser.slice(end);
+  out = out.replace(/<c:marker>[\s\S]*?<\/c:marker>/, marker => recolor(marker, color));
+  return out;
+}
+
+const barPoint = (row, color) => `<c:dPt><c:idx val="${row}"/><c:invertIfNegative val="0"/><c:bubble3D val="0"/><c:spPr>${fill(color)}<a:effectLst/></c:spPr></c:dPt>`;
+const linePoint = (row, color) => `<c:dPt><c:idx val="${row}"/><c:marker><c:symbol val="circle"/><c:size val="6"/><c:spPr>${fill(color)}<a:ln w="9525" cap="flat">${fill(color)}<a:prstDash val="solid"/><a:round/></a:ln><a:effectLst/></c:spPr></c:marker><c:bubble3D val="0"/></c:dPt>`;
+
+/**
+ * Rewrite the series of a generated classic chart for the highlight plan (see the module comment). `xml` is the chart part text.
+ * Series are matched to the plan by position, which is how core orders them (the columns after the category, and after the X
+ * column of a scatter chart): the generated part has one c:ser per plotted series, in that order.
+ */
+export function applyChartHighlight(xml, plan) {
+  const {kind, marks, accent, muted} = plan;
+  let seriesIndex = 0;
+  return xml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => {
+    const index = seriesIndex++;
+    if (plan.circular) {
+      return ser.replace(/<c:dPt>([\s\S]*?)<\/c:dPt>/g, (point, inner) => {
+        const row = Number(/<c:idx val="(\d+)"\/>/.exec(inner)?.[1]);
+        return marks.categories[row] === undefined ? point : recolor(point, marks.categories[row] ? accent : muted);
+      });
+    }
+    if (index >= marks.series.length) return ser;
+    let out = recolorSeries(ser, plan.seriesColor(index));
+    if (kind === 'bar' && marks.categories.some(Boolean)) {
+      const points = marks.categories.flatMap((_, row) => plan.markColor(index, row) === plan.seriesColor(index) ? [] : [barPoint(row, plan.markColor(index, row))]).join('');
+      if (points) out = out.replace(/<c:dLbls>|<c:cat>/, anchor => `${points}${anchor}`);
+    } else if (kind === 'line' && marks.categories.some(Boolean)) {
+      // A line shows a marker at every highlighted category: on a line with markers only where the series colour is not already the
+      // accent, on a line without markers (symbol none) at every highlighted point.
+      const hasMarkers = !/<c:marker>\s*<c:symbol val="none"\/>/.test(out);
+      const points = marks.categories.flatMap((highlighted, row) => highlighted && (!hasMarkers || plan.markColor(index, row) !== plan.seriesColor(index)) ? [linePoint(row, plan.markColor(index, row))] : []).join('');
+      if (points) {
+        // CT_LineSer: marker, dPt, dLbls, trendline, errBars, cat. The generator writes c:dLbls before c:marker; it moves behind the points.
+        const labels = /<c:dLbls>[\s\S]*?<\/c:dLbls>/.exec(out);
+        const markerEnd = out.indexOf('</c:marker>') + '</c:marker>'.length;
+        if (labels && labels.index < markerEnd) {
+          out = out.slice(0, labels.index) + out.slice(labels.index + labels[0].length);
+          const end = out.indexOf('</c:marker>') + '</c:marker>'.length;
+          out = `${out.slice(0, end)}${points}${labels[0]}${out.slice(end)}`;
+        } else out = `${out.slice(0, markerEnd)}${points}${out.slice(markerEnd)}`;
+      }
+    }
+    return out;
+  });
+}

package/dist/chart-options.js

@@ -8,17 +8,14 @@
 //   chartex charts   cx:axis/cx:title, cx:legend pos and cx:dataLabels pos (see chartex.js, which calls the helpers here).
 //
 // A chart that carries none of the three fields resolves to `active: false`; nothing below runs and its parts are unchanged.
-import * as opfCore from '@openpresentation/opf';
+import {chartOptionSupport, chartOptionTarget, resolveChartOptions, textColorForFill} from '@openpresentation/opf/composition';
 
 const INACTIVE = Object.freeze({active: false, axisTitles: {}, diagnostics: []});
 
-/** True when the installed core knows the chart option fields (older cores ignore them on export and import). */
-export const coreKnowsChartOptions = () => typeof opfCore.resolveChartOptions === 'function' && typeof opfCore.chartOptionSupport === 'function';
-
-/** The resolved options of a chart (an older core without `resolveChartOptions` ignores the fields). */
+/** The resolved options of a chart. */
 export function resolveChartOptionsFor(chart) {
-  if (typeof opfCore.resolveChartOptions !== 'function' || !chart || typeof chart !== 'object') return INACTIVE;
-  return opfCore.resolveChartOptions(chart, opfCore.chartOptionTarget(chart.type));
+  if (!chart || typeof chart !== 'object') return INACTIVE;
+  return resolveChartOptions(chart, chartOptionTarget(chart.type));
 }
 
 export function reportChartOptionDiagnostics(resolved, path, onDiagnostic) {
@@ -79,17 +76,33 @@ const dLbl = (index, color, labels, {size, font}) =>
  *   - the label text colour: the chart text colour outside a mark, the contrasting colour (core's `textColorForFill`, as the
  *     preview) inside one, per series, and per point on pie and doughnut charts.
  *
- * `info`: {resolved, kind, palette (series colours, hex without #), labelColor, font, textSize, pointCount}.
+ * FA-14: with a chart highlight (`info.highlight`, src/chart-highlight.js) `palette` holds the highlight-aware series colours, and a
+ * label inside a mark whose colour differs per point (pie and doughnut slices, columns and bars with a category highlight) is written
+ * per point with the colour that contrasts with that point's fill.
+ *
+ * `info`: {resolved, kind, palette (series colours, hex without #), labelColor, font, textSize, pointCount, highlight?}.
  */
 export function applyDataLabels(xml, info) {
-  const {resolved, kind, palette, labelColor, font, textSize, pointCount} = info;
+  // FA-15: a combo chart labels its column group like clustered columns and its line groups like line points (core's
+  // `linePosition`); the series colours run on across the groups.
+  if (info.kind === 'combo') {
+    let offset = 0;
+    return xml.replace(/<c:(barChart|lineChart)>[\s\S]*?<\/c:\1>/g, (group, element) => {
+      const line = element === 'lineChart';
+      const dataLabels = line ? {...info.resolved.dataLabels, position: info.resolved.dataLabels.linePosition ?? 'above'} : info.resolved.dataLabels;
+      const palette = info.palette.slice(offset).concat(info.palette.slice(0, offset));
+      offset = (offset + (group.match(/<c:ser>/g)?.length ?? 0)) % Math.max(1, info.palette.length);
+      return applyDataLabels(group, {...info, kind: line ? 'line' : 'bar', palette, resolved: {...info.resolved, dataLabels}});
+    });
+  }
+  const {resolved, kind, palette, labelColor, font, textSize, pointCount, highlight} = info;
   const labels = resolved.dataLabels;
   // Where the label sits on its mark: a bar or pie label placed inside the mark, and the labels of an area or a doughnut ring,
   // take the colour that contrasts with the mark; every other label keeps the chart text colour (as the preview does).
   const inside = kind === 'area' || kind === 'doughnut' || (['bar', 'pie', 'histogram', 'pareto', 'waterfall'].includes(kind) && INSIDE.has(labels.position));
-  const contrast = fill => typeof opfCore.textColorForFill === 'function' ? String(opfCore.textColorForFill(`#${fill}`, `#${labelColor}`)).replace(/^#/, '').toUpperCase() : labelColor;
-  const block = (color, {points = 0, leaderLines = false} = {}) =>
-    `<c:dLbls>${Array.from({length: points}, (_, index) => dLbl(index, inside ? contrast(palette[index % palette.length]) : labelColor, labels, {size: textSize, font})).join('')}` +
+  const contrast = fill => String(textColorForFill(`#${fill}`, `#${labelColor}`)).replace(/^#/, '').toUpperCase();
+  const block = (color, {points = 0, leaderLines = false, fills} = {}) =>
+    `<c:dLbls>${Array.from({length: points}, (_, index) => dLbl(index, inside ? contrast(fills?.[index] ?? palette[index % palette.length]) : labelColor, labels, {size: textSize, font})).join('')}` +
     `<c:numFmt formatCode="General" sourceLinked="0"/><c:spPr><a:noFill/><a:ln><a:noFill/></a:ln></c:spPr>${labelText(color, textSize, font)}${labelFlags(labels, {leaderLines})}</c:dLbls>`;
   const circular = kind === 'pie' || kind === 'doughnut';
   const replaceBlocks = (text, make) => text.replace(/<c:dLbls>[\s\S]*?<\/c:dLbls>/g, existing => make(existing));
@@ -98,7 +111,9 @@ export function applyDataLabels(xml, info) {
   const withSeries = xml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => {
     const index = seriesIndex++;
     const color = inside && !circular ? contrast(palette[index % palette.length]) : labelColor;
-    return replaceBlocks(ser, existing => block(color, {points: circular ? pointCount : 0, leaderLines: /<c:showLeaderLines\b/.test(existing)}));
+    const fills = highlight?.pointFills(index);
+    const points = circular ? pointCount : inside && fills ? fills.length : 0;
+    return replaceBlocks(ser, existing => block(color, {points, fills, leaderLines: /<c:showLeaderLines\b/.test(existing)}));
   });
   const outside = withSeries.split(/(<c:ser>[\s\S]*?<\/c:ser>)/);
   const groupLevel = outside.map((part, index) => index % 2 ? part : replaceBlocks(part, existing => block(labelColor, {leaderLines: /<c:showLeaderLines\b/.test(existing)}))).join('');
@@ -133,9 +148,7 @@ function titleString(title) {
  * plus `notes` naming what the three fields cannot express. `defaults` is what an export writes without the field:
  * `{legend: 'right' | undefined}` (a legend at the right of multi-series, pie and doughnut charts) and the chart kind.
  */
-export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCount, circular, scatter, seriesFormats = []}) {
-  // An older core's schema has no such fields (additionalProperties is false), so nothing is added to the imported chart.
-  if (!coreKnowsChartOptions()) return {options: {}, notes: []};
+export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCount, circular, scatter, seriesFormats = [], combo}) {
   const chart = chartSpace?.['c:chart'];
   const plotArea = chart?.['c:plotArea'];
   const out = {};
@@ -151,6 +164,9 @@ export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCo
     const category = titleString(asArray(plotArea?.['c:catAx'])[0]?.['c:title']), value = titleString(asArray(plotArea?.['c:valAx'])[0]?.['c:title']);
     if (category) axisTitles.category = category;
     if (value) axisTitles.value = value;
+    // FA-15: a combo chart's secondary value axis title.
+    const secondary = titleString(combo?.secondaryValueAxis?.['c:title']);
+    if (secondary) axisTitles.secondary = secondary;
   }
   if (Object.keys(axisTitles).length) out.axisTitles = axisTitles;
 
@@ -164,12 +180,12 @@ export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCo
     if (!(defaultLegend && position === 'right')) out.legend = position;
   } else if (defaultLegend) out.legend = 'none';
 
-  const dataLabels = classicDataLabels(chartNode, target, notes, seriesFormats);
+  const dataLabels = classicDataLabels(chartNode, target, notes, seriesFormats, combo);
   if (dataLabels !== undefined) out.dataLabels = dataLabels;
   return {options: out, notes};
 }
 
-function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
+function classicDataLabels(chartNode, target, notes, seriesFormats = [], combo) {
   const series = asArray(chartNode?.['c:ser']);
   // The labels the chart shows: the first series' block when it has one (PptxGenJS writes pie and doughnut visibility as per
   // point overrides), else the chart group's block.
@@ -186,12 +202,19 @@ function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
   for (const hidden of ['c:showSerName', 'c:showLegendKey', 'c:showBubbleSize']) {
     if (flag(source[hidden])) notes.push({option: 'dataLabels', message: `Data labels that show ${hidden.slice(6)} cannot be expressed; only category, value and percent import.`});
   }
-  const support = target && typeof opfCore.chartOptionSupport === 'function' ? opfCore.chartOptionSupport(target) : undefined;
+  const support = target ? chartOptionSupport(target) : undefined;
   const numberFormat = source['c:numFmt']?.formatCode ?? block['c:numFmt']?.formatCode;
   // RR-54: a label format that is a series' own number format imports with that column's format (or its own note).
   if (numberFormat && numberFormat !== 'General' && numberFormat !== '#,##0' && numberFormat !== '0%' && !seriesFormats.includes(numberFormat)) notes.push({option: 'dataLabels', message: `The label number format '${numberFormat}' cannot be expressed; labels import in the General format.`});
   const out = {};
-  const position = DLBL_POS_BACK[source['c:dLblPos']?.val ?? block['c:dLblPos']?.val];
+  let position = DLBL_POS_BACK[source['c:dLblPos']?.val ?? block['c:dLblPos']?.val];
+  if (combo) {
+    // FA-15: one OPF position covers both parts. A line position the columns cannot take (below, left, right) was asked for the
+    // lines; otherwise the column position (center, inside-end, inside-base) is the one, and 'center' is written to both.
+    const lineSeries = asArray(combo.lineNode?.['c:ser']).map(entry => entry?.['c:dLbls']).find(entry => entry !== undefined) ?? combo.lineNode?.['c:dLbls'];
+    const linePosition = DLBL_POS_BACK[lineSeries?.['c:dLblPos']?.val];
+    if (['below', 'left', 'right'].includes(linePosition)) position = linePosition;
+  }
   const supported = support?.dataLabels.positions ?? [];
   if (position && position !== support?.dataLabels.defaultPosition) {
     if (!support || supported.includes(position)) out.position = position;
@@ -204,9 +227,9 @@ function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
   return Object.keys(out).length ? out : true;
 }
 
-/** The core option target of a chart type id (undefined for an id outside the catalog or an older core). */
+/** The core option target of a chart type id (undefined for an id outside the catalog). */
 export function chartTargetFor(typeId) {
-  return typeof opfCore.chartOptionTarget === 'function' ? opfCore.chartOptionTarget(typeId) : undefined;
+  return chartOptionTarget(typeId);
 }
 
 // ---------------------------------------------------------------------------
@@ -233,7 +256,6 @@ function axisTitleText(axis) {
  * on a funnel), so only what differs from them is returned.
  */
 export function chartOptionsFromChartex(space, {type, seriesCount}) {
-  if (!coreKnowsChartOptions()) return {options: {}, notes: []};
   const chart = space?.['cx:chart'];
   const out = {};
   const notes = [];
@@ -262,7 +284,7 @@ export function chartOptionsFromChartex(space, {type, seriesCount}) {
     if (cxFlag(visibility.value)) content.push('value');
     if (cxFlag(visibility.seriesName)) notes.push({option: 'dataLabels', message: 'Chartex data labels that show the series name cannot be expressed; only category and value import.'});
     const position = CX_POSITION_BACK[labels.pos];
-    const support = typeof opfCore.chartOptionSupport === 'function' && typeof opfCore.chartOptionTarget === 'function' ? opfCore.chartOptionSupport(opfCore.chartOptionTarget(type) ?? {kind: type}) : undefined;
+    const support = chartOptionSupport(chartOptionTarget(type) ?? {kind: type});
     const isDefault = defaultContent && content.length === defaultContent.length && content.every((part, index) => part === defaultContent[index]) && (!position || position === 'center');
     const separator = text(labels['cx:separator']);
     const result = {};