ooxml-core 1.17.0 → 1.18.0

package/dist/index.cjs

@@ -636,6 +636,8 @@ __export(chart_exports, {
   CHART_ERROR_VALUE_TYPES: () => CHART_ERROR_VALUE_TYPES,
   CHART_GROUP_ELEMENTS: () => CHART_GROUP_ELEMENTS,
   CHART_STYLE_PARTS: () => CHART_STYLE_PARTS,
+  DATA_LABEL_CATEGORY_PERCENT_SEPARATOR: () => DATA_LABEL_CATEGORY_PERCENT_SEPARATOR,
+  DATA_LABEL_SEPARATOR: () => DATA_LABEL_SEPARATOR,
   DEFAULT_BAR_GAP_WIDTH: () => DEFAULT_BAR_GAP_WIDTH,
   DEFAULT_CHART_PALETTE: () => DEFAULT_CHART_PALETTE,
   DEFAULT_THEME_COLORS: () => DEFAULT_THEME_COLORS,
@@ -677,6 +679,7 @@ __export(chart_exports, {
   chartTrendlineKind: () => chartTrendlineKind,
   chartTrendlineType: () => chartTrendlineType,
   clusteredBarGeometry: () => clusteredBarGeometry,
+  composeDataLabelText: () => composeDataLabelText,
   computeBoxStats: () => computeBoxStats,
   computeBubbleRadius: () => computeBubbleRadius,
   computeHierarchicalSunburstArcs: () => computeHierarchicalSunburstArcs,
@@ -731,6 +734,7 @@ __export(chart_exports, {
   resolveBlankDisplay: () => resolveBlankDisplay,
   resolveChartGradient: () => resolveChartGradient,
   resolveChartStyleDefinition: () => resolveChartStyleDefinition,
+  resolveDataLabelFlags: () => resolveDataLabelFlags,
   resolveManualLayoutRect: () => resolveManualLayoutRect,
   scottBinCount: () => scottBinCount,
   shade: () => shade,
@@ -1277,6 +1281,52 @@ function formatChartNumber(value, formatCode) {
   return formatChartNumberWithColor(value, formatCode)?.text;
 }
 
+// chart/data-label-text.ts
+var DATA_LABEL_SEPARATOR = ", ";
+var DATA_LABEL_CATEGORY_PERCENT_SEPARATOR = "\n";
+var FLAG_KEYS = [
+  "showValue",
+  "showCategory",
+  "showSeriesName",
+  "showPercent",
+  "showBubbleSize"
+];
+function resolveDataLabelFlags(levels) {
+  const { point, series, chart } = levels;
+  const picked = {};
+  for (const key of FLAG_KEYS) picked[key] = point?.[key] ?? series?.[key] ?? chart?.[key];
+  const anyDeclared = FLAG_KEYS.some((key) => picked[key] !== void 0);
+  return {
+    showValue: anyDeclared ? picked.showValue === true : levels.siblingOwnsLabels !== true,
+    showCategory: picked.showCategory === true,
+    showSeriesName: picked.showSeriesName === true,
+    showPercent: picked.showPercent === true,
+    showBubbleSize: picked.showBubbleSize === true,
+    separator: point?.separator ?? series?.separator ?? chart?.separator ?? (picked.showCategory === true && picked.showPercent === true ? DATA_LABEL_CATEGORY_PERCENT_SEPARATOR : DATA_LABEL_SEPARATOR)
+  };
+}
+function composeDataLabelText(input) {
+  const { flags, value, numberFormat: numberFormat2 } = input;
+  const parts = [];
+  let valueColor;
+  if (flags.showSeriesName && input.seriesName) parts.push(input.seriesName);
+  if (flags.showCategory && input.category) parts.push(input.category);
+  if (flags.showValue) {
+    const formatted = formatChartNumberWithColor(value, numberFormat2);
+    parts.push(formatted?.text ?? (input.formatValue ?? String)(value, numberFormat2));
+    valueColor = formatted?.color;
+  }
+  if (flags.showPercent) {
+    const base = input.percentBase;
+    parts.push(base > 0 ? `${Math.round(Math.abs(value) / base * 100)}%` : "0%");
+  }
+  if (flags.showBubbleSize && input.bubbleSize !== void 0)
+    parts.push((input.formatBubbleSize ?? String)(input.bubbleSize));
+  const text4 = parts.join(flags.separator);
+  if (text4.length === 0) return void 0;
+  return { text: text4, color: parts.length === 1 && flags.showValue ? valueColor : void 0 };
+}
+
 // chart/auto-title.ts
 var CHART_AUTO_TITLE = "Chart Title";
 var CHARTEX_ONLY_TYPES = /* @__PURE__ */ new Set([
@@ -1424,10 +1474,10 @@ function squarify(nodes, box) {
 
 // chart/hierarchy.ts
 function normalizeLevels(levels, pointCount) {
-  return levels.map((level2) => {
+  return levels.map((level3) => {
     let previous = "";
     return Array.from({ length: pointCount }, (_, index) => {
-      const label = level2[index]?.trim() ?? "";
+      const label = level3[index]?.trim() ?? "";
       if (label) previous = label;
       return label || previous;
     });
@@ -1585,12 +1635,12 @@ function computeSunburstArcs(series, cx2, cy, maxR) {
   });
   return out;
 }
-function hierarchyKey(levels, level2, index) {
-  return levels.slice(level2).map((labels) => labels[index] ?? "").join("\0");
+function hierarchyKey(levels, level3, index) {
+  return levels.slice(level3).map((labels) => labels[index] ?? "").join("\0");
 }
 function computeHierarchicalSunburstArcs(categoryLevels2, values, cx2, cy, maxR) {
-  const levels = categoryLevels2.filter((level2) => level2.length > 0);
-  const leafCount = Math.max(values.length, ...levels.map((level2) => level2.length), 0);
+  const levels = categoryLevels2.filter((level3) => level3.length > 0);
+  const leafCount = Math.max(values.length, ...levels.map((level3) => level3.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);
@@ -1601,15 +1651,15 @@ function computeHierarchicalSunburstArcs(categoryLevels2, values, cx2, cy, maxR)
   const rootLabels = levels[levels.length - 1] ?? [];
   const rootColors = /* @__PURE__ */ new Map();
   const out = [];
-  for (let level2 = levels.length - 1; level2 >= 0; level2--) {
-    const ringIndex = levels.length - 1 - level2;
+  for (let level3 = levels.length - 1; level3 >= 0; level3--) {
+    const ringIndex = levels.length - 1 - level3;
     const innerRadius = ringWidth * (ringIndex + 0.5);
     const outerRadius = ringWidth * (ringIndex + 1.5);
     let start = 0;
     while (start < leafCount) {
-      const key = hierarchyKey(levels, level2, start);
+      const key = hierarchyKey(levels, level3, start);
       let end = start + 1;
-      while (end < leafCount && hierarchyKey(levels, level2, end) === key) end++;
+      while (end < leafCount && hierarchyKey(levels, level3, 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] ?? "";
@@ -1619,8 +1669,8 @@ function computeHierarchicalSunburstArcs(categoryLevels2, values, cx2, cy, maxR)
         colorIndex: rootColors.get(rootLabel) ?? start,
         opacity: Math.max(0.1, 0.9 - ringIndex * 0.1),
         level: ringIndex,
-        label: levels[level2]?.[start] ?? "",
-        ...level2 === 0 && end === start + 1 ? { pointIndex: start } : {},
+        label: levels[level3]?.[start] ?? "",
+        ...level3 === 0 && end === start + 1 ? { pointIndex: start } : {},
         ...arcLabelPlacement(cx2, cy, (innerRadius + outerRadius) / 2, startAngle, endAngle)
       });
       start = end;
@@ -2273,8 +2323,8 @@ function parseXml(xml, options = {}) {
   let parsed;
   try {
     parsed = new xmldom.DOMParser({
-      onError: (level2, message) => {
-        if (level2 !== "warning") parseError = message;
+      onError: (level3, message) => {
+        if (level3 !== "warning") parseError = message;
       }
     }).parseFromString(xml, "application/xml");
   } catch (error) {
@@ -3099,6 +3149,19 @@ function readChartStyle(xml) {
 }
 
 // chart/formatting-nodes.ts
+function chartDataLabelNode(root) {
+  const plot = first(first(root, "chart", NS.c), "plotArea", NS.c);
+  const groups = plot ? elements(plot).filter((node) => node.localName.endsWith("Chart")) : [];
+  const candidates = groups.flatMap((group2) => [
+    ...children(group2, "ser", NS.c).map((ser) => first(ser, "dLbls", NS.c)),
+    first(group2, "dLbls", NS.c)
+  ]);
+  return candidates.find(
+    (node) => node !== void 0 && (first(node, "txPr", NS.c) !== void 0 || elements(node).some(
+      (child3) => child3.localName.startsWith("show") && child3.getAttribute("val") === "1"
+    ))
+  );
+}
 function chartFormattingNodes(root) {
   const chart = first(root, "chart", NS.c);
   const plot = first(chart, "plotArea", NS.c);
@@ -3273,6 +3336,8 @@ function readChartFormatting(root) {
   const entries = Object.fromEntries(
     Object.entries(nodes).flatMap(([name, node]) => node ? [[name, entry2(node)]] : [])
   );
+  const labels = chartDataLabelNode(root);
+  if (labels) entries["dataLabel"] = entry2(labels);
   const builtInStyle = readBuiltInChartStyle(root);
   const textBody = c(root, "txPr");
   const textDefaults = textBody ? {
@@ -5141,7 +5206,7 @@ function dataSourceInner(source) {
     case "multiLvlStrRef": {
       const levels = source.levels ? elementXml(
         "multiLvlStrCache",
-        valXml("ptCount", source.levelPointCount) + source.levels.map((level2) => elementXml("lvl", cachePoints(level2))).join("")
+        valXml("ptCount", source.levelPointCount) + source.levels.map((level3) => elementXml("lvl", cachePoints(level3))).join("")
       ) : "";
       return `<c:multiLvlStrRef>${formula}${levels}</c:multiLvlStrRef>`;
     }
@@ -5404,6 +5469,41 @@ function summaryAnalysis(series) {
   };
 }
 
+// chart/render/summary-labels.ts
+function level(options, custom) {
+  const out = {};
+  if (options.deleted !== void 0) out.deleted = options.deleted;
+  if (options.showValue !== void 0) out.showValue = options.showValue;
+  if (options.showCategoryName !== void 0) out.showCategory = options.showCategoryName;
+  if (options.showSeriesName !== void 0) out.showSeriesName = options.showSeriesName;
+  if (options.showPercent !== void 0) out.showPercent = options.showPercent;
+  if (options.showBubbleSize !== void 0) out.showBubbleSize = options.showBubbleSize;
+  if (options.separator !== void 0) out.separator = options.separator;
+  if (options.position) out.position = options.position;
+  if (options.numberFormat?.formatCode) out.numberFormat = options.numberFormat.formatCode;
+  if (custom?.text !== void 0) out.text = custom.text;
+  return out;
+}
+function shows(levels, point) {
+  const flags = resolveDataLabelFlags({ ...levels, ...point ? { point } : {} });
+  return point?.text !== void 0 || Object.values(flags).some((value) => value === true);
+}
+function summaryDataLabels(series, group2) {
+  const own = series.dataLabels;
+  if (!own && !group2) return void 0;
+  const out = {};
+  if (group2) out.chart = level(group2);
+  if (own) out.series = level(own);
+  const points = {};
+  for (const labels of [group2, own])
+    for (const label of labels?.labels ?? [])
+      if (label.index !== void 0)
+        points[label.index] = { ...points[label.index], ...level(label, label.tx) };
+  if (Object.keys(points).length) out.points = points;
+  if (!shows(out) && !Object.values(points).some((point) => shows(out, point))) return void 0;
+  return out;
+}
+
 // 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";
@@ -5421,7 +5521,7 @@ var GROUP_TYPES = {
   surface: "surface"
 };
 var GROUPINGS = /* @__PURE__ */ new Set(["clustered", "stacked", "percentStacked", "standard"]);
-function chartSummarySeries(source, chartType) {
+function chartSummarySeries(source, chartType, groupLabels) {
   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;
@@ -5429,6 +5529,7 @@ function chartSummarySeries(source, chartType) {
     categories: chartSourceValues(categories),
     values: chartSourceValues(values).map(numeric)
   };
+  if (values?.cache?.formatCode !== void 0) out.numberFormat = values.cache.formatCode;
   if (source.bubbleSizes) {
     out.bubbleSizes = chartSourceValues(source.bubbleSizes).map(numeric);
     if (source.bubbleSizes.formula) out.bubbleSizesRef = source.bubbleSizes.formula;
@@ -5457,6 +5558,8 @@ function chartSummarySeries(source, chartType) {
   }
   if (Object.keys(points).length) out.pointColors = points;
   if (Object.keys(pointFills).length) out.pointFills = pointFills;
+  const dataLabels = summaryDataLabels(source, groupLabels);
+  if (dataLabels) out.dataLabels = dataLabels;
   Object.assign(out, summaryAnalysis(source));
   return out;
 }
@@ -5484,7 +5587,7 @@ function extraGroups(chartSpace, firstType) {
     const type = group2.kind === "bar" ? "column" : group2.kind;
     const entry3 = {
       chartType: type,
-      series: group2.series.map((source) => chartSummarySeries(source, type)),
+      series: group2.series.map((source) => chartSummarySeries(source, type, group2.dataLabels)),
       secondary: valueAxisId(chartSpace, group2.axisIds) !== primary
     };
     if (group2.grouping && GROUPINGS.has(group2.grouping))
@@ -5502,7 +5605,9 @@ 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 series = (group2?.series ?? []).map(
+    (source) => chartSummarySeries(source, chartType, group2?.dataLabels)
+  );
   const summary = {
     chartType,
     series,
@@ -5568,9 +5673,9 @@ function dimension(data, kind, type) {
   const out = { points: [] };
   const formula = text(cx(element2, "f"));
   if (formula) out.formula = formula;
-  const level2 = cx(element2, "lvl");
-  const count = Number(level2?.getAttribute("ptCount") ?? 0);
-  for (const point of level2 ? children(level2, "pt", NS.cx) : []) {
+  const level3 = cx(element2, "lvl");
+  const count = Number(level3?.getAttribute("ptCount") ?? 0);
+  for (const point of level3 ? children(level3, "pt", NS.cx) : []) {
     const index = Number(point.getAttribute("idx") ?? out.points.length);
     if (Number.isInteger(index) && index >= 0) out.points[index] = text(point);
   }
@@ -5579,10 +5684,10 @@ function dimension(data, kind, type) {
 }
 function categoryLevels(data) {
   const element2 = data ? children(data, "strDim", NS.cx).find((d) => (d.getAttribute("type") ?? "") === "cat") : void 0;
-  return (element2 ? children(element2, "lvl", NS.cx) : []).map((level2) => {
+  return (element2 ? children(element2, "lvl", NS.cx) : []).map((level3) => {
     const points = [];
-    const count = Number(level2.getAttribute("ptCount") ?? 0);
-    for (const point of children(level2, "pt", NS.cx)) {
+    const count = Number(level3.getAttribute("ptCount") ?? 0);
+    for (const point of children(level3, "pt", NS.cx)) {
       const index = Number(point.getAttribute("idx") ?? points.length);
       if (Number.isInteger(index) && index >= 0) points[index] = text(point);
     }
@@ -5883,218 +5988,6 @@ function chartBarSpacing(chart) {
   };
 }
 
-// chart/render/chart-svg-bars.ts
-function barLayout(model, frame2) {
-  const count = Math.max(1, model.series.length);
-  const geometry = clusteredBarGeometry(frame2.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, frame2, out, values) {
-  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
-  const { barSize, offset: barOffset } = barLayout(model, frame2);
-  const base = frame2.value(0);
-  const pos = new Array(model.categories.length).fill(0);
-  const neg = new Array(model.categories.length).fill(0);
-  model.series.forEach((s2, si) => {
-    values[si]?.forEach((v, i2) => {
-      if (v === null || i2 >= model.categories.length) return;
-      let from = 0;
-      let to = v;
-      if (stacked) {
-        const acc = v >= 0 ? pos : neg;
-        from = acc[i2] ?? 0;
-        to = from + v;
-        acc[i2] = to;
-      }
-      const a2 = stacked ? frame2.value(from) : base;
-      const b = frame2.value(to);
-      const offset = barOffset(si);
-      const center = frame2.band(i2);
-      const width = model.horizontal ? Math.abs(b - a2) : barSize;
-      const height = model.horizontal ? barSize : Math.abs(b - a2);
-      let color = s2.pointColors?.[i2] ?? s2.color;
-      const gradient = s2.pointGradients?.[i2] ?? (s2.pointColors?.[i2] === void 0 ? s2.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${i2}$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="${i2}">`);
-      if (model.horizontal)
-        out.push(
-          rect(Math.min(a2, b), center + offset, Math.abs(b - a2), barSize, color, s2.shadowFilter)
-        );
-      else
-        out.push(
-          rect(center + offset, Math.min(a2, b), barSize, Math.abs(b - a2), color, s2.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}"/>`
-    );
-  }
-}
-function errorBar(bars2, at2, 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, at2.displayIndex, at2.sourceIndex, side);
-    const sign = side === "plus" ? 1 : -1;
-    const [x1, y1] = plane(at2.x, at2.y);
-    const [x2, y2] = bars2.direction === "x" ? plane(at2.x + sign * amount, at2.y) : plane(at2.x, at2.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)
-    );
-  }
-}
-function categoryAnalysis(model, frame2, out) {
-  if (model.grouping === "stacked" || model.grouping === "percentStacked") return;
-  const plane = (x, y) => model.horizontal ? [frame2.value(y), frame2.band(x - 1)] : [frame2.band(x - 1), frame2.value(y)];
-  const barred = model.type === "bar" || model.type === "column";
-  const layout = barred ? barLayout(model, frame2) : 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 [px3, py] = plane(x, y);
-      return model.horizontal ? [px3, py + shift] : [px3 + shift, py];
-    };
-    seriesAnalysis(series, si, (i2) => i2 + 1, plane, barPlane, true, out);
-  });
-}
-function scatterAnalysis(model, px3, py, out) {
-  const plane = (x, y) => [px3(x), py(y)];
-  model.series.forEach((series, si) => {
-    if (!series.trendlines && !series.errorBars) return;
-    seriesAnalysis(series, si, (i2) => series.xValues?.[i2] ?? null, plane, plane, false, out);
-  });
-}
-
-// chart/render/chart-scale.ts
-var clean = (n2) => Number(n2.toPrecision(12));
-function* units(raw2) {
-  let exp = Math.floor(Math.log10(raw2)) - 1;
-  for (; ; ) {
-    const base = 10 ** exp;
-    for (const m of [1, 2, 5]) yield clean(m * base);
-    exp++;
-  }
-}
-function niceScale(dataMin, dataMax, options = {}) {
-  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
-  let lo = Number.isFinite(dataMin) ? dataMin : 0;
-  let hi = Number.isFinite(dataMax) ? dataMax : 0;
-  if (lo > hi) [lo, hi] = [hi, lo];
-  if (lo === hi) {
-    if (lo === 0) hi = 1;
-    else if (options.noZero) {
-      const pad2 = Math.abs(lo) * 0.1 || 1;
-      lo -= pad2;
-      hi += pad2;
-    } else if (lo > 0) lo = 0;
-    else hi = 0;
-  }
-  let fixedLo = false;
-  let fixedHi = false;
-  if (!options.noZero) {
-    if (lo >= 0 && hi - lo >= hi / 6) {
-      lo = 0;
-      fixedLo = true;
-    } else if (hi <= 0 && hi - lo >= -lo / 6) {
-      hi = 0;
-      fixedHi = true;
-    }
-  }
-  const range = hi - lo;
-  const top = fixedHi ? hi : hi + range * 0.05;
-  const bottom = fixedLo ? lo : lo - range * 0.05;
-  for (const unit of units(range / maxIntervals)) {
-    const min = fixedLo ? lo : Math.floor(clean(bottom / unit)) * unit;
-    const max = fixedHi ? hi : Math.ceil(clean(top / unit)) * unit;
-    const intervals = Math.round((max - min) / unit);
-    if (intervals <= maxIntervals && intervals > 0) {
-      const ticks = [];
-      for (let i2 = 0; i2 <= intervals; i2++) ticks.push(clean(min + i2 * unit));
-      return { min: clean(min), max: clean(max), majorUnit: unit, ticks };
-    }
-  }
-  return { min: lo, max: hi, majorUnit: range, ticks: [lo, hi] };
-}
-var PERCENT_SCALE = {
-  min: 0,
-  max: 1,
-  majorUnit: 0.1,
-  ticks: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
-};
-function formatAxisValue(value, percent = false) {
-  if (percent) return `${clean(value * 100)}%`;
-  const v = clean(value);
-  if (Math.abs(v) >= 1e15 || v !== 0 && Math.abs(v) < 1e-6)
-    return v.toExponential(2).replace("e+", "E+").replace("e-", "E-");
-  const [int2 = "0", frac] = String(Math.abs(v)).split(".");
-  const grouped2 = int2.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-  return `${v < 0 ? "-" : ""}${grouped2}${frac ? `.${frac}` : ""}`;
-}
-
 // drawingml/drawing-color-css.ts
 function drawingColorCss(value) {
   if (!value || value.alpha === 1) return value?.hex;
@@ -6112,36 +6005,6 @@ var TWIPS_PER_POINT = 20;
 var TWIPS_PER_INCH = 1440;
 var PIXELS_PER_INCH = 96;
 
-// 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(s2, format) {
-  const num2 = format.number;
-  return `<feDropShadow dx="${num2(s2.dx)}" dy="${num2(s2.dy)}" stdDeviation="${num2(s2.blur / 2)}" flood-color="${format.color(s2.color, "#000000")}" flood-opacity="${num2(s2.opacity)}" result="shadow"/>`;
-}
-
 // chart/render/theme-palette.ts
 var THEME_SLOTS = [
   "lt1",
@@ -6203,6 +6066,36 @@ function autoSeriesColor(theme, index) {
   return chartPaletteSeriesColor(findChartColorPalette(10), i2, i2 + 1, chartColorScheme(theme));
 }
 
+// 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(s2, format) {
+  const num2 = format.number;
+  return `<feDropShadow dx="${num2(s2.dx)}" dy="${num2(s2.dy)}" stdDeviation="${num2(s2.blur / 2)}" flood-color="${format.color(s2.color, "#000000")}" flood-opacity="${num2(s2.opacity)}" result="shadow"/>`;
+}
+
 // chart/text-inheritance.ts
 var TEXT_KEYS = [
   "fontSize",
@@ -6291,6 +6184,444 @@ function chartAppearance(chart, theme) {
   return out;
 }
 
+// text/css-font-family.ts
+var FALLBACKS = {
+  calibri: '"Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
+  "calibri light": '"Calibri Light", "Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
+  cambria: '"Cambria", "Caladea", Georgia, serif',
+  arial: 'Arial, "Liberation Sans", Helvetica, sans-serif',
+  "times new roman": '"Times New Roman", "Liberation Serif", Times, serif',
+  "courier new": '"Courier New", "Liberation Mono", monospace',
+  aptos: '"Aptos", "Calibri", "Carlito", "Segoe UI", sans-serif'
+};
+function cssFontFamily(name) {
+  const known = FALLBACKS[name.toLowerCase()];
+  if (known) return known;
+  const quoted = `"${name.replace(/["\\]/g, "")}"`;
+  return `${quoted}, "Calibri", "Carlito", "Segoe UI", sans-serif`;
+}
+
+// chart/render/chart-svg-appearance.ts
+var nextPaintId = 0;
+function chartGradientPaint(model, width = 1024, height = 768) {
+  const prefix = `xlsx-chart-${++nextPaintId}`;
+  const appearance = { ...model.appearance };
+  const defs = [];
+  const shadowPaint = (shadow, suffix) => {
+    const id = `${prefix}-${suffix}`;
+    const pad2 = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
+    defs.push(
+      `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad2)}" y="${n(-pad2)}" width="${n(width + pad2 * 2)}" height="${n(height + pad2 * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
+    );
+    return `url(#${id})`;
+  };
+  for (const [part, entry3] of Object.entries(appearance)) {
+    if (entry3?.textShadow)
+      appearance[part] = {
+        ...entry3,
+        textShadowFilter: shadowPaint(entry3.textShadow, `${part}-text-shadow`)
+      };
+  }
+  const paint2 = (gradient, suffix, bounds2) => {
+    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds2);
+    defs.push(chartGradientMarkup(def));
+    return `url(#${def.id})`;
+  };
+  for (const part of ["chartArea", "plotArea"]) {
+    const entry3 = appearance[part];
+    if (!entry3?.gradient) continue;
+    if (part === "plotArea" && ["circle", "shape"].includes(entry3.gradient.path ?? "")) continue;
+    appearance[part] = {
+      ...entry3,
+      fillColor: 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 bounds2 = model.type === "bar" || model.type === "column" ? { width: 1, height: 1, shape: "rect" } : void 0;
+    if (source.gradient) view.color = paint2(source.gradient, `s${index}`, bounds2);
+    if (source.pointGradients) {
+      view.pointColors = [...source.pointColors ?? []];
+      for (const [key, gradient] of Object.entries(source.pointGradients))
+        view.pointColors[Number(key)] = paint2(gradient, `s${index}-p${key}`, bounds2);
+    }
+    return view;
+  });
+  return defs.length ? { model: { ...model, appearance, series }, defs: `<defs>${defs.join("")}</defs>` } : { model, defs: "" };
+}
+function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
+  const entry3 = model.appearance?.[part];
+  return {
+    size: entry3?.fontSize === void 0 ? fallbackSize : chartPointsToPixels(entry3.fontSize),
+    ...entry3?.color === void 0 ? {} : { fill: entry3.color },
+    ...entry3?.bold === void 0 ? {} : { weight: entry3.bold ? "bold" : "normal" },
+    ...entry3?.italic === void 0 ? {} : { italic: entry3.italic },
+    ...entry3?.underline === void 0 ? {} : { underline: entry3.underline },
+    ...entry3?.typeface === void 0 ? {} : { family: cssFontFamily(entry3.typeface) },
+    ...entry3?.textShadowFilter === void 0 ? {} : { filter: entry3.textShadowFilter }
+  };
+}
+function chartStroke(model, part) {
+  const entry3 = model.appearance?.[part];
+  return {
+    color: entry3?.axisVisible === false ? "none" : entry3?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
+    width: entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth)
+  };
+}
+function chartAreaRect(model, part, area) {
+  if (area.w <= 0 || area.h <= 0) return "";
+  const entry3 = model.appearance?.[part];
+  let fill = entry3?.fillColor ?? (part === "chartArea" ? "#FFFFFF" : "none");
+  let defs = "";
+  if (part !== "chartArea" && entry3?.gradient && (part !== "plotArea" || ["circle", "shape"].includes(entry3.gradient.path ?? ""))) {
+    const def = buildChartGradientDef(`xlsx-chart-${++nextPaintId}-${part}`, entry3.gradient, {
+      width: area.w,
+      height: area.h,
+      shape: "rect"
+    });
+    defs = `<defs>${chartGradientMarkup(def)}</defs>`;
+    fill = `url(#${def.id})`;
+  }
+  const stroke = entry3?.lineColor ?? "none";
+  if (fill === "none" && stroke === "none") return "";
+  const width = entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth);
+  return `${defs}<rect x="${n(area.x)}" y="${n(area.y)}" width="${n(area.w)}" height="${n(area.h)}" fill="${esc(fill)}" stroke="${esc(stroke)}" stroke-width="${n(width)}" data-chart-part="${part}"/>`;
+}
+
+// chart/render/chart-svg-labels.ts
+var GAP = 3;
+var LINE = 1.2;
+var NAMED_COLORS = /^(black|blue|cyan|green|magenta|red|white|yellow)$/iu;
+function measure(model, label) {
+  const attrs = chartTextAttributes(model, "dataLabel", 10);
+  const size = attrs.size ?? 10;
+  const lines = label.text.split("\n");
+  return {
+    lines,
+    size,
+    w: Math.max(...lines.map((l) => textWidth(l, size))),
+    h: lines.length * size * LINE,
+    attrs
+  };
+}
+function draw(m, label, x, y, anchor, out) {
+  const fill = label.color && NAMED_COLORS.test(label.color) ? label.color.toLowerCase() : void 0;
+  m.lines.forEach((line3, k) => {
+    const lineY = y - m.h / 2 + (k + 0.5) * m.size * LINE + m.size * 0.35;
+    out.push(text2(x, lineY, line3, { ...m.attrs, ...fill ? { fill } : {}, anchor }));
+  });
+}
+function barLabels(model, marks, out) {
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  for (const mark of marks) {
+    const label = mark.series.labels?.[mark.index];
+    if (!label) continue;
+    const m = measure(model, label);
+    let position = label.position ?? (stacked ? "ctr" : "outEnd");
+    if (stacked && position === "outEnd") position = "ctr";
+    const cx2 = mark.x + mark.w / 2;
+    const cy = mark.y + mark.h / 2;
+    if (model.horizontal) {
+      const end = mark.negative ? mark.x : mark.x + mark.w;
+      const base = mark.negative ? mark.x + mark.w : mark.x;
+      const dir2 = mark.negative ? -1 : 1;
+      const side = (at2, outward) => [
+        at2 + (outward ? dir2 : -dir2) * GAP,
+        (outward ? dir2 : -dir2) > 0 ? "start" : "end"
+      ];
+      const [x, anchor] = position === "ctr" ? [cx2, "middle"] : position === "inEnd" ? side(end, false) : position === "inBase" ? side(base, true) : side(end, true);
+      draw(m, label, x, cy, anchor, out);
+      continue;
+    }
+    const top = mark.negative ? mark.y + mark.h : mark.y;
+    const bottom = mark.negative ? mark.y : mark.y + mark.h;
+    const dir = mark.negative ? 1 : -1;
+    const y = position === "ctr" ? cy : position === "inEnd" ? top - dir * (GAP + m.h / 2) : position === "inBase" ? bottom + dir * (GAP + m.h / 2) : top + dir * (GAP + m.h / 2);
+    draw(m, label, cx2, y, "middle", out);
+  }
+}
+function pointLabels(model, marks, out) {
+  for (const mark of marks) {
+    const label = mark.series.labels?.[mark.index];
+    if (!label) continue;
+    const m = measure(model, label);
+    const reach = mark.radius + GAP;
+    switch (model.type === "area" ? "ctr" : label.position ?? "r") {
+      case "ctr":
+        draw(m, label, mark.x, mark.y, "middle", out);
+        break;
+      case "t":
+        draw(m, label, mark.x, mark.y - reach - m.h / 2, "middle", out);
+        break;
+      case "b":
+        draw(m, label, mark.x, mark.y + reach + m.h / 2, "middle", out);
+        break;
+      case "l":
+        draw(m, label, mark.x - reach, mark.y, "end", out);
+        break;
+      default:
+        draw(m, label, mark.x + reach, mark.y, "start", out);
+    }
+  }
+}
+function sliceLabels(model, marks, out) {
+  for (const mark of marks) {
+    const label = mark.series.labels?.[mark.index];
+    if (!label) continue;
+    const m = measure(model, label);
+    const mid = (mark.start + mark.end) / 2;
+    const ux = Math.sin(mid);
+    const uy = -Math.cos(mid);
+    const place = (radius) => [
+      mark.cx + radius * ux,
+      mark.cy + radius * uy
+    ];
+    const position = model.type === "doughnut" ? "ctr" : label.position ?? "bestFit";
+    let x;
+    let y;
+    if (position === "ctr") [x, y] = place(mark.inner + (mark.outer - mark.inner) / 2);
+    else if (position === "inEnd") {
+      const extent = Math.abs(ux) * m.w / 2 + Math.abs(uy) * m.h / 2;
+      [x, y] = place(Math.max(0, mark.outer - GAP - extent));
+    } else if (position === "outEnd") {
+      const extent = Math.abs(ux) * m.w / 2 + Math.abs(uy) * m.h / 2;
+      [x, y] = place(mark.outer + GAP + extent);
+    } else {
+      const placed2 = placeBestFitLabel(
+        {
+          cx: mark.cx,
+          cy: mark.cy,
+          outerR: mark.outer,
+          startAngle: mark.start - Math.PI / 2,
+          endAngle: mark.end - Math.PI / 2
+        },
+        m.w,
+        m.h
+      );
+      x = placed2.x;
+      y = placed2.y;
+    }
+    draw(m, label, x, y, "middle", out);
+  }
+}
+function hasOutsideLabels(model) {
+  return model.series.some(
+    (s2) => s2.labels?.some(
+      (l) => l !== void 0 && ["bestFit", "outEnd"].includes(l.position ?? "bestFit")
+    )
+  );
+}
+
+// chart/render/chart-svg-bars.ts
+function barLayout(model, frame2) {
+  const count = Math.max(1, model.series.length);
+  const geometry = clusteredBarGeometry(frame2.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, frame2, out, values) {
+  const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
+  const { barSize, offset: barOffset } = barLayout(model, frame2);
+  const base = frame2.value(0);
+  const pos = new Array(model.categories.length).fill(0);
+  const neg = new Array(model.categories.length).fill(0);
+  const marks = [];
+  model.series.forEach((s2, si) => {
+    values[si]?.forEach((v, i2) => {
+      if (v === null || i2 >= model.categories.length) return;
+      let from = 0;
+      let to = v;
+      if (stacked) {
+        const acc = v >= 0 ? pos : neg;
+        from = acc[i2] ?? 0;
+        to = from + v;
+        acc[i2] = to;
+      }
+      const a2 = stacked ? frame2.value(from) : base;
+      const b = frame2.value(to);
+      const offset = barOffset(si);
+      const center = frame2.band(i2);
+      const width = model.horizontal ? Math.abs(b - a2) : barSize;
+      const height = model.horizontal ? barSize : Math.abs(b - a2);
+      let color = s2.pointColors?.[i2] ?? s2.color;
+      const gradient = s2.pointGradients?.[i2] ?? (s2.pointColors?.[i2] === void 0 ? s2.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${i2}$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="${i2}">`);
+      const box = model.horizontal ? { x: Math.min(a2, b), y: center + offset, w: Math.abs(b - a2), h: barSize } : { x: center + offset, y: Math.min(a2, b), w: barSize, h: Math.abs(b - a2) };
+      out.push(rect(box.x, box.y, box.w, box.h, color, s2.shadowFilter));
+      out.push("</g>");
+      marks.push({ series: s2, index: i2, ...box, negative: v < 0 });
+    });
+  });
+  barLabels(model, marks, out);
+}
+
+// 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}"/>`
+    );
+  }
+}
+function errorBar(bars2, at2, 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, at2.displayIndex, at2.sourceIndex, side);
+    const sign = side === "plus" ? 1 : -1;
+    const [x1, y1] = plane(at2.x, at2.y);
+    const [x2, y2] = bars2.direction === "x" ? plane(at2.x + sign * amount, at2.y) : plane(at2.x, at2.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)
+    );
+  }
+}
+function categoryAnalysis(model, frame2, out) {
+  if (model.grouping === "stacked" || model.grouping === "percentStacked") return;
+  const plane = (x, y) => model.horizontal ? [frame2.value(y), frame2.band(x - 1)] : [frame2.band(x - 1), frame2.value(y)];
+  const barred = model.type === "bar" || model.type === "column";
+  const layout = barred ? barLayout(model, frame2) : 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 [px3, py] = plane(x, y);
+      return model.horizontal ? [px3, py + shift] : [px3 + shift, py];
+    };
+    seriesAnalysis(series, si, (i2) => i2 + 1, plane, barPlane, true, out);
+  });
+}
+function scatterAnalysis(model, px3, py, out) {
+  const plane = (x, y) => [px3(x), py(y)];
+  model.series.forEach((series, si) => {
+    if (!series.trendlines && !series.errorBars) return;
+    seriesAnalysis(series, si, (i2) => series.xValues?.[i2] ?? null, plane, plane, false, out);
+  });
+}
+
+// chart/render/chart-scale.ts
+var clean = (n2) => Number(n2.toPrecision(12));
+function* units(raw2) {
+  let exp = Math.floor(Math.log10(raw2)) - 1;
+  for (; ; ) {
+    const base = 10 ** exp;
+    for (const m of [1, 2, 5]) yield clean(m * base);
+    exp++;
+  }
+}
+function niceScale(dataMin, dataMax, options = {}) {
+  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
+  let lo = Number.isFinite(dataMin) ? dataMin : 0;
+  let hi = Number.isFinite(dataMax) ? dataMax : 0;
+  if (lo > hi) [lo, hi] = [hi, lo];
+  if (lo === hi) {
+    if (lo === 0) hi = 1;
+    else if (options.noZero) {
+      const pad2 = Math.abs(lo) * 0.1 || 1;
+      lo -= pad2;
+      hi += pad2;
+    } else if (lo > 0) lo = 0;
+    else hi = 0;
+  }
+  let fixedLo = false;
+  let fixedHi = false;
+  if (!options.noZero) {
+    if (lo >= 0 && hi - lo >= hi / 6) {
+      lo = 0;
+      fixedLo = true;
+    } else if (hi <= 0 && hi - lo >= -lo / 6) {
+      hi = 0;
+      fixedHi = true;
+    }
+  }
+  const range = hi - lo;
+  const top = fixedHi ? hi : hi + range * 0.05;
+  const bottom = fixedLo ? lo : lo - range * 0.05;
+  for (const unit of units(range / maxIntervals)) {
+    const min = fixedLo ? lo : Math.floor(clean(bottom / unit)) * unit;
+    const max = fixedHi ? hi : Math.ceil(clean(top / unit)) * unit;
+    const intervals = Math.round((max - min) / unit);
+    if (intervals <= maxIntervals && intervals > 0) {
+      const ticks = [];
+      for (let i2 = 0; i2 <= intervals; i2++) ticks.push(clean(min + i2 * unit));
+      return { min: clean(min), max: clean(max), majorUnit: unit, ticks };
+    }
+  }
+  return { min: lo, max: hi, majorUnit: range, ticks: [lo, hi] };
+}
+var PERCENT_SCALE = {
+  min: 0,
+  max: 1,
+  majorUnit: 0.1,
+  ticks: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+};
+function formatAxisValue(value, percent = false) {
+  if (percent) return `${clean(value * 100)}%`;
+  const v = clean(value);
+  if (Math.abs(v) >= 1e15 || v !== 0 && Math.abs(v) < 1e-6)
+    return v.toExponential(2).replace("e+", "E+").replace("e-", "E-");
+  const [int2 = "0", frac] = String(Math.abs(v)).split(".");
+  const grouped2 = int2.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${v < 0 ? "-" : ""}${grouped2}${frac ? `.${frac}` : ""}`;
+}
+
 // chart/render/chart-view-analysis.ts
 function strokeOf(line3, fallback, resolve) {
   if (line3?.fill?.kind === "none") return void 0;
@@ -6547,6 +6878,64 @@ function chartTitleText(chart, theme) {
   };
 }
 
+// chart/render/chart-view-labels.ts
+function labelsOf(source, view, categories, numberFormat2) {
+  const { chart, series, points } = source;
+  if ((series?.deleted ?? chart?.deleted) === true) return void 0;
+  const percentBase = view.values.reduce(
+    (sum, v) => sum + (v === null ? 0 : Math.abs(v)),
+    0
+  );
+  const out = [];
+  let any = false;
+  view.values.forEach((value, i2) => {
+    const point = points?.[i2];
+    if (value === null || point?.deleted === true) return;
+    const position = point?.position ?? series?.position ?? chart?.position;
+    const x = view.xValues?.[i2];
+    const category = x === void 0 || x === null ? categories[i2] : formatAxisValue(x);
+    let built;
+    if (point?.text !== void 0) built = { text: point.text };
+    else {
+      const flags = resolveDataLabelFlags({
+        ...point ? { point } : {},
+        ...series ? { series } : {},
+        ...chart ? { chart } : {}
+      });
+      built = composeDataLabelText({
+        flags,
+        seriesName: view.name,
+        category,
+        value,
+        numberFormat: point?.numberFormat ?? series?.numberFormat ?? chart?.numberFormat ?? numberFormat2,
+        percentBase,
+        bubbleSize: view.sizes?.[i2] ?? void 0,
+        formatValue: (v) => formatAxisValue(v),
+        formatBubbleSize: (size) => formatAxisValue(size)
+      });
+    }
+    if (!built) return;
+    any = true;
+    out[i2] = {
+      text: built.text,
+      ...position ? { position } : {},
+      ...built.color ? { color: built.color } : {}
+    };
+  });
+  return any ? out : void 0;
+}
+function applyDataLabels(model, sources, extra) {
+  const apply = (source, view) => {
+    if (!source?.dataLabels) return;
+    const labels = labelsOf(source.dataLabels, view, model.categories, source.numberFormat);
+    if (labels) view.labels = labels;
+  };
+  model.series.forEach((view, i2) => apply(sources[i2], view));
+  model.extraGroups?.forEach(
+    (group2, g2) => group2.series.forEach((view, i2) => apply(extra[g2]?.series[i2], view))
+  );
+}
+
 // chart/render/chart-view-ex.ts
 function groupsAxis(groups, categories) {
   let min = Infinity;
@@ -6732,115 +7121,11 @@ function chartSummaryView(chart, theme, options = {}) {
     chartExtraView(chart, model, ctx, total, collect);
   if (type === "waterfall") waterfallView(chart, model, ctx);
   else if (!byPoint) model.valueAxis = valueAxis(model);
+  applyDataLabels(model, chart.series, extra);
   chartExtraAxes(model);
   return model;
 }
 
-// text/css-font-family.ts
-var FALLBACKS = {
-  calibri: '"Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
-  "calibri light": '"Calibri Light", "Calibri", "Carlito", "Segoe UI", Arial, sans-serif',
-  cambria: '"Cambria", "Caladea", Georgia, serif',
-  arial: 'Arial, "Liberation Sans", Helvetica, sans-serif',
-  "times new roman": '"Times New Roman", "Liberation Serif", Times, serif',
-  "courier new": '"Courier New", "Liberation Mono", monospace',
-  aptos: '"Aptos", "Calibri", "Carlito", "Segoe UI", sans-serif'
-};
-function cssFontFamily(name) {
-  const known = FALLBACKS[name.toLowerCase()];
-  if (known) return known;
-  const quoted = `"${name.replace(/["\\]/g, "")}"`;
-  return `${quoted}, "Calibri", "Carlito", "Segoe UI", sans-serif`;
-}
-
-// chart/render/chart-svg-appearance.ts
-var nextPaintId = 0;
-function chartGradientPaint(model, width = 1024, height = 768) {
-  const prefix = `xlsx-chart-${++nextPaintId}`;
-  const appearance = { ...model.appearance };
-  const defs = [];
-  const shadowPaint = (shadow, suffix) => {
-    const id = `${prefix}-${suffix}`;
-    const pad2 = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
-    defs.push(
-      `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad2)}" y="${n(-pad2)}" width="${n(width + pad2 * 2)}" height="${n(height + pad2 * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
-    );
-    return `url(#${id})`;
-  };
-  for (const [part, entry3] of Object.entries(appearance)) {
-    if (entry3?.textShadow)
-      appearance[part] = {
-        ...entry3,
-        textShadowFilter: shadowPaint(entry3.textShadow, `${part}-text-shadow`)
-      };
-  }
-  const paint2 = (gradient, suffix, bounds2) => {
-    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds2);
-    defs.push(chartGradientMarkup(def));
-    return `url(#${def.id})`;
-  };
-  for (const part of ["chartArea", "plotArea"]) {
-    const entry3 = appearance[part];
-    if (!entry3?.gradient) continue;
-    if (part === "plotArea" && ["circle", "shape"].includes(entry3.gradient.path ?? "")) continue;
-    appearance[part] = {
-      ...entry3,
-      fillColor: 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 bounds2 = model.type === "bar" || model.type === "column" ? { width: 1, height: 1, shape: "rect" } : void 0;
-    if (source.gradient) view.color = paint2(source.gradient, `s${index}`, bounds2);
-    if (source.pointGradients) {
-      view.pointColors = [...source.pointColors ?? []];
-      for (const [key, gradient] of Object.entries(source.pointGradients))
-        view.pointColors[Number(key)] = paint2(gradient, `s${index}-p${key}`, bounds2);
-    }
-    return view;
-  });
-  return defs.length ? { model: { ...model, appearance, series }, defs: `<defs>${defs.join("")}</defs>` } : { model, defs: "" };
-}
-function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
-  const entry3 = model.appearance?.[part];
-  return {
-    size: entry3?.fontSize === void 0 ? fallbackSize : chartPointsToPixels(entry3.fontSize),
-    ...entry3?.color === void 0 ? {} : { fill: entry3.color },
-    ...entry3?.bold === void 0 ? {} : { weight: entry3.bold ? "bold" : "normal" },
-    ...entry3?.italic === void 0 ? {} : { italic: entry3.italic },
-    ...entry3?.underline === void 0 ? {} : { underline: entry3.underline },
-    ...entry3?.typeface === void 0 ? {} : { family: cssFontFamily(entry3.typeface) },
-    ...entry3?.textShadowFilter === void 0 ? {} : { filter: entry3.textShadowFilter }
-  };
-}
-function chartStroke(model, part) {
-  const entry3 = model.appearance?.[part];
-  return {
-    color: entry3?.axisVisible === false ? "none" : entry3?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
-    width: entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth)
-  };
-}
-function chartAreaRect(model, part, area) {
-  if (area.w <= 0 || area.h <= 0) return "";
-  const entry3 = model.appearance?.[part];
-  let fill = entry3?.fillColor ?? (part === "chartArea" ? "#FFFFFF" : "none");
-  let defs = "";
-  if (part !== "chartArea" && entry3?.gradient && (part !== "plotArea" || ["circle", "shape"].includes(entry3.gradient.path ?? ""))) {
-    const def = buildChartGradientDef(`xlsx-chart-${++nextPaintId}-${part}`, entry3.gradient, {
-      width: area.w,
-      height: area.h,
-      shape: "rect"
-    });
-    defs = `<defs>${chartGradientMarkup(def)}</defs>`;
-    fill = `url(#${def.id})`;
-  }
-  const stroke = entry3?.lineColor ?? "none";
-  if (fill === "none" && stroke === "none") return "";
-  const width = entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth);
-  return `${defs}<rect x="${n(area.x)}" y="${n(area.y)}" width="${n(area.w)}" height="${n(area.h)}" fill="${esc(fill)}" stroke="${esc(stroke)}" stroke-width="${n(width)}" data-chart-part="${part}"/>`;
-}
-
 // chart/render/chart-svg-cartesian.ts
 function cartesianAxes(model, area, out) {
   const scale = model.valueAxis;
@@ -6959,6 +7244,7 @@ function linesAndAreas(model, frame2, out) {
   const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
   const acc = new Array(model.categories.length).fill(0);
   const area = model.type === "area";
+  const marks = [];
   const layers2 = [];
   model.series.forEach((s2, si) => {
     const points = [];
@@ -6973,6 +7259,13 @@ function linesAndAreas(model, frame2, out) {
       const top = below2 + (v ?? 0);
       if (stacked) acc[i2] = top;
       points.push([frame2.band(i2), frame2.value(top)]);
+      marks.push({
+        series: s2,
+        index: i2,
+        x: frame2.band(i2),
+        y: frame2.value(top),
+        radius: area ? 0 : 3
+      });
       lower.push([frame2.band(i2), frame2.value(below2)]);
     });
     layers2.push({
@@ -7005,6 +7298,7 @@ function linesAndAreas(model, frame2, out) {
       if (!Number.isNaN(x))
         out.push(`<circle cx="${n(x)}" cy="${n(y)}" r="2.5" fill="${color}"${filter}/>`);
   }
+  pointLabels(model, marks, out);
 }
 
 // chart/render/chart-svg-xy.ts
@@ -7074,6 +7368,7 @@ 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));
+  const marks = [];
   for (const [si, s2] of model.series.entries())
     s2.values.forEach((v, i2) => {
       const x = s2.xValues?.[i2] ?? null;
@@ -7082,14 +7377,17 @@ function scatter(model, area, out) {
       const fill = s2.pointColors?.[i2] ?? s2.color;
       if (!bubble) {
         out.push(`<circle cx="${n(px3(x))}" cy="${n(py(v))}" r="3" fill="${fill}"${filter}/>`);
+        marks.push({ series: s2, index: i2, x: px3(x), y: py(v), radius: 3 });
         return;
       }
       const r = radiusOf(s2.sizes?.[i2] ?? void 0);
       if (r === void 0) return;
+      marks.push({ series: s2, index: i2, x: px3(x), y: py(v), radius: r });
       out.push(
         `<circle cx="${n(px3(x))}" cy="${n(py(v))}" r="${n(r)}" fill="${fill}" fill-opacity="0.6" data-chart-series="${si}" data-chart-point="${i2}"${filter}/>`
       );
     });
+  pointLabels(model, marks, out);
   scatterAnalysis(model, px3, py, out);
 }
 
@@ -7254,7 +7552,9 @@ function pieSvg(model, area) {
   const out = [chartAreaRect(model, "plotArea", area)];
   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 margin = hasOutsideLabels(model) ? Math.min(area.w, area.h) * 0.12 : 0;
+  const radius = Math.max(1, Math.min(area.w, area.h) / 2 - 4 - margin);
+  const slices = [];
   const rings = model.type === "doughnut" ? model.series : model.series.slice(0, 1);
   const hole = model.type === "doughnut" ? radius * 0.5 : 0;
   const ringSize = (radius - hole) / Math.max(1, rings.length);
@@ -7271,9 +7571,20 @@ function pieSvg(model, area) {
       out.push(
         `<path d="${slicePath(cx2, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : ""}/>`
       );
+      slices.push({
+        series: s2,
+        index: i2,
+        cx: cx2,
+        cy,
+        outer,
+        inner,
+        start: angle,
+        end: angle + sweep
+      });
       angle += sweep;
     });
   });
+  sliceLabels(model, slices, out);
   return out.join("");
 }
 function radarSvg(model, area) {
@@ -7319,12 +7630,16 @@ function radarSvg(model, area) {
         })
       );
   });
+  const marks = [];
   for (const s2 of model.series) {
-    const points = s2.values.slice(0, count).map((v, i2) => polar(cx2, cy, r(v ?? scale.min), angle(i2))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+    const vertices = s2.values.slice(0, count).map((v, i2) => polar(cx2, cy, r(v ?? scale.min), angle(i2)));
+    vertices.forEach(([x, y], i2) => marks.push({ series: s2, index: i2, x, y, radius: 3 }));
+    const points = vertices.map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
     out.push(
       `<polygon points="${points}" fill="none" stroke="${s2.color}" stroke-width="2"${s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : ""}/>`
     );
   }
+  pointLabels(model, marks, out);
   return out.join("");
 }
 
@@ -7576,7 +7891,7 @@ function automaticLegend(model, area, out, options, bounds2) {
 
 // text/wrap-styled-runs.ts
 var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function wrapStyledRuns(runs, maxWidth, measure3, options = {}) {
+function wrapStyledRuns(runs, maxWidth, measure4, options = {}) {
   const groups = [];
   for (const [source, run2] of runs.entries()) {
     for (const token of run2.text.split(/(\r\n|[\r\n]|[ \t]+)/u).filter(Boolean)) {
@@ -7599,7 +7914,7 @@ function wrapStyledRuns(runs, maxWidth, measure3, options = {}) {
     return result2;
   };
   const width = (pieces) => pieces.reduce((sum, piece) => {
-    const advance = measure3(piece.text, piece.run);
+    const advance = measure4(piece.text, piece.run);
     return sum + (Number.isFinite(advance) && advance >= 0 ? advance : 0);
   }, 0);
   const result = [];
@@ -20790,9 +21105,9 @@ function paragraphsAt(text4, sizePt) {
   const afterParent = (text4.spaceAfterParent ?? DEFAULT_SPACE_AFTER_PARENT) / 100;
   const afterChild = (text4.spaceAfterChild ?? DEFAULT_SPACE_AFTER_CHILD) / 100;
   const { secondary } = paragraphSizesPt(text4, sizePt);
-  const paragraph2 = (value, level2) => {
-    const bullet = bulletLevel > 0 && level2 >= bulletLevel;
-    const size = bullet || level2 >= 2 ? secondary : sizePt;
+  const paragraph2 = (value, level3) => {
+    const bullet = bulletLevel > 0 && level3 >= bulletLevel;
+    const size = bullet || level3 >= 2 ? secondary : sizePt;
     return {
       text: value,
       size,
@@ -22226,7 +22541,7 @@ function arrangeHierRoot(node) {
 }
 
 // diagram/engine/alg-linear.ts
-function measure(node, box, horizontal, scale, uniform = false) {
+function measure2(node, box, horizontal, scale, uniform = false) {
   const refW = horizontal || uniform ? box.w * scale : box.w;
   const refH = !horizontal || uniform ? box.h * scale : box.h;
   evaluateWithReference(node, refW, refH);
@@ -22293,7 +22608,7 @@ function fitLinear(node, box, horizontal) {
   const along = horizontal ? box.w : box.h;
   const across = horizontal ? box.h : box.w;
   let scale = 1;
-  let current = measure(node, box, horizontal, scale);
+  let current = measure2(node, box, horizontal, scale);
   const full = current;
   let crossLimited = true;
   for (let iteration = 0; iteration < 12; iteration++) {
@@ -22303,10 +22618,10 @@ function fitLinear(node, box, horizontal) {
     if (factor >= 0.99999) {
       break;
     }
-    const next = measure(node, box, horizontal, scale * factor);
+    const next = measure2(node, box, horizontal, scale * factor);
     if (factor === fitAcross && next.cross >= current.cross - 1e-6) {
       crossLimited = false;
-      current = measure(node, box, horizontal, scale);
+      current = measure2(node, box, horizontal, scale);
       continue;
     }
     scale *= factor;
@@ -22323,9 +22638,9 @@ function fitLinear(node, box, horizontal) {
 function fitUniform(node, box, horizontal, stuck) {
   const along = horizontal ? box.w : box.h;
   let scale = 1;
-  let current = measure(node, box, horizontal, 1, true);
+  let current = measure2(node, box, horizontal, 1, true);
   for (let iteration = 0; iteration < 12 && current.total > along + 1e-3; iteration++) {
-    const next = measure(node, box, horizontal, scale * (along / current.total), true);
+    const next = measure2(node, box, horizontal, scale * (along / current.total), true);
     if (next.total >= current.total - 1e-6) {
       break;
     }
@@ -22347,7 +22662,7 @@ function refineAlong(node, box, horizontal, scale, current, full, crossLimited)
   let t1 = current.total;
   for (let i2 = 0; i2 < 6 && s1 < 1 && Math.abs(t1 - along) > 1e-3 && Math.abs(t0 - t1) > 1e-9; i2++) {
     const next = Math.min(1, Math.max(1e-6, s1 + (along - t1) * (s0 - s1) / (t0 - t1)));
-    const measured = measure(node, box, horizontal, next);
+    const measured = measure2(node, box, horizontal, next);
     if (measured.total > along + 1e-3 || crossLimited && measured.cross > across + 1e-6) {
       break;
     }
@@ -22360,7 +22675,7 @@ function refineAlong(node, box, horizontal, scale, current, full, crossLimited)
   if (best !== current) {
     return best;
   }
-  return measure(node, box, horizontal, scale);
+  return measure2(node, box, horizontal, scale);
 }
 function alignOffset(free, align, start, end) {
   if (align === start) {
@@ -22545,7 +22860,7 @@ function contentHeight(cell, w, h2) {
   cell.values = saved;
   return bottom;
 }
-function measure2(node, box, cells, spacer, row2) {
+function measure3(node, box, cells, spacer, row2) {
   const cellW = Math.max(...cells.map((c2) => c2.values.get("w") ?? box.w));
   const assignedH = Math.max(...cells.map((c2) => c2.values.get("h") ?? box.h));
   const cellH = Math.max(...cells.map((c2) => contentHeight(c2, cellW, assignedH)));
@@ -22580,7 +22895,7 @@ function fitSnakeByRule(node, box, cells, spacers, row2) {
   const floor = rule.val * POINTS_PER_MM2;
   const at2 = (value) => {
     evaluateAt(node, box, rule, targets, value);
-    return measure2(node, box, cells, spacers[0], row2);
+    return measure3(node, box, cells, spacers[0], row2);
   };
   let best = at2(start);
   if (fits2(best, cells.length, box, row2) || !(start > floor)) {
@@ -22885,7 +23200,7 @@ function depthOf(point) {
   }
   return depth;
 }
-function level(depth) {
+function level2(depth) {
   return Math.max(0, Math.min(MAX_LEVEL, depth));
 }
 function connectorDim(node) {
@@ -22899,11 +23214,11 @@ function derivedStyleLabel(node) {
   switch (point.type) {
     case "node":
     case "asst":
-      return `node${level(depthOf(point))}`;
+      return `node${level2(depthOf(point))}`;
     case "sibTrans":
       return `sibTrans${connectorDim(node)}1`;
     case "parTrans":
-      return `parChTrans${connectorDim(node)}${level(depthOf(point))}`;
+      return `parChTrans${connectorDim(node)}${level2(depthOf(point))}`;
     default:
       return void 0;
   }
@@ -29657,18 +29972,18 @@ function fanContinues(t, perRow, orgChart, siblingCount, normalCount) {
   const spanW = effectiveWidth(t, orgChart);
   return chPrefFanEligible || isSoloChainLink && normalCount > 1 && spanW === normalCount;
 }
-function walk2(t, level2, perRow, orgChart, siblingCount) {
+function walk2(t, level3, perRow, orgChart, siblingCount) {
   const { normal } = partitionChildren(t, orgChart);
   if (normal.length === 0) {
-    return { deepestFanLevel: level2, maxHangDepth: 0, maxHangRows: 0, hangingColumns: 0 };
+    return { deepestFanLevel: level3, maxHangDepth: 0, maxHangRows: 0, hangingColumns: 0 };
   }
-  if (level2 === 0) {
-    let deepestFan = level2;
+  if (level3 === 0) {
+    let deepestFan = level3;
     let maxHang = 0;
     let maxRows = 0;
     let hangingColumns = 0;
     for (const child3 of normal) {
-      const r = walk2(child3, level2 + 1, perRow, orgChart, normal.length);
+      const r = walk2(child3, level3 + 1, perRow, orgChart, normal.length);
       deepestFan = Math.max(deepestFan, r.deepestFanLevel);
       maxHang = Math.max(maxHang, r.maxHangDepth);
       maxRows = Math.max(maxRows, r.maxHangRows);
@@ -29682,12 +29997,12 @@ function walk2(t, level2, perRow, orgChart, siblingCount) {
     };
   }
   if (fanContinues(t, perRow, orgChart, siblingCount, normal.length)) {
-    let deepestFan = level2 + 1;
+    let deepestFan = level3 + 1;
     let maxHang = 0;
     let maxRows = 0;
     let hangingColumns = 0;
     for (const child3 of normal) {
-      const r = walk2(child3, level2 + 1, perRow, orgChart, void 0);
+      const r = walk2(child3, level3 + 1, perRow, orgChart, void 0);
       deepestFan = Math.max(deepestFan, r.deepestFanLevel);
       maxHang = Math.max(maxHang, r.maxHangDepth);
       maxRows = Math.max(maxRows, r.maxHangRows);
@@ -29701,7 +30016,7 @@ function walk2(t, level2, perRow, orgChart, siblingCount) {
     };
   }
   return {
-    deepestFanLevel: level2,
+    deepestFanLevel: level3,
     maxHangDepth: treeDepth(t) - 1,
     maxHangRows: countDescendants(t, orgChart),
     hangingColumns: 1
@@ -29740,20 +30055,20 @@ function computeHangShape(roots2, orgChart, perRow) {
 }
 
 // diagram/hierarchy/smartart-hierarchy-fan-aware-width.ts
-function widthWalk(t, level2, perRow, orgChart, siblingCount, map) {
+function widthWalk(t, level3, perRow, orgChart, siblingCount, map) {
   const { normal } = partitionChildren(t, orgChart);
   let width;
   if (normal.length === 0) {
     width = 1;
-  } else if (level2 === 0) {
+  } else if (level3 === 0) {
     width = 0;
     for (const child3 of normal) {
-      width += widthWalk(child3, level2 + 1, perRow, orgChart, normal.length, map);
+      width += widthWalk(child3, level3 + 1, perRow, orgChart, normal.length, map);
     }
   } else if (fanContinues(t, perRow, orgChart, siblingCount, normal.length)) {
     width = 0;
     for (const child3 of normal) {
-      width += widthWalk(child3, level2 + 1, perRow, orgChart, void 0, map);
+      width += widthWalk(child3, level3 + 1, perRow, orgChart, void 0, map);
     }
   } else {
     width = 1;
@@ -29947,7 +30262,7 @@ function placeAssistants(hc, x, parentBottom, assistants, options, cursor) {
     stubConnector(hc, assistant.node.id, x + hc.boxH / 2, parentBottom, x + width / 2, y);
   }
 }
-function placeHangingTree(hc, t, x, options, cursor, size, level2 = 0) {
+function placeHangingTree(hc, t, x, options, cursor, size, level3 = 0) {
   const y = cursor.y;
   const boxW = size?.w ?? hc.boxW;
   const boxH = size?.h ?? hc.boxH;
@@ -29960,7 +30275,7 @@ function placeHangingTree(hc, t, x, options, cursor, size, level2 = 0) {
   if (normal.length === 0) {
     return;
   }
-  if (options.foldDeeperGenerations && level2 >= 1) {
+  if (options.foldDeeperGenerations && level3 >= 1) {
     return;
   }
   const childX = align ? placeX : options.direction === "left" ? x - options.indent : x + options.indent;
@@ -29975,7 +30290,7 @@ function placeHangingTree(hc, t, x, options, cursor, size, level2 = 0) {
       childY,
       child3.node.id
     );
-    placeHangingTree(hc, child3, childX, options, cursor, void 0, level2 + 1);
+    placeHangingTree(hc, child3, childX, options, cursor, void 0, level3 + 1);
   }
 }
 function placeHangingForest(hc, roots2, startX, startY, options, rootSize) {
@@ -30048,17 +30363,17 @@ function fitHangingBox(view, algorithmNode, index, w, h2, rows, nodeCount, presL
 }
 
 // diagram/hierarchy/smartart-hierarchy-hanging-fold.ts
-function countRows(t, level2, orgChart, fold) {
+function countRows(t, level3, orgChart, fold) {
   const { assistants, normal } = partitionChildren(t, orgChart);
   let count = 1 + assistants.length;
   if (normal.length === 0) {
     return count;
   }
-  if (fold && level2 >= 1) {
+  if (fold && level3 >= 1) {
     return count;
   }
   for (const child3 of normal) {
-    count += countRows(child3, level2 + 1, orgChart, fold);
+    count += countRows(child3, level3 + 1, orgChart, fold);
   }
   return count;
 }
@@ -30615,8 +30930,8 @@ function planFan(childCount, perRow, siblingCxs) {
   }
   return { columns: siblingCxs, overflow: childCount - siblingCxs.length };
 }
-function placeFannedRow(hc, t, normal, plan, cx2, cy, level2, cellW, cellH, options, placeAtFn) {
-  const fanCy = (level2 + 1) * cellH + cellH / 2;
+function placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, options, placeAtFn) {
+  const fanCy = (level3 + 1) * cellH + cellH / 2;
   const fanned = normal.slice(0, plan.columns.length);
   for (let i2 = 0; i2 < fanned.length; i2++) {
     const child3 = fanned[i2];
@@ -30630,7 +30945,7 @@ function placeFannedRow(hc, t, normal, plan, cx2, cy, level2, cellW, cellH, opti
       fanCy - hc.boxH / 2,
       child3.node.id
     );
-    placeAtFn(hc, child3, childCx, fanCy, 0, 1, level2 + 1, cellW, cellH, options);
+    placeAtFn(hc, child3, childCx, fanCy, 0, 1, level3 + 1, cellW, cellH, options);
   }
   if (plan.overflow <= 0 || !options.hangingPlacer) {
     return;
@@ -30638,7 +30953,7 @@ function placeFannedRow(hc, t, normal, plan, cx2, cy, level2, cellW, cellH, opti
   const remainder = normal.slice(plan.columns.length);
   const columnOffset = hc.boxW * HIER_TAIL_OFFSET_RATIO;
   const anchorX = plan.columns[0] - hc.boxW / 2 + columnOffset;
-  const anchorY = (level2 + 2) * cellH;
+  const anchorY = (level3 + 2) * cellH;
   for (const child3 of remainder) {
     elbowConnector(
       hc,
@@ -30675,7 +30990,7 @@ function placeAssistantRow(hc, parentId, cx2, cy, assistants) {
     x += assistW + ASSISTANT_GAP;
   }
 }
-function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level2, cellW, cellH, options, placeChild) {
+function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level3, cellW, cellH, options, placeChild) {
   const siblingCxs = [];
   {
     let offset = xOffset;
@@ -30685,12 +31000,12 @@ function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level2, cellW
       offset += childW;
     }
   }
-  const cascadeShift = options.cascadeOffsetX && level2 + 1 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
+  const cascadeShift = options.cascadeOffsetX && level3 + 1 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
   let childOffset = xOffset;
   for (const child3 of normal) {
     const childW = spanOf(child3, options);
     const childCx = (childOffset + childW / 2) * cellW + cascadeShift;
-    const childCy = (level2 + 1) * cellH + cellH / 2;
+    const childCy = (level3 + 1) * cellH + cellH / 2;
     elbowConnector(
       hc,
       parentId,
@@ -30707,7 +31022,7 @@ function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level2, cellW
       childCy,
       childOffset,
       childW,
-      level2 + 1,
+      level3 + 1,
       cellW,
       cellH,
       options,
@@ -30733,13 +31048,13 @@ function wrappedGroupSlotCount(group2, orgChart) {
   }
   return group2.members.reduce((sum, m) => sum + effectiveWidth(m, orgChart), 0);
 }
-function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, level2, cellW, cellH, options, placeAtFn) {
+function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, level3, cellW, cellH, options, placeAtFn) {
   const groups = planWrappedGroups(normal, options.perRow, options.orgChart);
   const totalSlots = groups.reduce((sum, g2) => sum + wrappedGroupSlotCount(g2, options.orgChart), 0);
   const totalW = spanW * cellW;
   const leftX = xOffset * cellW;
   const unitW = totalW / Math.max(1, totalSlots);
-  const rowCy = (level2 + 1) * cellH + cellH / 2;
+  const rowCy = (level3 + 1) * cellH + cellH / 2;
   let slot2 = 0;
   for (const group2 of groups) {
     slot2 = group2.fansAsRow ? placeRowFanGroup(
@@ -30752,7 +31067,7 @@ function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, lev
       unitW,
       slot2,
       rowCy,
-      level2,
+      level3,
       cellW,
       cellH,
       options,
@@ -30769,25 +31084,25 @@ function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, lev
       rowCy,
       cellW,
       cellH,
-      level2,
+      level3,
       options,
       placeAtFn
     );
   }
 }
-function placeRowFanGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, level2, cellW, cellH, options, placeAtFn) {
+function placeRowFanGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, level3, cellW, cellH, options, placeAtFn) {
   let cursor = slot2;
   for (const child3 of group2.members) {
     const childW = effectiveWidth(child3, options.orgChart);
     const childCx = leftX + unitW * (cursor + childW / 2);
     elbowConnector(hc, parentId, cx2, cy + hc.boxH / 2, childCx, rowCy - hc.boxH / 2, child3.node.id);
     const virtualOffset = childCx / cellW - childW / 2;
-    placeAtFn(hc, child3, childCx, rowCy, virtualOffset, childW, level2 + 1, cellW, cellH, options);
+    placeAtFn(hc, child3, childCx, rowCy, virtualOffset, childW, level3 + 1, cellW, cellH, options);
     cursor += childW;
   }
   return cursor;
 }
-function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, cellW, cellH, level2, options, placeAtFn) {
+function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, cellW, cellH, level3, options, placeAtFn) {
   const groupCx = leftX + unitW * (slot2 + 0.5);
   const subRowH = cellH / group2.members.length;
   let fromId = parentId;
@@ -30799,7 +31114,7 @@ function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, ro
     elbowConnector(hc, fromId, fromX, fromY, groupCx, childCy - hc.boxH / 2, child3.node.id);
     const childW = effectiveWidth(child3, options.orgChart);
     const virtualOffset = groupCx / cellW - childW / 2;
-    placeAtFn(hc, child3, groupCx, childCy, virtualOffset, childW, level2 + 1, cellW, cellH, options);
+    placeAtFn(hc, child3, groupCx, childCy, virtualOffset, childW, level3 + 1, cellW, cellH, options);
     fromId = child3.node.id;
     fromX = groupCx;
     fromY = childCy + hc.boxH / 2;
@@ -30808,7 +31123,7 @@ function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, ro
 }
 
 // diagram/hierarchy/smartart-hierarchy-standard.ts
-function placeFlatChildren2(hc, parentId, normal, cx2, cy, xOffset, level2, cellW, cellH, options) {
+function placeFlatChildren2(hc, parentId, normal, cx2, cy, xOffset, level3, cellW, cellH, options) {
   placeFlatChildren(
     hc,
     parentId,
@@ -30816,14 +31131,14 @@ function placeFlatChildren2(hc, parentId, normal, cx2, cy, xOffset, level2, cell
     cx2,
     cy,
     xOffset,
-    level2,
+    level3,
     cellW,
     cellH,
     options,
     placeAt
   );
 }
-function placeWrappedChildren2(hc, parentId, normal, cx2, cy, xOffset, spanW, level2, cellW, cellH, options) {
+function placeWrappedChildren2(hc, parentId, normal, cx2, cy, xOffset, spanW, level3, cellW, cellH, options) {
   placeWrappedChildren(
     hc,
     parentId,
@@ -30832,32 +31147,32 @@ function placeWrappedChildren2(hc, parentId, normal, cx2, cy, xOffset, spanW, le
     cy,
     xOffset,
     spanW,
-    level2,
+    level3,
     cellW,
     cellH,
     options,
     placeAt
   );
 }
-function placeAt(hc, t, cx2, cy, xOffset, spanW, level2, cellW, cellH, options, siblingCxs) {
+function placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options, siblingCxs) {
   pushNode(hc, t.node, cx2 - hc.boxW / 2, cy - hc.boxH / 2);
   const { assistants, normal } = partitionChildren(t, options.orgChart);
   placeAssistantRow(hc, t.node.id, cx2, cy, assistants);
   if (normal.length === 0) {
     return;
   }
-  if (options.foldDeeperGenerations && level2 >= 1) {
+  if (options.foldDeeperGenerations && level3 >= 1) {
     return;
   }
-  if (options.hangingPlacer && level2 >= 1) {
+  if (options.hangingPlacer && level3 >= 1) {
     const plan = planFan(normal.length, options.perRow, siblingCxs);
     if (plan) {
-      placeFannedRow(hc, t, normal, plan, cx2, cy, level2, cellW, cellH, options, placeAt);
+      placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, options, placeAt);
       return;
     }
     const isSoloChainLink = !siblingCxs || siblingCxs.length === 1;
     if (isSoloChainLink && normal.length > 1 && spanW === normal.length) {
-      placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level2, cellW, cellH, options);
+      placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level3, cellW, cellH, options);
       return;
     }
     const anchorY = cy + hc.boxH / 2 + (options.hangHeightRatio ?? HANG_HEIGHT_RATIO) * hc.boxH;
@@ -30885,21 +31200,21 @@ function placeAt(hc, t, cx2, cy, xOffset, spanW, level2, cellW, cellH, options,
       cy,
       xOffset,
       spanW,
-      level2,
+      level3,
       cellW,
       cellH,
       options
     );
   } else {
-    placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level2, cellW, cellH, options);
+    placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level3, cellW, cellH, options);
   }
 }
-function placeStandardTree(hc, t, xOffset, level2, cellW, cellH, options) {
+function placeStandardTree(hc, t, xOffset, level3, cellW, cellH, options) {
   const spanW = spanOf(t, options);
-  const cascadeShift = options.cascadeOffsetX && level2 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
+  const cascadeShift = options.cascadeOffsetX && level3 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
   const cx2 = (xOffset + spanW / 2) * cellW + cascadeShift;
-  const cy = level2 * cellH + cellH / 2;
-  placeAt(hc, t, cx2, cy, xOffset, spanW, level2, cellW, cellH, options);
+  const cy = level3 * cellH + cellH / 2;
+  placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options);
 }
 
 // diagram/hierarchy/smartart-hierarchy-tailed-placer.ts
@@ -42702,8 +43017,8 @@ function layers(ids, forward, shortest) {
   }
   const result = [];
   for (const id of ids) {
-    const level2 = rank.get(id) ?? 0;
-    (result[level2] ??= []).push(id);
+    const level3 = rank.get(id) ?? 0;
+    (result[level3] ??= []).push(id);
   }
   return result.filter((layer) => layer.length);
 }