@rowsncolumns/toolkit 24.4.5 → 24.5.1

package/dist/esm/excel-parser/plugins/xlsx/charts.js

@@ -1,6 +1,8 @@
 import { generateSelectionsFromFormula } from "@rowsncolumns/utils";
 import { uuid } from "@rowsncolumns/utils";
+import { XMLParser } from "fast-xml-parser";
 import { get } from "lodash-es";
+import { anchorPlacementFromEditAs } from "./drawing";
 /**
  * Pick the data sheetId for a parsed selection. Honours the explicit
  * sheet prefix in the chart's formula reference (cross-sheet charts);
@@ -83,6 +85,26 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
             roundedCornersVal === true
             ? true
             : undefined;
+        // Chart Styles gallery id: `<c14:style>` (Office 2010+, id + 100)
+        // inside mc:Choice wins over the `<c:style>` fallback. Excel writes
+        // 2 / 102 on an unstyled chart, so that default stays implicit.
+        const chartStyle = extractChartStyle(chartSpaceRoot);
+        // PivotChart binding: `<c:pivotSource><c:name>` names the pivot; the
+        // id is resolved once the workbook's pivots are parsed
+        // (`bindPivotChartsToPivotTables`). `<c:pivotFmts>` and the c14
+        // field-button options ride along on the spec.
+        const pivotSourceName = extractPivotSourceName(chartSpaceRoot);
+        const pivotSourceFormatId = extractPivotSourceFormatId(chartSpaceRoot);
+        const pivotFormats = extractPivotFormats(chart);
+        if (pivotFormats)
+            attachPivotFormatBodies(pivotFormats, chartContent);
+        const pivotFieldButtons = extractPivotFieldButtons(chartSpaceRoot);
+        // Format Chart Area fill / border from the chartSpace `<c:spPr>`.
+        // Only literal `<a:srgbClr>` counts: Excel's default is a theme
+        // `bg1` fill, which must not pin every imported chart to white.
+        const chartSpacePr = get(chartSpaceRoot, "c:spPr") ?? get(chartSpaceRoot, "spPr");
+        const chartAreaFill = extractSrgbHex(get(chartSpacePr, "a:solidFill") ?? get(chartSpacePr, "solidFill"));
+        const chartAreaBorder = extractSrgbHex(get(chartSpacePr, "a:ln.a:solidFill") ?? get(chartSpacePr, "ln.solidFill"));
         const chartId = uuid();
         // Extract chart title (text + formatting)
         const title = extractChartTitle(chart);
@@ -106,6 +128,10 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
         const scatterStyle = chartType === "scatter" ? extractScatterStyle(plotArea) : undefined;
         // Extract hidden dimension strategy from plotVisOnly
         const hiddenDimensionStrategy = extractHiddenDimensionStrategy(chart);
+        // "Hidden and Empty Cells": only the non-default choices are recorded
+        // (Excel writes `gap` and `dispNaAsBlank="1"` into every file).
+        const emptyCells = extractEmptyCellsPolicy(chart);
+        const showNaAsEmpty = extractShowNaAsEmpty(chart);
         // Extract position from anchor
         const position = extractChartPosition(anchor, sheetId, sheetDimensions);
         if (!position) {
@@ -116,6 +142,10 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
         const dataLabels = extractDataLabelsOptions(plotArea, chartType);
         const { valueAxisOptions, secondaryValueAxisOptions, categoryAxisOptions, } = extractAxisOptions(plotArea);
         const doughnutHoleSize = chartType === "doughnut" ? extractDoughnutHoleSize(plotArea) : undefined;
+        // Exploded pie / doughnut — the per-series <c:explosion> percentage.
+        const explosion = chartType === "pie" || chartType === "doughnut"
+            ? extractExplosion(plotArea, chartType)
+            : undefined;
         // Pie-of-pie / bar-of-pie — <c:ofPieChart> degrades to chartType
         // "pie" with sourceChartType "OF_PIE" plus the split fields the
         // renderer uses to draw the composite layout.
@@ -135,6 +165,11 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
         const barLayout = chartType === "bar" || chartType === "column"
             ? extractBarLayoutOptions(plotArea)
             : undefined;
+        // Line-only — <c:grouping> (stacked / percentStacked) and the
+        // chart-level <c:marker> flag behind Excel's "Line with Markers".
+        const lineLayout = chartType === "line" ? extractLineChartOptions(plotArea, series) : undefined;
+        // Stock-only — HLC / OHLC / VHLC / VOHLC from the series layout.
+        const stockVariant = chartType === "stock" ? extractStockVariant(plotArea) : undefined;
         return {
             chartId,
             spec: {
@@ -145,6 +180,8 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
                 series,
                 dataRange,
                 hiddenDimensionStrategy,
+                ...(emptyCells && emptyCells !== "gaps" ? { emptyCells } : {}),
+                ...(showNaAsEmpty === false ? { showNaAsEmpty } : {}),
                 // Scatter/bubble must conform to BubbleChartSpec which requires
                 // `bubbleLabels`. We don't currently extract per-point labels
                 // from OOXML (rare in real files); set an empty array so the
@@ -167,6 +204,7 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
                 ...(typeof doughnutHoleSize === "number"
                     ? { doughnutHoleSize }
                     : {}),
+                ...(typeof explosion === "number" ? { explosion } : {}),
                 ...(ofPieOptions
                     ? { sourceChartType: "OF_PIE", ...ofPieOptions }
                     : {}),
@@ -184,9 +222,23 @@ export async function processChart(chartTarget, drawingPath, anchor, sheetId, zi
                 ...(typeof barLayout?.gapWidth === "number"
                     ? { gapWidth: barLayout.gapWidth }
                     : {}),
+                ...(lineLayout?.stackedType
+                    ? { stackedType: lineLayout.stackedType }
+                    : {}),
+                ...(lineLayout?.showMarkers ? { showMarkers: true } : {}),
+                ...(stockVariant ? { stockVariant } : {}),
                 ...(roundedCorners ? { roundedCorners } : {}),
+                ...(chartStyle !== undefined ? { chartStyle } : {}),
+                ...(chartAreaFill ? { backgroundColor: chartAreaFill } : {}),
+                ...(pivotSourceName ? { [PIVOT_SOURCE_NAME_KEY]: pivotSourceName } : {}),
+                ...(pivotSourceFormatId
+                    ? { [PIVOT_SOURCE_FORMAT_ID_KEY]: pivotSourceFormatId }
+                    : {}),
+                ...(pivotFormats ? { pivotFormats } : {}),
+                ...(pivotFieldButtons ? { pivotFieldButtons } : {}),
             },
             position,
+            ...(chartAreaBorder ? { borderColor: chartAreaBorder } : {}),
             id: chartId,
             type: "chart",
         };
@@ -256,8 +308,20 @@ function getSeriesElements(plotArea, chartType) {
             ]);
         case "radar":
             return getWithFallback(plotArea, ["c:radarChart.c:ser", "radarChart.ser"]);
-        case "stock":
-            return getWithFallback(plotArea, ["c:stockChart.c:ser", "stockChart.ser"]);
+        case "stock": {
+            // VHLC / VOHLC: the volume series lives in a sibling <c:barChart>
+            // and comes first (utils/stock.ts STOCK_ROLES); the price series
+            // follow in the <c:stockChart>.
+            const toArray = (value) => value === undefined || value === null
+                ? []
+                : Array.isArray(value)
+                    ? value
+                    : [value];
+            return [
+                ...toArray(getWithFallback(plotArea, ["c:barChart.c:ser", "barChart.ser"])),
+                ...toArray(getWithFallback(plotArea, ["c:stockChart.c:ser", "stockChart.ser"])),
+            ];
+        }
         case "scatter":
             return getWithFallback(plotArea, [
                 "c:scatterChart.c:ser",
@@ -456,6 +520,51 @@ export function extractHiddenDimensionStrategy(chart) {
     const skipHidden = plotVisOnly === "1" || plotVisOnly === "true" || plotVisOnly === true;
     return skipHidden ? "SKIP_HIDDEN_ROWS_AND_COLUMNS" : "SHOW_ALL";
 }
+/**
+ * `<c:dispBlanksAs val="gap|zero|span"/>` — Excel's "Show empty cells as"
+ * (Select Data → Hidden and Empty Cells). `span` is "Connect data points
+ * with line".
+ */
+export function extractEmptyCellsPolicy(chart) {
+    const val = getWithFallback(chart, [
+        "c:dispBlanksAs.a$.val",
+        "dispBlanksAs.a$.val",
+    ]);
+    switch (val) {
+        case "gap":
+            return "gaps";
+        case "zero":
+            return "zero";
+        case "span":
+            return "connect";
+        default:
+            return undefined;
+    }
+}
+/**
+ * Excel 2016+ "Show #N/A as an empty cell":
+ * `<c:chart><c:extLst><c:ext uri="{56B9EC1D-…}"><c16r3:dataDisplayOptions16>
+ * <c16r3:dispNaAsBlank val="0|1"/>`. Undefined when the file predates the
+ * option (Excel then treats #N/A the legacy way — as if `val="0"`, but the
+ * spec leaves the default to the renderer).
+ */
+export function extractShowNaAsEmpty(chart) {
+    const extLst = getWithFallback(chart, ["c:extLst", "extLst"]);
+    if (!extLst)
+        return undefined;
+    const extNode = getWithFallback(extLst, ["c:ext", "ext"]);
+    const exts = Array.isArray(extNode) ? extNode : extNode ? [extNode] : [];
+    for (const ext of exts) {
+        const val = getWithFallback(ext, [
+            "c16r3:dataDisplayOptions16.c16r3:dispNaAsBlank.a$.val",
+            "dataDisplayOptions16.dispNaAsBlank.a$.val",
+        ]);
+        if (val !== undefined) {
+            return val === "1" || val === "true" || val === true;
+        }
+    }
+    return undefined;
+}
 /**
  * Read the chart title's text formatting. Excel chart titles can be
  * styled two ways:
@@ -467,6 +576,46 @@ export function extractHiddenDimensionStrategy(chart) {
  * the more explicit signal). Returns `undefined` when neither carries
  * formatting so the renderer falls back to its theme defaults.
  */
