pptx-viewer-core 1.1.32 → 1.1.33

package/dist/index.js

@@ -1584,8 +1584,8 @@ var DEFAULT_COLORS = {
 };
 var DEFAULT_MAJOR_FONT = "Calibri Light";
 var DEFAULT_MINOR_FONT = "Calibri";
-function hexToRgb(hex7) {
-  return hex7.replace(/^#/, "").toUpperCase();
+function hexToRgb(hex8) {
+  return hex8.replace(/^#/, "").toUpperCase();
 }
 function isoNow() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
@@ -4258,8 +4258,8 @@ var PptxColorTransformCodec = class {
   clampUnitInterval(value) {
     return Math.min(1, Math.max(0, value));
   }
-  hexToRgb(hex7) {
-    const normalized = hex7.replace("#", "");
+  hexToRgb(hex8) {
+    const normalized = hex8.replace("#", "");
     if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
       return void 0;
     }
@@ -5769,7 +5769,7 @@ var PptxColorStyleCodec = class {
       parseColor: (colorNode, placeholderColor) => this.parseColor(colorNode, placeholderColor),
       extractColorOpacity: (colorNode) => this.extractColorOpacity(colorNode),
       clampUnitInterval: (value) => this.clampUnitInterval(value),
-      hexToRgb: (hex7) => this.hexToRgb(hex7),
+      hexToRgb: (hex8) => this.hexToRgb(hex8),
       rgbToHex: (r, g, b) => this.rgbToHex(r, g, b)
     });
     this.shapeEffectXmlCodec = new PptxShapeEffectXmlCodec({
@@ -5792,8 +5792,8 @@ var PptxColorStyleCodec = class {
   clampUnitInterval(value) {
     return this.colorTransformCodec.clampUnitInterval(value);
   }
-  hexToRgb(hex7) {
-    return this.colorTransformCodec.hexToRgb(hex7);
+  hexToRgb(hex8) {
+    return this.colorTransformCodec.hexToRgb(hex8);
   }
   rgbToHex(r, g, b) {
     return this.colorTransformCodec.rgbToHex(r, g, b);
@@ -5964,9 +5964,9 @@ function normalizeHex(value) {
   if (raw.length === 0) {
     return "";
   }
-  const hex7 = raw.replace(/^#/, "");
-  if (/^[0-9a-fA-F]{6}$/.test(hex7)) {
-    return hex7.toUpperCase();
+  const hex8 = raw.replace(/^#/, "");
+  if (/^[0-9a-fA-F]{6}$/.test(hex8)) {
+    return hex8.toUpperCase();
   }
   return raw.toLowerCase();
 }
@@ -5976,8 +5976,8 @@ function colorsEqual(left, right) {
   }
   return normalizeHex(left) === normalizeHex(right);
 }
-function buildSrgbColorChoice(hex7, opacity) {
-  const normalized = String(hex7 || "").replace(/^#/, "");
+function buildSrgbColorChoice(hex8, opacity) {
+  const normalized = String(hex8 || "").replace(/^#/, "");
   const srgb = { "@_val": normalized };
   if (typeof opacity === "number" && Number.isFinite(opacity) && opacity >= 0 && opacity < 1) {
     const alphaPct = Math.round(Math.max(0, Math.min(1, opacity)) * 1e5);
@@ -9489,9 +9489,9 @@ function decodeKeyframeValue(valNode) {
   if (strVal && strVal["@_val"] !== void 0) {
     return { value: String(strVal["@_val"]), valueType: "str" };
   }
-  const boolVal2 = valNode["p:boolVal"];
-  if (boolVal2 && boolVal2["@_val"] !== void 0) {
-    const raw = boolVal2["@_val"];
+  const boolVal3 = valNode["p:boolVal"];
+  if (boolVal3 && boolVal3["@_val"] !== void 0) {
+    const raw = boolVal3["@_val"];
     const value = raw === "1" || raw === "true";
     return { value, valueType: "bool" };
   }
@@ -12737,13 +12737,13 @@ function generateFontGuid() {
       bytes[i] = Math.floor(Math.random() * 256);
     }
   }
-  const hex7 = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
+  const hex8 = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
   return [
-    hex7.substring(0, 8),
-    hex7.substring(8, 12),
-    hex7.substring(12, 16),
-    hex7.substring(16, 20),
-    hex7.substring(20, 32)
+    hex8.substring(0, 8),
+    hex8.substring(8, 12),
+    hex8.substring(12, 16),
+    hex8.substring(16, 20),
+    hex8.substring(20, 32)
   ].join("-");
 }
 function detectFontFormat(data) {
@@ -13064,7 +13064,8 @@ function parseSeriesDataPoints(seriesNode, xmlLookup, colorParser) {
   }).filter((dp) => dp !== void 0);
 }
 function parseSeriesDataLabels(seriesNode, xmlLookup) {
-  const dLblNodes = xmlLookup.getChildrenArrayByLocalName(seriesNode, "dLbl");
+  const dLblsNode = xmlLookup.getChildByLocalName(seriesNode, "dLbls");
+  const dLblNodes = dLblsNode ? xmlLookup.getChildrenArrayByLocalName(dLblsNode, "dLbl") : xmlLookup.getChildrenArrayByLocalName(seriesNode, "dLbl");
   if (dLblNodes.length === 0) {
     return [];
   }
@@ -13074,6 +13075,10 @@ function parseSeriesDataLabels(seriesNode, xmlLookup) {
     if (idx === void 0) {
       return void 0;
     }
+    const deleteNode = xmlLookup.getChildByLocalName(node, "delete");
+    if (deleteNode?.["@_val"] === "1" || deleteNode?.["@_val"] === "true") {
+      return { idx };
+    }
     const result = { idx };
     const boolFields = [
       ["showVal", "showVal"],
@@ -13421,6 +13426,29 @@ function collectAxisTextValues(node, results) {
   }
 }
 
+// src/core/utils/chart-container-type-map.ts
+var CONTAINER_LOCAL_NAME_TO_TYPE = {
+  barChart: "bar",
+  bar3DChart: "bar3D",
+  lineChart: "line",
+  line3DChart: "line3D",
+  pieChart: "pie",
+  pie3DChart: "pie3D",
+  ofPieChart: "ofPie",
+  doughnutChart: "doughnut",
+  areaChart: "area",
+  area3DChart: "area3D",
+  scatterChart: "scatter",
+  bubbleChart: "bubble",
+  radarChart: "radar",
+  stockChart: "stock",
+  surfaceChart: "surface",
+  surface3DChart: "surface"
+};
+function chartContainerLocalNameToType(localName) {
+  return CONTAINER_LOCAL_NAME_TO_TYPE[localName];
+}
+
 // src/core/utils/chart-cx-parser.ts
 function extractCxSeriesColor(ser, xmlLookup) {
   const spPr = xmlLookup.getChildByLocalName(ser, "spPr");
@@ -15176,10 +15204,10 @@ function applyBackgroundColorToCSld(cSld, backgroundColor) {
     delete cSld["p:bg"];
     return;
   }
-  const hex7 = backgroundColor.replace(/^#/, "").toUpperCase();
+  const hex8 = backgroundColor.replace(/^#/, "").toUpperCase();
   cSld["p:bg"] = {
     "p:bgPr": {
-      "a:solidFill": { "a:srgbClr": { "@_val": hex7 } },
+      "a:solidFill": { "a:srgbClr": { "@_val": hex8 } },
       "a:effectLst": {}
     }
   };
@@ -15802,8 +15830,8 @@ function accentColor(index, themeColorMap) {
   }
   return DEFAULT_ACCENT_COLORS[index % DEFAULT_ACCENT_COLORS.length];
 }
-function lighten(hex7, amount) {
-  const parsed = hex7.replace("#", "");
+function lighten(hex8, amount) {
+  const parsed = hex8.replace("#", "");
   const r = parseInt(parsed.substring(0, 2), 16);
   const g = parseInt(parsed.substring(2, 4), 16);
   const b = parseInt(parsed.substring(4, 6), 16);
@@ -21418,11 +21446,11 @@ async function repairPptx(buffer) {
 }
 
 // src/core/utils/theme-switching.ts
-function normalizeHex2(hex7) {
-  if (!hex7) {
+function normalizeHex2(hex8) {
+  if (!hex8) {
     return "";
   }
-  return hex7.replace(/^#/, "").toUpperCase().slice(0, 6);
+  return hex8.replace(/^#/, "").toUpperCase().slice(0, 6);
 }
 function buildColorRemapTable(oldColorMap, newColorMap) {
   const remap = /* @__PURE__ */ new Map();
@@ -21616,8 +21644,8 @@ function applyThemeToData(data, newColorScheme, newFontScheme, themeName) {
 }
 
 // src/core/utils/accessibility-checker.ts
-function parseHexColor(hex7) {
-  const cleaned = hex7.replace(/^#/, "");
+function parseHexColor(hex8) {
+  const cleaned = hex8.replace(/^#/, "");
   if (!/^[\da-fA-F]+$/.test(cleaned)) {
     return null;
   }
@@ -24917,6 +24945,37 @@ function ensureArray6(v) {
   }
   return Array.isArray(v) ? v : [v];
 }
+function consolidateComboContainersInXml(plotArea, getLocalName) {
+  const containerKeys = Object.keys(plotArea).filter((k) => getLocalName(k).endsWith("Chart"));
+  if (containerKeys.length === 0) {
+    return void 0;
+  }
+  const primaryKey = containerKeys[0];
+  if (containerKeys.length === 1) {
+    return primaryKey;
+  }
+  const primary = plotArea[primaryKey];
+  if (!primary) {
+    return primaryKey;
+  }
+  const serKey = findKey4(primary, "ser", getLocalName) ?? "c:ser";
+  const allSeries = [];
+  for (const key of containerKeys) {
+    const container = plotArea[key];
+    if (!container) {
+      continue;
+    }
+    const containerSerKey = findKey4(container, "ser", getLocalName);
+    if (containerSerKey) {
+      allSeries.push(...ensureArray6(container[containerSerKey]));
+    }
+    if (key !== primaryKey) {
+      delete plotArea[key];
+    }
+  }
+  primary[serKey] = allSeries.length === 1 ? allSeries[0] : allSeries;
+  return primaryKey;
+}
 function effectiveContainers(series, chartLevelType) {
   return series.map((s) => {
     const t = s.seriesChartType ?? chartLevelType;
@@ -25368,6 +25427,146 @@ function applySeriesMarkerToXml(seriesNode, marker, getLocalName) {
   insertOrdered2(seriesNode, "c:marker", built, getLocalName);
 }
 
+// src/core/utils/chart-series-datalabel-serializer.ts
+function findKey9(obj, local, getLocalName) {
+  return Object.keys(obj).find((k) => getLocalName(k) === local);
+}
+function boolVal2(on) {
+  return { "@_val": on ? "1" : "0" };
+}
+var AFTER_DLBLS = /* @__PURE__ */ new Set(["cat", "val", "xVal", "yVal", "bubbleSize", "smooth", "extLst"]);
+var DLBLS_GROUP_ORDER = [
+  "numFmt",
+  "spPr",
+  "txPr",
+  "dLblPos",
+  "showLegendKey",
+  "showVal",
+  "showCatName",
+  "showSerName",
+  "showPercent",
+  "showBubbleSize",
+  "separator",
+  "showLeaderLines",
+  "leaderLines"
+];
+function buildDLbl(existing, label, getLocalName) {
+  const node = {};
+  node["c:idx"] = { "@_val": String(label.idx) };
+  const hasShow = label.showVal !== void 0 || label.showCatName !== void 0 || label.showSerName !== void 0 || label.showPercent !== void 0 || label.showLegendKey !== void 0 || label.showBubbleSize !== void 0;
+  const hasContent = hasShow || label.position !== void 0 || label.text !== void 0;
+  if (!hasContent) {
+    node["c:delete"] = { "@_val": "1" };
+    return node;
+  }
+  if (existing) {
+    const layoutKey = findKey9(existing, "layout", getLocalName);
+    if (layoutKey) {
+      node[layoutKey] = existing[layoutKey];
+    }
+  }
+  if (label.text !== void 0) {
+    node["c:tx"] = {
+      "c:rich": {
+        "a:bodyPr": {},
+        "a:lstStyle": {},
+        "a:p": { "a:r": { "a:t": label.text } }
+      }
+    };
+  } else if (existing) {
+    const txKey = findKey9(existing, "tx", getLocalName);
+    if (txKey) {
+      node[txKey] = existing[txKey];
+    }
+  }
+  if (existing) {
+    for (const local of ["numFmt", "spPr", "txPr"]) {
+      const k = findKey9(existing, local, getLocalName);
+      if (k) {
+        node[k] = existing[k];
+      }
+    }
+  }
+  if (label.position !== void 0) {
+    node["c:dLblPos"] = { "@_val": label.position };
+  }
+  if (label.showLegendKey !== void 0) {
+    node["c:showLegendKey"] = boolVal2(label.showLegendKey);
+  }
+  if (label.showVal !== void 0) {
+    node["c:showVal"] = boolVal2(label.showVal);
+  }
+  if (label.showCatName !== void 0) {
+    node["c:showCatName"] = boolVal2(label.showCatName);
+  }
+  if (label.showSerName !== void 0) {
+    node["c:showSerName"] = boolVal2(label.showSerName);
+  }
+  if (label.showPercent !== void 0) {
+    node["c:showPercent"] = boolVal2(label.showPercent);
+  }
+  if (label.showBubbleSize !== void 0) {
+    node["c:showBubbleSize"] = boolVal2(label.showBubbleSize);
+  }
+  return node;
+}
+function applySeriesDataLabelsToXml(seriesNode, dataLabels, getLocalName) {
+  const dLblsKey = findKey9(seriesNode, "dLbls", getLocalName);
+  const labels = dataLabels ?? [];
+  const existingByIdx = /* @__PURE__ */ new Map();
+  let groupChildren = [];
+  if (dLblsKey) {
+    const dLbls = seriesNode[dLblsKey];
+    const dLblKey = findKey9(dLbls, "dLbl", getLocalName);
+    if (dLblKey) {
+      const nodes = Array.isArray(dLbls[dLblKey]) ? dLbls[dLblKey] : [dLbls[dLblKey]];
+      for (const node of nodes) {
+        const idxKey = findKey9(node, "idx", getLocalName);
+        const idxNode = idxKey ? node[idxKey] : void 0;
+        const idx = idxNode ? Number.parseInt(String(idxNode["@_val"]), 10) : NaN;
+        if (Number.isFinite(idx)) {
+          existingByIdx.set(idx, node);
+        }
+      }
+    }
+    groupChildren = Object.keys(dLbls).filter((k) => getLocalName(k) !== "dLbl").map((k) => [k, dLbls[k]]);
+  }
+  if (labels.length === 0 && groupChildren.length === 0) {
+    if (dLblsKey) {
+      delete seriesNode[dLblsKey];
+    }
+    return;
+  }
+  const built = [...labels].sort((a, b) => a.idx - b.idx).map((label) => buildDLbl(existingByIdx.get(label.idx), label, getLocalName));
+  const newDLbls = {};
+  if (built.length > 0) {
+    newDLbls["c:dLbl"] = built.length === 1 ? built[0] : built;
+  }
+  const ordered = [...groupChildren].sort((a, b) => {
+    const ai = DLBLS_GROUP_ORDER.indexOf(getLocalName(a[0]));
+    const bi = DLBLS_GROUP_ORDER.indexOf(getLocalName(b[0]));
+    return (ai === -1 ? DLBLS_GROUP_ORDER.length : ai) - (bi === -1 ? DLBLS_GROUP_ORDER.length : bi);
+  });
+  for (const [k, v] of ordered) {
+    newDLbls[k] = v;
+  }
+  if (dLblsKey) {
+    seriesNode[dLblsKey] = newDLbls;
+    return;
+  }
+  const keys = Object.keys(seriesNode);
+  const beforeIdx = keys.findIndex((k) => AFTER_DLBLS.has(getLocalName(k)));
+  const entries = keys.map((k) => [k, seriesNode[k]]);
+  const at = beforeIdx === -1 ? entries.length : beforeIdx;
+  entries.splice(at, 0, ["c:dLbls", newDLbls]);
+  for (const k of keys) {
+    delete seriesNode[k];
+  }
+  for (const [k, v] of entries) {
+    seriesNode[k] = v;
+  }
+}
+
 // src/core/utils/chart-trendline-serializer.ts
 var TYPE_TO_OOXML = {
   linear: "linear",
@@ -25377,7 +25576,7 @@ var TYPE_TO_OOXML = {
   power: "power",
   movingAvg: "movingAvg"
 };
-function findKey9(obj, local, getLocalName) {
+function findKey10(obj, local, getLocalName) {
   return Object.keys(obj).find((k) => getLocalName(k) === local);
 }
 function ensureArray9(v) {
@@ -25394,10 +25593,10 @@ function buildSpPr(existing, color, getLocalName) {
     return existing;
   }
   const spPr = existing ? { ...existing } : {};
-  const lnKey = findKey9(spPr, "ln", getLocalName) ?? "a:ln";
+  const lnKey = findKey10(spPr, "ln", getLocalName) ?? "a:ln";
   const existingLn = spPr[lnKey] ?? {};
-  const fillKey = findKey9(existingLn, "solidFill", getLocalName) ?? "a:solidFill";
-  const noFillKey = findKey9(existingLn, "noFill", getLocalName);
+  const fillKey = findKey10(existingLn, "solidFill", getLocalName) ?? "a:solidFill";
+  const noFillKey = findKey10(existingLn, "noFill", getLocalName);
   const ln = { ...existingLn };
   if (noFillKey) {
     delete ln[noFillKey];
@@ -25409,13 +25608,13 @@ function buildSpPr(existing, color, getLocalName) {
 function buildTrendline(existing, t, getLocalName) {
   const node = {};
   if (existing) {
-    const nameKey = findKey9(existing, "name", getLocalName);
+    const nameKey = findKey10(existing, "name", getLocalName);
     if (nameKey) {
       node["c:name"] = existing[nameKey];
     }
   }
   const spPr = buildSpPr(
-    existing ? existing[findKey9(existing, "spPr", getLocalName) ?? ""] : void 0,
+    existing ? existing[findKey10(existing, "spPr", getLocalName) ?? ""] : void 0,
     t.color,
     getLocalName
   );
@@ -25445,7 +25644,7 @@ function buildTrendline(existing, t, getLocalName) {
     node["c:dispEq"] = { "@_val": "1" };
   }
   if (existing) {
-    const lblKey = findKey9(existing, "trendlineLbl", getLocalName);
+    const lblKey = findKey10(existing, "trendlineLbl", getLocalName);
     if (lblKey) {
       node["c:trendlineLbl"] = existing[lblKey];
     }
@@ -25453,7 +25652,7 @@ function buildTrendline(existing, t, getLocalName) {
   return node;
 }
 function applySeriesTrendlinesToXml(seriesNode, trendlines, getLocalName) {
-  const existingKey = findKey9(seriesNode, "trendline", getLocalName);
+  const existingKey = findKey10(seriesNode, "trendline", getLocalName);
   const existingNodes = existingKey ? ensureArray9(seriesNode[existingKey]) : [];
   const built = trendlines.map((t, i) => buildTrendline(existingNodes[i], t, getLocalName));
   if (existingKey) {
@@ -28663,8 +28862,8 @@ function buildTextRunEffectListXml(style) {
   }
   return effectLst;
 }
-function buildShadowColorNode(hex7, opacity) {
-  const clr = hex7.replace("#", "");
+function buildShadowColorNode(hex8, opacity) {
+  const clr = hex8.replace("#", "");
   const alpha = typeof opacity === "number" ? Math.round(opacity * 1e5) : void 0;
   return {
     "@_val": clr,
@@ -31907,8 +32106,8 @@ function updateCellTextStyleInRawXml(element, rowIndex, colIndex, styleUpdates)
         }
       }
       if ("color" in styleUpdates && typeof styleUpdates.color === "string") {
-        const hex7 = styleUpdates.color.replace("#", "");
-        rPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex7 } };
+        const hex8 = styleUpdates.color.replace("#", "");
+        rPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex8 } };
       }
       if ("align" in styleUpdates) {
         const pPr = paragraph["a:pPr"] ?? {};
@@ -31948,8 +32147,8 @@ function updateCellTextStyleInRawXml(element, rowIndex, colIndex, styleUpdates)
         }
       }
       if ("color" in styleUpdates && typeof styleUpdates.color === "string") {
-        const hex7 = styleUpdates.color.replace("#", "");
-        endRPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex7 } };
+        const hex8 = styleUpdates.color.replace("#", "");
+        endRPr["a:solidFill"] = { "a:srgbClr": { "@_val": hex8 } };
       }
     }
   }
@@ -32228,6 +32427,10 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
         if (!plotArea) {
           continue;
         }
+        consolidateComboContainersInXml(
+          plotArea,
+          (key) => this.compatibilityService.getXmlLocalName(key)
+        );
         let chartTypeKey = Object.keys(plotArea).find(
           (key) => this.compatibilityService.getXmlLocalName(key).endsWith("Chart")
         );
@@ -32290,19 +32493,19 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
             this.updateChartCacheValues(valNode, true, seriesData.values.map(String));
           }
           if (seriesData.color) {
-            const hex7 = seriesData.color.replace("#", "");
+            const hex8 = seriesData.color.replace("#", "");
             const spPr = this.xmlLookupService.getChildByLocalName(seriesNode, "spPr");
             if (spPr) {
               const solidFillKey = Object.keys(spPr).find(
                 (k) => this.compatibilityService.getXmlLocalName(k) === "solidFill"
               ) ?? "a:solidFill";
-              spPr[solidFillKey] = { "a:srgbClr": { "@_val": hex7 } };
+              spPr[solidFillKey] = { "a:srgbClr": { "@_val": hex8 } };
             } else {
               const spPrKey = Object.keys(seriesNode).find(
                 (k) => this.compatibilityService.getXmlLocalName(k) === "spPr"
               ) ?? "c:spPr";
               seriesNode[spPrKey] = {
-                "a:solidFill": { "a:srgbClr": { "@_val": hex7 } }
+                "a:solidFill": { "a:srgbClr": { "@_val": hex8 } }
               };
             }
           }
@@ -32334,6 +32537,13 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
               (key) => this.compatibilityService.getXmlLocalName(key)
             );
           }
+          if (seriesData.dataLabels !== void 0) {
+            applySeriesDataLabelsToXml(
+              seriesNode,
+              seriesData.dataLabels,
+              (key) => this.compatibilityService.getXmlLocalName(key)
+            );
+          }
         }
         if (chartData.series.length > seriesNodes.length) {
           const templateSeries = seriesNodes.length > 0 ? seriesNodes[seriesNodes.length - 1] : void 0;
@@ -32863,36 +33073,131 @@ var PptxHandlerRuntime23 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
   }
 };
 
-// src/core/core/runtime/smartart-save-chrome.ts
+// src/core/core/runtime/smartart-colors-builder.ts
 function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => Boolean(asObject(entry)));
+  }
+  const obj = asObject(value);
+  return obj ? [obj] : [];
+}
+function findKey11(obj, name, getLocalName) {
+  return Object.keys(obj).find((k) => getLocalName(k) === name);
+}
+function hex7(value) {
+  return value.replace("#", "");
+}
+var COLOR_LOCAL_NAMES = /* @__PURE__ */ new Set([
+  "srgbClr",
+  "schemeClr",
+  "sysClr",
+  "prstClr",
+  "scrgbClr",
+  "hslClr"
+]);
+function applyColorToList(list, value, getLocalName) {
+  const colorKey = Object.keys(list).find((k) => COLOR_LOCAL_NAMES.has(getLocalName(k)));
+  const srgb = { "@_val": hex7(value) };
+  if (!colorKey) {
+    list["a:srgbClr"] = srgb;
+    return;
+  }
+  const existing = list[colorKey];
+  const rest = Array.isArray(existing) ? existing.slice(1).filter((entry) => Boolean(asObject(entry))) : [];
+  if (colorKey !== "a:srgbClr") {
+    delete list[colorKey];
+  }
+  list["a:srgbClr"] = rest.length > 0 ? [srgb, ...rest] : srgb;
+}
+function applySmartArtColorTransform(colorsDef, transform, getLocalName) {
+  if (!transform) {
+    return false;
+  }
+  let mutated = false;
+  if (transform.name && transform.name.length > 0) {
+    if (colorsDef["@_title"] !== transform.name) {
+      colorsDef["@_title"] = transform.name;
+      mutated = true;
+    }
+  }
+  const styleLblKey = findKey11(colorsDef, "styleLbl", getLocalName);
+  if (!styleLblKey) {
+    return mutated;
+  }
+  const labels = toArray(colorsDef[styleLblKey]);
+  if (labels.length === 0) {
+    return mutated;
+  }
+  let fillIndex = 0;
+  let lineIndex = 0;
+  for (const label of labels) {
+    const fillKey = findKey11(label, "fillClrLst", getLocalName);
+    if (fillKey) {
+      const value = transform.fillColors[fillIndex++];
+      const list = asObject(label[fillKey]);
+      if (list && value) {
+        applyColorToList(list, value, getLocalName);
+        mutated = true;
+      }
+    }
+    const lineKey = findKey11(label, "linClrLst", getLocalName);
+    if (lineKey) {
+      const value = transform.lineColors[lineIndex++];
+      const list = asObject(label[lineKey]);
+      if (list && value) {
+        applyColorToList(list, value, getLocalName);
+        mutated = true;
+      }
+    }
+  }
+  return mutated;
+}
+
+// src/core/core/runtime/smartart-quickstyle-builder.ts
+function applySmartArtQuickStyle(styleDef, quickStyle) {
+  if (!quickStyle || !quickStyle.name || quickStyle.name.length === 0) {
+    return false;
+  }
+  if (styleDef["@_title"] === quickStyle.name) {
+    return false;
+  }
+  styleDef["@_title"] = quickStyle.name;
+  return true;
+}
+
+// src/core/core/runtime/smartart-save-chrome.ts
+function asObject2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function applySmartArtChrome(dataModel, chrome, getLocalName) {
   if (!chrome || !chrome.backgroundColor && !chrome.outlineColor && (chrome.outlineWidth === null || chrome.outlineWidth === void 0)) {
     return;
   }
-  const findKey10 = (obj, name) => Object.keys(obj).find((k) => getLocalName(k) === name);
+  const findKey12 = (obj, name) => Object.keys(obj).find((k) => getLocalName(k) === name);
   if (chrome.backgroundColor) {
-    const hex7 = chrome.backgroundColor.replace("#", "");
-    const bgKey = findKey10(dataModel, "bg") ?? "dgm:bg";
-    const bg = asObject(dataModel[bgKey]);
-    const fillKey = findKey10(bg, "solidFill") ?? "a:solidFill";
-    bg[fillKey] = { "a:srgbClr": { "@_val": hex7 } };
+    const hex8 = chrome.backgroundColor.replace("#", "");
+    const bgKey = findKey12(dataModel, "bg") ?? "dgm:bg";
+    const bg = asObject2(dataModel[bgKey]);
+    const fillKey = findKey12(bg, "solidFill") ?? "a:solidFill";
+    bg[fillKey] = { "a:srgbClr": { "@_val": hex8 } };
     dataModel[bgKey] = bg;
   }
   const hasOutlineWidth = chrome.outlineWidth !== null && chrome.outlineWidth !== void 0;
   if (chrome.outlineColor || hasOutlineWidth) {
-    const wholeKey = findKey10(dataModel, "whole") ?? "dgm:whole";
-    const whole = asObject(dataModel[wholeKey]);
-    const lnKey = findKey10(whole, "ln") ?? "a:ln";
-    const ln = asObject(whole[lnKey]);
+    const wholeKey = findKey12(dataModel, "whole") ?? "dgm:whole";
+    const whole = asObject2(dataModel[wholeKey]);
+    const lnKey = findKey12(whole, "ln") ?? "a:ln";
+    const ln = asObject2(whole[lnKey]);
     if (hasOutlineWidth) {
       ln["@_w"] = String(Math.round(chrome.outlineWidth * 12700));
     }
     if (chrome.outlineColor) {
-      const hex7 = chrome.outlineColor.replace("#", "");
-      const fillKey = findKey10(ln, "solidFill") ?? "a:solidFill";
-      ln[fillKey] = { "a:srgbClr": { "@_val": hex7 } };
+      const hex8 = chrome.outlineColor.replace("#", "");
+      const fillKey = findKey12(ln, "solidFill") ?? "a:solidFill";
+      ln[fillKey] = { "a:srgbClr": { "@_val": hex8 } };
     }
     whole[lnKey] = ln;
     dataModel[wholeKey] = whole;
@@ -32927,10 +33232,56 @@ function buildPointText(text) {
     }
   };
 }
-function applyTextToExistingPoint(pt2, text) {
+function joinRunText(runs) {
+  return (runs ?? []).map((run) => run.text).join("");
+}
+function buildMultiRunParagraph(runs) {
+  const runObjects = runs.map((run) => {
+    const rObj = {};
+    rObj["a:rPr"] = run.rPr ?? { "@_lang": "en-US", "@_dirty": "0" };
+    rObj["a:t"] = run.text;
+    return rObj;
+  });
+  return { "a:r": runObjects.length === 1 ? runObjects[0] : runObjects };
+}
+function shouldRebuildFromRuns(node) {
+  const runs = node.runs;
+  if (!runs || runs.length === 0) {
+    return false;
+  }
+  const hasRichRun = runs.length > 1 || Boolean(runs[0]?.rPr);
+  if (!hasRichRun) {
+    return false;
+  }
+  return joinRunText(runs) === node.text;
+}
+function buildPointFromRuns(runs) {
+  return {
+    "a:bodyPr": {},
+    "a:lstStyle": {},
+    "a:p": buildMultiRunParagraph(runs)
+  };
+}
+function applyRunsToExistingBody(pt2, tKey, runs) {
+  const body = pt2[tKey];
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    pt2[tKey] = buildPointFromRuns(runs);
+    return;
+  }
+  const bodyObj = body;
+  const pKey = Object.keys(bodyObj).find((k) => stripPrefix(k) === "p");
+  bodyObj[pKey ?? "a:p"] = buildMultiRunParagraph(runs);
+}
+function applyTextToExistingPoint(pt2, node) {
+  const text = node.text;
+  const rebuildFromRuns = shouldRebuildFromRuns(node);
   const tKey = Object.keys(pt2).find((k) => stripPrefix(k) === "t");
   if (!tKey) {
-    pt2["dgm:t"] = buildPointText(text);
+    pt2["dgm:t"] = rebuildFromRuns ? buildPointFromRuns(node.runs) : buildPointText(text);
+    return;
+  }
+  if (rebuildFromRuns) {
+    applyRunsToExistingBody(pt2, tKey, node.runs);
     return;
   }
   const body = pt2[tKey];
@@ -32991,7 +33342,7 @@ function mergeSmartArtPointXml(existingPts, nodes) {
     if (!desired) {
       continue;
     }
-    applyTextToExistingPoint(pt2, desired.text);
+    applyTextToExistingPoint(pt2, desired);
     seenContentIds.add(modelId);
     merged.push(pt2);
   }
@@ -33004,7 +33355,7 @@ function mergeSmartArtPointXml(existingPts, nodes) {
     if (node.nodeType && !NON_CONTENT_POINT_TYPES.has(node.nodeType)) {
       ptNode["@_type"] = node.nodeType;
     }
-    ptNode["dgm:t"] = buildPointText(node.text);
+    ptNode["dgm:t"] = shouldRebuildFromRuns(node) ? buildPointFromRuns(node.runs) : buildPointText(node.text);
     merged.push(ptNode);
   }
   return merged;
@@ -33113,9 +33464,83 @@ var PptxHandlerRuntime24 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       } catch (e) {
         console.warn(`Failed to save SmartArt data at ${dataPartPath}:`, e);
       }
+      await this.regenerateSmartArtColorPart(slidePath, smartArtData);
+      await this.regenerateSmartArtQuickStylePart(slidePath, smartArtData);
     }
     this.pendingSmartArtUpdates = void 0;
   }
+  /**
+   * Merge the in-memory colour transform back into `ppt/diagrams/colors*.xml`.
+   *
+   * Resolves the part via the SmartArt `colorsRelId` relationship alongside
+   * the data part, merges surgically (preserving unknown content), and skips
+   * gracefully when the rel or part is absent. No-op when the in-memory data
+   * carries no colour transform.
+   */
+  async regenerateSmartArtColorPart(slidePath, smartArtData) {
+    const transform = smartArtData?.colorTransform;
+    if (!smartArtData?.colorsRelId || !transform) {
+      return;
+    }
+    await this.mergeSmartArtDiagramPart(
+      slidePath,
+      smartArtData.colorsRelId,
+      "colorsDef",
+      "colours",
+      (colorsDef) => applySmartArtColorTransform(
+        colorsDef,
+        transform,
+        (k) => this.compatibilityService.getXmlLocalName(k)
+      )
+    );
+  }
+  /**
+   * Merge the in-memory quick style back into `ppt/diagrams/quickStyles*.xml`.
+   *
+   * Resolves the part via the SmartArt `styleRelId` relationship, merges
+   * surgically, and skips gracefully when the rel or part is absent. No-op
+   * when the in-memory data carries no quick style.
+   */
+  async regenerateSmartArtQuickStylePart(slidePath, smartArtData) {
+    const quickStyle = smartArtData?.quickStyle;
+    if (!smartArtData?.styleRelId || !quickStyle) {
+      return;
+    }
+    await this.mergeSmartArtDiagramPart(
+      slidePath,
+      smartArtData.styleRelId,
+      "styleDef",
+      "quick style",
+      (styleDef) => applySmartArtQuickStyle(styleDef, quickStyle)
+    );
+  }
+  /**
+   * Read a SmartArt diagram part by slide relationship id, locate its root
+   * definition element by local name, apply a surgical merge callback, and
+   * write the part back only when the callback reports a change. Skips
+   * gracefully when the rel, part, or root element is absent.
+   */
+  async mergeSmartArtDiagramPart(slidePath, relId, defLocalName, label, merge) {
+    const relationships = this.slideRelsMap.get(slidePath);
+    const target = relationships?.get(relId);
+    if (!target) {
+      return;
+    }
+    const partPath = this.resolveImagePath(slidePath, target);
+    const existingXml = await this.zip.file(partPath)?.async("string");
+    if (!existingXml) {
+      return;
+    }
+    try {
+      const parsed = this.parser.parse(existingXml);
+      const def = this.xmlLookupService.getChildByLocalName(parsed, defLocalName);
+      if (def && merge(def)) {
+        this.zip.file(partPath, this.builder.build(parsed));
+      }
+    } catch (e) {
+      console.warn(`Failed to save SmartArt ${label} at ${partPath}:`, e);
+    }
+  }
   /**
    * Find the slide path for an element by scanning the slideMap.
    */
@@ -33147,10 +33572,10 @@ var PptxHandlerRuntime24 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       }
       const cSld = root["p:cSld"] || {};
       if (notesMaster.backgroundColor) {
-        const hex7 = notesMaster.backgroundColor.replace("#", "");
+        const hex8 = notesMaster.backgroundColor.replace("#", "");
         cSld["p:bg"] = {
           "p:bgPr": {
-            "a:solidFill": { "a:srgbClr": { "@_val": hex7 } },
+            "a:solidFill": { "a:srgbClr": { "@_val": hex8 } },
             "a:effectLst": {}
           }
         };
@@ -33183,10 +33608,10 @@ var PptxHandlerRuntime24 = class _PptxHandlerRuntime extends PptxHandlerRuntime2
       }
       const cSld = root["p:cSld"] || {};
       if (handoutMaster.backgroundColor) {
-        const hex7 = handoutMaster.backgroundColor.replace("#", "");
+        const hex8 = handoutMaster.backgroundColor.replace("#", "");
         cSld["p:bg"] = {
           "p:bgPr": {
-            "a:solidFill": { "a:srgbClr": { "@_val": hex7 } },
+            "a:solidFill": { "a:srgbClr": { "@_val": hex8 } },
             "a:effectLst": {}
           }
         };
@@ -35636,8 +36061,8 @@ var PptxHandlerRuntime34 = class extends PptxHandlerRuntime33 {
    */
   buildClrSchemeObject(schemeName, colorMap) {
     const slot = (key) => {
-      const hex7 = String(colorMap[key] || "").replace(/^#/, "");
-      const srgb = hex7.length === 6 ? hex7.toUpperCase() : "000000";
+      const hex8 = String(colorMap[key] || "").replace(/^#/, "");
+      const srgb = hex8.length === 6 ? hex8.toUpperCase() : "000000";
       return { "a:srgbClr": { "@_val": srgb } };
     };
     return {
@@ -42416,8 +42841,8 @@ var PptxHandlerRuntime66 = class extends PptxHandlerRuntime65 {
   /**
    * Build an OOXML colour node (`a:srgbClr`) from a hex string.
    */
-  buildSrgbClrNode(hex7) {
-    const clean = hex7.replace(/^#/, "").toUpperCase();
+  buildSrgbClrNode(hex8) {
+    const clean = hex8.replace(/^#/, "").toUpperCase();
     return { "a:srgbClr": { "@_val": clean } };
   }
   /**
@@ -42840,6 +43265,45 @@ var PptxHandlerRuntime68 = class extends PptxHandlerRuntime67 {
       }
     }
   }
+  /**
+   * Extract the per-run text + run-properties of a SmartArt content point's
+   * first paragraph (`dgm:t/a:p/a:r`).
+   *
+   * Each `a:r` yields one {@link PptxSmartArtTextRun} carrying its joined
+   * `a:t` text and a verbatim copy of its `a:rPr` properties (when present).
+   * Only the first paragraph is captured: SmartArt content points are
+   * single-paragraph in practice, and the round-trip save path rebuilds a
+   * single paragraph from these runs. Returns undefined when there is fewer
+   * than one run worth preserving (a single run is still returned so per-run
+   * formatting like a bold sole run survives).
+   */
+  extractSmartArtNodeRuns(point) {
+    const tBody = this.xmlLookupService.getChildByLocalName(point, "t");
+    if (!tBody) {
+      return void 0;
+    }
+    const paragraph = this.xmlLookupService.getChildrenArrayByLocalName(tBody, "p")[0];
+    if (!paragraph) {
+      return void 0;
+    }
+    const runNodes = this.xmlLookupService.getChildrenArrayByLocalName(paragraph, "r");
+    if (runNodes.length === 0) {
+      return void 0;
+    }
+    const runs = [];
+    for (const run of runNodes) {
+      const textValues = [];
+      this.collectLocalTextValues(run, "t", textValues);
+      const text = textValues.join("");
+      const rPrNode = this.xmlLookupService.getChildByLocalName(run, "rPr");
+      const entry = { text };
+      if (rPrNode) {
+        entry.rPr = JSON.parse(JSON.stringify(rPrNode));
+      }
+      runs.push(entry);
+    }
+    return runs.length > 0 ? runs : void 0;
+  }
   /**
    * Parse background and outline chrome from `dgm:bg` and `dgm:whole`.
    */
@@ -43143,11 +43607,13 @@ var PptxHandlerRuntime70 = class _PptxHandlerRuntime extends PptxHandlerRuntime6
       if (!resolvedText) {
         return null;
       }
+      const runs = this.extractSmartArtNodeRuns(point);
       return {
         id: pointId,
         text: resolvedText.trim(),
         parentId: parentByNodeId.get(pointId),
-        nodeType
+        nodeType,
+        runs
       };
     }).filter((entry) => Boolean(entry)).slice(0, MAX_SMARTART_NODES);
     if (nodes.length === 0) {
@@ -43865,11 +44331,11 @@ var PptxHandlerRuntime74 = class extends PptxHandlerRuntime73 {
       } else if (localName === "srgbClr") {
         const items = Array.isArray(value) ? value : [value];
         for (const item of items) {
-          const hex7 = String(
+          const hex8 = String(
             typeof item === "object" && item !== null ? item["@_val"] : item ?? ""
           ).trim();
-          if (hex7.length > 0) {
-            output.push(hex7.startsWith("#") ? hex7 : `#${hex7}`);
+          if (hex8.length > 0) {
+            output.push(hex8.startsWith("#") ? hex8 : `#${hex8}`);
           }
         }
       }
@@ -43937,9 +44403,10 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       return void 0;
     }
     const chartType = this.detectChartType(plotArea);
-    const seriesContainerKey = Object.keys(plotArea).find(
+    const chartContainerKeys = Object.keys(plotArea).filter(
       (key) => this.compatibilityService.getXmlLocalName(key).endsWith("Chart")
     );
+    const seriesContainerKey = chartContainerKeys[0];
     if (!seriesContainerKey) {
       return this.parseCxChart(
         plotArea,
@@ -43951,19 +44418,14 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       );
     }
     const seriesContainer = plotArea[seriesContainerKey];
-    const seriesList = this.xmlLookupService.getChildrenArrayByLocalName(seriesContainer, "ser");
-    if (seriesList.length === 0) {
+    const { categories, series } = this.parseAllChartContainers(
+      plotArea,
+      chartContainerKeys,
+      chartType
+    );
+    if (series.length === 0) {
       return void 0;
     }
-    const categoriesFromFirstSeries = this.extractChartPointValues(
-      this.xmlLookupService.getChildByLocalName(seriesList[0], "cat"),
-      false
-    );
-    const categories = categoriesFromFirstSeries.length ? categoriesFromFirstSeries : this.extractChartPointValues(
-      this.xmlLookupService.getChildByLocalName(seriesList[0], "xVal"),
-      false
-    );
-    const series = this.buildChartSeries(seriesList, categories);
     const titleNode = this.xmlLookupService.getChildByLocalName(chartRoot, "title");
     const titleTextValues = [];
     this.collectLocalTextValues(titleNode, "t", titleTextValues);
@@ -44062,6 +44524,49 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
       ...clrMapOvr ? { clrMapOvr } : {}
     };
   }
+  /**
+   * Parse every chart-type container in the plot area into a single flat
+   * series list plus a shared category list.
+   *
+   * For a single-type chart this parses the one container exactly as before.
+   * For a combo chart (multiple `c:*Chart` siblings) each container's series
+   * are parsed and tagged with the container's chart type via
+   * {@link PptxChartSeries.seriesChartType}, so the combo serializer can
+   * re-emit each series under the correct container on save. Series keep the
+   * document order of their containers.
+   *
+   * @param plotArea - The `c:plotArea` XML object.
+   * @param containerKeys - All chart-type container keys, in document order.
+   * @param chartLevelType - The detected chart-level type. When this is
+   *   `combo`, each series is tagged with its own container type; otherwise no
+   *   per-series type is set (the chart-level type applies to every series).
+   * @returns The merged categories and series.
+   */
+  parseAllChartContainers(plotArea, containerKeys, chartLevelType) {
+    const isCombo = chartLevelType === "combo";
+    let categories = [];
+    const series = [];
+    for (const containerKey of containerKeys) {
+      const container = plotArea[containerKey];
+      const seriesList = this.xmlLookupService.getChildrenArrayByLocalName(container, "ser");
+      if (seriesList.length === 0) {
+        continue;
+      }
+      if (categories.length === 0) {
+        const fromCat = this.extractChartPointValues(
+          this.xmlLookupService.getChildByLocalName(seriesList[0], "cat"),
+          false
+        );
+        categories = fromCat.length ? fromCat : this.extractChartPointValues(
+          this.xmlLookupService.getChildByLocalName(seriesList[0], "xVal"),
+          false
+        );
+      }
+      const containerType = isCombo ? chartContainerLocalNameToType(this.compatibilityService.getXmlLocalName(containerKey)) : void 0;
+      series.push(...this.buildChartSeries(seriesList, categories, containerType));
+    }
+    return { categories, series };
+  }
   /**
    * Build the series array from raw OOXML `c:ser` nodes.
    *
@@ -44071,9 +44576,11 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
    *
    * @param seriesList - Array of `c:ser` XML objects from the chart container.
    * @param categories - Pre-parsed category labels (used for fallback values).
+   * @param seriesChartType - When set (combo charts), tags every series in this
+   *   container with its source chart type for round-trip.
    * @returns The series array matching `PptxChartData["series"]`.
    */
-  buildChartSeries(seriesList, categories) {
+  buildChartSeries(seriesList, categories, seriesChartType) {
     return seriesList.map((seriesNode, seriesIndex) => {
       const seriesName = this.extractChartSeriesName(seriesNode);
       const values = this.extractChartPointValues(
@@ -44111,7 +44618,8 @@ var PptxHandlerRuntime75 = class extends PptxHandlerRuntime74 {
         ...dataPoints.length > 0 ? { dataPoints } : {},
         ...seriesMarker ? { marker: seriesMarker } : {},
         ...dataLabels.length > 0 ? { dataLabels } : {},
-        ...explosion !== void 0 ? { explosion } : {}
+        ...explosion !== void 0 ? { explosion } : {},
+        ...seriesChartType ? { seriesChartType } : {}
       };
     });
   }
@@ -57098,6 +57606,51 @@ function setChartDataPointExplosion(element, seriesIndex, pointIndex, explosion)
   const dp = ensureDataPoint(series, pointIndex);
   dp.explosion = explosion;
 }
+function applyLabelEdit(label, edit) {
+  if (edit.showValue !== void 0) {
+    label.showVal = edit.showValue;
+  }
+  if (edit.showCategory !== void 0) {
+    label.showCatName = edit.showCategory;
+  }
+  if (edit.showSeriesName !== void 0) {
+    label.showSerName = edit.showSeriesName;
+  }
+  if (edit.showPercent !== void 0) {
+    label.showPercent = edit.showPercent;
+  }
+  if (edit.showLegendKey !== void 0) {
+    label.showLegendKey = edit.showLegendKey;
+  }
+  if (edit.position !== void 0) {
+    label.position = edit.position;
+  }
+  if (edit.text !== void 0) {
+    label.text = edit.text === "" ? void 0 : edit.text;
+  }
+}
+function setChartDataPointLabel(element, seriesIndex, pointIndex, edit) {
+  validateSeriesIndex(element, seriesIndex);
+  const series = element.chartData.series[seriesIndex];
+  if (edit === null) {
+    if (!series.dataLabels) {
+      return;
+    }
+    series.dataLabels = series.dataLabels.filter((l) => l.idx !== pointIndex);
+    if (series.dataLabels.length === 0) {
+      series.dataLabels = void 0;
+    }
+    return;
+  }
+  const labels = series.dataLabels ??= [];
+  let label = labels.find((l) => l.idx === pointIndex);
+  if (!label) {
+    label = { idx: pointIndex };
+    labels.push(label);
+    labels.sort((a, b) => a.idx - b.idx);
+  }
+  applyLabelEdit(label, edit);
+}
 function removeEmptyDataPoint(series, pointIndex) {
   if (!series.dataPoints) {
     return;
@@ -57147,8 +57700,8 @@ function generateLayoutXml(definition) {
   const phShapes = placeholders.map((ph, i) => placeholderSpXml(ph, i + 2)).join("\n");
   let bgXml = "";
   if (definition.backgroundColor) {
-    const hex7 = definition.backgroundColor.replace(/^#/, "").toUpperCase();
-    bgXml = `    <p:bg><p:bgPr><a:solidFill><a:srgbClr val="${hex7}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
+    const hex8 = definition.backgroundColor.replace(/^#/, "").toUpperCase();
+    bgXml = `    <p:bg><p:bgPr><a:solidFill><a:srgbClr val="${hex8}"/></a:solidFill><a:effectLst/></p:bgPr></p:bg>
 `;
   }
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -57624,8 +58177,8 @@ var TextBuilder = class _TextBuilder {
    *
    * @param hex - Color as a hex string (e.g. "#FF0000").
    */
-  color(hex7) {
-    this._options.color = hex7;
+  color(hex8) {
+    this._options.color = hex8;
     return this;
   }
   /**
@@ -62401,8 +62954,8 @@ function stepTable10(t) {
   }
   return out.join(" ");
 }
-function parseHexRgb(hex7) {
-  const m = /^#?([0-9a-f]{6})/i.exec(hex7.trim());
+function parseHexRgb(hex8) {
+  const m = /^#?([0-9a-f]{6})/i.exec(hex8.trim());
   if (!m) {
     return { r: 0, g: 0, b: 0 };
   }
@@ -63378,6 +63931,7 @@ exports.setChartCategories = setChartCategories;
 exports.setChartDataLabels = setChartDataLabels;
 exports.setChartDataPointExplosion = setChartDataPointExplosion;
 exports.setChartDataPointFill = setChartDataPointFill;
+exports.setChartDataPointLabel = setChartDataPointLabel;
 exports.setChartGrouping = setChartGrouping;
 exports.setChartLegend = setChartLegend;
 exports.setChartSeriesChartType = setChartSeriesChartType;