@openpresentation/opf-pptx 0.11.2 → 0.11.3

package/DEPENDENCY-NOTES.md

@@ -2,7 +2,7 @@
 
 ## Coordinated `@openpresentation/opf` pin
 
-PPTX 0.11.2 depends on published [`@openpresentation/opf@^0.11.2`](https://www.npmjs.com/package/@openpresentation/opf) (reference layer: ColorRef, document `variables`, exported `resolveColorRef()`). The optional renderer peer is [`@openpresentation/opf-render@^0.11.0`](https://www.npmjs.com/package/@openpresentation/opf-render) so editor 0.10.0 + render 0.11.0 + pptx 0.11.0 install together. CI checks out OPF [`b8a1faf`](https://github.com/OpenPresentation/opf/commit/b8a1faf24203635bd36b09ea19f44bcd53781f16) (`opf-v0.11.0`) for coordinated source linking. Named content colors resolve through core `resolveColorRef()`; eight-digit hex alpha stays a local export concern because core `normalizeHexColor` drops the alpha byte. Native `schemeClr` / theme `clrScheme` writes remain follow-up work.
+PPTX 0.11.3 depends on published [`@openpresentation/opf@^0.11.2`](https://www.npmjs.com/package/@openpresentation/opf) (reference layer: ColorRef, document `variables`, exported `resolveColorRef()`). The optional renderer peer is [`@openpresentation/opf-render@^0.11.0`](https://www.npmjs.com/package/@openpresentation/opf-render) so editor 0.10.0 + render 0.11.0 + pptx 0.11.0 install together. CI checks out OPF [`b8a1faf`](https://github.com/OpenPresentation/opf/commit/b8a1faf24203635bd36b09ea19f44bcd53781f16) (`opf-v0.11.0`) for coordinated source linking. Named content colors resolve through core `resolveColorRef()`; eight-digit hex alpha stays a local export concern because core `normalizeHexColor` drops the alpha byte. The deck color scheme is written as the theme `clrScheme`, and named slot and role colors (text, table cells and borders, hyperlinks, backgrounds) are written as `schemeClr` where the deck theme holds exactly that color; card, timeline and media colors, literal hex, variables, translucent colors and slide-override colors stay literal `srgbClr`.
 
 OPF PPTX 0.5.1 ships the exact, unmodified PptxGenJS 4.0.1 ESM distribution in `vendor/pptxgenjs`, with its MIT license, upstream archive integrity and per-file SHA-256 hashes. Its actual JSZip dependency is declared directly. Ordinary npm installations therefore omit the unused image-size parser without requiring consumer overrides. This removes the affected dependency; it does not patch the parser. Published OPF PPTX 0.5.0 retains the older graph.
 

package/README.md

@@ -1,6 +1,6 @@
 # OPF PPTX
 
-Version 0.11.2 exports the classic chart types as native chart constructs and writes named and default table colours, text pairs and hyperlink colours as theme references (no API or dependency change; resolved colours are unchanged). Version 0.11.1 exports `design.watermark` as a native picture (it re-imports) and embeds byte-identical media parts once, with no API or dependency change. Version 0.11.0 requires core `^0.11.2` (cover slides are centered between header and footer furniture) and the optional `@openpresentation/opf-render` peer `^0.11.0`; install them together so export and preview resolve the same core. Version 0.10.0 required core `^0.11.1` and the peer `^0.10.0`. It adds native slide-number and date fields, socials, slide-image treatments, theme color schemes, script-slot fonts and RTL, re-import of design and metadata references, native underline and current-body formatting on import, and UTC-canonical `zipDate` (see the changelog for the intentional contract changes).
+Version 0.11.3 adds the opt-in `toPptx({ chartex: 'native' })` export of the seven chartex chart types and always imports chartex charts (no API removed; the default output is unchanged). Version 0.11.2 exports the classic chart types as native chart constructs and writes named and default table colours, text pairs and hyperlink colours as theme references (no API or dependency change; resolved colours are unchanged). Version 0.11.1 exports `design.watermark` as a native picture (it re-imports) and embeds byte-identical media parts once, with no API or dependency change. Version 0.11.0 requires core `^0.11.2` (cover slides are centered between header and footer furniture) and the optional `@openpresentation/opf-render` peer `^0.11.0`; install them together so export and preview resolve the same core. Version 0.10.0 required core `^0.11.1` and the peer `^0.10.0`. It adds native slide-number and date fields, socials, slide-image treatments, theme color schemes, script-slot fonts and RTL, re-import of design and metadata references, native underline and current-body formatting on import, and UTC-canonical `zipDate` (see the changelog for the intentional contract changes).
 
 Version 0.9.1 kept core `^0.11.0` and raised the optional `@openpresentation/opf-render` peer to `^0.9.0` so it coexists with editor 0.8.0. ColorRef / `variables` on content colors still hex-resolve through core `resolveColorRef()` before PptxGenJS `srgbClr` export. Unrecognized run colors such as `color:'invalid'` still validate and fall back to the theme text color. Native DrawingML `schemeClr` and theme `clrScheme` writes, and native `p:hf` headers/footers, are not in this release. Import still flattens theme colors to hex. Metric, quote and timeline layout placeholders and the corrected text-bullet contract from 0.8.1 are retained.
 
@@ -80,8 +80,8 @@ The first exporter keeps the public API stable while using `pptxgenjs` internall
 
 - `Slide.title`, `Slide.subtitle`, and `Slide.tag` become editable text boxes, not PowerPoint master placeholders.
 - Root payloads, `blocks[]`, and promoted region keys become editable slide objects in deterministic regions. Promoted keys use the OPF 3x3 region vocabulary (`top`, `middle`, `bottom`, `left`, `center`, `right`).
-- Text, lists, metrics, quotes, timelines, code, tables, and inline-data charts are emitted as editable PowerPoint text, table, and chart objects. Content ColorRef values (hex, scheme slots/roles, and `var:<id>`) resolve through core `resolveColorRef()`. Slot and role names become native `a:schemeClr` references when the exported theme holds that exact color; hex, `var:<id>` and slide-override colors stay `a:srgbClr` (see [Theme color scheme](#theme-color-scheme)). Each classic chart type the core catalog keeps (one per Aspose.Slides `ChartType`: clustered/stacked/100% stacked column and bar, line and stacked line with or without markers, area/stacked/100% area, pie, doughnut, scatter with markers, radar/radar with markers/filled radar) is written as its exact native construct; deprecated core ids export as their replacement; other ids keep the previous best-effort mapping. Chartex types (treemap, histogram, pareto, box & whisker, waterfall, funnel, map) still export as clustered columns and report `chart-data-adapted` (`chartex-fallback`); a pie or doughnut chart plots only its first series and reports `chart-data-adapted` (`series-dropped`) when it has more.
-- A chart whose data is one column of values (a histogram or dot plot) has no category column. It exports as a native chart and reports `chart-data-adapted`: a histogram is binned into equal-width bins (Sturges' count, at most 50) and written as a column chart of the counts, and any other chart type plots the values against their row numbers. PowerPoint's own histogram chart is not exported (histogram is a column chart at this engine). Cells parse as in every chart ("12%", "$5" and "1,234" count) and cells that hold no number are skipped, not plotted as 0. Binned counts do not round-trip: re-importing the file gives a `Bin`/`Frequency` column chart, not the raw values. Chart data that cannot be plotted (no numbers, no rows, or an external data source), an empty table and unsupported content keep a placeholder frame with a plain-language description (never a dump of the source data or URLs) and report `chart-data-unplottable` or `content-placeholder` with a `reason`; content is never dropped without a diagnostic.
+- Text, lists, metrics, quotes, timelines, code, tables, and inline-data charts are emitted as editable PowerPoint text, table, and chart objects. Content ColorRef values (hex, scheme slots/roles, and `var:<id>`) resolve through core `resolveColorRef()`. Slot and role names become native `a:schemeClr` references when the exported theme holds that exact color; hex, `var:<id>` and slide-override colors stay `a:srgbClr` (see [Theme color scheme](#theme-color-scheme)). Each classic chart type the core catalog keeps (one per Aspose.Slides `ChartType`: clustered/stacked/100% stacked column and bar, line and stacked line with or without markers, area/stacked/100% area, pie, doughnut, scatter with markers, radar/radar with markers/filled radar) is written as its exact native construct; deprecated core ids export as their replacement; other ids keep the previous best-effort mapping. The chartex types (treemap, histogram, pareto, box & whisker, waterfall, funnel, map) export by default as clustered columns and report `chart-data-adapted` (`chartex-fallback`); with `chartex: "native"` they are written as native Office 2016 chartex parts (see [Chartex charts](#chartex-charts-ff-22b), opt-in pending native PowerPoint confirmation). A pie or doughnut chart (and, natively, a one-series chartex construct) plots only its first series and reports `chart-data-adapted` (`series-dropped`) when it has more.
+- A chart whose data is one column of values (a histogram or dot plot) has no category column. It exports as a native chart and reports `chart-data-adapted`: by default a histogram is binned into equal-width bins (Sturges' count, at most 50) and written as a column chart of the counts (`histogram-binned`; the binned counts do not round-trip), and any other chart type plots the values against their row numbers (`row-numbers`). With `chartex: "native"` a histogram or Pareto chart bins the values itself (PowerPoint's histogram with an explicit automatic bin count, no diagnostic) and re-imports as authored. Cells parse as in every chart ("12%", "$5" and "1,234" count) and cells that hold no number are skipped, not plotted as 0. Chart data that cannot be plotted (no numbers, no rows, or an external data source), an empty table and unsupported content keep a placeholder frame with a plain-language description (never a dump of the source data or URLs) and report `chart-data-unplottable` or `content-placeholder` with a `reason`; content is never dropped without a diagnostic.
 - Image assets are embedded only when supplied as data URIs, local paths, or host-resolved bytes/paths. Remote asset URLs are never fetched by the runtime path.
 - ZIP entries, generated chart/workbook part names, core-property timestamps, and nested chart workbook timestamps are normalized for reproducible bytes. [Export determinism](docs/export-determinism.md) lists the tested time zone, locale, clock and host-font controls and each known variance (WebP conversion, font registries, ICU segmentation, timestamps).
 - The package names only the document's chosen fonts. Chart text (data labels, axes, legend, titles) uses the chart slide's body font in `latin`/`ea`/`cs`; each embedded chart workbook uses the same fonts in its styles and theme; run `pitchFamily` follows the font scheme type (monospace is fixed pitch, serif is roman); and `docProps/app.xml` "Fonts Used" lists the fonts the package actually uses. The theme keeps PptxGenJS's per-script supplements (`THEME_SCRIPT_SUPPLEMENTS`) and empty `ea`/`cs` slots.
@@ -125,6 +125,24 @@ The first importer is mechanical and schema-compatible:
 
 There is no AI classification pass in the OSS runtime. Hosts can run optional cleanup or semantic remapping after `fromPptx` returns.
 
+## Chartex charts (FF-22b)
+
+**Opt-in.** `toPptx(document, {chartex: "native"})` enables the native chartex export described here. The default, `chartex: "fallback"`, keeps the clustered column export of the seven chartex ids byte for byte (`test/fixtures/chartex-fallback-main.json` pins it) with the `chartex-fallback` and `histogram-binned` diagnostics, because a malformed chartex part would make PowerPoint offer to repair the whole deck, and the parts are not yet confirmed in native PowerPoint (no Open XML SDK validation either). The default flips once the program's native check of the FF-22b deck set passes. Import of chartex parts is always on.
+
+With `chartex: "native"`, the seven kept chart types with no ECMA-376 construct are written as Office 2016 chartex parts (`ppt/charts/chartExN.xml`, `cx:chartSpace`, content type `application/vnd.ms-office.chartex+xml`), each with its chart style and colour style parts (`styleN.xml`, `colorsN.xml`) and the embedded workbook the data came from. PptxGenJS cannot write these parts, so the exporter first writes the classic clustered column chart of the same data and then post-processes the package (`src/chartex.js`): the slide's chart frame becomes an `mc:AlternateContent` whose `mc:Choice` (requiring the construct's chartex namespace) references the chartex part and whose `mc:Fallback` keeps the classic chart frame, so a reader without chartex support still shows the data as columns. Both parts share the workbook. `cx:series uniqueId` values are derived from the chart number, so the bytes stay deterministic.
+
+| OPF id | `cx:series layoutId` | Data (category-major) | Notes |
+|---|---|---|---|
+| `treemap` | `treemap` | `[Category, Value]`, first series | one tile per category, category data labels, one palette colour per tile |
+| `histogram` | `clusteredColumn` | `[Value]` or `[Category, Value]`, first series | a lone value column is binned by PowerPoint with an explicit automatic bin count (Scott's rule, `cx:binCount`); a category column bins by category (`cx:aggregation`) |
+| `pareto` | `clusteredColumn` owning a `paretoLine` | as histogram | the Office Pareto chart: sorted columns plus the cumulative-percentage line on a percentage axis |
+| `box-and-whisker` | `boxWhisker` | `[Category, S1, S2, ...]`, every series | rows with the same category form one box per series; exclusive quartiles, mean markers, outliers |
+| `waterfall` | `waterfall` | `[Category, Value]`, first series | connector lines; increases and decreases in the first two palette colours; no subtotals |
+| `funnel` | `funnel` | `[Category, Value]`, first series | value data labels |
+| `world` | `regionMap` | `[Region, Value]`, first series | no `cx:geoCache`: PowerPoint matches the region names and fetches the shapes from Bing Maps when the deck is opened online, and reports `chart-map-geodata`; offline, or where Office map data is disabled, the map shows no regions |
+
+The chart area, label colour, label font (`latin`/`ea`/`cs` in the chart's body font) and series colours follow the classic charts. Re-import (`fromPptx`) reads the chartex part first: the layoutIds name the OPF id (an owned `paretoLine` is `pareto`), `cx:strDim type="cat"` restores the categories and each `cx:numDim` a series, under the same 100,000-point and 1,000,000-cell bounds as classic chart caches; a lone value column comes back as authored. A chartex part with no OPF construct (sunburst) falls back to the `mc:Fallback` chart, or to a text placeholder when PowerPoint's own text fallback is all there is. Native PowerPoint rendering of each construct is confirmed through the program's bounded native sample, not by this package's tests.
+
 ## Languages, right-to-left text and script fonts
 
 The exporter reads the presentation `language` through core `resolveScriptFonts()` (FF-07; the model is core `docs/programs/font-fidelity-everywhere/script-font-model.md`):

package/dist/chart-types.js

@@ -29,19 +29,48 @@ export const CHART_TYPES = Object.freeze({
   radar: category('radar', { aspose: 'Radar', radarStyle: 'standard', markers: false }),
   'radar-with-markers': category('radar', { aspose: 'RadarWithMarkers', radarStyle: 'marker', markers: true }),
   'filled-radar': category('radar', { aspose: 'FilledRadar', radarStyle: 'filled', markers: false }),
-  treemap: { family: 'chartex', layoutId: 'treemap', aspose: 'Treemap' },
-  histogram: { family: 'chartex', layoutId: 'clusteredColumn', aspose: 'Histogram' },
-  pareto: { family: 'chartex', layoutId: 'clusteredColumn', aspose: 'ParetoLine' },
-  'box-and-whisker': { family: 'chartex', layoutId: 'boxWhisker', aspose: 'BoxAndWhisker' },
-  waterfall: { family: 'chartex', layoutId: 'waterfall', aspose: 'Waterfall' },
-  funnel: { family: 'chartex', layoutId: 'funnel', aspose: 'Funnel' },
-  world: { family: 'chartex', layoutId: 'regionMap', aspose: 'Map' },
+  // Office 2016 chartex constructs (cx:chartSpace, one cx:series per plot,
+  // named by layoutId). `requires` is the markup-compatibility namespace the
+  // slide's mc:Choice names, so older readers take the classic fallback.
+  // `series` is the number of value columns the construct plots.
+  treemap: chartex('treemap', 'Treemap', { requires: 'cx1', dimension: 'size', series: 1 }),
+  histogram: chartex('clusteredColumn', 'Histogram', { requires: 'cx1', binning: true, series: 1, axes: true }),
+  pareto: chartex('paretoLine', 'ParetoLine', { requires: 'cx1', binning: true, owner: 'clusteredColumn', series: 1, axes: true }),
+  'box-and-whisker': chartex('boxWhisker', 'BoxAndWhisker', { requires: 'cx1', series: Infinity, axes: true }),
+  waterfall: chartex('waterfall', 'Waterfall', { requires: 'cx1', series: 1, axes: true }),
+  funnel: chartex('funnel', 'Funnel', { requires: 'cx2', series: 1, axes: true }),
+  world: chartex('regionMap', 'Map', { requires: 'cx5', dimension: 'colorVal', series: 1 }),
 });
 
-// A chartex id (treemap, histogram, ...) has no classic construct; the exporter
-// writes it as a clustered column chart and reports chart-data-adapted.
+function chartex(layoutId, aspose, extra) {
+  return { family: 'chartex', layoutId, aspose, dimension: 'val', ...extra };
+}
+
+// The classic construct written as the mc:Fallback of every chartex chart, so a
+// reader without chartex support shows a clustered column chart of the same
+// workbook data.
 export const CHARTEX_FALLBACK = CHART_TYPES.column;
 
+// Markup-compatibility namespaces for `requires` (MS-ODRAWXML chartex
+// versions). PowerPoint 2016 and later understand all of them.
+export const CHARTEX_NAMESPACES = Object.freeze({
+  cx: 'http://schemas.microsoft.com/office/drawing/2014/chartex',
+  cx1: 'http://schemas.microsoft.com/office/drawing/2015/9/8/chartex',
+  cx2: 'http://schemas.microsoft.com/office/drawing/2015/10/21/chartex',
+  cx3: 'http://schemas.microsoft.com/office/drawing/2016/5/9/chartex',
+  cx4: 'http://schemas.microsoft.com/office/drawing/2016/5/10/chartex',
+  cx5: 'http://schemas.microsoft.com/office/drawing/2016/5/11/chartex',
+});
+
+// cx:series layoutIds of a chartex part (an owned paretoLine marks the Office
+// Pareto chart) -> kept OPF id, for import; null for sunburst and unknown layouts.
+export function chartTypeFromChartex(layoutIds) {
+  const ids = new Set(layoutIds);
+  if (ids.has('paretoLine')) return 'pareto';
+  for (const [id, spec] of Object.entries(CHART_TYPES)) if (spec.family === 'chartex' && ids.has(spec.layoutId)) return id;
+  return null;
+}
+
 const variants = (base, target) => Object.fromEntries([base, `${base}-2x`, `${base}-3x`].map((id) => [id, target]));
 
 // Deprecated core ids (opf 0.12.0 removes them) -> replacement id.

package/dist/chart-workbook.js

@@ -21,7 +21,8 @@ function relationship(entries,source,id){
 }
 function workbookContext(entries,chartPart){
  const chart=xml(entries,chartPart)?.chartSpace;
- const ref=relationship(entries,chartPart,chart?.externalData?.id);
+ // A classic part keeps c:externalData under c:chartSpace; a chartex part keeps cx:externalData under cx:chartData.
+ const ref=relationship(entries,chartPart,(chart?.externalData??chart?.chartData?.externalData)?.id);
  if(!ref?.type?.endsWith('/package')||!entries[ref.path])return undefined;
  // Read only bounded spreadsheet metadata. Never follow external workbook links.
  let size=0;
@@ -29,7 +30,8 @@ function workbookContext(entries,chartPart){
   if(!/^xl\/(workbook\.xml|_rels\/workbook\.xml\.rels|sharedStrings\.xml|worksheets\/[^/]+\.xml)$/.test(file.name))return false;
   size+=file.originalSize;if(size>16*1024*1024)throw Error('Chart workbook metadata exceeds the limit.');return true;
  }});
- const category=find(chart,'cat')[0]??find(chart,'xVal')[0],formula=category?.strRef?.f??category?.multiLvlStrRef?.f??category?.numRef?.f;
+ // The category range: c:cat/c:xVal references, or the chartex cx:strDim type="cat" formula.
+ const category=find(chart,'cat')[0]??find(chart,'xVal')[0]??find(chart,'strDim').find(dim=>dim?.type==='cat'),formula=category?.strRef?.f??category?.multiLvlStrRef?.f??category?.numRef?.f??(category?.type==='cat'?category?.f:undefined);
  // Infer a heading only for one contiguous vertical category range with a row
  // above it. Other chart/workbook arrangements remain explicitly unrecovered.
  const range=/^(?:'((?:[^']|'')+)'|([^'!]+))!\$?([A-Z]+)\$?(\d+):\$?([A-Z]+)\$?(\d+)$/i.exec(text(formula));

package/dist/chartex.js

@@ -0,0 +1,375 @@
+// Native Office 2016 chartex export and import (FF-22b).
+//
+// PptxGenJS cannot write a `cx:chartSpace` part, so a chartex chart (treemap,
+// histogram, pareto, box & whisker, waterfall, funnel, map) is exported in two
+// steps. PptxGenJS first writes the classic clustered column chart of the same
+// data, with its embedded workbook. The package is then post-processed here:
+// a `ppt/charts/chartExN.xml` part is added with `cx:chartData` (the workbook
+// ranges and their cached values) and one `cx:series` per plotted column,
+// together with its chart style and colour style parts, and the slide's chart
+// frame is wrapped in `mc:AlternateContent`: the `mc:Choice` (which requires
+// the chartex namespace of the construct) references the chartex part and the
+// `mc:Fallback` keeps the classic chart, so a reader without chartex support
+// still shows the data. Both parts share the workbook.
+//
+// Import reads the chartex part back: the `cx:series` layoutIds name the OPF
+// chart type (an owned `paretoLine` marks the Office Pareto chart), and the
+// cached dimensions restore the category-major data.
+import {CHARTEX_NAMESPACES, chartTypeFromChartex} from './chart-types.js';
+
+const NS = Object.freeze({
+  a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
+  r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+  mc: 'http://schemas.openxmlformats.org/markup-compatibility/2006',
+  cs: 'http://schemas.microsoft.com/office/drawing/2012/chartStyle',
+  cx: CHARTEX_NAMESPACES.cx,
+});
+
+export const CHARTEX_CONTENT_TYPES = Object.freeze({
+  chart: 'application/vnd.ms-office.chartex+xml',
+  style: 'application/vnd.ms-office.chartstyle+xml',
+  colors: 'application/vnd.ms-office.chartcolorstyle+xml',
+});
+
+export const CHARTEX_RELATIONSHIP_TYPES = Object.freeze({
+  chart: 'http://schemas.microsoft.com/office/2014/relationships/chartEx',
+  style: 'http://schemas.microsoft.com/office/2011/relationships/chartStyle',
+  colors: 'http://schemas.microsoft.com/office/2011/relationships/chartColorStyle',
+  package: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/package',
+});
+
+export const CHARTEX_GRAPHIC_DATA_URI = NS.cx;
+
+const decoder = new TextDecoder(), encoder = new TextEncoder();
+const text = bytes => decoder.decode(bytes);
+const escapeXml = value => String(value).replace(/[&<>"']/g, char => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;'}[char]));
+
+/** Excel column letters for a 1-based column index (1 = A, 27 = AA). */
+export function columnLetters(index) {
+  let name = '';
+  for (let n = index; n > 0; n = Math.floor((n - 1) / 26)) name = String.fromCharCode(65 + ((n - 1) % 26)) + name;
+  return name;
+}
+
+/**
+ * Office's automatic histogram bins: Scott's normal reference rule gives the bin
+ * width 3.49 * sd * n^(-1/3) (sample standard deviation), and the bins cover
+ * [min, max] from the minimum. Returns the bin count PowerPoint is told to use
+ * (`cx:binCount`), so the preview and the native chart agree on the bins.
+ */
+export function scottBinCount(values) {
+  const n = values.length;
+  if (n === 0) return 1;
+  let min = Infinity, max = -Infinity, mean = 0;
+  for (const value of values) { if (value < min) min = value; if (value > max) max = value; mean += value / n; }
+  if (!(max > min) || n < 2) return 1;
+  let variance = 0;
+  for (const value of values) variance += (value - mean) * (value - mean) / (n - 1);
+  const width = 3.49 * Math.sqrt(variance) * Math.cbrt(n) ** -1;
+  if (!(width > 0) || !Number.isFinite(width)) return 1;
+  const count = Math.ceil((max - min) / width - 1e-9);
+  return Number.isFinite(count) && count >= 1 ? count : 1;
+}
+
+// A deterministic GUID for cx:series uniqueId, from the chart number and
+// series index (FNV-1a over the key, repeated for each hex group).
+function seriesUniqueId(chart, index) {
+  const hex = (seed, length) => {
+    let hash = 0x811c9dc5 ^ seed;
+    const key = `chartEx${chart}:${index}:${seed}`;
+    for (let i = 0; i < key.length; i++) { hash ^= key.charCodeAt(i); hash = Math.imul(hash, 0x01000193) >>> 0; }
+    return hash.toString(16).toUpperCase().padStart(8, '0').repeat(2).slice(0, length);
+  };
+  return `{${hex(1, 8)}-${hex(2, 4)}-4${hex(3, 3)}-8${hex(4, 3)}-${hex(5, 12)}}`;
+}
+
+function solidFill(hex, alpha) {
+  return `<a:solidFill>${alpha === undefined ? `<a:srgbClr val="${hex}"/>` : `<a:srgbClr val="${hex}"><a:alpha val="${alpha}"/></a:srgbClr>`}</a:solidFill>`;
+}
+
+function numberText(value) {
+  return String(value);
+}
+
+// The layout properties of the plotted series (CT_SeriesLayoutProperties order:
+// parentLabelLayout, regionLabelLayout, visibility, aggregation, binning,
+// geography, statistics, subtotals).
+function layoutProperties(spec, series, hasCategories) {
+  switch (spec.layoutId) {
+    case 'treemap':
+      return '<cx:layoutPr><cx:parentLabelLayout val="none"/></cx:layoutPr>';
+    case 'clusteredColumn':
+    case 'paretoLine':
+      // A category column bins by category (Office "By category"); a lone value column is binned automatically (Scott's rule, made explicit).
+      if (hasCategories) return '<cx:layoutPr><cx:aggregation/></cx:layoutPr>';
+      return `<cx:layoutPr><cx:binning intervalClosed="r" underflow="auto" overflow="auto"><cx:binCount val="${scottBinCount(series.values.filter(value => value !== null && Number.isFinite(value)))}"/></cx:binning></cx:layoutPr>`;
+    case 'boxWhisker':
+      return '<cx:layoutPr><cx:visibility meanLine="0" meanMarker="1" nonoutliers="0" outliers="1"/><cx:statistics quartileMethod="exclusive"/></cx:layoutPr>';
+    case 'waterfall':
+      return '<cx:layoutPr><cx:visibility connectorLines="1"/></cx:layoutPr>';
+    case 'regionMap':
+      // No cx:geoCache: PowerPoint fetches the region shapes from Bing Maps when the deck is opened online (see chart-map-geodata).
+      return '<cx:layoutPr><cx:geography cultureLanguage="en-US" cultureRegion="US" attribution="Powered by Bing"/></cx:layoutPr>';
+    default:
+      return '';
+  }
+}
+
+function dataLabels(spec) {
+  if (spec.layoutId === 'treemap') return '<cx:dataLabels pos="inEnd"><cx:visibility seriesName="0" categoryName="1" value="0"/></cx:dataLabels>';
+  if (spec.layoutId === 'funnel') return '<cx:dataLabels pos="ctr"><cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels>';
+  return '';
+}
+
+// Per-point fills where the construct colours points, not series: a treemap
+// tile per category, a waterfall bar by sign. The preview paints the same.
+export function chartexPointColors(layoutId, values, palette) {
+  if (layoutId === 'treemap') return values.map((value, index) => value === null ? null : palette[index % palette.length]);
+  if (layoutId === 'waterfall') return values.map(value => value === null ? null : palette[value < 0 ? 1 : 0]);
+  return values.map(() => null);
+}
+
+function axes(spec, gridColor) {
+  if (!spec.axes) return '';
+  const gridlines = `<cx:majorGridlines><cx:spPr><a:ln w="9525"><a:solidFill><a:srgbClr val="${gridColor}"><a:alpha val="70000"/></a:srgbClr></a:solidFill></a:ln></cx:spPr></cx:majorGridlines>`;
+  const gapWidth = {clusteredColumn: '0.06', paretoLine: '0.06', boxWhisker: '1', waterfall: '0.5', funnel: '0.06'}[spec.layoutId] ?? '1';
+  const category = `<cx:axis id="0"><cx:catScaling gapWidth="${gapWidth}"/><cx:tickLabels/></cx:axis>`;
+  if (spec.layoutId === 'funnel') return `${category}<cx:axis id="1" hidden="1"><cx:valScaling/><cx:tickLabels/></cx:axis>`;
+  const value = `<cx:axis id="1"><cx:valScaling/>${gridlines}<cx:tickLabels/></cx:axis>`;
+  const percentage = spec.layoutId === 'paretoLine' ? '<cx:axis id="2"><cx:valScaling max="1" min="0"/><cx:units unit="percentage"/><cx:tickLabels/></cx:axis>' : '';
+  return `${category}${value}${percentage}`;
+}
+
+/**
+ * The cx:chartSpace part for one chart. `series` is the exporter's plotted
+ * series ({name, labels, values}); `hasCategories` says whether the first data
+ * column held category labels (a lone value column has none). The workbook
+ * layout is PptxGenJS's: Sheet1, headings in row 1, categories in column A and
+ * one series per following column.
+ */
+export function chartexPartXml({spec, series, hasCategories, number, workbookRelId, fill, labelColor, gridColor, font, palette}) {
+  const rows = series[0].labels.length;
+  const range = (letter) => `Sheet1!$${letter}$2:$${letter}$${rows + 1}`;
+  const categories = hasCategories
+    ? `<cx:strDim type="cat"><cx:f>${range('A')}</cx:f><cx:lvl ptCount="${rows}">${series[0].labels.map((label, index) => `<cx:pt idx="${index}">${escapeXml(label)}</cx:pt>`).join('')}</cx:lvl></cx:strDim>`
+    : '';
+  const data = series.map((entry, index) => {
+    const points = entry.values.map((value, row) => value === null || !Number.isFinite(value) ? '' : `<cx:pt idx="${row}">${numberText(value)}</cx:pt>`).join('');
+    return `<cx:data id="${index}">${categories}<cx:numDim type="${spec.dimension}"><cx:f>${range(columnLetters(index + 2))}</cx:f><cx:lvl ptCount="${rows}" formatCode="General">${points}</cx:lvl></cx:numDim></cx:data>`;
+  }).join('');
+  const plotted = series.map((entry, index) => {
+    const color = palette[index % palette.length];
+    const letter = columnLetters(index + 2);
+    const pointFills = chartexPointColors(spec.layoutId, entry.values, palette)
+      .map((pointColor, row) => pointColor ? `<cx:dataPt idx="${row}"><cx:spPr>${solidFill(pointColor)}</cx:spPr></cx:dataPt>` : '').join('');
+    return `<cx:series layoutId="${spec.owner ?? spec.layoutId}" uniqueId="${seriesUniqueId(number, index)}">` +
+      `<cx:tx><cx:txData><cx:f>Sheet1!$${letter}$1</cx:f><cx:v>${escapeXml(entry.name)}</cx:v></cx:txData></cx:tx>` +
+      `<cx:spPr>${solidFill(color)}</cx:spPr>${pointFills}${dataLabels(spec)}<cx:dataId val="${index}"/>${layoutProperties(spec, entry, hasCategories)}` +
+      (spec.axes ? '<cx:axisId val="0"/><cx:axisId val="1"/>' : '') + '</cx:series>';
+  });
+  if (spec.owner) {
+    // The Office Pareto chart: the cumulative-percentage line owned by the binned columns, on the percentage axis.
+    plotted.push(`<cx:series layoutId="${spec.layoutId}" ownerIdx="0" uniqueId="${seriesUniqueId(number, series.length)}"><cx:spPr><a:ln w="19050"><a:solidFill><a:srgbClr val="${palette[1 % palette.length]}"/></a:solidFill></a:ln></cx:spPr><cx:axisId val="0"/><cx:axisId val="2"/></cx:series>`);
+  }
+  const legend = spec.layoutId === 'boxWhisker' && series.length > 1 ? '<cx:legend pos="r" align="ctr" overlay="0"/>' : '';
+  const alpha = fill.transparency > 0 ? Math.round((100 - fill.transparency) * 1000) : undefined;
+  const face = escapeXml(font);
+  return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+    `<cx:chartSpace xmlns:a="${NS.a}" xmlns:r="${NS.r}" xmlns:cx="${NS.cx}">` +
+    `<cx:chartData><cx:externalData r:id="${workbookRelId}" cx:autoUpdate="0"/>${data}</cx:chartData>` +
+    `<cx:chart><cx:plotArea><cx:plotAreaRegion>${plotted.join('')}</cx:plotAreaRegion>${axes(spec, gridColor)}</cx:plotArea>${legend}</cx:chart>` +
+    `<cx:spPr>${solidFill(fill.color, alpha)}<a:ln><a:noFill/></a:ln></cx:spPr>` +
+    `<cx:txPr><a:bodyPr/><a:lstStyle/><a:p><a:pPr><a:defRPr sz="900">${solidFill(labelColor)}<a:latin typeface="${face}"/><a:ea typeface="${face}"/><a:cs typeface="${face}"/></a:defRPr></a:pPr><a:endParaRPr lang="en-US"/></a:p></cx:txPr>` +
+    '</cx:chartSpace>';
+}
+
+export function chartexRelationshipsXml({workbookTarget, number}) {
+  return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+    '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' +
+    `<Relationship Id="rId1" Type="${CHARTEX_RELATIONSHIP_TYPES.package}" Target="${escapeXml(workbookTarget)}"/>` +
+    `<Relationship Id="rId2" Type="${CHARTEX_RELATIONSHIP_TYPES.style}" Target="style${number}.xml"/>` +
+    `<Relationship Id="rId3" Type="${CHARTEX_RELATIONSHIP_TYPES.colors}" Target="colors${number}.xml"/>` +
+    '</Relationships>';
+}
+
+// Chart style part (cs:chartStyle, style 201): every CT_StyleEntry the schema
+// requires, in schema order, with the Office 2013+ default references. Series
+// and point fills in the chartex part are explicit, so the style only governs
+// text and chrome PowerPoint draws itself.
+const STYLE_ENTRIES = [
+  'axisTitle', 'categoryAxis', 'chartArea', 'dataLabel', 'dataLabelCallout', 'dataPoint', 'dataPoint3D', 'dataPointLine', 'dataPointMarker',
+  'dataPointMarkerLayout', 'dataPointWireframe', 'dataTable', 'downBar', 'dropLine', 'errorBar', 'floor', 'gridlineMajor', 'gridlineMinor', 'hiLoLine',
+  'leaderLine', 'legend', 'plotArea', 'plotArea3D', 'seriesAxis', 'seriesLine', 'title', 'trendline', 'trendlineLabel', 'upBar', 'valueAxis', 'wall',
+];
+export function chartStyleXml() {
+  const textColor = '<a:schemeClr val="tx1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr>';
+  const faintLine = '<a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="15000"/><a:lumOff val="85000"/></a:schemeClr></a:solidFill><a:round/></a:ln>';
+  const entry = (name, {fillIdx = '0', fillColor = '', fontColor = '<a:schemeClr val="tx1"/>', spPr = '', size = '', mods = ''} = {}) =>
+    `<cs:${name}${mods ? ` mods="${mods}"` : ''}><cs:lnRef idx="0"/><cs:fillRef idx="${fillIdx}">${fillColor}</cs:fillRef><cs:effectRef idx="0"/><cs:fontRef idx="minor">${fontColor}</cs:fontRef>${spPr ? `<cs:spPr>${spPr}</cs:spPr>` : ''}${size ? `<cs:defRPr sz="${size}" kern="1200"/>` : ''}</cs:${name}>`;
+  const entries = STYLE_ENTRIES.map(name => {
+    switch (name) {
+      case 'dataPointMarkerLayout': return '<cs:dataPointMarkerLayout symbol="circle" size="5"/>';
+      case 'axisTitle': return entry(name, {fontColor: textColor, size: '1000'});
+      case 'categoryAxis': case 'valueAxis': case 'seriesAxis': return entry(name, {fontColor: textColor, spPr: faintLine, size: '900'});
+      case 'chartArea': return entry(name, {mods: 'allowNoFillOverride allowNoLineOverride', spPr: `<a:solidFill><a:schemeClr val="bg1"/></a:solidFill>${faintLine}`, size: '1000'});
+      case 'dataLabel': case 'dataLabelCallout': case 'dataTable': case 'legend': case 'trendlineLabel': return entry(name, {fontColor: textColor, size: '900'});
+      case 'dataPoint': case 'dataPoint3D': case 'dataPointWireframe': case 'upBar': case 'floor': case 'wall':
+        return entry(name, {fillIdx: '1', fillColor: '<cs:styleClr val="auto"/>', spPr: '<a:solidFill><a:schemeClr val="phClr"/></a:solidFill>'});
+      case 'dataPointLine': case 'dataPointMarker': case 'trendline': case 'seriesLine': case 'hiLoLine': case 'dropLine': case 'leaderLine': case 'errorBar':
+        return entry(name, {fillColor: '<cs:styleClr val="auto"/>', spPr: '<a:ln w="28575" cap="rnd"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:round/></a:ln>'});
+      case 'downBar': return entry(name, {fillIdx: '1', spPr: '<a:solidFill><a:schemeClr val="dk1"><a:lumMod val="65000"/><a:lumOff val="35000"/></a:schemeClr></a:solidFill>'});
+      case 'gridlineMajor': case 'gridlineMinor': return entry(name, {spPr: faintLine});
+      case 'title': return entry(name, {fontColor: textColor, size: '1400'});
+      default: return entry(name);
+    }
+  }).join('');
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cs:chartStyle xmlns:cs="${NS.cs}" xmlns:a="${NS.a}" id="201">${entries}</cs:chartStyle>`;
+}
+
+// Colour style part (cs:colorStyle, colourful palette 10): the six theme
+// accents with the standard Office variations.
+export function chartColorStyleXml() {
+  const variations = ['', '<a:lumMod val="60000"/>', '<a:lumMod val="80000"/><a:lumOff val="20000"/>', '<a:lumMod val="80000"/>', '<a:lumMod val="60000"/><a:lumOff val="40000"/>',
+    '<a:lumMod val="50000"/>', '<a:lumMod val="70000"/><a:lumOff val="30000"/>', '<a:lumMod val="70000"/>', '<a:lumMod val="50000"/><a:lumOff val="50000"/>'];
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cs:colorStyle xmlns:cs="${NS.cs}" xmlns:a="${NS.a}" meth="cycle" id="10">` +
+    [1, 2, 3, 4, 5, 6].map(n => `<a:schemeClr val="accent${n}"/>`).join('') + variations.map(v => `<cs:variation>${v}</cs:variation>`).join('') + '</cs:colorStyle>';
+}
+
+/**
+ * Wrap the PptxGenJS chart frame: the mc:Choice references the chartex part,
+ * the mc:Fallback keeps the classic chart frame. The choice frame copies the
+ * name, id, description and transform of the original.
+ */
+export function wrapChartexFrame(frame, relId, requires) {
+  const namespace = CHARTEX_NAMESPACES[requires];
+  if (!namespace) throw new Error(`Unknown chartex namespace ${requires}.`);
+  const head = frame.match(/^<p:graphicFrame>[\s\S]*?<\/p:xfrm>/)?.[0];
+  if (!head) throw new Error('Generated chart frame has no transform.');
+  const choice = `${head}<a:graphic xmlns:a="${NS.a}"><a:graphicData uri="${NS.cx}"><cx:chart xmlns:cx="${NS.cx}" xmlns:r="${NS.r}" r:id="${relId}"/></a:graphicData></a:graphic></p:graphicFrame>`;
+  return `<mc:AlternateContent xmlns:mc="${NS.mc}"><mc:Choice xmlns:${requires}="${namespace}" Requires="${requires}">${choice}</mc:Choice><mc:Fallback>${frame}</mc:Fallback></mc:AlternateContent>`;
+}
+
+/**
+ * Add the chartex parts for every chart the exporter registered in
+ * `context.chartex` (by frame name), in slide order. Runs on the unzipped
+ * package after the classic chart parts have their fonts and headings.
+ */
+export function attachChartexParts(entries, chartex, parseRelationships) {
+  if (!chartex.size) return;
+  const slides = Object.keys(entries).filter(part => /^ppt\/slides\/slide\d+\.xml$/.test(part)).sort((a, b) => Number(a.match(/(\d+)\.xml$/)[1]) - Number(b.match(/(\d+)\.xml$/)[1]));
+  const overrides = [];
+  let number = 0;
+  for (const part of slides) {
+    const relationships = parseRelationships(entries, part);
+    const relsPart = part.replace(/([^/]+)$/, '_rels/$1.rels');
+    let rels = text(entries[relsPart]);
+    let nextId = Math.max(0, ...[...rels.matchAll(/\bId="rId(\d+)"/g)].map(match => Number(match[1]))) + 1;
+    let xml = text(entries[part]);
+    let changed = false;
+    xml = xml.replace(/<p:graphicFrame>[\s\S]*?<\/p:graphicFrame>/g, frame => {
+      const name = frame.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1];
+      const chart = chartex.get(name);
+      if (!chart) return frame;
+      const chartPart = relationships.get(frame.match(/<c:chart\b[^>]*\br:id="([^"]+)"/)?.[1])?.path;
+      if (!chartPart) throw new Error('Generated chart relationship is missing.');
+      const workbook = [...parseRelationships(entries, chartPart).values()].find(relationship => relationship.type === CHARTEX_RELATIONSHIP_TYPES.package);
+      if (!workbook) throw new Error('Generated chart has no embedded workbook.');
+      number += 1;
+      const base = `ppt/charts/chartEx${number}.xml`;
+      entries[base] = encoder.encode(chartexPartXml({...chart, number, workbookRelId: 'rId1'}));
+      entries[`ppt/charts/_rels/chartEx${number}.xml.rels`] = encoder.encode(chartexRelationshipsXml({workbookTarget: workbook.target, number}));
+      entries[`ppt/charts/style${number}.xml`] = encoder.encode(chartStyleXml());
+      entries[`ppt/charts/colors${number}.xml`] = encoder.encode(chartColorStyleXml());
+      overrides.push(`<Override PartName="/${base}" ContentType="${CHARTEX_CONTENT_TYPES.chart}"/>`,
+        `<Override PartName="/ppt/charts/style${number}.xml" ContentType="${CHARTEX_CONTENT_TYPES.style}"/>`,
+        `<Override PartName="/ppt/charts/colors${number}.xml" ContentType="${CHARTEX_CONTENT_TYPES.colors}"/>`);
+      const relId = `rId${nextId++}`;
+      rels = rels.replace('</Relationships>', `<Relationship Id="${relId}" Type="${CHARTEX_RELATIONSHIP_TYPES.chart}" Target="../charts/chartEx${number}.xml"/></Relationships>`);
+      changed = true;
+      return wrapChartexFrame(frame, relId, chart.spec.requires);
+    });
+    if (!changed) continue;
+    entries[part] = encoder.encode(xml);
+    entries[relsPart] = encoder.encode(rels);
+  }
+  if (overrides.length) entries['[Content_Types].xml'] = encoder.encode(text(entries['[Content_Types].xml']).replace('</Types>', `${overrides.join('')}</Types>`));
+}
+
+// ---------------------------------------------------------------------------
+// Import
+
+const asArray = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
+const scalar = value => typeof value === 'string' ? value : value && typeof value === 'object' ? String(value['#text'] ?? '') : value === undefined ? '' : String(value);
+
+/**
+ * Read a parsed cx:chartSpace (fast-xml-parser, prefixes kept, attributes as
+ * plain keys) back to an OPF chart. Returns null when no cx:series names a
+ * kept OPF chart type (sunburst has no OPF record). `heading` is the category
+ * heading recovered from the workbook, `limits` the cache bounds
+ * ({points, cells}) and `invalid(message, path)` throws the import error.
+ */
+export function chartFromChartex(doc, {heading, limits, invalid, path}) {
+  const space = doc?.['cx:chartSpace'];
+  const region = space?.['cx:chart']?.['cx:plotArea']?.['cx:plotAreaRegion'];
+  const allSeries = asArray(region?.['cx:series']);
+  const type = chartTypeFromChartex(allSeries.map(series => series?.layoutId));
+  if (!type) return null;
+  const dataById = new Map(asArray(space?.['cx:chartData']?.['cx:data']).map(data => [String(data?.id ?? ''), data]));
+  const plotted = allSeries.filter(series => series?.ownerIdx === undefined && series?.['cx:dataId']?.val !== undefined);
+  if (!plotted.length) return null;
+  const integer = (raw, limit, location) => {
+    if (typeof raw !== 'string' || !/^[+-]?\d+$/.test(raw.trim())) invalid('expected an unsigned integer', location);
+    const value = Number(raw.trim());
+    if (!Number.isSafeInteger(value) || value < 0 || value > limit) invalid(`integer exceeds the supported range 0–${limit}`, location);
+    return value;
+  };
+  let cells = 0;
+  const level = (dimension, location, numeric) => {
+    const lvl = asArray(dimension?.['cx:lvl'])[0];
+    if (!lvl) return [];
+    const count = lvl.ptCount === undefined ? undefined : integer(lvl.ptCount, limits.points, `${location}/cx:lvl@ptCount`);
+    const points = asArray(lvl['cx:pt']);
+    if (points.length > limits.points) invalid('too many points', location);
+    let extent = count ?? 0;
+    const indexed = new Map();
+    for (const [position, point] of points.entries()) {
+      const at = `${location}/cx:lvl/cx:pt[${position}]@idx`;
+      const index = integer(point?.idx, limits.points - 1, at);
+      if (count !== undefined && index >= count) invalid('point index is outside its declared count', at);
+      if (indexed.has(index)) invalid('duplicate point index', at);
+      const value = scalar(point);
+      if (numeric) {
+        const parsed = value.trim() === '' ? null : Number(value);
+        if (parsed !== null && !Number.isFinite(parsed)) invalid('numeric point is not a finite number', at);
+        indexed.set(index, parsed);
+      } else indexed.set(index, value);
+      extent = Math.max(extent, index + 1);
+    }
+    cells += extent;
+    if (cells > limits.cells) invalid('combined caches exceed the 1,000,000-cell import limit', location);
+    const result = new Array(extent).fill(null);
+    for (const [index, value] of indexed) result[index] = value;
+    return result;
+  };
+  let labels = null;
+  const names = [], values = [];
+  plotted.forEach((series, index) => {
+    const data = dataById.get(String(series['cx:dataId'].val));
+    if (!data) invalid('series data is missing', `${path}#cx:series[${index}]/cx:dataId`);
+    const location = `${path}#cx:data[@id="${series['cx:dataId'].val}"]`;
+    const categories = asArray(data['cx:strDim']).find(dimension => dimension?.type === 'cat');
+    if (categories && !labels) labels = level(categories, `${location}/cx:strDim`, false);
+    const numeric = asArray(data['cx:numDim'])[0];
+    values.push(numeric ? level(numeric, `${location}/cx:numDim`, true) : []);
+    const name = series['cx:tx']?.['cx:txData']?.['cx:v'];
+    names.push(name === undefined ? `Series ${index + 1}` : scalar(name));
+  });
+  const rowCount = values.reduce((count, row) => Math.max(count, row.length), labels?.length ?? 0);
+  if (rowCount === 0) return null;
+  if (rowCount * (values.length + (labels ? 1 : 0)) > limits.cells) invalid('chart cache exceeds the 1,000,000-cell import limit', path);
+  // A histogram or Pareto chart binned from one value column has no category dimension: the column comes back as authored.
+  if (!labels) return {type, data: {columns: [names[0]], rows: values[0].slice(0, rowCount).map((value, index) => [values[0][index] ?? null])}};
+  const rows = [];
+  for (let index = 0; index < rowCount; index += 1) rows.push([labels[index] ?? null, ...values.map(row => row[index] ?? null)]);
+  return {type, data: {columns: [heading ?? 'Category', ...names], rows}};
+}

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';
@@ -224,7 +225,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).
@@ -613,6 +621,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 +685,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 +924,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) {
@@ -1614,7 +1651,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 +1670,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 +1689,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}},
@@ -2164,7 +2211,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 +2220,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 +2243,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 +2260,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 +2272,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 +2292,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 +2308,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})`}));
   }
@@ -2486,6 +2541,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 +2596,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/script-fonts.js

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -37,8 +37,8 @@
   "sideEffects": false,
   "scripts": {
     "build": "node scripts/build.mjs",
-    "typecheck": "node --check src/index.js && node --check src/chart-types.js && node --check test/chart-types.mjs && node --check test/design-alignment.mjs && node --check src/color-ref.js && node --check src/theme-colors.js && node --check test/theme-colors.mjs && node --check test/table-theme-colors.mjs && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check src/slide-image-provenance.js && node --check test/slide-image.mjs && node --check test/slide-image-treatments.mjs && node --check src/watermark-provenance.js && node --check src/media-dedupe.js && node --check test/media-dedupe.mjs && node --check test/watermark.mjs && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs && node --check test/rich-table.mjs && node --check src/table-import.js && node --check test/rich-table-import.mjs && node --check test/rich-table-import-browser.js && node --check test/table-row-sizing.mjs && node --check test/table-styles.mjs && node --check test/table-styles-browser.js && node --check test/styled-table.mjs && node --check src/table-cell-import.js && node --check test/styled-table-import.mjs && node --check test/styled-table-import-browser.js && node --check src/table-border-import.js && node --check test/table-border-styles.mjs && node --check src/card-provenance.js && node --check test/content-cards.mjs && node --check src/chart-workbook.js && node --check test/chart-colors.mjs && node --check test/chart-workbook.mjs && node --check test/single-column-chart.mjs && node --check test/native-chart-colors.mjs && node --check src/heading-provenance.js && node --check test/accepted-text.mjs && node --check test/heading-provenance.mjs && node --check src/text-provenance.js && node --check test/plain-whitespace.mjs && node --check src/timeline-provenance.js && node --check test/shared-timeline.mjs && node --check test/shared-furniture.mjs && node --check src/furniture-provenance.js && node --check src/document-provenance.js && node --check test/document-provenance.mjs && node --check test/furniture-provenance.mjs && node --check src/furniture-fields.js && node --check test/furniture-fields.mjs && node --check test/furniture-wrapped-date.mjs && node --check test/native-picture.mjs && node --check test/compare-native-picture.mjs && node --check test/compare-native-picture-edit.mjs && node --check test/compare-native-picture-edit-controls.mjs && node --check test/native-font-embed-audit.mjs && node --check test/native-font-embed-controls.mjs && node --check test/native-font-embed-fixture-source.mjs && node --check test/native-font-edit-fixture.mjs && node --check test/native-mixed-edit-audit.mjs && node --check test/native-mixed-edit-controls.mjs && node --check test/master-bullet-font.mjs && node --check test/native-font-inventory-audit.mjs && node --check test/native-font-inventory-controls.mjs && node --check test/default-font-scheme.mjs && node --check test/export-chosen-fonts.mjs && node --check test/background-fills.mjs && node --check src/typeface-inventory.js && node --check src/package-fonts.js && node --check test/typeface-inventory.mjs && node --check src/script-fonts.js && node --check test/script-fonts.mjs && node --check test/powershell-scan.mjs && node --check test/powershell-scan-probes.mjs && node --check test/socials-furniture.mjs && node --check src/media-provenance.js && node --check test/layout-parity.mjs && node --check test/cover-centering.mjs && node --check test/media-placeholder.mjs && node --check test/image-placeholder.mjs && node --check test/list-shape-names.mjs && node --check test/layout-intent.mjs && node --check test/chart-cache-import.mjs && node --check test/zip-date.mjs && node --check test/native-text-whitespace.mjs && node --check test/native-underline.mjs && node --check src/native-text-style.js && node --check src/font-weights.js && node --check test/font-weight-import.mjs && node --check src/body-text-import.js && node --check test/native-body-rich-text.mjs && node --check test/native-body-rich-text-browser.js && node --check test/native-quote-import-contract.mjs && node --check test/native-quote-import-controls.mjs && node --check test/native-quote.mjs && node --check test/determinism.mjs && node --check test/determinism-fixtures.mjs && node --check test/table-frame-furniture-order.mjs && node --check test/shape-border-widths.mjs",
-    "test": "npm run build && node test/chart-types.mjs && node test/zip-date.mjs && node test/background-fills.mjs && npm run test:furniture && node test/slide-image.mjs && node test/slide-image-treatments.mjs && node test/watermark.mjs && node test/media-dedupe.mjs && node test/document-provenance.mjs && node test/layout-intent.mjs && node test/master-bullet-font.mjs && node test/default-font-scheme.mjs && node test/script-fonts.mjs && node test/export-chosen-fonts.mjs && node test/typeface-inventory.mjs && node test/color-ref-export.mjs && node test/theme-colors.mjs && node test/table-theme-colors.mjs && node test/plain-whitespace.mjs && node test/native-text-whitespace.mjs && node test/native-body-rich-text.mjs && node test/native-underline.mjs && node test/font-weight-import.mjs && node test/design-alignment.mjs && node test/accepted-text.mjs && node test/heading-provenance.mjs && node test/native-quote-import-controls.mjs && node test/chart-colors.mjs && node test/content-cards.mjs && node test/chart-workbook.mjs && node test/single-column-chart.mjs && node --test test/chart-cache-import.mjs && node test/dependency-boundary.mjs && npm run build:browser-check && npm run test:styled-table && node test/content-layout.mjs && node test/layout-parity.mjs && node test/cover-centering.mjs && node test/table-frame-furniture-order.mjs && node test/media-placeholder.mjs && node test/shape-border-widths.mjs && node test/image-placeholder.mjs && node test/list-shape-names.mjs && node test/shared-quote.mjs && npm run test:timeline && npm run test:determinism",
+    "typecheck": "node --check src/index.js && node --check src/chart-types.js && node --check src/chartex.js && node --check test/chartex.mjs && node --check test/chart-types.mjs && node --check test/design-alignment.mjs && node --check src/color-ref.js && node --check src/theme-colors.js && node --check test/theme-colors.mjs && node --check test/table-theme-colors.mjs && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check src/slide-image-provenance.js && node --check test/slide-image.mjs && node --check test/slide-image-treatments.mjs && node --check src/watermark-provenance.js && node --check src/media-dedupe.js && node --check test/media-dedupe.mjs && node --check test/watermark.mjs && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs && node --check test/rich-table.mjs && node --check src/table-import.js && node --check test/rich-table-import.mjs && node --check test/rich-table-import-browser.js && node --check test/table-row-sizing.mjs && node --check test/table-styles.mjs && node --check test/table-styles-browser.js && node --check test/styled-table.mjs && node --check src/table-cell-import.js && node --check test/styled-table-import.mjs && node --check test/styled-table-import-browser.js && node --check src/table-border-import.js && node --check test/table-border-styles.mjs && node --check src/card-provenance.js && node --check test/content-cards.mjs && node --check src/chart-workbook.js && node --check test/chart-colors.mjs && node --check test/chart-workbook.mjs && node --check test/single-column-chart.mjs && node --check test/native-chart-colors.mjs && node --check src/heading-provenance.js && node --check test/accepted-text.mjs && node --check test/heading-provenance.mjs && node --check src/text-provenance.js && node --check test/plain-whitespace.mjs && node --check src/timeline-provenance.js && node --check test/shared-timeline.mjs && node --check test/shared-furniture.mjs && node --check src/furniture-provenance.js && node --check src/document-provenance.js && node --check test/document-provenance.mjs && node --check test/furniture-provenance.mjs && node --check src/furniture-fields.js && node --check test/furniture-fields.mjs && node --check test/furniture-wrapped-date.mjs && node --check test/native-picture.mjs && node --check test/compare-native-picture.mjs && node --check test/compare-native-picture-edit.mjs && node --check test/compare-native-picture-edit-controls.mjs && node --check test/native-font-embed-audit.mjs && node --check test/native-font-embed-controls.mjs && node --check test/native-font-embed-fixture-source.mjs && node --check test/native-font-edit-fixture.mjs && node --check test/native-mixed-edit-audit.mjs && node --check test/native-mixed-edit-controls.mjs && node --check test/master-bullet-font.mjs && node --check test/native-font-inventory-audit.mjs && node --check test/native-font-inventory-controls.mjs && node --check test/default-font-scheme.mjs && node --check test/export-chosen-fonts.mjs && node --check test/background-fills.mjs && node --check src/typeface-inventory.js && node --check src/package-fonts.js && node --check test/typeface-inventory.mjs && node --check src/script-fonts.js && node --check test/script-fonts.mjs && node --check test/powershell-scan.mjs && node --check test/powershell-scan-probes.mjs && node --check test/socials-furniture.mjs && node --check src/media-provenance.js && node --check test/layout-parity.mjs && node --check test/cover-centering.mjs && node --check test/media-placeholder.mjs && node --check test/image-placeholder.mjs && node --check test/list-shape-names.mjs && node --check test/layout-intent.mjs && node --check test/chart-cache-import.mjs && node --check test/zip-date.mjs && node --check test/native-text-whitespace.mjs && node --check test/native-underline.mjs && node --check src/native-text-style.js && node --check src/font-weights.js && node --check test/font-weight-import.mjs && node --check src/body-text-import.js && node --check test/native-body-rich-text.mjs && node --check test/native-body-rich-text-browser.js && node --check test/native-quote-import-contract.mjs && node --check test/native-quote-import-controls.mjs && node --check test/native-quote.mjs && node --check test/determinism.mjs && node --check test/determinism-fixtures.mjs && node --check test/table-frame-furniture-order.mjs && node --check test/shape-border-widths.mjs",
+    "test": "npm run build && node test/chart-types.mjs && node test/chartex.mjs && node test/zip-date.mjs && node test/background-fills.mjs && npm run test:furniture && node test/slide-image.mjs && node test/slide-image-treatments.mjs && node test/watermark.mjs && node test/media-dedupe.mjs && node test/document-provenance.mjs && node test/layout-intent.mjs && node test/master-bullet-font.mjs && node test/default-font-scheme.mjs && node test/script-fonts.mjs && node test/export-chosen-fonts.mjs && node test/typeface-inventory.mjs && node test/color-ref-export.mjs && node test/theme-colors.mjs && node test/table-theme-colors.mjs && node test/plain-whitespace.mjs && node test/native-text-whitespace.mjs && node test/native-body-rich-text.mjs && node test/native-underline.mjs && node test/font-weight-import.mjs && node test/design-alignment.mjs && node test/accepted-text.mjs && node test/heading-provenance.mjs && node test/native-quote-import-controls.mjs && node test/chart-colors.mjs && node test/content-cards.mjs && node test/chart-workbook.mjs && node test/single-column-chart.mjs && node --test test/chart-cache-import.mjs && node test/dependency-boundary.mjs && npm run build:browser-check && npm run test:styled-table && node test/content-layout.mjs && node test/layout-parity.mjs && node test/cover-centering.mjs && node test/table-frame-furniture-order.mjs && node test/media-placeholder.mjs && node test/shape-border-widths.mjs && node test/image-placeholder.mjs && node test/list-shape-names.mjs && node test/shared-quote.mjs && npm run test:timeline && npm run test:determinism",
     "validate": "node scripts/validate-package.mjs",
     "test:packed": "node test/packed-install.mjs",
     "test:compare-published": "node test/compare-published.mjs",