@openpresentation/opf-pptx 0.11.2 → 0.11.4

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.4 depends on published [`@openpresentation/opf@^0.11.3`](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.4 re-imports quote payloads (each native quote line carries an `OPF_QUOTE_V1` tag) and slide-image payloads from an unchanged export, writes the theme's `a:ea` and `a:cs` only for slots a script font is selected for, and requires core `^0.11.3` (the 70 legacy gallery layout ids and their geometry; install it with renderer 0.11.6 and editor 0.10.4 so export and preview resolve the same core; no API removed). 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.
 
@@ -24,7 +24,7 @@ Version 0.8.0 also measures `design.contentBox` cards through core's padded inte
 
 ## Scope
 
-Version 0.8.0 requires core 0.10.0 and uses renderer 0.8.0 for coordinated preview/font measurement. Quotes and code export their accepted internal lines and styles without another fitting pass. [Controlled Windows PowerPoint quote evidence](docs/evidence/shared-quote-integration/comparison.json) records glyph containment, separation, save/reopen and text reimport against its exact source/font hashes. Native quote import returns editable text blocks and does not restore the original OPF quote structure, typography or readability policy. Native chart geometry and general scalar-text wrapping also remain different from preview; editability and valid reimport do not establish raster equivalence.
+Version 0.8.0 requires core 0.10.0 and uses renderer 0.8.0 for coordinated preview/font measurement. Quotes and code export their accepted internal lines and styles without another fitting pass. [Controlled Windows PowerPoint quote evidence](docs/evidence/shared-quote-integration/comparison.json) records glyph containment, separation, save/reopen and text reimport against its exact source/font hashes. Native quote import restores the quote payload from an unchanged export (see [Quote provenance](#quote-provenance-ff-57)); it does not restore the original typography or readability policy, and an edited or damaged quote imports as editable text blocks. Native chart geometry and general scalar-text wrapping also remain different from preview; editability and valid reimport do not establish raster equivalence.
 
 - Package: `@openpresentation/opf-pptx`
 - Repository: `OpenPresentation/opf-pptx`
@@ -80,12 +80,12 @@ 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.
-- `checkPptxTypefaces(bytes, {fonts, monospace})` inventories every `typeface`, workbook font name and "Fonts Used" entry in every XML part, including nested packages, and reports each font outside that policy. `inventoryPptxTypefaces()` returns the raw inventory.
+- 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 unless a script font was selected for that slot (see [Languages, right-to-left text and script fonts](#languages-right-to-left-text-and-script-fonts)).
+- `checkPptxTypefaces(bytes, {fonts, monospace, themeScripts})` (optional `themeScripts: {major: {ea, cs}, minor: {ea, cs}}` names the East Asian / complex-script families the author selected; a selected theme slot that is empty or different is reported as `theme-script-slot`, an unselected one may stay empty) inventories every `typeface`, workbook font name and "Fonts Used" entry in every XML part, including nested packages, and reports each font outside that policy. `inventoryPptxTypefaces()` returns the raw inventory.
 
 This pass did not require an OPF schema change. The deferred full OOXML placeholder mapping from `docs/plans/layout-placeholders.md` remains a later hand-written OOXML emitter concern.
 
@@ -101,6 +101,12 @@ This intentionally tightens the previous host-dependent `Date` parsing contract.
 
 ## v1 Import Mapping
 
+### Quote provenance (FF-57)
+
+A `quote` payload exports as native text lines: the body (the quoted text wrapped in straight quotation marks) and, when there is an attribution or source, one footer (`attribution - source`). Each line shape carries an `OPF_QUOTE_V1` tag that stores only topology (whether the value was the string shorthand, which footer fields exist, where the separator falls, and how many source lines each part has). No quote word is stored: every value is read back from the current native text, so a cleared or edited quote cannot bring back the words it once held.
+
+An unchanged export re-imports as `{ "type": "quote", "quote": ... }` exactly: the string shorthand stays a string, `text`/`attribution`/`source` come back with their whitespace, hard line breaks and inner quotation marks, and several quotes on one slide keep their order. Native edits to the body or footer text import as the edited quote. The importer reports `quote-import-reflow` (native formatting, position and font theme are not reconstructed) and `quote-footer-merged` when an edited footer no longer separates attribution from source. A missing, duplicated or reordered line, a changed manifest or a native bullet on a tagged line rejects the group: the shapes import as ordinary text blocks with an `invalid-quote-provenance` diagnostic and no old words are restored. A quote authored without tags (for example in PowerPoint) imports as text. The output stays ordinary editable PowerPoint text boxes; the tags are `p:custDataLst` entries that PowerPoint keeps.
+
 ### New in 0.10.0: current native body formatting
 
 Current source imports supported formatting from ordinary untagged native body text and list items. A value that previously imported as a string can now be a rich-run array containing the same current characters with explicit native properties. Unstyled values remain strings; title/subtitle selection and tagged recovery stay separate. Run, field and break order, blank paragraphs, significant whitespace, explicit normal overrides, paragraph/list defaults, point sizes, Latin font families, supported colors/alpha, hyperlinks and script direction come from the current PPTX. Edits, clears and deletion remain authoritative in every provenance mode. Native weight faces of the bundled Roboto family (for example `Roboto SemiBold`) import as `Roboto` plus `bold` for weights of 600 and above. Medium (500) and lighter weights import as regular, because OPF runs have no numeric weight, so a round trip re-exports Medium as Regular; `approximate-body-font-weight` reports this. Authored families such as `Arial Black` or `Aptos Light` keep their names.
@@ -125,12 +131,30 @@ 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`):
 
 - Every run, end-of-paragraph and default run property carries `lang` set to the resolved OOXML tag instead of a fixed `en-US`. That tag is the catalog's curated `ooxmlLang` (for example `ja-JP` or `ar-SA`) or an authored region tag such as `en-NZ`. `altLang` is not written: it names the editing-UI language, which OPF does not model.
-- For a language that uses an East Asian or complex-script slot (CJK, Arabic, Hebrew, Indic, Thai and others), theme major/minor `a:ea`/`a:cs` name the resolved heading/body fonts instead of the vendored empty values. For a language written in the latin slot (Latin, Cyrillic, Greek and others) they stay empty unless the design font scheme sets `eastAsian`/`complexScript` explicitly. Filling them with the latin family is gated on FF-05: native evidence shows it does not remove the nameless and Aptos entries PowerPoint lists at open, and empty slots keep PowerPoint's per-script theme fallback for CJK or Arabic text typed later. So en-US decks export byte-identically.
+- Theme major/minor `a:ea`/`a:cs` are written only for a slot where a script font is actually selected (FF-49): an explicit `eastAsian`/`complexScript` on the design font scheme, the scheme's own script family, or the language's script font (a language that uses the East Asian slot, such as Japanese, writes `ea`; one that uses the complex-script slot, such as Arabic, Hebrew, Indic or Thai, writes `cs`). Every other slot keeps the vendored empty typeface, exactly as Office's own themes leave it, so PowerPoint picks its per-language default for script text typed later and the package names nothing the author did not select (owner font policy). Latin, Cyrillic, Greek, Armenian, Georgian and Ethiopic decks write neither; the other slot of a CJK or complex-script deck is empty too. The language never changes the theme's latin fonts (Model C): `design.fontScheme` alone sets them. The preview resolves the same slots (opf-render's script profile: the theme's family where it names one, the latin family where it is empty), and `test/theme-script-slots.mjs` checks preview against export for every catalog font scheme.
 - The theme's per-script entry for the language's own script (for example `Jpan`, `Hang`, `Arab` or `Deva`) names the resolver's supplement. The rest of the vendored Office per-script list is unchanged; that list is FF-08's call.
 - Run `a:ea`/`a:cs` name the resolved slot when the language or the font scheme supplies a script-specific font, for example Meiryo in `a:ea` for Japanese or Arabic Typesetting in `a:cs` for Arabic. Headings take the heading font and other text the body font. Otherwise the slots keep repeating the run's latin face, so Latin, Cyrillic and Greek decks keep their run bytes.
 - In a right-to-left deck, each slide and notes paragraph takes its direction from core `paragraphDirection(text, direction)`, the same rule the renderer uses: `rtl="1"` when its first strong character is right-to-left or it has none (digits, punctuation, empty), else an explicit `rtl="0"` (an English quote, a code line). The master, layout and presentation default paragraph levels start right-to-left only in a right-to-left deck. Left-to-right decks write no paragraph direction. Alignment is unchanged: `algn` stays the composed absolute alignment (left stays `l`), so native line placement keeps matching the renderer's geometry. Right-aligning RTL text by default is a composition decision in core; until then, set `contentAlignment` or `titleAlignment` to `right`.
@@ -148,7 +172,7 @@ When the package carries an FF-32 stored `language` ([document round trip](docs/
 
 Exports report `language-unresolved` when the document's language cannot be resolved locally (a URL, `pkg:` reference or unknown id) and `en-US` is used.
 
-**Core without the resolver.** Core `@openpresentation/opf` 0.11.0 and earlier have no `resolveScriptFonts` (this release requires ^0.11.2, so this only applies to a forced older core). Export with it is byte-identical to the output before FF-07 (`lang="en-US"`, empty theme `ea`/`cs`, no `rtl`), and a document that names a language gets a `language-export-unavailable` diagnostic. A core with the resolver but without `paragraphDirection` marks no paragraph direction and reports `paragraph-direction-unavailable` for a right-to-left deck. Import then matches run tags against the installed catalog's `bcp47` and primary language. `npm run test:packed` exercises this path against the registry release. CI links core at a pinned commit that has the resolver.
+**Core without the resolver.** Core `@openpresentation/opf` 0.11.0 and earlier have no `resolveScriptFonts` (this release requires ^0.11.3, so this only applies to a forced older core). Export with it is byte-identical to the output before FF-07 (`lang="en-US"`, empty theme `ea`/`cs`, no `rtl`), and a document that names a language gets a `language-export-unavailable` diagnostic. A core with the resolver but without `paragraphDirection` marks no paragraph direction and reports `paragraph-direction-unavailable` for a right-to-left deck. Import then matches run tags against the installed catalog's `bcp47` and primary language. `npm run test:packed` exercises this path against the registry release. CI links core at a pinned commit that has the resolver.
 
 ## Runtime Policy
 

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}};
+}