+/**
+ * `<c:chartSpace>` → the Chart Styles id, from `<c14:style>` in the
+ * mc:Choice (id + 100) or the plain `<c:style>`. Excel's unstyled default
+ * (2) is returned as `undefined` so it stays implicit on the spec.
+ */
+function extractChartStyle(chartSpaceRoot) {
+    const alternates = [
+        getWithFallback(chartSpaceRoot, ["mc:AlternateContent", "AlternateContent"]),
+    ]
+        .flat()
+        .filter(Boolean);
+    let raw;
+    for (const alternate of alternates) {
+        const c14 = getWithFallback(alternate, [
+            "mc:Choice.c14:style.a$.val",
+            "Choice.c14:style.a$.val",
+            "Choice.style.a$.val",
+        ]);
+        if (c14 !== undefined) {
+            const value = Number(c14);
+            raw = value > 100 ? value - 100 : value;
+            break;
+        }
+    }
+    if (raw === undefined) {
+        raw = getWithFallback(chartSpaceRoot, ["c:style.a$.val", "style.a$.val"]);
+    }
+    const style = Number(raw);
+    if (!Number.isInteger(style) || style < 1 || style > 48 || style === 2) {
+        return undefined;
+    }
+    return style;
+}
+/** `<a:solidFill><a:srgbClr val="RRGGBB"/>` → `#RRGGBB`; theme fills are ignored. */
+function extractSrgbHex(solidFill) {
+    const raw = get(solidFill, "a:srgbClr.a$.val") ?? get(solidFill, "srgbClr.a$.val");
+    return typeof raw === "string" && /^[0-9a-fA-F]{6}$/.test(raw)
+        ? `#${raw.toUpperCase()}`
+        : undefined;
+}
 function extractChartTitleTextFormat(chart) {
     const title = get(chart, "c:title") ?? get(chart, "title");
     if (!title)
@@ -478,6 +627,310 @@ function extractChartTitleTextFormat(chart) {
     const txPr = get(title, "c:txPr") ?? get(title, "txPr");
     return extractTextProperties(txPr);
 }
+/**
+ * Transient spec key carrying `<c:pivotSource><c:name>` until the workbook's
+ * pivots are known; `bindPivotChartsToPivotTables` turns it into
+ * `pivotTableId` and removes it.
+ */
+export const PIVOT_SOURCE_NAME_KEY = "__pivotSourceName";
+/**
+ * Transient spec key carrying `<c:pivotSource><c:fmtId>` alongside the
+ * name; becomes `pivotSource.formatId` once the chart binds to its pivot.
+ */
+export const PIVOT_SOURCE_FORMAT_ID_KEY = "__pivotSourceFormatId";
+/**
+ * `<c:pivotSource><c:fmtId val="3"/>` — the id the pivot's `<chartFormats>`
+ * name this chart by. `0` is the exporter's default and stays implicit.
+ */
+export function extractPivotSourceFormatId(chartSpaceRoot) {
+    const raw = getWithFallback(chartSpaceRoot, [
+        "c:pivotSource.c:fmtId.a$.val",
+        "pivotSource.fmtId.a$.val",
+    ]);
+    const id = toInt(raw);
+    return Number.isFinite(id) && id > 0 ? id : undefined;
+}
+/** `<c:pivotSource><c:name>[Book1.xlsx]Sheet1!PivotTable1</c:name>` → the name text. */
+export function extractPivotSourceName(chartSpaceRoot) {
+    const raw = getWithFallback(chartSpaceRoot, [
+        "c:pivotSource.c:name.t$",
+        "c:pivotSource.c:name",
+        "pivotSource.name.t$",
+        "pivotSource.name",
+    ]);
+    const name = typeof raw === "string" ? raw.trim() : undefined;
+    return name ? name : undefined;
+}
+/**
+ * Split a pivotSource name into its sheet and pivot-table parts. The
+ * `[workbook]` prefix is dropped (it names the file the chart lived in);
+ * the sheet may be quoted (`'My Sheet'!PivotTable1`).
+ */
+export function parsePivotSourceName(name) {
+    const withoutBook = name.replace(/^\[[^\]]*\]/, "");
+    const bang = withoutBook.lastIndexOf("!");
+    if (bang === -1) {
+        return withoutBook ? { pivotName: withoutBook } : undefined;
+    }
+    const pivotName = withoutBook.slice(bang + 1);
+    if (!pivotName)
+        return undefined;
+    let sheetTitle = withoutBook.slice(0, bang);
+    if (sheetTitle.startsWith("'") && sheetTitle.endsWith("'")) {
+        sheetTitle = sheetTitle.slice(1, -1).replace(/''/g, "'");
+    }
+    return { sheetTitle: sheetTitle || undefined, pivotName };
+}
+/**
+ * Resolve every imported chart's `<c:pivotSource>` name to the id of the
+ * imported PivotTable it names (matched by pivot name, and by the pivot's
+ * target sheet when the name carries one). A name that matches no pivot
+ * leaves a plain chart — Excel converts a PivotChart whose pivot is gone
+ * to a static chart too. The transient key is always removed.
+ */
+export function bindPivotChartsToPivotTables(charts, pivotTables, sheetTitleById) {
+    for (const chart of charts) {
+        const spec = chart.spec;
+        const raw = spec[PIVOT_SOURCE_NAME_KEY];
+        const formatId = spec[PIVOT_SOURCE_FORMAT_ID_KEY];
+        delete spec[PIVOT_SOURCE_FORMAT_ID_KEY];
+        if (raw === undefined)
+            continue;
+        delete spec[PIVOT_SOURCE_NAME_KEY];
+        const parsed = typeof raw === "string" ? parsePivotSourceName(raw) : undefined;
+        if (!parsed)
+            continue;
+        const byName = pivotTables.filter((pivot) => (pivot.name ?? `PivotTable${pivot.pivotId}`) === parsed.pivotName);
+        const match = byName.find((pivot) => parsed.sheetTitle === undefined ||
+            sheetTitleById.get(pivot.targetPosition?.sheetId) === parsed.sheetTitle) ?? (parsed.sheetTitle === undefined ? byName[0] : undefined);
+        if (!match)
+            continue;
+        spec.pivotTableId = match.pivotId;
+        if (!spec.pivotSource) {
+            spec.pivotSource = { categoryAxis: "rows" };
+        }
+        if (typeof formatId === "number") {
+            spec.pivotSource.formatId = formatId;
+        }
+    }
+}
+/**
+ * `<c:chart><c:pivotFmts><c:pivotFmt><c:idx val/>…` — the per pivot-item
+ * formats Excel re-applies on a re-plot; only the index and a literal
+ * fill colour are kept.
+ */
+export function extractPivotFormats(chart) {
+    const raw = getWithFallback(chart, ["c:pivotFmts.c:pivotFmt", "pivotFmts.pivotFmt"]);
+    if (raw === undefined)
+        return undefined;
+    const list = Array.isArray(raw) ? raw : [raw];
+    const formats = [];
+    for (const fmt of list) {
+        const idx = toInt(getWithFallback(fmt, ["c:idx.a$.val", "idx.a$.val"]));
+        const fill = getWithFallback(fmt, [
+            "c:spPr.a:solidFill.a:srgbClr.a$.val",
+            "spPr.solidFill.srgbClr.a$.val",
+        ]);
+        formats.push({
+            index: idx,
+            ...(typeof fill === "string" && fill ? { color: `#${fill.toUpperCase()}` } : {}),
+        });
+    }
+    return formats.length ? formats : undefined;
+}
+/**
+ * Namespace URI → the prefix Excel writes for it. Bodies are stored with these
+ * canonical prefixes so a file that declared, say, `xmlns:c="…"` as `cs:` still
+ * round-trips through an exporter that declares `c:` / `a:` at the root.
+ */
+export const CHART_XML_PREFIXES = {
+    "http://schemas.openxmlformats.org/drawingml/2006/chart": "c",
+    "http://schemas.openxmlformats.org/drawingml/2006/main": "a",
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships": "r",
+    "http://schemas.openxmlformats.org/markup-compatibility/2006": "mc",
+    "http://schemas.microsoft.com/office/drawing/2007/8/2/chart": "c14",
+    "http://schemas.microsoft.com/office/drawing/2012/chart": "c15",
+    "http://schemas.microsoft.com/office/drawing/2014/chart": "c16",
+    "http://schemas.microsoft.com/office/drawing/2015/06/chart": "c16r2",
+    "http://schemas.microsoft.com/office/drawing/2017/03/chart": "c16r3",
+    "http://schemas.microsoft.com/office/drawing/2010/main": "a14",
+    "http://schemas.microsoft.com/office/drawing/2014/main": "a16",
+};
+// Ordered parse of a chart part — the object parse the plugin uses drops the
+// order of differently named siblings, which DrawingML schemas fix
+// (`<a:gsLst>` before `<a:lin>`, `<a:bodyPr>` before `<a:p>`), so the verbatim
+// bodies are read from a `preserveOrder` pass instead.
+const orderedChartParser = new XMLParser({
+    ignoreAttributes: false,
+    preserveOrder: true,
+    attributeNamePrefix: "",
+    textNodeName: "t$",
+    trimValues: false,
+    processEntities: false,
+});
+const localName = (tag) => tag.slice(tag.indexOf(":") + 1);
+/**
+ * `preserveOrder` node → `ChartXmlElement`, prefixes canonicalised through the
+ * `xmlns:*` declarations seen so far (`declared`: prefix → URI); namespace
+ * declarations themselves are dropped — the exporters re-emit them.
+ */
+const toChartXmlElement = (node, declared) => {
+    const tag = Object.keys(node).find((k) => k !== ":@");
+    if (!tag)
+        return undefined;
+    const rawAttrs = (node[":@"] ?? {});
+    const scope = new Map(declared);
+    for (const [k, v] of Object.entries(rawAttrs)) {
+        if (k === "xmlns")
+            scope.set("", String(v));
+        else if (k.startsWith("xmlns:"))
+            scope.set(k.slice(6), String(v));
+    }
+    const canonical = (name) => {
+        const at = name.indexOf(":");
+        const prefix = at === -1 ? "" : name.slice(0, at);
+        const uri = scope.get(prefix);
+        const known = uri ? CHART_XML_PREFIXES[uri] : undefined;
+        if (!known)
+            return name;
+        return `${known}:${at === -1 ? name : name.slice(at + 1)}`;
+    };
+    const attributes = {};
+    for (const [k, v] of Object.entries(rawAttrs)) {
+        if (k === "xmlns" || k.startsWith("xmlns:"))
+            continue;
+        attributes[k.includes(":") ? canonical(k) : k] = String(v);
+    }
+    const element = { tag: canonical(tag) };
+    if (Object.keys(attributes).length)
+        element.attributes = attributes;
+    const kids = Array.isArray(node[tag]) ? node[tag] : [];
+    const children = [];
+    let text;
+    for (const kid of kids) {
+        if (!kid || typeof kid !== "object")
+            continue;
+        if ("t$" in kid) {
+            text = (text ?? "") + String(kid.t$);
+            continue;
+        }
+        const child = toChartXmlElement(kid, scope);
+        if (child)
+            children.push(child);
+    }
+    if (children.length)
+        element.children = children;
+    else if (text !== undefined && text !== "")
+        element.text = text;
+    return element;
+};
+/**
+ * Read every `<c:pivotFmt>` body (its children after `<c:idx>`) verbatim from
+ * the chart part and attach it to the matching `pivotFormats` entry by index
+ * (rowsncolumns/spreadsheet#668 C-83). Gradient fills, theme colours, markers
+ * and data-label formatting Excel keeps per pivot item survive the round-trip
+ * that `color` (a literal solid fill) alone cannot carry.
+ */
+export function attachPivotFormatBodies(formats, chartContent) {
+    let ordered;
+    try {
+        ordered = orderedChartParser.parse(chartContent);
+    }
+    catch {
+        return;
+    }
+    const findPivotFmts = (nodes, declared) => {
+        for (const node of nodes) {
+            if (!node || typeof node !== "object")
+                continue;
+            const tag = Object.keys(node).find((k) => k !== ":@");
+            // Text nodes (`{ t$ }`) have no element children to search.
+            if (!tag || !Array.isArray(node[tag]))
+                continue;
+            const scope = new Map(declared);
+            for (const [k, v] of Object.entries((node[":@"] ?? {}))) {
+                if (k === "xmlns")
+                    scope.set("", String(v));
+                else if (k.startsWith("xmlns:"))
+                    scope.set(k.slice(6), String(v));
+            }
+            if (localName(tag) === "pivotFmts")
+                return { node, declared: scope };
+            const found = findPivotFmts((node[tag] ?? []), scope);
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
+    const found = findPivotFmts(ordered, new Map());
+    if (!found)
+        return;
+    const fmtsTag = Object.keys(found.node).find((k) => k !== ":@");
+    const byIndex = new Map();
+    for (const fmt of (found.node[fmtsTag] ?? [])) {
+        if (!fmt || typeof fmt !== "object")
+            continue;
+        const fmtTag = Object.keys(fmt).find((k) => k !== ":@");
+        if (!fmtTag || localName(fmtTag) !== "pivotFmt" || !Array.isArray(fmt[fmtTag]))
+            continue;
+        const kids = fmt[fmtTag];
+        let index;
+        const body = [];
+        for (const kid of kids) {
+            if (!kid || typeof kid !== "object")
+                continue;
+            const kidTag = Object.keys(kid).find((k) => k !== ":@");
+            if (!kidTag)
+                continue;
+            if (localName(kidTag) === "idx") {
+                index = toInt(kid[":@"]?.val);
+                continue;
+            }
+            const element = toChartXmlElement(kid, found.declared);
+            if (element)
+                body.push(element);
+        }
+        if (index !== undefined && body.length)
+            byIndex.set(index, body);
+    }
+    for (const format of formats) {
+        const body = byIndex.get(format.index);
+        if (body)
+            format.body = body;
+    }
+}
+const PIVOT_OPTIONS_EXT_URI = "{781A3756-C4B2-4CAC-9D66-4F8BD8637D16}";
+/**
+ * Excel's Field Buttons choices — `<c14:pivotOptions>` in the chartSpace
+ * `<c:extLst>`: `dropZoneFilter` / `dropZoneCategories` / `dropZoneData` /
+ * `dropZoneSeries` / `dropZonesVisible`, each `1` unless hidden. Only the
+ * hidden ones are recorded (every button shows by default).
+ */
+export function extractPivotFieldButtons(chartSpaceRoot) {
+    const extList = getWithFallback(chartSpaceRoot, ["c:extLst.c:ext", "extLst.ext"]);
+    if (extList === undefined)
+        return undefined;
+    const exts = Array.isArray(extList) ? extList : [extList];
+    const ext = exts.find((e) => e?.a$?.uri === PIVOT_OPTIONS_EXT_URI);
+    const options = getWithFallback(ext, ["c14:pivotOptions", "pivotOptions"]);
+    if (!options)
+        return undefined;
+    const isHidden = (element) => {
+        const val = getWithFallback(options, [
+            `c14:${element}.a$.val`,
+            `${element}.a$.val`,
+        ]);
+        return val === "0" || val === "false" || val === false;
+    };
+    const buttons = {
+        ...(isHidden("dropZonesVisible") ? { visible: false } : {}),
+        ...(isHidden("dropZoneFilter") ? { reportFilter: false } : {}),
+        ...(isHidden("dropZoneCategories") ? { axis: false } : {}),
+        ...(isHidden("dropZoneSeries") ? { legend: false } : {}),
+        ...(isHidden("dropZoneData") ? { value: false } : {}),
+    };
+    return Object.keys(buttons).length ? buttons : undefined;
+}
 export function extractChartTitle(chart) {
     // Try different possible paths for chart title
     const title = 
@@ -532,12 +985,19 @@ export function determineChartType(chart) {
     const c15Type = detectC15ChartType(plotArea);
     if (c15Type)
         return c15Type;
-    const barChart = getWithFallback(plotArea, [
+    // Excel's VHLC / VOHLC stock charts pair a <c:barChart> (the volume
+    // series) with the <c:stockChart>, so the stock group must win over the
+    // bar scan below.
+    if (getWithFallback(plotArea, ["c:stockChart", "stockChart"]))
+        return "stock";
+    // A chart whose secondary axis group is split into its own container
+    // carries an array here; the primary group comes first.
+    const barChart = firstGroup(getWithFallback(plotArea, [
         "c:barChart",
         "barChart",
         "c:bar3DChart",
         "bar3DChart",
-    ]);
+    ]));
     if (barChart) {
         const direction = get(barChart, "c:barDir.a$.val") ||
             get(barChart, "c:barDir.a$.t$") ||
@@ -585,8 +1045,6 @@ export function determineChartType(chart) {
         return "area";
     if (getWithFallback(plotArea, ["c:radarChart", "radarChart"]))
         return "radar";
-    if (getWithFallback(plotArea, ["c:stockChart", "stockChart"]))
-        return "stock";
     // Scatter and bubble — both use c:xVal/c:yVal series shape (not
     // c:cat/c:val like other charts). Bubble additionally has c:bubbleSize.
     if (getWithFallback(plotArea, ["c:scatterChart", "scatterChart"]))
@@ -778,6 +1236,77 @@ const CHART_TYPE_CONTAINERS = [
         isXY: true,
     },
 ];
+/**
+ * A series' position in the chart — `<c:order>` (Excel's plot / legend
+ * order), falling back to `<c:idx>`; NaN when the series carries neither.
+ */
+function seriesOrderOf(ser) {
+    const raw = get(ser, "c:order.a$.val") ??
+        get(ser, "order.a$.val") ??
+        get(ser, "c:idx.a$.val") ??
+        get(ser, "idx.a$.val");
+    const n = Number(raw);
+    return raw === undefined || raw === null || raw === "" ? NaN : n;
+}
+/**
+ * Put the collected series back in Excel's `<c:order>`: a chart split into
+ * several containers (one per chart type and per axis group) lists them
+ * container by container, which is not the authored order. Only sorts
+ * when every series carries an order (older / hand-written files without
+ * one keep their document order).
+ */
+function sortSeriesByOrder(series, orders) {
+    if (series.length < 2 || orders.length !== series.length)
+        return series;
+    if (orders.some((order) => !Number.isFinite(order)))
+        return series;
+    return series
+        .map((entry, index) => ({ entry, order: orders[index], index }))
+        .sort((a, b) => a.order - b.order || a.index - b.index)
+        .map(({ entry }) => entry);
+}
+/**
+ * The first chart-type container of a group that may be split into one
+ * container per axis group (primary first, then the secondary group).
+ */
+function firstGroup(node) {
+    return Array.isArray(node) ? node[0] : node;
+}
+/** `<c:axId val>` values of an axis element or a chart-type container. */
+function axisIdsOf(node) {
+    const raw = getWithFallback(node, ["c:axId", "axId"]);
+    if (!raw)
+        return [];
+    const list = Array.isArray(raw) ? raw : [raw];
+    return list
+        .map((entry) => entry?.a$?.val ?? entry?.a$?.t$ ?? entry)
+        .filter((id) => id != null)
+        .map(String);
+}
+/**
+ * The axis ids of the plot area's SECONDARY axis group — every `<c:valAx>`,
+ * `<c:catAx>` and `<c:dateAx>` after the first of its kind. Excel keeps one
+ * category axis and one value axis per axis group; a chart-type container
+ * whose `<c:axId>`s name any of these ids plots its series on the
+ * secondary group (Excel's "Plot Series On: Secondary Axis").
+ */
+function secondaryAxisGroupIds(plotArea) {
+    const ids = new Set();
+    for (const key of ["c:valAx", "valAx", "c:catAx", "catAx", "c:dateAx", "dateAx"]) {
+        const axes = get(plotArea, key);
+        if (!axes)
+            continue;
+        const list = Array.isArray(axes) ? axes : [axes];
+        list.slice(1).forEach((axis) => axisIdsOf(axis).forEach((id) => ids.add(id)));
+    }
+    return ids;
+}
+/** True when a chart-type container's `<c:axId>`s bind it to the secondary axis group. */
+function isSecondaryGroupContainer(container, secondaryIds) {
+    if (!secondaryIds.size)
+        return false;
+    return axisIdsOf(container).some((id) => secondaryIds.has(id));
+}
 /**
  * Resolve a chart-formula range string (e.g.
  * `'Data for the Chart'!$A$7:$A$26`) into the sources array our chart
@@ -838,9 +1367,13 @@ function extractInlineValues(node) {
 }
 export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId) {
     const series = [];
+    const orders = [];
     let seriesIndex = 0;
-    // Iterate through all chart type containers to support combo charts
-    for (const container of CHART_TYPE_CONTAINERS) {
+    const secondaryIds = secondaryAxisGroupIds(plotArea);
+    // Iterate through all chart type containers to support combo charts.
+    // A stock chart's <c:barChart> is its volume series, not a combo member
+    // — the stock path below reads both groups in role order.
+    for (const container of chartType === "stock" ? [] : CHART_TYPE_CONTAINERS) {
         const chartElement = getWithFallback(plotArea, container.paths);
         if (!chartElement)
             continue;
@@ -849,6 +1382,9 @@ export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId)
             ? chartElement
             : [chartElement];
         for (const singleChartElement of chartElements) {
+            // Series in a container bound to the secondary axis group plot on
+            // the secondary axes (Excel's "Plot Series On: Secondary Axis").
+            const useSecondaryAxis = isSecondaryGroupContainer(singleChartElement, secondaryIds);
             // Determine the actual chart type for this container
             let seriesChartType = container.chartType;
             if (container.isBar) {
@@ -911,6 +1447,7 @@ export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId)
                 const categorySources = serCatRef
                     ? resolveSourcesFromRef(serCatRef, sheetId, resolveSheetId)
                     : [];
+                orders.push(seriesOrderOf(ser));
                 series.push({
                     dataLabel: seriesTitle || `Series ${seriesIndex + 1}`,
                     ...(nameRef ? { dataLabelRef: nameRef } : {}),
@@ -926,6 +1463,7 @@ export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId)
                     // aren't part of combo mixing — leave it unset there so the
                     // renderer falls back to the chart-level chartType.
                     ...(container.isXY ? {} : { seriesChartType: seriesChartType }),
+                    ...(useSecondaryAxis ? { useSecondaryAxis: true } : {}),
                     sources,
                     ...(inlineValues && inlineValues.length ? { inlineValues } : {}),
                     ...(trendlines && trendlines.length ? { trendlines } : {}),
@@ -978,6 +1516,7 @@ export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId)
                 const categorySources = serCatRef
                     ? resolveSourcesFromRef(serCatRef, sheetId, resolveSheetId)
                     : [];
+                orders.push(seriesOrderOf(ser));
                 series.push({
                     dataLabel: seriesTitle || `Series ${index + 1}`,
                     ...(nameRef ? { dataLabelRef: nameRef } : {}),
@@ -997,7 +1536,9 @@ export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId)
             });
         }
     }
-    return series;
+    // Stock charts read their price roles in document order; every other
+    // chart lists its series in Excel's <c:order>.
+    return chartType === "stock" ? series : sortSeriesByOrder(series, orders);
 }
 /**
  * Extract per-data-point color overrides — `<c:dPt>` array inside
@@ -1247,10 +1788,12 @@ function extractTextProperties(txPr) {
  * renderer keeps its defaults.
  */
 function extractBarLayoutOptions(plotArea) {
-    const bar = get(plotArea, "c:barChart") ??
+    // The primary axis group's container when the secondary group is split
+    // into its own (Excel writes one container per axis group).
+    const bar = firstGroup(get(plotArea, "c:barChart") ??
         get(plotArea, "barChart") ??
         get(plotArea, "c:bar3DChart") ??
-        get(plotArea, "bar3DChart");
+        get(plotArea, "bar3DChart"));
     if (!bar)
         return undefined;
     // `<c:grouping val="clustered|stacked|percentStacked|standard"/>`.
@@ -1284,6 +1827,66 @@ function extractBarLayoutOptions(plotArea) {
         result.gapWidth = gapWidthVal;
     return Object.keys(result).length ? result : undefined;
 }
+/**
+ * Read `<c:lineChart>` / `<c:line3DChart>` `<c:grouping>` (standard /
+ * stacked / percentStacked → `stackedType`) and the chart-level
+ * `<c:marker val>` flag. Excel writes `<c:marker val="1"/>` on every line
+ * chart and hides a plain "Line"'s markers per series through
+ * `<c:marker><c:symbol val="none"/>`, so `showMarkers` is only reported
+ * when the flag is set and at least one series is not "none".
+ */
+function extractLineChartOptions(plotArea, series) {
+    // The primary axis group's container when the secondary group is split
+    // into its own (Excel writes one container per axis group).
+    const line = firstGroup(get(plotArea, "c:lineChart") ??
+        get(plotArea, "lineChart") ??
+        get(plotArea, "c:line3DChart") ??
+        get(plotArea, "line3DChart"));
+    if (!line)
+        return undefined;
+    const groupingVal = get(line, "c:grouping.a$.val") ??
+        get(line, "grouping.a$.val") ??
+        get(line, "c:grouping.a$.t$") ??
+        get(line, "grouping.a$.t$");
+    const result = {};
+    switch (groupingVal) {
+        case "stacked":
+            result.stackedType = "STACKED";
+            break;
+        case "percentStacked":
+            result.stackedType = "PERCENT_STACKED";
+            break;
+        case "standard":
+            result.stackedType = "UNSTACKED";
+            break;
+    }
+    const markerVal = get(line, "c:marker.a$.val") ?? get(line, "marker.a$.val");
+    const markerFlag = markerVal === "1" ||
+        markerVal === 1 ||
+        markerVal === "true" ||
+        markerVal === true;
+    if (markerFlag &&
+        series.length > 0 &&
+        series.some((entry) => entry.marker?.symbol !== "none")) {
+        result.showMarkers = true;
+    }
+    return Object.keys(result).length ? result : undefined;
+}
+/**
+ * Which of Excel's four stock layouts a `<c:stockChart>` is: a sibling
+ * `<c:barChart>` carries the volume series (V-variants), and four price
+ * series (open/high/low/close) instead of three mean OHLC.
+ */
+function extractStockVariant(plotArea) {
+    const prices = getWithFallback(plotArea, [
+        "c:stockChart.c:ser",
+        "stockChart.ser",
+    ]);
+    const priceCount = Array.isArray(prices) ? prices.length : prices ? 1 : 0;
+    const hasVolume = Boolean(getWithFallback(plotArea, ["c:barChart", "barChart"]));
+    const body = priceCount >= 4 ? "OHLC" : "HLC";
+    return hasVolume ? `V${body}` : body;
+}
 /**
  * Extract chart-level `<c:scatterStyle val=…>`. Excel default is
  * "lineMarker" (straight lines + markers). Returns undefined for
@@ -1537,6 +2140,12 @@ function extractSeriesColorInfo(ser) {
 }
 export function extractChartDomains(plotArea, chartType, sheetId, resolveSheetId) {
     const domains = [];
+    // Non-XY: Excel keeps one category axis per axis group. The primary
+    // group's first `<c:cat>` is domains[0]; when a container bound to the
+    // secondary axis group carries a different `<c:cat>`, that list is
+    // domains[1] — the secondary group's category axis.
+    const secondaryIds = secondaryAxisGroupIds(plotArea);
+    let primaryRef;
     // Search all chart type containers for domains. For XY charts the
     // "domain" is the X values (c:xVal); for everything else it's the
     // category axis (c:cat). Per-container loop covers combo charts.
@@ -1557,23 +2166,42 @@ export function extractChartDomains(plotArea, chartType, sheetId, resolveSheetId
             const seriesArray = Array.isArray(seriesElements)
                 ? seriesElements
                 : [seriesElements];
+            const secondaryGroup = !container.isXY &&
+                isSecondaryGroupContainer(singleChartElement, secondaryIds);
             for (const ser of seriesArray) {
                 const domainRef = container.isXY
                     ? getWithFallback(ser, X_VAL_REF_PATHS)
                     : getWithFallback(ser, CAT_REF_PATHS);
                 if (domainRef) {
+                    if (!container.isXY && domains.length) {
+                        // Primary already found: only a secondary-group container
+                        // with a different category list adds domains[1].
+                        if (secondaryGroup && domainRef !== primaryRef) {
+                            const sources = resolveSourcesFromRef(domainRef, sheetId, resolveSheetId);
+                            if (sources.length) {
+                                domains.push({ sources });
+                                return domains;
+                            }
+                        }
+                        break;
+                    }
                     const sources = resolveSourcesFromRef(domainRef, sheetId, resolveSheetId);
                     if (sources.length) {
                         domains.push({ sources });
                         // XY charts may carry per-series domains that differ — keep
                         // the first one we encounter for the dataRange anchor, but
                         // continue collecting so the renderer has a per-series X
-                        // when it needs one. For non-XY, first-found is enough.
-                        if (!container.isXY)
-                            return domains;
+                        // when it needs one. For non-XY, remember the primary ref
+                        // and keep scanning for a secondary group's own list.
+                        if (!container.isXY) {
+                            primaryRef = domainRef;
+                            if (!secondaryIds.size)
+                                return domains;
+                            break;
+                        }
                     }
                 }
-                else if (!container.isXY) {
+                else if (!container.isXY && !domains.length) {
                     // No cell ref — check for an inline `<c:strLit>`/`<c:numLit>`
                     // category list (e.g. `["Estimated", "Actual"]` embedded
                     // directly in the chart XML). Same for the series val side,
@@ -1650,6 +2278,28 @@ export function extractChartPosition(anchor, sheetId, sheetDimensions) {
         // Handle oneCellAnchor
         const oneCellFrom = getWithFallback(anchor, ["xdr:from", "from"]) ?? undefined;
         const hasTwoCellTarget = getWithFallback(anchor, ["xdr:to", "to"]) !== undefined;
+        // absoluteAnchor: `<xdr:pos>` + `<xdr:ext>` — "Don't move or size with
+        // cells"; kept as A1-relative pixel offsets (#668 C-06)
+        const absolutePos = getWithFallback(anchor, ["xdr:pos", "pos"]);
+        if (!oneCellFrom && absolutePos) {
+            const posAttributes = absolutePos.a$ ?? absolutePos;
+            const extNode = getWithFallback(anchor, ["xdr:ext", "ext"]);
+            const extAttributes = (extNode && (extNode.a$ ?? extNode)) || undefined;
+            const emuToPx = (value, fallback) => value !== undefined && value !== null
+                ? Math.round(parseInt(String(value), 10) / 9525)
+                : fallback;
+            return {
+                sheetId,
+                overlayPosition: {
+                    anchorCell: { rowIndex: 1, columnIndex: 1 },
+                    offsetXPixels: emuToPx(posAttributes?.x, 0),
+                    offsetYPixels: emuToPx(posAttributes?.y, 0),
+                    widthPixels: emuToPx(extAttributes?.cx, 400),
+                    heightPixels: emuToPx(extAttributes?.cy, 300),
+                    placement: "absolute",
+                },
+            };
+        }
         if (oneCellFrom && !hasTwoCellTarget) {
             const extNode = getWithFallback(anchor, ["xdr:ext", "ext"]);
             const extAttributes = (extNode && (extNode.a$ ?? extNode)) || undefined;
@@ -1675,6 +2325,7 @@ export function extractChartPosition(anchor, sheetId, sheetDimensions) {
                     offsetYPixels: Math.round(rowOff / 9525),
                     widthPixels: width,
                     heightPixels: height,
+                    placement: "moveOnly",
                 },
             };
         }
@@ -1722,6 +2373,10 @@ export function extractChartPosition(anchor, sheetId, sheetDimensions) {
             heightPx += Math.round(toRowOff / 9525);
             const width = Math.max(widthPx, 100);
             const height = Math.max(heightPx, 100);
+            // `editAs` is the placement mode; the default "Move and size with
+            // cells" keeps `to` as the second anchor so the frame follows the
+            // cells between the corners (#668 C-06)
+            const placement = anchorPlacementFromEditAs(getWithFallback(anchor, ["a$.editAs"]));
             return {
                 sheetId,
                 overlayPosition: {
@@ -1733,6 +2388,13 @@ export function extractChartPosition(anchor, sheetId, sheetDimensions) {
                     offsetYPixels: Math.round(rowOff / 9525),
                     widthPixels: width,
                     heightPixels: height,
+                    ...(placement === "moveAndSize"
+                        ? {
+                            toCell: { rowIndex: toRow + 1, columnIndex: toCol + 1 },
+                            toOffsetXPixels: Math.round(toColOff / 9525),
+                            toOffsetYPixels: Math.round(toRowOff / 9525),
+                        }
+                        : { placement }),
                 },
             };
         }
@@ -1839,7 +2501,7 @@ function extractDataLabelsOptions(plotArea, chartType) {
     const keys = containerKeys[chartType] ?? [];
     let container;
     for (const key of keys) {
-        container = container ?? get(plotArea, key);
+        container = container ?? firstGroup(get(plotArea, key));
     }
     const dLbls = get(container, "c:dLbls") ??
         get(container, "dLbls") ??
@@ -1925,6 +2587,17 @@ function readAxis(axis) {
     const textFormat = extractTextProperties(get(axis, "c:txPr") ?? get(axis, "txPr"));
     if (textFormat)
         result.textFormat = textFormat;
+    // <c:numFmt formatCode="…" sourceLinked="0"/> — an explicit tick-label
+    // format. `sourceLinked="1"` (Excel's default) means the axis inherits
+    // the source cells' format, which the renderer resolves at draw time,
+    // so it is intentionally NOT copied into the spec.
+    const numFmt = get(axis, "c:numFmt.a$") ?? get(axis, "numFmt.a$");
+    const formatCode = numFmt?.formatCode ?? numFmt?.t$;
+    if (typeof formatCode === "string" &&
+        formatCode &&
+        !readBoolean(numFmt?.sourceLinked)) {
+        result.numberFormatPattern = formatCode;
+    }
     return Object.keys(result).length ? result : undefined;
 }
 export function extractAxisOptions(plotArea) {
@@ -1982,6 +2655,25 @@ function extractDoughnutHoleSize(plotArea) {
         return undefined;
     return Math.min(0.9, Math.max(0, holeSize / 100));
 }
+/**
+ * Exploded pie / doughnut — `<c:ser><c:explosion val="25"/>` is the
+ * slice offset as a percentage of the radius. Excel writes it on every
+ * series of an exploded chart; the spec keeps one chart-level value, so
+ * the largest authored explosion wins. Undefined when no series is
+ * exploded (Excel omits the element for a plain pie).
+ */
+function extractExplosion(plotArea, chartType) {
+    const sers = getSeriesElements(plotArea, chartType);
+    const list = Array.isArray(sers) ? sers : sers ? [sers] : [];
+    let explosion;
+    for (const ser of list) {
+        const value = readNumber(get(ser, "c:explosion.a$.val") ?? get(ser, "explosion.a$.val"));
+        if (typeof value === "number" && value > 0) {
+            explosion = Math.max(explosion ?? 0, value);
+        }
+    }
+    return explosion;
+}
 // -------------------------- Phase 5.2 helpers --------------------------
 const mapTrendlineType = (val) => {
     switch (val) {