ooxml-core 1.1.0 → 1.2.0

package/dist/chart/index.cjs

@@ -4,46 +4,46 @@ var xmldom = require('@xmldom/xmldom');
 
 // chart/regression.ts
 function computeLinearRegression(xVals, yVals) {
-  const n = xVals.length;
-  if (n < 2) {
+  const n2 = xVals.length;
+  if (n2 < 2) {
     return { slope: 0, intercept: 0, rSquared: 0 };
   }
   let sumX = 0;
   let sumY = 0;
   let sumXY = 0;
   let sumXX = 0;
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     sumX += xVals[i];
     sumY += yVals[i];
     sumXY += xVals[i] * yVals[i];
     sumXX += xVals[i] * xVals[i];
   }
-  const denom = n * sumXX - sumX * sumX;
+  const denom = n2 * sumXX - sumX * sumX;
   if (Math.abs(denom) < 1e-12) {
-    return { slope: 0, intercept: sumY / n, rSquared: 0 };
+    return { slope: 0, intercept: sumY / n2, rSquared: 0 };
   }
-  const slope = (n * sumXY - sumX * sumY) / denom;
-  const intercept = (sumY - slope * sumX) / n;
+  const slope = (n2 * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n2;
   const ssRes = yVals.reduce((s, y, i) => s + (y - (slope * xVals[i] + intercept)) ** 2, 0);
-  const meanY = sumY / n;
+  const meanY = sumY / n2;
   const ssTot = yVals.reduce((s, y) => s + (y - meanY) ** 2, 0);
   const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
   return { slope, intercept, rSquared };
 }
 function fitPolynomial(xVals, yVals, order) {
-  const n = xVals.length;
+  const n2 = xVals.length;
   const m = order + 1;
   const matrix = Array.from({ length: m }, () => Array(m + 1).fill(0));
   for (let i = 0; i < m; i++) {
     for (let j = 0; j < m; j++) {
       let sum2 = 0;
-      for (let k = 0; k < n; k++) {
+      for (let k = 0; k < n2; k++) {
         sum2 += xVals[k] ** (i + j);
       }
       matrix[i][j] = sum2;
     }
     let sum = 0;
-    for (let k = 0; k < n; k++) {
+    for (let k = 0; k < n2; k++) {
       sum += yVals[k] * xVals[k] ** i;
     }
     matrix[i][m] = sum;
@@ -76,14 +76,14 @@ function fitPolynomial(xVals, yVals, order) {
   return matrix.map((row) => row[m]);
 }
 function computeRSquared(xVals, yVals, evalFn) {
-  const n = xVals.length;
-  if (n === 0) {
+  const n2 = xVals.length;
+  if (n2 === 0) {
     return 0;
   }
-  const meanY = yVals.reduce((s, y) => s + y, 0) / n;
+  const meanY = yVals.reduce((s, y) => s + y, 0) / n2;
   let ssRes = 0;
   let ssTot = 0;
-  for (let i = 0; i < n; i++) {
+  for (let i = 0; i < n2; i++) {
     ssRes += (yVals[i] - evalFn(xVals[i])) ** 2;
     ssTot += (yVals[i] - meanY) ** 2;
   }
@@ -207,7 +207,7 @@ function computeStackedSeriesPlots(seriesValues, catCount, percent) {
   return seriesValues.map((values) => {
     const cumulative = [], base = [], own = [];
     for (let ci = 0; ci < catCount; ci++) {
-      const raw = values[ci] ?? 0, total = totals?.[ci] ?? 0, val = percent ? total > 0 ? raw / total * 100 : 0 : raw, isNeg = val < 0, from = isNeg ? negRunning[ci] : posRunning[ci], to = from + val;
+      const raw2 = values[ci] ?? 0, total = totals?.[ci] ?? 0, val = percent ? total > 0 ? raw2 / total * 100 : 0 : raw2, isNeg = val < 0, from = isNeg ? negRunning[ci] : posRunning[ci], to = from + val;
       base.push(from);
       cumulative.push(to);
       own.push(val);
@@ -235,8 +235,8 @@ function axisTargetIntervals(plotHeightPx) {
     return DEFAULT_TARGET_INTERVALS;
   }
   const plotHeightPt = plotHeightPx / PX_PER_POINT;
-  const raw = Math.round(plotHeightPt / POINTS_PER_GRIDLINE);
-  return Math.min(MAX_TARGET_INTERVALS, Math.max(MIN_TARGET_INTERVALS, raw));
+  const raw2 = Math.round(plotHeightPt / POINTS_PER_GRIDLINE);
+  return Math.min(MAX_TARGET_INTERVALS, Math.max(MIN_TARGET_INTERVALS, raw2));
 }
 function niceAxisStep(value) {
   if (!Number.isFinite(value) || value <= 0) {
@@ -397,10 +397,10 @@ function squarify(nodes, box) {
   const scale = total > 0 ? box.w * box.h / total : box.w * box.h / sorted.length;
   const items = sorted.map((node) => ({ node, area: (total > 0 ? node.weight : 1) * scale }));
   const result = [];
-  let rect = { ...box };
+  let rect2 = { ...box };
   let remaining = items;
   for (let first2 = remaining[0]; first2 !== void 0; first2 = remaining[0]) {
-    const side = Math.min(rect.w, rect.h);
+    const side = Math.min(rect2.w, rect2.h);
     let row = [first2];
     let rowAreas = [first2.area];
     let worst = worstAspectRatio(rowAreas, side);
@@ -418,18 +418,18 @@ function squarify(nodes, box) {
     }
     const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
     const thickness = side > 0 ? rowTotalArea / side : 0;
-    const layoutVertically = rect.w >= rect.h;
-    let offset = layoutVertically ? rect.y : rect.x;
+    const layoutVertically = rect2.w >= rect2.h;
+    let offset = layoutVertically ? rect2.y : rect2.x;
     for (const item of row) {
       const length = thickness > 0 ? item.area / thickness : 0;
       if (layoutVertically) {
-        result.push([item.node, { x: rect.x, y: offset, w: thickness, h: length }]);
+        result.push([item.node, { x: rect2.x, y: offset, w: thickness, h: length }]);
       } else {
-        result.push([item.node, { x: offset, y: rect.y, w: length, h: thickness }]);
+        result.push([item.node, { x: offset, y: rect2.y, w: length, h: thickness }]);
       }
       offset += length;
     }
-    rect = layoutVertically ? { ...rect, x: rect.x + thickness, w: rect.w - thickness } : { ...rect, y: rect.y + thickness, h: rect.h - thickness };
+    rect2 = layoutVertically ? { ...rect2, x: rect2.x + thickness, w: rect2.w - thickness } : { ...rect2, y: rect2.y + thickness, h: rect2.h - thickness };
     remaining = remaining.slice(row.length);
   }
   return result;
@@ -475,8 +475,8 @@ function formatPolynomialEquation(coeffsAscending) {
 
 // chart/radar-geometry.ts
 function radarAngle(index, catCount) {
-  const n = Math.max(catCount, 1);
-  return Math.PI * 2 * index / n - Math.PI / 2;
+  const n2 = Math.max(catCount, 1);
+  return Math.PI * 2 * index / n2 - Math.PI / 2;
 }
 function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
   const denom = maxVal > 0 ? maxVal : 1;
@@ -486,9 +486,9 @@ function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
   });
 }
 function radarRingPoints(cx, cy, rr, catCount) {
-  const n = Math.max(catCount, 1);
-  return Array.from({ length: n }, (_, i) => {
-    const angle = radarAngle(i, n);
+  const n2 = Math.max(catCount, 1);
+  return Array.from({ length: n2 }, (_, i) => {
+    const angle = radarAngle(i, n2);
     return `${(cx + rr * Math.cos(angle)).toFixed(2)},${(cy + rr * Math.sin(angle)).toFixed(2)}`;
   }).join(" ");
 }
@@ -623,13 +623,13 @@ function hexToRgbChannels(color) {
     b: Number.parseInt(normalized.slice(4, 6), 16)
   };
 }
-function percentDivisorFor(text) {
-  return text.endsWith("%") ? 100 : 1e5;
+function percentDivisorFor(text2) {
+  return text2.endsWith("%") ? 100 : 1e5;
 }
 function parseOoxmlPercent(value) {
-  const text = String(value ?? "").trim();
-  const divisor = percentDivisorFor(text);
-  const magnitude = Number.parseFloat(divisor === 100 ? text.slice(0, -1) : text);
+  const text2 = String(value ?? "").trim();
+  const divisor = percentDivisorFor(text2);
+  const magnitude = Number.parseFloat(divisor === 100 ? text2.slice(0, -1) : text2);
   if (!Number.isFinite(magnitude)) {
     return void 0;
   }
@@ -675,7 +675,7 @@ function rgbToHsl(r, g, b) {
   return { h, s: clampUnitInterval(s), l: clampUnitInterval(l) };
 }
 function hslToRgb(h, s, l, roundChannel = Math.round, options) {
-  const sC = clampUnitInterval(s);
+  const sC = options?.clampSaturation === false ? s : clampUnitInterval(s);
   const lC = clampUnitInterval(l);
   const hN = (h % 360 + 360) % 360;
   const c2 = (1 - Math.abs(2 * lC - 1)) * sC;
@@ -1014,6 +1014,16 @@ function sigmaGradientStops(stops) {
   });
 }
 
+// color/hex-rgb.ts
+function parseArgbHex(hex) {
+  const clean2 = hex.replace(/^#/, "");
+  const rgb = clean2.length === 8 ? clean2.slice(2) : clean2;
+  if (!/^[0-9a-fA-F]{6}$/.test(rgb)) return void 0;
+  return [0, 2, 4].map((i) => parseInt(rgb.slice(i, i + 2), 16));
+}
+var clamp255 = (v) => Math.max(0, Math.min(255, v));
+var rgbToUpperHex = (rgb) => `#${rgb.map((v) => clamp255(Math.round(v)).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+
 // xml/namespaces.ts
 var NS = {
   /** DrawingML main. */
@@ -1057,6 +1067,10 @@ function named(element, local, ns, lenient = true) {
 }
 var children = (parent, local, ns, lenient = true) => elements(parent).filter((element) => named(element, local, ns, lenient));
 var first = (parent, local, ns, lenient = true) => parent ? children(parent, local, ns, lenient)[0] : void 0;
+function attr(element, local, ns, prefix) {
+  return element?.getAttributeNS(ns, local) ?? element?.getAttribute(`${prefix}:${local}`) ?? void 0;
+}
+var relAttr = (element, local) => attr(element, local, NS.r, "r");
 
 // drawingml/dom.ts
 function attributeReader(element) {
@@ -1079,6 +1093,54 @@ function booleanAttribute(element, name) {
   return void 0;
 }
 
+// drawingml/ordered-color-transforms.ts
+function orderedColorTransforms(channels, transforms) {
+  let { r, g, b } = channels;
+  let alpha = 1;
+  const wrap2 = (value) => (value % 360 + 360) % 360;
+  for (const transform of transforms) {
+    const { name, value } = transform;
+    const fraction = parseDrawingFraction(value);
+    if (name === "alpha" && fraction !== void 0) alpha = clampUnitInterval(fraction);
+    else if (name === "alphaMod" && fraction !== void 0)
+      alpha = clampUnitInterval(alpha * fraction);
+    else if (name === "alphaOff" && fraction !== void 0)
+      alpha = clampUnitInterval(alpha + fraction);
+    else if (name === "inv") [r, g, b] = [255 - r, 255 - g, 255 - b];
+    else if (name === "gray") r = g = b = 0.299 * r + 0.587 * g + 0.114 * b;
+    else if ((name === "shade" || name === "tint") && fraction !== void 0) {
+      const mix = (channel) => linearToSrgb255(
+        name === "shade" ? srgb255ToLinear(channel) * fraction : 1 - (1 - srgb255ToLinear(channel)) * fraction
+      );
+      [r, g, b] = [mix(r), mix(g), mix(b)];
+    } else {
+      const hsl = rgbToHsl(r, g, b);
+      if (name === "comp") hsl.h = wrap2(hsl.h + 180);
+      else if (name === "hue") {
+        const hue = parseDrawingHueDegrees(value);
+        if (hue !== void 0) hsl.h = wrap2(hue);
+      } else if (name === "hueOff") {
+        const hue = parseDrawingHueDegrees(value);
+        if (hue !== void 0) hsl.h = wrap2(hsl.h + hue);
+      } else if (name === "hueMod" && fraction !== void 0) hsl.h = wrap2(hsl.h * fraction);
+      else if (name === "sat" && fraction !== void 0) hsl.s = clampUnitInterval(fraction);
+      else if (name === "satMod" && fraction !== void 0) hsl.s *= fraction;
+      else if (name === "satOff" && fraction !== void 0)
+        hsl.s = clampUnitInterval(hsl.s + fraction);
+      else if (name === "lum" && fraction !== void 0) hsl.l = clampUnitInterval(fraction);
+      else if (name === "lumMod" && fraction !== void 0)
+        hsl.l = clampUnitInterval(hsl.l * fraction);
+      else if (name === "lumOff" && fraction !== void 0)
+        hsl.l = clampUnitInterval(hsl.l + fraction);
+      else continue;
+      ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l, (channel) => channel, {
+        clampSaturation: false
+      }));
+    }
+  }
+  return { r, g, b, alpha };
+}
+
 // drawingml/drawing-color.ts
 var COLOR_ELEMENTS = {
   srgbClr: "srgb",
@@ -1089,10 +1151,10 @@ var COLOR_ELEMENTS = {
   hslClr: "hsl"
 };
 function colorValue(kind, element) {
-  const attribute = (name) => element.getAttribute(name) ?? "";
-  if (kind === "scrgb") return `${attribute("r")},${attribute("g")},${attribute("b")}`;
-  if (kind === "hsl") return `${attribute("hue")},${attribute("sat")},${attribute("lum")}`;
-  return attribute("val");
+  const attribute2 = (name) => element.getAttribute(name) ?? "";
+  if (kind === "scrgb") return `${attribute2("r")},${attribute2("g")},${attribute2("b")}`;
+  if (kind === "hsl") return `${attribute2("hue")},${attribute2("sat")},${attribute2("lum")}`;
+  return attribute2("val");
 }
 function parseDrawingColorIn(container) {
   if (!container) return void 0;
@@ -1177,6 +1239,17 @@ function resolveDrawingColor(color, theme, options) {
   const base = baseHex(color, theme);
   const rgb = base ? hexToRgbChannels(base) : null;
   if (!rgb) return void 0;
+  if (options?.transformOrder === "document") {
+    const value = orderedColorTransforms(rgb, color.transforms);
+    const round = options.hslRounding === "halfDown" ? (channel) => Math.ceil(channel - 0.5) : Math.round;
+    return {
+      hex: `#${toHex(round(value.r))}${toHex(round(value.g))}${toHex(round(value.b))}`,
+      alpha: value.alpha,
+      unapplied: [...new Set(color.transforms.map((transform) => transform.name))].filter(
+        (name) => !APPLIED.has(name)
+      )
+    };
+  }
   let { r, g, b } = rgb;
   const find = (name) => color.transforms.find((entry3) => entry3.name === name)?.value;
   const has = (name) => color.transforms.some((entry3) => entry3.name === name);
@@ -1200,13 +1273,13 @@ function resolveDrawingColor(color, theme, options) {
   }
   if (["hue", "hueMod", "hueOff", "sat", "satMod", "satOff", "lum", "lumMod", "lumOff"].some(has)) {
     const hsl = rgbToHsl(r, g, b);
-    const wrap = (degrees) => (degrees % 360 + 360) % 360;
+    const wrap2 = (degrees) => (degrees % 360 + 360) % 360;
     const hueAbs = parseDrawingHueDegrees(find("hue"));
-    if (hueAbs !== void 0) hsl.h = wrap(hueAbs);
+    if (hueAbs !== void 0) hsl.h = wrap2(hueAbs);
     const hueMod = parseDrawingFraction(find("hueMod"));
-    if (hueMod !== void 0) hsl.h = wrap(hsl.h * hueMod);
+    if (hueMod !== void 0) hsl.h = wrap2(hsl.h * hueMod);
     const hueOff = parseDrawingHueDegrees(find("hueOff"));
-    if (hueOff !== void 0) hsl.h = wrap(hsl.h + hueOff);
+    if (hueOff !== void 0) hsl.h = wrap2(hsl.h + hueOff);
     const satAbs = parseDrawingFraction(find("sat"));
     if (satAbs !== void 0) hsl.s = clampUnitInterval(satAbs);
     const satMod = parseDrawingFraction(find("satMod"));
@@ -1219,7 +1292,7 @@ function resolveDrawingColor(color, theme, options) {
     if (lumMod !== void 0) hsl.l = clampUnitInterval(hsl.l * lumMod);
     const lumOff = parseDrawingFraction(find("lumOff"));
     if (lumOff !== void 0) hsl.l = clampUnitInterval(hsl.l + lumOff);
-    const round = Math.round;
+    const round = options?.hslRounding === "halfDown" ? (value) => Math.ceil(value - 0.5) : Math.round;
     ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l, round));
   }
   let alpha = parseDrawingPercent(find("alpha")) ?? 1;
@@ -1283,12 +1356,12 @@ var CHART_COLOR_PALETTES = [
 function findChartColorPalette(id) {
   return CHART_COLOR_PALETTES.find((palette) => palette.id === id);
 }
-function withinLinearTransform(i, n) {
-  if (n <= 1) {
+function withinLinearTransform(i, n2) {
+  if (n2 <= 1) {
     return {};
   }
-  const step = 140 / (n + 1);
-  const centre = (n - 1) / 2;
+  const step = 140 / (n2 + 1);
+  const centre = (n2 - 1) / 2;
   const value = 100 - step * Math.abs(i - centre);
   if (i < centre) {
     return { shade: Math.floor(value + 1e-9) * 1e3 };
@@ -1298,7 +1371,7 @@ function withinLinearTransform(i, n) {
   }
   return {};
 }
-function chartPaletteSeriesColorChoice(palette, i, n) {
+function chartPaletteSeriesColorChoice(palette, i, n2) {
   let base;
   let transform;
   if (palette.meth === "cycle") {
@@ -1306,9 +1379,9 @@ function chartPaletteSeriesColorChoice(palette, i, n) {
     const round = Math.floor(i / palette.base.length);
     transform = (palette.variations.length ? palette.variations[round % palette.variations.length] : {}) ?? {};
   } else {
-    const index = palette.meth === "withinLinearReversed" ? n - 1 - i : i;
+    const index = palette.meth === "withinLinearReversed" ? n2 - 1 - i : i;
     base = palette.base[0];
-    transform = withinLinearTransform(index, n);
+    transform = withinLinearTransform(index, n2);
   }
   if (!base) throw new RangeError("A chart palette must have a base color");
   return {
@@ -1317,12 +1390,12 @@ function chartPaletteSeriesColorChoice(palette, i, n) {
     transforms: Object.entries(transform).map(([name, value]) => ({ name, value: String(value) }))
   };
 }
-function chartPaletteSeriesColor(palette, i, n, scheme) {
-  const choice = chartPaletteSeriesColorChoice(palette, i, n);
+function chartPaletteSeriesColor(palette, i, n2, scheme) {
+  const choice = chartPaletteSeriesColorChoice(palette, i, n2);
   return (resolveDrawingColor(choice, { scheme: (name) => scheme[name] })?.hex ?? scheme[choice.value]).toUpperCase();
 }
-function chartPaletteColors(palette, n, scheme) {
-  return Array.from({ length: n }, (_, i) => chartPaletteSeriesColor(palette, i, n, scheme));
+function chartPaletteColors(palette, n2, scheme) {
+  return Array.from({ length: n2 }, (_, i) => chartPaletteSeriesColor(palette, i, n2, scheme));
 }
 
 // chart/color-style.ts
@@ -1393,11 +1466,11 @@ function resolveChartStyleDefinition(style, resolve) {
       const value = source[key];
       if (value !== void 0) Object.assign(entry3, { [key]: value });
     }
-    const line = fillColor(source.line?.fill) ?? (source.lineRef?.color && resolve(source.lineRef.color));
+    const line2 = fillColor(source.line?.fill) ?? (source.lineRef?.color && resolve(source.lineRef.color));
     const fill = fillColor(source.fill) ?? (source.fillRef?.color && resolve(source.fillRef.color));
     const color = (source.textColor && resolve(source.textColor)) ?? (source.fontRef?.color && resolve(source.fontRef.color));
     if (color !== void 0) entry3.color = color;
-    if (line !== void 0) entry3.lineColor = line;
+    if (line2 !== void 0) entry3.lineColor = line2;
     if (fill !== void 0) entry3.fillColor = fill;
     if (source.line?.widthEmu !== void 0 && source.line.widthEmu > 0)
       entry3.lineWidth = source.line.widthEmu / 12700;
@@ -1464,13 +1537,13 @@ var FILL_ELEMENTS = /* @__PURE__ */ new Set([
   "blipFill",
   "grpFill"
 ]);
-function fillElementOf(properties) {
-  return properties ? elements(properties).find(
+function fillElementOf(properties2) {
+  return properties2 ? elements(properties2).find(
     (element) => FILL_ELEMENTS.has(element.localName) && (!element.namespaceURI || element.namespaceURI === NS.a)
   ) : void 0;
 }
-function parseDrawingFill(properties) {
-  const fill = fillElementOf(properties);
+function parseDrawingFill(properties2) {
+  const fill = fillElementOf(properties2);
   if (!fill) return void 0;
   switch (fill.localName) {
     case "noFill":
@@ -1487,7 +1560,7 @@ function parseDrawingFill(properties) {
       });
       const angle = Number.parseInt(first(fill, "lin", NS.a)?.getAttribute("ang") ?? "", 10);
       const scaled = first(fill, "lin", NS.a)?.getAttribute("scaled");
-      const path = first(fill, "path", NS.a)?.getAttribute("path");
+      const path2 = first(fill, "path", NS.a)?.getAttribute("path");
       const focus = first(first(fill, "path", NS.a), "fillToRect", NS.a);
       const tile = first(fill, "tileRect", NS.a);
       const tileRect = tile ? {
@@ -1509,7 +1582,7 @@ function parseDrawingFill(properties) {
         ...Number.isFinite(angle) ? { angle: angle / 6e4 } : {},
         ...scaled === "1" || scaled === "true" ? { scaled: true } : {},
         ...scaled === "0" || scaled === "false" ? { scaled: false } : {},
-        ...path ? { path } : {},
+        ...path2 ? { path: path2 } : {},
         ...fillToRect && Object.values(fillToRect).every(Number.isFinite) ? { fillToRect } : {},
         ...tileRect && Object.values(tileRect).every(Number.isFinite) ? { tileRect } : {}
       };
@@ -1535,41 +1608,41 @@ function parseDrawingFill(properties) {
 }
 function parseDrawingLine(ln) {
   if (!ln) return void 0;
-  const line = {};
+  const line2 = {};
   const width = Number.parseInt(ln.getAttribute("w") ?? "", 10);
-  if (Number.isFinite(width)) line.widthEmu = width;
+  if (Number.isFinite(width)) line2.widthEmu = width;
   const fill = parseDrawingFill(ln);
-  if (fill) line.fill = fill;
+  if (fill) line2.fill = fill;
   const dash = first(ln, "prstDash", NS.a)?.getAttribute("val");
-  if (dash) line.dash = dash;
+  if (dash) line2.dash = dash;
   const cap = ln.getAttribute("cap");
-  if (cap) line.cap = cap;
-  return line;
+  if (cap) line2.cap = cap;
+  return line2;
 }
 
 // chart/read-appearance.ts
-function readChartAppearance(text, properties) {
+function readChartAppearance(text2, properties2) {
   const out = {};
-  const size = Number(text?.getAttribute("sz") ?? NaN);
+  const size = Number(text2?.getAttribute("sz") ?? NaN);
   if (Number.isFinite(size) && size > 0) out.fontSize = size / 100;
-  for (const [attribute, key] of [
+  for (const [attribute2, key] of [
     ["b", "bold"],
     ["i", "italic"]
   ]) {
-    const value = text?.getAttribute(attribute);
+    const value = text2?.getAttribute(attribute2);
     if (value !== null && value !== void 0) out[key] = value === "1" || value === "true";
   }
-  const typeface = first(text, "latin", NS.a)?.getAttribute("typeface");
-  const underline = text?.getAttribute("u");
+  const typeface2 = first(text2, "latin", NS.a)?.getAttribute("typeface");
+  const underline = text2?.getAttribute("u");
   if (underline) out.underline = underline !== "none";
-  if (typeface) out.typeface = typeface;
-  const color = parseDrawingColorIn(first(text, "solidFill", NS.a));
+  if (typeface2) out.typeface = typeface2;
+  const color = parseDrawingColorIn(first(text2, "solidFill", NS.a));
   if (color) out.textColor = color;
-  const fill = parseDrawingFill(properties);
-  const line = parseDrawingLine(first(properties, "ln", NS.a));
+  const fill = parseDrawingFill(properties2);
+  const line2 = parseDrawingLine(first(properties2, "ln", NS.a));
   if (fill) out.fill = fill;
-  if (line) out.line = line;
-  const effects = first(text, "effectLst", NS.a);
+  if (line2) out.line = line2;
+  const effects = first(text2, "effectLst", NS.a);
   if (effects) out.textEffectsXml = buildXml(effects);
   return out;
 }
@@ -1631,46 +1704,46 @@ function parseSpacing(parent) {
     ["spcPts", "points", 100],
     ["spcPct", "percent", 1e5]
   ]) {
-    const raw = first(parent, name, NS.a)?.getAttribute("val");
-    if (raw == null || !/^\d+$/.test(raw)) continue;
-    const value = Number(raw) / divisor;
+    const raw2 = first(parent, name, NS.a)?.getAttribute("val");
+    if (raw2 == null || !/^\d+$/.test(raw2)) continue;
+    const value = Number(raw2) / divisor;
     if (Number.isFinite(value)) return { unit, value };
   }
   return void 0;
 }
-function parseProperties(properties) {
+function parseProperties(properties2) {
   const parsed = {};
-  const size = Number.parseInt(properties?.getAttribute("sz") ?? "", 10);
+  const size = Number.parseInt(properties2?.getAttribute("sz") ?? "", 10);
   if (Number.isFinite(size)) parsed.sizePt = size / 100;
-  const bold = booleanAttribute(properties, "b");
+  const bold = booleanAttribute(properties2, "b");
   if (bold !== void 0) parsed.bold = bold;
-  const italic = booleanAttribute(properties, "i");
+  const italic = booleanAttribute(properties2, "i");
   if (italic !== void 0) parsed.italic = italic;
-  const underline = properties?.getAttribute("u");
+  const underline = properties2?.getAttribute("u");
   if (underline) parsed.underline = underline !== "none";
-  const color = parseDrawingColorIn(first(properties, "solidFill", NS.a));
+  const color = parseDrawingColorIn(first(properties2, "solidFill", NS.a));
   if (color) parsed.color = color;
-  const typeface = first(properties, "latin", NS.a)?.getAttribute("typeface");
-  if (typeface) parsed.typeface = typeface;
+  const typeface2 = first(properties2, "latin", NS.a)?.getAttribute("typeface");
+  if (typeface2) parsed.typeface = typeface2;
   return parsed;
 }
-function parseRun(run) {
+function parseRun(run2) {
   return {
-    text: run.localName === "br" ? "\n" : first(run, "t", NS.a)?.textContent ?? "",
-    ...parseProperties(first(run, "rPr", NS.a))
+    text: run2.localName === "br" ? "\n" : first(run2, "t", NS.a)?.textContent ?? "",
+    ...parseProperties(first(run2, "rPr", NS.a))
   };
 }
-function parseParagraph(paragraph) {
+function parseParagraph(paragraph2) {
   const runs = [];
-  for (const child2 of elements(paragraph))
+  for (const child2 of elements(paragraph2))
     if (child2.namespaceURI === NS.a && ["r", "fld", "br"].includes(child2.localName))
       runs.push(parseRun(child2));
-  const properties = first(paragraph, "pPr", NS.a);
-  const align = properties?.getAttribute("algn");
-  const defaults = parseProperties(first(properties, "defRPr", NS.a));
-  const lineSpacing = parseSpacing(first(properties, "lnSpc", NS.a));
-  const spaceBefore = parseSpacing(first(properties, "spcBef", NS.a));
-  const spaceAfter = parseSpacing(first(properties, "spcAft", NS.a));
+  const properties2 = first(paragraph2, "pPr", NS.a);
+  const align = properties2?.getAttribute("algn");
+  const defaults = parseProperties(first(properties2, "defRPr", NS.a));
+  const lineSpacing = parseSpacing(first(properties2, "lnSpc", NS.a));
+  const spaceBefore = parseSpacing(first(properties2, "spcBef", NS.a));
+  const spaceAfter = parseSpacing(first(properties2, "spcAft", NS.a));
   return {
     ...align ? { align } : {},
     ...Object.keys(defaults).length ? { defaultProperties: defaults } : {},
@@ -1682,22 +1755,22 @@ function parseParagraph(paragraph) {
 }
 function parseDrawingTextBody(body) {
   if (!body) return void 0;
-  const properties = first(body, "bodyPr", NS.a);
+  const properties2 = first(body, "bodyPr", NS.a);
   const paragraphs = children(body, "p", NS.a).map(parseParagraph);
   const result = {
     paragraphs,
-    text: paragraphs.map((paragraph) => paragraph.runs.map((run) => run.text).join("")).join("\n")
+    text: paragraphs.map((paragraph2) => paragraph2.runs.map((run2) => run2.text).join("")).join("\n")
   };
-  const anchor = properties?.getAttribute("anchor");
+  const anchor = properties2?.getAttribute("anchor");
   if (anchor) result.anchor = anchor;
   const insets = {};
-  for (const [key, attribute] of [
+  for (const [key, attribute2] of [
     ["left", "lIns"],
     ["top", "tIns"],
     ["right", "rIns"],
     ["bottom", "bIns"]
   ]) {
-    const value = Number.parseInt(properties?.getAttribute(attribute) ?? "", 10);
+    const value = Number.parseInt(properties2?.getAttribute(attribute2) ?? "", 10);
     if (Number.isFinite(value)) insets[key] = value;
   }
   if (Object.keys(insets).length > 0) result.insetsEmu = insets;
@@ -1708,8 +1781,8 @@ function parseDrawingTextBody(body) {
 function readChartManualLayoutValues(value) {
   const result = {};
   const enumeration = (name, values) => {
-    const raw = value(name);
-    return values.includes(raw) ? raw : void 0;
+    const raw2 = value(name);
+    return values.includes(raw2) ? raw2 : void 0;
   };
   const target = enumeration("layoutTarget", ["inner", "outer"]);
   if (target) result.layoutTarget = target;
@@ -1728,10 +1801,10 @@ function readChartManualLayoutValues(value) {
     ["w", "width"],
     ["h", "height"]
   ]) {
-    const raw = value(xml);
-    if (typeof raw !== "string" && typeof raw !== "number" || typeof raw === "string" && !raw.trim())
+    const raw2 = value(xml);
+    if (typeof raw2 !== "string" && typeof raw2 !== "number" || typeof raw2 === "string" && !raw2.trim())
       continue;
-    const number = Number(raw);
+    const number = Number(raw2);
     if (Number.isFinite(number)) result[key] = number;
   }
   return Object.keys(result).length ? result : void 0;
@@ -1753,8 +1826,8 @@ var c = (parent, name) => first(parent, name, NS.c);
 var a = (parent, name) => first(parent, name, NS.a);
 function entry2(node) {
   const body = c(node, "txPr");
-  const paragraph = a(body, "p");
-  const defaults = a(a(paragraph, "pPr"), "defRPr");
+  const paragraph2 = a(body, "p");
+  const defaults = a(a(paragraph2, "pPr"), "defRPr");
   const rich = c(c(node, "tx"), "rich");
   const richParagraph = a(rich, "p");
   const textBody = parseDrawingTextBody(rich);
@@ -1903,26 +1976,26 @@ function drawingColorXml(color) {
 }
 
 // drawingml/write-fill.ts
-function setDrawingFillXml(properties, xml) {
-  const doc = properties.ownerDocument;
+function setDrawingFillXml(properties2, xml) {
+  const doc = properties2.ownerDocument;
   const wrapper = parseXml(`<w xmlns:a="${NS.a}">${xml}</w>`);
   const fill = elements(wrapper.documentElement)[0];
   const names = ["solidFill", "gradFill", "pattFill", "blipFill", "grpFill", "noFill"];
   if (elements(wrapper.documentElement).length !== 1 || !fill || fill.namespaceURI !== NS.a || !names.includes(fill.localName))
     throw new Error("Invalid DrawingML fill XML");
-  const existing = elements(properties).filter(
+  const existing = elements(properties2).filter(
     (node) => node.namespaceURI === NS.a && names.includes(node.localName)
   );
   const next = doc.importNode(fill, true);
-  if (existing[0]) properties.replaceChild(next, existing[0]);
+  if (existing[0]) properties2.replaceChild(next, existing[0]);
   else
-    properties.insertBefore(
+    properties2.insertBefore(
       next,
-      elements(properties).find(
+      elements(properties2).find(
         (node) => node.namespaceURI === NS.a && ["ln", "effectLst", "effectDag", "scene3d", "sp3d", "extLst"].includes(node.localName)
       ) ?? null
     );
-  for (const extra of existing.slice(1)) properties.removeChild(extra);
+  for (const extra of existing.slice(1)) properties2.removeChild(extra);
 }
 function drawingFillXml(fill) {
   if (fill.kind === "none") return "<a:noFill/>";
@@ -1966,20 +2039,20 @@ function drawingFillXml(fill) {
     if (fill.scaled !== void 0) linear.setAttribute("scaled", fill.scaled ? "1" : "0");
   }
   if (fill.path !== void 0) {
-    let path = first(root, "path", NS.a);
-    if (!path) {
-      path = doc.createElementNS(NS.a, "a:path");
-      root.insertBefore(path, first(root, "tileRect", NS.a) ?? first(root, "extLst", NS.a) ?? null);
+    let path2 = first(root, "path", NS.a);
+    if (!path2) {
+      path2 = doc.createElementNS(NS.a, "a:path");
+      root.insertBefore(path2, first(root, "tileRect", NS.a) ?? first(root, "extLst", NS.a) ?? null);
     }
-    path.setAttribute("path", fill.path);
+    path2.setAttribute("path", fill.path);
     if (!fill.fillToRect) {
-      const old = first(path, "fillToRect", NS.a);
-      if (old) path.removeChild(old);
+      const old = first(path2, "fillToRect", NS.a);
+      if (old) path2.removeChild(old);
     } else {
-      let focus = first(path, "fillToRect", NS.a);
+      let focus = first(path2, "fillToRect", NS.a);
       if (!focus) {
         focus = doc.createElementNS(NS.a, "a:fillToRect");
-        path.appendChild(focus);
+        path2.appendChild(focus);
       }
       for (const [key, value] of Object.entries(fill.fillToRect))
         focus.setAttribute(key, String(Math.round(value * 1e5)));
@@ -2004,12 +2077,12 @@ function writeChartFillFormatting(root, formatting) {
   for (const [part, node] of Object.entries(chartFormattingNodes(root))) {
     const fill = formatting.entries[part]?.fill;
     if (!node || !fill) continue;
-    let properties = first(node, "spPr", NS.c);
-    if (JSON.stringify(parseDrawingFill(properties)) === JSON.stringify(fill)) continue;
+    let properties2 = first(node, "spPr", NS.c);
+    if (JSON.stringify(parseDrawingFill(properties2)) === JSON.stringify(fill)) continue;
     const xml = drawingFillXml(fill);
     if (xml === void 0) continue;
-    if (!properties) {
-      properties = root.ownerDocument.createElementNS(NS.c, "c:spPr");
+    if (!properties2) {
+      properties2 = root.ownerDocument.createElementNS(NS.c, "c:spPr");
       const successors = [
         "txPr",
         "crossAx",
@@ -2028,13 +2101,13 @@ function writeChartFillFormatting(root, formatting) {
         "extLst"
       ];
       node.insertBefore(
-        properties,
+        properties2,
         elements(node).find(
           (child2) => child2.namespaceURI === NS.c && successors.includes(child2.localName)
         ) ?? null
       );
     }
-    setDrawingFillXml(properties, xml);
+    setDrawingFillXml(properties2, xml);
     changed = true;
   }
   return changed;
@@ -2051,6 +2124,27 @@ function removeGradientStop(stops, index) {
   return stops.length <= 2 ? void 0 : stops.filter((_, i) => i !== index);
 }
 
+// chart/gradient-coincident-stops.ts
+var NATIVE_COINCIDENT_STOP_RAMP = 1 / 256;
+function spreadCoincidentStops(stops) {
+  const out = [];
+  for (const [index, stop] of stops.entries()) {
+    const source = stops[index - 1];
+    const previous = out.at(-1);
+    const next = stops[index + 1];
+    if (!source || !previous || stop.offset !== source.offset || stop.color === source.color && (stop.opacity ?? 1) === (source.opacity ?? 1)) {
+      out.push(stop);
+      continue;
+    }
+    const limit = Math.min(1, next ? next.offset : 1);
+    out.push({
+      ...stop,
+      offset: Math.max(stop.offset, Math.min(previous.offset + NATIVE_COINCIDENT_STOP_RAMP, limit))
+    });
+  }
+  return out;
+}
+
 // drawingml/gradient-geometry.ts
 var RECT_GRADIENT_DIRECTIONS = [
   { id: "center", label: "From Center", x: 0.5, y: 0.5 },
@@ -2238,7 +2332,7 @@ function buildChartGradientDef(id, fill, bounds) {
     y1: round(0.5 - dy),
     x2: round(0.5 + dx),
     y2: round(0.5 + dy),
-    stops
+    stops: spreadCoincidentStops(stops)
   };
 }
 
@@ -2311,6 +2405,2817 @@ function writeChartLayoutFormatting(root, formatting) {
   return changed;
 }
 
+// chart/data-cache.ts
+function chartCacheValues(cache) {
+  if (!cache) return [];
+  const numeric = cache.type === "number";
+  const out = [];
+  for (const point of cache.points) {
+    const text2 = point.value;
+    out[point.index ?? out.length] = numeric && text2.trim() !== "" && Number.isFinite(Number(text2)) ? Number(text2) : text2;
+  }
+  const size = Math.max(cache.pointCount ?? 0, out.length);
+  for (let index = 0; index < size; index++) if (out[index] === void 0) out[index] = "";
+  return out;
+}
+var chartSourceValues = (source) => chartCacheValues(source?.cache ?? source?.levels?.[0]);
+
+// chart/xml-fragment.ts
+var CHART_ROOT_BINDINGS = /* @__PURE__ */ new Map([
+  ["c", NS.c],
+  ["a", NS.a],
+  ["r", NS.r]
+]);
+var DECLARATION = / xmlns:([A-Za-z_][\w.-]*)="([^"]*)"/g;
+function stripDeclarations(xml, bindings) {
+  const conflicting = /* @__PURE__ */ new Set();
+  for (const [, prefix, uri] of xml.matchAll(DECLARATION))
+    if (prefix !== void 0 && bindings.has(prefix) && bindings.get(prefix) !== uri)
+      conflicting.add(prefix);
+  return xml.replace(
+    DECLARATION,
+    (match, prefix, uri) => bindings.get(prefix) === uri && !conflicting.has(prefix) ? "" : match
+  );
+}
+var innerXml = (element) => stripDeclarations(elements(element).map(buildXml).join(""), CHART_ROOT_BINDINGS);
+
+// chart/parse-util.ts
+var cChild = (parent, local) => first(parent, local, NS.c);
+var attribute = (element, name) => element?.hasAttribute(name) ? element.getAttribute(name) ?? void 0 : void 0;
+var cVal = (parent, local) => attribute(cChild(parent, local), "val");
+var path = (element) => `c:${element.parentNode?.localName ?? ""}/c:${element.localName}`;
+function malformed(context, element, value) {
+  context.issues.push({
+    code: "CHART_VALUE_INVALID",
+    message: `${path(element)} has an unreadable value "${value}".`
+  });
+}
+function cBool(context, parent, local) {
+  const element = cChild(parent, local);
+  if (!element) return void 0;
+  const raw2 = attribute(element, "val");
+  if (raw2 === void 0) return true;
+  const value = raw2.trim().toLowerCase();
+  if (value === "1" || value === "true") return true;
+  if (value === "0" || value === "false") return false;
+  malformed(context, element, raw2);
+  return void 0;
+}
+function cNumber(context, parent, local) {
+  const element = cChild(parent, local);
+  const raw2 = attribute(element, "val");
+  if (!element || raw2 === void 0) return void 0;
+  const value = raw2.trim() ? Number(raw2) : Number.NaN;
+  if (Number.isFinite(value)) return value;
+  malformed(context, element, raw2);
+  return void 0;
+}
+function reportUnmodelled(context, element, handled) {
+  for (const child2 of elements(element)) {
+    if (handled.has(child2.localName)) continue;
+    context.issues.push({
+      code: "CHART_ELEMENT_NOT_MODELLED",
+      message: `${path(child2)} is not modelled; it is kept only in the source part.`
+    });
+  }
+}
+function extensionList(parent) {
+  const extLst = cChild(parent, "extLst");
+  return extLst ? buildXml(extLst) : void 0;
+}
+function readShapeFields(spPr) {
+  const out = {};
+  const fill = parseDrawingFill(spPr);
+  if (fill) out.fill = fill;
+  const line2 = parseDrawingLine(first(spPr, "ln", NS.a));
+  if (line2) out.line = line2;
+  const effects = first(spPr, "effectLst", NS.a);
+  if (effects) out.effectsXml = buildXml(effects);
+  return out;
+}
+function shapeProperties(parent) {
+  const spPr = cChild(parent, "spPr");
+  if (!spPr) return void 0;
+  const out = readShapeFields(spPr);
+  const source = innerXml(spPr);
+  if (source) out.sourceXml = source;
+  return out;
+}
+function chartTextBody(element) {
+  const body = parseDrawingTextBody(element);
+  if (!body || !element) return body;
+  const source = innerXml(element);
+  if (source) body.sourceXml = source;
+  return body;
+}
+var textProperties = (parent) => chartTextBody(cChild(parent, "txPr"));
+function chartLines(parent, local) {
+  const element = cChild(parent, local);
+  if (!element) return void 0;
+  const spPr = shapeProperties(element);
+  return spPr ? { spPr } : {};
+}
+function numberFormat(parent) {
+  const element = cChild(parent, "numFmt");
+  const formatCode = attribute(element, "formatCode");
+  if (formatCode === void 0) return void 0;
+  const linked = attribute(element, "sourceLinked");
+  return {
+    formatCode,
+    ...linked === "1" || linked === "true" ? { sourceLinked: true } : {},
+    ...linked === "0" || linked === "false" ? { sourceLinked: false } : {}
+  };
+}
+function readLayoutFields(layout) {
+  const manual = cChild(layout, "manualLayout");
+  return (manual && readChartManualLayoutValues((name) => cVal(manual, name))) ?? {};
+}
+function manualLayout(parent) {
+  const layout = cChild(parent, "layout");
+  if (!layout) return void 0;
+  const out = readLayoutFields(layout);
+  const source = innerXml(layout);
+  if (source) out.sourceXml = source;
+  return out;
+}
+function assignDefined(target, values) {
+  for (const [key, value] of Object.entries(values))
+    if (value !== void 0) target[key] = value;
+  return target;
+}
+
+// chart/parse-text.ts
+function parseCache(node) {
+  const cache = {
+    type: node.localName === "numCache" || node.localName === "numLit" ? "number" : "string",
+    points: children(node, "pt", NS.c).map((pt) => {
+      const point = { value: cChild(pt, "v")?.textContent ?? "" };
+      const index = Number(attribute(pt, "idx") ?? Number.NaN);
+      if (Number.isInteger(index) && index >= 0) point.index = index;
+      const formatCode2 = attribute(pt, "formatCode");
+      if (formatCode2 !== void 0) point.formatCode = formatCode2;
+      return point;
+    })
+  };
+  const count = Number(cVal(node, "ptCount") ?? Number.NaN);
+  if (Number.isInteger(count) && count >= 0) cache.pointCount = count;
+  const formatCode = cChild(node, "formatCode")?.textContent;
+  if (formatCode) cache.formatCode = formatCode;
+  return cache;
+}
+function parseDataSource(element) {
+  if (!element) return void 0;
+  const source = {};
+  const ref = cChild(element, "numRef") ?? cChild(element, "strRef") ?? cChild(element, "multiLvlStrRef");
+  if (ref) {
+    source.kind = ref.localName;
+    const formula = cChild(ref, "f")?.textContent;
+    if (formula) source.formula = formula;
+    const cache = cChild(ref, "numCache") ?? cChild(ref, "strCache");
+    if (cache) source.cache = parseCache(cache);
+    const levels = cChild(ref, "multiLvlStrCache");
+    if (levels) {
+      source.levels = children(levels, "lvl", NS.c).map(parseCache);
+      const count = Number(cVal(levels, "ptCount") ?? Number.NaN);
+      if (Number.isInteger(count) && count >= 0) source.levelPointCount = count;
+    }
+    return source;
+  }
+  const literal = cChild(element, "numLit") ?? cChild(element, "strLit");
+  if (literal) {
+    source.kind = literal.localName;
+    source.cache = parseCache(literal);
+  }
+  return source;
+}
+function parseChartText(context, tx, allowValue) {
+  if (!tx) return void 0;
+  const text2 = {};
+  const rich = chartTextBody(cChild(tx, "rich"));
+  if (rich) text2.rich = rich;
+  if (cChild(tx, "strRef")) {
+    const reference2 = parseDataSource(tx);
+    if (reference2) text2.reference = reference2;
+  }
+  const value = allowValue ? cChild(tx, "v")?.textContent : void 0;
+  if (value !== void 0 && value !== null) text2.value = value;
+  const cached = chartCacheValues(text2.reference?.cache)[0];
+  const flat = text2.value ?? (rich ? rich.text : cached === void 0 ? void 0 : String(cached));
+  if (flat !== void 0) text2.text = flat;
+  reportUnmodelled(context, tx, new Set(allowValue ? ["strRef", "v"] : ["rich", "strRef"]));
+  return text2;
+}
+var TITLE = /* @__PURE__ */ new Set(["tx", "layout", "overlay", "spPr", "txPr", "extLst"]);
+function parseTitle(context, element) {
+  const tx = parseChartText(context, cChild(element, "tx"), false);
+  reportUnmodelled(context, element, TITLE);
+  return assignDefined(
+    {},
+    {
+      tx,
+      text: tx?.text,
+      overlay: cBool(context, element, "overlay"),
+      layout: manualLayout(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var LABEL_OPTIONS = [
+  "delete",
+  "showLegendKey",
+  "showVal",
+  "showCatName",
+  "showSerName",
+  "showPercent",
+  "showBubbleSize",
+  "separator",
+  "dLblPos",
+  "numFmt",
+  "spPr",
+  "txPr",
+  "extLst"
+];
+function labelOptions(context, element) {
+  const flag = (local) => cBool(context, element, local);
+  return assignDefined(
+    {},
+    {
+      deleted: flag("delete"),
+      showLegendKey: flag("showLegendKey"),
+      showValue: flag("showVal"),
+      showCategoryName: flag("showCatName"),
+      showSeriesName: flag("showSerName"),
+      showPercent: flag("showPercent"),
+      showBubbleSize: flag("showBubbleSize"),
+      separator: cChild(element, "separator")?.textContent ?? void 0,
+      position: cVal(element, "dLblPos"),
+      numberFormat: numberFormat(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var LABEL = /* @__PURE__ */ new Set([...LABEL_OPTIONS, "idx", "layout", "tx"]);
+var LABELS = /* @__PURE__ */ new Set([...LABEL_OPTIONS, "dLbl", "showLeaderLines", "leaderLines"]);
+function parseDataLabels(context, element) {
+  if (!element) return void 0;
+  const labels = children(element, "dLbl", NS.c).map((node) => {
+    reportUnmodelled(context, node, LABEL);
+    return assignDefined(labelOptions(context, node), {
+      index: cNumber(context, node, "idx"),
+      tx: parseChartText(context, cChild(node, "tx"), false),
+      layout: manualLayout(node)
+    });
+  });
+  reportUnmodelled(context, element, LABELS);
+  return assignDefined(
+    { ...labelOptions(context, element), labels },
+    {
+      showLeaderLines: cBool(context, element, "showLeaderLines"),
+      leaderLines: chartLines(element, "leaderLines")
+    }
+  );
+}
+
+// chart/parse-chrome.ts
+var SURFACE = /* @__PURE__ */ new Set(["thickness", "spPr", "pictureOptions", "extLst"]);
+function parseSurface(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, SURFACE);
+  const pictureOptions = cChild(element, "pictureOptions");
+  return assignDefined(
+    {},
+    {
+      thickness: cNumber(context, element, "thickness"),
+      spPr: shapeProperties(element),
+      pictureOptionsXml: pictureOptions ? buildXml(pictureOptions) : void 0,
+      extLst: extensionList(element)
+    }
+  );
+}
+var DATA_TABLE = /* @__PURE__ */ new Set([
+  "showHorzBorder",
+  "showVertBorder",
+  "showOutline",
+  "showKeys",
+  "spPr",
+  "txPr",
+  "extLst"
+]);
+function parseDataTable(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, DATA_TABLE);
+  return assignDefined(
+    {},
+    {
+      showHorizontalBorder: cBool(context, element, "showHorzBorder"),
+      showVerticalBorder: cBool(context, element, "showVertBorder"),
+      showOutline: cBool(context, element, "showOutline"),
+      showKeys: cBool(context, element, "showKeys"),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var DISPLAY_UNITS = /* @__PURE__ */ new Set(["custUnit", "builtInUnit", "dispUnitsLbl", "extLst"]);
+var DISPLAY_UNITS_LABEL = /* @__PURE__ */ new Set(["layout", "tx", "spPr", "txPr"]);
+function parseDisplayUnits(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, DISPLAY_UNITS);
+  const labelElement = cChild(element, "dispUnitsLbl");
+  let label;
+  if (labelElement) {
+    reportUnmodelled(context, labelElement, DISPLAY_UNITS_LABEL);
+    label = assignDefined(
+      {},
+      {
+        layout: manualLayout(labelElement),
+        tx: parseChartText(context, cChild(labelElement, "tx"), false),
+        spPr: shapeProperties(labelElement),
+        txPr: textProperties(labelElement)
+      }
+    );
+  }
+  return assignDefined(
+    {},
+    {
+      builtInUnit: cVal(element, "builtInUnit"),
+      customUnit: cNumber(context, element, "custUnit"),
+      label,
+      extLst: extensionList(element)
+    }
+  );
+}
+var DATA_DISPLAY_OPTIONS_URI = "{56B9EC1D-385E-4148-901F-78D8002777C0}";
+var C16R3 = "http://schemas.microsoft.com/office/drawing/2017/03/chart";
+function readDisplayNaAsBlank(chartExtLst) {
+  if (!chartExtLst?.includes(DATA_DISPLAY_OPTIONS_URI)) return void 0;
+  let root;
+  try {
+    root = parseXml(chartExtLst, { label: "Chart extension list" }).documentElement;
+  } catch {
+    return void 0;
+  }
+  for (const ext of elements(root)) {
+    if (ext.localName !== "ext" || attribute(ext, "uri") !== DATA_DISPLAY_OPTIONS_URI) continue;
+    const flag = first(first(ext, "dataDisplayOptions16", C16R3), "dispNaAsBlank", C16R3);
+    if (!flag) continue;
+    const raw2 = attribute(flag, "val")?.trim().toLowerCase();
+    return raw2 === void 0 || raw2 === "1" || raw2 === "true";
+  }
+  return void 0;
+}
+
+// chart/parse-series.ts
+var MARKER = /* @__PURE__ */ new Set(["symbol", "size", "spPr", "extLst"]);
+function parseMarker(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, MARKER);
+  return assignDefined(
+    {},
+    {
+      symbol: cVal(element, "symbol"),
+      size: cNumber(context, element, "size"),
+      spPr: shapeProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var POINT = /* @__PURE__ */ new Set([
+  "idx",
+  "invertIfNegative",
+  "marker",
+  "bubble3D",
+  "explosion",
+  "spPr",
+  "extLst"
+]);
+function parseDataPoint(context, element) {
+  reportUnmodelled(context, element, POINT);
+  const index = cNumber(context, element, "idx");
+  return assignDefined(
+    {},
+    {
+      index: index !== void 0 && Number.isInteger(index) && index >= 0 ? index : void 0,
+      invertIfNegative: cBool(context, element, "invertIfNegative"),
+      bubble3D: cBool(context, element, "bubble3D"),
+      explosion: cNumber(context, element, "explosion"),
+      marker: parseMarker(context, cChild(element, "marker")),
+      spPr: shapeProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var SERIES = /* @__PURE__ */ new Set([
+  "idx",
+  "order",
+  "tx",
+  "spPr",
+  "invertIfNegative",
+  "dPt",
+  "dLbls",
+  "cat",
+  "val",
+  "xVal",
+  "yVal",
+  "smooth",
+  "marker",
+  "explosion",
+  "bubbleSize",
+  "bubble3D",
+  "shape",
+  "extLst"
+]);
+function parseSeries(context, element) {
+  reportUnmodelled(context, element, SERIES);
+  return assignDefined(
+    { dataPoints: children(element, "dPt", NS.c).map((point) => parseDataPoint(context, point)) },
+    {
+      index: cNumber(context, element, "idx"),
+      order: cNumber(context, element, "order"),
+      tx: parseChartText(context, cChild(element, "tx"), true),
+      spPr: shapeProperties(element),
+      marker: parseMarker(context, cChild(element, "marker")),
+      dataLabels: parseDataLabels(context, cChild(element, "dLbls")),
+      categories: parseDataSource(cChild(element, "cat")),
+      values: parseDataSource(cChild(element, "val")),
+      xValues: parseDataSource(cChild(element, "xVal")),
+      yValues: parseDataSource(cChild(element, "yVal")),
+      bubbleSizes: parseDataSource(cChild(element, "bubbleSize")),
+      smooth: cBool(context, element, "smooth"),
+      invertIfNegative: cBool(context, element, "invertIfNegative"),
+      explosion: cNumber(context, element, "explosion"),
+      bubble3D: cBool(context, element, "bubble3D"),
+      shape: cVal(element, "shape"),
+      extLst: extensionList(element)
+    }
+  );
+}
+
+// chart/parse-plot.ts
+var CHART_GROUP_ELEMENTS = {
+  barChart: { kind: "bar", is3D: false },
+  bar3DChart: { kind: "bar", is3D: true },
+  lineChart: { kind: "line", is3D: false },
+  line3DChart: { kind: "line", is3D: true },
+  areaChart: { kind: "area", is3D: false },
+  area3DChart: { kind: "area", is3D: true },
+  pieChart: { kind: "pie", is3D: false },
+  pie3DChart: { kind: "pie", is3D: true },
+  ofPieChart: { kind: "ofPie", is3D: false },
+  doughnutChart: { kind: "doughnut", is3D: false },
+  scatterChart: { kind: "scatter", is3D: false },
+  radarChart: { kind: "radar", is3D: false },
+  bubbleChart: { kind: "bubble", is3D: false },
+  stockChart: { kind: "stock", is3D: false },
+  surfaceChart: { kind: "surface", is3D: false },
+  surface3DChart: { kind: "surface", is3D: true }
+};
+var AXIS_ELEMENTS = {
+  catAx: "cat",
+  valAx: "val",
+  dateAx: "date",
+  serAx: "ser"
+};
+var GROUP = /* @__PURE__ */ new Set([
+  "ser",
+  "axId",
+  "varyColors",
+  "dLbls",
+  "barDir",
+  "grouping",
+  "gapWidth",
+  "overlap",
+  "gapDepth",
+  "shape",
+  "marker",
+  "smooth",
+  "dropLines",
+  "hiLowLines",
+  "upDownBars",
+  "serLines",
+  "firstSliceAng",
+  "holeSize",
+  "ofPieType",
+  "scatterStyle",
+  "radarStyle",
+  "bubble3D",
+  "bubbleScale",
+  "showNegBubbles",
+  "sizeRepresents",
+  "wireframe",
+  "extLst"
+]);
+function parseGroup(context, element) {
+  const { kind, is3D } = CHART_GROUP_ELEMENTS[element.localName] ?? { kind: "bar", is3D: false };
+  reportUnmodelled(context, element, GROUP);
+  const number = (local) => cNumber(context, element, local);
+  const flag = (local) => cBool(context, element, local);
+  const barDir = cVal(element, "barDir");
+  const present = (local) => cChild(element, local) ? true : void 0;
+  const linesShape = (local) => chartLines(element, local)?.spPr;
+  const bars2 = cChild(element, "upDownBars");
+  return assignDefined(
+    {
+      kind,
+      element: element.localName,
+      is3D,
+      series: children(element, "ser", NS.c).map((ser) => parseSeries(context, ser)),
+      axisIds: children(element, "axId", NS.c).flatMap((axis) => {
+        const raw2 = attribute(axis, "val")?.trim();
+        const id = raw2 ? Number(raw2) : Number.NaN;
+        return Number.isFinite(id) ? [id] : [];
+      })
+    },
+    {
+      varyColors: flag("varyColors"),
+      dataLabels: parseDataLabels(context, cChild(element, "dLbls")),
+      barDirection: barDir === "bar" || barDir === "col" ? barDir : void 0,
+      grouping: cVal(element, "grouping"),
+      gapWidth: number("gapWidth"),
+      overlap: number("overlap"),
+      gapDepth: number("gapDepth"),
+      shape: cVal(element, "shape"),
+      marker: flag("marker"),
+      smooth: flag("smooth"),
+      dropLines: present("dropLines"),
+      hiLowLines: present("hiLowLines"),
+      upDownBars: present("upDownBars"),
+      seriesLines: present("serLines"),
+      dropLinesSpPr: linesShape("dropLines"),
+      hiLowLinesSpPr: linesShape("hiLowLines"),
+      seriesLinesSpPr: linesShape("serLines"),
+      upDownBarsGapWidth: cNumber(context, bars2, "gapWidth"),
+      upBars: chartLines(bars2, "upBars"),
+      downBars: chartLines(bars2, "downBars"),
+      firstSliceAngle: number("firstSliceAng"),
+      holeSize: number("holeSize"),
+      ofPieType: cVal(element, "ofPieType"),
+      scatterStyle: cVal(element, "scatterStyle"),
+      radarStyle: cVal(element, "radarStyle"),
+      bubble3D: flag("bubble3D"),
+      bubbleScale: number("bubbleScale"),
+      showNegativeBubbles: flag("showNegBubbles"),
+      sizeRepresents: cVal(element, "sizeRepresents"),
+      wireframe: flag("wireframe"),
+      extLst: extensionList(element)
+    }
+  );
+}
+var SCALING = /* @__PURE__ */ new Set(["orientation", "logBase", "min", "max", "extLst"]);
+var AXIS = /* @__PURE__ */ new Set([
+  "axId",
+  "scaling",
+  "delete",
+  "axPos",
+  "majorGridlines",
+  "minorGridlines",
+  "title",
+  "numFmt",
+  "majorTickMark",
+  "minorTickMark",
+  "tickLblPos",
+  "spPr",
+  "txPr",
+  "crossAx",
+  "crosses",
+  "crossesAt",
+  "crossBetween",
+  "majorUnit",
+  "minorUnit",
+  "auto",
+  "lblAlgn",
+  "lblOffset",
+  "tickLblSkip",
+  "tickMarkSkip",
+  "noMultiLvlLbl",
+  "baseTimeUnit",
+  "dispUnits",
+  "extLst"
+]);
+function parseAxis(context, element, kind) {
+  reportUnmodelled(context, element, AXIS);
+  const number = (local) => cNumber(context, element, local);
+  const scalingElement = cChild(element, "scaling");
+  if (scalingElement) reportUnmodelled(context, scalingElement, SCALING);
+  const scaling = assignDefined(
+    {},
+    {
+      orientation: cVal(scalingElement, "orientation"),
+      min: cNumber(context, scalingElement, "min"),
+      max: cNumber(context, scalingElement, "max"),
+      logBase: cNumber(context, scalingElement, "logBase")
+    }
+  );
+  const title = cChild(element, "title");
+  return assignDefined(
+    {
+      kind,
+      scaling,
+      majorGridlines: cChild(element, "majorGridlines") !== void 0,
+      minorGridlines: cChild(element, "minorGridlines") !== void 0
+    },
+    {
+      majorGridlinesSpPr: chartLines(element, "majorGridlines")?.spPr,
+      minorGridlinesSpPr: chartLines(element, "minorGridlines")?.spPr,
+      id: number("axId"),
+      crossAxisId: number("crossAx"),
+      position: cVal(element, "axPos"),
+      deleted: cBool(context, element, "delete"),
+      title: title ? parseTitle(context, title) : void 0,
+      numberFormat: numberFormat(element),
+      majorTickMark: cVal(element, "majorTickMark"),
+      minorTickMark: cVal(element, "minorTickMark"),
+      tickLabelPosition: cVal(element, "tickLblPos"),
+      crosses: cVal(element, "crosses"),
+      crossesAt: number("crossesAt"),
+      crossBetween: cVal(element, "crossBetween"),
+      majorUnit: number("majorUnit"),
+      minorUnit: number("minorUnit"),
+      auto: cBool(context, element, "auto"),
+      labelAlign: cVal(element, "lblAlgn"),
+      labelOffset: number("lblOffset"),
+      tickLabelSkip: number("tickLblSkip"),
+      tickMarkSkip: number("tickMarkSkip"),
+      noMultiLevelLabels: cBool(context, element, "noMultiLvlLbl"),
+      baseTimeUnit: cVal(element, "baseTimeUnit"),
+      displayUnits: parseDisplayUnits(context, cChild(element, "dispUnits")),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var PLOT_AREA = /* @__PURE__ */ new Set(["layout", "dTable", "spPr", "extLst"]);
+function parsePlotArea(context, element) {
+  const plotArea = { groups: [], axes: [] };
+  if (!element) {
+    context.issues.push({
+      code: "CHART_PLOT_AREA_MISSING",
+      message: "The chart has no c:plotArea."
+    });
+    return plotArea;
+  }
+  const handled = new Set(PLOT_AREA);
+  for (const child2 of elements(element)) {
+    if (CHART_GROUP_ELEMENTS[child2.localName]) {
+      plotArea.groups.push(parseGroup(context, child2));
+      handled.add(child2.localName);
+    }
+    const axis = AXIS_ELEMENTS[child2.localName];
+    if (axis) {
+      plotArea.axes.push(parseAxis(context, child2, axis));
+      handled.add(child2.localName);
+    }
+  }
+  reportUnmodelled(context, element, handled);
+  return assignDefined(plotArea, {
+    layout: manualLayout(element),
+    dataTable: parseDataTable(context, cChild(element, "dTable")),
+    spPr: shapeProperties(element),
+    extLst: extensionList(element)
+  });
+}
+
+// chart/parse-space.ts
+var LEGEND = /* @__PURE__ */ new Set(["legendPos", "legendEntry", "layout", "overlay", "spPr", "txPr", "extLst"]);
+function parseLegend(context, element) {
+  reportUnmodelled(context, element, LEGEND);
+  const entries = children(element, "legendEntry", NS.c).map(
+    (entry3) => assignDefined(
+      {},
+      {
+        index: cNumber(context, entry3, "idx"),
+        deleted: cBool(context, entry3, "delete"),
+        txPr: textProperties(entry3)
+      }
+    )
+  );
+  return assignDefined(
+    { entries },
+    {
+      position: cVal(element, "legendPos"),
+      overlay: cBool(context, element, "overlay"),
+      layout: manualLayout(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var VIEW_3D = /* @__PURE__ */ new Set(["rotX", "rotY", "depthPercent", "hPercent", "rAngAx", "perspective"]);
+function parseView3D(context, element) {
+  reportUnmodelled(context, element, VIEW_3D);
+  return assignDefined(
+    {},
+    {
+      rotX: cNumber(context, element, "rotX"),
+      rotY: cNumber(context, element, "rotY"),
+      depthPercent: cNumber(context, element, "depthPercent"),
+      heightPercent: cNumber(context, element, "hPercent"),
+      rightAngleAxes: cBool(context, element, "rAngAx"),
+      perspective: cNumber(context, element, "perspective")
+    }
+  );
+}
+function chartStyle(context, space) {
+  const direct = cNumber(context, space, "style");
+  if (direct !== void 0) return direct;
+  for (const alternate of children(space, "AlternateContent", NS.mc)) {
+    const style = cNumber(context, first(alternate, "Fallback", NS.mc), "style");
+    if (style !== void 0) return style;
+  }
+  return void 0;
+}
+function c14Style(space) {
+  for (const alternate of children(space, "AlternateContent", NS.mc)) {
+    const raw2 = attribute(first(first(alternate, "Choice", NS.mc), "style", NS.c14, false), "val");
+    const value = raw2?.trim() ? Number(raw2) : Number.NaN;
+    if (Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function namespaceDeclarations(root) {
+  const out = [];
+  for (const item of Array.from(root.attributes)) {
+    if (item.prefix !== "xmlns" || CHART_ROOT_BINDINGS.get(item.localName) === item.value) continue;
+    out.push({ prefix: item.localName, uri: item.value });
+  }
+  return out.length ? out : void 0;
+}
+var CHART = /* @__PURE__ */ new Set([
+  "title",
+  "autoTitleDeleted",
+  "view3D",
+  "floor",
+  "sideWall",
+  "backWall",
+  "plotArea",
+  "legend",
+  "plotVisOnly",
+  "dispBlanksAs",
+  "showDLblsOverMax",
+  "extLst"
+]);
+var SPACE = /* @__PURE__ */ new Set([
+  "date1904",
+  "lang",
+  "roundedCorners",
+  "AlternateContent",
+  "style",
+  "chart",
+  "spPr",
+  "txPr",
+  "externalData",
+  "printSettings",
+  "userShapes",
+  "extLst"
+]);
+function parseChartSpace(source) {
+  const context = { issues: [] };
+  const root = typeof source === "string" ? parseXml(source, { label: "Chart part" }).documentElement : source;
+  if (root.localName !== "chartSpace" || root.namespaceURI && root.namespaceURI !== NS.c) {
+    context.issues.push({
+      code: "CHART_ROOT_UNEXPECTED",
+      message: `The part root is {${root.namespaceURI ?? ""}}${root.localName}, not c:chartSpace (chartex parts are not modelled).`
+    });
+    return { chartSpace: { plotArea: { groups: [], axes: [] } }, issues: context.issues };
+  }
+  reportUnmodelled(context, root, SPACE);
+  const chart = cChild(root, "chart");
+  if (!chart)
+    context.issues.push({ code: "CHART_CHART_MISSING", message: "The part has no c:chart." });
+  else reportUnmodelled(context, chart, CHART);
+  const title = cChild(chart, "title");
+  const legend = cChild(chart, "legend");
+  const view3D = cChild(chart, "view3D");
+  const printSettings = cChild(root, "printSettings");
+  const chartSpace = assignDefined(
+    { plotArea: parsePlotArea(context, cChild(chart, "plotArea")) },
+    {
+      date1904: cBool(context, root, "date1904"),
+      language: cVal(root, "lang"),
+      roundedCorners: cBool(context, root, "roundedCorners"),
+      style: chartStyle(context, root),
+      c14Style: c14Style(root),
+      title: title ? parseTitle(context, title) : void 0,
+      autoTitleDeleted: cBool(context, chart, "autoTitleDeleted"),
+      view3D: view3D ? parseView3D(context, view3D) : void 0,
+      floor: parseSurface(context, cChild(chart, "floor")),
+      sideWall: parseSurface(context, cChild(chart, "sideWall")),
+      backWall: parseSurface(context, cChild(chart, "backWall")),
+      legend: legend ? parseLegend(context, legend) : void 0,
+      plotVisibleOnly: cBool(context, chart, "plotVisOnly"),
+      displayBlanksAs: cVal(chart, "dispBlanksAs"),
+      showDataLabelsOverMax: cBool(context, chart, "showDLblsOverMax"),
+      spPr: shapeProperties(root),
+      txPr: textProperties(root),
+      externalDataRelId: relAttr(cChild(root, "externalData"), "id") || void 0,
+      externalDataAutoUpdate: cBool(context, cChild(root, "externalData"), "autoUpdate"),
+      printSettings: printSettings ? buildXml(printSettings) : void 0,
+      userShapesRelId: relAttr(cChild(root, "userShapes"), "id") || void 0,
+      chartExtLst: extensionList(chart),
+      extLst: extensionList(root),
+      namespaceDeclarations: namespaceDeclarations(root)
+    }
+  );
+  return { chartSpace, issues: context.issues };
+}
+
+// drawingml/write-line.ts
+var FILLS = /* @__PURE__ */ new Set(["noFill", "solidFill", "gradFill", "pattFill"]);
+function dropDrawingDeclarations(element) {
+  if (element.getAttribute("xmlns:a") === NS.a) element.removeAttribute("xmlns:a");
+  for (const child2 of elements(element)) dropDrawingDeclarations(child2);
+}
+function patchDrawingLine(ln, line2) {
+  if (line2.widthEmu === void 0) ln.removeAttribute("w");
+  else ln.setAttribute("w", String(Math.round(line2.widthEmu)));
+  if (line2.cap === void 0) ln.removeAttribute("cap");
+  else ln.setAttribute("cap", line2.cap);
+  const fill = line2.fill && drawingFillXml(line2.fill);
+  if (fill || !line2.fill) {
+    for (const node of elements(ln))
+      if (node.namespaceURI === NS.a && FILLS.has(node.localName)) ln.removeChild(node);
+  }
+  if (fill) {
+    const parsed = parseXml(`<w xmlns:a="${NS.a}">${fill}</w>`).documentElement;
+    for (const node of elements(parsed).reverse()) {
+      const imported = ln.ownerDocument.importNode(node, true);
+      dropDrawingDeclarations(imported);
+      ln.insertBefore(imported, ln.firstChild);
+    }
+  }
+  const dashes = elements(ln).filter(
+    (node) => node.namespaceURI === NS.a && (node.localName === "prstDash" || node.localName === "custDash")
+  );
+  if (line2.dash === void 0) {
+    for (const node of dashes) if (node.localName === "prstDash") ln.removeChild(node);
+    return;
+  }
+  const dash = ln.ownerDocument.createElementNS(NS.a, "a:prstDash");
+  dash.setAttribute("val", line2.dash);
+  for (const node of dashes) ln.removeChild(node);
+  const afterFill = elements(ln).find(
+    (node) => node.namespaceURI !== NS.a || !FILLS.has(node.localName)
+  );
+  ln.insertBefore(dash, afterFill ?? null);
+}
+function drawingLineXml(line2) {
+  const doc = parseXml(`<a:ln xmlns:a="${NS.a}"/>`);
+  patchDrawingLine(doc.documentElement, line2);
+  return buildXml(doc);
+}
+
+// chart/write-util.ts
+var INVALID_XML = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/g;
+var escapeText = (value) => value.replace(INVALID_XML, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttribute = (value) => escapeText(value).replace(/"/g, "&quot;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
+function chartNumber(value) {
+  if (!Number.isFinite(value)) throw new Error(`Chart number ${value} is not finite`);
+  const text2 = String(value);
+  const match = /^(-?)(\d+)(?:\.(\d+))?e([+-]\d+)$/i.exec(text2);
+  if (!match) return text2;
+  const [, sign = "", whole = "", fraction = "", exponent = "0"] = match;
+  const digits = whole + fraction;
+  const point = whole.length + Number(exponent);
+  const body = point <= 0 ? `0.${"0".repeat(-point)}${digits}` : point >= digits.length ? digits + "0".repeat(point - digits.length) : `${digits.slice(0, point)}.${digits.slice(point)}`;
+  return sign + body.replace(/^0+(?=\d)/, "");
+}
+function valXml(local, value) {
+  if (value === void 0) return "";
+  const text2 = typeof value === "boolean" ? value ? "1" : "0" : typeof value === "number" ? chartNumber(value) : escapeAttribute(value);
+  return `<c:${local} val="${text2}"/>`;
+}
+var elementXml = (local, content, attributes = "") => content ? `<c:${local}${attributes}>${content}</c:${local}>` : `<c:${local}${attributes}/>`;
+var raw = (context, xml) => xml ? stripDeclarations(xml, context.bindings) : "";
+function sameValue(left, right) {
+  if (left === right) return true;
+  if (typeof left !== "object" || typeof right !== "object" || !left || !right) return false;
+  if (Array.isArray(left) !== Array.isArray(right)) return false;
+  const entries = (value) => Object.entries(value).filter(([, item]) => item !== void 0);
+  const a2 = entries(left);
+  const b = new Map(entries(right));
+  return a2.length === b.size && a2.every(([key, item]) => b.has(key) && sameValue(item, b.get(key)));
+}
+
+// chart/write-text-body.ts
+function runProperties(local, properties2) {
+  const p = properties2 ?? {};
+  const attributes = [
+    p.sizePt === void 0 ? "" : ` sz="${Math.round(p.sizePt * 100)}"`,
+    p.bold === void 0 ? "" : ` b="${p.bold ? 1 : 0}"`,
+    p.italic === void 0 ? "" : ` i="${p.italic ? 1 : 0}"`,
+    p.underline === void 0 ? "" : ` u="${p.underline ? "sng" : "none"}"`
+  ].join("");
+  const children2 = (p.color ? `<a:solidFill>${drawingColorXml(p.color)}</a:solidFill>` : "") + (p.typeface ? `<a:latin typeface="${escapeAttribute(p.typeface)}"/>` : "");
+  return children2 ? `<a:${local}${attributes}>${children2}</a:${local}>` : `<a:${local}${attributes}/>`;
+}
+function spacing(local, value) {
+  if (!value) return "";
+  const inner = value.unit === "points" ? `<a:spcPts val="${Math.round(value.value * 100)}"/>` : `<a:spcPct val="${Math.round(value.value * 1e5)}"/>`;
+  return `<a:${local}>${inner}</a:${local}>`;
+}
+function run(value) {
+  const { text: text2, ...properties2 } = value;
+  const hasProperties = Object.keys(properties2).length > 0;
+  if (text2 === "\n")
+    return hasProperties ? `<a:br>${runProperties("rPr", properties2)}</a:br>` : "<a:br/>";
+  return `<a:r>${hasProperties ? runProperties("rPr", properties2) : ""}<a:t>${escapeText(text2)}</a:t></a:r>`;
+}
+function paragraph(value) {
+  const align = value.align ? ` algn="${escapeAttribute(value.align)}"` : "";
+  const properties2 = spacing("lnSpc", value.lineSpacing) + spacing("spcBef", value.spaceBefore) + spacing("spcAft", value.spaceAfter) + runProperties("defRPr", value.defaultProperties);
+  return `<a:p><a:pPr${align}>${properties2}</a:pPr>${value.runs.map(run).join("")}</a:p>`;
+}
+function writeTextBody(body) {
+  const insets = body.insetsEmu ?? {};
+  const attributes = [
+    ["lIns", insets.left],
+    ["tIns", insets.top],
+    ["rIns", insets.right],
+    ["bIns", insets.bottom]
+  ].map(([name, value]) => value === void 0 ? "" : ` ${name}="${Math.round(Number(value))}"`).join("");
+  const anchor = body.anchor ? ` anchor="${escapeAttribute(body.anchor)}"` : "";
+  const paragraphs = body.paragraphs.length ? body.paragraphs.map(paragraph).join("") : paragraph({ runs: [] });
+  return `<a:bodyPr${attributes}${anchor}/><a:lstStyle/>${paragraphs}`;
+}
+
+// chart/write-shape.ts
+var ROOT_DECLARATIONS = [...CHART_ROOT_BINDINGS].map(([prefix, uri]) => ` xmlns:${prefix}="${uri}"`).join("");
+var wrap = (local, xml) => parseXml(`<c:${local}${ROOT_DECLARATIONS}>${xml}</c:${local}>`, { label: "Chart" }).documentElement;
+function chartFillXml(fill) {
+  if (fill.kind !== "pattern") return drawingFillXml(fill);
+  const color = (local, value) => {
+    const choice = local === "fgClr" ? value.foreground : value.background;
+    return choice ? `<a:${local}>${drawingColorXml(choice)}</a:${local}>` : "";
+  };
+  return `<a:pattFill prst="${escapeAttribute(fill.preset)}">${color("fgClr", fill)}${color("bgClr", fill)}</a:pattFill>`;
+}
+var AFTER_LINE = ["effectLst", "effectDag", "scene3d", "sp3d", "extLst"];
+var AFTER_EFFECTS = ["effectDag", "scene3d", "sp3d", "extLst"];
+var firstOf = (parent, names) => elements(parent).find((node) => node.namespaceURI === NS.a && names.includes(node.localName)) ?? null;
+function patchShape(root, shape, read) {
+  const doc = root.ownerDocument;
+  if (!sameValue(read.fill, shape.fill)) {
+    const xml = shape.fill && chartFillXml(shape.fill);
+    if (xml) setDrawingFillXml(root, xml);
+    else if (!shape.fill)
+      for (let fill = fillElementOf(root); fill; fill = fillElementOf(root)) root.removeChild(fill);
+  }
+  if (!sameValue(read.line, shape.line)) {
+    let ln = first(root, "ln", NS.a);
+    if (!shape.line) {
+      if (ln) root.removeChild(ln);
+    } else {
+      if (!ln) {
+        ln = doc.createElementNS(NS.a, "a:ln");
+        root.insertBefore(ln, firstOf(root, AFTER_LINE));
+      }
+      patchDrawingLine(ln, shape.line);
+    }
+  }
+  if (read.effectsXml !== shape.effectsXml) {
+    const old = first(root, "effectLst", NS.a);
+    if (old) root.removeChild(old);
+    if (shape.effectsXml) {
+      const effects = elements(wrap("w", shape.effectsXml))[0];
+      if (effects?.namespaceURI !== NS.a || effects.localName !== "effectLst")
+        throw new Error("Invalid chart effects XML");
+      root.insertBefore(doc.importNode(effects, true), firstOf(root, AFTER_EFFECTS));
+    }
+  }
+}
+function shapePropertiesXml(context, shape) {
+  if (!shape) return "";
+  const { sourceXml, ...fields } = shape;
+  let inner;
+  if (sourceXml !== void 0) {
+    const root = wrap("spPr", sourceXml);
+    const read = readShapeFields(root);
+    if (sameValue(read, fields)) inner = sourceXml;
+    else {
+      patchShape(root, fields, read);
+      inner = innerXml(root);
+    }
+  } else {
+    const fill = fields.fill && chartFillXml(fields.fill);
+    inner = (fill ?? "") + (fields.line ? drawingLineXml(fields.line) : "") + (fields.effectsXml ?? "");
+  }
+  return elementXml("spPr", raw(context, inner));
+}
+function textBodyInnerXml(context, body) {
+  const { sourceXml, ...fields } = body;
+  if (sourceXml !== void 0) {
+    const read = parseDrawingTextBody(wrap("txPr", sourceXml));
+    if (sameValue(read, fields)) return raw(context, sourceXml);
+  }
+  return raw(context, writeTextBody(fields));
+}
+var textBodyXml = (context, body, local = "txPr") => body ? elementXml(local, textBodyInnerXml(context, body)) : "";
+var LAYOUT_FIELDS = [
+  ["layoutTarget", "layoutTarget"],
+  ["xMode", "xMode"],
+  ["yMode", "yMode"],
+  ["wMode", "widthMode"],
+  ["hMode", "heightMode"],
+  ["x", "x"],
+  ["y", "y"],
+  ["w", "width"],
+  ["h", "height"]
+];
+function layoutXml(context, value) {
+  if (!value) return "";
+  const { sourceXml, ...layout } = value;
+  if (sourceXml !== void 0 && sameValue(readLayoutFields(wrap("layout", sourceXml)), layout))
+    return elementXml("layout", raw(context, sourceXml));
+  const manual = LAYOUT_FIELDS.map(([local, key]) => {
+    const value2 = layout[key];
+    if (value2 === void 0) return "";
+    const text2 = typeof value2 === "number" ? chartNumber(value2) : value2;
+    return `<c:${local} val="${text2}"/>`;
+  }).join("");
+  return elementXml("layout", manual ? `<c:manualLayout>${manual}</c:manualLayout>` : "");
+}
+function numberFormatXml(format) {
+  if (!format) return "";
+  const linked = format.sourceLinked === void 0 ? "" : ` sourceLinked="${format.sourceLinked ? 1 : 0}"`;
+  return `<c:numFmt formatCode="${escapeAttribute(format.formatCode)}"${linked}/>`;
+}
+
+// chart/write-text.ts
+var textElement = (local, value) => `<c:${local}>${escapeText(value)}</c:${local}>`;
+function cachePoints(cache) {
+  return cache.points.map((point, position) => {
+    const format = point.formatCode === void 0 ? "" : ` formatCode="${escapeAttribute(point.formatCode)}"`;
+    return `<c:pt idx="${point.index ?? position}"${format}>${textElement("v", point.value)}</c:pt>`;
+  }).join("");
+}
+function cacheXml(local, cache, withFormat) {
+  if (!cache) return "";
+  const format = withFormat && cache.formatCode !== void 0 ? textElement("formatCode", cache.formatCode) : "";
+  return elementXml(local, format + valXml("ptCount", cache.pointCount) + cachePoints(cache));
+}
+function dataSourceInner(source) {
+  const formula = textElement("f", source.formula ?? "");
+  switch (source.kind) {
+    case "numRef":
+      return `<c:numRef>${formula}${cacheXml("numCache", source.cache, true)}</c:numRef>`;
+    case "strRef":
+      return `<c:strRef>${formula}${cacheXml("strCache", source.cache, false)}</c:strRef>`;
+    case "multiLvlStrRef": {
+      const levels = source.levels ? elementXml(
+        "multiLvlStrCache",
+        valXml("ptCount", source.levelPointCount) + source.levels.map((level) => elementXml("lvl", cachePoints(level))).join("")
+      ) : "";
+      return `<c:multiLvlStrRef>${formula}${levels}</c:multiLvlStrRef>`;
+    }
+    case "numLit":
+      return cacheXml("numLit", source.cache ?? { points: [] }, true);
+    case "strLit":
+      return cacheXml("strLit", source.cache ?? { points: [] }, false);
+    default:
+      return "";
+  }
+}
+var dataSourceXml = (local, source) => source ? elementXml(local, dataSourceInner(source)) : "";
+function chartTextXml(context, text2, seriesName2) {
+  if (!text2) return "";
+  if (text2.reference) return elementXml("tx", dataSourceInner(text2.reference));
+  if (seriesName2) {
+    const value = text2.value ?? text2.text;
+    return elementXml("tx", value === void 0 ? "" : textElement("v", value));
+  }
+  if (text2.rich) return elementXml("tx", textBodyXml(context, text2.rich, "rich"));
+  if (text2.text === void 0) return "<c:tx/>";
+  const paragraphs = text2.text.split("\n").map((line2) => ({ runs: [{ text: line2 }] }));
+  return `<c:tx><c:rich>${writeTextBody({ paragraphs })}</c:rich></c:tx>`;
+}
+function titleXml(context, title) {
+  if (!title) return "";
+  const tx = title.tx ?? (title.text === void 0 ? void 0 : { text: title.text });
+  return elementXml(
+    "title",
+    chartTextXml(context, tx, false) + layoutXml(context, title.layout) + valXml("overlay", title.overlay) + shapePropertiesXml(context, title.spPr) + textBodyXml(context, title.txPr) + raw(context, title.extLst)
+  );
+}
+function labelOptionsXml(context, options) {
+  return numberFormatXml(options.numberFormat) + shapePropertiesXml(context, options.spPr) + textBodyXml(context, options.txPr) + valXml("dLblPos", options.position) + valXml("showLegendKey", options.showLegendKey) + valXml("showVal", options.showValue) + valXml("showCatName", options.showCategoryName) + valXml("showSerName", options.showSeriesName) + valXml("showPercent", options.showPercent) + valXml("showBubbleSize", options.showBubbleSize) + (options.separator === void 0 ? "" : textElement("separator", options.separator));
+}
+function labelXml(context, label) {
+  return elementXml(
+    "dLbl",
+    valXml("idx", label.index) + valXml("delete", label.deleted) + layoutXml(context, label.layout) + chartTextXml(context, label.tx, false) + labelOptionsXml(context, label) + raw(context, label.extLst)
+  );
+}
+function dataLabelsXml(context, labels) {
+  if (!labels) return "";
+  const leaderLines = labels.leaderLines ? elementXml("leaderLines", shapePropertiesXml(context, labels.leaderLines.spPr)) : "";
+  return elementXml(
+    "dLbls",
+    labels.labels.map((label) => labelXml(context, label)).join("") + valXml("delete", labels.deleted) + labelOptionsXml(context, labels) + valXml("showLeaderLines", labels.showLeaderLines) + leaderLines + raw(context, labels.extLst)
+  );
+}
+
+// chart/write-chrome.ts
+function surfaceXml(context, local, surface) {
+  if (!surface) return "";
+  return elementXml(
+    local,
+    valXml("thickness", surface.thickness) + shapePropertiesXml(context, surface.spPr) + raw(context, surface.pictureOptionsXml) + raw(context, surface.extLst)
+  );
+}
+function dataTableXml(context, table) {
+  if (!table) return "";
+  return elementXml(
+    "dTable",
+    valXml("showHorzBorder", table.showHorizontalBorder) + valXml("showVertBorder", table.showVerticalBorder) + valXml("showOutline", table.showOutline) + valXml("showKeys", table.showKeys) + shapePropertiesXml(context, table.spPr) + textBodyXml(context, table.txPr) + raw(context, table.extLst)
+  );
+}
+function displayUnitsXml(context, units2) {
+  if (!units2) return "";
+  const label = units2.label;
+  return elementXml(
+    "dispUnits",
+    valXml("custUnit", units2.customUnit) + (units2.customUnit === void 0 ? valXml("builtInUnit", units2.builtInUnit) : "") + (label ? elementXml(
+      "dispUnitsLbl",
+      layoutXml(context, label.layout) + chartTextXml(context, label.tx, false) + shapePropertiesXml(context, label.spPr) + textBodyXml(context, label.txPr)
+    ) : "") + raw(context, units2.extLst)
+  );
+}
+
+// chart/write-axes.ts
+var AXIS_ELEMENTS2 = {
+  cat: "catAx",
+  val: "valAx",
+  date: "dateAx",
+  ser: "serAx"
+};
+var gridlinesXml = (context, local, present, shape) => present ? elementXml(local, shapePropertiesXml(context, shape)) : "";
+function axisXml(context, axis) {
+  const { scaling } = axis;
+  return elementXml(
+    AXIS_ELEMENTS2[axis.kind],
+    valXml("axId", axis.id) + elementXml(
+      "scaling",
+      valXml("logBase", scaling.logBase) + valXml("orientation", scaling.orientation) + valXml("max", scaling.max) + valXml("min", scaling.min)
+    ) + valXml("delete", axis.deleted) + valXml("axPos", axis.position) + gridlinesXml(context, "majorGridlines", axis.majorGridlines, axis.majorGridlinesSpPr) + gridlinesXml(context, "minorGridlines", axis.minorGridlines, axis.minorGridlinesSpPr) + titleXml(context, axis.title) + numberFormatXml(axis.numberFormat) + valXml("majorTickMark", axis.majorTickMark) + valXml("minorTickMark", axis.minorTickMark) + valXml("tickLblPos", axis.tickLabelPosition) + shapePropertiesXml(context, axis.spPr) + textBodyXml(context, axis.txPr) + valXml("crossAx", axis.crossAxisId) + valXml("crosses", axis.crosses) + valXml("crossesAt", axis.crossesAt) + valXml("crossBetween", axis.crossBetween) + valXml("auto", axis.auto) + valXml("lblAlgn", axis.labelAlign) + valXml("lblOffset", axis.labelOffset) + valXml("baseTimeUnit", axis.baseTimeUnit) + valXml("majorUnit", axis.majorUnit) + valXml("minorUnit", axis.minorUnit) + displayUnitsXml(context, axis.displayUnits) + valXml("tickLblSkip", axis.tickLabelSkip) + valXml("tickMarkSkip", axis.tickMarkSkip) + valXml("noMultiLvlLbl", axis.noMultiLevelLabels) + raw(context, axis.extLst)
+  );
+}
+
+// chart/write-series.ts
+function markerXml(context, marker) {
+  if (!marker) return "";
+  return elementXml(
+    "marker",
+    valXml("symbol", marker.symbol) + valXml("size", marker.size) + shapePropertiesXml(context, marker.spPr) + raw(context, marker.extLst)
+  );
+}
+function dataPointXml(context, point) {
+  return elementXml(
+    "dPt",
+    valXml("idx", point.index) + valXml("invertIfNegative", point.invertIfNegative) + markerXml(context, point.marker) + valXml("bubble3D", point.bubble3D) + valXml("explosion", point.explosion) + shapePropertiesXml(context, point.spPr) + raw(context, point.extLst)
+  );
+}
+function seriesXml(context, series, position) {
+  return elementXml(
+    "ser",
+    valXml("idx", series.index ?? position) + valXml("order", series.order ?? position) + chartTextXml(context, series.tx, true) + shapePropertiesXml(context, series.spPr) + valXml("invertIfNegative", series.invertIfNegative) + markerXml(context, series.marker) + valXml("explosion", series.explosion) + series.dataPoints.map((point) => dataPointXml(context, point)).join("") + dataLabelsXml(context, series.dataLabels) + dataSourceXml("cat", series.categories) + dataSourceXml("val", series.values) + dataSourceXml("xVal", series.xValues) + dataSourceXml("yVal", series.yValues) + dataSourceXml("bubbleSize", series.bubbleSizes) + valXml("smooth", series.smooth) + valXml("shape", series.shape) + valXml("bubble3D", series.bubble3D) + raw(context, series.extLst)
+  );
+}
+
+// chart/write-plot.ts
+var linesXml = (context, local, present, shape) => present ? elementXml(local, shapePropertiesXml(context, shape)) : "";
+var barsXml = (context, local, bars2) => bars2 ? elementXml(local, shapePropertiesXml(context, bars2.spPr)) : "";
+function upDownBarsXml(context, group) {
+  if (!group.upDownBars) return "";
+  return elementXml(
+    "upDownBars",
+    valXml("gapWidth", group.upDownBarsGapWidth) + barsXml(context, "upBars", group.upBars) + barsXml(context, "downBars", group.downBars)
+  );
+}
+function groupElement(group) {
+  if (Object.hasOwn(CHART_GROUP_ELEMENTS, group.element)) return group.element;
+  const match = Object.entries(CHART_GROUP_ELEMENTS).find(
+    ([, value]) => value.kind === group.kind && value.is3D === group.is3D
+  );
+  if (!match) throw new Error(`No chart group element for ${group.kind}`);
+  return match[0];
+}
+function groupXml(context, group) {
+  return elementXml(
+    groupElement(group),
+    valXml("ofPieType", group.ofPieType) + valXml("scatterStyle", group.scatterStyle) + valXml("radarStyle", group.radarStyle) + valXml("wireframe", group.wireframe) + valXml("barDir", group.barDirection) + valXml("grouping", group.grouping) + valXml("varyColors", group.varyColors) + group.series.map((series, position) => seriesXml(context, series, position)).join("") + dataLabelsXml(context, group.dataLabels) + valXml("gapWidth", group.gapWidth) + valXml("overlap", group.overlap) + linesXml(context, "dropLines", group.dropLines, group.dropLinesSpPr) + linesXml(context, "hiLowLines", group.hiLowLines, group.hiLowLinesSpPr) + upDownBarsXml(context, group) + valXml("marker", group.marker) + valXml("smooth", group.smooth) + valXml("gapDepth", group.gapDepth) + valXml("shape", group.shape) + valXml("firstSliceAng", group.firstSliceAngle) + valXml("holeSize", group.holeSize) + valXml("bubble3D", group.bubble3D) + valXml("bubbleScale", group.bubbleScale) + valXml("showNegBubbles", group.showNegativeBubbles) + valXml("sizeRepresents", group.sizeRepresents) + linesXml(context, "serLines", group.seriesLines, group.seriesLinesSpPr) + group.axisIds.map((id) => valXml("axId", id)).join("") + raw(context, group.extLst)
+  );
+}
+function plotAreaXml(context, plotArea) {
+  return elementXml(
+    "plotArea",
+    layoutXml(context, plotArea.layout) + plotArea.groups.map((group) => groupXml(context, group)).join("") + plotArea.axes.map((axis) => axisXml(context, axis)).join("") + dataTableXml(context, plotArea.dataTable) + shapePropertiesXml(context, plotArea.spPr) + raw(context, plotArea.extLst)
+  );
+}
+
+// chart/write-space.ts
+var DECLARATION2 = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+function view3DXml(view) {
+  if (!view) return "";
+  return elementXml(
+    "view3D",
+    valXml("rotX", view.rotX) + valXml("hPercent", view.heightPercent) + valXml("rotY", view.rotY) + valXml("depthPercent", view.depthPercent) + valXml("rAngAx", view.rightAngleAxes) + valXml("perspective", view.perspective)
+  );
+}
+function legendXml(context, legend) {
+  if (!legend) return "";
+  const entries = legend.entries.map(
+    (entry3) => elementXml(
+      "legendEntry",
+      valXml("idx", entry3.index) + valXml("delete", entry3.deleted) + textBodyXml(context, entry3.txPr)
+    )
+  ).join("");
+  return elementXml(
+    "legend",
+    valXml("legendPos", legend.position) + entries + layoutXml(context, legend.layout) + valXml("overlay", legend.overlay) + shapePropertiesXml(context, legend.spPr) + textBodyXml(context, legend.txPr) + raw(context, legend.extLst)
+  );
+}
+function styleXml(context, space) {
+  const style = valXml("style", space.style);
+  if (space.c14Style === void 0) return style;
+  const choice = `<mc:Choice Requires="c14" xmlns:c14="${NS.c14}"><c14:style val="${space.c14Style}"/></mc:Choice>`;
+  const fallback = style ? `<mc:Fallback>${style}</mc:Fallback>` : "<mc:Fallback/>";
+  return raw(
+    context,
+    `<mc:AlternateContent xmlns:mc="${NS.mc}">${choice}${fallback}</mc:AlternateContent>`
+  );
+}
+var relationship = (local, id, content = "") => id === void 0 ? "" : elementXml(local, content, ` r:id="${escapeAttribute(id)}"`);
+function writeChartSpace(space, options = {}) {
+  const bindings = new Map(CHART_ROOT_BINDINGS);
+  for (const { prefix, uri } of space.namespaceDeclarations ?? [])
+    if (!bindings.has(prefix) && /^[A-Za-z_][\w.-]*$/.test(prefix)) bindings.set(prefix, uri);
+  const context = { bindings };
+  const declarations = [...bindings].map(([prefix, uri]) => ` xmlns:${prefix}="${escapeAttribute(uri)}"`).join("");
+  const chart = elementXml(
+    "chart",
+    titleXml(context, space.title) + valXml("autoTitleDeleted", space.autoTitleDeleted) + view3DXml(space.view3D) + surfaceXml(context, "floor", space.floor) + surfaceXml(context, "sideWall", space.sideWall) + surfaceXml(context, "backWall", space.backWall) + plotAreaXml(context, space.plotArea) + legendXml(context, space.legend) + valXml("plotVisOnly", space.plotVisibleOnly) + valXml("dispBlanksAs", space.displayBlanksAs) + valXml("showDLblsOverMax", space.showDataLabelsOverMax) + raw(context, space.chartExtLst)
+  );
+  const body = valXml("date1904", space.date1904) + valXml("lang", space.language) + valXml("roundedCorners", space.roundedCorners) + styleXml(context, space) + chart + shapePropertiesXml(context, space.spPr) + textBodyXml(context, space.txPr) + relationship(
+    "externalData",
+    space.externalDataRelId,
+    valXml("autoUpdate", space.externalDataAutoUpdate)
+  ) + raw(context, space.printSettings) + relationship("userShapes", space.userShapesRelId) + raw(context, space.extLst);
+  const breakAfter = options.declarationBreak ?? "\r\n";
+  return `${DECLARATION2}${breakAfter}<c:chartSpace${declarations}>${body}</c:chartSpace>`;
+}
+
+// chart/render/summary-from-space.ts
+var solidColor = (fill) => fill?.kind === "solid" ? fill.color : void 0;
+var isSolidFill = (fill) => fill?.kind === "solid" || fill?.kind === "unsupported" && fill.element === "solidFill";
+var GROUP_TYPES = {
+  bar: "bar",
+  line: "line",
+  area: "area",
+  pie: "pie",
+  ofPie: "pie",
+  doughnut: "doughnut",
+  scatter: "scatter",
+  radar: "radar",
+  bubble: "bubble",
+  stock: "stock",
+  surface: "surface"
+};
+var GROUPINGS = /* @__PURE__ */ new Set(["clustered", "stacked", "percentStacked", "standard"]);
+function chartSummarySeries(source, chartType) {
+  const categories = source.categories ?? source.xValues;
+  const values = source.values ?? source.yValues;
+  const out = {
+    categories: chartSourceValues(categories),
+    values: chartSourceValues(values).map(
+      (v) => typeof v === "number" ? v : v === "" ? null : Number.isFinite(Number(v)) ? Number(v) : null
+    )
+  };
+  if (source.tx?.text !== void 0) out.name = source.tx.text;
+  const nameRef = source.tx?.reference?.formula;
+  if (nameRef) out.nameRef = nameRef;
+  if (categories?.formula) out.categoriesRef = categories.formula;
+  if (values?.formula) out.valuesRef = values.formula;
+  if (source.spPr?.effectsXml) out.effectsXml = source.spPr.effectsXml;
+  const primary = ["line", "scatter", "radar"].includes(chartType) ? source.spPr?.line?.fill : source.spPr?.fill;
+  const fill = chartType === "scatter" && !isSolidFill(primary) ? source.marker?.spPr?.fill : primary;
+  const drawingColor = solidColor(fill);
+  if (drawingColor) out.drawingColor = drawingColor;
+  if (fill && fill.kind !== "solid" && !(chartType === "scatter" && fill.kind === "none"))
+    out.fill = fill;
+  const points = {};
+  const pointFills = {};
+  for (const point of source.dataPoints) {
+    const properties2 = point.spPr ?? point.marker?.spPr;
+    if (point.index === void 0) continue;
+    const pointColor = solidColor(properties2?.fill);
+    if (pointColor) points[point.index] = pointColor;
+    if (properties2?.fill && properties2.fill.kind !== "solid")
+      pointFills[point.index] = properties2.fill;
+  }
+  if (Object.keys(points).length) out.pointColors = points;
+  if (Object.keys(pointFills).length) out.pointFills = pointFills;
+  return out;
+}
+function chartSummaryFromSpace(chartSpace, extras = {}) {
+  const group = chartSpace.plotArea.groups[0];
+  let chartType = group ? GROUP_TYPES[group.kind] : "column";
+  if (chartType === "bar" && group?.barDirection !== "bar") chartType = "column";
+  const series = (group?.series ?? []).map((source) => chartSummarySeries(source, chartType));
+  const summary = {
+    chartType,
+    series,
+    showLegend: chartSpace.legend !== void 0
+  };
+  const grouping = group?.grouping;
+  if (grouping && GROUPINGS.has(grouping))
+    summary.grouping = grouping;
+  if (chartType === "bar" || chartType === "column") {
+    for (const [value, field, fallback, min, max] of [
+      [group?.gapWidth, "barGapWidth", 150, 0, 500],
+      [group?.overlap, "barOverlap", 0, -100, 100]
+    ]) {
+      const resolved = value ?? fallback;
+      if (Number.isInteger(resolved) && resolved >= min && resolved <= max)
+        summary[field] = resolved;
+    }
+  }
+  if (chartSpace.title && chartSpace.autoTitleDeleted !== true) {
+    const title = chartSpace.title.text;
+    if (title !== void 0) summary.title = title;
+    else if (series.length === 1 && series[0]?.name) summary.title = series[0].name;
+  }
+  const legendPos = chartSpace.legend?.position;
+  if (legendPos && ["r", "l", "t", "b", "tr"].includes(legendPos))
+    summary.legendPosition = legendPos;
+  if (extras.formatting) summary.formatting = extras.formatting;
+  if (extras.colorPalette !== void 0) summary.colorPalette = extras.colorPalette;
+  if (extras.styleDefinition) summary.styleDefinition = extras.styleDefinition;
+  return summary;
+}
+
+// drawingml/theme-color.ts
+function themeSlotHex(color) {
+  if (!color) return void 0;
+  const value = color.kind === "srgb" ? color.value : color.kind === "system" ? color.fallback : void 0;
+  return value ? value.toUpperCase() : void 0;
+}
+
+// chart/render/chart-scale.ts
+var clean = (n2) => Number(n2.toPrecision(12));
+function* units(raw2) {
+  let exp = Math.floor(Math.log10(raw2)) - 1;
+  for (; ; ) {
+    const base = 10 ** exp;
+    for (const m of [1, 2, 5]) yield clean(m * base);
+    exp++;
+  }
+}
+function niceScale(dataMin, dataMax, options = {}) {
+  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
+  let lo = Number.isFinite(dataMin) ? dataMin : 0;
+  let hi = Number.isFinite(dataMax) ? dataMax : 0;
+  if (lo > hi) [lo, hi] = [hi, lo];
+  if (lo === hi) {
+    if (lo === 0) hi = 1;
+    else if (options.noZero) {
+      const pad = Math.abs(lo) * 0.1 || 1;
+      lo -= pad;
+      hi += pad;
+    } else if (lo > 0) lo = 0;
+    else hi = 0;
+  }
+  let fixedLo = false;
+  let fixedHi = false;
+  if (!options.noZero) {
+    if (lo >= 0 && hi - lo >= hi / 6) {
+      lo = 0;
+      fixedLo = true;
+    } else if (hi <= 0 && hi - lo >= -lo / 6) {
+      hi = 0;
+      fixedHi = true;
+    }
+  }
+  const range = hi - lo;
+  const top = fixedHi ? hi : hi + range * 0.05;
+  const bottom = fixedLo ? lo : lo - range * 0.05;
+  for (const unit of units(range / maxIntervals)) {
+    const min = fixedLo ? lo : Math.floor(clean(bottom / unit)) * unit;
+    const max = fixedHi ? hi : Math.ceil(clean(top / unit)) * unit;
+    const intervals = Math.round((max - min) / unit);
+    if (intervals <= maxIntervals && intervals > 0) {
+      const ticks = [];
+      for (let i = 0; i <= intervals; i++) ticks.push(clean(min + i * unit));
+      return { min: clean(min), max: clean(max), majorUnit: unit, ticks };
+    }
+  }
+  return { min: lo, max: hi, majorUnit: range, ticks: [lo, hi] };
+}
+var PERCENT_SCALE = {
+  min: 0,
+  max: 1,
+  majorUnit: 0.1,
+  ticks: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+};
+function formatAxisValue(value, percent = false) {
+  if (percent) return `${clean(value * 100)}%`;
+  const v = clean(value);
+  if (Math.abs(v) >= 1e15 || v !== 0 && Math.abs(v) < 1e-6)
+    return v.toExponential(2).replace("e+", "E+").replace("e-", "E-");
+  const [int = "0", frac] = String(Math.abs(v)).split(".");
+  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${v < 0 ? "-" : ""}${grouped}${frac ? `.${frac}` : ""}`;
+}
+
+// chart/render/chart-svg-util.ts
+var TEXT_COLOR = "#595959";
+var GRID_COLOR = "#D9D9D9";
+var AXIS_COLOR = "#BFBFBF";
+var FONT_SIZE = 10;
+function esc(text2) {
+  return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var n = (value) => String(Math.round(value * 100) / 100);
+var textWidth = (text2, size = FONT_SIZE) => text2.length * size * 0.55;
+function text(x, y, content, attrs = {}) {
+  const parts = [`x="${n(x)}"`, `y="${n(y)}"`];
+  parts.push(`font-size="${attrs.size ?? FONT_SIZE}"`);
+  parts.push(`fill="${esc(attrs.fill ?? TEXT_COLOR)}"`);
+  if (attrs.anchor && attrs.anchor !== "start") parts.push(`text-anchor="${attrs.anchor}"`);
+  if (attrs.weight) parts.push(`font-weight="${attrs.weight}"`);
+  if (attrs.baseline) parts.push(`dominant-baseline="${attrs.baseline}"`);
+  if (attrs.family) parts.push(`font-family="${esc(attrs.family)}"`);
+  if (attrs.filter) parts.push(`filter="${esc(attrs.filter)}"`);
+  if (attrs.italic !== void 0) parts.push(`font-style="${attrs.italic ? "italic" : "normal"}"`);
+  if (attrs.underline !== void 0)
+    parts.push(`text-decoration="${attrs.underline ? "underline" : "none"}"`);
+  return `<text ${parts.join(" ")}>${esc(content)}</text>`;
+}
+var line = (x1, y1, x2, y2, stroke, width = 1) => `<line x1="${n(x1)}" y1="${n(y1)}" x2="${n(x2)}" y2="${n(y2)}" stroke="${stroke}" stroke-width="${width}"/>`;
+var rect = (x, y, w, h, fill, filter) => `<rect x="${n(x)}" y="${n(y)}" width="${n(Math.max(0, w))}" height="${n(Math.max(0, h))}" fill="${fill}"${filter ? ` filter="${esc(filter)}"` : ""}/>`;
+function fit(content, maxWidth, size = FONT_SIZE) {
+  if (textWidth(content, size) <= maxWidth) return content;
+  const chars = Math.max(1, Math.floor(maxWidth / (size * 0.55)) - 1);
+  return `${content.slice(0, chars)}\u2026`;
+}
+
+// chart/render/theme-palette.ts
+var THEME_SLOTS = [
+  "lt1",
+  "dk1",
+  "lt2",
+  "dk2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var DEFAULT_THEME_COLORS = [
+  "FFFFFF",
+  "000000",
+  "E7E6E6",
+  "44546A",
+  "4472C4",
+  "ED7D31",
+  "A5A5A5",
+  "FFC000",
+  "5B9BD5",
+  "70AD47",
+  "0563C1",
+  "954F72"
+];
+function themeColor(theme, index) {
+  const hex = theme.colors[index] ?? DEFAULT_THEME_COLORS[index];
+  return hex && parseArgbHex(hex) ? hex.replace(/^#/, "") : void 0;
+}
+
+// chart/render/chart-colors.ts
+function chartColorScheme(theme) {
+  const slots = Object.fromEntries(
+    THEME_SLOTS.map((slot, index) => [slot, `#${themeColor(theme, index) ?? "000000"}`])
+  );
+  return {
+    ...slots,
+    bg1: slots.lt1,
+    tx1: slots.dk1,
+    bg2: slots.lt2,
+    tx2: slots.dk2
+  };
+}
+function modulateLuminance(hex, lumMod, lumOff = 0) {
+  const rgb = parseArgbHex(hex);
+  if (!rgb) return "#000000";
+  if (lumMod === 1 && lumOff === 0) return rgbToUpperHex(rgb);
+  const hsl = rgbToHsl(...rgb);
+  const l = Math.max(0, Math.min(1, hsl.l * lumMod + lumOff));
+  const out = hslToRgb(hsl.h, hsl.s, l);
+  return rgbToUpperHex([out.r, out.g, out.b]);
+}
+function autoSeriesColor(theme, index) {
+  const i = Math.max(0, Math.floor(index));
+  return chartPaletteSeriesColor(findChartColorPalette(10), i, i + 1, chartColorScheme(theme));
+}
+
+// drawingml/drawing-color-css.ts
+function drawingColorCss(value) {
+  if (!value || value.alpha === 1) return value?.hex;
+  const channels = [1, 3, 5].map(
+    (offset) => Number.parseInt(value.hex.slice(offset, offset + 2), 16)
+  );
+  return `rgba(${channels.join(",")},${value.alpha})`;
+}
+
+// chart/render/chart-value-axis.ts
+function valueAxis(model) {
+  const stackable = model.type === "bar" || model.type === "column" || model.type === "line" || model.type === "area";
+  if (stackable && model.grouping === "percentStacked")
+    return { ...PERCENT_SCALE, ticks: [...PERCENT_SCALE.ticks], percent: true };
+  let min = Infinity;
+  let max = -Infinity;
+  if (stackable && model.grouping === "stacked") {
+    for (let i = 0; i < model.categories.length; i++) {
+      let pos = 0;
+      let neg = 0;
+      for (const s of model.series) {
+        const v = s.values[i] ?? 0;
+        if (v >= 0) pos += v;
+        else neg += v;
+      }
+      min = Math.min(min, neg);
+      max = Math.max(max, pos);
+    }
+  } else {
+    for (const s of model.series)
+      for (const v of s.values)
+        if (v !== null) {
+          min = Math.min(min, v);
+          max = Math.max(max, v);
+        }
+  }
+  if (min === Infinity) {
+    min = 0;
+    max = 1;
+  }
+  return { ...niceScale(min, max), percent: false };
+}
+function categoryTotals(model) {
+  return model.categories.map(
+    (_, i) => model.series.reduce((sum, s) => sum + Math.abs(s.values[i] ?? 0), 0)
+  );
+}
+
+// units/constants.ts
+var EMU_PER_PIXEL = 9525;
+var EMU_PER_POINT = 12700;
+
+// drawingml/drawing-shadow.ts
+function resolveDrawingShadow(effects, theme) {
+  const node = first(effects, "outerShdw", NS.a);
+  if (!node) return void 0;
+  const value = (key, fallback) => Number(node.getAttribute(key) ?? fallback);
+  if (value("sx", 1e5) !== 1e5 || value("sy", 1e5) !== 1e5 || value("kx", 0) !== 0 || value("ky", 0) !== 0)
+    return void 0;
+  const color = parseDrawingColorIn(node);
+  const resolved = color && resolveDrawingColor(color, theme, { transformOrder: "document" });
+  const blur = value("blurRad", 0) / EMU_PER_PIXEL;
+  const distance = value("dist", 0) / EMU_PER_PIXEL;
+  const angle = value("dir", 0) / 6e4 * Math.PI / 180;
+  if (!resolved || ![blur, distance, angle].every(Number.isFinite) || blur < 0 || distance < 0)
+    return void 0;
+  return {
+    color: resolved.hex,
+    opacity: resolved.alpha,
+    blur,
+    dx: Math.cos(angle) * distance,
+    dy: Math.sin(angle) * distance
+  };
+}
+function resolveDrawingShadowXml(xml, theme) {
+  return xml ? resolveDrawingShadow(parseXml(xml).documentElement, theme) : void 0;
+}
+function svgDropShadowElement(s, format) {
+  const num = format.number;
+  return `<feDropShadow dx="${num(s.dx)}" dy="${num(s.dy)}" stdDeviation="${num(s.blur / 2)}" flood-color="${format.color(s.color, "#000000")}" flood-opacity="${num(s.opacity)}" result="shadow"/>`;
+}
+
+// chart/text-inheritance.ts
+var TEXT_KEYS = [
+  "fontSize",
+  "bold",
+  "italic",
+  "underline",
+  "typeface",
+  "textColor",
+  "fontRef"
+];
+var TEXT_PARTS = [
+  "title",
+  "axisTitle",
+  "categoryAxis",
+  "valueAxis",
+  "legend",
+  "dataLabel"
+];
+function inheritChartText(part, entry3, builtIn, root) {
+  if (!root || !TEXT_PARTS.includes(part)) return entry3;
+  const out = { ...entry3 };
+  for (const key of TEXT_KEYS) {
+    delete out[key];
+    const value = root[key] ?? builtIn?.[key];
+    if (value !== void 0) Object.assign(out, { [key]: value });
+  }
+  if (part === "title" && root.fontSize !== void 0) out.fontSize = root.fontSize * 1.2;
+  if (root.textEffectsXml !== void 0) out.textEffectsXml = root.textEffectsXml;
+  return out;
+}
+
+// chart/render/chart-appearance.ts
+var chartPointsToPixels = (points) => points * EMU_PER_POINT / EMU_PER_PIXEL;
+function typeface(entry3, theme) {
+  const name = entry3.typeface;
+  if (name?.startsWith("+mj-")) return theme.majorFont;
+  if (name?.startsWith("+mn-")) return theme.minorFont;
+  return name ?? (entry3.fontRef?.index === "major" ? theme.majorFont : entry3.fontRef?.index === "minor" ? theme.minorFont : void 0);
+}
+function chartAppearance(chart, theme) {
+  const defaults = builtInChartTextStyle(effectiveBuiltInChartStyle(chart.formatting));
+  const entries = {};
+  for (const part of CHART_STYLE_PARTS) {
+    const base = chart.styleDefinition?.entries[part];
+    const direct = chart.formatting?.entries[part];
+    if (!defaults[part] && !base && !direct) continue;
+    const entry3 = {
+      ...inheritChartText(
+        part,
+        { ...defaults[part], ...base, sourceXml: base?.sourceXml ?? "" },
+        defaults[part],
+        chart.formatting?.textDefaults
+      ),
+      ...direct,
+      sourceXml: direct?.sourceXml ?? base?.sourceXml ?? ""
+    };
+    if (base?.line || direct?.line) entry3.line = { ...base?.line, ...direct?.line };
+    entries[part] = entry3;
+  }
+  const scheme = chartColorScheme(theme);
+  const resolve = (color) => resolveDrawingColor(
+    color,
+    { scheme: (name) => scheme[name] },
+    { hslRounding: "halfDown", transformOrder: "document" }
+  );
+  const out = resolveChartStyleDefinition(
+    { entries},
+    (color) => drawingColorCss(resolve(color))
+  ) ?? {};
+  for (const part of CHART_STYLE_PARTS) {
+    const entry3 = entries[part];
+    if (!entry3) continue;
+    const family = typeface(entry3, theme);
+    const shadow = resolveDrawingShadowXml(entry3.textEffectsXml, {
+      scheme: (name) => scheme[name]
+    });
+    if (shadow) (out[part] ??= {}).textShadow = shadow;
+    if (family) (out[part] ??= {}).typeface = family;
+    if (entry3.axisVisible !== void 0) (out[part] ??= {}).axisVisible = entry3.axisVisible;
+    if (entry3.labelsVisible !== void 0) (out[part] ??= {}).labelsVisible = entry3.labelsVisible;
+    if (entry3.line?.widthEmu === 0) (out[part] ??= {}).lineWidth = 0;
+    if (entry3.fill?.kind === "gradient") {
+      (out[part] ??= {}).gradient = resolveChartGradient(entry3.fill, resolve);
+    }
+  }
+  return out;
+}
+
+// chart/render/chart-title-text.ts
+function properties(run2) {
+  return {
+    ...run2.sizePt === void 0 ? {} : { fontSize: run2.sizePt },
+    ...run2.bold === void 0 ? {} : { bold: run2.bold },
+    ...run2.italic === void 0 ? {} : { italic: run2.italic },
+    ...run2.underline === void 0 ? {} : { underline: run2.underline },
+    ...run2.typeface === void 0 ? {} : { typeface: run2.typeface },
+    ...run2.color === void 0 ? {} : { textColor: run2.color }
+  };
+}
+function chartTitleText(chart, theme) {
+  const formatting = chart.formatting;
+  const entry3 = formatting?.entries.title;
+  const body = entry3?.textBody;
+  if (!formatting || !body || body.text !== chart.title) return void 0;
+  if (body.paragraphs.length === 1 && body.paragraphs[0].runs.length <= 1 && !body.text.includes("\n") && !body.paragraphs[0].lineSpacing && !body.paragraphs[0].spaceBefore && !body.paragraphs[0].spaceAfter)
+    return void 0;
+  return {
+    paragraphs: body.paragraphs.map((paragraph2) => ({
+      ...paragraph2.align ? { align: paragraph2.align } : {},
+      ...paragraph2.lineSpacing ? { lineSpacing: paragraph2.lineSpacing } : {},
+      ...paragraph2.spaceBefore ? { spaceBefore: paragraph2.spaceBefore } : {},
+      ...paragraph2.spaceAfter ? { spaceAfter: paragraph2.spaceAfter } : {},
+      runs: paragraph2.runs.map((run2) => {
+        const direct = {
+          sourceXml: "",
+          ...entry3.textBodyStyle,
+          ...properties(paragraph2.defaultProperties ?? {}),
+          ...properties(run2)
+        };
+        const appearance = chartAppearance(
+          {
+            ...chart,
+            formatting: { ...formatting, entries: { ...formatting.entries, title: direct } }
+          },
+          theme
+        )?.title ?? {};
+        return { text: run2.text, appearance };
+      })
+    }))
+  };
+}
+
+// chart/render/chart-view.ts
+var isRefError = (value) => typeof value === "object" && value !== null && "error" in value;
+var SUPPORTED = /* @__PURE__ */ new Set([
+  "bar",
+  "column",
+  "line",
+  "area",
+  "pie",
+  "doughnut",
+  "scatter",
+  "radar"
+]);
+function toText(value) {
+  if (value === null) return "";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (isRefError(value)) return value.error;
+  return String(value);
+}
+var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+function resolveRef(ref, evaluateRef) {
+  if (!ref) return void 0;
+  try {
+    const values = evaluateRef(ref);
+    return values.length ? values : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function seriesName(series, index, evaluateRef) {
+  const fromRef = resolveRef(series.nameRef, evaluateRef)?.map(toText).filter((t) => t !== "").join(" ");
+  return fromRef || series.name || `Series${index + 1}`;
+}
+function chartSummaryView(chart, theme, options = {}) {
+  const evaluateRef = options.evaluateRef ?? (() => []);
+  const type = chart.chartType;
+  const radial = type === "pie" || type === "doughnut";
+  const palette = chart.colorPalette === void 0 ? void 0 : findChartColorPalette(chart.colorPalette);
+  const scheme = chartColorScheme(theme);
+  const drawingColor = (color) => color && drawingColorCss(
+    resolveDrawingColor(
+      color,
+      {
+        scheme: (name) => scheme[name]
+      },
+      { transformOrder: "document" }
+    )
+  );
+  const gradient = (fill) => fill?.kind === "gradient" ? resolveChartGradient(
+    fill,
+    (color) => resolveDrawingColor(
+      color,
+      {
+        scheme: (name) => scheme[name]
+      },
+      { transformOrder: "document" }
+    )
+  ) : void 0;
+  const grouping = chart.grouping ?? (type === "bar" || type === "column" ? "clustered" : "standard");
+  let categories = [];
+  const rawCategories = [];
+  const series = chart.series.map((s, i) => {
+    const values = resolveRef(s.valuesRef, evaluateRef)?.map(toNumber) ?? s.values.map(toNumber);
+    const cats = resolveRef(s.categoriesRef, evaluateRef) ?? s.categories;
+    rawCategories.push(cats);
+    const paletteColor = palette && chartPaletteSeriesColor(palette, i, chart.series.length, scheme);
+    const color = s.fill?.kind === "none" ? "none" : drawingColor(s.fill?.kind === "solid" ? s.fill.color : s.drawingColor) ?? options.seriesColor?.(s, i) ?? paletteColor ?? autoSeriesColor(theme, i);
+    const view = { name: seriesName(s, i, evaluateRef), values, color };
+    const shadow = resolveDrawingShadowXml(s.effectsXml, {
+      scheme: (name) => scheme[name]
+    });
+    if (shadow) view.shadow = shadow;
+    const resolvedGradient = gradient(s.fill);
+    if (resolvedGradient) view.gradient = resolvedGradient;
+    const points = Object.fromEntries(
+      Object.entries(s.pointFills ?? {}).flatMap(([key, fill]) => {
+        const value = gradient(fill);
+        return value ? [[key, value]] : [];
+      })
+    );
+    if (Object.keys(points).length) view.pointGradients = points;
+    return view;
+  });
+  const longest = Math.max(0, ...series.map((s) => s.values.length));
+  const firstCats = rawCategories.find((c2) => c2.length > 0) ?? [];
+  categories = Array.from(
+    { length: Math.max(longest, firstCats.length) },
+    (_, i) => firstCats[i] !== void 0 ? toText(firstCats[i] ?? null) : String(i + 1)
+  );
+  if (radial) {
+    series.forEach((s, seriesIndex) => {
+      s.pointColors = s.values.map((_, i) => {
+        const explicit = drawingColor(chart.series[seriesIndex]?.pointColors?.[i]);
+        return explicit ?? (palette ? chartPaletteSeriesColor(palette, i, s.values.length, scheme) : autoSeriesColor(theme, i));
+      });
+    });
+  } else
+    series.forEach((s, seriesIndex) => {
+      const points = chart.series[seriesIndex]?.pointColors;
+      if (points) s.pointColors = s.values.map((_, i) => drawingColor(points[i]) ?? s.color);
+    });
+  series.forEach((s, index) => {
+    const source = chart.series[index];
+    if (s.gradient && !radial && s.pointColors) {
+      for (let i = 0; i < s.pointColors.length; i++)
+        if (!source.pointColors?.[i]) delete s.pointColors[i];
+    }
+    for (const [key, fill] of Object.entries(source.pointFills ?? {})) {
+      if (fill.kind === "none") (s.pointColors ??= [])[Number(key)] = "none";
+      else if (fill.kind === "solid") {
+        const paint = drawingColor(fill.color);
+        if (paint) (s.pointColors ??= [])[Number(key)] = paint;
+      }
+    }
+  });
+  const model = {
+    ...chart.barGapWidth === void 0 ? {} : { barGapWidth: chart.barGapWidth },
+    ...chart.barOverlap === void 0 ? {} : { barOverlap: chart.barOverlap },
+    type,
+    grouping,
+    showLegend: chart.showLegend,
+    legendPosition: chart.legendPosition ?? "r",
+    categories,
+    series,
+    horizontal: type === "bar",
+    supported: SUPPORTED.has(type)
+  };
+  if (chart.title) model.title = chart.title;
+  const titleFormatting = chart.formatting?.entries.title;
+  if (titleFormatting?.layout) model.titleLayout = titleFormatting.layout;
+  if (titleFormatting?.overlay !== void 0) model.titleOverlay = titleFormatting.overlay;
+  const legendFormatting = chart.formatting?.entries.legend;
+  if (legendFormatting?.layout) model.legendLayout = legendFormatting.layout;
+  if (legendFormatting?.overlay !== void 0) model.legendOverlay = legendFormatting.overlay;
+  const titleText = chartTitleText(chart, theme);
+  if (titleText) model.titleText = titleText;
+  const appearance = chartAppearance(chart, theme);
+  if (appearance) model.appearance = appearance;
+  if (type === "scatter") {
+    series.forEach((s, i) => {
+      const cats = rawCategories[i] ?? [];
+      const numeric = cats.length > 0 && cats.every((c2) => typeof c2 === "number");
+      s.xValues = s.values.map((_, k) => numeric ? toNumber(cats[k] ?? null) : k + 1);
+    });
+    const xs = series.flatMap((s) => s.xValues ?? []).filter((x) => x !== null);
+    model.xAxis = xs.length ? niceScale(Math.min(...xs), Math.max(...xs)) : niceScale(0, 1);
+  }
+  if (!radial) model.valueAxis = valueAxis(model);
+  return model;
+}
+
+// text/css-font-family.ts
+var FALLBACKS = {
+  calibri: '"Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
+  "calibri light": '"Calibri Light", "Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
+  cambria: '"Cambria", "Caladea", Georgia, serif',
+  arial: 'Arial, "Liberation Sans", Helvetica, sans-serif',
+  "times new roman": '"Times New Roman", "Liberation Serif", Times, serif',
+  "courier new": '"Courier New", "Liberation Mono", monospace',
+  aptos: '"Aptos", "Calibri", "Carlito", "Segoe UI", sans-serif'
+};
+function cssFontFamily(name) {
+  const known = FALLBACKS[name.toLowerCase()];
+  if (known) return known;
+  const quoted = `"${name.replace(/["\\]/g, "")}"`;
+  return `${quoted}, "Calibri", "Carlito", "Segoe UI", sans-serif`;
+}
+
+// chart/render/chart-svg-appearance.ts
+var nextPaintId = 0;
+function chartGradientPaint(model, width = 1024, height = 768) {
+  const prefix = `xlsx-chart-${++nextPaintId}`;
+  const appearance = { ...model.appearance };
+  const defs = [];
+  const shadowPaint = (shadow, suffix) => {
+    const id = `${prefix}-${suffix}`;
+    const pad = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
+    defs.push(
+      `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad)}" y="${n(-pad)}" width="${n(width + pad * 2)}" height="${n(height + pad * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
+    );
+    return `url(#${id})`;
+  };
+  for (const [part, entry3] of Object.entries(appearance)) {
+    if (entry3?.textShadow)
+      appearance[part] = {
+        ...entry3,
+        textShadowFilter: shadowPaint(entry3.textShadow, `${part}-text-shadow`)
+      };
+  }
+  const paint = (gradient, suffix, bounds) => {
+    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds);
+    defs.push(chartGradientMarkup(def));
+    return `url(#${def.id})`;
+  };
+  for (const part of ["chartArea", "plotArea"]) {
+    const entry3 = appearance[part];
+    if (!entry3?.gradient) continue;
+    if (part === "plotArea" && ["circle", "shape"].includes(entry3.gradient.path ?? "")) continue;
+    appearance[part] = {
+      ...entry3,
+      fillColor: paint(entry3.gradient, part, { width, height, shape: "rect" })
+    };
+  }
+  const series = model.series.map((source, index) => {
+    const view = { ...source };
+    if (source.shadow) view.shadowFilter = shadowPaint(source.shadow, `s${index}-shadow`);
+    const bounds = model.type === "bar" || model.type === "column" ? { width: 1, height: 1, shape: "rect" } : void 0;
+    if (source.gradient) view.color = paint(source.gradient, `s${index}`, bounds);
+    if (source.pointGradients) {
+      view.pointColors = [...source.pointColors ?? []];
+      for (const [key, gradient] of Object.entries(source.pointGradients))
+        view.pointColors[Number(key)] = paint(gradient, `s${index}-p${key}`, bounds);
+    }
+    return view;
+  });
+  return defs.length ? { model: { ...model, appearance, series }, defs: `<defs>${defs.join("")}</defs>` } : { model, defs: "" };
+}
+function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
+  const entry3 = model.appearance?.[part];
+  return {
+    size: entry3?.fontSize === void 0 ? fallbackSize : chartPointsToPixels(entry3.fontSize),
+    ...entry3?.color === void 0 ? {} : { fill: entry3.color },
+    ...entry3?.bold === void 0 ? {} : { weight: entry3.bold ? "bold" : "normal" },
+    ...entry3?.italic === void 0 ? {} : { italic: entry3.italic },
+    ...entry3?.underline === void 0 ? {} : { underline: entry3.underline },
+    ...entry3?.typeface === void 0 ? {} : { family: cssFontFamily(entry3.typeface) },
+    ...entry3?.textShadowFilter === void 0 ? {} : { filter: entry3.textShadowFilter }
+  };
+}
+function chartStroke(model, part) {
+  const entry3 = model.appearance?.[part];
+  return {
+    color: entry3?.axisVisible === false ? "none" : entry3?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
+    width: entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth)
+  };
+}
+function chartAreaRect(model, part, area) {
+  if (area.w <= 0 || area.h <= 0) return "";
+  const entry3 = model.appearance?.[part];
+  let fill = entry3?.fillColor ?? (part === "chartArea" ? "#FFFFFF" : "none");
+  let defs = "";
+  if (part !== "chartArea" && entry3?.gradient && (part !== "plotArea" || ["circle", "shape"].includes(entry3.gradient.path ?? ""))) {
+    const def = buildChartGradientDef(`xlsx-chart-${++nextPaintId}-${part}`, entry3.gradient, {
+      width: area.w,
+      height: area.h,
+      shape: "rect"
+    });
+    defs = `<defs>${chartGradientMarkup(def)}</defs>`;
+    fill = `url(#${def.id})`;
+  }
+  const stroke = entry3?.lineColor ?? "none";
+  if (fill === "none" && stroke === "none") return "";
+  const width = entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth);
+  return `${defs}<rect x="${n(area.x)}" y="${n(area.y)}" width="${n(area.w)}" height="${n(area.h)}" fill="${esc(fill)}" stroke="${esc(stroke)}" stroke-width="${n(width)}" data-chart-part="${part}"/>`;
+}
+
+// chart/render/chart-spacing.ts
+function chartBarSpacing(chart) {
+  const stacked = chart.grouping === "stacked" || chart.grouping === "percentStacked";
+  return {
+    barGapWidth: chart.barGapWidth ?? 150,
+    barOverlap: chart.barOverlap ?? (stacked ? 100 : 0)
+  };
+}
+
+// chart/render/chart-svg-bars.ts
+function bars(model, frame, out, values) {
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  const count = Math.max(1, model.series.length);
+  const geometry = clusteredBarGeometry(frame.bandSize, count, chartBarSpacing(model));
+  const barSize = geometry.singleBarWidth;
+  const base = frame.value(0);
+  const pos = new Array(model.categories.length).fill(0);
+  const neg = new Array(model.categories.length).fill(0);
+  model.series.forEach((s, si) => {
+    values[si]?.forEach((v, i) => {
+      if (v === null || i >= model.categories.length) return;
+      let from = 0;
+      let to = v;
+      if (stacked) {
+        const acc = v >= 0 ? pos : neg;
+        from = acc[i] ?? 0;
+        to = from + v;
+        acc[i] = to;
+      }
+      const a2 = stacked ? frame.value(from) : base;
+      const b = frame.value(to);
+      const offset = model.horizontal ? geometry.clusterWidth / 2 - barSize - si * geometry.step : -geometry.clusterWidth / 2 + si * geometry.step;
+      const center = frame.band(i);
+      const width = model.horizontal ? Math.abs(b - a2) : barSize;
+      const height = model.horizontal ? barSize : Math.abs(b - a2);
+      let color = s.pointColors?.[i] ?? s.color;
+      const gradient = s.pointGradients?.[i] ?? (s.pointColors?.[i] === void 0 ? s.gradient : void 0);
+      if (gradient && (gradient.path === "circle" || gradient.path === "shape")) {
+        const baseId = color.match(/^url\(#(.+)\)$/)?.[1];
+        if (baseId) {
+          const id = baseId.replace(/(-s\d+(?:-p\d+)?)$/, `-mark${i}$1`);
+          const def = buildChartGradientDef(id, gradient, {
+            width: Number(n(width)),
+            height: Number(n(height)),
+            shape: "rect"
+          });
+          out.push(`<defs>${chartGradientMarkup(def)}</defs>`);
+          color = `url(#${id})`;
+        }
+      }
+      out.push(`<g data-chart-series="${si}" data-chart-point="${i}">`);
+      if (model.horizontal)
+        out.push(
+          rect(Math.min(a2, b), center + offset, Math.abs(b - a2), barSize, color, s.shadowFilter)
+        );
+      else
+        out.push(
+          rect(center + offset, Math.min(a2, b), barSize, Math.abs(b - a2), color, s.shadowFilter)
+        );
+      out.push("</g>");
+    });
+  });
+}
+
+// chart/render/chart-svg-cartesian.ts
+function axes(model, area, out) {
+  const scale = model.valueAxis;
+  if (!scale) return void 0;
+  const labels = scale.ticks.map((t) => formatAxisValue(t, scale.percent));
+  const valueAttrs = chartTextAttributes(model, "valueAxis");
+  const categoryAttrs = chartTextAttributes(model, "categoryAxis");
+  const valueSize = valueAttrs.size ?? 10;
+  const categorySize = categoryAttrs.size ?? 10;
+  const grid = chartStroke(model, "gridlineMajor");
+  const axis = chartStroke(model, "categoryAxis");
+  const valueLabels = model.appearance?.valueAxis?.labelsVisible !== false;
+  const categoryLabels = model.appearance?.categoryAxis?.labelsVisible !== false;
+  const labelW = valueLabels ? Math.max(...labels.map((l) => textWidth(l, valueSize)), 8) + 6 : 4;
+  const horizontal = model.horizontal;
+  const cats = Math.max(1, model.categories.length);
+  const catW = Math.min(
+    area.w * 0.3,
+    Math.max(...model.categories.map((c2) => textWidth(c2, categorySize)), 8) + 6
+  );
+  const plot = horizontal ? {
+    x: area.x + catW,
+    y: area.y,
+    w: Math.max(1, area.w - catW - 4),
+    h: Math.max(1, area.h - Math.max(16, valueSize * 1.5))
+  } : {
+    x: area.x + labelW,
+    y: area.y + 4,
+    w: Math.max(1, area.w - labelW - 4),
+    h: Math.max(1, area.h - Math.max(20, categorySize * 1.5))
+  };
+  const span = scale.max - scale.min || 1;
+  const value = horizontal ? (v) => plot.x + (v - scale.min) / span * plot.w : (v) => plot.y + plot.h - (v - scale.min) / span * plot.h;
+  const bandSize = (horizontal ? plot.h : plot.w) / cats;
+  const band = horizontal ? (i) => plot.y + plot.h - bandSize * (i + 0.5) : (i) => plot.x + bandSize * (i + 0.5);
+  out.push(chartAreaRect(model, "plotArea", plot));
+  scale.ticks.forEach((t, i) => {
+    const p = value(t);
+    const label = labels[i] ?? "";
+    if (horizontal) {
+      out.push(line(p, plot.y, p, plot.y + plot.h, grid.color, grid.width));
+      if (valueLabels)
+        out.push(
+          text(p, plot.y + plot.h + valueSize + 2, label, { anchor: "middle", ...valueAttrs })
+        );
+    } else {
+      out.push(line(plot.x, p, plot.x + plot.w, p, grid.color, grid.width));
+      if (valueLabels)
+        out.push(text(plot.x - 4, p + valueSize * 0.3, label, { anchor: "end", ...valueAttrs }));
+    }
+  });
+  const zero = value(Math.min(Math.max(0, scale.min), scale.max));
+  if (horizontal) out.push(line(zero, plot.y, zero, plot.y + plot.h, axis.color, axis.width));
+  else out.push(line(plot.x, zero, plot.x + plot.w, zero, axis.color, axis.width));
+  const step = Math.max(
+    1,
+    Math.ceil(cats / Math.max(1, Math.floor((horizontal ? plot.h : plot.w) / 14)))
+  );
+  model.categories.forEach((c2, i) => {
+    if (!categoryLabels || i % step !== 0) return;
+    const p = band(i);
+    if (horizontal)
+      out.push(
+        text(plot.x - 4, p + categorySize * 0.3, fit(c2, catW - 6, categorySize), {
+          anchor: "end",
+          ...categoryAttrs
+        })
+      );
+    else
+      out.push(
+        text(p, plot.y + plot.h + categorySize + 3, fit(c2, bandSize * step, categorySize), {
+          anchor: "middle",
+          ...categoryAttrs
+        })
+      );
+  });
+  return { plot, value, band, bandSize };
+}
+function plotted(model) {
+  if (model.grouping !== "percentStacked") return model.series.map((s) => s.values);
+  const totals = categoryTotals(model);
+  return model.series.map(
+    (s) => s.values.map((v, i) => v === null ? null : v / (totals[i] || 1))
+  );
+}
+function linesAndAreas(model, frame, out) {
+  const values = plotted(model);
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  const acc = new Array(model.categories.length).fill(0);
+  const area = model.type === "area";
+  const layers = [];
+  model.series.forEach((s, si) => {
+    const points = [];
+    const lower = [];
+    model.categories.forEach((_, i) => {
+      const v = values[si]?.[i] ?? null;
+      if (v === null && !area) {
+        points.push([NaN, NaN]);
+        return;
+      }
+      const below = stacked ? acc[i] ?? 0 : 0;
+      const top = below + (v ?? 0);
+      if (stacked) acc[i] = top;
+      points.push([frame.band(i), frame.value(top)]);
+      lower.push([frame.band(i), frame.value(below)]);
+    });
+    layers.push({
+      points,
+      lower,
+      color: s.color,
+      filter: s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""
+    });
+  });
+  for (const { points, lower, color, filter } of area ? [...layers].reverse() : layers) {
+    if (area) {
+      const poly = [...points, ...[...lower].reverse()].map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+      out.push(`<polygon points="${poly}" fill="${color}" fill-opacity="0.85"${filter}/>`);
+      continue;
+    }
+    let segment = [];
+    const flush = () => {
+      if (segment.length > 1)
+        out.push(
+          `<polyline points="${segment.join(" ")}" fill="none" stroke="${color}" stroke-width="2.25" stroke-linejoin="round"${filter}/>`
+        );
+      segment = [];
+    };
+    for (const [x, y] of points) {
+      if (Number.isNaN(x)) flush();
+      else segment.push(`${n(x)},${n(y)}`);
+    }
+    flush();
+    for (const [x, y] of points)
+      if (!Number.isNaN(x))
+        out.push(`<circle cx="${n(x)}" cy="${n(y)}" r="2.5" fill="${color}"${filter}/>`);
+  }
+}
+function scatter(model, area, out) {
+  const ys = model.valueAxis;
+  const xs = model.xAxis;
+  if (!ys || !xs) return;
+  const yLabels = ys.ticks.map((t) => formatAxisValue(t));
+  const valueAttrs = chartTextAttributes(model, "valueAxis");
+  const categoryAttrs = chartTextAttributes(model, "categoryAxis");
+  const valueSize = valueAttrs.size ?? 10;
+  const categorySize = categoryAttrs.size ?? 10;
+  const grid = chartStroke(model, "gridlineMajor");
+  const xAxis = chartStroke(model, "categoryAxis");
+  const yAxis = chartStroke(model, "valueAxis");
+  const valueLabels = model.appearance?.valueAxis?.labelsVisible !== false;
+  const categoryLabels = model.appearance?.categoryAxis?.labelsVisible !== false;
+  const labelW = valueLabels ? Math.max(...yLabels.map((l) => textWidth(l, valueSize)), 8) + 6 : 4;
+  const plot = {
+    x: area.x + labelW,
+    y: area.y + 4,
+    w: Math.max(1, area.w - labelW - 8),
+    h: Math.max(1, area.h - Math.max(20, categorySize * 1.5))
+  };
+  const px = (v, s) => plot.x + (v - s.min) / (s.max - s.min || 1) * plot.w;
+  const py = (v, s) => plot.y + plot.h - (v - s.min) / (s.max - s.min || 1) * plot.h;
+  out.push(chartAreaRect(model, "plotArea", plot));
+  ys.ticks.forEach((t, i) => {
+    out.push(line(plot.x, py(t, ys), plot.x + plot.w, py(t, ys), grid.color, grid.width));
+    if (valueLabels)
+      out.push(
+        text(plot.x - 4, py(t, ys) + valueSize * 0.3, yLabels[i] ?? "", {
+          anchor: "end",
+          ...valueAttrs
+        })
+      );
+  });
+  for (const t of xs.ticks) {
+    out.push(
+      line(px(t, xs), plot.y + plot.h, px(t, xs), plot.y + plot.h + 3, xAxis.color, xAxis.width)
+    );
+    if (categoryLabels)
+      out.push(
+        text(px(t, xs), plot.y + plot.h + categorySize + 3, formatAxisValue(t), {
+          anchor: "middle",
+          ...categoryAttrs
+        })
+      );
+  }
+  out.push(
+    line(plot.x, plot.y + plot.h, plot.x + plot.w, plot.y + plot.h, xAxis.color, xAxis.width)
+  );
+  out.push(line(plot.x, plot.y, plot.x, plot.y + plot.h, yAxis.color, yAxis.width));
+  for (const s of model.series)
+    s.values.forEach((v, i) => {
+      const x = s.xValues?.[i] ?? null;
+      if (v === null || x === null) return;
+      out.push(
+        `<circle cx="${n(px(x, xs))}" cy="${n(py(v, ys))}" r="3" fill="${s.pointColors?.[i] ?? s.color}"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+      );
+    });
+}
+function cartesianSvg(model, area) {
+  const out = [];
+  if (model.type === "scatter") {
+    scatter(model, area, out);
+    return out.join("");
+  }
+  const frame = axes(model, area, out);
+  if (!frame) return "";
+  if (model.type === "bar" || model.type === "column") bars(model, frame, out, plotted(model));
+  else linesAndAreas(model, frame, out);
+  return out.join("");
+}
+
+// chart/render/chart-svg-radial.ts
+var polar = (cx, cy, r, angle) => [
+  cx + r * Math.sin(angle),
+  cy - r * Math.cos(angle)
+];
+function slicePath(cx, cy, r, inner, a0, a1) {
+  const sweep = a1 - a0;
+  if (sweep >= Math.PI * 2 - 1e-9) {
+    const mid = a0 + Math.PI;
+    return slicePath(cx, cy, r, inner, a0, mid) + slicePath(cx, cy, r, inner, mid, a1);
+  }
+  const large = sweep > Math.PI ? 1 : 0;
+  const [x0, y0] = polar(cx, cy, r, a0);
+  const [x1, y1] = polar(cx, cy, r, a1);
+  if (inner <= 0)
+    return `M${n(cx)},${n(cy)} L${n(x0)},${n(y0)} A${n(r)},${n(r)} 0 ${large} 1 ${n(x1)},${n(y1)} Z`;
+  const [ix1, iy1] = polar(cx, cy, inner, a1);
+  const [ix0, iy0] = polar(cx, cy, inner, a0);
+  return `M${n(x0)},${n(y0)} A${n(r)},${n(r)} 0 ${large} 1 ${n(x1)},${n(y1)} L${n(ix1)},${n(iy1)} A${n(inner)},${n(inner)} 0 ${large} 0 ${n(ix0)},${n(iy0)} Z`;
+}
+function pieSvg(model, area) {
+  const out = [chartAreaRect(model, "plotArea", area)];
+  const cx = area.x + area.w / 2;
+  const cy = area.y + area.h / 2;
+  const radius = Math.max(1, Math.min(area.w, area.h) / 2 - 4);
+  const rings = model.type === "doughnut" ? model.series : model.series.slice(0, 1);
+  const hole = model.type === "doughnut" ? radius * 0.5 : 0;
+  const ringSize = (radius - hole) / Math.max(1, rings.length);
+  rings.forEach((s, ri) => {
+    const outer = radius - ri * ringSize;
+    const inner = model.type === "doughnut" ? outer - ringSize : 0;
+    const total = s.values.reduce((sum, v) => sum + (v !== null && v > 0 ? v : 0), 0);
+    if (total <= 0) return;
+    let angle = 0;
+    s.values.forEach((v, i) => {
+      if (v === null || v <= 0) return;
+      const sweep = v / total * Math.PI * 2;
+      const color = s.pointColors?.[i] ?? s.color;
+      out.push(
+        `<path d="${slicePath(cx, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+      );
+      angle += sweep;
+    });
+  });
+  return out.join("");
+}
+function radarSvg(model, area) {
+  const out = [chartAreaRect(model, "plotArea", area)];
+  const scale = model.valueAxis;
+  const count = model.categories.length;
+  if (!scale || count < 1) return "";
+  const valueAttrs = chartTextAttributes(model, "valueAxis", 9);
+  const categoryAttrs = chartTextAttributes(model, "categoryAxis");
+  const valueSize = valueAttrs.size ?? 9;
+  const categorySize = categoryAttrs.size ?? 10;
+  const grid = chartStroke(model, "gridlineMajor");
+  const axis = chartStroke(model, "categoryAxis");
+  const cx = area.x + area.w / 2;
+  const cy = area.y + area.h / 2 + 4;
+  const radius = Math.max(1, Math.min(area.w, area.h) / 2 - Math.max(18, categorySize * 1.8));
+  const angle = (i) => i / count * Math.PI * 2;
+  const r = (v) => (v - scale.min) / (scale.max - scale.min || 1) * radius;
+  const labelEvery = Math.max(
+    1,
+    Math.ceil(12 / Math.max(1, radius / Math.max(1, scale.ticks.length - 1)))
+  );
+  for (const [k, t] of scale.ticks.entries()) {
+    const ring = Array.from({ length: count }, (_, i) => polar(cx, cy, r(t), angle(i))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+    out.push(
+      `<polygon points="${ring}" fill="none" stroke="${grid.color}" stroke-width="${n(grid.width)}"/>`
+    );
+    if (model.appearance?.valueAxis?.labelsVisible !== false && k % labelEvery === 0)
+      out.push(
+        text(cx + 3, cy - r(t) + valueSize * 0.3, formatAxisValue(t, scale.percent), valueAttrs)
+      );
+  }
+  model.categories.forEach((c2, i) => {
+    const [x, y] = polar(cx, cy, radius, angle(i));
+    out.push(line(cx, cy, x, y, axis.color, axis.width));
+    const [lx, ly] = polar(cx, cy, radius + 10, angle(i));
+    const anchor = Math.abs(lx - cx) < 2 ? "middle" : lx > cx ? "start" : "end";
+    if (model.appearance?.categoryAxis?.labelsVisible !== false)
+      out.push(
+        text(lx, ly + categorySize * 0.3, fit(c2, area.w / 4, categorySize), {
+          anchor,
+          ...categoryAttrs
+        })
+      );
+  });
+  for (const s of model.series) {
+    const points = s.values.slice(0, count).map((v, i) => polar(cx, cy, r(v ?? scale.min), angle(i))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+    out.push(
+      `<polygon points="${points}" fill="none" stroke="${s.color}" stroke-width="2"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
+    );
+  }
+  return out.join("");
+}
+
+// chart/render/chart-svg-text-metrics.ts
+var CHART_FONT_FAMILY = "Calibri, Carlito, Arial, sans-serif";
+function cssFont(attrs) {
+  return `${attrs.italic ? "italic" : "normal"} ${attrs.weight ?? "normal"} ${attrs.size ?? 10}px ${attrs.family ?? CHART_FONT_FAMILY}`;
+}
+function chartFontMetrics(attrs, options) {
+  const metrics = options.measureFont?.(cssFont(attrs));
+  return metrics && Number.isFinite(metrics.ascent) && Number.isFinite(metrics.descent) && metrics.ascent >= 0 && metrics.descent >= 0 && metrics.ascent + metrics.descent > 0 ? metrics : void 0;
+}
+function chartTextWidth(content, attrs, options) {
+  const width = options.measureText?.(content, cssFont(attrs));
+  return width !== void 0 && Number.isFinite(width) && width >= 0 ? width : textWidth(content, attrs.size);
+}
+function fitChartText(content, maxWidth, attrs, options) {
+  if (!options.measureText) return fit(content, maxWidth, attrs.size);
+  if (chartTextWidth(content, attrs, options) <= maxWidth) return content;
+  const points = [...content];
+  let low = 0;
+  let high = points.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (chartTextWidth(`${points.slice(0, mid).join("")}\u2026`, attrs, options) <= maxWidth) low = mid;
+    else high = mid - 1;
+  }
+  return `${points.slice(0, low).join("")}\u2026`;
+}
+
+// chart/render/chart-svg-legend.ts
+function chartLegendSvg(model, area, frame, options) {
+  const automatic = [];
+  const bounds = {};
+  const reserved = automaticLegend(model, area, automatic, options, bounds);
+  const plot = model.legendOverlay ? area : reserved;
+  const box = bounds.box;
+  if (!box) return { plot, markup: "", foreground: false };
+  const manual = resolveManualLayoutRect(model.legendLayout, frame, {
+    x: box.x,
+    y: box.y,
+    width: box.w,
+    height: box.h
+  });
+  if (!manual) return { plot, markup: automatic.join(""), foreground: !!model.legendOverlay };
+  const entries = legendEntries(model);
+  const attrs = chartTextAttributes(model, "legend");
+  const size = attrs.size ?? 10;
+  const font = chartFontMetrics(attrs, options);
+  const keySize = size / 2;
+  const keyGap = size / 4;
+  const widths = entries.map(
+    (entry3) => chartTextWidth(entry3.label, attrs, options) + keySize + keyGap
+  );
+  const horizontal = manual.width > manual.height && widths.reduce((sum, width) => sum + width, 0) + size <= manual.width;
+  const rowWidth = horizontal ? manual.width / entries.length : manual.width;
+  const rowHeight = horizontal ? manual.height : manual.height / entries.length;
+  const horizontalGap = Math.max(
+    0,
+    (manual.width - widths.reduce((sum, width) => sum + width, 0)) / (entries.length + 1)
+  );
+  let horizontalX = manual.x + horizontalGap;
+  const markup = [
+    chartAreaRect(model, "legend", { x: manual.x, y: manual.y, w: manual.width, h: manual.height })
+  ];
+  const baselineOffset = font ? (font.ascent - font.descent) / 2 : size * 0.35;
+  entries.forEach((entry3, i) => {
+    const available = horizontal ? chartTextWidth(entry3.label, attrs, options) : Math.max(0, rowWidth - size / 2 - keySize - keyGap);
+    const label = fitChartText(entry3.label, available, attrs, options);
+    const contentWidth = Math.min(
+      horizontal ? widths[i] ?? 0 : Math.max(...widths),
+      rowWidth - size / 2
+    );
+    const x = horizontal ? horizontalX : manual.x + Math.max(size / 4, (rowWidth - contentWidth) / 2);
+    const centerY = manual.y + (horizontal ? 0 : i * rowHeight) + rowHeight / 2;
+    markup.push(rect(x, centerY - keySize / 2, keySize, keySize, entry3.color));
+    markup.push(text(x + keySize + keyGap, centerY + baselineOffset, label, attrs));
+    if (horizontal) horizontalX += (widths[i] ?? 0) + horizontalGap;
+  });
+  return {
+    plot,
+    markup: `<g data-chart-legend-layout="true">${markup.join("")}</g>`,
+    foreground: true
+  };
+}
+function legendEntries(model) {
+  if (model.type === "pie" || model.type === "doughnut") {
+    const first2 = model.series[0];
+    return model.categories.map((label, i) => ({
+      label,
+      color: first2?.pointColors?.[i] ?? first2?.color ?? "#4472C4"
+    }));
+  }
+  return model.series.map((s) => ({ label: s.name, color: s.color }));
+}
+function automaticLegend(model, area, out, options, bounds) {
+  const entries = legendEntries(model);
+  if (!model.showLegend || entries.length === 0) return area;
+  const pos = model.legendPosition;
+  const attrs = chartTextAttributes(model, "legend");
+  const size = attrs.size ?? 10;
+  const rowH = Math.max(16, size * 1.4);
+  if (pos === "t" || pos === "b") {
+    const widths = entries.map(
+      (e) => Math.min(chartTextWidth(e.label, attrs, options) + 20, area.w / 2)
+    );
+    const total = widths.reduce((a2, b) => a2 + b, 0);
+    let x2 = area.x + Math.max(0, (area.w - total) / 2);
+    const y = pos === "t" ? area.y + 4 : area.y + area.h - rowH + 4;
+    bounds.box = { x: x2 - 4, y: y - 4, w: Math.min(total, area.w) + 8, h: rowH + 4 };
+    out.push(
+      chartAreaRect(model, "legend", {
+        x: x2 - 4,
+        y: y - 4,
+        w: Math.min(total, area.w) + 8,
+        h: rowH + 4
+      })
+    );
+    entries.forEach((e, i) => {
+      const w = widths[i] ?? 0;
+      out.push(rect(x2, y, 8, 8, e.color));
+      out.push(text(x2 + 12, y + 8, fitChartText(e.label, w - 16, attrs, options), attrs));
+      x2 += w;
+    });
+    return pos === "t" ? { x: area.x, y: area.y + rowH + 4, w: area.w, h: area.h - rowH - 4 } : { x: area.x, y: area.y, w: area.w, h: area.h - rowH - 4 };
+  }
+  const width = Math.min(
+    area.w * 0.35,
+    Math.max(...entries.map((e) => chartTextWidth(e.label, attrs, options))) + 22
+  );
+  const height = entries.length * rowH;
+  const x = pos === "l" ? area.x + 4 : area.x + area.w - width;
+  const y0 = pos === "tr" ? area.y + 4 : area.y + Math.max(0, (area.h - height) / 2);
+  bounds.box = { x: x - 4, y: y0, w: width + 4, h: Math.min(height, area.y + area.h - y0) };
+  out.push(
+    chartAreaRect(model, "legend", {
+      x: x - 4,
+      y: y0,
+      w: width + 4,
+      h: Math.min(height, area.y + area.h - y0)
+    })
+  );
+  entries.forEach((e, i) => {
+    const y = y0 + i * rowH;
+    if (y + rowH > area.y + area.h + 2) return;
+    out.push(rect(x, y + 3, 8, 8, e.color));
+    out.push(text(x + 12, y + 11, fitChartText(e.label, width - 16, attrs, options), attrs));
+  });
+  return pos === "l" ? { x: area.x + width + 8, y: area.y, w: area.w - width - 8, h: area.h } : { x: area.x, y: area.y, w: area.w - width - 8, h: area.h };
+}
+
+// text/wrap-styled-runs.ts
+var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
+  const groups = [];
+  for (const [source, run2] of runs.entries()) {
+    for (const token of run2.text.split(/(\r\n|[\r\n]|[ \t]+)/u).filter(Boolean)) {
+      const kind = /^[\r\n]+$/u.test(token) ? "break" : /^[ \t]+$/u.test(token) ? "space" : "word";
+      let group = groups.at(-1);
+      if (!group || group.kind !== kind || kind === "break") {
+        group = { kind, pieces: [] };
+        groups.push(group);
+      }
+      if (kind !== "break") group.pieces.push({ run: run2, source, text: token });
+    }
+  }
+  const merged = (left, right) => {
+    const result2 = left.map((piece) => ({ ...piece }));
+    for (const piece of right) {
+      const last = result2.at(-1);
+      if (last?.source === piece.source) last.text += piece.text;
+      else result2.push({ ...piece });
+    }
+    return result2;
+  };
+  const width = (pieces) => pieces.reduce((sum, piece) => {
+    const advance = measure(piece.text, piece.run);
+    return sum + (Number.isFinite(advance) && advance >= 0 ? advance : 0);
+  }, 0);
+  const result = [];
+  let line2 = [];
+  let spaces = [];
+  const flush = () => {
+    result.push(line2.map((piece) => ({ ...piece.run, text: piece.text })));
+    line2 = [];
+    spaces = [];
+  };
+  for (const group of groups) {
+    if (group.kind === "break") {
+      flush();
+      continue;
+    }
+    if (group.kind === "space") {
+      spaces = group.pieces;
+      continue;
+    }
+    const separator = line2.length ? spaces : [];
+    const wordWidth = width(group.pieces);
+    if (line2.length && width(merged(line2, [...separator, ...group.pieces])) > maxWidth) flush();
+    else line2 = merged(line2, separator);
+    spaces = [];
+    if (options.breakWords && wordWidth > maxWidth) {
+      for (const piece of group.pieces) {
+        for (const { segment } of graphemes.segment(piece.text)) {
+          const next = { ...piece, text: segment };
+          if (line2.length && width(merged(line2, [next])) > maxWidth) flush();
+          line2 = merged(line2, [next]);
+        }
+      }
+    } else line2 = merged(line2, group.pieces);
+  }
+  flush();
+  return result;
+}
+
+// chart/render/chart-svg-title-text.ts
+function spacing2(value, naturalHeight, fallback) {
+  return value ? value.unit === "points" ? chartPointsToPixels(value.value) : naturalHeight * value.value : fallback;
+}
+function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
+  if (!model.title) return void 0;
+  const base = chartTextAttributes(model, "title", 14);
+  const capacity = Math.max(1, width * 0.8 - 8);
+  if (!model.titleText && !hasManualLayoutFields(model.titleLayout) && !model.titleOverlay && !model.title.includes("\n") && chartTextWidth(model.title, base, options) <= capacity)
+    return void 0;
+  const paragraphs = model.titleText?.paragraphs ?? [
+    {
+      runs: [{ text: model.title, appearance: model.appearance?.title ?? {} }]
+    }
+  ];
+  const hardLines = [];
+  for (const paragraph2 of paragraphs) {
+    let line2 = {
+      ...paragraph2,
+      runs: []
+    };
+    hardLines.push(line2);
+    for (const run2 of paragraph2.runs) {
+      const pieces = run2.text.split("\n");
+      for (const [index, piece] of pieces.entries()) {
+        if (index) {
+          line2 = { ...paragraph2, runs: [] };
+          hardLines.push(line2);
+        }
+        if (piece) line2.runs.push({ ...run2, text: piece });
+      }
+    }
+  }
+  const lines = hardLines.flatMap((line2) => {
+    const wrapped = wrapStyledRuns(
+      line2.runs,
+      capacity,
+      (content, run2) => chartTextWidth(
+        content,
+        chartTextAttributes(
+          { ...model, appearance: { title: run2.appearance } },
+          "title",
+          base.size
+        ),
+        options
+      ),
+      { breakWords: true }
+    );
+    const { spaceBefore, spaceAfter, ...properties2 } = line2;
+    return wrapped.map((runs, index) => ({
+      ...properties2,
+      runs,
+      ...index === 0 && spaceBefore ? { spaceBefore } : {},
+      ...index === wrapped.length - 1 && spaceAfter ? { spaceAfter } : {}
+    }));
+  });
+  const metrics = lines.map((line2) => {
+    const runs = line2.runs.map((run2) => ({
+      ...run2,
+      attrs: chartTextAttributes(
+        { ...model, appearance: { title: run2.appearance } },
+        "title",
+        base.size
+      )
+    }));
+    return {
+      ...line2,
+      runs,
+      width: runs.reduce((sum, run2) => sum + chartTextWidth(run2.text, run2.attrs, options), 0),
+      size: runs.length ? Math.max(...runs.map((run2) => run2.attrs.size ?? 14)) : base.size ?? 14,
+      fontMetrics: (runs.length ? runs.map((run2) => run2.attrs) : [base]).map(
+        (attrs) => chartFontMetrics(attrs, options)
+      )
+    };
+  });
+  const measured = metrics.every((line2) => line2.fontMetrics.every((font) => font !== void 0));
+  const vertical = metrics.map((line2) => {
+    const ascent = measured ? Math.max(...line2.fontMetrics.map((font) => font.ascent)) : line2.size;
+    const descent = measured ? Math.max(...line2.fontMetrics.map((font) => font.descent)) : line2.size * 0.4 + 4;
+    const natural = ascent + descent;
+    const height2 = spacing2(line2.lineSpacing, natural, natural);
+    const leading = (height2 - natural) / 2;
+    return {
+      ascent: ascent + leading,
+      descent: descent + leading,
+      height: height2,
+      before: spacing2(line2.spaceBefore, natural, 0),
+      after: spacing2(line2.spaceAfter, natural, 0),
+      leading
+    };
+  });
+  const boxWidth = Math.min(width - 16, Math.max(0, ...metrics.map((line2) => line2.width)) + 8);
+  const height = vertical.reduce(
+    (sum, line2) => sum + line2.height + line2.before + line2.after,
+    measured ? 4 : 0
+  );
+  let baseline = 8 + (metrics[0]?.size ?? base.size ?? 14) + (vertical[0]?.before ?? 0) + (vertical[0]?.leading ?? 0);
+  const spans = [];
+  for (const [index, line2] of metrics.entries()) {
+    if (index)
+      baseline += vertical[index - 1].descent + vertical[index - 1].after + vertical[index].before + vertical[index].ascent;
+    let x = line2.align === "l" ? (width - boxWidth) / 2 + 4 : line2.align === "r" ? (width + boxWidth) / 2 - 4 - line2.width : (width - line2.width) / 2;
+    for (const run2 of line2.runs) {
+      spans.push(
+        text(x, baseline, run2.text, {
+          ...run2.attrs,
+          anchor: "start"
+        }).replace("<text ", '<tspan data-chart-title-run="true" ').replace("</text>", "</tspan>")
+      );
+      x += chartTextWidth(run2.text, run2.attrs, options);
+    }
+  }
+  const parent = text(0, 0, "", { ...base, underline: false }).replace(
+    "</text>",
+    `${spans.join("")}</text>`
+  );
+  const markup = chartAreaRect(model, "title", {
+    x: (width - boxWidth) / 2,
+    y: 4,
+    w: Math.max(0, boxWidth),
+    h: height
+  }) + parent;
+  const automatic = { x: (width - boxWidth) / 2, y: 4, width: boxWidth, height };
+  const manual = resolveManualLayoutRect(
+    model.titleLayout,
+    { width, height: frameHeight },
+    automatic
+  );
+  return {
+    markup: manual ? `<g data-chart-title-layout="true" transform="translate(${n(manual.x - automatic.x)} ${n(manual.y - automatic.y)})">${markup}</g>` : markup,
+    height: Math.max(24, height)
+  };
+}
+
+// chart/render/chart-svg.ts
+function renderChartSvg(model, width, height, options = {}) {
+  const paint = chartGradientPaint(model, Math.max(1, width), Math.max(1, height));
+  model = paint.model;
+  const w = Math.max(1, width);
+  const h = Math.max(1, height);
+  const out = [];
+  let foregroundTitle = "";
+  out.push(
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${n(w)}" height="${n(h)}" viewBox="0 0 ${n(w)} ${n(h)}" font-family="${esc(CHART_FONT_FAMILY)}" role="img">`
+  );
+  if (model.title) out.push(`<title>${esc(model.title)}</title>`);
+  if (paint.defs) out.push(paint.defs);
+  out.push(chartAreaRect(model, "chartArea", { x: 0, y: 0, w, h }));
+  let area = { x: 8, y: 8, w: w - 16, h: h - 16 };
+  const richTitle = chartRichTitleSvg(model, w, options, h);
+  if (richTitle) {
+    if (model.titleLayout || model.titleOverlay) foregroundTitle = richTitle.markup;
+    else out.push(richTitle.markup);
+    if (!model.titleOverlay)
+      area = { ...area, y: area.y + richTitle.height, h: area.h - richTitle.height };
+  } else if (model.title) {
+    const attrs = chartTextAttributes(model, "title", 14);
+    const size = attrs.size ?? 14;
+    const label = fitChartText(model.title, w - 16, attrs, options);
+    const titleWidth = Math.min(w - 16, chartTextWidth(label, attrs, options) + 8);
+    const font = chartFontMetrics(attrs, options);
+    const titleHeight = Math.max(24, font ? font.ascent + font.descent + 4 : size * 1.4 + 4);
+    out.push(
+      chartAreaRect(model, "title", {
+        x: (w - titleWidth) / 2,
+        y: 4,
+        w: Math.max(0, titleWidth),
+        h: font ? font.ascent + font.descent + 4 : size * 1.4 + 4
+      })
+    );
+    out.push(
+      text(w / 2, 8 + size, label, {
+        anchor: "middle",
+        fill: "#404040",
+        ...attrs
+      })
+    );
+    if (!model.titleOverlay)
+      area = { x: area.x, y: area.y + titleHeight, w: area.w, h: area.h - titleHeight };
+  }
+  if (!model.supported) {
+    out.push(
+      text(w / 2, area.y + area.h / 2, `${model.type} charts are not drawn`, { anchor: "middle" })
+    );
+    if (foregroundTitle) out.push(foregroundTitle);
+    out.push("</svg>");
+    return out.join("");
+  }
+  const legend = chartLegendSvg(model, area, { width: w, height: h }, options);
+  area = legend.plot;
+  if (!legend.foreground) out.push(legend.markup);
+  if (area.w > 4 && area.h > 4) {
+    if (model.type === "pie" || model.type === "doughnut") out.push(pieSvg(model, area));
+    else if (model.type === "radar") out.push(radarSvg(model, area));
+    else out.push(cartesianSvg(model, area));
+  }
+  if (legend.foreground) out.push(legend.markup);
+  if (foregroundTitle) out.push(foregroundTitle);
+  out.push("</svg>");
+  return out.join("");
+}
+
+// chart/render/render-space.ts
+var DRAWN_CHART_TYPES = /* @__PURE__ */ new Set([
+  "bar",
+  "column",
+  "line",
+  "area",
+  "pie",
+  "doughnut",
+  "scatter",
+  "radar"
+]);
+function chartThemePalette(theme, fonts = {}) {
+  return {
+    colors: THEME_SLOTS.map(
+      (slot, index) => themeSlotHex(theme?.colors[slot]) ?? DEFAULT_THEME_COLORS[index] ?? "000000"
+    ),
+    majorFont: fonts.major ?? "Calibri Light",
+    minorFont: fonts.minor ?? "Calibri"
+  };
+}
+function chartSpaceKind(space) {
+  if (!space.plotArea.groups.length) return { drawn: false };
+  const type = chartSummaryFromSpace(space).chartType;
+  return { type, drawn: DRAWN_CHART_TYPES.has(type) };
+}
+function renderChartSpaceSvg(space, options) {
+  const { width, height, theme, fonts, formatting, colorPalette, styleDefinition, ...svg } = options;
+  const summary = chartSummaryFromSpace(space, {
+    ...formatting ? { formatting } : {},
+    ...colorPalette !== void 0 ? { colorPalette } : {},
+    ...styleDefinition ? { styleDefinition } : {}
+  });
+  const view = chartSummaryView(summary, chartThemePalette(theme, fonts));
+  return renderChartSvg(view, width, height, svg);
+}
+
 exports.BEST_FIT_EDGE_TOLERANCE = BEST_FIT_EDGE_TOLERANCE;
 exports.BEST_FIT_OUTSIDE_GAP = BEST_FIT_OUTSIDE_GAP;
 exports.BEST_FIT_RIM_INSET = BEST_FIT_RIM_INSET;
@@ -2318,20 +5223,34 @@ exports.CHART_COLOR_PALETTES = CHART_COLOR_PALETTES;
 exports.CHART_COLOR_STYLE_CONTENT_TYPE = CHART_COLOR_STYLE_CONTENT_TYPE;
 exports.CHART_COLOR_STYLE_NS = CHART_COLOR_STYLE_NS;
 exports.CHART_COLOR_STYLE_REL = CHART_COLOR_STYLE_REL;
+exports.CHART_GROUP_ELEMENTS = CHART_GROUP_ELEMENTS;
 exports.CHART_STYLE_PARTS = CHART_STYLE_PARTS;
+exports.DEFAULT_THEME_COLORS = DEFAULT_THEME_COLORS;
+exports.DRAWN_CHART_TYPES = DRAWN_CHART_TYPES;
 exports.LABEL_COLLISION_GAP = LABEL_COLLISION_GAP;
+exports.THEME_SLOTS = THEME_SLOTS;
 exports.aggregateByCategory = aggregateByCategory;
 exports.assertBarClusterOptions = assertBarClusterOptions;
+exports.autoSeriesColor = autoSeriesColor;
 exports.axisTargetIntervals = axisTargetIntervals;
 exports.buildChartGradientDef = buildChartGradientDef;
 exports.builtInChartStyleXml = builtInChartStyleXml;
 exports.builtInChartTextStyle = builtInChartTextStyle;
+exports.categoryTotals = categoryTotals;
+exports.chartCacheValues = chartCacheValues;
+exports.chartColorScheme = chartColorScheme;
 exports.chartColorStyleId = chartColorStyleId;
 exports.chartColorStyleXml = chartColorStyleXml;
 exports.chartGradientMarkup = chartGradientMarkup;
 exports.chartPaletteColors = chartPaletteColors;
 exports.chartPaletteSeriesColor = chartPaletteSeriesColor;
 exports.chartPaletteSeriesColorChoice = chartPaletteSeriesColorChoice;
+exports.chartSourceValues = chartSourceValues;
+exports.chartSpaceKind = chartSpaceKind;
+exports.chartSummaryFromSpace = chartSummaryFromSpace;
+exports.chartSummarySeries = chartSummarySeries;
+exports.chartSummaryView = chartSummaryView;
+exports.chartThemePalette = chartThemePalette;
 exports.clusteredBarGeometry = clusteredBarGeometry;
 exports.computeBoxStats = computeBoxStats;
 exports.computeHistogramBins = computeHistogramBins;
@@ -2350,9 +5269,11 @@ exports.formatPowerEquation = formatPowerEquation;
 exports.formatTrendlineCoefficient = formatTrendlineCoefficient;
 exports.groupRowsByCategory = groupRowsByCategory;
 exports.hasManualLayoutFields = hasManualLayoutFields;
+exports.modulateLuminance = modulateLuminance;
 exports.niceAxisStep = niceAxisStep;
 exports.niceValueAxisBounds = niceValueAxisBounds;
 exports.nudgeOutsideLabels = nudgeOutsideLabels;
+exports.parseChartSpace = parseChartSpace;
 exports.placeBestFitLabel = placeBestFitLabel;
 exports.radarAngle = radarAngle;
 exports.radarRingPoints = radarRingPoints;
@@ -2360,7 +5281,10 @@ exports.readBuiltInChartStyle = readBuiltInChartStyle;
 exports.readChartFormatting = readChartFormatting;
 exports.readChartManualLayoutValues = readChartManualLayoutValues;
 exports.readChartStyle = readChartStyle;
+exports.readDisplayNaAsBlank = readDisplayNaAsBlank;
 exports.removeGradientStop = removeGradientStop;
+exports.renderChartSpaceSvg = renderChartSpaceSvg;
+exports.renderChartSvg = renderChartSvg;
 exports.resolveBlankDisplay = resolveBlankDisplay;
 exports.resolveChartGradient = resolveChartGradient;
 exports.resolveChartStyleDefinition = resolveChartStyleDefinition;
@@ -2368,6 +5292,7 @@ exports.resolveManualLayoutRect = resolveManualLayoutRect;
 exports.scottBinCount = scottBinCount;
 exports.sortGradientStops = sortGradientStops;
 exports.squarify = squarify;
+exports.themeColor = themeColor;
 exports.updateGradientStop = updateGradientStop;
 exports.visibleRuns = visibleRuns;
 exports.withChartGradientDirection = withChartGradientDirection;
@@ -2375,3 +5300,4 @@ exports.withinLinearTransform = withinLinearTransform;
 exports.writeChartAxisFormatting = writeChartAxisFormatting;
 exports.writeChartFillFormatting = writeChartFillFormatting;
 exports.writeChartLayoutFormatting = writeChartLayoutFormatting;
+exports.writeChartSpace = writeChartSpace;