ooxml-core 1.12.2 → 1.14.0

package/dist/chart/index.cjs

@@ -290,6 +290,669 @@ function niceValueAxisBounds(dataMin, dataMax, targetIntervals = DEFAULT_TARGET_
   return { min, max, majorUnit: unit };
 }
 
+// chart/number-format-pattern.ts
+var NAMED_FORMAT_COLORS = {
+  black: "#000000",
+  blue: "#0000FF",
+  cyan: "#00FFFF",
+  green: "#00FF00",
+  magenta: "#FF00FF",
+  red: "#FF0000",
+  white: "#FFFFFF",
+  yellow: "#FFFF00"
+};
+var PLACEHOLDER = /[0#?]/u;
+function parsePattern(code) {
+  let scale = 1;
+  let scientific = false;
+  let color;
+  const chars = [];
+  let inQuotes = false;
+  for (let i = 0; i < code.length; i += 1) {
+    const ch = code[i] ?? "";
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (inQuotes) {
+      chars.push({ ch, literal: true });
+      continue;
+    }
+    if (ch === "\\" || ch === "*" || ch === "_") {
+      const next = code[i + 1];
+      i += 1;
+      if (ch === "\\" && next !== void 0) {
+        chars.push({ ch: next, literal: true });
+      }
+      continue;
+    }
+    if (ch === "%") {
+      scale *= 100;
+      chars.push({ ch, literal: true });
+      continue;
+    }
+    if (ch === "E" && (code[i + 1] === "+" || code[i + 1] === "-")) {
+      scientific = true;
+      chars.push({ ch: "E", literal: false });
+      i += 1;
+      continue;
+    }
+    if (ch === "[") {
+      const close = code.indexOf("]", i);
+      const token = code.slice(i + 1, close === -1 ? code.length : close);
+      const named2 = NAMED_FORMAT_COLORS[token.trim().toLowerCase()];
+      if (named2 && color === void 0) {
+        color = named2;
+      }
+      i = close === -1 ? code.length : close;
+      continue;
+    }
+    chars.push({ ch, literal: false });
+  }
+  const firstDigit = chars.findIndex((c2) => !c2.literal && PLACEHOLDER.test(c2.ch));
+  if (firstDigit === -1) {
+    return void 0;
+  }
+  let lastDigit = firstDigit;
+  for (let i = chars.length - 1; i >= firstDigit; i -= 1) {
+    const c2 = chars[i];
+    if (c2 && !c2.literal && (PLACEHOLDER.test(c2.ch) || c2.ch === "." || c2.ch === "," || c2.ch === "E")) {
+      lastDigit = i;
+      break;
+    }
+  }
+  const numeric = chars.slice(firstDigit, lastDigit + 1);
+  const prefix = chars.slice(0, firstDigit).map((c2) => c2.ch).join("");
+  const suffix = chars.slice(lastDigit + 1).map((c2) => c2.ch).join("");
+  let grouped = false;
+  let intDigits = 0;
+  let required = 0;
+  let optional = 0;
+  let afterPoint = false;
+  let inExponent = false;
+  for (let i = 0; i < numeric.length; i += 1) {
+    const { ch, literal } = numeric[i] ?? { ch: "", literal: true };
+    if (literal) {
+      continue;
+    }
+    if (ch === "E") {
+      inExponent = true;
+      continue;
+    }
+    if (inExponent) {
+      continue;
+    }
+    if (ch === ".") {
+      afterPoint = true;
+      continue;
+    }
+    if (ch === ",") {
+      const next = numeric.slice(i + 1).find((c2) => !c2.literal);
+      if (!next || next.ch === "." || !PLACEHOLDER.test(next.ch)) {
+        scale /= 1e3;
+      } else {
+        grouped = true;
+      }
+      continue;
+    }
+    if (!PLACEHOLDER.test(ch)) {
+      continue;
+    }
+    if (afterPoint) {
+      if (ch === "0") {
+        required += 1;
+      } else {
+        optional += 1;
+      }
+    } else if (ch === "0") {
+      intDigits += 1;
+    }
+  }
+  return {
+    prefix,
+    suffix,
+    intDigits,
+    decimals: { required, optional },
+    grouped,
+    scale,
+    scientific,
+    color
+  };
+}
+function group(intPart) {
+  return intPart.replace(/\B(?=(\d{3})+(?!\d))/gu, ",");
+}
+function applyPattern(value, pattern, forcePositive) {
+  const scaled = value * pattern.scale;
+  const magnitude = forcePositive ? Math.abs(scaled) : scaled;
+  if (pattern.scientific) {
+    const digits = pattern.decimals.required + pattern.decimals.optional;
+    const exponential = magnitude.toExponential(digits);
+    const [mantissa = "", exponent = "0"] = exponential.split("e");
+    const sign = exponent.startsWith("-") ? "-" : "+";
+    const power = Math.abs(Number(exponent)).toString().padStart(2, "0");
+    return `${pattern.prefix}${mantissa}E${sign}${power}${pattern.suffix}`;
+  }
+  const maxDecimals = pattern.decimals.required + pattern.decimals.optional;
+  let body = magnitude.toFixed(maxDecimals);
+  if (pattern.decimals.optional > 0) {
+    body = body.replace(/(\.\d*?)0+$/u, "$1").replace(/\.$/u, "");
+    const [, frac = ""] = body.split(".");
+    if (frac.length < pattern.decimals.required) {
+      body = Number(body).toFixed(pattern.decimals.required);
+    }
+  }
+  const [rawIntPart = "", fracPart] = body.split(".");
+  let intPart = rawIntPart;
+  const hasMinusChar = intPart.startsWith("-");
+  const negative = hasMinusChar && Number(body) !== 0;
+  if (hasMinusChar) {
+    intPart = intPart.slice(1);
+  }
+  if (intPart.length < pattern.intDigits) {
+    intPart = intPart.padStart(pattern.intDigits, "0");
+  }
+  if (pattern.intDigits === 0 && intPart === "0" && fracPart !== void 0) {
+    intPart = "";
+  }
+  if (pattern.grouped) {
+    intPart = group(intPart);
+  }
+  const number = fracPart === void 0 ? intPart : `${intPart}.${fracPart}`;
+  return `${negative ? "-" : ""}${pattern.prefix}${number}${pattern.suffix}`;
+}
+
+// chart/number-format.ts
+var GENERAL = /* @__PURE__ */ new Set(["", "general", "@"]);
+function sections(code) {
+  const out = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < code.length; i += 1) {
+    const ch = code[i];
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      current += ch;
+      continue;
+    }
+    if (ch === "\\") {
+      current += ch + (code[i + 1] ?? "");
+      i += 1;
+      continue;
+    }
+    if (ch === ";" && !inQuotes) {
+      out.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  out.push(current);
+  return out;
+}
+function sectionFor(value, parts) {
+  if (parts.length === 1) {
+    return { code: parts[0] ?? "", forcePositive: false };
+  }
+  if (value < 0 && parts[1] !== void 0) {
+    return { code: parts[1] ?? "", forcePositive: true };
+  }
+  if (value === 0 && parts[2] !== void 0) {
+    return { code: parts[2] ?? "", forcePositive: false };
+  }
+  return { code: parts[0] ?? "", forcePositive: false };
+}
+function formatChartNumberWithColor(value, formatCode) {
+  if (!Number.isFinite(value)) {
+    return void 0;
+  }
+  const code = (formatCode ?? "").trim();
+  if (GENERAL.has(code.toLowerCase())) {
+    return void 0;
+  }
+  if (/(?:^|[^\\"])(?:yy|mm?m|dd?|hh|ss)/iu.test(code) && !/[0#?]/u.test(code)) {
+    return void 0;
+  }
+  const { code: section, forcePositive } = sectionFor(value, sections(code));
+  const pattern = parsePattern(section);
+  if (!pattern) {
+    return void 0;
+  }
+  try {
+    return { text: applyPattern(value, pattern, forcePositive), color: pattern.color };
+  } catch {
+    return void 0;
+  }
+}
+function formatChartNumber(value, formatCode) {
+  return formatChartNumberWithColor(value, formatCode)?.text;
+}
+
+// chart/auto-title.ts
+var CHART_AUTO_TITLE = "Chart Title";
+var CHARTEX_ONLY_TYPES = /* @__PURE__ */ new Set([
+  "waterfall",
+  "funnel",
+  "treemap",
+  "sunburst",
+  "boxWhisker",
+  "histogram",
+  "regionMap"
+]);
+function isChartexOnlyType(chartType) {
+  return CHARTEX_ONLY_TYPES.has(chartType);
+}
+function impliesAutoTitle(input) {
+  return !(input.hasTitle !== void 0 || input.autoTitleDeleted === true || isChartexOnlyType(input.chartType) || input.seriesNames.length !== 1 || !input.seriesNames[0]);
+}
+function resolveAutoTitleText(input) {
+  if (!input.hasTitle) return void 0;
+  if (input.title) return input.title;
+  if (!isChartexOnlyType(input.chartType) && input.seriesNames.length === 1)
+    return input.seriesNames[0] || void 0;
+  return input.seriesNames.length > 0 ? CHART_AUTO_TITLE : void 0;
+}
+
+// chart/axis-format.ts
+function formatCompactAxisValue(value, formatCode) {
+  const formatted = formatChartNumber(value, formatCode);
+  if (formatted !== void 0) return formatted;
+  if (Math.abs(value) >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (Math.abs(value) >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
+  if (Number.isInteger(value)) return String(value);
+  return value.toFixed(1);
+}
+
+// chart/bubble-radius.ts
+function computeBubbleRadius(sizeVal, maxBubble, medianRadius, options) {
+  const scale = (options?.bubbleScale ?? 100) / 100;
+  if (sizeVal === void 0) return medianRadius * scale;
+  const denom = maxBubble > 0 ? maxBubble : 1;
+  const magnitude = Math.abs(sizeVal);
+  const ratio = (options?.sizeRepresents ?? "w") === "area" ? Math.sqrt(magnitude) / Math.sqrt(denom) : magnitude / denom;
+  return medianRadius * scale * 0.5 + ratio * medianRadius * scale * 1.5;
+}
+function maxBubbleSize(sizes) {
+  return sizes.length > 0 ? Math.max(1, ...sizes.map(Math.abs)) : 1;
+}
+function medianBubbleRadius(plotWidth, plotHeight) {
+  return Math.min(plotWidth, plotHeight) * 0.04;
+}
+
+// chart/stock-candles.ts
+var STOCK_DEFAULT_UP_FILL = "#FFFFFF";
+var STOCK_DEFAULT_DOWN_FILL = "#404040";
+var STOCK_DEFAULT_WICK_COLOR = "#334155";
+var STOCK_TICK_WIDTH = 1.5;
+function stockSlots(count, closeLast = false) {
+  if (count < 3) return void 0;
+  const four = count >= 4;
+  return {
+    ...four ? { open: 0 } : {},
+    high: four ? 1 : 0,
+    low: four ? 2 : 1,
+    close: closeLast ? count - 1 : four ? 3 : 2
+  };
+}
+var present = (v) => v !== null && v !== void 0;
+function stockCandle(input) {
+  const { high, low, close, open, x, band, y } = input;
+  if (!present(high) || !present(low)) return void 0;
+  const candleWidth = band * (input.bodyShare ?? 0.5);
+  const candle = { wick: { x, y1: y(high), y2: y(low) } };
+  if (input.hasOpen && present(open) && present(close)) {
+    const openY = y(open);
+    const closeY = y(close);
+    candle.body = {
+      x: x - candleWidth / 2,
+      y: Math.min(openY, closeY),
+      w: candleWidth,
+      h: Math.max(Math.abs(openY - closeY), 1),
+      up: close >= open
+    };
+  } else if (present(close)) {
+    candle.tick = {
+      x1: x,
+      x2: x + Math.max(candleWidth * 0.4, 4),
+      y: y(close)
+    };
+  }
+  return candle;
+}
+
+// chart/treemap-squarify.ts
+function worstAspectRatio(areas, side) {
+  const sum = areas.reduce((total, area) => total + area, 0);
+  const max = Math.max(...areas);
+  const min = Math.min(...areas);
+  const sideSq = side * side;
+  const sumSq = sum * sum;
+  return Math.max(sideSq * max / sumSq, sumSq / (sideSq * min));
+}
+function squarify(nodes, box) {
+  const sorted = [...nodes].sort((a2, b) => b.weight - a2.weight);
+  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
+  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 rect2 = { ...box };
+  let remaining = items;
+  for (let first2 = remaining[0]; first2 !== void 0; first2 = remaining[0]) {
+    const side = Math.min(rect2.w, rect2.h);
+    let row = [first2];
+    let rowAreas = [first2.area];
+    let worst = worstAspectRatio(rowAreas, side);
+    let cursor = 1;
+    for (let next = remaining[cursor]; next !== void 0; next = remaining[cursor]) {
+      const candidateAreas = [...rowAreas, next.area];
+      const candidateWorst = worstAspectRatio(candidateAreas, side);
+      if (candidateWorst > worst) {
+        break;
+      }
+      row = [...row, next];
+      rowAreas = candidateAreas;
+      worst = candidateWorst;
+      cursor++;
+    }
+    const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
+    const thickness = side > 0 ? rowTotalArea / side : 0;
+    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: rect2.x, y: offset, w: thickness, h: length }]);
+      } else {
+        result.push([item.node, { x: offset, y: rect2.y, w: length, h: thickness }]);
+      }
+      offset += length;
+    }
+    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;
+}
+
+// chart/hierarchy.ts
+function normalizeLevels(levels, pointCount) {
+  return levels.map((level) => {
+    let previous = "";
+    return Array.from({ length: pointCount }, (_, index) => {
+      const label = level[index]?.trim() ?? "";
+      if (label) previous = label;
+      return label || previous;
+    });
+  });
+}
+function findOrAddParent(children2, label, colorIndex, parentLabelLayout) {
+  const existing = children2.find((child2) => child2.children && child2.label === label);
+  if (existing?.children) return existing;
+  const parent = { label, weight: 0, children: [], colorIndex, parentLabelLayout };
+  children2.push(parent);
+  return parent;
+}
+function buildSeriesHierarchy(series, seriesIndex, categoryLabels, categoryLevels2, colorStride) {
+  const pointCount = series.values.length;
+  const levels = normalizeLevels(categoryLevels2 ?? [], pointCount);
+  const layout = series.parentLabelLayout ?? "banner";
+  const roots = [];
+  for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
+    let children2 = roots;
+    for (let levelIndex = levels.length - 1; levelIndex >= 1; levelIndex--) {
+      const label = levels[levelIndex]?.[pointIndex] || `Group ${levelIndex}`;
+      children2 = findOrAddParent(children2, label, pointIndex, layout).children;
+    }
+    children2.push({
+      label: levels[0]?.[pointIndex] || categoryLabels[pointIndex] || String(pointIndex + 1),
+      weight: Math.abs(series.values[pointIndex] ?? 0),
+      seriesIndex,
+      pointIndex,
+      colorIndex: seriesIndex * colorStride + pointIndex,
+      parentLabelLayout: layout
+    });
+  }
+  return roots;
+}
+function aggregate(node) {
+  if (node.children) node.weight = node.children.reduce((sum, child2) => sum + aggregate(child2), 0);
+  return node.weight;
+}
+function propagateColor(node, colorIndex) {
+  node.colorIndex = colorIndex;
+  for (const child2 of node.children ?? []) propagateColor(child2, colorIndex);
+}
+function buildHierarchyRoots(series, categoryLabels, categoryLevels2) {
+  const colorStride = Math.max(categoryLabels.length, ...series.map((s) => s.values.length), 1);
+  let roots = series.flatMap(
+    (s, index) => buildSeriesHierarchy(s, index, categoryLabels, categoryLevels2, colorStride)
+  );
+  if (series.length > 1)
+    roots = series.map((s, index) => ({
+      label: s.name,
+      weight: 0,
+      children: buildSeriesHierarchy(s, index, categoryLabels, categoryLevels2, colorStride),
+      colorIndex: index * colorStride,
+      parentLabelLayout: s.parentLabelLayout ?? "banner"
+    }));
+  for (const root of roots) aggregate(root);
+  roots.forEach((root, index) => propagateColor(root, index));
+  return roots;
+}
+function hierarchyBranchLabels(series, categoryLabels, categoryLevels2) {
+  if (series.length > 1) return series.map((s) => s.name);
+  if (categoryLevels2 && categoryLevels2.length > 1) {
+    const pointCount = series[0]?.values.length ?? categoryLabels.length;
+    const topLevel = normalizeLevels(categoryLevels2, pointCount).at(-1) ?? [];
+    const seen = [];
+    for (const label of topLevel) if (!seen.includes(label)) seen.push(label);
+    return seen;
+  }
+  return [...categoryLabels];
+}
+var BANNER_HEIGHT = 16;
+function layoutTreemap(nodes, box) {
+  const cells = [];
+  for (const [node, allocation] of squarify(nodes, box)) {
+    const cell = {
+      x: allocation.x + 1,
+      y: allocation.y + 1,
+      w: Math.max(allocation.w - 2, 1),
+      h: Math.max(allocation.h - 2, 1)
+    };
+    if (node.children) {
+      const showParent = node.parentLabelLayout !== "none" && cell.w > 28 && cell.h > 16;
+      if (showParent)
+        cells.push({ kind: "parent", label: node.label, x: cell.x + 4, y: cell.y + 11 });
+      const banner = showParent && node.parentLabelLayout === "banner" ? BANNER_HEIGHT : 0;
+      cells.push(
+        ...layoutTreemap(node.children, {
+          ...cell,
+          y: cell.y + banner,
+          h: Math.max(cell.h - banner, 1)
+        })
+      );
+      continue;
+    }
+    cells.push({
+      kind: "leaf",
+      ...cell,
+      label: node.label,
+      colorIndex: node.colorIndex,
+      seriesIndex: node.seriesIndex ?? 0,
+      pointIndex: node.pointIndex ?? 0,
+      labelFits: cell.w > 30 && cell.h > 14,
+      labelSize: Math.min(10, cell.h * 0.3)
+    });
+  }
+  return cells;
+}
+
+// chart/sunburst-arcs.ts
+function arcLabelPlacement(cx2, cy, radius, startAngle, endAngle) {
+  const midAngle = (startAngle + endAngle) / 2;
+  let rotation = midAngle * 180 / Math.PI + 90;
+  if (rotation > 90 && rotation < 270) rotation -= 180;
+  return {
+    labelX: cx2 + radius * Math.cos(midAngle),
+    labelY: cy + radius * Math.sin(midAngle),
+    labelRotation: rotation
+  };
+}
+function sunburstArcPath(cx2, cy, innerRadius, outerRadius, startAngle, endAngle) {
+  const sweep = endAngle - startAngle;
+  const largeArc = sweep > Math.PI ? 1 : 0;
+  const x1 = cx2 + outerRadius * Math.cos(startAngle);
+  const y1 = cy + outerRadius * Math.sin(startAngle);
+  const x2 = cx2 + outerRadius * Math.cos(endAngle);
+  const y2 = cy + outerRadius * Math.sin(endAngle);
+  const x3 = cx2 + innerRadius * Math.cos(endAngle);
+  const y3 = cy + innerRadius * Math.sin(endAngle);
+  const x4 = cx2 + innerRadius * Math.cos(startAngle);
+  const y4 = cy + innerRadius * Math.sin(startAngle);
+  return `M ${x1} ${y1} A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${x2} ${y2} L ${x3} ${y3} A ${innerRadius} ${innerRadius} 0 ${largeArc} 0 ${x4} ${y4} Z`;
+}
+function computeSunburstArcs(series, cx2, cy, maxR) {
+  const seriesCount = Math.max(series.length, 1);
+  const ringWidth = maxR / (seriesCount + 0.5);
+  const out = [];
+  series.forEach((s, si) => {
+    const values = s.values;
+    const innerRadius = ringWidth * (si + 0.5);
+    const outerRadius = ringWidth * (si + 1.5);
+    const total = values.reduce((acc, value) => acc + Math.abs(value), 0) || 1;
+    let startAngle = -Math.PI / 2;
+    for (let pointIndex = 0; pointIndex < values.length; pointIndex++) {
+      const endAngle = startAngle + Math.abs(values[pointIndex] ?? 0) / total * Math.PI * 2;
+      out.push({
+        d: sunburstArcPath(cx2, cy, innerRadius, outerRadius, startAngle, endAngle),
+        colorIndex: pointIndex,
+        opacity: Math.max(0.1, 0.9 - si * 0.1),
+        pointIndex,
+        level: si,
+        ...arcLabelPlacement(cx2, cy, (innerRadius + outerRadius) / 2, startAngle, endAngle)
+      });
+      startAngle = endAngle;
+    }
+  });
+  return out;
+}
+function hierarchyKey(levels, level, index) {
+  return levels.slice(level).map((labels) => labels[index] ?? "").join("\0");
+}
+function computeHierarchicalSunburstArcs(categoryLevels2, values, cx2, cy, maxR) {
+  const levels = categoryLevels2.filter((level) => level.length > 0);
+  const leafCount = Math.max(values.length, ...levels.map((level) => level.length), 0);
+  if (levels.length === 0 || leafCount === 0) return [];
+  const rawWeights = Array.from({ length: leafCount }, (_, index) => Math.abs(values[index] ?? 0));
+  const weights = rawWeights.some((value) => value !== 0) ? rawWeights : rawWeights.map(() => 1);
+  const total = weights.reduce((sum, value) => sum + value, 0);
+  const prefix = [0];
+  for (const weight of weights) prefix.push((prefix[prefix.length - 1] ?? 0) + weight);
+  const ringWidth = maxR / (levels.length + 0.5);
+  const rootLabels = levels[levels.length - 1] ?? [];
+  const rootColors = /* @__PURE__ */ new Map();
+  const out = [];
+  for (let level = levels.length - 1; level >= 0; level--) {
+    const ringIndex = levels.length - 1 - level;
+    const innerRadius = ringWidth * (ringIndex + 0.5);
+    const outerRadius = ringWidth * (ringIndex + 1.5);
+    let start = 0;
+    while (start < leafCount) {
+      const key = hierarchyKey(levels, level, start);
+      let end = start + 1;
+      while (end < leafCount && hierarchyKey(levels, level, end) === key) end++;
+      const startAngle = -Math.PI / 2 + (prefix[start] ?? 0) / total * Math.PI * 2;
+      const endAngle = -Math.PI / 2 + (prefix[end] ?? 0) / total * Math.PI * 2;
+      const rootLabel = rootLabels[start] ?? "";
+      if (!rootColors.has(rootLabel)) rootColors.set(rootLabel, rootColors.size);
+      out.push({
+        d: sunburstArcPath(cx2, cy, innerRadius, outerRadius, startAngle, endAngle),
+        colorIndex: rootColors.get(rootLabel) ?? start,
+        opacity: Math.max(0.1, 0.9 - ringIndex * 0.1),
+        level: ringIndex,
+        label: levels[level]?.[start] ?? "",
+        ...level === 0 && end === start + 1 ? { pointIndex: start } : {},
+        ...arcLabelPlacement(cx2, cy, (innerRadius + outerRadius) / 2, startAngle, endAngle)
+      });
+      start = end;
+    }
+  }
+  return out;
+}
+
+// chart/style-palette.ts
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.substring(0, 2), 16),
+    parseInt(h.substring(2, 4), 16),
+    parseInt(h.substring(4, 6), 16)
+  ];
+}
+function rgbToHex(r, g, b) {
+  const clamp = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`;
+}
+function tint(hex, amount) {
+  const [r, g, b] = hexToRgb(hex);
+  return rgbToHex(r + (255 - r) * amount, g + (255 - g) * amount, b + (255 - b) * amount);
+}
+function shade(hex, amount) {
+  const [r, g, b] = hexToRgb(hex);
+  return rgbToHex(r * (1 - amount), g * (1 - amount), b * (1 - amount));
+}
+var OFFICE_ACCENTS = [
+  "#4472C4",
+  "#ED7D31",
+  "#A5A5A5",
+  "#FFC000",
+  "#5B9BD5",
+  "#70AD47"
+];
+var DEFAULT_EXTRAS = ["#FF0000", "#00B0F0"];
+var DEFAULT_CHART_PALETTE = [...OFFICE_ACCENTS, ...DEFAULT_EXTRAS];
+function monochromaticRamp(base) {
+  return [
+    shade(base, 0.5),
+    shade(base, 0.35),
+    shade(base, 0.15),
+    base,
+    tint(base, 0.2),
+    tint(base, 0.4),
+    tint(base, 0.6),
+    tint(base, 0.8)
+  ];
+}
+var GREY = "#7F7F7F";
+function buildPalette(column, accents) {
+  if (column === 0) {
+    return monochromaticRamp(GREY);
+  }
+  if (column === 1) {
+    return [...accents, ...accents.map((accent) => shade(accent, 0.4))];
+  }
+  return monochromaticRamp(accents[column - 2]);
+}
+function usableAccents(accents) {
+  return accents?.length === 6 && accents.every((accent) => /^#[0-9a-f]{6}$/iu.test(accent)) ? accents : OFFICE_ACCENTS;
+}
+var paletteCache = /* @__PURE__ */ new Map();
+function getChartStylePalette(styleId, themeAccents) {
+  const accents = usableAccents(themeAccents);
+  const valid = styleId !== void 0 && styleId >= 1 && styleId <= 48;
+  if (!valid && accents === OFFICE_ACCENTS) {
+    return DEFAULT_CHART_PALETTE;
+  }
+  const column = valid ? (Math.trunc(styleId) - 1) % 8 : -1;
+  const key = `${column}:${accents.join(",")}`;
+  let palette = paletteCache.get(key);
+  if (!palette) {
+    palette = column < 0 ? [...accents, ...DEFAULT_EXTRAS] : buildPalette(column, accents);
+    paletteCache.set(key, palette);
+  }
+  return palette;
+}
+
 // chart/histogram-binning.ts
 function binLabel(lower, upper, closed, format) {
   return closed === "r" ? `(${format(lower)}, ${format(upper)}]` : `[${format(lower)}, ${format(upper)})`;
@@ -382,57 +1045,38 @@ function aggregateByCategory(values, rawCategories) {
   });
 }
 
-// chart/treemap-squarify.ts
-function worstAspectRatio(areas, side) {
-  const sum = areas.reduce((total, area) => total + area, 0);
-  const max = Math.max(...areas);
-  const min = Math.min(...areas);
-  const sideSq = side * side;
-  const sumSq = sum * sum;
-  return Math.max(sideSq * max / sumSq, sumSq / (sideSq * min));
-}
-function squarify(nodes, box) {
-  const sorted = [...nodes].sort((a2, b) => b.weight - a2.weight);
-  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
-  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 rect2 = { ...box };
-  let remaining = items;
-  for (let first2 = remaining[0]; first2 !== void 0; first2 = remaining[0]) {
-    const side = Math.min(rect2.w, rect2.h);
-    let row = [first2];
-    let rowAreas = [first2.area];
-    let worst = worstAspectRatio(rowAreas, side);
-    let cursor = 1;
-    for (let next = remaining[cursor]; next !== void 0; next = remaining[cursor]) {
-      const candidateAreas = [...rowAreas, next.area];
-      const candidateWorst = worstAspectRatio(candidateAreas, side);
-      if (candidateWorst > worst) {
-        break;
-      }
-      row = [...row, next];
-      rowAreas = candidateAreas;
-      worst = candidateWorst;
-      cursor++;
-    }
-    const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
-    const thickness = side > 0 ? rowTotalArea / side : 0;
-    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: rect2.x, y: offset, w: thickness, h: length }]);
-      } else {
-        result.push([item.node, { x: offset, y: rect2.y, w: length, h: thickness }]);
-      }
-      offset += length;
+// chart/waterfall.ts
+function buildWaterfallSteps(values, options) {
+  const subtotalIndices = new Set(
+    options?.subtotalIndices ?? (values.length > 0 ? [values.length - 1] : [])
+  );
+  const steps = [];
+  let runningTotal = 0;
+  for (let sourceIndex = 0; sourceIndex < values.length; sourceIndex++) {
+    const value = values[sourceIndex] ?? 0;
+    const isSubtotal = subtotalIndices.has(sourceIndex);
+    const startValue = isSubtotal ? 0 : runningTotal;
+    const endValue = isSubtotal ? value : runningTotal + value;
+    steps.push({ sourceIndex, value, startValue, endValue, isSubtotal });
+    runningTotal = endValue;
+  }
+  return steps;
+}
+function computeWaterfallRange(steps, plotHeightPx) {
+  let dataMin = Number.POSITIVE_INFINITY;
+  let dataMax = Number.NEGATIVE_INFINITY;
+  for (const step of steps)
+    for (const value of [step.startValue, step.endValue]) {
+      if (value < dataMin) dataMin = value;
+      if (value > dataMax) dataMax = value;
     }
-    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;
+  if (dataMin === Number.POSITIVE_INFINITY) return { min: 0, max: 1, span: 1 };
+  const { min, max, majorUnit } = niceValueAxisBounds(
+    dataMin,
+    dataMax,
+    plotHeightPx !== void 0 ? axisTargetIntervals(plotHeightPx) : void 0
+  );
+  return { min, max, span: Math.max(max - min, Number.EPSILON), majorUnit };
 }
 
 // chart/trendline-equation.ts
@@ -461,16 +1105,147 @@ function formatLogarithmicEquation(slope, intercept) {
 function formatPowerEquation(a2, b) {
   return `y = ${formatTrendlineCoefficient(a2)}x^${formatTrendlineCoefficient(b)}`;
 }
-function formatPolynomialEquation(coeffsAscending) {
-  const order = coeffsAscending.length - 1;
-  let out = "y = ";
-  for (let power = order; power >= 0; power--) {
-    const coeff = coeffsAscending[power] ?? 0;
-    const { sign, abs } = signedTerm(coeff);
-    const variable = power === 0 ? "" : power === 1 ? "x" : `x^${power}`;
-    out += power === order ? `${sign === "-" ? "-" : ""}${abs}${variable}` : ` ${sign} ${abs}${variable}`;
+function formatPolynomialEquation(coeffsAscending) {
+  const order = coeffsAscending.length - 1;
+  let out = "y = ";
+  for (let power = order; power >= 0; power--) {
+    const coeff = coeffsAscending[power] ?? 0;
+    const { sign, abs } = signedTerm(coeff);
+    const variable = power === 0 ? "" : power === 1 ? "x" : `x^${power}`;
+    out += power === order ? `${sign === "-" ? "-" : ""}${abs}${variable}` : ` ${sign} ${abs}${variable}`;
+  }
+  return out;
+}
+
+// chart/trendline-fit.ts
+var noFit = () => ({
+  points: [],
+  equation: "",
+  rSquared: 0,
+  coefficients: []
+});
+function fitModel(options, xVals, yVals) {
+  const xs = [...xVals];
+  const ys = [...yVals];
+  switch (options.kind) {
+    case "linear": {
+      const reg = computeLinearRegression(xs, ys);
+      const fixed = options.intercept;
+      const slope = fixed !== void 0 ? ys.reduce((s, y, i) => s + (y - fixed) * xs[i], 0) / xs.reduce((s, x) => s + x * x, 0) : reg.slope;
+      const b = fixed ?? reg.intercept;
+      return {
+        evaluate: (x) => slope * x + b,
+        equation: formatLinearEquation(slope, b),
+        rSquared: reg.rSquared,
+        coefficients: [b, slope]
+      };
+    }
+    case "exponential": {
+      const logY = ys.filter((y) => y > 0).map((y) => Math.log(y));
+      const posX = xs.filter((_x, i) => ys[i] > 0);
+      if (logY.length < 2) return void 0;
+      const reg = computeLinearRegression(posX, logY);
+      const a2 = Math.exp(reg.intercept);
+      const b = reg.slope;
+      return {
+        evaluate: (x) => a2 * Math.exp(b * x),
+        equation: formatExponentialEquation(a2, b),
+        rSquared: reg.rSquared,
+        coefficients: [a2, b]
+      };
+    }
+    case "logarithmic": {
+      const lnX = xs.filter((x) => x > 0).map((x) => Math.log(x));
+      const posY = ys.filter((_y, i) => xs[i] > 0);
+      if (lnX.length < 2) return void 0;
+      const reg = computeLinearRegression(lnX, posY);
+      return {
+        evaluate: (x) => x > 0 ? reg.slope * Math.log(x) + reg.intercept : 0,
+        equation: formatLogarithmicEquation(reg.slope, reg.intercept),
+        rSquared: reg.rSquared,
+        coefficients: [reg.intercept, reg.slope]
+      };
+    }
+    case "power": {
+      const logX = xs.filter((x, i) => x > 0 && ys[i] > 0).map((x) => Math.log(x));
+      const logY = ys.filter((y, i) => y > 0 && xs[i] > 0).map((y) => Math.log(y));
+      if (logX.length < 2) return void 0;
+      const reg = computeLinearRegression(logX, logY);
+      const a2 = Math.exp(reg.intercept);
+      return {
+        evaluate: (x) => x > 0 ? a2 * x ** reg.slope : 0,
+        equation: formatPowerEquation(a2, reg.slope),
+        rSquared: reg.rSquared,
+        coefficients: [a2, reg.slope]
+      };
+    }
+    case "polynomial": {
+      const order = Math.min(options.order ?? 2, 6);
+      const coeffs = fitPolynomial(xs, ys, order);
+      const evaluate = (x) => coeffs.reduce((s, c2, i) => s + c2 * x ** i, 0);
+      return {
+        evaluate,
+        equation: formatPolynomialEquation(coeffs),
+        rSquared: computeRSquared(xs, ys, evaluate),
+        coefficients: coeffs
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function fitChartTrendline(options, xVals, yVals) {
+  const count = yVals.length;
+  if (count < 2) return noFit();
+  if (options.kind === "movingAvg") {
+    const period = options.period ?? 2;
+    const points2 = [];
+    for (let i = period - 1; i < count; i++) {
+      let sum = 0;
+      for (let j = i - period + 1; j <= i; j++) sum += yVals[j];
+      points2.push({ x: xVals[i], y: sum / period });
+    }
+    return { points: points2, equation: `${period}-period moving average`, rSquared: 0, coefficients: [] };
+  }
+  const model = fitModel(options, xVals, yVals);
+  if (!model) return noFit();
+  const startX = Math.min(...xVals) - (options.backward ?? 0);
+  const endX = Math.max(...xVals) + (options.forward ?? 0);
+  const steps = Math.max(Math.ceil((endX - startX) * 4), 20);
+  const points = [];
+  for (let step = 0; step <= steps; step++) {
+    const x = startX + (endX - startX) * step / steps;
+    const y = model.evaluate(x);
+    if (Number.isFinite(y)) points.push({ x, y });
+  }
+  return {
+    points,
+    equation: model.equation,
+    rSquared: model.rSquared,
+    coefficients: model.coefficients
+  };
+}
+
+// chart/error-bar-amount.ts
+function chartSampleVariance(values) {
+  const count = values.length;
+  if (count === 0) return 0;
+  const mean = values.reduce((sum, value) => sum + value, 0) / count;
+  return values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / Math.max(count - 1, 1);
+}
+function chartErrorBarAmount(options, values, displayIndex, sourceIndex, side) {
+  switch (options.valueType) {
+    case "fixedVal":
+      return options.value ?? 0;
+    case "percentage":
+      return Math.abs(values[displayIndex] ?? 0) * ((options.value ?? 0) / 100);
+    case "stdDev":
+      return Math.sqrt(chartSampleVariance(values)) * (options.value ?? 1);
+    case "stdErr":
+      return Math.sqrt(chartSampleVariance(values) / Math.max(values.length, 1));
+    case "cust":
+      return side === "plus" ? options.customPlus?.[sourceIndex] ?? 0 : options.customMinus?.[sourceIndex] ?? 0;
   }
-  return out;
 }
 
 // chart/radar-geometry.ts
@@ -478,18 +1253,18 @@ function radarAngle(index, catCount) {
   const n2 = Math.max(catCount, 1);
   return Math.PI * 2 * index / n2 - Math.PI / 2;
 }
-function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
+function computeRadarPoints(values, maxVal, radius, cx2, cy, catCount) {
   const denom = maxVal > 0 ? maxVal : 1;
   return values.slice(0, Math.max(catCount, 1)).map((val, i) => {
     const angle = radarAngle(i, catCount), r = Math.abs(val) / denom * radius;
-    return { x: cx + r * Math.cos(angle), y: cy + r * Math.sin(angle) };
+    return { x: cx2 + r * Math.cos(angle), y: cy + r * Math.sin(angle) };
   });
 }
-function radarRingPoints(cx, cy, rr, catCount) {
+function radarRingPoints(cx2, cy, rr, catCount) {
   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)}`;
+    return `${(cx2 + rr * Math.cos(angle)).toFixed(2)},${(cy + rr * Math.sin(angle)).toFixed(2)}`;
   }).join(" ");
 }
 
