@rowsncolumns/toolkit 24.4.1

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

@@ -0,0 +1,2178 @@
+import { __assign, __awaiter, __generator, __values } from "tslib";
+import { generateSelectionsFromFormula } from "@rowsncolumns/utils";
+import { uuid } from "@rowsncolumns/utils";
+import { get } from "lodash-es";
+/**
+ * Pick the data sheetId for a parsed selection. Honours the explicit
+ * sheet prefix in the chart's formula reference (cross-sheet charts);
+ * falls back to the host sheet when the formula has no prefix.
+ */
+function pickSheetId(sheetName, hostSheetId, resolveSheetId) {
+    if (sheetName && resolveSheetId) {
+        var resolved = resolveSheetId(sheetName);
+        if (resolved !== undefined)
+            return resolved;
+    }
+    return hostSheetId;
+}
+// Import from index.ts in the same directory (circular dependency but resolving symbols)
+// Note: We need to use type import for Workbook if needed, or functions
+// In this case, we need getChartReferenceFromAnchor which was exported from workbook.ts originally
+// but now is in index.ts of the plugin. However, charts.ts doesn't seem to import it based on the file content I read.
+// The search_replace failed because the import wasn't there.
+// Let me double check the file content again.
+// The file content I read has NO imports from "../charts" or "../workbook".
+// It seems I was trying to fix a linter error that I *assumed* existed or was trying to match code that wasn't there.
+// The file content shows standard imports and internal functions.
+function getWithFallback(source, paths) {
+    var e_1, _a;
+    try {
+        for (var paths_1 = __values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+            var path = paths_1_1.value;
+            var value = get(source, path);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+function toInt(value) {
+    var parsed = parseInt(typeof value === "number" ? String(value) : value !== null && value !== void 0 ? value : "0", 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+export function processChart(chartTarget, drawingPath, anchor, sheetId, zipParser, xmlParser, sheetDimensions, resolveSheetId) {
+    return __awaiter(this, void 0, void 0, function () {
+        var chartPath, drawingDir, chartContent, chartXml, chart, chartSpaceRoot, roundedCornersRaw, roundedCornersVal, roundedCorners, chartId, title, titleTextFormat, chartType, plotArea, series, domains, dataRange, bubbleSizes, scatterStyle, hiddenDimensionStrategy, position, legend, dataLabels, _a, valueAxisOptions, secondaryValueAxisOptions, categoryAxisOptions, doughnutHoleSize, ofPieOptions, radarStyle, binCount, barLayout, err_1;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 2, , 3]);
+                    chartPath = chartTarget;
+                    drawingDir = drawingPath.substring(0, drawingPath.lastIndexOf("/"));
+                    if (chartPath.startsWith("../")) {
+                        chartPath = "xl/".concat(chartPath.replace("../", ""));
+                    }
+                    else if (!chartPath.startsWith("/") && !chartPath.startsWith("xl/")) {
+                        chartPath = "".concat(drawingDir, "/").concat(chartPath);
+                    }
+                    return [4 /*yield*/, zipParser.getText(chartPath)];
+                case 1:
+                    chartContent = _c.sent();
+                    if (!chartContent) {
+                        return [2 /*return*/, null];
+                    }
+                    chartXml = xmlParser.parse(chartContent);
+                    chart = getWithFallback(chartXml, [
+                        "c:chartSpace.c:chart",
+                        "chartSpace.chart",
+                        "chartSpace.c:chart",
+                        "c:chartSpace.chart",
+                    ]);
+                    if (!chart) {
+                        console.log("Chart data not found in file:", chartPath);
+                        console.log("Available keys:", Object.keys(chartXml));
+                        return [2 /*return*/, null];
+                    }
+                    chartSpaceRoot = getWithFallback(chartXml, [
+                        "c:chartSpace",
+                        "chartSpace",
+                    ]);
+                    roundedCornersRaw = getWithFallback(chartSpaceRoot, [
+                        "c:roundedCorners",
+                        "roundedCorners",
+                    ]);
+                    roundedCornersVal = (_b = roundedCornersRaw === null || roundedCornersRaw === void 0 ? void 0 : roundedCornersRaw.a$) === null || _b === void 0 ? void 0 : _b.val;
+                    roundedCorners = roundedCornersVal === "1" ||
+                        roundedCornersVal === "true" ||
+                        roundedCornersVal === true
+                        ? true
+                        : undefined;
+                    chartId = uuid();
+                    title = extractChartTitle(chart);
+                    titleTextFormat = extractChartTitleTextFormat(chart);
+                    chartType = determineChartType(chart);
+                    plotArea = getWithFallback(chart, ["c:plotArea", "plotArea"]);
+                    series = extractChartSeries(plotArea, chartType, sheetId, resolveSheetId);
+                    domains = extractChartDomains(plotArea, chartType, sheetId, resolveSheetId);
+                    dataRange = extractChartDataRange(plotArea, chartType, sheetId, resolveSheetId);
+                    bubbleSizes = chartType === "bubble"
+                        ? extractChartBubbleSizes(plotArea, sheetId, resolveSheetId)
+                        : undefined;
+                    scatterStyle = chartType === "scatter" ? extractScatterStyle(plotArea) : undefined;
+                    hiddenDimensionStrategy = extractHiddenDimensionStrategy(chart);
+                    position = extractChartPosition(anchor, sheetId, sheetDimensions);
+                    if (!position) {
+                        console.log("Could not extract chart position");
+                        return [2 /*return*/, null];
+                    }
+                    legend = extractLegendOptions(chart);
+                    dataLabels = extractDataLabelsOptions(plotArea, chartType);
+                    _a = extractAxisOptions(plotArea), valueAxisOptions = _a.valueAxisOptions, secondaryValueAxisOptions = _a.secondaryValueAxisOptions, categoryAxisOptions = _a.categoryAxisOptions;
+                    doughnutHoleSize = chartType === "doughnut" ? extractDoughnutHoleSize(plotArea) : undefined;
+                    ofPieOptions = chartType === "pie" ? extractOfPieOptions(plotArea) : undefined;
+                    radarStyle = chartType === "radar" ? extractRadarStyle(plotArea) : undefined;
+                    binCount = chartType === "histogram"
+                        ? extractC15HistogramBinCount(plotArea)
+                        : undefined;
+                    barLayout = chartType === "bar" || chartType === "column"
+                        ? extractBarLayoutOptions(plotArea)
+                        : undefined;
+                    return [2 /*return*/, {
+                            chartId: chartId,
+                            spec: __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ title: title }, (titleTextFormat ? { titleTextFormat: titleTextFormat } : {})), { chartType: chartType, domains: domains, series: series, dataRange: dataRange, hiddenDimensionStrategy: hiddenDimensionStrategy }), (chartType === "scatter" || chartType === "bubble"
+                                ? { bubbleLabels: [] }
+                                : {})), (bubbleSizes && bubbleSizes.length ? { bubbleSizes: bubbleSizes } : {})), (scatterStyle
+                                ? { scatterStyle: scatterStyle }
+                                : {})), (legend ? { legend: legend } : {})), (dataLabels ? { dataLabels: dataLabels } : {})), (valueAxisOptions ? { valueAxisOptions: valueAxisOptions } : {})), (secondaryValueAxisOptions
+                                ? { secondaryValueAxisOptions: secondaryValueAxisOptions }
+                                : {})), (categoryAxisOptions ? { categoryAxisOptions: categoryAxisOptions } : {})), (typeof doughnutHoleSize === "number"
+                                ? { doughnutHoleSize: doughnutHoleSize }
+                                : {})), (ofPieOptions
+                                ? __assign({ sourceChartType: "OF_PIE" }, ofPieOptions) : {})), (radarStyle ? { radarStyle: radarStyle } : {})), (typeof binCount === "number" ? { binCount: binCount } : {})), ((barLayout === null || barLayout === void 0 ? void 0 : barLayout.stackedType)
+                                ? { stackedType: barLayout.stackedType }
+                                : {})), (typeof (barLayout === null || barLayout === void 0 ? void 0 : barLayout.overlap) === "number"
+                                ? { overlap: barLayout.overlap }
+                                : {})), (typeof (barLayout === null || barLayout === void 0 ? void 0 : barLayout.gapWidth) === "number"
+                                ? { gapWidth: barLayout.gapWidth }
+                                : {})), (roundedCorners ? { roundedCorners: roundedCorners } : {})),
+                            position: position,
+                            id: chartId,
+                            type: "chart",
+                        }];
+                case 2:
+                    err_1 = _c.sent();
+                    console.log("Error processing chart:", err_1);
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Helper to get series elements with namespace fallbacks
+function getSeriesElements(plotArea, chartType) {
+    switch (chartType) {
+        case "bar":
+        case "column":
+        // Phase 5.5 — c15 extension chart types emit a c:barChart body
+        // for older-Excel compatibility, so their series live in the same
+        // place as a bar/column chart. Phase 5.5b — histogram additionally
+        // wraps the barChart in mc:AlternateContent > mc:Fallback, so we
+        // also probe that path.
+        case "histogram":
+        case "boxplot":
+        case "waterfall":
+        case "funnel":
+            return getWithFallback(plotArea, [
+                "c:barChart.c:ser",
+                "barChart.ser",
+                "c:bar3DChart.c:ser",
+                "bar3DChart.ser",
+                "mc:AlternateContent.mc:Fallback.c:barChart.c:ser",
+                "AlternateContent.Fallback.barChart.ser",
+            ]);
+        case "line":
+            return getWithFallback(plotArea, [
+                "c:lineChart.c:ser",
+                "lineChart.ser",
+                "c:line3DChart.c:ser",
+                "line3DChart.ser",
+            ]);
+        case "pie":
+            return getWithFallback(plotArea, [
+                "c:pieChart.c:ser",
+                "pieChart.ser",
+                "c:pie3DChart.c:ser",
+                "pie3DChart.ser",
+                // pie-of-pie / bar-of-pie — determineChartType maps
+                // <c:ofPieChart> to "pie", so its series live here too.
+                "c:ofPieChart.c:ser",
+                "ofPieChart.ser",
+            ]);
+        case "doughnut":
+            return getWithFallback(plotArea, [
+                "c:doughnutChart.c:ser",
+                "doughnutChart.ser",
+            ]);
+        case "area":
+            return getWithFallback(plotArea, [
+                "c:areaChart.c:ser",
+                "areaChart.ser",
+                "c:area3DChart.c:ser",
+                "area3DChart.ser",
+            ]);
+        case "radar":
+            return getWithFallback(plotArea, ["c:radarChart.c:ser", "radarChart.ser"]);
+        case "stock":
+            return getWithFallback(plotArea, ["c:stockChart.c:ser", "stockChart.ser"]);
+        case "scatter":
+            return getWithFallback(plotArea, [
+                "c:scatterChart.c:ser",
+                "scatterChart.ser",
+            ]);
+        case "bubble":
+            return getWithFallback(plotArea, [
+                "c:bubbleChart.c:ser",
+                "bubbleChart.ser",
+            ]);
+        default:
+            return getWithFallback(plotArea, ["c:barChart.c:ser", "barChart.ser"]);
+    }
+}
+// Path tuples used by the per-series ref extractors below. We accept
+// both namespaced and stripped forms because fast-xml-parser is
+// configured both ways in different code paths.
+var X_VAL_REF_PATHS = [
+    "c:xVal.c:numRef.c:f",
+    "c:xVal.c:numRef.c:f.t$",
+    "xVal.numRef.f",
+    "xVal.numRef.f.t$",
+    // scatter X axis can also be string (categorical X)
+    "c:xVal.c:strRef.c:f",
+    "c:xVal.c:strRef.c:f.t$",
+    "xVal.strRef.f",
+    "xVal.strRef.f.t$",
+];
+var Y_VAL_REF_PATHS = [
+    "c:yVal.c:numRef.c:f",
+    "c:yVal.c:numRef.c:f.t$",
+    "yVal.numRef.f",
+    "yVal.numRef.f.t$",
+];
+var BUBBLE_SIZE_REF_PATHS = [
+    "c:bubbleSize.c:numRef.c:f",
+    "c:bubbleSize.c:numRef.c:f.t$",
+    "bubbleSize.numRef.f",
+    "bubbleSize.numRef.f.t$",
+];
+var CAT_REF_PATHS = [
+    "c:cat.c:strRef.c:f",
+    "c:cat.c:numRef.c:f",
+    "c:cat.c:strRef.c:f.t$",
+    "c:cat.c:numRef.c:f.t$",
+    "cat.strRef.f",
+    "cat.numRef.f",
+    "cat.strRef.f.t$",
+    "cat.numRef.f.t$",
+];
+var VAL_REF_PATHS = [
+    "c:val.c:numRef.c:f",
+    "c:val.c:numRef.c:f.t$",
+    "val.numRef.f",
+    "val.numRef.f.t$",
+];
+var TX_REF_PATHS = [
+    "c:tx.c:strRef.c:f",
+    "c:tx.c:strRef.c:f.t$",
+    "tx.strRef.f",
+    "tx.strRef.f.t$",
+];
+var isXYChart = function (chartType) {
+    return chartType === "scatter" || chartType === "bubble";
+};
+// Extract the overall data range for the chart
+export function extractChartDataRange(plotArea, chartType, sheetId, resolveSheetId) {
+    var e_2, _a;
+    try {
+        var seriesElements = getSeriesElements(plotArea, chartType);
+        if (!seriesElements)
+            return null;
+        var seriesArray = Array.isArray(seriesElements)
+            ? seriesElements
+            : [seriesElements];
+        // Collect all ranges from the chart, tagged with their parsed
+        // sheet name so cross-sheet refs can be honoured.
+        var allRanges = [];
+        try {
+            for (var seriesArray_1 = __values(seriesArray), seriesArray_1_1 = seriesArray_1.next(); !seriesArray_1_1.done; seriesArray_1_1 = seriesArray_1.next()) {
+                var ser = seriesArray_1_1.value;
+                if (isXYChart(chartType)) {
+                    var xRef = getWithFallback(ser, X_VAL_REF_PATHS);
+                    var yRef = getWithFallback(ser, Y_VAL_REF_PATHS);
+                    var sizeRef = chartType === "bubble"
+                        ? getWithFallback(ser, BUBBLE_SIZE_REF_PATHS)
+                        : undefined;
+                    var nameRef = getWithFallback(ser, TX_REF_PATHS);
+                    if (xRef)
+                        allRanges.push(xRef);
+                    if (yRef)
+                        allRanges.push(yRef);
+                    if (sizeRef)
+                        allRanges.push(sizeRef);
+                    if (nameRef)
+                        allRanges.push(nameRef);
+                }
+                else {
+                    var catRef = getWithFallback(ser, CAT_REF_PATHS);
+                    var valRef = getWithFallback(ser, VAL_REF_PATHS);
+                    var nameRef = getWithFallback(ser, TX_REF_PATHS);
+                    if (catRef)
+                        allRanges.push(catRef);
+                    if (valRef)
+                        allRanges.push(valRef);
+                    if (nameRef)
+                        allRanges.push(nameRef);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (seriesArray_1_1 && !seriesArray_1_1.done && (_a = seriesArray_1.return)) _a.call(seriesArray_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (allRanges.length === 0)
+            return null;
+        // Bounding range is computed per-sheet — different ranges may live
+        // on different sheets (a chart referencing both the host sheet and
+        // a data sheet, for example). Per Excel, the chart's "data range"
+        // is logically the union of inputs; we pick the first sheet's
+        // bounding box as the reportable dataRange and pin the rest via
+        // the per-series sources.
+        var boundingRange = calculateBoundingRange(allRanges);
+        if (boundingRange) {
+            var selections = generateSelectionsFromFormula("=".concat(boundingRange));
+            if (selections.length > 0) {
+                var sel = selections[0];
+                var resolved = pickSheetId(sel.sheetName, sheetId, resolveSheetId);
+                return __assign(__assign({}, sel.range), { sheetId: resolved });
+            }
+        }
+        return null;
+    }
+    catch (err) {
+        console.log("Error extracting chart data range:", err);
+        return null;
+    }
+}
+// Calculate the bounding range that encompasses all the individual ranges
+function calculateBoundingRange(ranges) {
+    var e_3, _a;
+    try {
+        var minRow = Infinity;
+        var maxRow = -Infinity;
+        var minCol = Infinity;
+        var maxCol = -Infinity;
+        var sheetName = "";
+        try {
+            for (var ranges_1 = __values(ranges), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
+                var range = ranges_1_1.value;
+                // Parse each range (e.g., "Sheet1!$A$2:$A$20" or "Sheet1!$C$1")
+                var selections = generateSelectionsFromFormula("=".concat(range));
+                if (selections.length > 0) {
+                    var sel = selections[0];
+                    // Extract sheet name from the first range
+                    if (!sheetName && range.includes("!")) {
+                        sheetName = range.split("!")[0];
+                    }
+                    // Update bounding box
+                    minRow = Math.min(minRow, sel.range.startRowIndex);
+                    maxRow = Math.max(maxRow, sel.range.endRowIndex);
+                    minCol = Math.min(minCol, sel.range.startColumnIndex);
+                    maxCol = Math.max(maxCol, sel.range.endColumnIndex);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (ranges_1_1 && !ranges_1_1.done && (_a = ranges_1.return)) _a.call(ranges_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        if (minRow === Infinity || minCol === Infinity) {
+            return null;
+        }
+        // Convert back to Excel range format
+        var startCell = columnIndexToLetter(minCol) + minRow;
+        var endCell = columnIndexToLetter(maxCol) + maxRow;
+        var rangeStr = startCell === endCell ? startCell : "".concat(startCell, ":").concat(endCell);
+        return sheetName ? "".concat(sheetName, "!").concat(rangeStr) : rangeStr;
+    }
+    catch (err) {
+        console.log("Error calculating bounding range:", err);
+        return null;
+    }
+}
+// Helper function to convert column index to letter (1 -> A, 2 -> B, etc.)
+function columnIndexToLetter(index) {
+    var result = "";
+    var num = index;
+    while (num > 0) {
+        num--;
+        result = String.fromCharCode(65 + (num % 26)) + result;
+        num = Math.floor(num / 26);
+    }
+    return result;
+}
+/**
+ * Extract hidden dimension strategy from plotVisOnly attribute
+ * In Excel: plotVisOnly="1" means skip hidden rows/columns, "0" means show all
+ */
+export function extractHiddenDimensionStrategy(chart) {
+    var plotVisOnly = getWithFallback(chart, [
+        "c:plotVisOnly.a$.val",
+        "c:plotVisOnly.a$.t$",
+        "plotVisOnly.a$.val",
+        "plotVisOnly.a$.t$",
+    ]);
+    if (plotVisOnly === undefined) {
+        return undefined;
+    }
+    // "1" or "true" = skip hidden cells, "0" or "false" = show all
+    var skipHidden = plotVisOnly === "1" || plotVisOnly === "true" || plotVisOnly === true;
+    return skipHidden ? "SKIP_HIDDEN_ROWS_AND_COLUMNS" : "SHOW_ALL";
+}
+/**
+ * Read the chart title's text formatting. Excel chart titles can be
+ * styled two ways:
+ *  - via `<c:title><c:txPr>` (paragraph default, affects future
+ *    content); writers use this when no inline rich text is present.
+ *  - via `<c:title><c:tx><c:rich>` (the title text itself, with
+ *    per-paragraph `<a:pPr><a:defRPr>` carrying the styling).
+ * We probe both, with the rich-text path winning when present (it's
+ * the more explicit signal). Returns `undefined` when neither carries
+ * formatting so the renderer falls back to its theme defaults.
+ */
+function extractChartTitleTextFormat(chart) {
+    var _a, _b, _c;
+    var title = (_a = get(chart, "c:title")) !== null && _a !== void 0 ? _a : get(chart, "title");
+    if (!title)
+        return undefined;
+    var richTxPr = (_b = get(title, "c:tx.c:rich")) !== null && _b !== void 0 ? _b : get(title, "tx.rich");
+    var fromRich = extractTextProperties(richTxPr);
+    if (fromRich)
+        return fromRich;
+    var txPr = (_c = get(title, "c:txPr")) !== null && _c !== void 0 ? _c : get(title, "txPr");
+    return extractTextProperties(txPr);
+}
+export function extractChartTitle(chart) {
+    // Try different possible paths for chart title
+    var title = 
+    // Rich text format (your current structure)
+    get(chart, "c:title.c:tx.c:rich.a:p.a:r.a:t") ||
+        // Alternative rich text paths
+        get(chart, "c:title.c:tx.c:rich.a:p.a:r.a:t.t$") ||
+        // String reference format
+        get(chart, "c:title.c:tx.c:strRef.c:strCache.c:pt.c:v") ||
+        get(chart, "c:title.c:tx.c:strRef.c:strCache.c:pt.c:v.t$") ||
+        // Direct value format
+        get(chart, "c:title.c:tx.c:v") ||
+        get(chart, "c:title.c:tx.c:v.t$") ||
+        // Simple text format
+        get(chart, "c:title.c:tx") ||
+        // Fallback: look for any text in title
+        extractTextFromTitle(get(chart, "c:title")) ||
+        "";
+    return typeof title === "string" ? title : "";
+}
+// Helper function to recursively search for text in title structure
+function extractTextFromTitle(titleObj) {
+    if (!titleObj)
+        return "";
+    // If it's already a string, return it
+    if (typeof titleObj === "string")
+        return titleObj;
+    // Look for common text properties
+    if (titleObj["a:t"])
+        return titleObj["a:t"];
+    if (titleObj.t$)
+        return titleObj.t$;
+    if (titleObj.text)
+        return titleObj.text;
+    if (titleObj.value)
+        return titleObj.value;
+    // Recursively search through nested objects
+    for (var key in titleObj) {
+        if (typeof titleObj[key] === "object") {
+            var result = extractTextFromTitle(titleObj[key]);
+            if (result)
+                return result;
+        }
+    }
+    return "";
+}
+export function determineChartType(chart) {
+    var plotArea = getWithFallback(chart, ["c:plotArea", "plotArea"]);
+    // c15 extension marker (Phase 5.5): if the plotArea's c:extLst tags
+    // the chart as histogram / boxplot / waterfall / funnel, that overrides
+    // the bar-chart fallback the body uses for older-Excel compatibility.
+    var c15Type = detectC15ChartType(plotArea);
+    if (c15Type)
+        return c15Type;
+    var barChart = getWithFallback(plotArea, [
+        "c:barChart",
+        "barChart",
+        "c:bar3DChart",
+        "bar3DChart",
+    ]);
+    if (barChart) {
+        var direction = get(barChart, "c:barDir.a$.val") ||
+            get(barChart, "c:barDir.a$.t$") ||
+            get(barChart, "barDir.a$.val") ||
+            get(barChart, "barDir.a$.t$") ||
+            get(barChart, "c:barDir.a$.v") ||
+            get(barChart, "barDir.a$.v");
+        return direction === "bar" ? "bar" : "column";
+    }
+    if (getWithFallback(plotArea, [
+        "c:lineChart",
+        "lineChart",
+        "c:line3DChart",
+        "line3DChart",
+    ]))
+        return "line";
+    // OOXML uses a dedicated <c:doughnutChart> element. Check it before
+    // <c:pieChart>/<c:ofPieChart> so the more-specific shape wins.
+    if (getWithFallback(plotArea, ["c:doughnutChart", "doughnutChart"]))
+        return "doughnut";
+    // pie-of-pie / bar-of-pie — the renderer draws the composite from a
+    // plain "pie" chartType plus sourceChartType "OF_PIE" and the of-pie
+    // split fields (extracted in extractOfPieOptions).
+    if (getWithFallback(plotArea, ["c:ofPieChart", "ofPieChart"]))
+        return "pie";
+    if (getWithFallback(plotArea, [
+        "c:pieChart",
+        "pieChart",
+        "c:pie3DChart",
+        "pie3DChart",
+    ]))
+        return "pie";
+    if (getWithFallback(plotArea, [
+        "c:areaChart",
+        "areaChart",
+        "c:area3DChart",
+        "area3DChart",
+    ]))
+        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"]))
+        return "scatter";
+    if (getWithFallback(plotArea, ["c:bubbleChart", "bubbleChart"]))
+        return "bubble";
+    return "column"; // default
+}
+/**
+ * Phase 5.5 — detect the c15 extension marker our exporter writes on
+ * the plotArea. Returns the originating chart type (histogram /
+ * boxplot / waterfall / funnel) or null if no marker is present.
+ *
+ * The marker shape is:
+ *   c:plotArea > c:extLst > c:ext (uri = ...) > c15:<chartName>Chart
+ *
+ * We accept either array or single-object shape for `c:ext` since
+ * fast-xml-parser normalizes lone children to objects.
+ */
+function detectC15ChartType(plotArea) {
+    var e_4, _a, e_5, _b;
+    if (!plotArea)
+        return null;
+    // Empty c15 elements (`<c15:histogramChart/>`) parse to "" — truthy
+    // checks skip them, so we test for key presence instead.
+    var hasKey = function (obj, key) {
+        return obj != null && Object.prototype.hasOwnProperty.call(obj, key);
+    };
+    // Phase 5.5b: c15 chart wrapped in mc:AlternateContent > mc:Choice.
+    // This is the Excel-native shape — modern Excel renders the chart
+    // from here, older Excel uses mc:Fallback (a c:barChart).
+    var altContent = getWithFallback(plotArea, [
+        "mc:AlternateContent",
+        "AlternateContent",
+    ]);
+    if (altContent) {
+        var choice = getWithFallback(altContent, ["mc:Choice", "Choice"]);
+        if (choice) {
+            var choices = Array.isArray(choice) ? choice : [choice];
+            try {
+                for (var choices_1 = __values(choices), choices_1_1 = choices_1.next(); !choices_1_1.done; choices_1_1 = choices_1.next()) {
+                    var c = choices_1_1.value;
+                    if (hasKey(c, "c15:histogramChart") || hasKey(c, "histogramChart"))
+                        return "histogram";
+                    if (hasKey(c, "c15:boxWhiskerChart") || hasKey(c, "boxWhiskerChart"))
+                        return "boxplot";
+                    if (hasKey(c, "c15:waterfallChart") || hasKey(c, "waterfallChart"))
+                        return "waterfall";
+                    if (hasKey(c, "c15:funnelChart") || hasKey(c, "funnelChart"))
+                        return "funnel";
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (choices_1_1 && !choices_1_1.done && (_a = choices_1.return)) _a.call(choices_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    // Phase 5.5 (legacy): c15 extension marker inside c:extLst > c:ext.
+    // Round-trips through our pipeline; opens as bar chart in Excel.
+    // Kept so files written by older versions of this code still parse.
+    var extLst = getWithFallback(plotArea, ["c:extLst", "extLst"]);
+    if (!extLst)
+        return null;
+    var extNode = getWithFallback(extLst, ["c:ext", "ext"]);
+    if (!extNode)
+        return null;
+    var exts = Array.isArray(extNode) ? extNode : [extNode];
+    try {
+        for (var exts_1 = __values(exts), exts_1_1 = exts_1.next(); !exts_1_1.done; exts_1_1 = exts_1.next()) {
+            var ext = exts_1_1.value;
+            if (!ext)
+                continue;
+            if (hasKey(ext, "c15:histogramChart") || hasKey(ext, "histogramChart"))
+                return "histogram";
+            if (hasKey(ext, "c15:boxWhiskerChart") || hasKey(ext, "boxWhiskerChart"))
+                return "boxplot";
+            if (hasKey(ext, "c15:waterfallChart") || hasKey(ext, "waterfallChart"))
+                return "waterfall";
+            if (hasKey(ext, "c15:funnelChart") || hasKey(ext, "funnelChart"))
+                return "funnel";
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (exts_1_1 && !exts_1_1.done && (_b = exts_1.return)) _b.call(exts_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return null;
+}
+/**
+ * Phase 5.5 — pull binCount out of the c15:histogramChart extension
+ * marker. Returns undefined if absent.
+ */
+export function extractC15HistogramBinCount(plotArea) {
+    var e_6, _a, e_7, _b;
+    var _c, _d, _e, _f;
+    if (!plotArea)
+        return undefined;
+    var readBinCount = function (hist) {
+        var _a, _b, _c;
+        if (!hist)
+            return undefined;
+        var raw = (_c = (_b = (_a = get(hist, "c15:binCount.a$.val")) !== null && _a !== void 0 ? _a : get(hist, "binCount.a$.val")) !== null && _b !== void 0 ? _b : get(hist, "c15:binCount.a$.v")) !== null && _c !== void 0 ? _c : get(hist, "binCount.a$.v");
+        if (raw === undefined || raw === null)
+            return undefined;
+        var num = Number(raw);
+        return Number.isFinite(num) ? num : undefined;
+    };
+    // Phase 5.5b: histogram inside mc:AlternateContent > mc:Choice.
+    var altContent = getWithFallback(plotArea, [
+        "mc:AlternateContent",
+        "AlternateContent",
+    ]);
+    if (altContent) {
+        var choice = getWithFallback(altContent, ["mc:Choice", "Choice"]);
+        var choices = Array.isArray(choice)
+            ? choice
+            : choice
+                ? [choice]
+                : [];
+        try {
+            for (var choices_2 = __values(choices), choices_2_1 = choices_2.next(); !choices_2_1.done; choices_2_1 = choices_2.next()) {
+                var c = choices_2_1.value;
+                var hist = (_d = (_c = c === null || c === void 0 ? void 0 : c["c15:histogramChart"]) !== null && _c !== void 0 ? _c : c === null || c === void 0 ? void 0 : c["histogramChart"]) !== null && _d !== void 0 ? _d : null;
+                var v = readBinCount(hist);
+                if (v !== undefined)
+                    return v;
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (choices_2_1 && !choices_2_1.done && (_a = choices_2.return)) _a.call(choices_2);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    }
+    // Phase 5.5 (legacy): histogram inside c:extLst > c:ext marker.
+    var extLst = getWithFallback(plotArea, ["c:extLst", "extLst"]);
+    if (!extLst)
+        return undefined;
+    var extNode = getWithFallback(extLst, ["c:ext", "ext"]);
+    if (!extNode)
+        return undefined;
+    var exts = Array.isArray(extNode) ? extNode : [extNode];
+    try {
+        for (var exts_2 = __values(exts), exts_2_1 = exts_2.next(); !exts_2_1.done; exts_2_1 = exts_2.next()) {
+            var ext = exts_2_1.value;
+            var hist = (_f = (_e = ext === null || ext === void 0 ? void 0 : ext["c15:histogramChart"]) !== null && _e !== void 0 ? _e : ext === null || ext === void 0 ? void 0 : ext["histogramChart"]) !== null && _f !== void 0 ? _f : null;
+            var v = readBinCount(hist);
+            if (v !== undefined)
+                return v;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (exts_2_1 && !exts_2_1.done && (_b = exts_2.return)) _b.call(exts_2);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return undefined;
+}
+// Chart type containers to search for series. Combo charts can mix
+// multiple containers (e.g. column + line on one chart), so we iterate
+// through all of them. XY charts (scatter/bubble) have a different
+// per-series shape (xVal/yVal/bubbleSize) and require their own series
+// extractor — they're listed here so combo charts that mix XY with
+// non-XY series (rare but valid in OOXML) still pick up both.
+var CHART_TYPE_CONTAINERS = [
+    {
+        paths: ["c:barChart", "barChart", "c:bar3DChart", "bar3DChart"],
+        chartType: "column",
+        isBar: true,
+    },
+    {
+        paths: ["c:lineChart", "lineChart", "c:line3DChart", "line3DChart"],
+        chartType: "line",
+    },
+    {
+        paths: ["c:areaChart", "areaChart", "c:area3DChart", "area3DChart"],
+        chartType: "area",
+    },
+    {
+        paths: ["c:scatterChart", "scatterChart"],
+        chartType: "scatter",
+        isXY: true,
+    },
+    {
+        paths: ["c:bubbleChart", "bubbleChart"],
+        chartType: "bubble",
+        isXY: true,
+    },
+];
+/**
+ * Resolve a chart-formula range string (e.g.
+ * `'Data for the Chart'!$A$7:$A$26`) into the sources array our chart
+ * model expects (one entry per parsed selection, with the data sheet's
+ * sheetId — not the chart's host sheet).
+ */
+function resolveSourcesFromRef(ref, hostSheetId, resolveSheetId) {
+    var selections = generateSelectionsFromFormula("=".concat(ref));
+    return selections.map(function (sel) { return (__assign(__assign({}, sel.range), { sheetId: pickSheetId(sel.sheetName, hostSheetId, resolveSheetId) })); });
+}
+/**
+ * Extract inline values from a `<c:strLit>` or `<c:numLit>` element —
+ * these appear when chart data is embedded directly in the chart XML
+ * rather than referencing the sheet (Event Budget.xlsx uses this for
+ * its `["Estimated", "Actual"]` category labels).
+ *
+ * Returns the values ordered by their `idx` attribute (Excel allows
+ * sparse indices). Returns `undefined` when no inline data is present.
+ */
+function extractInlineValues(node) {
+    var e_8, _a;
+    var _b, _c, _d, _e;
+    if (!node)
+        return undefined;
+    var strLit = (_b = get(node, "c:strLit")) !== null && _b !== void 0 ? _b : get(node, "strLit");
+    var numLit = (_c = get(node, "c:numLit")) !== null && _c !== void 0 ? _c : get(node, "numLit");
+    var lit = strLit !== null && strLit !== void 0 ? strLit : numLit;
+    if (!lit)
+        return undefined;
+    var pts = (_d = get(lit, "c:pt")) !== null && _d !== void 0 ? _d : get(lit, "pt");
+    if (!pts)
+        return [];
+    var ptArray = Array.isArray(pts) ? pts : [pts];
+    // Order by the `idx` attribute. Most files emit them in order but
+    // spec permits any order; we honour that to avoid mis-aligning the
+    // first column when authors hand-craft chart XML.
+    var indexed = [];
+    try {
+        for (var ptArray_1 = __values(ptArray), ptArray_1_1 = ptArray_1.next(); !ptArray_1_1.done; ptArray_1_1 = ptArray_1.next()) {
+            var pt = ptArray_1_1.value;
+            var idxAttr = get(pt, "a$.idx");
+            var idx = idxAttr !== undefined ? Number(idxAttr) : indexed.length;
+            var rawV = (_e = get(pt, "c:v")) !== null && _e !== void 0 ? _e : get(pt, "v");
+            var v = void 0;
+            if (typeof rawV === "number" || typeof rawV === "boolean") {
+                v = rawV;
+            }
+            else if (numLit && typeof rawV === "string" && rawV.trim() !== "") {
+                var n = Number(rawV);
+                v = Number.isFinite(n) ? n : rawV;
+            }
+            else {
+                v = typeof rawV === "string" ? rawV : String(rawV !== null && rawV !== void 0 ? rawV : "");
+            }
+            indexed.push({ idx: Number.isFinite(idx) ? idx : indexed.length, v: v });
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (ptArray_1_1 && !ptArray_1_1.done && (_a = ptArray_1.return)) _a.call(ptArray_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    indexed.sort(function (a, b) { return a.idx - b.idx; });
+    return indexed.map(function (entry) { return entry.v; });
+}
+export function extractChartSeries(plotArea, chartType, sheetId, resolveSheetId) {
+    var e_9, _a, e_10, _b;
+    var _c, _d;
+    var series = [];
+    var seriesIndex = 0;
+    try {
+        // Iterate through all chart type containers to support combo charts
+        for (var CHART_TYPE_CONTAINERS_1 = __values(CHART_TYPE_CONTAINERS), CHART_TYPE_CONTAINERS_1_1 = CHART_TYPE_CONTAINERS_1.next(); !CHART_TYPE_CONTAINERS_1_1.done; CHART_TYPE_CONTAINERS_1_1 = CHART_TYPE_CONTAINERS_1.next()) {
+            var container = CHART_TYPE_CONTAINERS_1_1.value;
+            var chartElement = getWithFallback(plotArea, container.paths);
+            if (!chartElement)
+                continue;
+            // Handle case where chart element is an array (e.g., multiple c:lineChart elements)
+            var chartElements = Array.isArray(chartElement)
+                ? chartElement
+                : [chartElement];
+            try {
+                for (var chartElements_1 = (e_10 = void 0, __values(chartElements)), chartElements_1_1 = chartElements_1.next(); !chartElements_1_1.done; chartElements_1_1 = chartElements_1.next()) {
+                    var singleChartElement = chartElements_1_1.value;
+                    // Determine the actual chart type for this container
+                    var seriesChartType = container.chartType;
+                    if (container.isBar) {
+                        // Check barDir to distinguish bar vs column
+                        var direction = get(singleChartElement, "c:barDir.a$.val") ||
+                            get(singleChartElement, "c:barDir.a$.t$") ||
+                            get(singleChartElement, "barDir.a$.val") ||
+                            get(singleChartElement, "barDir.a$.t$");
+                        seriesChartType = direction === "bar" ? "bar" : "column";
+                    }
+                    // Get series elements from this container
+                    var seriesElements = getWithFallback(singleChartElement, [
+                        "c:ser",
+                        "ser",
+                    ]);
+                    if (!seriesElements)
+                        continue;
+                    var seriesArray = Array.isArray(seriesElements)
+                        ? seriesElements
+                        : [seriesElements];
+                    for (var i = 0; i < seriesArray.length; i++) {
+                        var ser = seriesArray[i];
+                        // Scatter/bubble — "series" carries Y values (yVal). Non-XY —
+                        // it carries c:val.
+                        var valRef = container.isXY
+                            ? getWithFallback(ser, Y_VAL_REF_PATHS)
+                            : getWithFallback(ser, VAL_REF_PATHS);
+                        var seriesTitle = extractSeriesTitleFromSeries(ser);
+                        var colorInfo = extractSeriesColorInfo(ser);
+                        // Resolve the series' value source — preferring the cell-range
+                        // reference and falling back to inline `<c:numLit>`/`<c:strLit>`
+                        // when there's no range (rare for series values, common for
+                        // tiny embedded charts).
+                        var sources = [];
+                        var inlineValues = void 0;
+                        if (valRef) {
+                            sources = resolveSourcesFromRef(valRef, sheetId, resolveSheetId);
+                        }
+                        if (!sources.length) {
+                            var valNode = container.isXY
+                                ? (_c = get(ser, "c:yVal")) !== null && _c !== void 0 ? _c : get(ser, "yVal")
+                                : (_d = get(ser, "c:val")) !== null && _d !== void 0 ? _d : get(ser, "val");
+                            inlineValues = extractInlineValues(valNode);
+                        }
+                        if (!sources.length && (!inlineValues || !inlineValues.length)) {
+                            seriesIndex++;
+                            continue;
+                        }
+                        var trendlines = extractTrendlines(ser);
+                        var errorBars = extractErrorBars(ser, sheetId, resolveSheetId);
+                        var marker = extractSeriesMarker(ser);
+                        var dataPointColors = extractSeriesDataPointColors(ser);
+                        var nameRef = getWithFallback(ser, TX_REF_PATHS);
+                        // Per-series category reference — charts whose series plot against
+                        // different category ranges can't be represented by the single
+                        // chart-level domain alone; the exporter prefers this when present.
+                        var serCatRef = container.isXY
+                            ? undefined
+                            : getWithFallback(ser, CAT_REF_PATHS);
+                        var categorySources = serCatRef
+                            ? resolveSourcesFromRef(serCatRef, sheetId, resolveSheetId)
+                            : [];
+                        series.push(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dataLabel: seriesTitle || "Series ".concat(seriesIndex + 1) }, (nameRef ? { dataLabelRef: nameRef } : {})), (categorySources.length ? { categorySources: categorySources } : {})), { color: colorInfo.color }), (colorInfo.noFill ? { noFill: true } : {})), { negativeColor: colorInfo.negativeColor, invertIfNegative: colorInfo.invertIfNegative }), (colorInfo.gradient ? { gradient: colorInfo.gradient } : {})), (container.isXY ? {} : { seriesChartType: seriesChartType })), { sources: sources }), (inlineValues && inlineValues.length ? { inlineValues: inlineValues } : {})), (trendlines && trendlines.length ? { trendlines: trendlines } : {})), (errorBars ? { errorBars: errorBars } : {})), (marker ? { marker: marker } : {})), (dataPointColors && dataPointColors.length
+                            ? { dataPointColors: dataPointColors }
+                            : {})));
+                        seriesIndex++;
+                    }
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (chartElements_1_1 && !chartElements_1_1.done && (_b = chartElements_1.return)) _b.call(chartElements_1);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (CHART_TYPE_CONTAINERS_1_1 && !CHART_TYPE_CONTAINERS_1_1.done && (_a = CHART_TYPE_CONTAINERS_1.return)) _a.call(CHART_TYPE_CONTAINERS_1);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    // Fallback: pie/doughnut/radar/stock/ofPie/etc. aren't in
+    // CHART_TYPE_CONTAINERS; they're single-container, type-specific,
+    // and don't combo with other types. Pick up via the type-specific
+    // path-set helper.
+    if (series.length === 0) {
+        var seriesElements = getSeriesElements(plotArea, chartType);
+        if (seriesElements) {
+            var seriesArray = Array.isArray(seriesElements)
+                ? seriesElements
+                : [seriesElements];
+            seriesArray.forEach(function (ser, index) {
+                var _a, _b;
+                var valRef = isXYChart(chartType)
+                    ? getWithFallback(ser, Y_VAL_REF_PATHS)
+                    : getWithFallback(ser, VAL_REF_PATHS);
+                var seriesTitle = extractSeriesTitleFromSeries(ser);
+                var colorInfo = extractSeriesColorInfo(ser);
+                var sources = [];
+                var inlineValues;
+                if (valRef) {
+                    sources = resolveSourcesFromRef(valRef, sheetId, resolveSheetId);
+                }
+                if (!sources.length) {
+                    var valNode = isXYChart(chartType)
+                        ? (_a = get(ser, "c:yVal")) !== null && _a !== void 0 ? _a : get(ser, "yVal")
+                        : (_b = get(ser, "c:val")) !== null && _b !== void 0 ? _b : get(ser, "val");
+                    inlineValues = extractInlineValues(valNode);
+                }
+                if (!sources.length && (!inlineValues || !inlineValues.length)) {
+                    return;
+                }
+                var marker = extractSeriesMarker(ser);
+                var dataPointColors = extractSeriesDataPointColors(ser);
+                var nameRef = getWithFallback(ser, TX_REF_PATHS);
+                var serCatRef = isXYChart(chartType)
+                    ? undefined
+                    : getWithFallback(ser, CAT_REF_PATHS);
+                var categorySources = serCatRef
+                    ? resolveSourcesFromRef(serCatRef, sheetId, resolveSheetId)
+                    : [];
+                series.push(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ dataLabel: seriesTitle || "Series ".concat(index + 1) }, (nameRef ? { dataLabelRef: nameRef } : {})), (categorySources.length ? { categorySources: categorySources } : {})), { color: colorInfo.color }), (colorInfo.noFill ? { noFill: true } : {})), { negativeColor: colorInfo.negativeColor, invertIfNegative: colorInfo.invertIfNegative }), (colorInfo.gradient ? { gradient: colorInfo.gradient } : {})), { sources: sources }), (inlineValues && inlineValues.length ? { inlineValues: inlineValues } : {})), (marker ? { marker: marker } : {})), (dataPointColors && dataPointColors.length
+                    ? { dataPointColors: dataPointColors }
+                    : {})));
+            });
+        }
+    }
+    return series;
+}
+/**
+ * Extract per-data-point color overrides — `<c:dPt>` array inside
+ * `<c:ser>`. Each entry pins a specific category index to its own
+ * fill color (Gantt charts use this to colour individual tasks; pie
+ * charts use it for per-slice colors). Returns `undefined` when there
+ * are no overrides.
+ */
+function extractSeriesDataPointColors(ser) {
+    var e_11, _a;
+    var _b, _c, _d;
+    var raw = (_b = get(ser, "c:dPt")) !== null && _b !== void 0 ? _b : get(ser, "dPt");
+    if (!raw)
+        return undefined;
+    var list = Array.isArray(raw) ? raw : [raw];
+    var result = [];
+    try {
+        for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+            var dPt = list_1_1.value;
+            var idxRaw = (_c = get(dPt, "c:idx.a$.val")) !== null && _c !== void 0 ? _c : get(dPt, "idx.a$.val");
+            var idx = idxRaw !== undefined ? Number(idxRaw) : NaN;
+            if (!Number.isFinite(idx))
+                continue;
+            var solidFill = (_d = get(dPt, "c:spPr.a:solidFill")) !== null && _d !== void 0 ? _d : get(dPt, "spPr.a:solidFill");
+            var color = resolveDrawingColor(solidFill);
+            if (!color)
+                continue;
+            result.push({ idx: idx, color: color });
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return result.length ? result : undefined;
+}
+var MARKER_SYMBOL_SET = new Set([
+    "none",
+    "circle",
+    "square",
+    "diamond",
+    "triangle",
+    "x",
+    "plus",
+    "star",
+    "dash",
+    "dot",
+    "auto",
+    "picture",
+]);
+function extractSeriesMarker(ser) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var raw = (_a = get(ser, "c:marker")) !== null && _a !== void 0 ? _a : get(ser, "marker");
+    if (!raw)
+        return undefined;
+    var symbolRaw = (_d = (_c = (_b = get(raw, "c:symbol.a$.val")) !== null && _b !== void 0 ? _b : get(raw, "symbol.a$.val")) !== null && _c !== void 0 ? _c : get(raw, "c:symbol.a$.t$")) !== null && _d !== void 0 ? _d : get(raw, "symbol.a$.t$");
+    var symbol = typeof symbolRaw === "string" &&
+        MARKER_SYMBOL_SET.has(symbolRaw)
+        ? symbolRaw
+        : undefined;
+    var sizeAttr = (_g = (_f = (_e = get(raw, "c:size.a$.val")) !== null && _e !== void 0 ? _e : get(raw, "size.a$.val")) !== null && _f !== void 0 ? _f : get(raw, "c:size.a$.t$")) !== null && _g !== void 0 ? _g : get(raw, "size.a$.t$");
+    var size = sizeAttr !== undefined && sizeAttr !== null && sizeAttr !== ""
+        ? Number(sizeAttr)
+        : undefined;
+    // Marker fill — used when explicit (not derived from series color).
+    var fillRgb = (_h = get(raw, "c:spPr.a:solidFill.a:srgbClr.a$.val")) !== null && _h !== void 0 ? _h : get(raw, "spPr.solidFill.srgbClr.a$.val");
+    var color = fillRgb ? "#".concat(fillRgb) : undefined;
+    var result = {};
+    if (symbol)
+        result.symbol = symbol;
+    if (typeof size === "number" && Number.isFinite(size))
+        result.size = size;
+    if (color)
+        result.color = color;
+    return Object.keys(result).length ? result : undefined;
+}
+// ─── Text property extraction (color, font) ──────────────────────────
+// Used by `readAxis`, `extractLegendOptions`, `extractDataLabelsOptions`,
+// `extractChartTitle` to pull `<c:txPr>` / `<a:rPr>` styling so axis
+// labels, data labels, legend entries and chart titles render with
+// their authored colors instead of falling back to the renderer's
+// theme default (the BEP.xlsx import showed all labels as
+// near-black).
+var OFFICE_THEME_FALLBACK = {
+    // Standard Office theme color tokens. We don't try to resolve from
+    // the workbook's actual `xl/theme/themeN.xml` here — the chart is
+    // typically authored against the same theme palette and these
+    // defaults match the in-app theme defaults closely enough that the
+    // visual difference is below noise level.
+    tx1: "#000000",
+    tx2: "#44546A",
+    bg1: "#FFFFFF",
+    bg2: "#E7E6E6",
+    dk1: "#000000",
+    dk2: "#44546A",
+    lt1: "#FFFFFF",
+    lt2: "#E7E6E6",
+    accent1: "#4472C4",
+    accent2: "#ED7D31",
+    accent3: "#A5A5A5",
+    accent4: "#FFC000",
+    accent5: "#5B9BD5",
+    accent6: "#70AD47",
+    hlink: "#0563C1",
+    folHlink: "#954F72",
+};
+/**
+ * Apply OOXML lumMod / lumOff / shade / tint modifiers to a base RGB
+ * color. All are stored as 1000ths of a percent (75000 = 75%).
+ *
+ * - `lumMod` scales each channel (`c * mod`)
+ * - `lumOff` adds toward white (`+ 255 * off`)
+ * - `shade` darkens — interpolates toward black (`c * shade`)
+ * - `tint` lightens — interpolates toward white (`c + (255 - c) * tint`)
+ *
+ * Order: shade/tint apply first (they're independent transforms), then
+ * lumMod/lumOff. Matches Excel's behaviour closely for common patterns:
+ *   - `tx1 + lumMod=75% + lumOff=25%` → `#404040` dark gray (BEP)
+ *   - `accent1 + shade=76%` → darker accent1 (Gantt)
+ */
+var applyLumModOff = function (hex, lumMod, lumOff, shade, tint) {
+    var m = /^#?([0-9a-fA-F]{6})$/.exec(hex);
+    if (!m)
+        return hex;
+    var v = parseInt(m[1], 16);
+    var r = (v >> 16) & 0xff;
+    var g = (v >> 8) & 0xff;
+    var b = v & 0xff;
+    // shade darkens (multiply by factor < 1); tint lightens (interp
+    // toward white). Apply before lumMod/lumOff since those mix in a
+    // different luminance space and Excel evaluates shade/tint first.
+    if (typeof shade === "number" && shade > 0 && shade < 1) {
+        r = r * shade;
+        g = g * shade;
+        b = b * shade;
+    }
+    if (typeof tint === "number" && tint > 0 && tint < 1) {
+        r = r + (255 - r) * tint;
+        g = g + (255 - g) * tint;
+        b = b + (255 - b) * tint;
+    }
+    var mod = typeof lumMod === "number" ? lumMod : 1;
+    var off = typeof lumOff === "number" ? lumOff : 0;
+    var apply = function (c) {
+        return Math.max(0, Math.min(255, Math.round(c * mod + 255 * off)));
+    };
+    var toHex = function (c) {
+        return c.toString(16).padStart(2, "0").toUpperCase();
+    };
+    return "#".concat(toHex(apply(r))).concat(toHex(apply(g))).concat(toHex(apply(b)));
+};
+/**
+ * Resolve a DrawingML `<a:solidFill>` (or any element that wraps an
+ * `<a:srgbClr>` / `<a:schemeClr>`) to a hex color string. Handles
+ * `lumMod`/`lumOff` modifiers used to derive grays from theme tokens.
+ */
+function resolveDrawingColor(node) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    if (!node)
+        return undefined;
+    // Direct RGB.
+    var srgb = (_a = get(node, "a:srgbClr.a$.val")) !== null && _a !== void 0 ? _a : get(node, "srgbClr.a$.val");
+    if (srgb) {
+        var lumMod = readPctNumber((_b = get(node, "a:srgbClr.a:lumMod.a$.val")) !== null && _b !== void 0 ? _b : get(node, "srgbClr.lumMod.a$.val"));
+        var lumOff = readPctNumber((_c = get(node, "a:srgbClr.a:lumOff.a$.val")) !== null && _c !== void 0 ? _c : get(node, "srgbClr.lumOff.a$.val"));
+        var shade = readPctNumber((_d = get(node, "a:srgbClr.a:shade.a$.val")) !== null && _d !== void 0 ? _d : get(node, "srgbClr.shade.a$.val"));
+        var tint = readPctNumber((_e = get(node, "a:srgbClr.a:tint.a$.val")) !== null && _e !== void 0 ? _e : get(node, "srgbClr.tint.a$.val"));
+        return applyLumModOff("#".concat(srgb), lumMod, lumOff, shade, tint);
+    }
+    // Theme reference.
+    var schemeName = (_f = get(node, "a:schemeClr.a$.val")) !== null && _f !== void 0 ? _f : get(node, "schemeClr.a$.val");
+    if (typeof schemeName === "string") {
+        var base = (_g = OFFICE_THEME_FALLBACK[schemeName]) !== null && _g !== void 0 ? _g : "#000000";
+        var lumMod = readPctNumber((_h = get(node, "a:schemeClr.a:lumMod.a$.val")) !== null && _h !== void 0 ? _h : get(node, "schemeClr.lumMod.a$.val"));
+        var lumOff = readPctNumber((_j = get(node, "a:schemeClr.a:lumOff.a$.val")) !== null && _j !== void 0 ? _j : get(node, "schemeClr.lumOff.a$.val"));
+        var shade = readPctNumber((_k = get(node, "a:schemeClr.a:shade.a$.val")) !== null && _k !== void 0 ? _k : get(node, "schemeClr.shade.a$.val"));
+        var tint = readPctNumber((_l = get(node, "a:schemeClr.a:tint.a$.val")) !== null && _l !== void 0 ? _l : get(node, "schemeClr.tint.a$.val"));
+        return applyLumModOff(base, lumMod, lumOff, shade, tint);
+    }
+    return undefined;
+}
+/** Parse an OOXML percentage stored as 1000ths-of-a-percent → 0..1. */
+function readPctNumber(val) {
+    if (val === undefined || val === null || val === "")
+        return undefined;
+    var n = Number(val);
+    return Number.isFinite(n) ? n / 100000 : undefined;
+}
+/**
+ * Extract a `ChartTextFormat` from an OOXML text-properties node. The
+ * input is typically `<c:txPr>` or `<c:title><c:tx><c:rich>` — both
+ * use the same `<a:p><a:pPr><a:defRPr>…</a:defRPr></a:pPr></a:p>`
+ * shape to express paragraph-default character properties.
+ *
+ * Returns `undefined` when the node carries no formatting (so the
+ * caller doesn't emit an empty `textFormat` field).
+ */
+function extractTextProperties(txPr) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!txPr)
+        return undefined;
+    // The font/color lives on `<a:p><a:pPr><a:defRPr>`. Some writers put
+    // it directly on `<a:r><a:rPr>` for rich titles — accept both.
+    var defRPr = (_c = (_b = (_a = get(txPr, "a:p.a:pPr.a:defRPr")) !== null && _a !== void 0 ? _a : get(txPr, "p.pPr.defRPr")) !== null && _b !== void 0 ? _b : get(txPr, "a:p.a:r.a:rPr")) !== null && _c !== void 0 ? _c : get(txPr, "p.r.rPr");
+    if (!defRPr)
+        return undefined;
+    var result = {};
+    // Font size — `sz` is in 100ths of a point (`sz="900"` → 9pt).
+    var szAttr = (_d = get(defRPr, "a$.sz")) !== null && _d !== void 0 ? _d : get(defRPr, "a$.t$");
+    if (szAttr !== undefined && szAttr !== null && szAttr !== "") {
+        var sz = Number(szAttr);
+        if (Number.isFinite(sz) && sz > 0)
+            result.fontSize = sz / 100;
+    }
+    // Bold / italic / underline / strikethrough.
+    var bAttr = get(defRPr, "a$.b");
+    if (bAttr === "1" || bAttr === 1 || bAttr === true)
+        result.bold = true;
+    var iAttr = get(defRPr, "a$.i");
+    if (iAttr === "1" || iAttr === 1 || iAttr === true)
+        result.italic = true;
+    var uAttr = get(defRPr, "a$.u");
+    if (typeof uAttr === "string" && uAttr !== "none")
+        result.underline = true;
+    var strikeAttr = get(defRPr, "a$.strike");
+    if (typeof strikeAttr === "string" && strikeAttr !== "noStrike") {
+        result.strikethrough = true;
+    }
+    // Font family — `<a:latin typeface="…">`.
+    var latin = (_e = get(defRPr, "a:latin.a$.typeface")) !== null && _e !== void 0 ? _e : get(defRPr, "latin.a$.typeface");
+    if (typeof latin === "string" && latin)
+        result.fontFamily = latin;
+    // Color — `<a:solidFill>` containing `<a:srgbClr>` or `<a:schemeClr>`.
+    var solidFill = (_f = get(defRPr, "a:solidFill")) !== null && _f !== void 0 ? _f : get(defRPr, "solidFill");
+    var color = resolveDrawingColor(solidFill);
+    if (color)
+        result.color = color;
+    return Object.keys(result).length ? result : undefined;
+}
+/**
+ * Read bar/column `<c:grouping>`, `<c:overlap>`, `<c:gapWidth>` —
+ * controls how multi-series bars are arranged (clustered / stacked /
+ * percent-stacked). Looks inside `<c:barChart>` / `<c:bar3DChart>`
+ * containers; returns `undefined` if no settings are present so the
+ * renderer keeps its defaults.
+ */
+function extractBarLayoutOptions(plotArea) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var bar = (_c = (_b = (_a = get(plotArea, "c:barChart")) !== null && _a !== void 0 ? _a : get(plotArea, "barChart")) !== null && _b !== void 0 ? _b : get(plotArea, "c:bar3DChart")) !== null && _c !== void 0 ? _c : get(plotArea, "bar3DChart");
+    if (!bar)
+        return undefined;
+    // `<c:grouping val="clustered|stacked|percentStacked|standard"/>`.
+    // `standard` is "side-by-side, no stacking" — same as `clustered`
+    // semantically; map both to UNSTACKED.
+    var groupingVal = (_f = (_e = (_d = get(bar, "c:grouping.a$.val")) !== null && _d !== void 0 ? _d : get(bar, "grouping.a$.val")) !== null && _e !== void 0 ? _e : get(bar, "c:grouping.a$.t$")) !== null && _f !== void 0 ? _f : get(bar, "grouping.a$.t$");
+    var stackedType;
+    switch (groupingVal) {
+        case "stacked":
+            stackedType = "STACKED";
+            break;
+        case "percentStacked":
+            stackedType = "PERCENT_STACKED";
+            break;
+        case "clustered":
+        case "standard":
+            stackedType = "UNSTACKED";
+            break;
+    }
+    var overlapVal = readNumber((_g = get(bar, "c:overlap.a$.val")) !== null && _g !== void 0 ? _g : get(bar, "overlap.a$.val"));
+    var gapWidthVal = readNumber((_h = get(bar, "c:gapWidth.a$.val")) !== null && _h !== void 0 ? _h : get(bar, "gapWidth.a$.val"));
+    var result = {};
+    if (stackedType)
+        result.stackedType = stackedType;
+    if (typeof overlapVal === "number")
+        result.overlap = overlapVal;
+    if (typeof gapWidthVal === "number")
+        result.gapWidth = gapWidthVal;
+    return Object.keys(result).length ? result : undefined;
+}
+/**
+ * Extract chart-level `<c:scatterStyle val=…>`. Excel default is
+ * "lineMarker" (straight lines + markers). Returns undefined for
+ * non-scatter charts.
+ */
+function extractScatterStyle(plotArea) {
+    var _a, _b, _c;
+    var val = (_c = (_b = (_a = get(plotArea, "c:scatterChart.c:scatterStyle.a$.val")) !== null && _a !== void 0 ? _a : get(plotArea, "scatterChart.scatterStyle.a$.val")) !== null && _b !== void 0 ? _b : get(plotArea, "c:scatterChart.c:scatterStyle.a$.t$")) !== null && _c !== void 0 ? _c : get(plotArea, "scatterChart.scatterStyle.a$.t$");
+    return typeof val === "string" && val ? val : undefined;
+}
+function extractSeriesTitleFromSeries(ser) {
+    var e_12, _a;
+    // Prefer cached textual value if present
+    var cacheEntries = get(ser, "c:tx.c:strRef.c:strCache.c:pt");
+    if (cacheEntries) {
+        var pts = Array.isArray(cacheEntries) ? cacheEntries : [cacheEntries];
+        try {
+            for (var pts_1 = __values(pts), pts_1_1 = pts_1.next(); !pts_1_1.done; pts_1_1 = pts_1.next()) {
+                var pt = pts_1_1.value;
+                var value = coerceTitleText(get(pt, "c:v.t$") ||
+                    get(pt, "c:v") ||
+                    extractRichText(get(pt, "c:rich")));
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (pts_1_1 && !pts_1_1.done && (_a = pts_1.return)) _a.call(pts_1);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+    }
+    // Fall back to literal
+    var literal = coerceTitleText(get(ser, "c:tx.c:v.t$") ||
+        get(ser, "c:tx.c:v") ||
+        extractRichText(get(ser, "c:tx.c:rich")));
+    if (literal) {
+        return literal;
+    }
+    return undefined;
+}
+/**
+ * fast-xml-parser converts numeric `<c:v>` values (e.g. a series header
+ * like 2024) into numbers; normalize primitives to strings and drop
+ * anything else so titles are always strings downstream.
+ */
+function coerceTitleText(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return undefined;
+}
+function extractRichText(node) {
+    var e_13, _a, e_14, _b;
+    if (!node) {
+        return undefined;
+    }
+    var paragraphs = getWithFallback(node, ["a:p", "p"]);
+    var paragraphArray = Array.isArray(paragraphs)
+        ? paragraphs
+        : paragraphs
+            ? [paragraphs]
+            : [];
+    var fragments = [];
+    try {
+        for (var paragraphArray_1 = __values(paragraphArray), paragraphArray_1_1 = paragraphArray_1.next(); !paragraphArray_1_1.done; paragraphArray_1_1 = paragraphArray_1.next()) {
+            var paragraph = paragraphArray_1_1.value;
+            var runs = getWithFallback(paragraph, ["a:r", "r"]);
+            var runArray = Array.isArray(runs) ? runs : runs ? [runs] : [paragraph];
+            try {
+                for (var runArray_1 = (e_14 = void 0, __values(runArray)), runArray_1_1 = runArray_1.next(); !runArray_1_1.done; runArray_1_1 = runArray_1.next()) {
+                    var run = runArray_1_1.value;
+                    var text = getWithFallback(run, ["a:t.t$", "a:t"]) ||
+                        getWithFallback(run, ["t$", "t"]);
+                    if (typeof text === "string") {
+                        fragments.push(text);
+                    }
+                }
+            }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (runArray_1_1 && !runArray_1_1.done && (_b = runArray_1.return)) _b.call(runArray_1);
+                }
+                finally { if (e_14) throw e_14.error; }
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (paragraphArray_1_1 && !paragraphArray_1_1.done && (_a = paragraphArray_1.return)) _a.call(paragraphArray_1);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    if (fragments.length > 0) {
+        return fragments.join("");
+    }
+    return undefined;
+}
+function normalizeHexColor(value) {
+    if (!value)
+        return undefined;
+    var trimmed = value.toString().trim().replace(/^#/, "");
+    if (!trimmed)
+        return undefined;
+    var sanitized = trimmed.replace(/[^0-9a-fA-F]/g, "").toUpperCase();
+    if (sanitized.length === 6) {
+        return "#".concat(sanitized);
+    }
+    if (sanitized.length === 8) {
+        return "#".concat(sanitized.slice(-6));
+    }
+    return undefined;
+}
+function extractSeriesColorInfo(ser) {
+    var e_15, _a, e_16, _b;
+    var _c, _d, _e, _f;
+    var result = {};
+    // <a:noFill/> on the series shape properties — transparent series.
+    // OOXML can express this as the singleton element with no children;
+    // the absence of a:solidFill / a:gradFill is also a signal but
+    // brittler. fast-xml-parser emits `noFill: ""` or `noFill: {}` for
+    // empty elements — both falsy by-value but truthy by-presence.
+    var noFillFill = (_c = get(ser, "c:spPr.a:noFill")) !== null && _c !== void 0 ? _c : get(ser, "spPr.a:noFill");
+    if (noFillFill !== undefined) {
+        result.noFill = true;
+    }
+    // Try the full <a:solidFill> shape first — handles both srgbClr
+    // and schemeClr (with lumMod/lumOff/shade/tint/alpha modifiers).
+    var solidFillNode = (_d = get(ser, "c:spPr.a:solidFill")) !== null && _d !== void 0 ? _d : get(ser, "spPr.a:solidFill");
+    var resolvedFill = resolveDrawingColor(solidFillNode);
+    // Extract main color - check both fill color (for bar/column) and line color (for line/area charts)
+    var fillColorValue = getWithFallback(ser, [
+        "c:spPr.a:solidFill.a:srgbClr.a$.val",
+        "c:spPr.a:solidFill.a:srgbClr.a$.t$",
+        "c:spPr.a:solidFill.a:srgbClr.a$.rgb",
+        "c:spPr.solidFill.srgbClr.a$.val",
+        "spPr.a:solidFill.a:srgbClr.a$.val",
+        "spPr.solidFill.srgbClr.a$.val",
+    ]);
+    // Line color for line/scatter/area charts
+    var lineColorValue = getWithFallback(ser, [
+        "c:spPr.a:ln.a:solidFill.a:srgbClr.a$.val",
+        "c:spPr.a:ln.a:solidFill.a:srgbClr.a$.t$",
+        "c:spPr.a:ln.a:solidFill.a:srgbClr.a$.rgb",
+        "c:spPr.a:ln.solidFill.srgbClr.a$.val",
+        "spPr.a:ln.a:solidFill.a:srgbClr.a$.val",
+        "spPr.ln.solidFill.srgbClr.a$.val",
+    ]);
+    // Use fill color if available, otherwise use line color.
+    // resolvedFill handles schemeClr; the legacy normalize call handles
+    // the explicit srgbClr path (kept as a fallback). When noFill is set
+    // we leave `color` undefined — the renderer treats the series as
+    // transparent.
+    if (!result.noFill) {
+        result.color =
+            (_e = resolvedFill !== null && resolvedFill !== void 0 ? resolvedFill : normalizeHexColor(fillColorValue)) !== null && _e !== void 0 ? _e : normalizeHexColor(lineColorValue);
+    }
+    // Gradient fill — DrawingML `<a:gradFill>` inside `<c:spPr>`. Stops
+    // come in EMU per-mille (0..100000); positions get normalized back
+    // to 0..1 for our shape. Linear angle is in 60000ths of a degree;
+    // path gradients carry insets via `<a:path><a:fillToRect/>`.
+    var gradFill = getWithFallback(ser, [
+        "c:spPr.a:gradFill",
+        "spPr.a:gradFill",
+        "c:spPr.gradFill",
+    ]);
+    if (gradFill) {
+        var rawStops = getWithFallback(gradFill, [
+            "a:gsLst.a:gs",
+            "gsLst.gs",
+        ]);
+        var stopList = rawStops
+            ? Array.isArray(rawStops)
+                ? rawStops
+                : [rawStops]
+            : [];
+        var stops = [];
+        try {
+            for (var stopList_1 = __values(stopList), stopList_1_1 = stopList_1.next(); !stopList_1_1.done; stopList_1_1 = stopList_1.next()) {
+                var stop_1 = stopList_1_1.value;
+                var posRaw = (_f = stop_1 === null || stop_1 === void 0 ? void 0 : stop_1.a$) === null || _f === void 0 ? void 0 : _f.pos;
+                var position = posRaw != null
+                    ? Math.max(0, Math.min(1, parseFloat(posRaw) / 100000))
+                    : NaN;
+                if (!Number.isFinite(position))
+                    continue;
+                var hex = getWithFallback(stop_1, [
+                    "a:srgbClr.a$.val",
+                    "srgbClr.a$.val",
+                ]);
+                var color = normalizeHexColor(hex);
+                if (!color)
+                    continue;
+                stops.push({ position: position, color: color });
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (stopList_1_1 && !stopList_1_1.done && (_a = stopList_1.return)) _a.call(stopList_1);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        if (stops.length > 0) {
+            stops.sort(function (a, b) { return a.position - b.position; });
+            var lin = getWithFallback(gradFill, ["a:lin.a$", "lin.a$"]);
+            var path = getWithFallback(gradFill, ["a:path", "path"]);
+            if (path) {
+                var insets = getWithFallback(path, [
+                    "a:fillToRect.a$",
+                    "fillToRect.a$",
+                ]);
+                var emuToFraction = function (v) {
+                    if (v == null)
+                        return undefined;
+                    var n = parseFloat(v);
+                    return Number.isFinite(n) ? n / 100000 : undefined;
+                };
+                result.gradient = {
+                    type: "path",
+                    left: emuToFraction(insets === null || insets === void 0 ? void 0 : insets.l),
+                    right: emuToFraction(insets === null || insets === void 0 ? void 0 : insets.r),
+                    top: emuToFraction(insets === null || insets === void 0 ? void 0 : insets.t),
+                    bottom: emuToFraction(insets === null || insets === void 0 ? void 0 : insets.b),
+                    stops: stops,
+                };
+            }
+            else {
+                var ang = (lin === null || lin === void 0 ? void 0 : lin.ang) != null ? parseFloat(lin.ang) : 0;
+                result.gradient = {
+                    type: "linear",
+                    degree: Number.isFinite(ang) ? ang / 60000 : 0,
+                    stops: stops,
+                };
+            }
+        }
+    }
+    // Extract invertIfNegative flag
+    var invertIfNegativeVal = getWithFallback(ser, [
+        "c:invertIfNegative.a$.val",
+        "c:invertIfNegative.t$",
+        "c:invertIfNegative",
+        "invertIfNegative.a$.val",
+        "invertIfNegative",
+    ]);
+    // Value can be "1", "true", true, or 1
+    if (invertIfNegativeVal !== undefined) {
+        result.invertIfNegative =
+            invertIfNegativeVal === "1" ||
+                invertIfNegativeVal === true ||
+                invertIfNegativeVal === 1 ||
+                invertIfNegativeVal === "true";
+    }
+    // Extract negative fill color from extLst (Excel 2010+ format)
+    // The negative color is stored in c:extLst.c:ext with specific URI
+    var extLst = getWithFallback(ser, [
+        "c:extLst.c:ext",
+        "c:extLst",
+        "extLst.ext",
+        "extLst",
+    ]);
+    if (extLst) {
+        var extArray = Array.isArray(extLst) ? extLst : [extLst];
+        try {
+            for (var extArray_1 = __values(extArray), extArray_1_1 = extArray_1.next(); !extArray_1_1.done; extArray_1_1 = extArray_1.next()) {
+                var ext = extArray_1_1.value;
+                // Look for invertSolidFillFmt extension (negative fill format)
+                var negFillColor = getWithFallback(ext, [
+                    "c14:invertSolidFillFmt.c14:spPr.a:solidFill.a:srgbClr.a$.val",
+                    "c14:invertSolidFillFmt.c14:spPr.a:solidFill.a:srgbClr.a$.rgb",
+                    "invertSolidFillFmt.spPr.solidFill.srgbClr.a$.val",
+                    // Also check for c15 namespace (Excel 2013+)
+                    "c15:invertSolidFillFmt.c15:spPr.a:solidFill.a:srgbClr.a$.val",
+                ]);
+                if (negFillColor) {
+                    result.negativeColor = normalizeHexColor(negFillColor);
+                    // If we have a negative color, invertIfNegative should be true
+                    if (result.negativeColor) {
+                        result.invertIfNegative = true;
+                    }
+                    break;
+                }
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (extArray_1_1 && !extArray_1_1.done && (_b = extArray_1.return)) _b.call(extArray_1);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+    }
+    return result;
+}
+export function extractChartDomains(plotArea, chartType, sheetId, resolveSheetId) {
+    var e_17, _a, e_18, _b, e_19, _c, e_20, _d;
+    var _e, _f;
+    var domains = [];
+    try {
+        // 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.
+        for (var CHART_TYPE_CONTAINERS_2 = __values(CHART_TYPE_CONTAINERS), CHART_TYPE_CONTAINERS_2_1 = CHART_TYPE_CONTAINERS_2.next(); !CHART_TYPE_CONTAINERS_2_1.done; CHART_TYPE_CONTAINERS_2_1 = CHART_TYPE_CONTAINERS_2.next()) {
+            var container = CHART_TYPE_CONTAINERS_2_1.value;
+            var chartElement = getWithFallback(plotArea, container.paths);
+            if (!chartElement)
+                continue;
+            var chartElements = Array.isArray(chartElement)
+                ? chartElement
+                : [chartElement];
+            try {
+                for (var chartElements_2 = (e_18 = void 0, __values(chartElements)), chartElements_2_1 = chartElements_2.next(); !chartElements_2_1.done; chartElements_2_1 = chartElements_2.next()) {
+                    var singleChartElement = chartElements_2_1.value;
+                    var seriesElements_1 = getWithFallback(singleChartElement, [
+                        "c:ser",
+                        "ser",
+                    ]);
+                    if (!seriesElements_1)
+                        continue;
+                    var seriesArray = Array.isArray(seriesElements_1)
+                        ? seriesElements_1
+                        : [seriesElements_1];
+                    try {
+                        for (var seriesArray_2 = (e_19 = void 0, __values(seriesArray)), seriesArray_2_1 = seriesArray_2.next(); !seriesArray_2_1.done; seriesArray_2_1 = seriesArray_2.next()) {
+                            var ser = seriesArray_2_1.value;
+                            var domainRef = container.isXY
+                                ? getWithFallback(ser, X_VAL_REF_PATHS)
+                                : getWithFallback(ser, CAT_REF_PATHS);
+                            if (domainRef) {
+                                var sources = resolveSourcesFromRef(domainRef, sheetId, resolveSheetId);
+                                if (sources.length) {
+                                    domains.push({ sources: 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;
+                                }
+                            }
+                            else if (!container.isXY) {
+                                // 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,
+                                // but domains is by far the most common case.
+                                var catNode = (_e = get(ser, "c:cat")) !== null && _e !== void 0 ? _e : get(ser, "cat");
+                                var inlineValues = extractInlineValues(catNode);
+                                if (inlineValues && inlineValues.length) {
+                                    domains.push({ sources: [], inlineValues: inlineValues });
+                                    return domains;
+                                }
+                            }
+                        }
+                    }
+                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                    finally {
+                        try {
+                            if (seriesArray_2_1 && !seriesArray_2_1.done && (_c = seriesArray_2.return)) _c.call(seriesArray_2);
+                        }
+                        finally { if (e_19) throw e_19.error; }
+                    }
+                    if (domains.length && container.isXY)
+                        return domains;
+                }
+            }
+            catch (e_18_1) { e_18 = { error: e_18_1 }; }
+            finally {
+                try {
+                    if (chartElements_2_1 && !chartElements_2_1.done && (_b = chartElements_2.return)) _b.call(chartElements_2);
+                }
+                finally { if (e_18) throw e_18.error; }
+            }
+        }
+    }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    finally {
+        try {
+            if (CHART_TYPE_CONTAINERS_2_1 && !CHART_TYPE_CONTAINERS_2_1.done && (_a = CHART_TYPE_CONTAINERS_2.return)) _a.call(CHART_TYPE_CONTAINERS_2);
+        }
+        finally { if (e_17) throw e_17.error; }
+    }
+    // Fallback for chart types not in CHART_TYPE_CONTAINERS
+    // (pie/doughnut/radar/stock/ofPie/scatter/bubble outside combos).
+    var seriesElements = getSeriesElements(plotArea, chartType);
+    if (seriesElements) {
+        var seriesArray = Array.isArray(seriesElements)
+            ? seriesElements
+            : [seriesElements];
+        try {
+            for (var seriesArray_3 = __values(seriesArray), seriesArray_3_1 = seriesArray_3.next(); !seriesArray_3_1.done; seriesArray_3_1 = seriesArray_3.next()) {
+                var ser = seriesArray_3_1.value;
+                var domainRef = isXYChart(chartType)
+                    ? getWithFallback(ser, X_VAL_REF_PATHS)
+                    : getWithFallback(ser, CAT_REF_PATHS);
+                if (domainRef) {
+                    var sources = resolveSourcesFromRef(domainRef, sheetId, resolveSheetId);
+                    if (sources.length) {
+                        domains.push({ sources: sources });
+                        if (!isXYChart(chartType))
+                            break;
+                    }
+                }
+                else if (!isXYChart(chartType)) {
+                    var catNode = (_f = get(ser, "c:cat")) !== null && _f !== void 0 ? _f : get(ser, "cat");
+                    var inlineValues = extractInlineValues(catNode);
+                    if (inlineValues && inlineValues.length) {
+                        domains.push({ sources: [], inlineValues: inlineValues });
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (seriesArray_3_1 && !seriesArray_3_1.done && (_d = seriesArray_3.return)) _d.call(seriesArray_3);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
+    }
+    return domains;
+}
+/**
+ * Bubble charts have a third dimension — bubble size — referenced
+ * via `<c:bubbleSize><c:numRef><c:f>` on each series. Returns one
+ * `ChartData` entry per series (matches the shape used by `domains` /
+ * `series`).
+ */
+export function extractChartBubbleSizes(plotArea, sheetId, resolveSheetId) {
+    var e_21, _a;
+    var sizes = [];
+    var seriesElements = getSeriesElements(plotArea, "bubble");
+    if (!seriesElements)
+        return sizes;
+    var seriesArray = Array.isArray(seriesElements)
+        ? seriesElements
+        : [seriesElements];
+    try {
+        for (var seriesArray_4 = __values(seriesArray), seriesArray_4_1 = seriesArray_4.next(); !seriesArray_4_1.done; seriesArray_4_1 = seriesArray_4.next()) {
+            var ser = seriesArray_4_1.value;
+            var sizeRef = getWithFallback(ser, BUBBLE_SIZE_REF_PATHS);
+            if (!sizeRef)
+                continue;
+            var sources = resolveSourcesFromRef(sizeRef, sheetId, resolveSheetId);
+            if (sources.length)
+                sizes.push({ sources: sources });
+        }
+    }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    finally {
+        try {
+            if (seriesArray_4_1 && !seriesArray_4_1.done && (_a = seriesArray_4.return)) _a.call(seriesArray_4);
+        }
+        finally { if (e_21) throw e_21.error; }
+    }
+    return sizes;
+}
+export function extractChartPosition(anchor, sheetId, sheetDimensions) {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        // Handle oneCellAnchor
+        var oneCellFrom = (_a = getWithFallback(anchor, ["xdr:from", "from"])) !== null && _a !== void 0 ? _a : undefined;
+        var hasTwoCellTarget = getWithFallback(anchor, ["xdr:to", "to"]) !== undefined;
+        if (oneCellFrom && !hasTwoCellTarget) {
+            var extNode = getWithFallback(anchor, ["xdr:ext", "ext"]);
+            var extAttributes = (extNode && ((_b = extNode.a$) !== null && _b !== void 0 ? _b : extNode)) || undefined;
+            var col = toInt(getWithFallback(oneCellFrom, ["xdr:col", "col"]));
+            var row = toInt(getWithFallback(oneCellFrom, ["xdr:row", "row"]));
+            var colOff = toInt(getWithFallback(oneCellFrom, ["xdr:colOff", "colOff"]));
+            var rowOff = toInt(getWithFallback(oneCellFrom, ["xdr:rowOff", "rowOff"]));
+            // Convert EMU to pixels (1 EMU = 1/9525 pixels)
+            var width = extAttributes && extAttributes.cx
+                ? Math.round(parseInt(String(extAttributes.cx), 10) / 9525)
+                : 400;
+            var height = extAttributes && extAttributes.cy
+                ? Math.round(parseInt(String(extAttributes.cy), 10) / 9525)
+                : 300;
+            return {
+                sheetId: sheetId,
+                overlayPosition: {
+                    anchorCell: {
+                        rowIndex: row + 1,
+                        columnIndex: col + 1,
+                    },
+                    offsetXPixels: Math.round(colOff / 9525),
+                    offsetYPixels: Math.round(rowOff / 9525),
+                    widthPixels: width,
+                    heightPixels: height,
+                },
+            };
+        }
+        // Handle twoCellAnchor
+        var fromCell = (_c = getWithFallback(anchor, ["xdr:from", "from"])) !== null && _c !== void 0 ? _c : undefined;
+        var toCell = (_d = getWithFallback(anchor, ["xdr:to", "to"])) !== null && _d !== void 0 ? _d : undefined;
+        if (fromCell && toCell) {
+            var col = toInt(getWithFallback(fromCell, ["xdr:col", "col"]));
+            var row = toInt(getWithFallback(fromCell, ["xdr:row", "row"]));
+            var colOff = toInt(getWithFallback(fromCell, ["xdr:colOff", "colOff"]));
+            var rowOff = toInt(getWithFallback(fromCell, ["xdr:rowOff", "rowOff"]));
+            var toCol = toInt(getWithFallback(toCell, ["xdr:col", "col"]));
+            var toRow = toInt(getWithFallback(toCell, ["xdr:row", "row"]));
+            var toColOff = toInt(getWithFallback(toCell, ["xdr:colOff", "colOff"]));
+            var toRowOff = toInt(getWithFallback(toCell, ["xdr:rowOff", "rowOff"]));
+            // Default cell dimensions in pixels
+            var DEFAULT_COL_WIDTH_PX_1 = (_e = sheetDimensions === null || sheetDimensions === void 0 ? void 0 : sheetDimensions.defaultColumnWidth) !== null && _e !== void 0 ? _e : 64;
+            var DEFAULT_ROW_HEIGHT_PX_1 = (_f = sheetDimensions === null || sheetDimensions === void 0 ? void 0 : sheetDimensions.defaultRowHeight) !== null && _f !== void 0 ? _f : 20;
+            // Helper to get column width in pixels
+            var getColWidth = function (colIndex) {
+                var _a, _b;
+                return ((_b = (_a = sheetDimensions === null || sheetDimensions === void 0 ? void 0 : sheetDimensions.columnWidths) === null || _a === void 0 ? void 0 : _a.get(colIndex + 1)) !== null && _b !== void 0 ? _b : DEFAULT_COL_WIDTH_PX_1);
+            };
+            // Helper to get row height in pixels
+            var getRowHeight = function (rowIndex) {
+                var _a, _b;
+                return ((_b = (_a = sheetDimensions === null || sheetDimensions === void 0 ? void 0 : sheetDimensions.rowHeights) === null || _a === void 0 ? void 0 : _a.get(rowIndex + 1)) !== null && _b !== void 0 ? _b : DEFAULT_ROW_HEIGHT_PX_1);
+            };
+            // Calculate width by summing actual column widths
+            var widthPx = 0;
+            for (var c = col; c < toCol; c++) {
+                widthPx += getColWidth(c);
+            }
+            // Subtract offset into first cell, add offset into last cell
+            // Offsets are in EMUs, convert to pixels
+            widthPx -= Math.round(colOff / 9525);
+            widthPx += Math.round(toColOff / 9525);
+            // Calculate height by summing actual row heights
+            var heightPx = 0;
+            for (var r = row; r < toRow; r++) {
+                heightPx += getRowHeight(r);
+            }
+            // Subtract offset into first cell, add offset into last cell
+            heightPx -= Math.round(rowOff / 9525);
+            heightPx += Math.round(toRowOff / 9525);
+            var width = Math.max(widthPx, 100);
+            var height = Math.max(heightPx, 100);
+            return {
+                sheetId: sheetId,
+                overlayPosition: {
+                    anchorCell: {
+                        rowIndex: row + 1,
+                        columnIndex: col + 1,
+                    },
+                    offsetXPixels: Math.round(colOff / 9525),
+                    offsetYPixels: Math.round(rowOff / 9525),
+                    widthPixels: width,
+                    heightPixels: height,
+                },
+            };
+        }
+        return null;
+    }
+    catch (err) {
+        console.log("Error extracting chart position:", err);
+        return null;
+    }
+}
+// -------------------------- Phase 5 helpers --------------------------
+// Read OOXML legend (<c:legend>), data labels (<c:dLbls>), and axis
+// formatting (<c:valAx>, <c:catAx>) elements into the engine's ChartSpec
+// shape. All helpers return `undefined` when nothing meaningful is set,
+// so callers can spread the result without polluting the spec.
+var readBoolean = function (val) {
+    if (val === undefined || val === null)
+        return undefined;
+    return val === "1" || val === "true" || val === true;
+};
+var readNumber = function (val) {
+    if (val === undefined || val === null)
+        return undefined;
+    var n = typeof val === "number" ? val : parseFloat(String(val));
+    return Number.isFinite(n) ? n : undefined;
+};
+var mapLegendPosition = function (val) {
+    switch (val) {
+        case "t":
+            return "top";
+        case "b":
+            return "bottom";
+        case "l":
+            return "left";
+        case "r":
+            return "right";
+        case "tr":
+            return "topRight";
+        default:
+            return undefined;
+    }
+};
+function extractLegendOptions(chart) {
+    var _a, _b, _c;
+    // OOXML omits <c:legend> when the chart hides the legend, but
+    // includes it (possibly empty) when the legend is shown. Some
+    // writers add a child <c:delete val="1"/> instead — handle that too.
+    var legend = getWithFallback(chart, ["c:legend", "legend"]);
+    if (legend === undefined) {
+        // Excel's default is "show". We only emit a `legend` field when the
+        // source explicitly suppressed it, otherwise renderers fall back.
+        return undefined;
+    }
+    var deleted = readBoolean((_a = get(legend, "c:delete.a$.val")) !== null && _a !== void 0 ? _a : get(legend, "delete.a$.val"));
+    if (deleted) {
+        return { position: "none" };
+    }
+    var posVal = (_b = get(legend, "c:legendPos.a$.val")) !== null && _b !== void 0 ? _b : get(legend, "legendPos.a$.val");
+    var position = mapLegendPosition(posVal);
+    var textFormat = extractTextProperties((_c = get(legend, "c:txPr")) !== null && _c !== void 0 ? _c : get(legend, "txPr"));
+    if (!position && !textFormat)
+        return undefined;
+    return __assign(__assign({}, (position ? { position: position } : {})), (textFormat ? { textFormat: textFormat } : {}));
+}
+var mapDataLabelPosition = function (val) {
+    switch (val) {
+        case "ctr":
+            return "center";
+        case "inEnd":
+            return "insideEnd";
+        case "inBase":
+            return "inside";
+        case "outEnd":
+            return "outsideEnd";
+        case "bestFit":
+            return "bestFit";
+        default:
+            return undefined;
+    }
+};
+function extractDataLabelsOptions(plotArea, chartType) {
+    var e_22, _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    // Look for <c:dLbls> inside the chartType-specific container. We pick
+    // the first one we find — chart-level labels apply to all series.
+    var containerKeys = {
+        bar: ["c:barChart", "barChart"],
+        column: ["c:barChart", "barChart"],
+        line: ["c:lineChart", "lineChart"],
+        pie: ["c:pieChart", "pieChart", "c:ofPieChart", "ofPieChart"],
+        doughnut: ["c:doughnutChart", "doughnutChart"],
+        area: ["c:areaChart", "areaChart"],
+    };
+    var keys = (_b = containerKeys[chartType]) !== null && _b !== void 0 ? _b : [];
+    var container;
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            container = container !== null && container !== void 0 ? container : get(plotArea, key);
+        }
+    }
+    catch (e_22_1) { e_22 = { error: e_22_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_22) throw e_22.error; }
+    }
+    var dLbls = (_e = (_d = (_c = get(container, "c:dLbls")) !== null && _c !== void 0 ? _c : get(container, "dLbls")) !== null && _d !== void 0 ? _d : get(plotArea, "c:dLbls")) !== null && _e !== void 0 ? _e : get(plotArea, "dLbls");
+    if (!dLbls)
+        return undefined;
+    var result = {};
+    var pos = (_f = get(dLbls, "c:dLblPos.a$.val")) !== null && _f !== void 0 ? _f : get(dLbls, "dLblPos.a$.val");
+    var position = mapDataLabelPosition(pos);
+    if (position)
+        result.position = position;
+    var showVal = readBoolean((_g = get(dLbls, "c:showVal.a$.val")) !== null && _g !== void 0 ? _g : get(dLbls, "showVal.a$.val"));
+    if (showVal) {
+        result.show = true;
+        result.showValue = true;
+    }
+    var showCat = readBoolean((_h = get(dLbls, "c:showCatName.a$.val")) !== null && _h !== void 0 ? _h : get(dLbls, "showCatName.a$.val"));
+    if (showCat) {
+        result.show = true;
+        result.showCategoryName = true;
+    }
+    var showPct = readBoolean((_j = get(dLbls, "c:showPercent.a$.val")) !== null && _j !== void 0 ? _j : get(dLbls, "showPercent.a$.val"));
+    if (showPct) {
+        result.show = true;
+        result.showPercent = true;
+    }
+    var showSer = readBoolean((_k = get(dLbls, "c:showSerName.a$.val")) !== null && _k !== void 0 ? _k : get(dLbls, "showSerName.a$.val"));
+    if (showSer) {
+        result.show = true;
+        result.showSeriesName = true;
+    }
+    // If only `position` was set with no `show*` flags, treat as "show".
+    if (position && result.show === undefined)
+        result.show = true;
+    // <c:txPr> on the dLbls block — affects every label in the chart.
+    var textFormat = extractTextProperties((_l = get(dLbls, "c:txPr")) !== null && _l !== void 0 ? _l : get(dLbls, "txPr"));
+    if (textFormat)
+        result.textFormat = textFormat;
+    // <c:numFmt formatCode="…"/> — Excel uses this to render labels as
+    // currency / percent / etc. (`"$"#,##0`, `0.00%`). Without parsing
+    // this, the renderer falls back to raw numbers (e.g. `1831` instead
+    // of `$1,831`).
+    var numFmt = (_p = (_o = (_m = get(dLbls, "c:numFmt.a$.formatCode")) !== null && _m !== void 0 ? _m : get(dLbls, "numFmt.a$.formatCode")) !== null && _o !== void 0 ? _o : get(dLbls, "c:numFmt.a$.t$")) !== null && _p !== void 0 ? _p : get(dLbls, "numFmt.a$.t$");
+    if (typeof numFmt === "string" && numFmt) {
+        result.numberFormatPattern = numFmt;
+    }
+    return Object.keys(result).length ? result : undefined;
+}
+function readAxis(axis) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!axis)
+        return undefined;
+    var result = {};
+    // <c:scaling><c:logBase val="…"/> + <c:orientation val="minMax|maxMin"/>
+    var logBase = readNumber((_a = get(axis, "c:scaling.c:logBase.a$.val")) !== null && _a !== void 0 ? _a : get(axis, "scaling.logBase.a$.val"));
+    if (typeof logBase === "number" && logBase > 0)
+        result.logarithmic = true;
+    var orientation = (_b = get(axis, "c:scaling.c:orientation.a$.val")) !== null && _b !== void 0 ? _b : get(axis, "scaling.orientation.a$.val");
+    if (orientation === "maxMin")
+        result.reverse = true;
+    var min = readNumber((_c = get(axis, "c:scaling.c:min.a$.val")) !== null && _c !== void 0 ? _c : get(axis, "scaling.min.a$.val"));
+    if (typeof min === "number")
+        result.min = min;
+    var max = readNumber((_d = get(axis, "c:scaling.c:max.a$.val")) !== null && _d !== void 0 ? _d : get(axis, "scaling.max.a$.val"));
+    if (typeof max === "number")
+        result.max = max;
+    // <c:delete val="1"/> hides the axis entirely.
+    var deleted = readBoolean((_e = get(axis, "c:delete.a$.val")) !== null && _e !== void 0 ? _e : get(axis, "delete.a$.val"));
+    if (deleted)
+        result.visible = false;
+    // <c:majorGridlines/> presence == show. Empty element is sufficient.
+    var majorGridlines = (_f = get(axis, "c:majorGridlines")) !== null && _f !== void 0 ? _f : get(axis, "majorGridlines");
+    if (majorGridlines !== undefined)
+        result.showMajorGridlines = true;
+    // <c:txPr> — axis tick-label font/color. Without this we'd inherit
+    // the renderer's theme default (near-black) and lose the authored
+    // color (e.g. BEP.xlsx X axis = #14325A, Y axis = #F0621C).
+    var textFormat = extractTextProperties((_g = get(axis, "c:txPr")) !== null && _g !== void 0 ? _g : get(axis, "txPr"));
+    if (textFormat)
+        result.textFormat = textFormat;
+    return Object.keys(result).length ? result : undefined;
+}
+export function extractAxisOptions(plotArea) {
+    var _a, _b, _c, _d;
+    var valAx = (_a = get(plotArea, "c:valAx")) !== null && _a !== void 0 ? _a : get(plotArea, "valAx");
+    var catAx = (_b = get(plotArea, "c:catAx")) !== null && _b !== void 0 ? _b : get(plotArea, "catAx");
+    // Some chart types use <c:dateAx>; treat as category for our purposes.
+    var dateAx = (_c = get(plotArea, "c:dateAx")) !== null && _c !== void 0 ? _c : get(plotArea, "dateAx");
+    var valAxes = Array.isArray(valAx) ? valAx : valAx ? [valAx] : [];
+    return {
+        valueAxisOptions: readAxis(valAxes[0]),
+        secondaryValueAxisOptions: valAxes.length > 1 ? readAxis(valAxes[1]) : undefined,
+        categoryAxisOptions: readAxis((_d = (Array.isArray(catAx) ? catAx[0] : catAx)) !== null && _d !== void 0 ? _d : (Array.isArray(dateAx) ? dateAx[0] : dateAx)),
+    };
+}
+/**
+ * Pie-of-pie / bar-of-pie — extract the of-pie layout fields from
+ * `<c:ofPieChart>`. Returns undefined for plain pies. `splitType`
+ * maps the OOXML tokens (`pos`/`val`/`percent`) to the spec vocabulary;
+ * `auto` and `cust` (custom point assignment, carried in `<c:custSplit>`
+ * which the spec cannot represent) are omitted so the renderer applies
+ * Excel's default rule (position, last 3 values).
+ */
+export function extractOfPieOptions(plotArea) {
+    var _a, _b, _c, _d;
+    var ofPie = getWithFallback(plotArea, ["c:ofPieChart", "ofPieChart"]);
+    if (!ofPie)
+        return undefined;
+    var typeRaw = (_a = get(ofPie, "c:ofPieType.a$.val")) !== null && _a !== void 0 ? _a : get(ofPie, "ofPieType.a$.val");
+    var ofPieType = typeRaw === "bar" ? "bar" : "pie";
+    var splitRaw = (_b = get(ofPie, "c:splitType.a$.val")) !== null && _b !== void 0 ? _b : get(ofPie, "splitType.a$.val");
+    var splitType = splitRaw === "pos"
+        ? "position"
+        : splitRaw === "val"
+            ? "value"
+            : splitRaw === "percent"
+                ? "percent"
+                : undefined;
+    var splitPos = readNumber((_c = get(ofPie, "c:splitPos.a$.val")) !== null && _c !== void 0 ? _c : get(ofPie, "splitPos.a$.val"));
+    var secondPieSize = readNumber((_d = get(ofPie, "c:secondPieSize.a$.val")) !== null && _d !== void 0 ? _d : get(ofPie, "secondPieSize.a$.val"));
+    return __assign(__assign(__assign({ ofPieType: ofPieType }, (splitType ? { splitType: splitType } : {})), (typeof splitPos === "number" ? { splitPos: splitPos } : {})), (typeof secondPieSize === "number" ? { secondPieSize: secondPieSize } : {}));
+}
+function extractDoughnutHoleSize(plotArea) {
+    var _a;
+    // <c:doughnutChart><c:holeSize val="50"/> — value is the inner radius
+    // as a percentage of the chart radius (0-90). We normalize to a 0-1
+    // fraction so renderers can use it without knowing the spec.
+    var holeSize = readNumber((_a = get(plotArea, "c:doughnutChart.c:holeSize.a$.val")) !== null && _a !== void 0 ? _a : get(plotArea, "doughnutChart.holeSize.a$.val"));
+    if (typeof holeSize !== "number")
+        return undefined;
+    return Math.min(0.9, Math.max(0, holeSize / 100));
+}
+// -------------------------- Phase 5.2 helpers --------------------------
+var mapTrendlineType = function (val) {
+    switch (val) {
+        case "exp":
+            return "exp";
+        case "log":
+            return "log";
+        case "poly":
+            return "poly";
+        case "power":
+            return "power";
+        case "movingAvg":
+            return "movingAvg";
+        case "linear":
+        default:
+            return "linear";
+    }
+};
+function extractTrendlines(ser) {
+    var e_23, _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    // <c:trendline> can appear multiple times under a single series; the
+    // parser may surface either an array or a single object.
+    var raw = (_b = get(ser, "c:trendline")) !== null && _b !== void 0 ? _b : get(ser, "trendline");
+    if (!raw)
+        return undefined;
+    var list = Array.isArray(raw) ? raw : [raw];
+    var results = [];
+    try {
+        for (var list_2 = __values(list), list_2_1 = list_2.next(); !list_2_1.done; list_2_1 = list_2.next()) {
+            var t = list_2_1.value;
+            var type = mapTrendlineType((_c = get(t, "c:trendlineType.a$.val")) !== null && _c !== void 0 ? _c : get(t, "trendlineType.a$.val"));
+            var order = readNumber((_d = get(t, "c:order.a$.val")) !== null && _d !== void 0 ? _d : get(t, "order.a$.val"));
+            var period = readNumber((_e = get(t, "c:period.a$.val")) !== null && _e !== void 0 ? _e : get(t, "period.a$.val"));
+            var name_1 = (_h = (_g = (_f = get(t, "c:name.t$")) !== null && _f !== void 0 ? _f : get(t, "name.t$")) !== null && _g !== void 0 ? _g : get(t, "c:name")) !== null && _h !== void 0 ? _h : get(t, "name");
+            var showEquation = readBoolean((_j = get(t, "c:dispEq.a$.val")) !== null && _j !== void 0 ? _j : get(t, "dispEq.a$.val"));
+            var showRSquared = readBoolean((_k = get(t, "c:dispRSqr.a$.val")) !== null && _k !== void 0 ? _k : get(t, "dispRSqr.a$.val"));
+            var forecastForward = readNumber((_l = get(t, "c:forward.a$.val")) !== null && _l !== void 0 ? _l : get(t, "forward.a$.val"));
+            var forecastBackward = readNumber((_m = get(t, "c:backward.a$.val")) !== null && _m !== void 0 ? _m : get(t, "backward.a$.val"));
+            var entry = { type: type };
+            if (typeof order === "number")
+                entry.order = order;
+            if (typeof period === "number")
+                entry.period = period;
+            if (typeof name_1 === "string" && name_1)
+                entry.name = name_1;
+            if (showEquation)
+                entry.showEquation = true;
+            if (showRSquared)
+                entry.showRSquared = true;
+            if (typeof forecastForward === "number")
+                entry.forecastForward = forecastForward;
+            if (typeof forecastBackward === "number")
+                entry.forecastBackward = forecastBackward;
+            results.push(entry);
+        }
+    }
+    catch (e_23_1) { e_23 = { error: e_23_1 }; }
+    finally {
+        try {
+            if (list_2_1 && !list_2_1.done && (_a = list_2.return)) _a.call(list_2);
+        }
+        finally { if (e_23) throw e_23.error; }
+    }
+    return results;
+}
+function extractErrorBars(ser, hostSheetId, resolveSheetId) {
+    var _a, _b, _c, _d, _e, _f;
+    var raw = (_a = get(ser, "c:errBars")) !== null && _a !== void 0 ? _a : get(ser, "errBars");
+    if (!raw)
+        return undefined;
+    var direction = (_b = get(raw, "c:errDir.a$.val")) !== null && _b !== void 0 ? _b : get(raw, "errDir.a$.val");
+    var barType = (_c = get(raw, "c:errBarType.a$.val")) !== null && _c !== void 0 ? _c : get(raw, "errBarType.a$.val");
+    var valTypeVal = (_d = get(raw, "c:errValType.a$.val")) !== null && _d !== void 0 ? _d : get(raw, "errValType.a$.val");
+    var value = readNumber((_e = get(raw, "c:val.a$.val")) !== null && _e !== void 0 ? _e : get(raw, "val.a$.val"));
+    var noEndCap = readBoolean((_f = get(raw, "c:noEndCap.a$.val")) !== null && _f !== void 0 ? _f : get(raw, "noEndCap.a$.val"));
+    var result = {};
+    if (direction === "x" || direction === "y")
+        result.direction = direction;
+    if (barType === "both" || barType === "plus" || barType === "minus") {
+        result.barType = barType;
+    }
+    if (valTypeVal === "fixedVal" ||
+        valTypeVal === "percentage" ||
+        valTypeVal === "stdDev" ||
+        valTypeVal === "stdErr" ||
+        valTypeVal === "cust") {
+        result.valueType = valTypeVal === "cust" ? "custom" : valTypeVal;
+    }
+    if (typeof value === "number")
+        result.value = value;
+    if (noEndCap)
+        result.noEndCap = true;
+    // Custom error bars carry per-point magnitudes in worksheet ranges —
+    // `<c:plus>/<c:minus>` each hold a `<c:numRef><c:f>` reference.
+    if (result.valueType === "custom") {
+        var plusRef = getWithFallback(raw, [
+            "c:plus.c:numRef.c:f",
+            "c:plus.c:numRef.c:f.t$",
+            "plus.numRef.f",
+            "plus.numRef.f.t$",
+        ]);
+        var minusRef = getWithFallback(raw, [
+            "c:minus.c:numRef.c:f",
+            "c:minus.c:numRef.c:f.t$",
+            "minus.numRef.f",
+            "minus.numRef.f.t$",
+        ]);
+        if (plusRef) {
+            var plusSources = resolveSourcesFromRef(plusRef, hostSheetId, resolveSheetId);
+            if (plusSources.length)
+                result.plusRange = plusSources[0];
+        }
+        if (minusRef) {
+            var minusSources = resolveSourcesFromRef(minusRef, hostSheetId, resolveSheetId);
+            if (minusSources.length)
+                result.minusRange = minusSources[0];
+        }
+    }
+    return Object.keys(result).length ? result : undefined;
+}
+function extractRadarStyle(plotArea) {
+    var _a;
+    var val = (_a = get(plotArea, "c:radarChart.c:radarStyle.a$.val")) !== null && _a !== void 0 ? _a : get(plotArea, "radarChart.radarStyle.a$.val");
+    if (val === "standard" || val === "marker" || val === "filled")
+        return val;
+    return undefined;
+}