@rowsncolumns/toolkit 24.4.1

package/dist/cjs/exporter/xlsx/chart-builder.js

@@ -0,0 +1,1901 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { cellRangeToAddress, sanitizeSheetName } from "@rowsncolumns/utils";
+import { XMLBuilder } from "fast-xml-parser";
+import { area_series, bubble_series, chart_template, column_json, column_series, donut_json, line_series, scatter_json, scatter_series, static_title, } from "./chart-templates";
+var XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+var INVALID_XML_CHAR_REGEX = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+var chartBuilder = new XMLBuilder({
+    ignoreAttributes: false,
+    attributesGroupName: "a$",
+    textNodeName: "t$",
+    suppressEmptyNode: true,
+});
+var sanitizeXmlText = function (value) {
+    return value ? value.replace(INVALID_XML_CHAR_REGEX, "") : value;
+};
+var cloneTemplate = function (template) {
+    return JSON.parse(JSON.stringify(template));
+};
+var removeProp = function (obj, key) {
+    delete obj[key];
+};
+var normalizeFormula = function (formula) {
+    var trimmed = formula.startsWith("=") ? formula.slice(1) : formula;
+    return sanitizeXmlText(trimmed).replace(/\r\n|\r|\n/g, " ");
+};
+var hasPropertyReference = function (formula) {
+    if (!formula)
+        return false;
+    // Detects cell references with property access: A1.property, $A$1.nested.value, etc.
+    var propertyReferencePattern = /[$]?[A-Za-z]{1,3}[$]?[1-9][0-9]*\./;
+    return propertyReferencePattern.test(formula);
+};
+var formatRangeRef = function (range, sheetNameById) {
+    if (!range)
+        return undefined;
+    var sheetName = sheetNameById.get(range.sheetId);
+    return cellRangeToAddress(sheetName, range);
+};
+/**
+ * A1 reference over EVERY range of a (possibly multi-area) source list,
+ * joined with the union operator — `'Sheet'!$E$19,'Sheet'!$E$26,…`. The old
+ * first-range-only behavior silently truncated discontiguous series.
+ */
+var formatSourcesRef = function (sources, sheetNameById) {
+    if (!(sources === null || sources === void 0 ? void 0 : sources.length))
+        return undefined;
+    var parts = sources
+        .map(function (range) { return formatRangeRef(range, sheetNameById); })
+        .filter(function (ref) { return Boolean(ref); });
+    return parts.length ? parts.join(",") : undefined;
+};
+var seriesCategoryRef = function (entry, sheetNameById) {
+    return formatSourcesRef(entry === null || entry === void 0 ? void 0 : entry.categorySources, sheetNameById);
+};
+var buildSeriesLabel = function (label, sheetName, labelRef) {
+    // A captured source reference (`<c:tx><c:strRef>`) wins over the literal:
+    // emitting the ref without a cache lets Excel resolve the live series name
+    // on open, instead of freezing a possibly-generic literal.
+    if (labelRef) {
+        return {
+            "c:tx": {
+                "c:strRef": {
+                    "c:f": labelRef,
+                },
+            },
+        };
+    }
+    if (label === undefined || label === null || label === "")
+        return undefined;
+    // Numeric series headers (e.g. a year like 2024) can reach us as numbers
+    var text = typeof label === "string" ? label : String(label);
+    if (text.startsWith("=")) {
+        // If label contains property references (e.g., =A1.propertyName),
+        // treat it as static text instead of formula reference
+        if (hasPropertyReference(text)) {
+            return {
+                "c:tx": {
+                    "c:v": sanitizeXmlText(text),
+                },
+            };
+        }
+        var formula = normalizeFormula(text);
+        var resolved = sheetName && !formula.includes("!")
+            ? "".concat(sanitizeSheetName(sheetName), "!").concat(formula)
+            : formula;
+        return {
+            "c:tx": {
+                "c:strRef": {
+                    "c:f": resolved,
+                },
+            },
+        };
+    }
+    return {
+        "c:tx": {
+            "c:v": sanitizeXmlText(text),
+        },
+    };
+};
+var buildColorNode = function (color) {
+    var normalized = color.startsWith("#") ? color.slice(1) : color;
+    var hex = normalized.length === 6
+        ? normalized
+        : normalized.slice(normalized.length - 6);
+    return {
+        "a:solidFill": {
+            "a:srgbClr": {
+                a$: {
+                    val: hex,
+                },
+            },
+        },
+    };
+};
+var normalizeHex = function (color) {
+    var stripped = color.startsWith("#") ? color.slice(1) : color;
+    return stripped.length === 6
+        ? stripped
+        : stripped.slice(stripped.length - 6);
+};
+/**
+ * Build an OOXML `<a:gradFill>` node from a series-level gradient
+ * descriptor. Matches the DrawingML schema:
+ *
+ *   <a:gradFill flip="none" rotWithShape="1">
+ *     <a:gsLst>
+ *       <a:gs pos="0"><a:srgbClr val="FF0000"/></a:gs>
+ *       <a:gs pos="100000"><a:srgbClr val="0000FF"/></a:gs>
+ *     </a:gsLst>
+ *     <a:lin ang="5400000" scaled="0"/>  <!-- or <a:path path="rect">…</a:path> -->
+ *   </a:gradFill>
+ *
+ * Positions are EMU per-mille (0..100000). Linear angle is in 60000ths
+ * of a degree (90° == 5400000) — Excel's chart angle convention runs
+ * clockwise from 12 o'clock, so the conversion is `deg * 60000`.
+ *
+ * Path gradients use `<a:path path="rect">` with a `<a:fillToRect>`
+ * child carrying the inset of the inner stop in EMU per-mille.
+ */
+var buildGradFillNode = function (gradient) {
+    var _a, _b;
+    if (!((_a = gradient === null || gradient === void 0 ? void 0 : gradient.stops) === null || _a === void 0 ? void 0 : _a.length))
+        return null;
+    var gsList = gradient.stops.map(function (stop) { return ({
+        a$: { pos: String(Math.round(Math.max(0, Math.min(1, stop.position)) * 100000)) },
+        "a:srgbClr": { a$: { val: normalizeHex(stop.color) } },
+    }); });
+    var direction = {};
+    if (gradient.type === "path") {
+        var toEmu = function (v) {
+            return v != null ? String(Math.round(v * 100000)) : "0";
+        };
+        direction["a:path"] = {
+            a$: { path: "rect" },
+            "a:fillToRect": {
+                a$: {
+                    l: toEmu(gradient.left),
+                    r: toEmu(gradient.right),
+                    t: toEmu(gradient.top),
+                    b: toEmu(gradient.bottom),
+                },
+            },
+        };
+    }
+    else {
+        var deg = (((_b = gradient.degree) !== null && _b !== void 0 ? _b : 0) % 360 + 360) % 360;
+        direction["a:lin"] = {
+            a$: {
+                ang: String(Math.round(deg * 60000)),
+                scaled: "0",
+            },
+        };
+    }
+    return __assign({ a$: { flip: "none", rotWithShape: "1" }, "a:gsLst": { "a:gs": gsList } }, direction);
+};
+/**
+ * Replace the series' shape-properties fill with a gradient when one
+ * is supplied. Strips any pre-existing solid/scheme fill so the
+ * gradient doesn't double up.
+ */
+var applySeriesGradient = function (seriesNode, gradient) {
+    if (!gradient)
+        return false;
+    var gradFill = buildGradFillNode(gradient);
+    if (!gradFill)
+        return false;
+    var spPr = seriesNode["c:spPr"];
+    if (!spPr)
+        return false;
+    delete spPr["a:solidFill"];
+    spPr["a:gradFill"] = gradFill;
+    return true;
+};
+/**
+ * Build the extension list for a series with invertIfNegative support.
+ * This adds the c14:invertSolidFillFmt extension for negative fill color.
+ */
+var buildSeriesExtLst = function (negativeColor, uniqueId) {
+    var extensions = [];
+    // Add unique ID extension (required by Excel)
+    extensions.push({
+        a$: {
+            uri: "{C3380CC4-5D6E-409C-BE32-E72D297353CC}",
+            "xmlns:c16": "http://schemas.microsoft.com/office/drawing/2014/chart",
+        },
+        "c16:uniqueId": {
+            a$: {
+                val: uniqueId,
+            },
+        },
+    });
+    // Add negative fill color extension if specified
+    if (negativeColor) {
+        var normalizedColor = negativeColor.startsWith("#")
+            ? negativeColor.slice(1)
+            : negativeColor;
+        var hex = normalizedColor.length === 6
+            ? normalizedColor
+            : normalizedColor.slice(normalizedColor.length - 6);
+        extensions.push({
+            a$: {
+                uri: "{6F2FDCE9-48DA-4B69-8628-5D25D57E5C99}",
+                "xmlns:c14": "http://schemas.microsoft.com/office/drawing/2007/8/2/chart",
+            },
+            "c14:invertSolidFillFmt": {
+                "c14:spPr": {
+                    "a:solidFill": {
+                        "a:srgbClr": {
+                            a$: {
+                                val: hex,
+                            },
+                        },
+                    },
+                    "a:ln": {
+                        "a:noFill": {},
+                    },
+                    "a:effectLst": {},
+                },
+            },
+        });
+    }
+    return {
+        "c:ext": extensions.length === 1 ? extensions[0] : extensions,
+    };
+};
+// ─── Round-trip helpers (textFormat, marker, dPt, inline values) ─────
+/**
+ * Build a `<c:txPr>` XML node from a ChartTextFormat. Returns
+ * `undefined` when the format has no settable properties so callers
+ * can skip emission. Used by axis, legend, title, and data-label
+ * blocks to preserve authored color/font on round-trip.
+ */
+var buildTxPrNode = function (textFormat) {
+    if (!textFormat)
+        return undefined;
+    var defRPr = { a$: {} };
+    if (typeof textFormat.fontSize === "number") {
+        // ChartTextFormat stores points; OOXML stores 100ths of a point.
+        defRPr.a$.sz = String(Math.round(textFormat.fontSize * 100));
+    }
+    if (textFormat.bold)
+        defRPr.a$.b = "1";
+    if (textFormat.italic)
+        defRPr.a$.i = "1";
+    if (textFormat.underline)
+        defRPr.a$.u = "sng";
+    if (textFormat.strikethrough)
+        defRPr.a$.strike = "sngStrike";
+    if (textFormat.color) {
+        var hex = String(textFormat.color).replace(/^#/, "").toUpperCase();
+        defRPr["a:solidFill"] = {
+            "a:srgbClr": { a$: { val: hex } },
+        };
+    }
+    if (textFormat.fontFamily) {
+        defRPr["a:latin"] = { a$: { typeface: textFormat.fontFamily } };
+    }
+    // Only emit when we wrote something useful — otherwise Excel rejects
+    // an empty defRPr.
+    var hasAttrs = Object.keys(defRPr.a$).length > 0;
+    var hasChildren = Object.keys(defRPr).some(function (k) { return k !== "a$"; });
+    if (!hasAttrs && !hasChildren)
+        return undefined;
+    return {
+        "a:bodyPr": {
+            a$: {
+                rot: "0",
+                spcFirstLastPara: "1",
+                vertOverflow: "ellipsis",
+                wrap: "square",
+                anchor: "ctr",
+                anchorCtr: "1",
+            },
+        },
+        "a:lstStyle": {},
+        "a:p": {
+            "a:pPr": { "a:defRPr": defRPr },
+            "a:endParaRPr": { a$: { lang: "en-US" } },
+        },
+    };
+};
+/**
+ * Build a `<c:strLit>` inline category block from an array of values.
+ * Used when a chart's category axis is embedded literally in the chart
+ * XML (e.g. Event Budget's `["Estimated", "Actual"]`) instead of
+ * referencing the sheet.
+ */
+var buildInlineStrLit = function (values) { return ({
+    "c:strLit": {
+        "c:ptCount": { a$: { val: String(values.length) } },
+        "c:pt": values.map(function (v, i) { return ({
+            a$: { idx: String(i) },
+            "c:v": sanitizeXmlText(String(v)),
+        }); }),
+    },
+}); };
+/**
+ * Build a `<c:numLit>` inline numeric block from values. Used for
+ * inline-value series (rare but legal in OOXML).
+ */
+var buildInlineNumLit = function (values) { return ({
+    "c:numLit": {
+        "c:formatCode": "General",
+        "c:ptCount": { a$: { val: String(values.length) } },
+        "c:pt": values.map(function (v, i) { return ({
+            a$: { idx: String(i) },
+            "c:v": typeof v === "number" ? String(v) : Number(v).toString(),
+        }); }),
+    },
+}); };
+/**
+ * Build a `<c:marker>` node from a ChartData.marker spec. Returns
+ * `undefined` when the marker carries no information.
+ */
+var buildMarkerNode = function (marker) {
+    if (!marker)
+        return undefined;
+    var node = {};
+    if (marker.symbol) {
+        node["c:symbol"] = { a$: { val: marker.symbol } };
+    }
+    if (typeof marker.size === "number") {
+        node["c:size"] = { a$: { val: String(Math.round(marker.size)) } };
+    }
+    if (marker.color) {
+        node["c:spPr"] = {
+            "a:solidFill": buildColorNode(marker.color)["a:solidFill"],
+        };
+    }
+    return Object.keys(node).length ? node : undefined;
+};
+/**
+ * Build a `<c:dPt>` array from per-point color overrides. Each entry
+ * pins a category index to a different fill — Gantt-style charts use
+ * this to colour each task individually.
+ */
+var buildDataPointNodes = function (dataPointColors) {
+    if (!dataPointColors || !dataPointColors.length)
+        return undefined;
+    return dataPointColors.map(function (dp) { return ({
+        "c:idx": { a$: { val: String(dp.idx) } },
+        "c:invertIfNegative": { a$: { val: "0" } },
+        "c:bubble3D": { a$: { val: "0" } },
+        "c:spPr": {
+            "a:solidFill": buildColorNode(dp.color)["a:solidFill"],
+            "a:ln": { "a:noFill": {} },
+        },
+    }); });
+};
+/**
+ * Apply transparent fill to a series spPr node. Mirrors the
+ * `<a:noFill/>` form Excel uses for invisible "offset" bars (Gantt
+ * lag series). Replaces any existing solidFill/gradFill.
+ */
+var applyNoFillToSeriesSpPr = function (seriesNode) {
+    var _a;
+    var spPr = (seriesNode["c:spPr"] = (_a = seriesNode["c:spPr"]) !== null && _a !== void 0 ? _a : {});
+    removeProp(spPr, "a:solidFill");
+    removeProp(spPr, "a:gradFill");
+    spPr["a:noFill"] = {};
+};
+/**
+ * Build the subtitle `<a:p>` paragraph node (fast-xml-parser object form)
+ * appended below the chart title inside the same `<c:rich>` block.
+ *
+ * Mirrors the legacy JS post-patcher (`chart-subtitle-patcher.ts`): the
+ * subtitle renders at ~70% of the title font size (9pt floor) in a muted
+ * `tx1` scheme colour. `titleSize` is in OOXML hundredths-of-a-point.
+ */
+var buildSubtitleParagraphNode = function (subtitle, titleSize) {
+    var subtitleSize = Math.max(900, Math.round(titleSize * 0.7));
+    return {
+        "a:pPr": {
+            "a:defRPr": {
+                a$: {
+                    sz: String(subtitleSize),
+                    b: "0",
+                    i: "0",
+                    u: "none",
+                    strike: "noStrike",
+                    kern: "1200",
+                    spc: "0",
+                    baseline: "0",
+                },
+                "a:solidFill": {
+                    "a:schemeClr": {
+                        a$: { val: "tx1" },
+                        "a:lumMod": { a$: { val: "65000" } },
+                        "a:lumOff": { a$: { val: "35000" } },
+                    },
+                },
+                "a:latin": { a$: { typeface: "+mn-lt" } },
+                "a:ea": { a$: { typeface: "+mn-ea" } },
+                "a:cs": { a$: { typeface: "+mn-cs" } },
+            },
+        },
+        "a:r": {
+            "a:rPr": { a$: { lang: "en-US", sz: String(subtitleSize), b: "0", i: "0" } },
+            "a:t": sanitizeXmlText(subtitle),
+        },
+    };
+};
+var applyChartTitle = function (chartNode, title, titleTextFormat, subtitle) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!title)
+        return;
+    var titleBlock = cloneTemplate(static_title);
+    titleBlock["c:tx"]["c:rich"]["a:p"]["a:r"]["a:rPr"].a$.lang = "en-US";
+    titleBlock["c:tx"]["c:rich"]["a:p"]["a:r"]["a:t"] = sanitizeXmlText(title);
+    // Apply authored text format on the rich run's `a:rPr` so Excel
+    // preserves color/font on round-trip. We mutate the rPr directly
+    // (it's already inside the template's a:p > a:r).
+    if (titleTextFormat) {
+        var rPr = titleBlock["c:tx"]["c:rich"]["a:p"]["a:r"]["a:rPr"];
+        if (typeof titleTextFormat.fontSize === "number") {
+            rPr.a$.sz = String(Math.round(titleTextFormat.fontSize * 100));
+        }
+        if (titleTextFormat.bold)
+            rPr.a$.b = "1";
+        if (titleTextFormat.italic)
+            rPr.a$.i = "1";
+        if (titleTextFormat.color) {
+            var hex = String(titleTextFormat.color).replace(/^#/, "").toUpperCase();
+            rPr["a:solidFill"] = { "a:srgbClr": { a$: { val: hex } } };
+        }
+        if (titleTextFormat.fontFamily) {
+            rPr["a:latin"] = { a$: { typeface: titleTextFormat.fontFamily } };
+        }
+    }
+    // Append the subtitle as a SECOND `<a:p>` inside the title's `<c:rich>`,
+    // matching what the legacy JS post-patcher spliced in. Emitted natively
+    // here so no post-processing pass is needed. Scale relative to the
+    // authored title size (defaults to the template's 14pt → sz="1400").
+    if (subtitle && subtitle.trim().length > 0) {
+        var rich = titleBlock["c:tx"]["c:rich"];
+        var titlePara = rich["a:p"];
+        var titleSizeStr = ((_d = (_c = (_b = (_a = titlePara === null || titlePara === void 0 ? void 0 : titlePara["a:pPr"]) === null || _a === void 0 ? void 0 : _a["a:defRPr"]) === null || _b === void 0 ? void 0 : _b.a$) === null || _c === void 0 ? void 0 : _c.sz) !== null && _d !== void 0 ? _d : (_g = (_f = (_e = titlePara === null || titlePara === void 0 ? void 0 : titlePara["a:r"]) === null || _e === void 0 ? void 0 : _e["a:rPr"]) === null || _f === void 0 ? void 0 : _f.a$) === null || _g === void 0 ? void 0 : _g.sz);
+        var titleSize = titleSizeStr && Number.isFinite(parseInt(titleSizeStr, 10))
+            ? parseInt(titleSizeStr, 10)
+            : 1400;
+        rich["a:p"] = [titlePara, buildSubtitleParagraphNode(subtitle, titleSize)];
+    }
+    chartNode["c:title"] = titleBlock;
+};
+var getPrimarySource = function (entry) { var _a; return (_a = entry === null || entry === void 0 ? void 0 : entry.sources) === null || _a === void 0 ? void 0 : _a[0]; };
+/**
+ * c15 extension namespace (Excel 2012+) — histogram / boxplot /
+ * waterfall / funnel charts are emitted with a `c:barChart` body
+ * inside `mc:Fallback` (so older Excel still renders something) plus a
+ * full c15 chart element inside `mc:Choice` (so Excel 2016+ renders
+ * the chart natively). See `buildC15AlternateContent` and the per-type
+ * builders below.
+ */
+var C15_NS = "http://schemas.microsoft.com/office/drawing/2012/chart";
+var C15_ELEMENT_NAMES = {
+    histogram: "c15:histogramChart",
+    boxplot: "c15:boxWhiskerChart",
+    waterfall: "c15:waterfallChart",
+    funnel: "c15:funnelChart",
+};
+var isC15ChartType = function (t) {
+    return t === "histogram" || t === "boxplot" || t === "waterfall" || t === "funnel";
+};
+var MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+/**
+ * Phase 5.5b — build the full c15:histogramChart body that Excel 2016+
+ * uses to render histograms natively. Lives inside `mc:Choice` next to
+ * the older `c:barChart` fallback (in `mc:Fallback`). Both share the
+ * `c:catAx`/`c:valAx` declared at `c:plotArea` level — c15 axId values
+ * are picked to match the bar chart's axId so Excel can resolve them.
+ */
+var buildC15HistogramChartNode = function (spec, seriesRefs, series, domainRef, axIds) {
+    var c15SeriesEntries = [];
+    seriesRefs.forEach(function (ref, index) {
+        var _a;
+        if (!ref)
+            return;
+        var seriesNode = {
+            "c15:idx": { a$: { val: String(index) } },
+            "c15:order": { a$: { val: String(index) } },
+        };
+        // Series title — only if the consumer set a non-formula dataLabel.
+        var dataLabel = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.dataLabel;
+        if (dataLabel && !dataLabel.startsWith("=")) {
+            seriesNode["c15:tx"] = {
+                "c15:v": dataLabel,
+            };
+        }
+        seriesNode["c15:val"] = {
+            "c15:numRef": {
+                "c15:f": ref,
+            },
+        };
+        c15SeriesEntries.push(seriesNode);
+    });
+    var histogramChart = {
+        "c15:varyColors": { a$: { val: "0" } },
+        "c15:ser": c15SeriesEntries.length === 1 ? c15SeriesEntries[0] : c15SeriesEntries,
+        "c15:axId": [
+            { a$: { val: axIds.catAxId } },
+            { a$: { val: axIds.valAxId } },
+        ],
+    };
+    // Bin configuration: explicit binCount when set, otherwise let Excel
+    // auto-bin (Sturges-like).
+    if (typeof (spec === null || spec === void 0 ? void 0 : spec.binCount) === "number" && spec.binCount > 0) {
+        histogramChart["c15:binCount"] = { a$: { val: String(spec.binCount) } };
+    }
+    else {
+        histogramChart["c15:binsAuto"] = { a$: { val: "1" } };
+    }
+    return histogramChart;
+};
+/**
+ * Phase 5.5b — c15:boxWhiskerChart body. Excel 2016+ renders box & whisker
+ * natively from this. Each series carries its raw values; Excel computes
+ * the quartiles + median + outliers from `c15:quartileMethod`.
+ */
+var buildC15BoxplotChartNode = function (_spec, seriesRefs, series, domainRef, axIds) {
+    var c15SeriesEntries = [];
+    seriesRefs.forEach(function (ref, index) {
+        var _a;
+        if (!ref)
+            return;
+        var seriesNode = {
+            "c15:idx": { a$: { val: String(index) } },
+            "c15:order": { a$: { val: String(index) } },
+            "c15:invertIfNegative": { a$: { val: "0" } },
+            "c15:bubble3D": { a$: { val: "0" } },
+        };
+        var dataLabel = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.dataLabel;
+        if (dataLabel && !dataLabel.startsWith("=")) {
+            seriesNode["c15:tx"] = { "c15:v": dataLabel };
+        }
+        if (domainRef) {
+            seriesNode["c15:cat"] = {
+                "c15:strRef": { "c15:f": domainRef },
+            };
+        }
+        seriesNode["c15:val"] = {
+            "c15:numRef": { "c15:f": ref },
+        };
+        c15SeriesEntries.push(seriesNode);
+    });
+    return {
+        "c15:varyColors": { a$: { val: "0" } },
+        "c15:ser": c15SeriesEntries.length === 1 ? c15SeriesEntries[0] : c15SeriesEntries,
+        "c15:showInnerPoints": { a$: { val: "0" } },
+        "c15:showOutlierPoints": { a$: { val: "1" } },
+        "c15:showMeanMarker": { a$: { val: "1" } },
+        "c15:showMeanLine": { a$: { val: "0" } },
+        "c15:quartileMethod": { a$: { val: "exclusive" } },
+        "c15:axId": [
+            { a$: { val: axIds.catAxId } },
+            { a$: { val: axIds.valAxId } },
+        ],
+    };
+};
+/**
+ * Phase 5.5b — c15:waterfallChart body. Each c15:ser carries one data
+ * point per category. Subtotals are marked at the series level via
+ * c15:dPt with c15:subTotal set; without these, Excel treats every
+ * point as a delta and the running cumulative is implicit.
+ */
+var buildC15WaterfallChartNode = function (_spec, seriesRefs, series, domainRef, axIds) {
+    var c15SeriesEntries = [];
+    seriesRefs.forEach(function (ref, index) {
+        var _a;
+        if (!ref)
+            return;
+        var seriesNode = {
+            "c15:idx": { a$: { val: String(index) } },
+            "c15:order": { a$: { val: String(index) } },
+        };
+        var dataLabel = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.dataLabel;
+        if (dataLabel && !dataLabel.startsWith("=")) {
+            seriesNode["c15:tx"] = { "c15:v": dataLabel };
+        }
+        if (domainRef) {
+            seriesNode["c15:cat"] = {
+                "c15:strRef": { "c15:f": domainRef },
+            };
+        }
+        seriesNode["c15:val"] = {
+            "c15:numRef": { "c15:f": ref },
+        };
+        c15SeriesEntries.push(seriesNode);
+    });
+    return {
+        "c15:varyColors": { a$: { val: "0" } },
+        "c15:ser": c15SeriesEntries.length === 1 ? c15SeriesEntries[0] : c15SeriesEntries,
+        "c15:axId": [
+            { a$: { val: axIds.catAxId } },
+            { a$: { val: axIds.valAxId } },
+        ],
+    };
+};
+/**
+ * Phase 5.5b — c15:funnelChart body. Categories label each funnel
+ * stage; values size the stages. No subtotals, no quartile config.
+ */
+var buildC15FunnelChartNode = function (_spec, seriesRefs, series, domainRef, axIds) {
+    var c15SeriesEntries = [];
+    seriesRefs.forEach(function (ref, index) {
+        var _a;
+        if (!ref)
+            return;
+        var seriesNode = {
+            "c15:idx": { a$: { val: String(index) } },
+            "c15:order": { a$: { val: String(index) } },
+        };
+        var dataLabel = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.dataLabel;
+        if (dataLabel && !dataLabel.startsWith("=")) {
+            seriesNode["c15:tx"] = { "c15:v": dataLabel };
+        }
+        if (domainRef) {
+            seriesNode["c15:cat"] = {
+                "c15:strRef": { "c15:f": domainRef },
+            };
+        }
+        seriesNode["c15:val"] = {
+            "c15:numRef": { "c15:f": ref },
+        };
+        c15SeriesEntries.push(seriesNode);
+    });
+    return {
+        "c15:varyColors": { a$: { val: "0" } },
+        "c15:ser": c15SeriesEntries.length === 1 ? c15SeriesEntries[0] : c15SeriesEntries,
+        "c15:axId": [
+            { a$: { val: axIds.catAxId } },
+            { a$: { val: axIds.valAxId } },
+        ],
+    };
+};
+/**
+ * Phase 5.5b — wrap a c15 chart body in `mc:AlternateContent` so Excel
+ * 2016+ uses the c15 chart and older Excel falls back to the bar chart.
+ * Returns the AlternateContent node ready to splice into c:plotArea.
+ */
+var buildC15AlternateContent = function (chartType, c15ChartBody, fallbackBarChart) {
+    var _a;
+    var choiceElementName = C15_ELEMENT_NAMES[chartType];
+    return {
+        a$: { "xmlns:mc": MC_NS },
+        "mc:Choice": (_a = {
+                a$: {
+                    Requires: "c15",
+                    "xmlns:c15": C15_NS,
+                }
+            },
+            _a[choiceElementName] = c15ChartBody,
+            _a),
+        "mc:Fallback": {
+            "c:barChart": fallbackBarChart,
+        },
+    };
+};
+/**
+ * Group series by their effective chart type for combo chart support.
+ * Returns a map of chart type to array of {index, ref, seriesData}.
+ */
+var groupSeriesByChartType = function (series, seriesRefs, defaultChartType) {
+    var groups = new Map();
+    seriesRefs.forEach(function (ref, index) {
+        var _a;
+        if (!ref)
+            return;
+        var seriesData = series[index];
+        var effectiveType = ((_a = seriesData === null || seriesData === void 0 ? void 0 : seriesData.seriesChartType) !== null && _a !== void 0 ? _a : defaultChartType);
+        if (!groups.has(effectiveType)) {
+            groups.set(effectiveType, []);
+        }
+        groups.get(effectiveType).push({ index: index, ref: ref, data: seriesData });
+    });
+    return groups;
+};
+/**
+ * Check if a chart has multiple series types (combo chart).
+ */
+var isComboChart = function (series, defaultChartType) {
+    var e_1, _a;
+    var _b;
+    var types = new Set();
+    try {
+        for (var series_1 = __values(series), series_1_1 = series_1.next(); !series_1_1.done; series_1_1 = series_1.next()) {
+            var s = series_1_1.value;
+            types.add((_b = s.seriesChartType) !== null && _b !== void 0 ? _b : defaultChartType);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (series_1_1 && !series_1_1.done && (_a = series_1.return)) _a.call(series_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return types.size > 1;
+};
+/**
+ * Build a bar/column series node.
+ */
+var buildBarSeriesNode = function (index, ref, seriesData, domainRef, sheetName, isFirstInGroup) {
+    var _a;
+    var seriesNode = cloneTemplate(column_series);
+    seriesNode["c:idx"] = { a$: { val: index.toString() } };
+    seriesNode["c:order"] = { a$: { val: index.toString() } };
+    var seriesColor = seriesData === null || seriesData === void 0 ? void 0 : seriesData.color;
+    var anyData = seriesData;
+    // noFill takes precedence over any other fill — Gantt-style
+    // invisible offset series. Must run BEFORE solidFill/gradient so it
+    // can wipe the template's default fill.
+    if (anyData === null || anyData === void 0 ? void 0 : anyData.noFill) {
+        applyNoFillToSeriesSpPr(seriesNode);
+    }
+    else if (applySeriesGradient(seriesNode, seriesData === null || seriesData === void 0 ? void 0 : seriesData.gradient)) {
+        // Gradient wins — solid/scheme already cleared.
+    }
+    else if (seriesColor) {
+        seriesNode["c:spPr"]["a:solidFill"] =
+            buildColorNode(seriesColor)["a:solidFill"];
+    }
+    else if (index < 6) {
+        seriesNode["c:spPr"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+    }
+    // Per-data-point colors — emit `<c:dPt>` array after the series-
+    // level fill. Each entry overrides the fill for one category index.
+    var dPtNodes = buildDataPointNodes(anyData === null || anyData === void 0 ? void 0 : anyData.dataPointColors);
+    if (dPtNodes) {
+        seriesNode["c:dPt"] = dPtNodes;
+    }
+    // Handle invertIfNegative for negative bar coloring
+    var invertIfNegative = seriesData === null || seriesData === void 0 ? void 0 : seriesData.invertIfNegative;
+    var negativeColor = seriesData === null || seriesData === void 0 ? void 0 : seriesData.negativeColor;
+    if (invertIfNegative) {
+        seriesNode["c:invertIfNegative"] = { a$: { val: "1" } };
+        var uniqueId = "{".concat(crypto.randomUUID().toUpperCase(), "}");
+        seriesNode["c:extLst"] = buildSeriesExtLst(negativeColor !== null && negativeColor !== void 0 ? negativeColor : undefined, uniqueId);
+    }
+    // Excel writes the category reference on every series, not just the first
+    // in a group — readers treat a cat-less series as having no categories.
+    if (domainRef) {
+        seriesNode["c:cat"] = {
+            "c:strRef": {
+                "c:f": domainRef,
+            },
+        };
+    }
+    else if (seriesData === null || seriesData === void 0 ? void 0 : seriesData.inlineDomainValues) {
+        // Inline category labels (`<c:strLit>`) — used when categories are
+        // embedded in the chart XML rather than from a sheet range.
+        seriesNode["c:cat"] = buildInlineStrLit(seriesData.inlineDomainValues);
+    }
+    seriesNode["c:val"]["c:numRef"]["c:f"] = ref;
+    // Inline series values (`<c:numLit>`) — when the series carries its
+    // own values rather than a cell-range. Rare for bars but valid.
+    var inlineValues = anyData === null || anyData === void 0 ? void 0 : anyData.inlineValues;
+    if (!ref && Array.isArray(inlineValues) && inlineValues.length) {
+        removeProp(seriesNode, "c:val");
+        seriesNode["c:val"] = buildInlineNumLit(inlineValues);
+    }
+    var labelNode = buildSeriesLabel((_a = seriesData === null || seriesData === void 0 ? void 0 : seriesData.dataLabel) !== null && _a !== void 0 ? _a : undefined, sheetName, seriesData === null || seriesData === void 0 ? void 0 : seriesData.dataLabelRef);
+    if (labelNode) {
+        seriesNode["c:tx"] = labelNode["c:tx"];
+    }
+    // Per-series marker — typically scatter/bubble but bar/line/area
+    // charts can carry one too via `<c:marker>`.
+    var markerNode = buildMarkerNode(anyData === null || anyData === void 0 ? void 0 : anyData.marker);
+    if (markerNode) {
+        seriesNode["c:marker"] = markerNode;
+    }
+    return seriesNode;
+};
+/**
+ * Build a line series node.
+ */
+var buildLineSeriesNode = function (index, ref, seriesData, domainRef, sheetName, smooth) {
+    var _a, _b;
+    var seriesNode = cloneTemplate(line_series);
+    seriesNode["c:idx"] = { a$: { val: index.toString() } };
+    seriesNode["c:order"] = { a$: { val: index.toString() } };
+    var seriesColor = seriesData === null || seriesData === void 0 ? void 0 : seriesData.color;
+    // Line series carry the stroke fill on `c:spPr/a:ln`. A gradient on
+    // a line stroke is unusual (Excel renders a flat-color stroke even
+    // when the underlying spec carries a gradient on `a:ln`), so we
+    // prefer a solid stroke and only apply the gradient to the bg-style
+    // `c:spPr/a:solidFill` slot when present. If the caller explicitly
+    // requested a gradient, we replace the stroke's solid color with
+    // the first stop's hex — best-effort fallback.
+    if ((seriesData === null || seriesData === void 0 ? void 0 : seriesData.gradient) && ((_a = seriesData.gradient.stops) === null || _a === void 0 ? void 0 : _a.length)) {
+        var first = seriesData.gradient.stops[0].color;
+        seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+            buildColorNode(first)["a:solidFill"];
+    }
+    else if (seriesColor) {
+        seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+            buildColorNode(seriesColor)["a:solidFill"];
+    }
+    else if (index < 6) {
+        seriesNode["c:spPr"]["a:ln"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+    }
+    if (domainRef) {
+        seriesNode["c:cat"]["c:strRef"]["c:f"] = domainRef;
+    }
+    else {
+        removeProp(seriesNode, "c:cat");
+    }
+    seriesNode["c:val"]["c:numRef"]["c:f"] = ref;
+    if (smooth) {
+        seriesNode["c:smooth"].a$.val = "1";
+    }
+    var labelNode = buildSeriesLabel((_b = seriesData === null || seriesData === void 0 ? void 0 : seriesData.dataLabel) !== null && _b !== void 0 ? _b : undefined, sheetName, seriesData === null || seriesData === void 0 ? void 0 : seriesData.dataLabelRef);
+    if (labelNode) {
+        seriesNode["c:tx"] = labelNode["c:tx"];
+    }
+    return seriesNode;
+};
+/**
+ * Build an area series node.
+ */
+var buildAreaSeriesNode = function (index, ref, seriesData, domainRef, sheetName) {
+    var _a, _b, _c;
+    var seriesNode = cloneTemplate(area_series);
+    seriesNode["c:idx"] = { a$: { val: index.toString() } };
+    seriesNode["c:order"] = { a$: { val: index.toString() } };
+    var seriesColor = seriesData === null || seriesData === void 0 ? void 0 : seriesData.color;
+    if (applySeriesGradient(seriesNode, seriesData === null || seriesData === void 0 ? void 0 : seriesData.gradient)) {
+        // Gradient applied to the fill area. Stroke stays solid using
+        // the first stop's color so the outline is visible.
+        if ((_b = (_a = seriesData === null || seriesData === void 0 ? void 0 : seriesData.gradient) === null || _a === void 0 ? void 0 : _a.stops) === null || _b === void 0 ? void 0 : _b.length) {
+            seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+                buildColorNode(seriesData.gradient.stops[0].color)["a:solidFill"];
+        }
+    }
+    else if (seriesColor) {
+        seriesNode["c:spPr"]["a:solidFill"] =
+            buildColorNode(seriesColor)["a:solidFill"];
+        seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+            buildColorNode(seriesColor)["a:solidFill"];
+    }
+    else if (index < 6) {
+        seriesNode["c:spPr"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+        seriesNode["c:spPr"]["a:ln"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+    }
+    if (domainRef) {
+        seriesNode["c:cat"]["c:strRef"]["c:f"] = domainRef;
+    }
+    else {
+        removeProp(seriesNode, "c:cat");
+    }
+    seriesNode["c:val"]["c:numRef"]["c:f"] = ref;
+    var labelNode = buildSeriesLabel((_c = seriesData === null || seriesData === void 0 ? void 0 : seriesData.dataLabel) !== null && _c !== void 0 ? _c : undefined, sheetName, seriesData === null || seriesData === void 0 ? void 0 : seriesData.dataLabelRef);
+    if (labelNode) {
+        seriesNode["c:tx"] = labelNode["c:tx"];
+    }
+    return seriesNode;
+};
+/**
+ * Pie/doughnut templates carry exactly one `c:ser`; a source chart with
+ * several series (e.g. seven single-cell slices) silently lost all but the
+ * first. Convert the template's ser into an array and append one node per
+ * remaining series, each with its own idx/order, name, category and value
+ * reference.
+ */
+var appendExtraCircularSeries = function (chartNode, groupKey, seriesRefs, seriesCatRefs, domainRef, series, sheetName) {
+    var e_2, _a;
+    var _b, _c, _d, _e, _f, _g, _h;
+    var group = (_b = chartNode["c:plotArea"]) === null || _b === void 0 ? void 0 : _b[groupKey];
+    if (!group)
+        return;
+    var extra = seriesRefs
+        .map(function (ref, index) { return ({ ref: ref, index: index }); })
+        .filter(function (_a) {
+        var ref = _a.ref, index = _a.index;
+        return index > 0 && Boolean(ref);
+    });
+    if (!extra.length)
+        return;
+    var firstSer = group["c:ser"];
+    var sers = Array.isArray(firstSer) ? firstSer : [firstSer];
+    // The template's single ser is series 0; give it its per-series cat when
+    // one was captured.
+    var firstCat = seriesCatRefs[0];
+    if (firstCat && ((_d = (_c = sers[0]) === null || _c === void 0 ? void 0 : _c["c:cat"]) === null || _d === void 0 ? void 0 : _d["c:strRef"])) {
+        sers[0]["c:cat"]["c:strRef"]["c:f"] = firstCat;
+    }
+    try {
+        for (var extra_1 = __values(extra), extra_1_1 = extra_1.next(); !extra_1_1.done; extra_1_1 = extra_1.next()) {
+            var _j = extra_1_1.value, ref = _j.ref, index = _j.index;
+            var node = {
+                "c:idx": { a$: { val: String(index) } },
+                "c:order": { a$: { val: String(index) } },
+            };
+            var labelNode = buildSeriesLabel((_f = (_e = series[index]) === null || _e === void 0 ? void 0 : _e.dataLabel) !== null && _f !== void 0 ? _f : undefined, sheetName, (_g = series[index]) === null || _g === void 0 ? void 0 : _g.dataLabelRef);
+            if (labelNode) {
+                node["c:tx"] = labelNode["c:tx"];
+            }
+            var catRef = (_h = seriesCatRefs[index]) !== null && _h !== void 0 ? _h : domainRef;
+            if (catRef) {
+                node["c:cat"] = { "c:strRef": { "c:f": catRef } };
+            }
+            node["c:val"] = { "c:numRef": { "c:f": ref } };
+            sers.push(node);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (extra_1_1 && !extra_1_1.done && (_a = extra_1.return)) _a.call(extra_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    group["c:ser"] = sers;
+};
+var buildPieChart = function (domainRef, valueRef, title, subtitle) {
+    var pieChart = cloneTemplate(donut_json);
+    applyChartTitle(pieChart, title, undefined, subtitle);
+    var plotArea = pieChart["c:plotArea"];
+    var donut = plotArea["c:doughnutChart"];
+    removeProp(donut, "c:holeSize");
+    plotArea["c:pieChart"] = donut;
+    removeProp(plotArea, "c:doughnutChart");
+    var seriesNode = plotArea["c:pieChart"]["c:ser"];
+    if (domainRef) {
+        seriesNode["c:cat"]["c:strRef"]["c:f"] = domainRef;
+    }
+    if (valueRef) {
+        seriesNode["c:val"]["c:numRef"]["c:f"] = valueRef;
+    }
+    return pieChart;
+};
+/**
+ * Pie-of-pie / bar-of-pie (`<c:ofPieChart>`). Reuses the donut template
+ * like buildPieChart but rebuilds the chart-group node so the of-pie
+ * elements land in the CT_OfPieChart sequence order: ofPieType,
+ * varyColors, ser, dLbls, gapWidth, splitType, splitPos, secondPieSize,
+ * serLines. splitType maps the spec vocabulary back to the OOXML
+ * tokens (`pos`/`val`/`percent`); `<c:serLines/>` turns on Excel's
+ * connector lines between the two plots.
+ */
+var buildOfPieChart = function (domainRef, valueRef, title, spec, subtitle) {
+    var chartObj = cloneTemplate(donut_json);
+    applyChartTitle(chartObj, title, undefined, subtitle);
+    var plotArea = chartObj["c:plotArea"];
+    var donut = plotArea["c:doughnutChart"];
+    // holeSize and firstSliceAng are pie/doughnut-only — invalid inside
+    // <c:ofPieChart>.
+    removeProp(donut, "c:holeSize");
+    removeProp(donut, "c:firstSliceAng");
+    var splitTypeVal = (spec === null || spec === void 0 ? void 0 : spec.splitType) === "position"
+        ? "pos"
+        : (spec === null || spec === void 0 ? void 0 : spec.splitType) === "value"
+            ? "val"
+            : (spec === null || spec === void 0 ? void 0 : spec.splitType) === "percent"
+                ? "percent"
+                : undefined;
+    var ofPieNode = __assign(__assign(__assign(__assign({ "c:ofPieType": { a$: { val: (spec === null || spec === void 0 ? void 0 : spec.ofPieType) === "bar" ? "bar" : "pie" } }, "c:varyColors": donut["c:varyColors"], "c:ser": donut["c:ser"], "c:dLbls": donut["c:dLbls"], 
+        // Excel's default gap between the two plots.
+        "c:gapWidth": { a$: { val: "100" } } }, (splitTypeVal ? { "c:splitType": { a$: { val: splitTypeVal } } } : {})), (typeof (spec === null || spec === void 0 ? void 0 : spec.splitPos) === "number" && Number.isFinite(spec.splitPos)
+        ? { "c:splitPos": { a$: { val: String(spec.splitPos) } } }
+        : {})), (typeof (spec === null || spec === void 0 ? void 0 : spec.secondPieSize) === "number" &&
+        Number.isFinite(spec.secondPieSize)
+        ? { "c:secondPieSize": { a$: { val: String(Math.round(spec.secondPieSize)) } } }
+        : {})), { "c:serLines": {} });
+    plotArea["c:ofPieChart"] = ofPieNode;
+    removeProp(plotArea, "c:doughnutChart");
+    var seriesNode = ofPieNode["c:ser"];
+    if (domainRef) {
+        seriesNode["c:cat"]["c:strRef"]["c:f"] = domainRef;
+    }
+    if (valueRef) {
+        seriesNode["c:val"]["c:numRef"]["c:f"] = valueRef;
+    }
+    return chartObj;
+};
+/**
+ * Minimal builder for chart types that follow the line-style template
+ * (radar, stock, etc.) — single chart-type container with a flat series
+ * list. Reuses the column template and rewrites its barChart block to
+ * the target chart-type element. The renderer/Excel handles the rest.
+ */
+var buildRadarLikeChart = function (chartElementKey, domainRef, seriesRefs, title, radarStyle, subtitle) {
+    var _a;
+    var chartObj = cloneTemplate(column_json);
+    applyChartTitle(chartObj, title, undefined, subtitle);
+    var plotArea = chartObj["c:plotArea"];
+    var barChart = plotArea["c:barChart"];
+    var axisIds = (_a = barChart === null || barChart === void 0 ? void 0 : barChart["c:axId"]) !== null && _a !== void 0 ? _a : [];
+    var containerNode = {
+        "c:varyColors": { a$: { val: "0" } },
+        "c:ser": [],
+        "c:axId": axisIds,
+    };
+    if (chartElementKey === "c:radarChart") {
+        containerNode["c:radarStyle"] = {
+            a$: { val: radarStyle !== null && radarStyle !== void 0 ? radarStyle : "standard" },
+        };
+    }
+    removeProp(plotArea, "c:barChart");
+    plotArea[chartElementKey] = containerNode;
+    var seriesContainer = containerNode["c:ser"];
+    seriesRefs.forEach(function (ref, index) {
+        if (!ref)
+            return;
+        var seriesNode = {
+            "c:idx": { a$: { val: String(index) } },
+            "c:order": { a$: { val: String(index) } },
+            "c:cat": domainRef
+                ? { "c:strRef": { "c:f": domainRef } }
+                : undefined,
+            "c:val": { "c:numRef": { "c:f": ref } },
+        };
+        if (!domainRef)
+            delete seriesNode["c:cat"];
+        seriesContainer.push(seriesNode);
+    });
+    return chartObj;
+};
+var buildDoughnutChart = function (domainRef, valueRef, title, subtitle) {
+    // Doughnut uses the same donut_json template as pie but keeps the
+    // <c:doughnutChart> wrapper (and the holeSize, which we set later
+    // via applyDoughnutHole when the spec carries one).
+    var chartObj = cloneTemplate(donut_json);
+    applyChartTitle(chartObj, title, undefined, subtitle);
+    var plotArea = chartObj["c:plotArea"];
+    var seriesNode = plotArea["c:doughnutChart"]["c:ser"];
+    if (domainRef) {
+        seriesNode["c:cat"]["c:strRef"]["c:f"] = domainRef;
+    }
+    if (valueRef) {
+        seriesNode["c:val"]["c:numRef"]["c:f"] = valueRef;
+    }
+    return chartObj;
+};
+export var buildChartXml = function (chart, sheetNameById) {
+    var e_3, _a, e_4, _b, e_5, _c;
+    var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10;
+    var series = (_e = (_d = chart.spec) === null || _d === void 0 ? void 0 : _d.series) !== null && _e !== void 0 ? _e : [];
+    if (!series.length)
+        return undefined;
+    var domainRef = formatSourcesRef((_g = (_f = chart.spec.domains) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.sources, sheetNameById);
+    var seriesRefs = series.map(function (entry) {
+        return formatSourcesRef(entry === null || entry === void 0 ? void 0 : entry.sources, sheetNameById);
+    });
+    var seriesCatRefs = series.map(function (entry) {
+        return seriesCategoryRef(entry, sheetNameById);
+    });
+    if (!seriesRefs.some(Boolean))
+        return undefined;
+    var chartType = chart.spec.chartType;
+    var chartTitle = (_h = chart.spec.title) !== null && _h !== void 0 ? _h : undefined;
+    // Subtitle line rendered under the title (e.g. a "Total Value to
+    // Paid-In" caption under "Net MOIC by Fund Vintage"). Emitted as a
+    // second `<a:p>` in the title's rich block — see `applyChartTitle`.
+    var chartSubtitle = (_j = chart.spec.subtitle) !== null && _j !== void 0 ? _j : undefined;
+    // Authored title text formatting (color/font/bold) — round-tripped
+    // back so Excel keeps the styled title we read on import.
+    var chartTitleFmt = (_k = chart.spec.titleTextFormat) !== null && _k !== void 0 ? _k : undefined;
+    var smooth = "smooth" in chart.spec ? chart.spec.smooth : undefined;
+    var chartSpace = cloneTemplate(chart_template);
+    var sheetName = sheetNameById.get(chart.position.sheetId);
+    // Check for combo chart (multiple series chart types)
+    if (isComboChart(series, chartType)) {
+        var groups = groupSeriesByChartType(series, seriesRefs, chartType);
+        // Build combo chart with multiple chart type containers
+        var comboChart = cloneTemplate(column_json);
+        applyChartTitle(comboChart, chartTitle, chartTitleFmt, chartSubtitle);
+        var plotArea = comboChart["c:plotArea"];
+        var baseBarChart = plotArea["c:barChart"];
+        var axisIds = (_l = baseBarChart === null || baseBarChart === void 0 ? void 0 : baseBarChart["c:axId"]) !== null && _l !== void 0 ? _l : [];
+        var dLbls = (_m = baseBarChart === null || baseBarChart === void 0 ? void 0 : baseBarChart["c:dLbls"]) !== null && _m !== void 0 ? _m : {};
+        // Remove the default bar chart - we'll add specific chart types
+        removeProp(plotArea, "c:barChart");
+        try {
+            // Add chart type containers for each group
+            for (var groups_1 = __values(groups), groups_1_1 = groups_1.next(); !groups_1_1.done; groups_1_1 = groups_1.next()) {
+                var _11 = __read(groups_1_1.value, 2), groupType = _11[0], groupSeries = _11[1];
+                if (groupType === "bar" || groupType === "column") {
+                    var barChartNode = {
+                        "c:barDir": { a$: { val: groupType === "bar" ? "bar" : "col" } },
+                        "c:grouping": { a$: { val: "clustered" } },
+                        "c:varyColors": { a$: { val: "0" } },
+                        "c:ser": [],
+                        "c:dLbls": dLbls,
+                        "c:axId": axisIds,
+                    };
+                    for (var i = 0; i < groupSeries.length; i++) {
+                        var _12 = groupSeries[i], index = _12.index, ref = _12.ref, data = _12.data;
+                        var seriesNode = buildBarSeriesNode(index, ref, data, (_o = seriesCatRefs[index]) !== null && _o !== void 0 ? _o : domainRef, sheetName, i === 0);
+                        barChartNode["c:ser"].push(seriesNode);
+                    }
+                    plotArea["c:barChart"] = barChartNode;
+                }
+                else if (groupType === "line") {
+                    var lineChartNode = {
+                        "c:grouping": { a$: { val: "standard" } },
+                        "c:varyColors": { a$: { val: "0" } },
+                        "c:ser": [],
+                        "c:dLbls": dLbls,
+                        "c:axId": axisIds,
+                    };
+                    try {
+                        for (var groupSeries_1 = (e_4 = void 0, __values(groupSeries)), groupSeries_1_1 = groupSeries_1.next(); !groupSeries_1_1.done; groupSeries_1_1 = groupSeries_1.next()) {
+                            var _13 = groupSeries_1_1.value, index = _13.index, ref = _13.ref, data = _13.data;
+                            var seriesNode = buildLineSeriesNode(index, ref, data, (_p = seriesCatRefs[index]) !== null && _p !== void 0 ? _p : domainRef, sheetName, smooth);
+                            lineChartNode["c:ser"].push(seriesNode);
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (groupSeries_1_1 && !groupSeries_1_1.done && (_b = groupSeries_1.return)) _b.call(groupSeries_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    plotArea["c:lineChart"] = lineChartNode;
+                }
+                else if (groupType === "area") {
+                    var areaChartNode = {
+                        "c:grouping": { a$: { val: "standard" } },
+                        "c:varyColors": { a$: { val: "0" } },
+                        "c:ser": [],
+                        "c:dLbls": dLbls,
+                        "c:axId": axisIds,
+                    };
+                    try {
+                        for (var groupSeries_2 = (e_5 = void 0, __values(groupSeries)), groupSeries_2_1 = groupSeries_2.next(); !groupSeries_2_1.done; groupSeries_2_1 = groupSeries_2.next()) {
+                            var _14 = groupSeries_2_1.value, index = _14.index, ref = _14.ref, data = _14.data;
+                            var seriesNode = buildAreaSeriesNode(index, ref, data, (_q = seriesCatRefs[index]) !== null && _q !== void 0 ? _q : domainRef, sheetName);
+                            areaChartNode["c:ser"].push(seriesNode);
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (groupSeries_2_1 && !groupSeries_2_1.done && (_c = groupSeries_2.return)) _c.call(groupSeries_2);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                    plotArea["c:areaChart"] = areaChartNode;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (groups_1_1 && !groups_1_1.done && (_a = groups_1.return)) _a.call(groups_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        chartSpace["c:chartSpace"]["c:chart"] = comboChart;
+        var xml_1 = chartBuilder.build(chartSpace);
+        return "".concat(XML_DECLARATION).concat(xml_1);
+    }
+    // Handle non-combo charts (original logic)
+    if (isC15ChartType(chartType)) {
+        // Histogram / boxplot / waterfall / funnel emit as a barChart for
+        // older Excel compatibility. For histogram (Phase 5.5b), the
+        // barChart is wrapped in mc:AlternateContent with a c15:histogramChart
+        // sibling in mc:Choice — Excel 2016+ uses the c15 chart, older
+        // versions fall back to bar. For boxplot/waterfall/funnel we still
+        // use the c15 extension marker (round-trips in our pipeline; opens
+        // as bar chart in Excel) until those types get the same upgrade.
+        var barChartDoc = cloneTemplate(column_json);
+        applyChartTitle(barChartDoc, chartTitle, chartTitleFmt, chartSubtitle);
+        var bar = barChartDoc["c:plotArea"]["c:barChart"];
+        bar["c:barDir"].a$.val = "col";
+        var seriesContainer_1 = bar["c:ser"];
+        seriesRefs.forEach(function (ref, index) {
+            var _a, _b, _c, _d, _e;
+            if (!ref)
+                return;
+            var seriesNode = cloneTemplate(column_series);
+            seriesNode["c:idx"] = { a$: { val: index.toString() } };
+            seriesNode["c:order"] = { a$: { val: index.toString() } };
+            var seriesColor = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.color;
+            if (applySeriesGradient(seriesNode, (_b = series[index]) === null || _b === void 0 ? void 0 : _b.gradient)) {
+                // Gradient applied; nothing else.
+            }
+            else if (seriesColor) {
+                seriesNode["c:spPr"]["a:solidFill"] =
+                    buildColorNode(seriesColor)["a:solidFill"];
+            }
+            else if (index < 6) {
+                seriesNode["c:spPr"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+            }
+            if (!index && domainRef) {
+                seriesNode["c:cat"] = {
+                    "c:strRef": {
+                        "c:f": domainRef,
+                    },
+                };
+            }
+            seriesNode["c:val"]["c:numRef"]["c:f"] = ref;
+            var labelNode = buildSeriesLabel((_d = (_c = series[index]) === null || _c === void 0 ? void 0 : _c.dataLabel) !== null && _d !== void 0 ? _d : undefined, sheetNameById.get(chart.position.sheetId), (_e = series[index]) === null || _e === void 0 ? void 0 : _e.dataLabelRef);
+            if (labelNode) {
+                seriesNode["c:tx"] = labelNode["c:tx"];
+            }
+            seriesContainer_1.push(seriesNode);
+        });
+        // Phase 5.5b: wrap the bar chart in mc:AlternateContent and emit
+        // a full c15:* chart in mc:Choice so Excel 2016+ renders natively.
+        // c:catAx / c:valAx stay at c:plotArea level — both Choice and
+        // Fallback reference them through matching axId values.
+        var axIdNodes = bar["c:axId"];
+        var catAxId = (_t = (_s = (_r = axIdNodes === null || axIdNodes === void 0 ? void 0 : axIdNodes[0]) === null || _r === void 0 ? void 0 : _r.a$) === null || _s === void 0 ? void 0 : _s.val) !== null && _t !== void 0 ? _t : "1";
+        var valAxId = (_w = (_v = (_u = axIdNodes === null || axIdNodes === void 0 ? void 0 : axIdNodes[1]) === null || _u === void 0 ? void 0 : _u.a$) === null || _v === void 0 ? void 0 : _v.val) !== null && _w !== void 0 ? _w : "2";
+        var c15Args = {
+            seriesRefs: seriesRefs,
+            series: series,
+            domainRef: domainRef,
+            axIds: { catAxId: catAxId, valAxId: valAxId },
+        };
+        var c15Chart = void 0;
+        if (chartType === "histogram") {
+            c15Chart = buildC15HistogramChartNode(chart.spec, c15Args.seriesRefs, c15Args.series, c15Args.domainRef, c15Args.axIds);
+        }
+        else if (chartType === "boxplot") {
+            c15Chart = buildC15BoxplotChartNode(chart.spec, c15Args.seriesRefs, c15Args.series, c15Args.domainRef, c15Args.axIds);
+        }
+        else if (chartType === "waterfall") {
+            c15Chart = buildC15WaterfallChartNode(chart.spec, c15Args.seriesRefs, c15Args.series, c15Args.domainRef, c15Args.axIds);
+        }
+        else {
+            c15Chart = buildC15FunnelChartNode(chart.spec, c15Args.seriesRefs, c15Args.series, c15Args.domainRef, c15Args.axIds);
+        }
+        var altContent = buildC15AlternateContent(chartType, c15Chart, bar);
+        removeProp(barChartDoc["c:plotArea"], "c:barChart");
+        barChartDoc["c:plotArea"]["mc:AlternateContent"] = altContent;
+        chartSpace["c:chartSpace"]["c:chart"] = barChartDoc;
+    }
+    else if (chartType === "bar" || chartType === "column") {
+        var barChart = cloneTemplate(column_json);
+        applyChartTitle(barChart, chartTitle, chartTitleFmt, chartSubtitle);
+        var bar = barChart["c:plotArea"]["c:barChart"];
+        bar["c:barDir"].a$.val = chartType === "bar" ? "bar" : "col";
+        // Grouping / overlap / gapWidth — Excel's stacked / percent-stacked
+        // bars need these set. Excel's defaults are `clustered` + overlap=0
+        // + gapWidth=150; we only emit when the spec actually carries a
+        // value to avoid bloating the file.
+        var stackedType = chart.spec.stackedType;
+        if (stackedType === "STACKED") {
+            bar["c:grouping"] = { a$: { val: "stacked" } };
+        }
+        else if (stackedType === "PERCENT_STACKED") {
+            bar["c:grouping"] = { a$: { val: "percentStacked" } };
+        }
+        else if (stackedType === "UNSTACKED") {
+            bar["c:grouping"] = { a$: { val: "clustered" } };
+        }
+        var overlap = chart.spec.overlap;
+        if (typeof overlap === "number") {
+            bar["c:overlap"] = { a$: { val: String(Math.round(overlap)) } };
+        }
+        var gapWidth = chart.spec.gapWidth;
+        if (typeof gapWidth === "number") {
+            bar["c:gapWidth"] = { a$: { val: String(Math.round(gapWidth)) } };
+        }
+        var seriesContainer_2 = bar["c:ser"];
+        // Inline categories — when no cell-range, use the first domain's
+        // inlineValues directly on the first series' c:cat.
+        var inlineDomainValues_1 = (_y = (_x = chart.spec.domains) === null || _x === void 0 ? void 0 : _x[0]) === null || _y === void 0 ? void 0 : _y.inlineValues;
+        seriesRefs.forEach(function (ref, index) {
+            var _a, _b;
+            if (!ref && !((_a = series[index]) === null || _a === void 0 ? void 0 : _a.inlineValues))
+                return;
+            // Decorate the spec entry with the chart-level inline domain so
+            // `buildBarSeriesNode` can emit `<c:strLit>` on the first series.
+            var enrichedSeries = index === 0 && !domainRef && (inlineDomainValues_1 === null || inlineDomainValues_1 === void 0 ? void 0 : inlineDomainValues_1.length)
+                ? __assign(__assign({}, series[index]), { inlineDomainValues: inlineDomainValues_1 })
+                : series[index];
+            var seriesNode = buildBarSeriesNode(index, ref !== null && ref !== void 0 ? ref : "", enrichedSeries, (_b = seriesCatRefs[index]) !== null && _b !== void 0 ? _b : domainRef, sheetNameById.get(chart.position.sheetId), index === 0);
+            seriesContainer_2.push(seriesNode);
+        });
+        chartSpace["c:chartSpace"]["c:chart"] = barChart;
+    }
+    else if (chartType === "pie") {
+        var valueRef = seriesRefs.find(Boolean);
+        var specAny = chart.spec;
+        // Pie-of-pie / bar-of-pie round-trips as <c:ofPieChart> when the
+        // spec carries the OF_PIE marker (or an explicit ofPieType).
+        var isOfPie = String((_z = specAny === null || specAny === void 0 ? void 0 : specAny.sourceChartType) !== null && _z !== void 0 ? _z : "").toUpperCase() === "OF_PIE" ||
+            (specAny === null || specAny === void 0 ? void 0 : specAny.ofPieType) === "pie" ||
+            (specAny === null || specAny === void 0 ? void 0 : specAny.ofPieType) === "bar";
+        var pieChart = isOfPie
+            ? buildOfPieChart(domainRef, valueRef, chartTitle, specAny, chartSubtitle)
+            : buildPieChart(domainRef, valueRef, chartTitle, chartSubtitle);
+        if (!isOfPie) {
+            appendExtraCircularSeries(pieChart, "c:pieChart", seriesRefs, seriesCatRefs, domainRef, series, sheetNameById.get(chart.position.sheetId));
+        }
+        chartSpace["c:chartSpace"]["c:chart"] = pieChart;
+    }
+    else if (chartType === "doughnut") {
+        var valueRef = seriesRefs.find(Boolean);
+        var doughnutChart = buildDoughnutChart(domainRef, valueRef, chartTitle, chartSubtitle);
+        appendExtraCircularSeries(doughnutChart, "c:doughnutChart", seriesRefs, seriesCatRefs, domainRef, series, sheetNameById.get(chart.position.sheetId));
+        chartSpace["c:chartSpace"]["c:chart"] = doughnutChart;
+    }
+    else if (chartType === "radar") {
+        var radarChart = buildRadarLikeChart("c:radarChart", domainRef, seriesRefs, chartTitle, (_0 = chart.spec.radarStyle) !== null && _0 !== void 0 ? _0 : "standard", chartSubtitle);
+        chartSpace["c:chartSpace"]["c:chart"] = radarChart;
+    }
+    else if (chartType === "stock") {
+        var stockChart = buildRadarLikeChart("c:stockChart", domainRef, seriesRefs, chartTitle, undefined, chartSubtitle);
+        chartSpace["c:chartSpace"]["c:chart"] = stockChart;
+    }
+    else if (chartType === "line") {
+        var lineChart = cloneTemplate(column_json);
+        applyChartTitle(lineChart, chartTitle, chartTitleFmt, chartSubtitle);
+        var plotArea = lineChart["c:plotArea"];
+        var barChart = plotArea["c:barChart"];
+        var lineChartNode = {
+            "c:grouping": {
+                a$: {
+                    val: "standard",
+                },
+            },
+            "c:varyColors": {
+                a$: {
+                    val: "0",
+                },
+            },
+            "c:ser": [],
+            "c:dLbls": (_1 = barChart === null || barChart === void 0 ? void 0 : barChart["c:dLbls"]) !== null && _1 !== void 0 ? _1 : {},
+            "c:axId": (_2 = barChart === null || barChart === void 0 ? void 0 : barChart["c:axId"]) !== null && _2 !== void 0 ? _2 : [],
+        };
+        removeProp(plotArea, "c:barChart");
+        plotArea["c:lineChart"] = lineChartNode;
+        var seriesContainer_3 = lineChartNode["c:ser"];
+        seriesRefs.forEach(function (ref, index) {
+            var _a, _b, _c, _d, _e;
+            if (!ref)
+                return;
+            var seriesNode = cloneTemplate(line_series);
+            seriesNode["c:idx"] = { a$: { val: index.toString() } };
+            seriesNode["c:order"] = { a$: { val: index.toString() } };
+            var seriesColor = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.color;
+            if (seriesColor) {
+                seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+                    buildColorNode(seriesColor)["a:solidFill"];
+            }
+            else if (index < 6) {
+                seriesNode["c:spPr"]["a:ln"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+            }
+            // Category axis is optional - Excel will use numeric indices if not provided
+            var catRef = (_b = seriesCatRefs[index]) !== null && _b !== void 0 ? _b : domainRef;
+            if (catRef) {
+                seriesNode["c:cat"]["c:strRef"]["c:f"] = catRef;
+            }
+            else {
+                // Remove the category reference if no domain
+                removeProp(seriesNode, "c:cat");
+            }
+            seriesNode["c:val"]["c:numRef"]["c:f"] = ref;
+            if (smooth) {
+                seriesNode["c:smooth"].a$.val = "1";
+            }
+            var labelNode = buildSeriesLabel((_d = (_c = series[index]) === null || _c === void 0 ? void 0 : _c.dataLabel) !== null && _d !== void 0 ? _d : undefined, sheetNameById.get(chart.position.sheetId), (_e = series[index]) === null || _e === void 0 ? void 0 : _e.dataLabelRef);
+            if (labelNode) {
+                seriesNode["c:tx"] = labelNode["c:tx"];
+            }
+            seriesContainer_3.push(seriesNode);
+        });
+        chartSpace["c:chartSpace"]["c:chart"] = lineChart;
+    }
+    else if (chartType === "area") {
+        var areaChart = cloneTemplate(column_json);
+        applyChartTitle(areaChart, chartTitle, chartTitleFmt, chartSubtitle);
+        var plotArea = areaChart["c:plotArea"];
+        var barChart = plotArea["c:barChart"];
+        var areaChartNode = {
+            "c:grouping": {
+                a$: {
+                    val: "standard",
+                },
+            },
+            "c:varyColors": {
+                a$: {
+                    val: "0",
+                },
+            },
+            "c:ser": [],
+            "c:dLbls": (_3 = barChart === null || barChart === void 0 ? void 0 : barChart["c:dLbls"]) !== null && _3 !== void 0 ? _3 : {},
+            "c:axId": (_4 = barChart === null || barChart === void 0 ? void 0 : barChart["c:axId"]) !== null && _4 !== void 0 ? _4 : [],
+        };
+        removeProp(plotArea, "c:barChart");
+        plotArea["c:areaChart"] = areaChartNode;
+        var seriesContainer_4 = areaChartNode["c:ser"];
+        seriesRefs.forEach(function (ref, index) {
+            var _a, _b, _c, _d, _e;
+            if (!ref)
+                return;
+            var seriesNode = cloneTemplate(area_series);
+            seriesNode["c:idx"] = { a$: { val: index.toString() } };
+            seriesNode["c:order"] = { a$: { val: index.toString() } };
+            var seriesColor = (_a = series[index]) === null || _a === void 0 ? void 0 : _a.color;
+            if (seriesColor) {
+                seriesNode["c:spPr"]["a:solidFill"] =
+                    buildColorNode(seriesColor)["a:solidFill"];
+                seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+                    buildColorNode(seriesColor)["a:solidFill"];
+            }
+            else if (index < 6) {
+                seriesNode["c:spPr"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+                seriesNode["c:spPr"]["a:ln"]["a:solidFill"]["a:schemeClr"].a$.val = "accent".concat(index + 1);
+            }
+            // Category axis is optional - Excel will use numeric indices if not provided
+            var catRef = (_b = seriesCatRefs[index]) !== null && _b !== void 0 ? _b : domainRef;
+            if (catRef) {
+                seriesNode["c:cat"]["c:strRef"]["c:f"] = catRef;
+            }
+            else {
+                removeProp(seriesNode, "c:cat");
+            }
+            seriesNode["c:val"]["c:numRef"]["c:f"] = ref;
+            var labelNode = buildSeriesLabel((_d = (_c = series[index]) === null || _c === void 0 ? void 0 : _c.dataLabel) !== null && _d !== void 0 ? _d : undefined, sheetNameById.get(chart.position.sheetId), (_e = series[index]) === null || _e === void 0 ? void 0 : _e.dataLabelRef);
+            if (labelNode) {
+                seriesNode["c:tx"] = labelNode["c:tx"];
+            }
+            seriesContainer_4.push(seriesNode);
+        });
+        chartSpace["c:chartSpace"]["c:chart"] = areaChart;
+    }
+    else if (chartType === "scatter" || chartType === "bubble") {
+        var bubbleSpec = chart.spec;
+        var domainEntries_1 = (_5 = bubbleSpec.domains) !== null && _5 !== void 0 ? _5 : [];
+        var seriesEntries = (_6 = bubbleSpec.series) !== null && _6 !== void 0 ? _6 : [];
+        var bubbleSizeEntries_1 = (_7 = bubbleSpec.bubbleSizes) !== null && _7 !== void 0 ? _7 : [];
+        var bubbleLabelEntries_1 = (_8 = bubbleSpec.bubbleLabels) !== null && _8 !== void 0 ? _8 : [];
+        var seriesContainer_5 = [];
+        var seriesTemplate_1 = chartType === "bubble" ? bubble_series : scatter_series;
+        seriesEntries.forEach(function (entry, index) {
+            var _a, _b, _c, _d, _e, _f;
+            var domainRef = formatRangeRef((_a = getPrimarySource(domainEntries_1[index])) !== null && _a !== void 0 ? _a : getPrimarySource(domainEntries_1[0]), sheetNameById);
+            var valueRef = formatRangeRef(getPrimarySource(entry), sheetNameById);
+            if (!domainRef || !valueRef)
+                return;
+            var seriesNode = cloneTemplate(seriesTemplate_1);
+            seriesNode["c:idx"] = { a$: { val: index.toString() } };
+            seriesNode["c:order"] = { a$: { val: index.toString() } };
+            var seriesColor = entry === null || entry === void 0 ? void 0 : entry.color;
+            if (seriesColor) {
+                if (chartType === "bubble") {
+                    seriesNode["c:spPr"]["a:solidFill"] =
+                        buildColorNode(seriesColor)["a:solidFill"];
+                }
+                else {
+                    seriesNode["c:spPr"]["a:ln"]["a:solidFill"] =
+                        buildColorNode(seriesColor)["a:solidFill"];
+                }
+            }
+            else if (index < 6) {
+                var colorNode = chartType === "bubble"
+                    ? seriesNode["c:spPr"]["a:solidFill"]["a:schemeClr"]
+                    : seriesNode["c:spPr"]["a:ln"]["a:solidFill"]["a:schemeClr"];
+                colorNode.a$.val = "accent".concat(index + 1);
+            }
+            seriesNode["c:xVal"]["c:numRef"]["c:f"] = domainRef;
+            seriesNode["c:yVal"]["c:numRef"]["c:f"] = valueRef;
+            if (chartType === "bubble") {
+                var sizeRef = formatRangeRef((_c = (_b = getPrimarySource(bubbleSizeEntries_1[index])) !== null && _b !== void 0 ? _b : getPrimarySource(bubbleSizeEntries_1[0])) !== null && _c !== void 0 ? _c : getPrimarySource(entry), sheetNameById);
+                if (sizeRef) {
+                    seriesNode["c:bubbleSize"]["c:numRef"]["c:f"] = sizeRef;
+                }
+            }
+            else if (smooth) {
+                seriesNode["c:smooth"].a$.val = "1";
+            }
+            var labelNode = buildSeriesLabel((_f = (_d = entry === null || entry === void 0 ? void 0 : entry.dataLabel) !== null && _d !== void 0 ? _d : (_e = bubbleLabelEntries_1[index]) === null || _e === void 0 ? void 0 : _e.dataLabel) !== null && _f !== void 0 ? _f : undefined, sheetNameById.get(chart.position.sheetId), entry === null || entry === void 0 ? void 0 : entry.dataLabelRef);
+            if (labelNode) {
+                seriesNode["c:tx"] = labelNode["c:tx"];
+            }
+            seriesContainer_5.push(seriesNode);
+        });
+        if (!seriesContainer_5.length)
+            return undefined;
+        var chartDoc = cloneTemplate(scatter_json);
+        applyChartTitle(chartDoc, chartTitle, chartTitleFmt, chartSubtitle);
+        var plotArea = chartDoc["c:plotArea"];
+        var scatterChart = plotArea["c:scatterChart"];
+        if (chartType === "bubble") {
+            removeProp(plotArea, "c:scatterChart");
+            removeProp(scatterChart, "c:scatterStyle");
+            scatterChart["c:bubbleScale"] = { a$: { val: "100" } };
+            scatterChart["c:showNegBubbles"] = { a$: { val: "0" } };
+            scatterChart["c:sizeRepresents"] = { a$: { val: "area" } };
+            plotArea["c:bubbleChart"] = scatterChart;
+        }
+        else {
+            // <c:scatterStyle> — Excel default is "lineMarker". Round-trip
+            // whatever the spec carries so the connecting line / marker mix
+            // survives re-saving.
+            var scatterStyle = chart.spec.scatterStyle;
+            if (scatterStyle && typeof scatterStyle === "string") {
+                scatterChart["c:scatterStyle"] = { a$: { val: scatterStyle } };
+            }
+        }
+        // Per-series marker — append to each series node that doesn't yet
+        // carry one (scatter/bubble series templates already include a
+        // marker block in many cases; only add when authored).
+        seriesContainer_5.forEach(function (node, i) {
+            var _a, _b;
+            var markerSpec = (_b = (_a = chart.spec.series) === null || _a === void 0 ? void 0 : _a[i]) === null || _b === void 0 ? void 0 : _b.marker;
+            var m = buildMarkerNode(markerSpec);
+            if (m) {
+                node["c:marker"] = m;
+            }
+        });
+        var targetChart = chartType === "bubble" ? plotArea["c:bubbleChart"] : scatterChart;
+        targetChart["c:ser"] = seriesContainer_5;
+        chartSpace["c:chartSpace"]["c:chart"] = chartDoc;
+    }
+    else if (chartType === "treemap" || chartType === "sunburst") {
+        var treeSpec = chart.spec;
+        var labelRef = formatRangeRef(getPrimarySource((_9 = treeSpec.labels) === null || _9 === void 0 ? void 0 : _9[0]), sheetNameById);
+        var sizeRef = formatRangeRef(getPrimarySource((_10 = treeSpec.sizeData) === null || _10 === void 0 ? void 0 : _10[0]), sheetNameById);
+        if (!labelRef || !sizeRef)
+            return undefined;
+        if (chartType === "sunburst") {
+            var pieChart = buildPieChart(labelRef, sizeRef, chartTitle, chartSubtitle);
+            chartSpace["c:chartSpace"]["c:chart"] = pieChart;
+        }
+        else {
+            var columnChart = cloneTemplate(column_json);
+            applyChartTitle(columnChart, chartTitle, chartTitleFmt, chartSubtitle);
+            var bar = columnChart["c:plotArea"]["c:barChart"];
+            var seriesContainer = bar["c:ser"];
+            var seriesNode = cloneTemplate(column_series);
+            seriesNode["c:idx"] = { a$: { val: "0" } };
+            seriesNode["c:order"] = { a$: { val: "0" } };
+            seriesNode["c:cat"] = {
+                "c:strRef": {
+                    "c:f": labelRef,
+                },
+            };
+            seriesNode["c:val"]["c:numRef"]["c:f"] = sizeRef;
+            seriesContainer.push(seriesNode);
+            chartSpace["c:chartSpace"]["c:chart"] = columnChart;
+        }
+    }
+    else {
+        return undefined;
+    }
+    // Apply Phase 5.1 formatting (legend, data labels, axis options) to the
+    // assembled chart. These mutate the chart node in place — they're
+    // chartType-agnostic and intentionally run last so per-type branches
+    // don't have to know about them.
+    applyChartFormatting(chartSpace, chart.spec, sheetNameById);
+    // `<c:roundedCorners val="1"/>` lives at the chartSpace root (sibling
+    // of `<c:chart>`). Default per OOXML §21.2.2.183 is `false`; only
+    // emit when the spec opted in so files imported without the element
+    // round-trip cleanly without gaining a spurious one.
+    if (chart.spec.roundedCorners) {
+        chartSpace["c:chartSpace"]["c:roundedCorners"] = { a$: { val: "1" } };
+    }
+    var xml = chartBuilder.build(chartSpace);
+    return "".concat(XML_DECLARATION).concat(xml);
+};
+// -------------------------- Phase 5 helpers --------------------------
+var LEGEND_POS = {
+    top: "t",
+    bottom: "b",
+    left: "l",
+    right: "r",
+    topRight: "tr",
+};
+var DLBL_POS = {
+    center: "ctr",
+    inside: "inBase",
+    outside: "outEnd",
+    insideEnd: "inEnd",
+    outsideEnd: "outEnd",
+    bestFit: "bestFit",
+};
+var applyChartFormatting = function (chartSpace, spec, sheetNameById) {
+    var _a;
+    var chartNode = (_a = chartSpace === null || chartSpace === void 0 ? void 0 : chartSpace["c:chartSpace"]) === null || _a === void 0 ? void 0 : _a["c:chart"];
+    if (!chartNode)
+        return;
+    applyLegend(chartNode, spec === null || spec === void 0 ? void 0 : spec.legend);
+    var plotArea = chartNode["c:plotArea"];
+    if (!plotArea)
+        return;
+    applyDataLabels(plotArea, spec === null || spec === void 0 ? void 0 : spec.dataLabels);
+    applyAxisOptions(plotArea, spec === null || spec === void 0 ? void 0 : spec.valueAxisOptions, "value");
+    applyAxisOptions(plotArea, spec === null || spec === void 0 ? void 0 : spec.categoryAxisOptions, "category");
+    applyDoughnutHole(plotArea, spec === null || spec === void 0 ? void 0 : spec.doughnutHoleSize);
+    applySeriesOverlays(plotArea, spec === null || spec === void 0 ? void 0 : spec.series, sheetNameById);
+    applySecondaryAxis(plotArea, spec === null || spec === void 0 ? void 0 : spec.secondaryValueAxisOptions);
+};
+var SERIES_CONTAINER_KEYS = [
+    "c:barChart",
+    "c:lineChart",
+    "c:pieChart",
+    "c:doughnutChart",
+    "c:areaChart",
+    "c:scatterChart",
+    "c:bubbleChart",
+];
+/**
+ * Walk the per-chart-type containers in plotArea and apply trendlines
+ * / errBars to each emitted `<c:ser>`. The series order in spec.series
+ * matches the order emitted by the builder, so we index by position.
+ */
+var applySeriesOverlays = function (plotArea, series, sheetNameById) {
+    var e_6, _a, e_7, _b;
+    if (!Array.isArray(series) || !series.length)
+        return;
+    var seriesIndex = 0;
+    try {
+        for (var SERIES_CONTAINER_KEYS_1 = __values(SERIES_CONTAINER_KEYS), SERIES_CONTAINER_KEYS_1_1 = SERIES_CONTAINER_KEYS_1.next(); !SERIES_CONTAINER_KEYS_1_1.done; SERIES_CONTAINER_KEYS_1_1 = SERIES_CONTAINER_KEYS_1.next()) {
+            var key = SERIES_CONTAINER_KEYS_1_1.value;
+            var container = plotArea[key];
+            if (!container)
+                continue;
+            var ser = container["c:ser"];
+            if (!ser)
+                continue;
+            var list = Array.isArray(ser) ? ser : [ser];
+            try {
+                for (var list_1 = (e_7 = void 0, __values(list)), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                    var node = list_1_1.value;
+                    var data = series[seriesIndex++];
+                    if (!data)
+                        continue;
+                    if (Array.isArray(data.trendlines) && data.trendlines.length) {
+                        var built = data.trendlines
+                            .map(buildTrendlineNode)
+                            .filter(Boolean);
+                        // OOXML allows multiple <c:trendline> on a series; preserve the
+                        // order from the spec.
+                        node["c:trendline"] = built.length === 1 ? built[0] : built;
+                    }
+                    if (data.errorBars) {
+                        var built = buildErrorBarsNode(data.errorBars, sheetNameById);
+                        if (built)
+                            node["c:errBars"] = built;
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (list_1_1 && !list_1_1.done && (_b = list_1.return)) _b.call(list_1);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (SERIES_CONTAINER_KEYS_1_1 && !SERIES_CONTAINER_KEYS_1_1.done && (_a = SERIES_CONTAINER_KEYS_1.return)) _a.call(SERIES_CONTAINER_KEYS_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+};
+var buildTrendlineNode = function (t) {
+    var _a;
+    if (!t)
+        return undefined;
+    var node = {};
+    if (t.name) {
+        node["c:name"] = { t$: String(t.name) };
+    }
+    // <c:trendlineType val="linear|exp|log|poly|power|movingAvg"/>
+    node["c:trendlineType"] = {
+        a$: { val: (_a = t.type) !== null && _a !== void 0 ? _a : "linear" },
+    };
+    if (t.type === "poly" && typeof t.order === "number") {
+        node["c:order"] = { a$: { val: String(t.order) } };
+    }
+    if (t.type === "movingAvg" && typeof t.period === "number") {
+        node["c:period"] = { a$: { val: String(t.period) } };
+    }
+    if (typeof t.forecastForward === "number") {
+        node["c:forward"] = { a$: { val: String(t.forecastForward) } };
+    }
+    if (typeof t.forecastBackward === "number") {
+        node["c:backward"] = { a$: { val: String(t.forecastBackward) } };
+    }
+    if (t.showEquation) {
+        node["c:dispEq"] = { a$: { val: "1" } };
+    }
+    if (t.showRSquared) {
+        node["c:dispRSqr"] = { a$: { val: "1" } };
+    }
+    return node;
+};
+var buildErrorBarsNode = function (eb, sheetNameById) {
+    var _a, _b, _c;
+    if (!eb)
+        return undefined;
+    var node = {};
+    if (eb.direction === "x" || eb.direction === "y") {
+        node["c:errDir"] = { a$: { val: eb.direction } };
+    }
+    node["c:errBarType"] = { a$: { val: (_a = eb.barType) !== null && _a !== void 0 ? _a : "both" } };
+    var valueType = eb.valueType === "custom" ? "cust" : eb.valueType;
+    node["c:errValType"] = { a$: { val: valueType !== null && valueType !== void 0 ? valueType : "fixedVal" } };
+    if (eb.noEndCap) {
+        node["c:noEndCap"] = { a$: { val: "1" } };
+    }
+    // Custom error bars — per-point magnitudes come from worksheet
+    // ranges emitted as `<c:plus>/<c:minus>` numRefs. Schema order puts
+    // them after noEndCap and before `<c:val>`.
+    if (valueType === "cust") {
+        var plusRef = formatRangeRef((_b = eb.plusRange) !== null && _b !== void 0 ? _b : undefined, sheetNameById);
+        var minusRef = formatRangeRef((_c = eb.minusRange) !== null && _c !== void 0 ? _c : undefined, sheetNameById);
+        if (plusRef) {
+            node["c:plus"] = { "c:numRef": { "c:f": plusRef } };
+        }
+        if (minusRef) {
+            node["c:minus"] = { "c:numRef": { "c:f": minusRef } };
+        }
+    }
+    if (typeof eb.value === "number") {
+        node["c:val"] = { a$: { val: String(eb.value) } };
+    }
+    return node;
+};
+/**
+ * Add a secondary `<c:valAx>` next to the primary one when the spec
+ * carries `secondaryValueAxisOptions`. We give it a distinct axId
+ * (existing primary axId + 100) — series-level routing to the new axis
+ * is intentionally not wired up here (most consumers of "secondary
+ * axis" only care about the data round-trip; full charting fidelity
+ * lands in a follow-up).
+ */
+var applySecondaryAxis = function (plotArea, opts) {
+    var _a, _b, _c;
+    if (!opts)
+        return;
+    var existing = plotArea["c:valAx"];
+    if (!existing)
+        return;
+    var existingArr = Array.isArray(existing) ? existing : [existing];
+    if (existingArr.length >= 2)
+        return; // already has secondary
+    var primary = existingArr[0];
+    var primaryAxId = parseInt(((_c = (_b = (_a = primary === null || primary === void 0 ? void 0 : primary["c:axId"]) === null || _a === void 0 ? void 0 : _a.a$) === null || _b === void 0 ? void 0 : _b.val) !== null && _c !== void 0 ? _c : "1000"), 10);
+    var secondary = {
+        "c:axId": { a$: { val: String(primaryAxId + 100) } },
+        "c:scaling": { "c:orientation": { a$: { val: "minMax" } } },
+        "c:delete": { a$: { val: "0" } },
+        "c:axPos": { a$: { val: "r" } },
+        "c:crossAx": { a$: { val: String(primaryAxId) } },
+    };
+    // Apply the same logarithmic / reverse / min / max / gridlines etc.
+    applyAxisOptions({ "c:valAx": secondary }, opts, "value");
+    plotArea["c:valAx"] = __spreadArray(__spreadArray([], __read(existingArr), false), [secondary], false);
+};
+var applyLegend = function (chartNode, legend) {
+    var _a;
+    if (!legend)
+        return;
+    if (legend.position === "none") {
+        // Excel omits <c:legend> entirely when hidden; some readers expect
+        // an explicit <c:legend><c:delete val="1"/> instead. Use the
+        // explicit form so the suppression survives ANY reader.
+        chartNode["c:legend"] = {
+            "c:delete": { a$: { val: "1" } },
+        };
+        return;
+    }
+    var posCode = LEGEND_POS[legend.position];
+    var txPr = buildTxPrNode(legend.textFormat);
+    if (!posCode) {
+        // No explicit position — just ensure the legend element exists,
+        // attach text formatting if authored.
+        var existing = (_a = chartNode["c:legend"]) !== null && _a !== void 0 ? _a : {};
+        if (txPr)
+            existing["c:txPr"] = txPr;
+        chartNode["c:legend"] = existing;
+        return;
+    }
+    chartNode["c:legend"] = __assign({ "c:legendPos": { a$: { val: posCode } }, "c:overlay": { a$: { val: "0" } } }, (txPr ? { "c:txPr": txPr } : {}));
+};
+var applyDataLabels = function (plotArea, dataLabels) {
+    if (!(dataLabels === null || dataLabels === void 0 ? void 0 : dataLabels.show))
+        return;
+    // Find the chart-type container inside <c:plotArea>. We attach <c:dLbls>
+    // to whichever exists.
+    var containerKey = [
+        "c:barChart",
+        "c:lineChart",
+        "c:pieChart",
+        "c:doughnutChart",
+        "c:areaChart",
+    ].find(function (k) { return plotArea[k]; });
+    if (!containerKey)
+        return;
+    var container = plotArea[containerKey];
+    var posCode = dataLabels.position && DLBL_POS[dataLabels.position];
+    var dLbls = {};
+    if (posCode)
+        dLbls["c:dLblPos"] = { a$: { val: posCode } };
+    // <c:numFmt> — emit before the show* flags. Excel reads this to
+    // format the label value (e.g. `"$"#,##0` → "$1,831").
+    if (dataLabels.numberFormatPattern) {
+        dLbls["c:numFmt"] = {
+            a$: {
+                formatCode: dataLabels.numberFormatPattern,
+                sourceLinked: "0",
+            },
+        };
+    }
+    // <c:txPr> — authored color / font / bold for the label text.
+    var txPr = buildTxPrNode(dataLabels.textFormat);
+    if (txPr)
+        dLbls["c:txPr"] = txPr;
+    // OOXML requires explicit boolean flags. When none of show* are set,
+    // default to showVal=1 since that's Excel's default for "Show Labels".
+    var showValue = dataLabels.showValue === undefined
+        ? !dataLabels.showCategoryName &&
+            !dataLabels.showPercent &&
+            !dataLabels.showSeriesName
+        : !!dataLabels.showValue;
+    dLbls["c:showLegendKey"] = { a$: { val: "0" } };
+    dLbls["c:showVal"] = { a$: { val: showValue ? "1" : "0" } };
+    dLbls["c:showCatName"] = {
+        a$: { val: dataLabels.showCategoryName ? "1" : "0" },
+    };
+    dLbls["c:showSerName"] = {
+        a$: { val: dataLabels.showSeriesName ? "1" : "0" },
+    };
+    dLbls["c:showPercent"] = {
+        a$: { val: dataLabels.showPercent ? "1" : "0" },
+    };
+    dLbls["c:showBubbleSize"] = { a$: { val: "0" } };
+    container["c:dLbls"] = dLbls;
+};
+var applyAxisOptions = function (plotArea, options, kind) {
+    var _a;
+    if (!options)
+        return;
+    var axisKey = kind === "value" ? "c:valAx" : "c:catAx";
+    var ax = plotArea[axisKey];
+    if (!ax)
+        return;
+    // OOXML can carry multiple axes (e.g. primary + secondary). Target the
+    // first one for now — secondary axes ship in Phase 5.2.
+    var node = Array.isArray(ax) ? ax[0] : ax;
+    var scaling = (node["c:scaling"] = (_a = node["c:scaling"]) !== null && _a !== void 0 ? _a : {});
+    if (options.logarithmic) {
+        scaling["c:logBase"] = { a$: { val: "10" } };
+    }
+    if (options.reverse) {
+        scaling["c:orientation"] = { a$: { val: "maxMin" } };
+    }
+    if (typeof options.min === "number") {
+        scaling["c:min"] = { a$: { val: String(options.min) } };
+    }
+    if (typeof options.max === "number") {
+        scaling["c:max"] = { a$: { val: String(options.max) } };
+    }
+    if (options.visible === false) {
+        node["c:delete"] = { a$: { val: "1" } };
+    }
+    if (options.showMajorGridlines === true && !node["c:majorGridlines"]) {
+        node["c:majorGridlines"] = {};
+    }
+    if (options.showMajorGridlines === false && node["c:majorGridlines"]) {
+        delete node["c:majorGridlines"];
+    }
+    // <c:txPr> — axis tick-label color/font. Without this, exported
+    // axes would render with the default theme color instead of the
+    // authored one (BEP.xlsx axis colors #14325A / #F0621C).
+    var txPr = buildTxPrNode(options.textFormat);
+    if (txPr)
+        node["c:txPr"] = txPr;
+};
+var applyDoughnutHole = function (plotArea, holeSize) {
+    if (typeof holeSize !== "number")
+        return;
+    var doughnut = plotArea["c:doughnutChart"];
+    if (!doughnut)
+        return;
+    // Convert 0-1 fraction back to OOXML's 0-90 percentage.
+    var pct = Math.round(Math.max(0, Math.min(0.9, holeSize)) * 100);
+    doughnut["c:holeSize"] = { a$: { val: String(pct) } };
+};