@@ -623,13 +1398,13 @@ function hexToRgbChannels(color) {
     b: Number.parseInt(normalized.slice(4, 6), 16)
   };
 }
-function percentDivisorFor(text2) {
-  return text2.endsWith("%") ? 100 : 1e5;
+function percentDivisorFor(text3) {
+  return text3.endsWith("%") ? 100 : 1e5;
 }
 function parseOoxmlPercent(value) {
-  const text2 = String(value ?? "").trim();
-  const divisor = percentDivisorFor(text2);
-  const magnitude = Number.parseFloat(divisor === 100 ? text2.slice(0, -1) : text2);
+  const text3 = String(value ?? "").trim();
+  const divisor = percentDivisorFor(text3);
+  const magnitude = Number.parseFloat(divisor === 100 ? text3.slice(0, -1) : text3);
   if (!Number.isFinite(magnitude)) {
     return void 0;
   }
@@ -1030,16 +1805,42 @@ var NS = {
   a: "http://schemas.openxmlformats.org/drawingml/2006/main",
   /** DrawingML chart. */
   c: "http://schemas.openxmlformats.org/drawingml/2006/chart",
+  /** Office 2016 extended charts (waterfall, histogram, funnel...; `cx:chartSpace`). */
+  cx: "http://schemas.microsoft.com/office/drawing/2014/chartex",
   /** Office 2010 chart extensions, including built-in modern chart styles. */
   c14: "http://schemas.microsoft.com/office/drawing/2007/8/2/chart",
   /** Relationships (`r:id`, `r:embed`). */
   r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
   /** Markup compatibility (`mc:AlternateContent`). */
   mc: "http://schemas.openxmlformats.org/markup-compatibility/2006"};
+var DEFAULT_XML_LIMITS = {
+  maxDepth: 512,
+  maxNodes: 5e6
+};
+var MARKUP_RE = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<(\/?)([^\s\/>]+)(?:\s+[^\s=\/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*\s*(\/?)>/g;
+function checkXmlLimits(xml, label, limits = {}) {
+  const maxDepth = limits.maxDepth ?? DEFAULT_XML_LIMITS.maxDepth;
+  const maxNodes = limits.maxNodes ?? DEFAULT_XML_LIMITS.maxNodes;
+  let depth = 0;
+  let nodes = 0;
+  for (const match of xml.matchAll(MARKUP_RE)) {
+    const [, closing, name, selfClosing] = match;
+    if (name === void 0) continue;
+    if (closing) {
+      depth--;
+      continue;
+    }
+    nodes++;
+    if (nodes > maxNodes) throw new Error(`${label} XML exceeds the limit of ${maxNodes} elements`);
+    if (!selfClosing && ++depth > maxDepth)
+      throw new Error(`${label} XML exceeds the nesting depth limit of ${maxDepth}`);
+  }
+}
 function parseXml(xml, options = {}) {
   const label = options.label ?? "OOXML";
   if (/<!DOCTYPE|<!ENTITY/i.test(xml))
     throw new Error(`${label} XML with DTD or entity declarations is not supported`);
+  checkXmlLimits(xml, label, options.limits);
   let parseError = "";
   let parsed;
   try {
@@ -1259,17 +2060,17 @@ function resolveDrawingColor(color, theme, options) {
   }
   if (has("inv")) [r, g, b] = [255 - r, 255 - g, 255 - b];
   if (has("gray")) r = g = b = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
-  const shade = parseDrawingPercent(find("shade"));
-  if (shade !== void 0) {
-    r = linearToSrgb255(srgb255ToLinear(r) * shade);
-    g = linearToSrgb255(srgb255ToLinear(g) * shade);
-    b = linearToSrgb255(srgb255ToLinear(b) * shade);
-  }
-  const tint = parseDrawingPercent(find("tint"));
-  if (tint !== void 0) {
-    r = linearToSrgb255(1 - (1 - srgb255ToLinear(r)) * tint);
-    g = linearToSrgb255(1 - (1 - srgb255ToLinear(g)) * tint);
-    b = linearToSrgb255(1 - (1 - srgb255ToLinear(b)) * tint);
+  const shade2 = parseDrawingPercent(find("shade"));
+  if (shade2 !== void 0) {
+    r = linearToSrgb255(srgb255ToLinear(r) * shade2);
+    g = linearToSrgb255(srgb255ToLinear(g) * shade2);
+    b = linearToSrgb255(srgb255ToLinear(b) * shade2);
+  }
+  const tint2 = parseDrawingPercent(find("tint"));
+  if (tint2 !== void 0) {
+    r = linearToSrgb255(1 - (1 - srgb255ToLinear(r)) * tint2);
+    g = linearToSrgb255(1 - (1 - srgb255ToLinear(g)) * tint2);
+    b = linearToSrgb255(1 - (1 - srgb255ToLinear(b)) * tint2);
   }
   if (["hue", "hueMod", "hueOff", "sat", "satMod", "satOff", "lum", "lumMod", "lumOff"].some(has)) {
     const hsl = rgbToHsl(r, g, b);
@@ -1621,28 +2422,28 @@ function parseDrawingLine(ln) {
 }
 
 // chart/read-appearance.ts
-function readChartAppearance(text2, properties2) {
+function readChartAppearance(text3, properties2) {
   const out = {};
-  const size = Number(text2?.getAttribute("sz") ?? NaN);
+  const size = Number(text3?.getAttribute("sz") ?? NaN);
   if (Number.isFinite(size) && size > 0) out.fontSize = size / 100;
   for (const [attribute2, key] of [
     ["b", "bold"],
     ["i", "italic"]
   ]) {
-    const value = text2?.getAttribute(attribute2);
+    const value = text3?.getAttribute(attribute2);
     if (value !== null && value !== void 0) out[key] = value === "1" || value === "true";
   }
-  const typeface2 = first(text2, "latin", NS.a)?.getAttribute("typeface");
-  const underline = text2?.getAttribute("u");
+  const typeface2 = first(text3, "latin", NS.a)?.getAttribute("typeface");
+  const underline = text3?.getAttribute("u");
   if (underline) out.underline = underline !== "none";
   if (typeface2) out.typeface = typeface2;
-  const color = parseDrawingColorIn(first(text2, "solidFill", NS.a));
+  const color = parseDrawingColorIn(first(text3, "solidFill", NS.a));
   if (color) out.textColor = color;
   const fill = parseDrawingFill(properties2);
   const line2 = parseDrawingLine(first(properties2, "ln", NS.a));
   if (fill) out.fill = fill;
   if (line2) out.line = line2;
-  const effects = first(text2, "effectLst", NS.a);
+  const effects = first(text3, "effectLst", NS.a);
   if (effects) out.textEffectsXml = buildXml(effects);
   return out;
 }
@@ -2158,7 +2959,7 @@ function rectGradientFocus(id) {
   if (!direction) throw new RangeError(`Unknown rectangular gradient direction ${id}`);
   return { l: direction.x, t: direction.y, r: 1 - direction.x, b: 1 - direction.y };
 }
-function hexToRgb(color) {
+function hexToRgb2(color) {
   const parsed = hexToRgbChannels(color);
   if (parsed) return parsed;
   const hex = color.replace("#", "");
@@ -2172,8 +2973,8 @@ function toHexChannel(value) {
   return toHex(value).toLowerCase();
 }
 function lerpStops(a2, b, t) {
-  const ca = hexToRgb(a2.color);
-  const cb = hexToRgb(b.color);
+  const ca = hexToRgb2(a2.color);
+  const cb = hexToRgb2(b.color);
   const oa = a2.opacity ?? 1;
   const ob = b.opacity ?? 1;
   return {
@@ -2252,8 +3053,8 @@ function buildRectPathGradientSvg(stops, focalPoint, fillToRect, options) {
       );
     }
   }
-  const paint = masked ? `<defs><mask id="alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="100" height="100" mask-type="luminance" color-interpolation="sRGB">${alphaRects.join("")}</mask></defs><g mask="url(#alpha)">${rects.join("")}</g>` : rects.join("");
-  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="none">${paint}</svg>`;
+  const paint2 = masked ? `<defs><mask id="alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="100" height="100" mask-type="luminance" color-interpolation="sRGB">${alphaRects.join("")}</mask></defs><g mask="url(#alpha)">${rects.join("")}</g>` : rects.join("");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="none">${paint2}</svg>`;
 }
 
 // chart/gradient-definition.ts
@@ -2305,16 +3106,16 @@ function buildChartGradientDef(id, fill, bounds) {
     };
   }
   if (fill.type === "radial") {
-    const cx = fill.focalPoint?.x ?? 0.5;
+    const cx2 = fill.focalPoint?.x ?? 0.5;
     const cy = fill.focalPoint?.y ?? 0.5;
     const aspect = fill.path === "circle" && bounds && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width > 0 && bounds.height > 0 ? bounds.height / bounds.width : 1;
     return {
       kind: "radialGradient",
       id,
-      cx,
+      cx: cx2,
       cy,
       r: Math.max(
-        ...[0, 1].flatMap((x) => [0, 1].map((y) => Math.hypot(x - cx, (y - cy) * aspect)))
+        ...[0, 1].flatMap((x) => [0, 1].map((y) => Math.hypot(x - cx2, (y - cy) * aspect)))
       ),
       ...aspect === 1 ? {} : { gradientTransform: `matrix(1 0 0 ${1 / aspect} 0 ${cy * (1 - 1 / aspect)})` },
       stops
@@ -2407,14 +3208,43 @@ function writeChartLayoutFormatting(root, formatting) {
   return changed;
 }
 
+// chart/model-analysis.ts
+var KIND_OF_TYPE = {
+  linear: "linear",
+  exp: "exponential",
+  log: "logarithmic",
+  poly: "polynomial",
+  power: "power",
+  movingAvg: "movingAvg"
+};
+var TYPE_OF_KIND = {
+  linear: "linear",
+  exponential: "exp",
+  logarithmic: "log",
+  polynomial: "poly",
+  power: "power",
+  movingAvg: "movingAvg"
+};
+var chartTrendlineKind = (type) => type !== void 0 && Object.hasOwn(KIND_OF_TYPE, type) ? KIND_OF_TYPE[type] : void 0;
+var chartTrendlineType = (kind) => TYPE_OF_KIND[kind];
+var CHART_ERROR_BAR_DIRECTIONS = ["x", "y"];
+var CHART_ERROR_BAR_TYPES = ["both", "minus", "plus"];
+var CHART_ERROR_VALUE_TYPES = [
+  "cust",
+  "fixedVal",
+  "percentage",
+  "stdDev",
+  "stdErr"
+];
+
 // 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 text3 = point.value;
+    out[point.index ?? out.length] = numeric && text3.trim() !== "" && Number.isFinite(Number(text3)) ? Number(text3) : text3;
   }
   const size = Math.max(cache.pointCount ?? 0, out.length);
   for (let index = 0; index < size; index++) if (out[index] === void 0) out[index] = "";
@@ -2472,6 +3302,14 @@ function cNumber(context, parent, local) {
   malformed(context, element, raw2);
   return void 0;
 }
+function cEnum(context, parent, local, allowed) {
+  const element = cChild(parent, local);
+  const raw2 = attribute(element, "val");
+  if (!element || raw2 === void 0) return void 0;
+  if (allowed.includes(raw2)) return raw2;
+  malformed(context, element, raw2);
+  return void 0;
+}
 function reportUnmodelled(context, element, handled) {
   for (const child2 of elements(element)) {
     if (handled.has(child2.localName)) continue;
@@ -2592,20 +3430,20 @@ function parseDataSource(element) {
 }
 function parseChartText(context, tx, allowValue) {
   if (!tx) return void 0;
-  const text2 = {};
+  const text3 = {};
   const rich = chartTextBody(cChild(tx, "rich"));
-  if (rich) text2.rich = rich;
+  if (rich) text3.rich = rich;
   if (cChild(tx, "strRef")) {
     const reference2 = parseDataSource(tx);
-    if (reference2) text2.reference = reference2;
+    if (reference2) text3.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;
+  if (value !== void 0 && value !== null) text3.value = value;
+  const cached = chartCacheValues(text3.reference?.cache)[0];
+  const flat = text3.value ?? (rich ? rich.text : cached === void 0 ? void 0 : String(cached));
+  if (flat !== void 0) text3.text = flat;
   reportUnmodelled(context, tx, new Set(allowValue ? ["strRef", "v"] : ["rich", "strRef"]));
-  return text2;
+  return text3;
 }
 var TITLE = /* @__PURE__ */ new Set(["tx", "layout", "overlay", "spPr", "txPr", "extLst"]);
 function parseTitle(context, element) {
@@ -2772,6 +3610,105 @@ function readDisplayNaAsBlank(chartExtLst) {
   return void 0;
 }
 
+// chart/parse-analysis.ts
+var TRENDLINE_TYPES = [
+  "exp",
+  "linear",
+  "log",
+  "movingAvg",
+  "poly",
+  "power"
+];
+var LABEL2 = /* @__PURE__ */ new Set(["layout", "tx", "numFmt", "spPr", "txPr", "extLst"]);
+function parseTrendlineLabel(context, element) {
+  if (!element) return void 0;
+  reportUnmodelled(context, element, LABEL2);
+  return assignDefined(
+    {},
+    {
+      layout: manualLayout(element),
+      tx: parseChartText(context, cChild(element, "tx"), false),
+      numberFormat: numberFormat(element),
+      spPr: shapeProperties(element),
+      txPr: textProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+var TRENDLINE = /* @__PURE__ */ new Set([
+  "name",
+  "spPr",
+  "trendlineType",
+  "order",
+  "period",
+  "forward",
+  "backward",
+  "intercept",
+  "dispRSqr",
+  "dispEq",
+  "trendlineLbl",
+  "extLst"
+]);
+function parseTrendline(context, element) {
+  reportUnmodelled(context, element, TRENDLINE);
+  const name = cChild(element, "name");
+  return assignDefined(
+    {},
+    {
+      name: name ? name.textContent ?? "" : void 0,
+      spPr: shapeProperties(element),
+      trendlineType: cEnum(context, element, "trendlineType", TRENDLINE_TYPES),
+      order: cNumber(context, element, "order"),
+      period: cNumber(context, element, "period"),
+      forward: cNumber(context, element, "forward"),
+      backward: cNumber(context, element, "backward"),
+      intercept: cNumber(context, element, "intercept"),
+      displayRSquared: cBool(context, element, "dispRSqr"),
+      displayEquation: cBool(context, element, "dispEq"),
+      label: parseTrendlineLabel(context, cChild(element, "trendlineLbl")),
+      extLst: extensionList(element)
+    }
+  );
+}
+var ERROR_BARS = /* @__PURE__ */ new Set([
+  "errDir",
+  "errBarType",
+  "errValType",
+  "noEndCap",
+  "plus",
+  "minus",
+  "val",
+  "spPr",
+  "extLst"
+]);
+function parseErrorBars(context, element) {
+  reportUnmodelled(context, element, ERROR_BARS);
+  return assignDefined(
+    {},
+    {
+      direction: cEnum(context, element, "errDir", CHART_ERROR_BAR_DIRECTIONS),
+      barType: cEnum(context, element, "errBarType", CHART_ERROR_BAR_TYPES),
+      valueType: cEnum(context, element, "errValType", CHART_ERROR_VALUE_TYPES),
+      noEndCap: cBool(context, element, "noEndCap"),
+      plus: parseDataSource(cChild(element, "plus")),
+      minus: parseDataSource(cChild(element, "minus")),
+      value: cNumber(context, element, "val"),
+      spPr: shapeProperties(element),
+      extLst: extensionList(element)
+    }
+  );
+}
+function parseSeriesAnalysis(context, series) {
+  const trendlines2 = children(series, "trendline", NS.c).map(
+    (node) => parseTrendline(context, node)
+  );
+  const errorBars = children(series, "errBars", NS.c).map((node) => parseErrorBars(context, node));
+  return {
+    ...trendlines2.length ? { trendlines: trendlines2 } : {},
+    ...errorBars.length ? { errorBars } : {}
+  };
+}
+
 // chart/parse-series.ts
 var MARKER = /* @__PURE__ */ new Set(["symbol", "size", "spPr", "extLst"]);
 function parseMarker(context, element) {
@@ -2820,6 +3757,8 @@ var SERIES = /* @__PURE__ */ new Set([
   "invertIfNegative",
   "dPt",
   "dLbls",
+  "trendline",
+  "errBars",
   "cat",
   "val",
   "xVal",
@@ -2835,7 +3774,10 @@ var SERIES = /* @__PURE__ */ new Set([
 function parseSeries(context, element) {
   reportUnmodelled(context, element, SERIES);
   return assignDefined(
-    { dataPoints: children(element, "dPt", NS.c).map((point) => parseDataPoint(context, point)) },
+    {
+      dataPoints: children(element, "dPt", NS.c).map((point) => parseDataPoint(context, point)),
+      ...parseSeriesAnalysis(context, element)
+    },
     {
       index: cNumber(context, element, "idx"),
       order: cNumber(context, element, "order"),
@@ -2918,7 +3860,7 @@ function parseGroup(context, element) {
   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 present2 = (local) => cChild(element, local) ? true : void 0;
   const linesShape = (local) => chartLines(element, local)?.spPr;
   const bars2 = cChild(element, "upDownBars");
   return assignDefined(
@@ -2944,10 +3886,10 @@ function parseGroup(context, element) {
       shape: cVal(element, "shape"),
       marker: flag("marker"),
       smooth: flag("smooth"),
-      dropLines: present("dropLines"),
-      hiLowLines: present("hiLowLines"),
-      upDownBars: present("upDownBars"),
-      seriesLines: present("serLines"),
+      dropLines: present2("dropLines"),
+      hiLowLines: present2("hiLowLines"),
+      upDownBars: present2("upDownBars"),
+      seriesLines: present2("serLines"),
       dropLinesSpPr: linesShape("dropLines"),
       hiLowLinesSpPr: linesShape("hiLowLines"),
       seriesLinesSpPr: linesShape("serLines"),
@@ -3279,9 +4221,9 @@ var escapeText = (value) => value.replace(INVALID_XML, "").replace(/&/g, "&amp;"
 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 text3 = String(value);
+  const match = /^(-?)(\d+)(?:\.(\d+))?e([+-]\d+)$/i.exec(text3);
+  if (!match) return text3;
   const [, sign = "", whole = "", fraction = "", exponent = "0"] = match;
   const digits = whole + fraction;
   const point = whole.length + Number(exponent);
@@ -3290,8 +4232,8 @@ function chartNumber(value) {
 }
 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}"/>`;
+  const text3 = typeof value === "boolean" ? value ? "1" : "0" : typeof value === "number" ? chartNumber(value) : escapeAttribute(value);
+  return `<c:${local} val="${text3}"/>`;
 }
 var elementXml = (local, content, attributes = "") => content ? `<c:${local}${attributes}>${content}</c:${local}>` : `<c:${local}${attributes}/>`;
 var raw = (context, xml) => xml ? stripDeclarations(xml, context.bindings) : "";
@@ -3323,11 +4265,11 @@ function spacing(local, value) {
   return `<a:${local}>${inner}</a:${local}>`;
 }
 function run(value) {
-  const { text: text2, ...properties2 } = value;
+  const { text: text3, ...properties2 } = value;
   const hasProperties = Object.keys(properties2).length > 0;
-  if (text2 === "\n")
+  if (text3 === "\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>`;
+  return `<a:r>${hasProperties ? runProperties("rPr", properties2) : ""}<a:t>${escapeText(text3)}</a:t></a:r>`;
 }
 function paragraph(value) {
   const align = value.align ? ` algn="${escapeAttribute(value.align)}"` : "";
@@ -3438,8 +4380,8 @@ function layoutXml(context, value) {
   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}"/>`;
+    const text3 = typeof value2 === "number" ? chartNumber(value2) : value2;
+    return `<c:${local} val="${text3}"/>`;
   }).join("");
   return elementXml("layout", manual ? `<c:manualLayout>${manual}</c:manualLayout>` : "");
 }
@@ -3485,16 +4427,16 @@ function dataSourceInner(source) {
   }
 }
 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));
+function chartTextXml(context, text3, seriesName2) {
+  if (!text3) return "";
+  if (text3.reference) return elementXml("tx", dataSourceInner(text3.reference));
   if (seriesName2) {
-    const value = text2.value ?? text2.text;
+    const value = text3.value ?? text3.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 }] }));
+  if (text3.rich) return elementXml("tx", textBodyXml(context, text3.rich, "rich"));
+  if (text3.text === void 0) return "<c:tx/>";
+  const paragraphs = text3.text.split("\n").map((line2) => ({ runs: [{ text: line2 }] }));
   return `<c:tx><c:rich>${writeTextBody({ paragraphs })}</c:rich></c:tx>`;
 }
 function titleXml(context, title) {
@@ -3557,7 +4499,7 @@ var AXIS_ELEMENTS2 = {
   date: "dateAx",
   ser: "serAx"
 };
-var gridlinesXml = (context, local, present, shape) => present ? elementXml(local, shapePropertiesXml(context, shape)) : "";
+var gridlinesXml = (context, local, present2, shape) => present2 ? elementXml(local, shapePropertiesXml(context, shape)) : "";
 function axisXml(context, axis) {
   const { scaling } = axis;
   return elementXml(
@@ -3569,6 +4511,28 @@ function axisXml(context, axis) {
   );
 }
 
+// chart/write-analysis.ts
+function trendlineLabelXml(context, label) {
+  if (!label) return "";
+  return elementXml(
+    "trendlineLbl",
+    layoutXml(context, label.layout) + chartTextXml(context, label.tx, false) + numberFormatXml(label.numberFormat) + shapePropertiesXml(context, label.spPr) + textBodyXml(context, label.txPr) + raw(context, label.extLst)
+  );
+}
+function trendlineXml(context, trendline) {
+  return elementXml(
+    "trendline",
+    (trendline.name === void 0 ? "" : `<c:name>${escapeText(trendline.name)}</c:name>`) + shapePropertiesXml(context, trendline.spPr) + valXml("trendlineType", trendline.trendlineType ?? "linear") + valXml("order", trendline.order) + valXml("period", trendline.period) + valXml("forward", trendline.forward) + valXml("backward", trendline.backward) + valXml("intercept", trendline.intercept) + valXml("dispRSqr", trendline.displayRSquared) + valXml("dispEq", trendline.displayEquation) + trendlineLabelXml(context, trendline.label) + raw(context, trendline.extLst)
+  );
+}
+function errorBarsXml(context, bars2) {
+  return elementXml(
+    "errBars",
+    valXml("errDir", bars2.direction) + valXml("errBarType", bars2.barType ?? "both") + valXml("errValType", bars2.valueType ?? "fixedVal") + valXml("noEndCap", bars2.noEndCap) + dataSourceXml("plus", bars2.plus) + dataSourceXml("minus", bars2.minus) + valXml("val", bars2.value) + shapePropertiesXml(context, bars2.spPr) + raw(context, bars2.extLst)
+  );
+}
+var seriesAnalysisXml = (context, series) => (series.trendlines ?? []).map((trendline) => trendlineXml(context, trendline)).join("") + (series.errorBars ?? []).map((bars2) => errorBarsXml(context, bars2)).join("");
+
 // chart/write-series.ts
 function markerXml(context, marker) {
   if (!marker) return "";
@@ -3586,38 +4550,38 @@ function dataPointXml(context, point) {
 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)
+    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) + seriesAnalysisXml(context, series) + 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 linesXml = (context, local, present2, shape) => present2 ? 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 "";
+function upDownBarsXml(context, group2) {
+  if (!group2.upDownBars) return "";
   return elementXml(
     "upDownBars",
-    valXml("gapWidth", group.upDownBarsGapWidth) + barsXml(context, "upBars", group.upBars) + barsXml(context, "downBars", group.downBars)
+    valXml("gapWidth", group2.upDownBarsGapWidth) + barsXml(context, "upBars", group2.upBars) + barsXml(context, "downBars", group2.downBars)
   );
 }
-function groupElement(group) {
-  if (Object.hasOwn(CHART_GROUP_ELEMENTS, group.element)) return group.element;
+function groupElement(group2) {
+  if (Object.hasOwn(CHART_GROUP_ELEMENTS, group2.element)) return group2.element;
   const match = Object.entries(CHART_GROUP_ELEMENTS).find(
-    ([, value]) => value.kind === group.kind && value.is3D === group.is3D
+    ([, value]) => value.kind === group2.kind && value.is3D === group2.is3D
   );
-  if (!match) throw new Error(`No chart group element for ${group.kind}`);
+  if (!match) throw new Error(`No chart group element for ${group2.kind}`);
   return match[0];
 }
-function groupXml(context, group) {
+function groupXml(context, group2) {
   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)
+    groupElement(group2),
+    valXml("ofPieType", group2.ofPieType) + valXml("scatterStyle", group2.scatterStyle) + valXml("radarStyle", group2.radarStyle) + valXml("wireframe", group2.wireframe) + valXml("barDir", group2.barDirection) + valXml("grouping", group2.grouping) + valXml("varyColors", group2.varyColors) + group2.series.map((series, position) => seriesXml(context, series, position)).join("") + dataLabelsXml(context, group2.dataLabels) + valXml("gapWidth", group2.gapWidth) + valXml("overlap", group2.overlap) + linesXml(context, "dropLines", group2.dropLines, group2.dropLinesSpPr) + linesXml(context, "hiLowLines", group2.hiLowLines, group2.hiLowLinesSpPr) + upDownBarsXml(context, group2) + valXml("marker", group2.marker) + valXml("smooth", group2.smooth) + valXml("gapDepth", group2.gapDepth) + valXml("shape", group2.shape) + valXml("firstSliceAng", group2.firstSliceAngle) + valXml("holeSize", group2.holeSize) + valXml("bubble3D", group2.bubble3D) + valXml("bubbleScale", group2.bubbleScale) + valXml("showNegBubbles", group2.showNegativeBubbles) + valXml("sizeRepresents", group2.sizeRepresents) + linesXml(context, "serLines", group2.seriesLines, group2.seriesLinesSpPr) + group2.axisIds.map((id) => valXml("axId", id)).join("") + raw(context, group2.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)
+    layoutXml(context, plotArea.layout) + plotArea.groups.map((group2) => groupXml(context, group2)).join("") + plotArea.axes.map((axis) => axisXml(context, axis)).join("") + dataTableXml(context, plotArea.dataTable) + shapePropertiesXml(context, plotArea.spPr) + raw(context, plotArea.extLst)
   );
 }
 
@@ -3673,6 +4637,46 @@ function writeChartSpace(space, options = {}) {
   return `${DECLARATION2}${breakAfter}<c:chartSpace${declarations}>${body}</c:chartSpace>`;
 }
 
+// chart/render/summary-analysis.ts
+function summaryTrendline(source) {
+  const kind = chartTrendlineKind(source.trendlineType);
+  if (!kind) return void 0;
+  const out = { kind };
+  if (source.order !== void 0) out.order = source.order;
+  if (source.period !== void 0) out.period = source.period;
+  if (source.forward !== void 0) out.forward = source.forward;
+  if (source.backward !== void 0) out.backward = source.backward;
+  if (source.intercept !== void 0) out.intercept = source.intercept;
+  if (source.name !== void 0) out.name = source.name;
+  if (source.spPr?.line) out.line = source.spPr.line;
+  return out;
+}
+var amounts = (source) => chartSourceValues(source).map((value) => typeof value === "number" ? value : 0);
+function summaryErrorBars(source) {
+  if (!source.valueType) return void 0;
+  const out = {
+    direction: source.direction ?? "y",
+    barType: source.barType ?? "both",
+    valueType: source.valueType
+  };
+  if (source.value !== void 0) out.value = source.value;
+  if (source.valueType === "cust") {
+    out.customPlus = amounts(source.plus);
+    out.customMinus = amounts(source.minus);
+  }
+  if (source.noEndCap !== void 0) out.noEndCap = source.noEndCap;
+  if (source.spPr?.line) out.line = source.spPr.line;
+  return out;
+}
+function summaryAnalysis(series) {
+  const trendlines2 = (series.trendlines ?? []).map(summaryTrendline).filter((entry3) => entry3 !== void 0);
+  const errorBars = (series.errorBars ?? []).map(summaryErrorBars).filter((entry3) => entry3 !== void 0);
+  return {
+    ...trendlines2.length ? { trendlines: trendlines2 } : {},
+    ...errorBars.length ? { errorBars } : {}
+  };
+}
+
 // 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";
@@ -3693,12 +4697,15 @@ var GROUPINGS = /* @__PURE__ */ new Set(["clustered", "stacked", "percentStacked
 function chartSummarySeries(source, chartType) {
   const categories = source.categories ?? source.xValues;
   const values = source.values ?? source.yValues;
+  const numeric = (v) => typeof v === "number" ? v : v === "" ? null : Number.isFinite(Number(v)) ? Number(v) : null;
   const out = {
     categories: chartSourceValues(categories),
-    values: chartSourceValues(values).map(
-      (v) => typeof v === "number" ? v : v === "" ? null : Number.isFinite(Number(v)) ? Number(v) : null
-    )
+    values: chartSourceValues(values).map(numeric)
   };
+  if (source.bubbleSizes) {
+    out.bubbleSizes = chartSourceValues(source.bubbleSizes).map(numeric);
+    if (source.bubbleSizes.formula) out.bubbleSizesRef = source.bubbleSizes.formula;
+  }
   if (source.tx?.text !== void 0) out.name = source.tx.text;
   const nameRef = source.tx?.reference?.formula;
   if (nameRef) out.nameRef = nameRef;
@@ -3723,50 +4730,446 @@ function chartSummarySeries(source, chartType) {
   }
   if (Object.keys(points).length) out.pointColors = points;
   if (Object.keys(pointFills).length) out.pointFills = pointFills;
+  Object.assign(out, summaryAnalysis(source));
+  return out;
+}
+function valueAxisId(chartSpace, axisIds) {
+  return axisIds.find(
+    (id) => chartSpace.plotArea.axes.some((a2) => a2.id === id && a2.kind === "val")
+  );
+}
+function stockStyle(group2) {
+  return {
+    ...group2.hiLowLinesSpPr ? { hiLowLines: group2.hiLowLinesSpPr } : {},
+    ...group2.upBars?.spPr ? { upBars: group2.upBars.spPr } : {},
+    ...group2.downBars?.spPr ? { downBars: group2.downBars.spPr } : {},
+    ...group2.upDownBarsGapWidth === void 0 ? {} : { gapWidth: group2.upDownBarsGapWidth }
+  };
+}
+function extraGroups(chartSpace, firstType) {
+  const [first2, ...rest] = chartSpace.plotArea.groups;
+  if (!first2 || !["column", "line", "area"].includes(firstType)) return [];
+  const primary = valueAxisId(chartSpace, first2.axisIds);
+  const out = [];
+  for (const group2 of rest) {
+    const stockOverColumns = group2.kind === "stock" && firstType === "column";
+    if (group2.is3D || !(["bar", "line", "area"].includes(group2.kind) || stockOverColumns)) continue;
+    const type = group2.kind === "bar" ? "column" : group2.kind;
+    const entry3 = {
+      chartType: type,
+      series: group2.series.map((source) => chartSummarySeries(source, type)),
+      secondary: valueAxisId(chartSpace, group2.axisIds) !== primary
+    };
+    if (group2.grouping && GROUPINGS.has(group2.grouping))
+      entry3.grouping = group2.grouping;
+    if (type === "stock") entry3.stock = stockStyle(group2);
+    if (type === "column") {
+      if (group2.gapWidth !== void 0) entry3.barGapWidth = group2.gapWidth;
+      if (group2.overlap !== void 0) entry3.barOverlap = group2.overlap;
+    }
+    if (entry3.series.length) out.push(entry3);
+  }
+  return out;
+}
+function chartSummaryFromSpace(chartSpace, extras = {}) {
+  const group2 = chartSpace.plotArea.groups[0];
+  let chartType = group2 ? GROUP_TYPES[group2.kind] : "column";
+  if (chartType === "bar" && group2?.barDirection !== "bar") chartType = "column";
+  const series = (group2?.series ?? []).map((source) => chartSummarySeries(source, chartType));
+  const summary = {
+    chartType,
+    series,
+    showLegend: chartSpace.legend !== void 0
+  };
+  const combined = extraGroups(chartSpace, chartType);
+  if (combined.length) summary.extraGroups = combined;
+  if (chartType === "stock" && group2) summary.stock = stockStyle(group2);
+  if (chartType === "bubble" && group2) {
+    const sizeRepresents = group2.sizeRepresents === "w" ? "w" : "area";
+    summary.bubble = {
+      sizeRepresents,
+      ...group2.bubbleScale === void 0 ? {} : { bubbleScale: group2.bubbleScale },
+      showNegativeBubbles: group2.showNegativeBubbles === true
+    };
+  }
+  const grouping = group2?.grouping;
+  if (grouping && GROUPINGS.has(grouping))
+    summary.grouping = grouping;
+  if (chartType === "bar" || chartType === "column") {
+    for (const [value, field, fallback, min, max] of [
+      [group2?.gapWidth, "barGapWidth", 150, 0, 500],
+      [group2?.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;
+}
+
+// chart/render/summary-from-chartex.ts
+var cx = (parent, local) => first(parent, local, NS.cx);
+var text = (element) => (element?.textContent ?? "").trim();
+function scalar(parent, local) {
+  const element = cx(parent, local);
+  if (!element) return void 0;
+  return element.hasAttribute("val") ? element.getAttribute("val") ?? "" : text(element);
+}
+function seriesData(root, series) {
+  const inline = cx(series, "data");
+  if (inline) return inline;
+  const id = cx(series, "dataId")?.getAttribute("val");
+  const shared = children(cx(root, "chartData") ?? root, "data", NS.cx);
+  return id === null || id === void 0 ? shared[0] : shared.find((d) => d.getAttribute("id") === id);
+}
+function dimension(data, kind, type) {
+  const all = data ? children(data, kind, NS.cx) : [];
+  const element = all.find((d) => (d.getAttribute("type") ?? "") === type) ?? void 0;
+  if (!element) return void 0;
+  const out = { points: [] };
+  const formula = text(cx(element, "f"));
+  if (formula) out.formula = formula;
+  const level = cx(element, "lvl");
+  const count = Number(level?.getAttribute("ptCount") ?? 0);
+  for (const point of level ? children(level, "pt", NS.cx) : []) {
+    const index = Number(point.getAttribute("idx") ?? out.points.length);
+    if (Number.isInteger(index) && index >= 0) out.points[index] = text(point);
+  }
+  for (let i = 0; i < Math.max(count, out.points.length); i++) out.points[i] ??= "";
+  return out;
+}
+function categoryLevels(data) {
+  const element = data ? children(data, "strDim", NS.cx).find((d) => (d.getAttribute("type") ?? "") === "cat") : void 0;
+  return (element ? children(element, "lvl", NS.cx) : []).map((level) => {
+    const points = [];
+    const count = Number(level.getAttribute("ptCount") ?? 0);
+    for (const point of children(level, "pt", NS.cx)) {
+      const index = Number(point.getAttribute("idx") ?? points.length);
+      if (Number.isInteger(index) && index >= 0) points[index] = text(point);
+    }
+    for (let i = 0; i < Math.max(count, points.length); i++) points[i] ??= "";
+    return points;
+  });
+}
+function titleOf(chart) {
+  const tx = cx(cx(chart, "title"), "tx");
+  const data = text(cx(cx(tx, "txData"), "v"));
+  if (data) return data;
+  const rich = cx(tx, "rich");
+  if (!rich) return void 0;
+  const runs = Array.from(rich.getElementsByTagNameNS(NS.a, "t")).map((t) => t.textContent ?? "");
+  return runs.join("") || void 0;
+}
+function seriesFill(series) {
+  const fill = parseDrawingFill(cx(series, "spPr"));
+  const color = fill?.kind === "solid" ? fill.color : void 0;
+  return color ? { drawingColor: color } : {};
+}
+function numberOf(value) {
+  const parsed = Number.parseFloat(value ?? "");
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function histogramOptions(layoutPr) {
+  const binning = cx(layoutPr, "binning");
+  const out = {};
+  const size = numberOf(scalar(binning, "binSize"));
+  const count = numberOf(scalar(binning, "binCount"));
+  if (size !== void 0) out.binSize = size;
+  if (count !== void 0 && count >= 0) out.binCount = Math.trunc(count);
+  const closed = binning?.getAttribute("intervalClosed");
+  if (closed === "l" || closed === "r") out.intervalClosed = closed;
+  for (const key of ["underflow", "overflow"]) {
+    const raw2 = binning?.getAttribute(key);
+    if (raw2 === "auto") out[key] = "auto";
+    else if (raw2 !== null && raw2 !== void 0 && numberOf(raw2) !== void 0)
+      out[key] = numberOf(raw2);
+  }
+  if (cx(layoutPr, "aggregation")) out.aggregateByCategory = true;
   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;
-    }
+var LEGEND_POSITIONS = ["r", "l", "t", "b", "tr"];
+function chartExSummary(source) {
+  const root = typeof source === "string" ? parseXml(source, { label: "Chart part" }).documentElement : source;
+  if (root.localName !== "chartSpace" || root.namespaceURI !== NS.cx) return void 0;
+  const chart = cx(root, "chart");
+  const region = cx(cx(chart, "plotArea"), "plotAreaRegion");
+  const all = region ? children(region, "series", NS.cx) : [];
+  const primary = all.find((s) => s.getAttribute("layoutId") !== "paretoLine") ?? all[0];
+  const layoutId = primary?.getAttribute("layoutId") ?? "";
+  const chartType = layoutId === "waterfall" ? "waterfall" : layoutId === "clusteredColumn" ? "histogram" : layoutId === "treemap" || layoutId === "sunburst" ? layoutId : void 0;
+  if (!primary || !chartType) return { layoutId };
+  const data = seriesData(root, primary);
+  const categories = dimension(data, "strDim", "cat");
+  const values = dimension(
+    data,
+    "numDim",
+    chartType === "treemap" || chartType === "sunburst" ? "size" : "val"
+  );
+  const txData = cx(cx(primary, "tx"), "txData");
+  const series = {
+    categories: categories?.points ?? [],
+    values: (values?.points ?? []).map(
+      (p) => p !== "" && Number.isFinite(Number(p)) ? Number(p) : null
+    ),
+    ...seriesFill(primary)
+  };
+  const name = text(cx(txData, "v"));
+  if (name) series.name = name;
+  const nameRef = text(cx(txData, "f"));
+  if (nameRef) series.nameRef = nameRef;
+  if (categories?.formula) series.categoriesRef = categories.formula;
+  if (values?.formula) series.valuesRef = values.formula;
+  const layoutPr = cx(primary, "layoutPr");
+  const legend = cx(chart, "legend");
+  const summary = { chartType, series: [series], showLegend: legend !== void 0 };
+  summary.formatting = {
+    builtInStyle: 2,
+    sourceXml: "",
+    entries: {
+      title: {
+        fontSize: 14,
+        bold: false,
+        textColor: {
+          kind: "scheme",
+          value: "tx1",
+          transforms: [
+            { name: "lumMod", value: "65000" },
+            { name: "lumOff", value: "35000" }
+          ]
+        },
+        sourceXml: ""
+      }
+    }
+  };
+  const title = titleOf(chart);
+  if (title) summary.title = title;
+  const position = legend?.getAttribute("pos");
+  if (position && LEGEND_POSITIONS.includes(position))
+    summary.legendPosition = position;
+  if (chartType === "waterfall") {
+    const subtotals = cx(layoutPr, "subtotals");
+    const connectors = cx(layoutPr, "visibility")?.getAttribute("connectorLines");
+    summary.waterfall = {
+      ...subtotals ? {
+        subtotalIndices: children(subtotals, "idx", NS.cx).map((idx) => Number.parseInt(idx.getAttribute("val") ?? "", 10)).filter((idx) => Number.isInteger(idx) && idx >= 0)
+      } : {},
+      ...connectors === "0" || connectors === "false" ? { connectorLines: false } : {}
+    };
+  } else if (chartType === "treemap" || chartType === "sunburst") {
+    const layout = cx(layoutPr, "parentLabelLayout")?.getAttribute("val");
+    summary.hierarchy = {
+      levels: categoryLevels(data),
+      dataLabels: cx(primary, "dataLabels") !== void 0,
+      ...layout === "none" || layout === "banner" || layout === "overlapping" ? { parentLabelLayout: layout } : {}
+    };
+  } else summary.histogram = histogramOptions(layoutPr);
+  return { layoutId, 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-svg-util.ts
+var TEXT_COLOR = "#595959";
+var GRID_COLOR = "#D9D9D9";
+var AXIS_COLOR = "#BFBFBF";
+var FONT_SIZE = 10;
+function esc(text3) {
+  return text3.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 = (text3, size = FONT_SIZE) => text3.length * size * 0.55;
+function text2(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/chart-spacing.ts
+function chartBarSpacing(chart) {
+  const stacked = chart.grouping === "stacked" || chart.grouping === "percentStacked";
+  return {
+    barGapWidth: chart.barGapWidth ?? DEFAULT_BAR_GAP_WIDTH,
+    barOverlap: chart.barOverlap ?? (stacked ? 100 : 0)
+  };
+}
+
+// chart/render/chart-svg-bars.ts
+function barLayout(model, frame) {
+  const count = Math.max(1, model.series.length);
+  const geometry = clusteredBarGeometry(frame.bandSize, count, chartBarSpacing(model));
+  const barSize = geometry.singleBarWidth;
+  const offset = (si) => model.horizontal ? geometry.clusterWidth / 2 - barSize - si * geometry.step : -geometry.clusterWidth / 2 + si * geometry.step;
+  return { barSize, offset };
+}
+function bars(model, frame, out, values) {
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  const { barSize, offset: barOffset } = barLayout(model, frame);
+  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 = barOffset(si);
+      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-analysis.ts
+var DASHES = {
+  dot: [1, 3],
+  dash: [4, 3],
+  lgDash: [8, 3],
+  dashDot: [4, 3, 1, 3],
+  lgDashDot: [8, 3, 1, 3],
+  lgDashDotDot: [8, 3, 1, 3, 1, 3],
+  sysDash: [3, 1],
+  sysDot: [1, 1],
+  sysDashDot: [3, 1, 1, 1],
+  sysDashDotDot: [3, 1, 1, 1, 1, 1]
+};
+var CAP = 4;
+function strokeAttributes(stroke) {
+  const pattern = stroke.dash ? DASHES[stroke.dash] : void 0;
+  const dash = pattern ? ` stroke-dasharray="${pattern.map((step) => n(step * stroke.width)).join(" ")}"` : "";
+  return `stroke="${esc(stroke.color)}" stroke-width="${n(stroke.width)}"${dash}`;
+}
+var segment = (x1, y1, x2, y2, stroke) => `<line x1="${n(x1)}" y1="${n(y1)}" x2="${n(x2)}" y2="${n(y2)}" ${stroke}/>`;
+function trendlines(series, si, xs, ys, plane, out) {
+  for (const trendline of series.trendlines ?? []) {
+    const fit2 = fitChartTrendline(trendline.fit, xs, ys);
+    if (fit2.points.length < 2) continue;
+    const points = fit2.points.map(({ x, y }) => plane(x, y).map(n).join(",")).join(" ");
+    out.push(
+      `<polyline points="${points}" fill="none" ${strokeAttributes(trendline.stroke)} data-chart-part="trendline" data-chart-series="${si}"/>`
+    );
   }
-  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;
+}
+function errorBar(bars2, at, values, plane, out) {
+  const stroke = strokeAttributes(bars2.stroke);
+  for (const side of ["plus", "minus"]) {
+    if (bars2.barType !== side && bars2.barType !== "both") continue;
+    const amount = chartErrorBarAmount(bars2.amount, values, at.displayIndex, at.sourceIndex, side);
+    const sign = side === "plus" ? 1 : -1;
+    const [x1, y1] = plane(at.x, at.y);
+    const [x2, y2] = bars2.direction === "x" ? plane(at.x + sign * amount, at.y) : plane(at.x, at.y + sign * amount);
+    out.push(segment(x1, y1, x2, y2, stroke));
+    if (!bars2.endCap) continue;
+    if (x1 === x2) out.push(segment(x2 - CAP, y2, x2 + CAP, y2, stroke));
+    else out.push(segment(x2, y2 - CAP, x2, y2 + CAP, stroke));
+  }
+}
+function plottedPoints(series, xOf) {
+  return series.values.flatMap((y, index) => {
+    const x = xOf(index);
+    return y === null || x === null ? [] : [{ x, y, index }];
+  });
+}
+function seriesAnalysis(series, si, xOf, plane, barPlane, categoryAxis, out) {
+  const points = plottedPoints(series, xOf);
+  const xs = points.map((p) => p.x);
+  const ys = points.map((p) => p.y);
+  trendlines(series, si, xs, ys, plane, out);
+  for (const bars2 of series.errorBars ?? []) {
+    if (categoryAxis && bars2.direction === "x") continue;
+    const values = bars2.direction === "x" ? xs : ys;
+    points.forEach(
+      (p, displayIndex) => errorBar(bars2, { x: p.x, y: p.y, displayIndex, sourceIndex: p.index }, values, barPlane, out)
+    );
   }
-  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;
+function categoryAnalysis(model, frame, out) {
+  if (model.grouping === "stacked" || model.grouping === "percentStacked") return;
+  const plane = (x, y) => model.horizontal ? [frame.value(y), frame.band(x - 1)] : [frame.band(x - 1), frame.value(y)];
+  const barred = model.type === "bar" || model.type === "column";
+  const layout = barred ? barLayout(model, frame) : void 0;
+  model.series.forEach((series, si) => {
+    if (!series.trendlines && !series.errorBars) return;
+    const shift = layout ? layout.offset(si) + layout.barSize / 2 : 0;
+    const barPlane = (x, y) => {
+      const [px, py] = plane(x, y);
+      return model.horizontal ? [px, py + shift] : [px + shift, py];
+    };
+    seriesAnalysis(series, si, (i) => i + 1, plane, barPlane, true, out);
+  });
+}
+function scatterAnalysis(model, px, py, out) {
+  const plane = (x, y) => [px(x), py(y)];
+  model.series.forEach((series, si) => {
+    if (!series.trendlines && !series.errorBars) return;
+    seriesAnalysis(series, si, (i) => series.xValues?.[i] ?? null, plane, plane, false, out);
+  });
 }
 
 // chart/render/chart-scale.ts
@@ -3835,36 +5238,47 @@ function formatAxisValue(value, percent = false) {
   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;");
+// 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})`;
 }
-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>`;
+
+// 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
+  };
 }
-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`;
+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/render/theme-palette.ts
@@ -3928,88 +5342,6 @@ function autoSeriesColor(theme, 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",
@@ -4075,27 +5407,239 @@ function chartAppearance(chart, theme) {
     { 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);
+  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-view-analysis.ts
+function strokeOf(line2, fallback, resolve) {
+  if (line2?.fill?.kind === "none") return void 0;
+  const color = (line2?.fill?.kind === "solid" ? resolve(line2.fill.color) : void 0) ?? fallback.color;
+  const width = line2?.widthEmu === void 0 ? fallback.width : chartPointsToPixels(line2.widthEmu / 12700);
+  const dash = line2?.dash ?? fallback.dash;
+  return { color, width, ...dash && dash !== "solid" ? { dash } : {} };
+}
+function analysisView(source, seriesColor, resolve) {
+  const plain = seriesColor === "none" || seriesColor.startsWith("url(") ? TEXT_COLOR : seriesColor;
+  const trendlines2 = (source.trendlines ?? []).flatMap((entry3) => {
+    const { name: _name, line: line2, ...fit2 } = entry3;
+    const fallback = { color: plain, width: chartPointsToPixels(1.5), dash: "sysDot" };
+    const stroke = strokeOf(line2, fallback, resolve);
+    return stroke ? [{ fit: fit2, stroke }] : [];
+  });
+  const errorBars = (source.errorBars ?? []).flatMap((entry3) => {
+    const { direction, barType, noEndCap, line: line2, ...amount } = entry3;
+    const stroke = strokeOf(line2, { color: TEXT_COLOR, width: chartPointsToPixels(0.75) }, resolve);
+    return stroke ? [{ direction, barType, amount, endCap: noEndCap !== true, stroke }] : [];
+  });
+  return {
+    ...trendlines2.length ? { trendlines: trendlines2 } : {},
+    ...errorBars.length ? { errorBars } : {}
+  };
+}
+
+// chart/render/chart-view-series.ts
+var isRefError = (value) => typeof value === "object" && value !== null && "error" in value;
+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 seriesContext(chart, theme, options) {
+  const scheme = chartColorScheme(theme);
+  const resolver = { scheme: (name) => scheme[name] };
+  return {
+    theme,
+    scheme,
+    palette: chart.colorPalette === void 0 ? void 0 : findChartColorPalette(chart.colorPalette),
+    evaluateRef: options.evaluateRef ?? (() => []),
+    seriesColor: options.seriesColor,
+    drawingColor: (color) => color && drawingColorCss(resolveDrawingColor(color, resolver, { transformOrder: "document" })),
+    gradient: (fill) => fill?.kind === "gradient" ? resolveChartGradient(
+      fill,
+      (color) => resolveDrawingColor(color, resolver, { transformOrder: "document" })
+    ) : void 0
+  };
+}
+function seriesView(ctx, s, index, total, categoriesOf) {
+  const { theme, scheme, palette, evaluateRef } = ctx;
+  const values = resolveRef(s.valuesRef, evaluateRef)?.map(toNumber) ?? s.values.map(toNumber);
+  categoriesOf(resolveRef(s.categoriesRef, evaluateRef) ?? s.categories);
+  const paletteColor = palette && chartPaletteSeriesColor(palette, index, total, scheme);
+  const color = s.fill?.kind === "none" ? "none" : ctx.drawingColor(s.fill?.kind === "solid" ? s.fill.color : s.drawingColor) ?? ctx.seriesColor?.(s, index) ?? paletteColor ?? autoSeriesColor(theme, index);
+  const view = { name: seriesName(s, index, evaluateRef), values, color };
+  const shadow = resolveDrawingShadowXml(s.effectsXml, { scheme: (name) => scheme[name] });
+  if (shadow) view.shadow = shadow;
+  const resolvedGradient = ctx.gradient(s.fill);
+  if (resolvedGradient) view.gradient = resolvedGradient;
+  const points = Object.fromEntries(
+    Object.entries(s.pointFills ?? {}).flatMap(([key, fill]) => {
+      const value = ctx.gradient(fill);
+      return value ? [[key, value]] : [];
+    })
+  );
+  if (Object.keys(points).length) view.pointGradients = points;
+  Object.assign(view, analysisView(s, color, ctx.drawingColor));
+  return view;
+}
+
+// chart/render/chart-view-families.ts
+function bubbleView(chart, model, evaluateRef) {
+  chart.series.forEach((source, i) => {
+    const view = model.series[i];
+    if (!view) return;
+    const live = resolveRef(source.bubbleSizesRef, evaluateRef)?.map(toNumber);
+    const sizes = live ?? source.bubbleSizes;
+    if (sizes) view.sizes = sizes;
+  });
+  model.bubble = {
+    sizeRepresents: chart.bubble?.sizeRepresents ?? "area",
+    ...chart.bubble?.bubbleScale === void 0 ? {} : { bubbleScale: chart.bubble.bubbleScale },
+    showNegativeBubbles: chart.bubble?.showNegativeBubbles === true
+  };
+}
+var columnNumber = (letters) => [...letters].reduce((n2, ch) => n2 * 26 + ch.charCodeAt(0) - 64, 0);
+function refColumns(ref) {
+  const match = /\$?([A-Z]{1,3})\$?\d+:\$?([A-Z]{1,3})\$?\d+\s*$/i.exec(ref);
+  if (!match) return 1;
+  return Math.max(
+    1,
+    columnNumber((match[2] ?? "").toUpperCase()) - columnNumber((match[1] ?? "").toUpperCase()) + 1
+  );
+}
+function liveLevels(ref, evaluateRef) {
+  const columns = ref ? refColumns(ref) : 1;
+  const flat = columns > 1 ? resolveRef(ref, evaluateRef)?.map(toText) : void 0;
+  if (!flat || flat.length % columns !== 0) return void 0;
+  const levels = Array.from({ length: columns }, () => []);
+  flat.forEach((label, i) => levels[columns - 1 - i % columns]?.push(label));
+  return levels;
+}
+function hierarchyView(chart, model, evaluateRef) {
+  const first2 = model.series[0];
+  const live = liveLevels(chart.series[0]?.categoriesRef, evaluateRef);
+  if (live?.[0]) model.categories = live[0];
+  const count = Math.max(first2?.values.length ?? 0, model.categories.length);
+  const supplied = live ?? chart.hierarchy?.levels ?? [];
+  const levels = supplied.length > 1 ? normalizeLevels(supplied, count) : [];
+  model.hierarchy = {
+    levels,
+    parentLabelLayout: chart.hierarchy?.parentLabelLayout ?? "banner",
+    labels: chart.hierarchy?.dataLabels !== false,
+    branches: hierarchyBranchLabels(
+      model.series.map((s) => ({ name: s.name, values: s.values.map((v) => v ?? 0) })),
+      model.categories,
+      levels.length > 1 ? levels : void 0
+    )
+  };
+}
+
+// chart/render/chart-view-stock.ts
+var EMU_PER_PX = 9525;
+function paintOf(fill, ctx) {
+  if (fill?.kind === "none") return "none";
+  return fill?.kind === "solid" ? ctx.drawingColor(fill.color) : void 0;
+}
+function lineOf(shape, ctx, color) {
+  const line2 = shape?.line;
+  return {
+    color: paintOf(line2?.fill, ctx) ?? color,
+    width: line2?.widthEmu === void 0 ? 1 : Math.max(0.5, line2.widthEmu / EMU_PER_PX)
+  };
+}
+function barOf(shape, ctx, fallback) {
+  const stroke = lineOf(shape, ctx, "#404040");
+  return {
+    fill: paintOf(shape?.fill, ctx) ?? fallback,
+    stroke: stroke.color,
+    strokeWidth: stroke.width
+  };
+}
+function stockView(style, ctx) {
+  return {
+    wick: lineOf(style?.hiLowLines, ctx, STOCK_DEFAULT_WICK_COLOR),
+    up: barOf(style?.upBars, ctx, STOCK_DEFAULT_UP_FILL),
+    down: barOf(style?.downBars, ctx, STOCK_DEFAULT_DOWN_FILL),
+    bodyShare: 1 / (1 + Math.max(0, style?.gapWidth ?? 150) / 100)
+  };
+}
+
+// chart/render/chart-value-axis.ts
+function valueExtent(type, grouping, series, categories) {
+  const stackable = type === "bar" || type === "column" || type === "line" || type === "area";
+  let min = Infinity;
+  let max = -Infinity;
+  if (stackable && grouping === "stacked") {
+    for (let i = 0; i < categories; i++) {
+      let pos = 0;
+      let neg = 0;
+      for (const s of 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 series)
+      for (const v of s.values)
+        if (v !== null) {
+          min = Math.min(min, v);
+          max = Math.max(max, v);
+        }
   }
-  return out;
+  return { min, max };
+}
+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, max } = valueExtent(model.type, model.grouping, model.series, model.categories.length);
+  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)
+  );
 }
 
 // chart/render/chart-title-text.ts
@@ -4142,8 +5686,87 @@ function chartTitleText(chart, theme) {
   };
 }
 
+// chart/render/chart-view-ex.ts
+function groupsAxis(groups, categories) {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const group2 of groups) {
+    const extent = valueExtent(group2.type, group2.grouping, group2.series, categories);
+    min = Math.min(min, extent.min);
+    max = Math.max(max, extent.max);
+  }
+  return min === Infinity ? { ...niceScale(0, 1), percent: false } : { ...niceScale(min, max), percent: false };
+}
+function chartExtraView(chart, model, ctx, total, categoriesOf) {
+  let index = chart.series.length;
+  const groups = [];
+  for (const group2 of chart.extraGroups ?? []) {
+    const series = group2.series.map((s) => seriesView(ctx, s, index++, total, categoriesOf));
+    const view = {
+      type: group2.chartType,
+      grouping: group2.grouping ?? (group2.chartType === "column" ? "clustered" : "standard"),
+      series,
+      secondary: group2.secondary
+    };
+    if (group2.chartType === "stock") view.stock = stockView(group2.stock, ctx);
+    if (group2.barGapWidth !== void 0) view.barGapWidth = group2.barGapWidth;
+    if (group2.barOverlap !== void 0) view.barOverlap = group2.barOverlap;
+    groups.push(view);
+  }
+  if (!groups.length) return;
+  model.extraGroups = groups;
+}
+function chartExtraAxes(model) {
+  const groups = model.extraGroups;
+  if (!groups || !model.valueAxis) return;
+  const count = model.categories.length;
+  const secondary = groups.filter((g) => g.secondary);
+  if (secondary.length) model.secondaryAxis = groupsAxis(secondary, count);
+  const shared = groups.filter((g) => !g.secondary);
+  if (!shared.length || model.valueAxis.percent) return;
+  const own = valueExtent(model.type, model.grouping, model.series, count);
+  let min = own.min;
+  let max = own.max;
+  for (const group2 of shared) {
+    const extent = valueExtent(group2.type, group2.grouping, group2.series, count);
+    min = Math.min(min, extent.min);
+    max = Math.max(max, extent.max);
+  }
+  model.valueAxis = { ...niceScale(min, max), percent: false };
+}
+function waterfallView(chart, model, ctx) {
+  const values = (model.series[0]?.values ?? []).map((v) => v ?? 0);
+  const steps = buildWaterfallSteps(values, chart.waterfall);
+  const role = (i) => ctx.palette && chartPaletteSeriesColor(ctx.palette, i, 3, ctx.scheme) || autoSeriesColor(ctx.theme, i);
+  model.waterfall = {
+    steps,
+    connectors: chart.waterfall?.connectorLines !== false,
+    colors: { increase: role(0), decrease: role(1), total: role(2) }
+  };
+  const ends = steps.flatMap((step) => [step.startValue, step.endValue]);
+  model.valueAxis = {
+    ...ends.length ? niceScale(Math.min(...ends), Math.max(...ends)) : niceScale(0, 1),
+    percent: false
+  };
+  const labels = model.categories;
+  model.categories = steps.map((_, i) => labels[i] ?? String(i + 1));
+}
+function histogramView(chart, model) {
+  const first2 = model.series[0];
+  if (!first2) return;
+  const raw2 = first2.values.map((v) => v ?? Number.NaN);
+  const options = chart.histogram ?? {};
+  const bins = options.aggregateByCategory ? aggregateByCategory(
+    first2.values.map((v) => v ?? 0),
+    model.categories
+  ) : computeHistogramBins(raw2, options, formatAxisValue);
+  model.categories = bins.map((bin) => bin.label);
+  first2.values = bins.map((bin) => bin.value);
+  model.barGapWidth = 0;
+  model.barOverlap = 0;
+}
+
 // chart/render/chart-view.ts
-var isRefError = (value) => typeof value === "object" && value !== null && "error" in value;
 var SUPPORTED = /* @__PURE__ */ new Set([
   "bar",
   "column",
@@ -4152,85 +5775,37 @@ var SUPPORTED = /* @__PURE__ */ new Set([
   "pie",
   "doughnut",
   "scatter",
-  "radar"
+  "radar",
+  "waterfall",
+  "histogram",
+  "bubble",
+  "stock",
+  "treemap",
+  "sunburst"
 ]);
-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 byPoint = radial || type === "treemap" || type === "sunburst";
+  const ctx = seriesContext(chart, theme, options);
+  const { palette, scheme, drawingColor } = ctx;
   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 collect = (cats) => void rawCategories.push(cats);
+  const extra = chart.extraGroups ?? [];
+  const total = chart.series.length + extra.reduce((n2, g) => n2 + g.series.length, 0);
+  const series = chart.series.map((s, i) => seriesView(ctx, s, i, total, collect));
+  const longest = Math.max(
+    0,
+    ...series.map((s) => s.values.length),
+    ...extra.flatMap((g) => g.series.map((s) => s.values.length))
+  );
   const firstCats = rawCategories.find((c2) => c2.length > 0) ?? [];
-  categories = Array.from(
+  const categories = Array.from(
     { length: Math.max(longest, firstCats.length) },
     (_, i) => firstCats[i] !== void 0 ? toText(firstCats[i] ?? null) : String(i + 1)
   );
-  if (radial) {
+  if (byPoint) {
     series.forEach((s, seriesIndex) => {
       s.pointColors = s.values.map((_, i) => {
         const explicit = drawingColor(chart.series[seriesIndex]?.pointColors?.[i]);
@@ -4251,8 +5826,8 @@ function chartSummaryView(chart, theme, options = {}) {
     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 paint2 = drawingColor(fill.color);
+        if (paint2) (s.pointColors ??= [])[Number(key)] = paint2;
       }
     }
   });
@@ -4279,7 +5854,7 @@ function chartSummaryView(chart, theme, options = {}) {
   if (titleText) model.titleText = titleText;
   const appearance = chartAppearance(chart, theme);
   if (appearance) model.appearance = appearance;
-  if (type === "scatter") {
+  if (type === "scatter" || type === "bubble") {
     series.forEach((s, i) => {
       const cats = rawCategories[i] ?? [];
       const numeric = cats.length > 0 && cats.every((c2) => typeof c2 === "number");
@@ -4288,7 +5863,15 @@ function chartSummaryView(chart, theme, options = {}) {
     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);
+  if (type === "stock") model.stock = stockView(chart.stock, ctx);
+  if (type === "bubble") bubbleView(chart, model, ctx.evaluateRef);
+  if (type === "treemap" || type === "sunburst") hierarchyView(chart, model, ctx.evaluateRef);
+  if (type === "histogram") histogramView(chart, model);
+  if (extra.length && (type === "column" || type === "line" || type === "area"))
+    chartExtraView(chart, model, ctx, total, collect);
+  if (type === "waterfall") waterfallView(chart, model, ctx);
+  else if (!byPoint) model.valueAxis = valueAxis(model);
+  chartExtraAxes(model);
   return model;
 }
 
@@ -4330,7 +5913,7 @@ function chartGradientPaint(model, width = 1024, height = 768) {
         textShadowFilter: shadowPaint(entry3.textShadow, `${part}-text-shadow`)
       };
   }
-  const paint = (gradient, suffix, bounds) => {
+  const paint2 = (gradient, suffix, bounds) => {
     const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds);
     defs.push(chartGradientMarkup(def));
     return `url(#${def.id})`;
@@ -4341,18 +5924,18 @@ function chartGradientPaint(model, width = 1024, height = 768) {
     if (part === "plotArea" && ["circle", "shape"].includes(entry3.gradient.path ?? "")) continue;
     appearance[part] = {
       ...entry3,
-      fillColor: paint(entry3.gradient, part, { width, height, shape: "rect" })
+      fillColor: paint2(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.gradient) view.color = paint2(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);
+        view.pointColors[Number(key)] = paint2(gradient, `s${index}-p${key}`, bounds);
     }
     return view;
   });
@@ -4397,72 +5980,8 @@ function chartAreaRect(model, part, area) {
   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 ?? DEFAULT_BAR_GAP_WIDTH,
-    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) {
+function cartesianAxes(model, area, out) {
   const scale = model.valueAxis;
   if (!scale) return void 0;
   const labels = scale.ticks.map((t) => formatAxisValue(t, scale.percent));
@@ -4481,6 +6000,9 @@ function axes(model, area, out) {
     area.w * 0.3,
     Math.max(...model.categories.map((c2) => textWidth(c2, categorySize)), 8) + 6
   );
+  const second = horizontal ? void 0 : model.secondaryAxis;
+  const secondLabels = second?.ticks.map((t) => formatAxisValue(t, second.percent)) ?? [];
+  const secondW = second ? valueLabels ? Math.max(...secondLabels.map((l) => textWidth(l, valueSize)), 8) + 8 : 4 : 0;
   const plot = horizontal ? {
     x: area.x + catW,
     y: area.y,
@@ -4489,7 +6011,7 @@ function axes(model, area, out) {
   } : {
     x: area.x + labelW,
     y: area.y + 4,
-    w: Math.max(1, area.w - labelW - 4),
+    w: Math.max(1, area.w - labelW - 4 - secondW),
     h: Math.max(1, area.h - Math.max(20, categorySize * 1.5))
   };
   const span = scale.max - scale.min || 1;
@@ -4504,12 +6026,12 @@ function axes(model, area, out) {
       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 })
+          text2(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 }));
+        out.push(text2(plot.x - 4, p + valueSize * 0.3, label, { anchor: "end", ...valueAttrs }));
     }
   });
   const zero = value(Math.min(Math.max(0, scale.min), scale.max));
@@ -4524,20 +6046,45 @@ function axes(model, area, out) {
     const p = band(i);
     if (horizontal)
       out.push(
-        text(plot.x - 4, p + categorySize * 0.3, fit(c2, catW - 6, categorySize), {
+        text2(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), {
+        text2(p, plot.y + plot.h + categorySize + 3, fit(c2, bandSize * step, categorySize), {
           anchor: "middle",
           ...categoryAttrs
         })
       );
   });
-  return { plot, value, band, bandSize };
+  const frame = { plot, value, band, bandSize };
+  if (second) {
+    const secondSpan = second.max - second.min || 1;
+    frame.secondary = (v) => plot.y + plot.h - (v - second.min) / secondSpan * plot.h;
+    const secondAxis = chartStroke(model, "valueAxis");
+    out.push(
+      line(
+        plot.x + plot.w,
+        plot.y,
+        plot.x + plot.w,
+        plot.y + plot.h,
+        secondAxis.color,
+        secondAxis.width
+      )
+    );
+    if (valueLabels)
+      second.ticks.forEach(
+        (t, i) => out.push(
+          text2(plot.x + plot.w + 4, frame.secondary(t) + valueSize * 0.3, secondLabels[i] ?? "", {
+            anchor: "start",
+            ...valueAttrs
+          })
+        )
+      );
+  }
+  return frame;
 }
 function plotted(model) {
   if (model.grouping !== "percentStacked") return model.series.map((s) => s.values);
@@ -4580,17 +6127,17 @@ function linesAndAreas(model, frame, out) {
       out.push(`<polygon points="${poly}" fill="${color}" fill-opacity="0.85"${filter}/>`);
       continue;
     }
-    let segment = [];
+    let segment2 = [];
     const flush = () => {
-      if (segment.length > 1)
+      if (segment2.length > 1)
         out.push(
-          `<polyline points="${segment.join(" ")}" fill="none" stroke="${color}" stroke-width="2.25" stroke-linejoin="round"${filter}/>`
+          `<polyline points="${segment2.join(" ")}" fill="none" stroke="${color}" stroke-width="2.25" stroke-linejoin="round"${filter}/>`
         );
-      segment = [];
+      segment2 = [];
     };
     for (const [x, y] of points) {
       if (Number.isNaN(x)) flush();
-      else segment.push(`${n(x)},${n(y)}`);
+      else segment2.push(`${n(x)},${n(y)}`);
     }
     flush();
     for (const [x, y] of points)
@@ -4598,6 +6145,8 @@ function linesAndAreas(model, frame, out) {
         out.push(`<circle cx="${n(x)}" cy="${n(y)}" r="2.5" fill="${color}"${filter}/>`);
   }
 }
+
+// chart/render/chart-svg-xy.ts
 function scatter(model, area, out) {
   const ys = model.valueAxis;
   const xs = model.xAxis;
@@ -4619,26 +6168,42 @@ function scatter(model, area, out) {
     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;
+  const bubble = model.type === "bubble" ? model.bubble : void 0;
+  const biggest = maxBubbleSize(
+    model.series.flatMap((s) => (s.sizes ?? []).filter((v) => v !== null))
+  );
+  const median = medianBubbleRadius(plot.w, plot.h);
+  const radiusOf = (size) => bubble && !(size !== void 0 && size < 0 && !bubble.showNegativeBubbles) ? computeBubbleRadius(size, biggest, median, bubble) : void 0;
+  let reach = 0;
+  if (bubble)
+    for (const s of model.series)
+      s.values.forEach((_, i) => {
+        reach = Math.max(reach, radiusOf(s.sizes?.[i] ?? void 0) ?? 0);
+      });
+  const widen = (s, length) => {
+    const pad = reach * (s.max - s.min || 1) / Math.max(1, length - 2 * reach);
+    return { ...s, min: s.min - pad, max: s.max + pad };
+  };
+  const xView = widen(xs, plot.w);
+  const yView = widen(ys, plot.h);
+  const px = (v) => plot.x + (v - xView.min) / (xView.max - xView.min || 1) * plot.w;
+  const py = (v) => plot.y + plot.h - (v - yView.min) / (yView.max - yView.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));
+    out.push(line(plot.x, py(t), plot.x + plot.w, py(t), grid.color, grid.width));
     if (valueLabels)
       out.push(
-        text(plot.x - 4, py(t, ys) + valueSize * 0.3, yLabels[i] ?? "", {
+        text2(plot.x - 4, py(t) + 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)
-    );
+    out.push(line(px(t), plot.y + plot.h, px(t), 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), {
+        text2(px(t), plot.y + plot.h + categorySize + 3, formatAxisValue(t), {
           anchor: "middle",
           ...categoryAttrs
         })
@@ -4648,51 +6213,185 @@ function scatter(model, area, out) {
     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)
+  for (const [si, s] of model.series.entries())
     s.values.forEach((v, i) => {
       const x = s.xValues?.[i] ?? null;
       if (v === null || x === null) return;
+      const filter = s.shadowFilter ? ` filter="${s.shadowFilter}"` : "";
+      const fill = s.pointColors?.[i] ?? s.color;
+      if (!bubble) {
+        out.push(`<circle cx="${n(px(x))}" cy="${n(py(v))}" r="3" fill="${fill}"${filter}/>`);
+        return;
+      }
+      const r = radiusOf(s.sizes?.[i] ?? void 0);
+      if (r === void 0) 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}"` : ""}/>`
+        `<circle cx="${n(px(x))}" cy="${n(py(v))}" r="${n(r)}" fill="${fill}" fill-opacity="0.6" data-chart-series="${si}" data-chart-point="${i}"${filter}/>`
       );
     });
+  scatterAnalysis(model, px, py, out);
+}
+
+// chart/render/chart-svg-stock.ts
+function stockBars(model, frame, out) {
+  const slots = stockSlots(model.series.length);
+  if (!slots) return;
+  const style = model.stock ?? stockView(void 0, { drawingColor: () => void 0 });
+  const at = (role, i) => role === void 0 ? void 0 : model.series[role]?.values[i];
+  const closeColor = model.series[slots.close]?.color ?? style.wick.color;
+  model.categories.forEach((_, i) => {
+    const candle = stockCandle({
+      x: frame.band(i),
+      band: frame.bandSize,
+      high: at(slots.high, i),
+      low: at(slots.low, i),
+      close: at(slots.close, i),
+      open: at(slots.open, i),
+      hasOpen: slots.open !== void 0,
+      bodyShare: style.bodyShare,
+      y: frame.value
+    });
+    if (!candle) return;
+    out.push(`<g data-chart-series="${slots.close}" data-chart-point="${i}">`);
+    out.push(
+      line(
+        candle.wick.x,
+        candle.wick.y1,
+        candle.wick.x,
+        candle.wick.y2,
+        style.wick.color,
+        style.wick.width
+      )
+    );
+    if (candle.body) {
+      const { x, y, w, h, up } = candle.body;
+      const bar = up ? style.up : style.down;
+      const stroke = bar.stroke === "none" ? "" : ` stroke="${esc(bar.stroke)}" stroke-width="${n(bar.strokeWidth)}"`;
+      out.push(rect(x, y, w, h, bar.fill).replace("/>", `${stroke}/>`));
+    } else if (candle.tick) {
+      out.push(
+        line(
+          candle.tick.x1,
+          candle.tick.y,
+          candle.tick.x2,
+          candle.tick.y,
+          closeColor,
+          STOCK_TICK_WIDTH
+        )
+      );
+    }
+    out.push("</g>");
+  });
+}
+
+// chart/render/chart-svg-waterfall.ts
+var CONNECTOR_COLOR = "#7F7F7F";
+var BAR_SHARE = 2 / 3;
+function waterfallBars(model, frame, out) {
+  const view = model.waterfall;
+  if (!view) return;
+  const width = frame.bandSize * BAR_SHARE;
+  view.steps.forEach((step, i) => {
+    const a2 = frame.value(step.startValue);
+    const b = frame.value(step.endValue);
+    const color = step.isSubtotal ? view.colors.total : step.value >= 0 ? view.colors.increase : view.colors.decrease;
+    const x = frame.band(i) - width / 2;
+    out.push(`<g data-chart-series="0" data-chart-point="${step.sourceIndex}">`);
+    out.push(rect(x, Math.min(a2, b), width, Math.max(Math.abs(b - a2), 1), color));
+    out.push("</g>");
+    const next = view.steps[i + 1];
+    if (view.connectors && next) {
+      const xNext = frame.band(i + 1) - width / 2;
+      out.push(
+        line(x + width, b, xNext, b, CONNECTOR_COLOR, 0.75).replace(
+          "/>",
+          ` stroke-dasharray="${n(3)} ${n(2)}"/>`
+        )
+      );
+    }
+  });
+}
+
+// chart/render/chart-svg-plots.ts
+var RANK = {
+  area: 0,
+  bar: 1,
+  column: 1,
+  histogram: 1,
+  line: 2,
+  stock: 2
+};
+function paint(layer, out) {
+  const { model, frame } = layer;
+  if (model.type === "stock") stockBars(model, frame, out);
+  else if (model.type === "bar" || model.type === "column" || model.type === "histogram")
+    bars(model, frame, out, plotted(model));
+  else linesAndAreas(model, frame, out);
 }
 function cartesianSvg(model, area) {
   const out = [];
-  if (model.type === "scatter") {
+  if (model.type === "scatter" || model.type === "bubble") {
     scatter(model, area, out);
     return out.join("");
   }
-  const frame = axes(model, area, out);
+  const frame = cartesianAxes(model, area, out);
   if (!frame) return "";
-  if (model.type === "bar" || model.type === "column") bars(model, frame, out, plotted(model));
-  else linesAndAreas(model, frame, out);
+  if (model.type === "waterfall") {
+    waterfallBars(model, frame, out);
+    return out.join("");
+  }
+  if (model.type === "stock") {
+    stockBars(model, frame, out);
+    return out.join("");
+  }
+  const layers = [{ model, frame }];
+  for (const group2 of model.extraGroups ?? []) {
+    const grouped = {
+      ...model,
+      type: group2.type,
+      grouping: group2.grouping,
+      series: group2.series,
+      horizontal: false
+    };
+    if (group2.stock) grouped.stock = group2.stock;
+    else delete grouped.stock;
+    if (group2.barGapWidth !== void 0) grouped.barGapWidth = group2.barGapWidth;
+    else delete grouped.barGapWidth;
+    if (group2.barOverlap !== void 0) grouped.barOverlap = group2.barOverlap;
+    else delete grouped.barOverlap;
+    const value = group2.secondary && frame.secondary ? frame.secondary : frame.value;
+    layers.push({ model: grouped, frame: { ...frame, value } });
+  }
+  layers.map((layer, order) => ({ layer, order })).sort(
+    (a2, b) => (RANK[a2.layer.model.type] ?? 1) - (RANK[b.layer.model.type] ?? 1) || a2.order - b.order
+  ).forEach(({ layer }) => paint(layer, out));
+  categoryAnalysis(model, frame, out);
   return out.join("");
 }
 
 // chart/render/chart-svg-radial.ts
-var polar = (cx, cy, r, angle) => [
-  cx + r * Math.sin(angle),
+var polar = (cx2, cy, r, angle) => [
+  cx2 + r * Math.sin(angle),
   cy - r * Math.cos(angle)
 ];
-function slicePath(cx, cy, r, inner, a0, a1) {
+function slicePath(cx2, 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);
+    return slicePath(cx2, cy, r, inner, a0, mid) + slicePath(cx2, 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);
+  const [x0, y0] = polar(cx2, cy, r, a0);
+  const [x1, y1] = polar(cx2, 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(cx2)},${n(cy)} L${n(x0)},${n(y0)} A${n(r)},${n(r)} 0 ${large} 1 ${n(x1)},${n(y1)} Z`;
+  const [ix1, iy1] = polar(cx2, cy, inner, a1);
+  const [ix0, iy0] = polar(cx2, 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 cx2 = 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);
@@ -4709,7 +6408,7 @@ function pieSvg(model, area) {
       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}"` : ""}/>`
+        `<path d="${slicePath(cx2, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
       );
       angle += sweep;
     });
@@ -4727,7 +6426,7 @@ function radarSvg(model, area) {
   const categorySize = categoryAttrs.size ?? 10;
   const grid = chartStroke(model, "gridlineMajor");
   const axis = chartStroke(model, "categoryAxis");
-  const cx = area.x + area.w / 2;
+  const cx2 = 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;
@@ -4737,30 +6436,30 @@ function radarSvg(model, area) {
     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(" ");
+    const ring = Array.from({ length: count }, (_, i) => polar(cx2, 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)
+        text2(cx2 + 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";
+    const [x, y] = polar(cx2, cy, radius, angle(i));
+    out.push(line(cx2, cy, x, y, axis.color, axis.width));
+    const [lx, ly] = polar(cx2, cy, radius + 10, angle(i));
+    const anchor = Math.abs(lx - cx2) < 2 ? "middle" : lx > cx2 ? "start" : "end";
     if (model.appearance?.categoryAxis?.labelsVisible !== false)
       out.push(
-        text(lx, ly + categorySize * 0.3, fit(c2, area.w / 4, categorySize), {
+        text2(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(" ");
+    const points = s.values.slice(0, count).map((v, i) => polar(cx2, 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}"` : ""}/>`
     );
@@ -4768,6 +6467,88 @@ function radarSvg(model, area) {
   return out.join("");
 }
 
+// chart/render/chart-svg-hierarchy.ts
+var colorAt2 = (model, index) => {
+  const first2 = model.series[0];
+  const colors = first2?.pointColors;
+  return (colors && colors.length > 0 ? colors[index % colors.length] : void 0) ?? first2?.color ?? "#4472C4";
+};
+var leafValues = (model) => (model.series[0]?.values ?? []).map((v) => v ?? 0);
+function treemapSvg(model, area) {
+  const out = [chartAreaRect(model, "plotArea", area)];
+  const hierarchy = model.hierarchy;
+  const series = model.series.map((s) => ({
+    name: s.name,
+    values: s.values.map((v) => v ?? 0),
+    // Without data labels Office draws no parent banners either, so no space is reserved.
+    parentLabelLayout: hierarchy?.labels === false ? "none" : hierarchy?.parentLabelLayout
+  }));
+  const roots = buildHierarchyRoots(
+    series,
+    model.categories,
+    hierarchy && hierarchy.levels.length > 1 ? hierarchy.levels : void 0
+  );
+  const cells = layoutTreemap(roots, { x: area.x, y: area.y, w: area.w, h: area.h });
+  for (const cell of cells) {
+    if (cell.kind === "parent") {
+      if (hierarchy?.labels !== false)
+        out.push(text2(cell.x, cell.y, cell.label, { size: 10, weight: "bold", fill: "#303030" }));
+      continue;
+    }
+    out.push(`<g data-chart-series="${cell.seriesIndex}" data-chart-point="${cell.pointIndex}">`);
+    out.push(
+      rect(cell.x, cell.y, cell.w, cell.h, colorAt2(model, cell.colorIndex)).replace(
+        "/>",
+        ' rx="2"/>'
+      )
+    );
+    if (cell.labelFits && hierarchy?.labels !== false)
+      out.push(
+        text2(
+          cell.x + cell.w / 2,
+          cell.y + cell.h / 2,
+          fit(cell.label, cell.w - 4, cell.labelSize),
+          {
+            anchor: "middle",
+            size: cell.labelSize,
+            weight: "bold",
+            fill: "#FFFFFF",
+            baseline: "central"
+          }
+        )
+      );
+    out.push("</g>");
+  }
+  return out.join("");
+}
+function sunburstSvg(model, area) {
+  const out = [chartAreaRect(model, "plotArea", area)];
+  const cx2 = area.x + area.w / 2;
+  const cy = area.y + area.h / 2;
+  const maxR = Math.min(area.w, area.h) / 2 - 4;
+  if (maxR <= 0) return out.join("");
+  const levels = model.hierarchy?.levels ?? [];
+  const arcs = levels.length > 1 ? computeHierarchicalSunburstArcs(levels, leafValues(model), cx2, cy, maxR) : computeSunburstArcs(
+    model.series.map((s) => ({ values: s.values.map((v) => v ?? 0) })),
+    cx2,
+    cy,
+    maxR
+  );
+  for (const arc of arcs)
+    out.push(
+      `<path d="${arc.d}" fill="${colorAt2(model, arc.colorIndex)}" stroke="#FFFFFF" stroke-width="1.5"${arc.pointIndex === void 0 ? "" : ` data-chart-series="0" data-chart-point="${arc.pointIndex}"`}/>`
+    );
+  const flatLabels = levels.length > 1 || model.series.length !== 1 ? void 0 : model.categories;
+  for (const arc of model.hierarchy?.labels === false ? [] : arcs) {
+    const label = arc.label ?? (arc.pointIndex === void 0 ? void 0 : flatLabels?.[arc.pointIndex]);
+    if (!label) continue;
+    out.push(
+      `<text x="${n(arc.labelX)}" y="${n(arc.labelY)}" font-size="10" fill="#FFFFFF" text-anchor="middle" dominant-baseline="central" transform="rotate(${n(arc.labelRotation)}, ${n(arc.labelX)}, ${n(arc.labelY)})">${esc(label)}</text>`
+    );
+  }
+  return out.join("");
+}
+
 // chart/render/chart-svg-text-metrics.ts
 var CHART_FONT_FAMILY = "Calibri, Carlito, Arial, sans-serif";
 function cssFont(attrs) {
@@ -4841,7 +6622,7 @@ function chartLegendSvg(model, area, frame, options) {
     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));
+    markup.push(text2(x + keySize + keyGap, centerY + baselineOffset, label, attrs));
     if (horizontal) horizontalX += (widths[i] ?? 0) + horizontalGap;
   });
   return {
@@ -4858,7 +6639,23 @@ function legendEntries(model) {
       color: first2?.pointColors?.[i] ?? first2?.color ?? "#4472C4"
     }));
   }
-  return model.series.map((s) => ({ label: s.name, color: s.color }));
+  if ((model.type === "treemap" || model.type === "sunburst") && model.hierarchy) {
+    const first2 = model.series[0];
+    return model.hierarchy.branches.map((label, i) => ({
+      label,
+      color: first2?.pointColors?.[i % Math.max(1, first2.pointColors.length)] ?? first2?.color ?? "#4472C4"
+    }));
+  }
+  if (model.type === "waterfall" && model.waterfall)
+    return [
+      { label: "Increase", color: model.waterfall.colors.increase },
+      { label: "Decrease", color: model.waterfall.colors.decrease },
+      { label: "Total", color: model.waterfall.colors.total }
+    ];
+  return [...model.series, ...(model.extraGroups ?? []).flatMap((g) => g.series)].map((s) => ({
+    label: s.name,
+    color: s.color
+  }));
 }
 function automaticLegend(model, area, out, options, bounds) {
   const entries = legendEntries(model);
@@ -4886,7 +6683,7 @@ function automaticLegend(model, area, out, options, bounds) {
     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));
+      out.push(text2(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 };
@@ -4911,7 +6708,7 @@ function automaticLegend(model, area, out, options, bounds) {
     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));
+    out.push(text2(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 };
 }
@@ -4923,12 +6720,12 @@ function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
   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);
+      let group2 = groups.at(-1);
+      if (!group2 || group2.kind !== kind || kind === "break") {
+        group2 = { kind, pieces: [] };
+        groups.push(group2);
       }
-      if (kind !== "break") group.pieces.push({ run: run2, source, text: token });
+      if (kind !== "break") group2.pieces.push({ run: run2, source, text: token });
     }
   }
   const merged = (left, right) => {
@@ -4952,29 +6749,29 @@ function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
     line2 = [];
     spaces = [];
   };
-  for (const group of groups) {
-    if (group.kind === "break") {
+  for (const group2 of groups) {
+    if (group2.kind === "break") {
       flush();
       continue;
     }
-    if (group.kind === "space") {
-      spaces = group.pieces;
+    if (group2.kind === "space") {
+      spaces = group2.pieces;
       continue;
     }
     const separator = line2.length ? spaces : [];
-    const wordWidth = width(group.pieces);
-    if (line2.length && width(merged(line2, [...separator, ...group.pieces])) > maxWidth) flush();
+    const wordWidth = width(group2.pieces);
+    if (line2.length && width(merged(line2, [...separator, ...group2.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 };
+      for (const piece of group2.pieces) {
+        for (const { segment: segment2 } of graphemes.segment(piece.text)) {
+          const next = { ...piece, text: segment2 };
           if (line2.length && width(merged(line2, [next])) > maxWidth) flush();
           line2 = merged(line2, [next]);
         }
       }
-    } else line2 = merged(line2, group.pieces);
+    } else line2 = merged(line2, group2.pieces);
   }
   flush();
   return result;
@@ -5084,7 +6881,7 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
     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, {
+        text2(x, baseline, run2.text, {
           ...run2.attrs,
           anchor: "start"
         }).replace("<text ", '<tspan data-chart-title-run="true" ').replace("</text>", "</tspan>")
@@ -5092,7 +6889,7 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
       x += chartTextWidth(run2.text, run2.attrs, options);
     }
   }
-  const parent = text(0, 0, "", { ...base, underline: false }).replace(
+  const parent = text2(0, 0, "", { ...base, underline: false }).replace(
     "</text>",
     `${spans.join("")}</text>`
   );
@@ -5116,8 +6913,8 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
 
 // 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 paint2 = chartGradientPaint(model, Math.max(1, width), Math.max(1, height));
+  model = paint2.model;
   const w = Math.max(1, width);
   const h = Math.max(1, height);
   const out = [];
@@ -5126,7 +6923,7 @@ function renderChartSvg(model, width, height, options = {}) {
     `<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);
+  if (paint2.defs) out.push(paint2.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);
@@ -5151,7 +6948,7 @@ function renderChartSvg(model, width, height, options = {}) {
       })
     );
     out.push(
-      text(w / 2, 8 + size, label, {
+      text2(w / 2, 8 + size, label, {
         anchor: "middle",
         fill: "#404040",
         ...attrs
@@ -5162,7 +6959,7 @@ function renderChartSvg(model, width, height, options = {}) {
   }
   if (!model.supported) {
     out.push(
-      text(w / 2, area.y + area.h / 2, `${model.type} charts are not drawn`, { anchor: "middle" })
+      text2(w / 2, area.y + area.h / 2, `${model.type} charts are not drawn`, { anchor: "middle" })
     );
     if (foregroundTitle) out.push(foregroundTitle);
     out.push("</svg>");
@@ -5174,6 +6971,8 @@ function renderChartSvg(model, width, height, options = {}) {
   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 if (model.type === "treemap") out.push(treemapSvg(model, area));
+    else if (model.type === "sunburst") out.push(sunburstSvg(model, area));
     else out.push(cartesianSvg(model, area));
   }
   if (legend.foreground) out.push(legend.markup);
@@ -5191,7 +6990,13 @@ var DRAWN_CHART_TYPES = /* @__PURE__ */ new Set([
   "pie",
   "doughnut",
   "scatter",
-  "radar"
+  "radar",
+  "waterfall",
+  "histogram",
+  "bubble",
+  "stock",
+  "treemap",
+  "sunburst"
 ]);
 function chartThemePalette(theme, fonts = {}) {
   return {
@@ -5217,26 +7022,43 @@ function renderChartSpaceSvg(space, options) {
   const view = chartSummaryView(summary, chartThemePalette(theme, fonts));
   return renderChartSvg(view, width, height, svg);
 }
+function renderChartSummarySvg(summary, options) {
+  const { width, height, theme, fonts, ...svg } = options;
+  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;
+exports.CHART_AUTO_TITLE = CHART_AUTO_TITLE;
 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_ERROR_BAR_DIRECTIONS = CHART_ERROR_BAR_DIRECTIONS;
+exports.CHART_ERROR_BAR_TYPES = CHART_ERROR_BAR_TYPES;
+exports.CHART_ERROR_VALUE_TYPES = CHART_ERROR_VALUE_TYPES;
 exports.CHART_GROUP_ELEMENTS = CHART_GROUP_ELEMENTS;
 exports.CHART_STYLE_PARTS = CHART_STYLE_PARTS;
 exports.DEFAULT_BAR_GAP_WIDTH = DEFAULT_BAR_GAP_WIDTH;
+exports.DEFAULT_CHART_PALETTE = DEFAULT_CHART_PALETTE;
 exports.DEFAULT_THEME_COLORS = DEFAULT_THEME_COLORS;
 exports.DRAWN_CHART_TYPES = DRAWN_CHART_TYPES;
 exports.LABEL_COLLISION_GAP = LABEL_COLLISION_GAP;
+exports.STOCK_DEFAULT_DOWN_FILL = STOCK_DEFAULT_DOWN_FILL;
+exports.STOCK_DEFAULT_UP_FILL = STOCK_DEFAULT_UP_FILL;
+exports.STOCK_DEFAULT_WICK_COLOR = STOCK_DEFAULT_WICK_COLOR;
+exports.STOCK_TICK_WIDTH = STOCK_TICK_WIDTH;
 exports.THEME_SLOTS = THEME_SLOTS;
+exports.aggregate = aggregate;
 exports.aggregateByCategory = aggregateByCategory;
 exports.assertBarClusterOptions = assertBarClusterOptions;
 exports.autoSeriesColor = autoSeriesColor;
 exports.axisTargetIntervals = axisTargetIntervals;
 exports.buildChartGradientDef = buildChartGradientDef;
+exports.buildHierarchyRoots = buildHierarchyRoots;
+exports.buildWaterfallSteps = buildWaterfallSteps;
 exports.builtInChartStyleXml = builtInChartStyleXml;
 exports.builtInChartTextStyle = builtInChartTextStyle;
 exports.categoryTotals = categoryTotals;
@@ -5244,37 +7066,58 @@ exports.chartCacheValues = chartCacheValues;
 exports.chartColorScheme = chartColorScheme;
 exports.chartColorStyleId = chartColorStyleId;
 exports.chartColorStyleXml = chartColorStyleXml;
+exports.chartErrorBarAmount = chartErrorBarAmount;
+exports.chartExSummary = chartExSummary;
 exports.chartGradientMarkup = chartGradientMarkup;
 exports.chartPaletteColors = chartPaletteColors;
 exports.chartPaletteSeriesColor = chartPaletteSeriesColor;
 exports.chartPaletteSeriesColorChoice = chartPaletteSeriesColorChoice;
+exports.chartSampleVariance = chartSampleVariance;
 exports.chartSourceValues = chartSourceValues;
 exports.chartSpaceKind = chartSpaceKind;
 exports.chartSummaryFromSpace = chartSummaryFromSpace;
 exports.chartSummarySeries = chartSummarySeries;
 exports.chartSummaryView = chartSummaryView;
 exports.chartThemePalette = chartThemePalette;
+exports.chartTrendlineKind = chartTrendlineKind;
+exports.chartTrendlineType = chartTrendlineType;
 exports.clusteredBarGeometry = clusteredBarGeometry;
 exports.computeBoxStats = computeBoxStats;
+exports.computeBubbleRadius = computeBubbleRadius;
+exports.computeHierarchicalSunburstArcs = computeHierarchicalSunburstArcs;
 exports.computeHistogramBins = computeHistogramBins;
 exports.computeLinearRegression = computeLinearRegression;
 exports.computeRSquared = computeRSquared;
 exports.computeRadarPoints = computeRadarPoints;
 exports.computeStackedSeriesPlots = computeStackedSeriesPlots;
+exports.computeSunburstArcs = computeSunburstArcs;
+exports.computeWaterfallRange = computeWaterfallRange;
 exports.effectiveBuiltInChartStyle = effectiveBuiltInChartStyle;
 exports.findChartColorPalette = findChartColorPalette;
+exports.fitChartTrendline = fitChartTrendline;
 exports.fitPolynomial = fitPolynomial;
+exports.formatChartNumber = formatChartNumber;
+exports.formatChartNumberWithColor = formatChartNumberWithColor;
+exports.formatCompactAxisValue = formatCompactAxisValue;
 exports.formatExponentialEquation = formatExponentialEquation;
 exports.formatLinearEquation = formatLinearEquation;
 exports.formatLogarithmicEquation = formatLogarithmicEquation;
 exports.formatPolynomialEquation = formatPolynomialEquation;
 exports.formatPowerEquation = formatPowerEquation;
 exports.formatTrendlineCoefficient = formatTrendlineCoefficient;
+exports.getChartStylePalette = getChartStylePalette;
 exports.groupRowsByCategory = groupRowsByCategory;
 exports.hasManualLayoutFields = hasManualLayoutFields;
+exports.hierarchyBranchLabels = hierarchyBranchLabels;
+exports.impliesAutoTitle = impliesAutoTitle;
+exports.isChartexOnlyType = isChartexOnlyType;
+exports.layoutTreemap = layoutTreemap;
+exports.maxBubbleSize = maxBubbleSize;
+exports.medianBubbleRadius = medianBubbleRadius;
 exports.modulateLuminance = modulateLuminance;
 exports.niceAxisStep = niceAxisStep;
 exports.niceValueAxisBounds = niceValueAxisBounds;
+exports.normalizeLevels = normalizeLevels;
 exports.nudgeOutsideLabels = nudgeOutsideLabels;
 exports.parseChartSpace = parseChartSpace;
 exports.placeBestFitLabel = placeBestFitLabel;
@@ -5287,15 +7130,22 @@ exports.readChartStyle = readChartStyle;
 exports.readDisplayNaAsBlank = readDisplayNaAsBlank;
 exports.removeGradientStop = removeGradientStop;
 exports.renderChartSpaceSvg = renderChartSpaceSvg;
+exports.renderChartSummarySvg = renderChartSummarySvg;
 exports.renderChartSvg = renderChartSvg;
+exports.resolveAutoTitleText = resolveAutoTitleText;
 exports.resolveBlankDisplay = resolveBlankDisplay;
 exports.resolveChartGradient = resolveChartGradient;
 exports.resolveChartStyleDefinition = resolveChartStyleDefinition;
 exports.resolveManualLayoutRect = resolveManualLayoutRect;
 exports.scottBinCount = scottBinCount;
+exports.shade = shade;
 exports.sortGradientStops = sortGradientStops;
 exports.squarify = squarify;
+exports.stockCandle = stockCandle;
+exports.stockSlots = stockSlots;
+exports.sunburstArcPath = sunburstArcPath;
 exports.themeColor = themeColor;
+exports.tint = tint;
 exports.updateGradientStop = updateGradientStop;
 exports.visibleRuns = visibleRuns;
 exports.withChartGradientDirection = withChartGradientDirection;