ooxml-core 1.17.0 → 1.18.0

package/dist/docx/layout/index.mjs

@@ -57,8 +57,8 @@ function parseXml(xml, options = {}) {
   let parsed;
   try {
     parsed = new DOMParser({
-      onError: (level, message) => {
-        if (level !== "warning") parseError = message;
+      onError: (level2, message) => {
+        if (level2 !== "warning") parseError = message;
       }
     }).parseFromString(xml, "application/xml");
   } catch (error) {
@@ -728,8 +728,8 @@ function resolveRunFormatting(run, context = {}) {
     if (state) result[key] = true;
   }
   for (const key of OVERRIDE_KEYS) {
-    for (const level of levels) {
-      const value = level[key];
+    for (const level2 of levels) {
+      const value = level2[key];
       if (value !== void 0) result[key] = value;
     }
   }
@@ -11339,6 +11339,287 @@ function groupRowsByCategory(rawCategories) {
   return { uniqueCategories, rowIndexesByCategory };
 }
 
+// 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 named3 = NAMED_FORMAT_COLORS[token.trim().toLowerCase()];
+      if (named3 && color === void 0) {
+        color = named3;
+      }
+      i = close === -1 ? code.length : close;
+      continue;
+    }
+    chars.push({ ch, literal: false });
+  }
+  const firstDigit = chars.findIndex((c) => !c.literal && PLACEHOLDER.test(c.ch));
+  if (firstDigit === -1) {
+    return void 0;
+  }
+  let lastDigit = firstDigit;
+  for (let i = chars.length - 1; i >= firstDigit; i -= 1) {
+    const c = chars[i];
+    if (c && !c.literal && (PLACEHOLDER.test(c.ch) || c.ch === "." || c.ch === "," || c.ch === "E")) {
+      lastDigit = i;
+      break;
+    }
+  }
+  const numeric = chars.slice(firstDigit, lastDigit + 1);
+  const prefix2 = chars.slice(0, firstDigit).map((c) => c.ch).join("");
+  const suffix = chars.slice(lastDigit + 1).map((c) => c.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((c) => !c.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: prefix2,
+    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;
+  }
+}
+
+// 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 } = 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, numberFormat);
+    parts.push(formatted?.text ?? (input.formatValue ?? String)(value, numberFormat));
+    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 text2 = parts.join(flags.separator);
+  if (text2.length === 0) return void 0;
+  return { text: text2, color: parts.length === 1 && flags.showValue ? valueColor : void 0 };
+}
+
 // chart/bubble-radius.ts
 function computeBubbleRadius(sizeVal, maxBubble, medianRadius, options) {
   const scale = (options?.bubbleScale ?? 100) / 100;
@@ -11451,10 +11732,10 @@ function squarify(nodes, box) {
 
 // chart/hierarchy.ts
 function normalizeLevels(levels, pointCount) {
-  return levels.map((level) => {
+  return levels.map((level2) => {
     let previous = "";
     return Array.from({ length: pointCount }, (_, index) => {
-      const label = level[index]?.trim() ?? "";
+      const label = level2[index]?.trim() ?? "";
       if (label) previous = label;
       return label || previous;
     });
@@ -11612,12 +11893,12 @@ function computeSunburstArcs(series, cx, cy, maxR) {
   });
   return out;
 }
-function hierarchyKey(levels, level, index) {
-  return levels.slice(level).map((labels) => labels[index] ?? "").join("\0");
+function hierarchyKey(levels, level2, index) {
+  return levels.slice(level2).map((labels) => labels[index] ?? "").join("\0");
 }
 function computeHierarchicalSunburstArcs(categoryLevels, values, cx, cy, maxR) {
-  const levels = categoryLevels.filter((level) => level.length > 0);
-  const leafCount = Math.max(values.length, ...levels.map((level) => level.length), 0);
+  const levels = categoryLevels.filter((level2) => level2.length > 0);
+  const leafCount = Math.max(values.length, ...levels.map((level2) => level2.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);
@@ -11628,15 +11909,15 @@ function computeHierarchicalSunburstArcs(categoryLevels, values, cx, cy, maxR) {
   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;
+  for (let level2 = levels.length - 1; level2 >= 0; level2--) {
+    const ringIndex = levels.length - 1 - level2;
     const innerRadius = ringWidth * (ringIndex + 0.5);
     const outerRadius = ringWidth * (ringIndex + 1.5);
     let start = 0;
     while (start < leafCount) {
-      const key = hierarchyKey(levels, level, start);
+      const key = hierarchyKey(levels, level2, start);
       let end = start + 1;
-      while (end < leafCount && hierarchyKey(levels, level, end) === key) end++;
+      while (end < leafCount && hierarchyKey(levels, level2, end) === key) end++;
       const startAngle = -Math.PI / 2 + (prefix2[start] ?? 0) / total * Math.PI * 2;
       const endAngle = -Math.PI / 2 + (prefix2[end] ?? 0) / total * Math.PI * 2;
       const rootLabel = rootLabels[start] ?? "";
@@ -11646,8 +11927,8 @@ function computeHierarchicalSunburstArcs(categoryLevels, values, cx, cy, maxR) {
         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 } : {},
+        label: levels[level2]?.[start] ?? "",
+        ...level2 === 0 && end === start + 1 ? { pointIndex: start } : {},
         ...arcLabelPlacement(cx, cy, (innerRadius + outerRadius) / 2, startAngle, endAngle)
       });
       start = end;
@@ -11935,6 +12216,65 @@ function chartErrorBarAmount(options, values, displayIndex, sourceIndex, side) {
   }
 }
 
+// chart/pie-best-fit.ts
+var PX_PER_PT = 4 / 3;
+var BEST_FIT_RIM_INSET = 4 * PX_PER_PT;
+var BEST_FIT_EDGE_TOLERANCE = 1.5 * PX_PER_PT;
+var BEST_FIT_OUTSIDE_GAP = 2 * PX_PER_PT;
+function farCorner(x, y, w, h) {
+  return Math.hypot(Math.abs(x) + w / 2, Math.abs(y) + h / 2);
+}
+function insideDistance(ux, uy, w, h, limit) {
+  if (farCorner(0, 0, w, h) > limit) {
+    return void 0;
+  }
+  let lo = 0;
+  let hi = limit;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (farCorner(mid * ux, mid * uy, w, h) > limit) {
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo;
+}
+function edgeOverhang(x, y, w, h, slice) {
+  let worst = Number.NEGATIVE_INFINITY;
+  const corners = [
+    [-w / 2, -h / 2],
+    [w / 2, -h / 2],
+    [-w / 2, h / 2],
+    [w / 2, h / 2]
+  ];
+  for (const [dx, dy] of corners) {
+    const px = x + dx;
+    const py = y + dy;
+    const fromStart = Math.cos(slice.startAngle) * py - Math.sin(slice.startAngle) * px;
+    const fromEnd = Math.sin(slice.endAngle) * px - Math.cos(slice.endAngle) * py;
+    worst = Math.max(worst, -fromStart, -fromEnd);
+  }
+  return worst;
+}
+function placeBestFitLabel(slice, w, h) {
+  const mid = (slice.startAngle + slice.endAngle) / 2;
+  const ux = Math.cos(mid);
+  const uy = Math.sin(mid);
+  const distance = insideDistance(ux, uy, w, h, slice.outerR - BEST_FIT_RIM_INSET);
+  if (distance !== void 0) {
+    const x = distance * ux;
+    const y = distance * uy;
+    const reflex = slice.endAngle - slice.startAngle >= Math.PI;
+    if (reflex || edgeOverhang(x, y, w, h, slice) <= BEST_FIT_EDGE_TOLERANCE) {
+      return { x: slice.cx + x, y: slice.cy + y, inside: true };
+    }
+  }
+  const extent = Math.abs(ux) * w / 2 + Math.abs(uy) * h / 2;
+  const outside = slice.outerR + BEST_FIT_OUTSIDE_GAP + extent;
+  return { x: slice.cx + outside * ux, y: slice.cy + outside * uy, inside: false };
+}
+
 // chart/color-palettes.ts
 var COLORFUL_VARIATIONS = [
   {},
@@ -12288,6 +12628,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 own2 = series.dataLabels;
+  if (!own2 && !group2) return void 0;
+  const out = {};
+  if (group2) out.chart = level(group2);
+  if (own2) out.series = level(own2);
+  const points = {};
+  for (const labels of [group2, own2])
+    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";
@@ -12305,7 +12680,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;
@@ -12313,6 +12688,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;
@@ -12341,6 +12717,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;
 }
@@ -12349,12 +12727,12 @@ function valueAxisId(chartSpace, axisIds) {
     (id) => chartSpace.plotArea.axes.some((a) => a.id === id && a.kind === "val")
   );
 }
-function stockStyle(group) {
+function stockStyle(group2) {
   return {
-    ...group.hiLowLinesSpPr ? { hiLowLines: group.hiLowLinesSpPr } : {},
-    ...group.upBars?.spPr ? { upBars: group.upBars.spPr } : {},
-    ...group.downBars?.spPr ? { downBars: group.downBars.spPr } : {},
-    ...group.upDownBarsGapWidth === void 0 ? {} : { gapWidth: group.upDownBarsGapWidth }
+    ...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) {
@@ -12362,31 +12740,33 @@ function extraGroups(chartSpace, firstType) {
   if (!first3 || !["column", "line", "area"].includes(firstType)) return [];
   const primary = valueAxisId(chartSpace, first3.axisIds);
   const out = [];
-  for (const group of rest) {
-    const stockOverColumns = group.kind === "stock" && firstType === "column";
-    if (group.is3D || !(["bar", "line", "area"].includes(group.kind) || stockOverColumns)) continue;
-    const type = group.kind === "bar" ? "column" : group.kind;
+  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 entry = {
       chartType: type,
-      series: group.series.map((source) => chartSummarySeries(source, type)),
-      secondary: valueAxisId(chartSpace, group.axisIds) !== primary
+      series: group2.series.map((source) => chartSummarySeries(source, type, group2.dataLabels)),
+      secondary: valueAxisId(chartSpace, group2.axisIds) !== primary
     };
-    if (group.grouping && GROUPINGS.has(group.grouping))
-      entry.grouping = group.grouping;
-    if (type === "stock") entry.stock = stockStyle(group);
+    if (group2.grouping && GROUPINGS.has(group2.grouping))
+      entry.grouping = group2.grouping;
+    if (type === "stock") entry.stock = stockStyle(group2);
     if (type === "column") {
-      if (group.gapWidth !== void 0) entry.barGapWidth = group.gapWidth;
-      if (group.overlap !== void 0) entry.barOverlap = group.overlap;
+      if (group2.gapWidth !== void 0) entry.barGapWidth = group2.gapWidth;
+      if (group2.overlap !== void 0) entry.barOverlap = group2.overlap;
     }
     if (entry.series.length) out.push(entry);
   }
   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 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, group2?.dataLabels)
+  );
   const summary = {
     chartType,
     series,
@@ -12394,22 +12774,22 @@ function chartSummaryFromSpace(chartSpace, extras = {}) {
   };
   const combined = extraGroups(chartSpace, chartType);
   if (combined.length) summary.extraGroups = combined;
-  if (chartType === "stock" && group) summary.stock = stockStyle(group);
-  if (chartType === "bubble" && group) {
-    const sizeRepresents = group.sizeRepresents === "w" ? "w" : "area";
+  if (chartType === "stock" && group2) summary.stock = stockStyle(group2);
+  if (chartType === "bubble" && group2) {
+    const sizeRepresents = group2.sizeRepresents === "w" ? "w" : "area";
     summary.bubble = {
       sizeRepresents,
-      ...group.bubbleScale === void 0 ? {} : { bubbleScale: group.bubbleScale },
-      showNegativeBubbles: group.showNegativeBubbles === true
+      ...group2.bubbleScale === void 0 ? {} : { bubbleScale: group2.bubbleScale },
+      showNegativeBubbles: group2.showNegativeBubbles === true
     };
   }
-  const grouping = group?.grouping;
+  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 [
-      [group?.gapWidth, "barGapWidth", 150, 0, 500],
-      [group?.overlap, "barOverlap", 0, -100, 100]
+      [group2?.gapWidth, "barGapWidth", 150, 0, 500],
+      [group2?.overlap, "barOverlap", 0, -100, 100]
     ]) {
       const resolved = value ?? fallback;
       if (Number.isInteger(resolved) && resolved >= min && resolved <= max)
@@ -12471,268 +12851,56 @@ 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((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 a = stacked ? frame2.value(from) : base;
-      const b = frame2.value(to);
-      const offset = barOffset(si);
-      const center = frame2.band(i);
-      const width = model.horizontal ? Math.abs(b - a) : barSize;
-      const height = model.horizontal ? barSize : Math.abs(b - a);
-      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(
-          rect2(Math.min(a, b), center + offset, Math.abs(b - a), barSize, color, s.shadowFilter)
-        );
-      else
-        out.push(
-          rect2(center + offset, Math.min(a, b), barSize, Math.abs(b - a), color, s.shadowFilter)
-        );
-      out.push("</g>");
-    });
-  });
+// chart/render/theme-palette.ts
+var THEME_SLOTS = [
+  "lt1",
+  "dk1",
+  "lt2",
+  "dk2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var DEFAULT_THEME_COLORS = [
+  "FFFFFF",
+  "000000",
+  "E7E6E6",
+  "44546A",
+  "4472C4",
+  "ED7D31",
+  "A5A5A5",
+  "FFC000",
+  "5B9BD5",
+  "70AD47",
+  "0563C1",
+  "954F72"
+];
+function themeColor(theme, index) {
+  const hex = theme.colors[index] ?? DEFAULT_THEME_COLORS[index];
+  return hex && parseArgbHex(hex) ? hex.replace(/^#/, "") : void 0;
 }
 
-// chart/render/chart-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}"/>`
-    );
-  }
+// chart/render/chart-colors.ts
+function chartColorScheme(theme) {
+  const slots = Object.fromEntries(
+    THEME_SLOTS.map((slot, index) => [slot, `#${themeColor(theme, index) ?? "000000"}`])
+  );
+  return {
+    ...slots,
+    bg1: slots.lt1,
+    tx1: slots.dk1,
+    bg2: slots.lt2,
+    tx2: slots.dk2
+  };
 }
-function 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)
-    );
-  }
-}
-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 [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
-var clean = (n2) => Number(n2.toPrecision(12));
-function* units(raw) {
-  let exp = Math.floor(Math.log10(raw)) - 1;
-  for (; ; ) {
-    const base = 10 ** exp;
-    for (const m of [1, 2, 5]) yield clean(m * base);
-    exp++;
-  }
-}
-function niceScale(dataMin, dataMax, options = {}) {
-  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
-  let lo = Number.isFinite(dataMin) ? dataMin : 0;
-  let hi = Number.isFinite(dataMax) ? dataMax : 0;
-  if (lo > hi) [lo, hi] = [hi, lo];
-  if (lo === hi) {
-    if (lo === 0) hi = 1;
-    else if (options.noZero) {
-      const pad = Math.abs(lo) * 0.1 || 1;
-      lo -= pad;
-      hi += pad;
-    } else if (lo > 0) lo = 0;
-    else hi = 0;
-  }
-  let fixedLo = false;
-  let fixedHi = false;
-  if (!options.noZero) {
-    if (lo >= 0 && hi - lo >= hi / 6) {
-      lo = 0;
-      fixedLo = true;
-    } else if (hi <= 0 && hi - lo >= -lo / 6) {
-      hi = 0;
-      fixedHi = true;
-    }
-  }
-  const range = hi - lo;
-  const top = fixedHi ? hi : hi + range * 0.05;
-  const bottom = fixedLo ? lo : lo - range * 0.05;
-  for (const unit of units(range / maxIntervals)) {
-    const min = fixedLo ? lo : Math.floor(clean(bottom / unit)) * unit;
-    const max = fixedHi ? hi : Math.ceil(clean(top / unit)) * unit;
-    const intervals = Math.round((max - min) / unit);
-    if (intervals <= maxIntervals && intervals > 0) {
-      const ticks = [];
-      for (let i = 0; i <= intervals; i++) ticks.push(clean(min + i * unit));
-      return { min: clean(min), max: clean(max), majorUnit: unit, ticks };
-    }
-  }
-  return { min: lo, max: hi, majorUnit: range, ticks: [lo, hi] };
-}
-var PERCENT_SCALE = {
-  min: 0,
-  max: 1,
-  majorUnit: 0.1,
-  ticks: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
-};
-function formatAxisValue(value, percent = false) {
-  if (percent) return `${clean(value * 100)}%`;
-  const v = clean(value);
-  if (Math.abs(v) >= 1e15 || v !== 0 && Math.abs(v) < 1e-6)
-    return v.toExponential(2).replace("e+", "E+").replace("e-", "E-");
-  const [int = "0", frac] = String(Math.abs(v)).split(".");
-  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-  return `${v < 0 ? "-" : ""}${grouped}${frac ? `.${frac}` : ""}`;
-}
-
-// chart/render/theme-palette.ts
-var THEME_SLOTS = [
-  "lt1",
-  "dk1",
-  "lt2",
-  "dk2",
-  "accent1",
-  "accent2",
-  "accent3",
-  "accent4",
-  "accent5",
-  "accent6",
-  "hlink",
-  "folHlink"
-];
-var DEFAULT_THEME_COLORS = [
-  "FFFFFF",
-  "000000",
-  "E7E6E6",
-  "44546A",
-  "4472C4",
-  "ED7D31",
-  "A5A5A5",
-  "FFC000",
-  "5B9BD5",
-  "70AD47",
-  "0563C1",
-  "954F72"
-];
-function themeColor(theme, index) {
-  const hex = theme.colors[index] ?? DEFAULT_THEME_COLORS[index];
-  return hex && parseArgbHex(hex) ? hex.replace(/^#/, "") : void 0;
-}
-
-// chart/render/chart-colors.ts
-function chartColorScheme(theme) {
-  const slots = Object.fromEntries(
-    THEME_SLOTS.map((slot, index) => [slot, `#${themeColor(theme, index) ?? "000000"}`])
-  );
-  return {
-    ...slots,
-    bg1: slots.lt1,
-    tx1: slots.dk1,
-    bg2: slots.lt2,
-    tx2: slots.dk2
-  };
-}
-function autoSeriesColor(theme, index) {
-  const i = Math.max(0, Math.floor(index));
-  return chartPaletteSeriesColor(findChartColorPalette(10), i, i + 1, chartColorScheme(theme));
+function autoSeriesColor(theme, index) {
+  const i = Math.max(0, Math.floor(index));
+  return chartPaletteSeriesColor(findChartColorPalette(10), i, i + 1, chartColorScheme(theme));
 }
 
 // chart/text-inheritance.ts
@@ -12761,66 +12929,504 @@ function inheritChartText(part, entry, builtIn, root) {
     const value = root[key] ?? builtIn?.[key];
     if (value !== void 0) Object.assign(out, { [key]: value });
   }
-  if (part === "title" && root.fontSize !== void 0) out.fontSize = root.fontSize * 1.2;
-  if (root.textEffectsXml !== void 0) out.textEffectsXml = root.textEffectsXml;
-  return out;
+  if (part === "title" && root.fontSize !== void 0) out.fontSize = root.fontSize * 1.2;
+  if (root.textEffectsXml !== void 0) out.textEffectsXml = root.textEffectsXml;
+  return out;
+}
+
+// chart/render/chart-appearance.ts
+var chartPointsToPixels = (points) => points * EMU_PER_POINT / EMU_PER_PIXEL;
+function typeface(entry, theme) {
+  const name = entry.typeface;
+  if (name?.startsWith("+mj-")) return theme.majorFont;
+  if (name?.startsWith("+mn-")) return theme.minorFont;
+  return name ?? (entry.fontRef?.index === "major" ? theme.majorFont : entry.fontRef?.index === "minor" ? theme.minorFont : void 0);
+}
+function chartAppearance(chart, theme) {
+  const defaults = builtInChartTextStyle(effectiveBuiltInChartStyle(chart.formatting));
+  const entries = {};
+  for (const part of CHART_STYLE_PARTS) {
+    const base = chart.styleDefinition?.entries[part];
+    const direct = chart.formatting?.entries[part];
+    if (!defaults[part] && !base && !direct) continue;
+    const entry = {
+      ...inheritChartText(
+        part,
+        { ...defaults[part], ...base, sourceXml: base?.sourceXml ?? "" },
+        defaults[part],
+        chart.formatting?.textDefaults
+      ),
+      ...direct,
+      sourceXml: direct?.sourceXml ?? base?.sourceXml ?? ""
+    };
+    if (base?.line || direct?.line) entry.line = { ...base?.line, ...direct?.line };
+    entries[part] = entry;
+  }
+  const scheme = chartColorScheme(theme);
+  const resolve = (color) => resolveDrawingColor(
+    color,
+    { scheme: (name) => scheme[name] },
+    { hslRounding: "halfDown", transformOrder: "document" }
+  );
+  const out = resolveChartStyleDefinition(
+    { entries},
+    (color) => drawingColorCss(resolve(color))
+  ) ?? {};
+  for (const part of CHART_STYLE_PARTS) {
+    const entry = entries[part];
+    if (!entry) continue;
+    const family = typeface(entry, theme);
+    const shadow = resolveDrawingShadowXml(entry.textEffectsXml, {
+      scheme: (name) => scheme[name]
+    });
+    if (shadow) (out[part] ??= {}).textShadow = shadow;
+    if (family) (out[part] ??= {}).typeface = family;
+    if (entry.axisVisible !== void 0) (out[part] ??= {}).axisVisible = entry.axisVisible;
+    if (entry.labelsVisible !== void 0) (out[part] ??= {}).labelsVisible = entry.labelsVisible;
+    if (entry.line?.widthEmu === 0) (out[part] ??= {}).lineWidth = 0;
+    if (entry.fill?.kind === "gradient") {
+      (out[part] ??= {}).gradient = resolveChartGradient(entry.fill, resolve);
+    }
+  }
+  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 prefix2 = `xlsx-chart-${++nextPaintId}`;
+  const appearance = { ...model.appearance };
+  const defs = [];
+  const shadowPaint = (shadow, suffix) => {
+    const id = `${prefix2}-${suffix}`;
+    const pad = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
+    defs.push(
+      `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad)}" y="${n(-pad)}" width="${n(width + pad * 2)}" height="${n(height + pad * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
+    );
+    return `url(#${id})`;
+  };
+  for (const [part, entry] of Object.entries(appearance)) {
+    if (entry?.textShadow)
+      appearance[part] = {
+        ...entry,
+        textShadowFilter: shadowPaint(entry.textShadow, `${part}-text-shadow`)
+      };
+  }
+  const paint2 = (gradient, suffix, bounds) => {
+    const def = buildChartGradientDef(`${prefix2}-${suffix}`, gradient, bounds);
+    defs.push(chartGradientMarkup(def));
+    return `url(#${def.id})`;
+  };
+  for (const part of ["chartArea", "plotArea"]) {
+    const entry = appearance[part];
+    if (!entry?.gradient) continue;
+    if (part === "plotArea" && ["circle", "shape"].includes(entry.gradient.path ?? "")) continue;
+    appearance[part] = {
+      ...entry,
+      fillColor: paint2(entry.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 = 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)] = paint2(gradient, `s${index}-p${key}`, bounds);
+    }
+    return view;
+  });
+  return defs.length ? { model: { ...model, appearance, series }, defs: `<defs>${defs.join("")}</defs>` } : { model, defs: "" };
+}
+function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
+  const entry = model.appearance?.[part];
+  return {
+    size: entry?.fontSize === void 0 ? fallbackSize : chartPointsToPixels(entry.fontSize),
+    ...entry?.color === void 0 ? {} : { fill: entry.color },
+    ...entry?.bold === void 0 ? {} : { weight: entry.bold ? "bold" : "normal" },
+    ...entry?.italic === void 0 ? {} : { italic: entry.italic },
+    ...entry?.underline === void 0 ? {} : { underline: entry.underline },
+    ...entry?.typeface === void 0 ? {} : { family: cssFontFamily(entry.typeface) },
+    ...entry?.textShadowFilter === void 0 ? {} : { filter: entry.textShadowFilter }
+  };
+}
+function chartStroke(model, part) {
+  const entry = model.appearance?.[part];
+  return {
+    color: entry?.axisVisible === false ? "none" : entry?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
+    width: entry?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry.lineWidth)
+  };
+}
+function chartAreaRect(model, part, area) {
+  if (area.w <= 0 || area.h <= 0) return "";
+  const entry = model.appearance?.[part];
+  let fill = entry?.fillColor ?? (part === "chartArea" ? "#FFFFFF" : "none");
+  let defs = "";
+  if (part !== "chartArea" && entry?.gradient && (part !== "plotArea" || ["circle", "shape"].includes(entry.gradient.path ?? ""))) {
+    const def = buildChartGradientDef(`xlsx-chart-${++nextPaintId}-${part}`, entry.gradient, {
+      width: area.w,
+      height: area.h,
+      shape: "rect"
+    });
+    defs = `<defs>${chartGradientMarkup(def)}</defs>`;
+    fill = `url(#${def.id})`;
+  }
+  const stroke = entry?.lineColor ?? "none";
+  if (fill === "none" && stroke === "none") return "";
+  const width = entry?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry.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(text(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 cx = 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 = (at, outward) => [
+        at + (outward ? dir2 : -dir2) * GAP,
+        (outward ? dir2 : -dir2) > 0 ? "start" : "end"
+      ];
+      const [x, anchor] = position === "ctr" ? [cx, "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, cx, 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 place2 = (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] = place2(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] = place2(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] = place2(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(
+    (s) => s.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((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 a = stacked ? frame2.value(from) : base;
+      const b = frame2.value(to);
+      const offset = barOffset(si);
+      const center = frame2.band(i);
+      const width = model.horizontal ? Math.abs(b - a) : barSize;
+      const height = model.horizontal ? barSize : Math.abs(b - a);
+      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}">`);
+      const box = model.horizontal ? { x: Math.min(a, b), y: center + offset, w: Math.abs(b - a), h: barSize } : { x: center + offset, y: Math.min(a, b), w: barSize, h: Math.abs(b - a) };
+      out.push(rect2(box.x, box.y, box.w, box.h, color, s.shadowFilter));
+      out.push("</g>");
+      marks.push({ series: s, index: i, ...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, 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)
+    );
+  }
+}
+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 [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-appearance.ts
-var chartPointsToPixels = (points) => points * EMU_PER_POINT / EMU_PER_PIXEL;
-function typeface(entry, theme) {
-  const name = entry.typeface;
-  if (name?.startsWith("+mj-")) return theme.majorFont;
-  if (name?.startsWith("+mn-")) return theme.minorFont;
-  return name ?? (entry.fontRef?.index === "major" ? theme.majorFont : entry.fontRef?.index === "minor" ? theme.minorFont : void 0);
+// chart/render/chart-scale.ts
+var clean = (n2) => Number(n2.toPrecision(12));
+function* units(raw) {
+  let exp = Math.floor(Math.log10(raw)) - 1;
+  for (; ; ) {
+    const base = 10 ** exp;
+    for (const m of [1, 2, 5]) yield clean(m * base);
+    exp++;
+  }
 }
-function chartAppearance(chart, theme) {
-  const defaults = builtInChartTextStyle(effectiveBuiltInChartStyle(chart.formatting));
-  const entries = {};
-  for (const part of CHART_STYLE_PARTS) {
-    const base = chart.styleDefinition?.entries[part];
-    const direct = chart.formatting?.entries[part];
-    if (!defaults[part] && !base && !direct) continue;
-    const entry = {
-      ...inheritChartText(
-        part,
-        { ...defaults[part], ...base, sourceXml: base?.sourceXml ?? "" },
-        defaults[part],
-        chart.formatting?.textDefaults
-      ),
-      ...direct,
-      sourceXml: direct?.sourceXml ?? base?.sourceXml ?? ""
-    };
-    if (base?.line || direct?.line) entry.line = { ...base?.line, ...direct?.line };
-    entries[part] = entry;
+function niceScale(dataMin, dataMax, options = {}) {
+  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
+  let lo = Number.isFinite(dataMin) ? dataMin : 0;
+  let hi = Number.isFinite(dataMax) ? dataMax : 0;
+  if (lo > hi) [lo, hi] = [hi, lo];
+  if (lo === hi) {
+    if (lo === 0) hi = 1;
+    else if (options.noZero) {
+      const pad = Math.abs(lo) * 0.1 || 1;
+      lo -= pad;
+      hi += pad;
+    } else if (lo > 0) lo = 0;
+    else hi = 0;
   }
-  const scheme = chartColorScheme(theme);
-  const resolve = (color) => resolveDrawingColor(
-    color,
-    { scheme: (name) => scheme[name] },
-    { hslRounding: "halfDown", transformOrder: "document" }
-  );
-  const out = resolveChartStyleDefinition(
-    { entries},
-    (color) => drawingColorCss(resolve(color))
-  ) ?? {};
-  for (const part of CHART_STYLE_PARTS) {
-    const entry = entries[part];
-    if (!entry) continue;
-    const family = typeface(entry, theme);
-    const shadow = resolveDrawingShadowXml(entry.textEffectsXml, {
-      scheme: (name) => scheme[name]
-    });
-    if (shadow) (out[part] ??= {}).textShadow = shadow;
-    if (family) (out[part] ??= {}).typeface = family;
-    if (entry.axisVisible !== void 0) (out[part] ??= {}).axisVisible = entry.axisVisible;
-    if (entry.labelsVisible !== void 0) (out[part] ??= {}).labelsVisible = entry.labelsVisible;
-    if (entry.line?.widthEmu === 0) (out[part] ??= {}).lineWidth = 0;
-    if (entry.fill?.kind === "gradient") {
-      (out[part] ??= {}).gradient = resolveChartGradient(entry.fill, resolve);
+  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;
     }
   }
-  return out;
+  const range = hi - lo;
+  const top = fixedHi ? hi : hi + range * 0.05;
+  const bottom = fixedLo ? lo : lo - range * 0.05;
+  for (const unit of units(range / maxIntervals)) {
+    const min = fixedLo ? lo : Math.floor(clean(bottom / unit)) * unit;
+    const max = fixedHi ? hi : Math.ceil(clean(top / unit)) * unit;
+    const intervals = Math.round((max - min) / unit);
+    if (intervals <= maxIntervals && intervals > 0) {
+      const ticks = [];
+      for (let i = 0; i <= intervals; i++) ticks.push(clean(min + i * unit));
+      return { min: clean(min), max: clean(max), majorUnit: unit, ticks };
+    }
+  }
+  return { min: lo, max: hi, majorUnit: range, ticks: [lo, hi] };
+}
+var PERCENT_SCALE = {
+  min: 0,
+  max: 1,
+  majorUnit: 0.1,
+  ticks: [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+};
+function formatAxisValue(value, percent = false) {
+  if (percent) return `${clean(value * 100)}%`;
+  const v = clean(value);
+  if (Math.abs(v) >= 1e15 || v !== 0 && Math.abs(v) < 1e-6)
+    return v.toExponential(2).replace("e+", "E+").replace("e-", "E-");
+  const [int = "0", frac] = String(Math.abs(v)).split(".");
+  const grouped = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${v < 0 ? "-" : ""}${grouped}${frac ? `.${frac}` : ""}`;
 }
 
 // chart/render/chart-view-analysis.ts
@@ -13079,12 +13685,70 @@ function chartTitleText(chart, theme) {
   };
 }
 
+// chart/render/chart-view-labels.ts
+function labelsOf(source, view, categories, numberFormat) {
+  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, i) => {
+    const point = points?.[i];
+    if (value === null || point?.deleted === true) return;
+    const position = point?.position ?? series?.position ?? chart?.position;
+    const x = view.xValues?.[i];
+    const category = x === void 0 || x === null ? categories[i] : 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 ?? numberFormat,
+        percentBase,
+        bubbleSize: view.sizes?.[i] ?? void 0,
+        formatValue: (v) => formatAxisValue(v),
+        formatBubbleSize: (size) => formatAxisValue(size)
+      });
+    }
+    if (!built) return;
+    any = true;
+    out[i] = {
+      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, i) => apply(sources[i], view));
+  model.extraGroups?.forEach(
+    (group2, g) => group2.series.forEach((view, i) => apply(extra[g]?.series[i], view))
+  );
+}
+
 // chart/render/chart-view-ex.ts
 function groupsAxis(groups, categories) {
   let min = Infinity;
   let max = -Infinity;
-  for (const group of groups) {
-    const extent = valueExtent(group.type, group.grouping, group.series, categories);
+  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);
   }
@@ -13093,17 +13757,17 @@ function groupsAxis(groups, categories) {
 function chartExtraView(chart, model, ctx, total, categoriesOf) {
   let index = chart.series.length;
   const groups = [];
-  for (const group of chart.extraGroups ?? []) {
-    const series = group.series.map((s) => seriesView(ctx, s, index++, total, categoriesOf));
+  for (const group2 of chart.extraGroups ?? []) {
+    const series = group2.series.map((s) => seriesView(ctx, s, index++, total, categoriesOf));
     const view = {
-      type: group.chartType,
-      grouping: group.grouping ?? (group.chartType === "column" ? "clustered" : "standard"),
+      type: group2.chartType,
+      grouping: group2.grouping ?? (group2.chartType === "column" ? "clustered" : "standard"),
       series,
-      secondary: group.secondary
+      secondary: group2.secondary
     };
-    if (group.chartType === "stock") view.stock = stockView(group.stock, ctx);
-    if (group.barGapWidth !== void 0) view.barGapWidth = group.barGapWidth;
-    if (group.barOverlap !== void 0) view.barOverlap = group.barOverlap;
+    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;
@@ -13120,8 +13784,8 @@ function chartExtraAxes(model) {
   const own2 = valueExtent(model.type, model.grouping, model.series, count);
   let min = own2.min;
   let max = own2.max;
-  for (const group of shared) {
-    const extent = valueExtent(group.type, group.grouping, group.series, count);
+  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);
   }
@@ -13264,115 +13928,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 prefix2 = `xlsx-chart-${++nextPaintId}`;
-  const appearance = { ...model.appearance };
-  const defs = [];
-  const shadowPaint = (shadow, suffix) => {
-    const id = `${prefix2}-${suffix}`;
-    const pad = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
-    defs.push(
-      `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad)}" y="${n(-pad)}" width="${n(width + pad * 2)}" height="${n(height + pad * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
-    );
-    return `url(#${id})`;
-  };
-  for (const [part, entry] of Object.entries(appearance)) {
-    if (entry?.textShadow)
-      appearance[part] = {
-        ...entry,
-        textShadowFilter: shadowPaint(entry.textShadow, `${part}-text-shadow`)
-      };
-  }
-  const paint2 = (gradient, suffix, bounds) => {
-    const def = buildChartGradientDef(`${prefix2}-${suffix}`, gradient, bounds);
-    defs.push(chartGradientMarkup(def));
-    return `url(#${def.id})`;
-  };
-  for (const part of ["chartArea", "plotArea"]) {
-    const entry = appearance[part];
-    if (!entry?.gradient) continue;
-    if (part === "plotArea" && ["circle", "shape"].includes(entry.gradient.path ?? "")) continue;
-    appearance[part] = {
-      ...entry,
-      fillColor: paint2(entry.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 = 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)] = paint2(gradient, `s${index}-p${key}`, bounds);
-    }
-    return view;
-  });
-  return defs.length ? { model: { ...model, appearance, series }, defs: `<defs>${defs.join("")}</defs>` } : { model, defs: "" };
-}
-function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
-  const entry = model.appearance?.[part];
-  return {
-    size: entry?.fontSize === void 0 ? fallbackSize : chartPointsToPixels(entry.fontSize),
-    ...entry?.color === void 0 ? {} : { fill: entry.color },
-    ...entry?.bold === void 0 ? {} : { weight: entry.bold ? "bold" : "normal" },
-    ...entry?.italic === void 0 ? {} : { italic: entry.italic },
-    ...entry?.underline === void 0 ? {} : { underline: entry.underline },
-    ...entry?.typeface === void 0 ? {} : { family: cssFontFamily(entry.typeface) },
-    ...entry?.textShadowFilter === void 0 ? {} : { filter: entry.textShadowFilter }
-  };
-}
-function chartStroke(model, part) {
-  const entry = model.appearance?.[part];
-  return {
-    color: entry?.axisVisible === false ? "none" : entry?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
-    width: entry?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry.lineWidth)
-  };
-}
-function chartAreaRect(model, part, area) {
-  if (area.w <= 0 || area.h <= 0) return "";
-  const entry = model.appearance?.[part];
-  let fill = entry?.fillColor ?? (part === "chartArea" ? "#FFFFFF" : "none");
-  let defs = "";
-  if (part !== "chartArea" && entry?.gradient && (part !== "plotArea" || ["circle", "shape"].includes(entry.gradient.path ?? ""))) {
-    const def = buildChartGradientDef(`xlsx-chart-${++nextPaintId}-${part}`, entry.gradient, {
-      width: area.w,
-      height: area.h,
-      shape: "rect"
-    });
-    defs = `<defs>${chartGradientMarkup(def)}</defs>`;
-    fill = `url(#${def.id})`;
-  }
-  const stroke = entry?.lineColor ?? "none";
-  if (fill === "none" && stroke === "none") return "";
-  const width = entry?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry.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;
@@ -13491,6 +14051,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 layers = [];
   model.series.forEach((s, si) => {
     const points = [];
@@ -13505,6 +14066,13 @@ function linesAndAreas(model, frame2, out) {
       const top = below2 + (v ?? 0);
       if (stacked) acc[i] = top;
       points.push([frame2.band(i), frame2.value(top)]);
+      marks.push({
+        series: s,
+        index: i,
+        x: frame2.band(i),
+        y: frame2.value(top),
+        radius: area ? 0 : 3
+      });
       lower.push([frame2.band(i), frame2.value(below2)]);
     });
     layers.push({
@@ -13537,6 +14105,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
@@ -13606,6 +14175,7 @@ function scatter(model, area, out) {
     line2(plot.x, plot.y + plot.h, plot.x + plot.w, plot.y + plot.h, xAxis.color, xAxis.width)
   );
   out.push(line2(plot.x, plot.y, plot.x, plot.y + plot.h, yAxis.color, yAxis.width));
+  const marks = [];
   for (const [si, s] of model.series.entries())
     s.values.forEach((v, i) => {
       const x = s.xValues?.[i] ?? null;
@@ -13614,14 +14184,17 @@ function scatter(model, area, out) {
       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}/>`);
+        marks.push({ series: s, index: i, x: px(x), y: py(v), radius: 3 });
         return;
       }
       const r = radiusOf(s.sizes?.[i] ?? void 0);
       if (r === void 0) return;
+      marks.push({ series: s, index: i, x: px(x), y: py(v), radius: r });
       out.push(
         `<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}/>`
       );
     });
+  pointLabels(model, marks, out);
   scatterAnalysis(model, px, py, out);
 }
 
@@ -13738,21 +14311,21 @@ function cartesianSvg(model, area) {
     return out.join("");
   }
   const layers = [{ model, frame: frame2 }];
-  for (const group of model.extraGroups ?? []) {
+  for (const group2 of model.extraGroups ?? []) {
     const grouped = {
       ...model,
-      type: group.type,
-      grouping: group.grouping,
-      series: group.series,
+      type: group2.type,
+      grouping: group2.grouping,
+      series: group2.series,
       horizontal: false
     };
-    if (group.stock) grouped.stock = group.stock;
+    if (group2.stock) grouped.stock = group2.stock;
     else delete grouped.stock;
-    if (group.barGapWidth !== void 0) grouped.barGapWidth = group.barGapWidth;
+    if (group2.barGapWidth !== void 0) grouped.barGapWidth = group2.barGapWidth;
     else delete grouped.barGapWidth;
-    if (group.barOverlap !== void 0) grouped.barOverlap = group.barOverlap;
+    if (group2.barOverlap !== void 0) grouped.barOverlap = group2.barOverlap;
     else delete grouped.barOverlap;
-    const value = group.secondary && frame2.secondary ? frame2.secondary : frame2.value;
+    const value = group2.secondary && frame2.secondary ? frame2.secondary : frame2.value;
     layers.push({ model: grouped, frame: { ...frame2, value } });
   }
   layers.map((layer, order) => ({ layer, order })).sort(
@@ -13786,7 +14359,9 @@ function pieSvg(model, area) {
   const out = [chartAreaRect(model, "plotArea", area)];
   const cx = area.x + area.w / 2;
   const cy = area.y + area.h / 2;
-  const radius = Math.max(1, Math.min(area.w, area.h) / 2 - 4);
+  const 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);
@@ -13803,9 +14378,20 @@ function pieSvg(model, area) {
       out.push(
         `<path d="${slicePath(cx, cy, outer, inner, angle, angle + sweep)}" fill="${color}" stroke="#FFFFFF" stroke-width="1"${s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""}/>`
       );
+      slices.push({
+        series: s,
+        index: i,
+        cx,
+        cy,
+        outer,
+        inner,
+        start: angle,
+        end: angle + sweep
+      });
       angle += sweep;
     });
   });
+  sliceLabels(model, slices, out);
   return out.join("");
 }
 function radarSvg(model, area) {
@@ -13851,12 +14437,16 @@ function radarSvg(model, area) {
         })
       );
   });
+  const marks = [];
   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 vertices = s.values.slice(0, count).map((v, i) => polar(cx, cy, r(v ?? scale.min), angle(i)));
+    vertices.forEach(([x, y], i) => marks.push({ series: s, index: i, x, y, radius: 3 }));
+    const points = vertices.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}"` : ""}/>`
     );
   }
+  pointLabels(model, marks, out);
   return out.join("");
 }
 
@@ -14108,17 +14698,17 @@ function automaticLegend(model, area, out, options, bounds) {
 
 // text/wrap-styled-runs.ts
 var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
+function wrapStyledRuns(runs, maxWidth, measure2, options = {}) {
   const groups = [];
   for (const [source, run] of runs.entries()) {
     for (const token of run.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, source, text: token });
+      if (kind !== "break") group2.pieces.push({ run, source, text: token });
     }
   }
   const merged = (left, right) => {
@@ -14131,7 +14721,7 @@ function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
     return result2;
   };
   const width = (pieces) => pieces.reduce((sum, piece) => {
-    const advance = measure(piece.text, piece.run);
+    const advance = measure2(piece.text, piece.run);
     return sum + (Number.isFinite(advance) && advance >= 0 ? advance : 0);
   }, 0);
   const result = [];
@@ -14142,29 +14732,29 @@ function wrapStyledRuns(runs, maxWidth, measure, options = {}) {
     line3 = [];
     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 = line3.length ? spaces : [];
-    const wordWidth = width(group.pieces);
-    if (line3.length && width(merged(line3, [...separator, ...group.pieces])) > maxWidth) flush();
+    const wordWidth = width(group2.pieces);
+    if (line3.length && width(merged(line3, [...separator, ...group2.pieces])) > maxWidth) flush();
     else line3 = merged(line3, separator);
     spaces = [];
     if (options.breakWords && wordWidth > maxWidth) {
-      for (const piece of group.pieces) {
+      for (const piece of group2.pieces) {
         for (const { segment: segment2 } of graphemes.segment(piece.text)) {
           const next = { ...piece, text: segment2 };
           if (line3.length && width(merged(line3, [next])) > maxWidth) flush();
           line3 = merged(line3, [next]);
         }
       }
-    } else line3 = merged(line3, group.pieces);
+    } else line3 = merged(line3, group2.pieces);
   }
   flush();
   return result;
@@ -14521,11 +15111,11 @@ function parseDirectParagraphProperties(props) {
 
 // docx/numbering-parse.ts
 var own = (map, key) => Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
-function resolveNumberingLevel(catalog, numId, level) {
+function resolveNumberingLevel(catalog, numId, level2) {
   const num = own(catalog.nums, numId);
   if (!num) return void 0;
-  const override = num.levelOverrides?.[level];
-  const sourceAbstract = own(catalog.abstractNums, num.abstractNumId)?.levels[level];
+  const override = num.levelOverrides?.[level2];
+  const sourceAbstract = own(catalog.abstractNums, num.abstractNumId)?.levels[level2];
   const abstract = sourceAbstract?.startWasOmitted && sourceAbstract.start === 1 ? { ...sourceAbstract, start: 0 } : sourceAbstract;
   let base = override?.lvl ?? abstract;
   if (!base) return void 0;
@@ -14924,10 +15514,10 @@ function resolveParagraphNumbering(paragraph, styleCatalog, numberingCatalog) {
   const inherited = resolveStyleNumbering(paragraph.style, styleCatalog);
   if (!inherited || inherited.numId <= 0) return void 0;
   if (numberingCatalog && paragraph.style && styleCatalog.styles[paragraph.style]) {
-    for (let level = 0; level < 9; level++) {
-      const definition = resolveNumberingLevel(numberingCatalog, String(inherited.numId), level);
+    for (let level2 = 0; level2 < 9; level2++) {
+      const definition = resolveNumberingLevel(numberingCatalog, String(inherited.numId), level2);
       if (definition?.paragraphStyleId === paragraph.style)
-        return { numId: inherited.numId, level };
+        return { numId: inherited.numId, level: level2 };
     }
   }
   return inherited;
@@ -14960,23 +15550,23 @@ var NumberingCounters = class {
     return started;
   }
   /** Advances one level and resets deeper counters according to their resolved restart rules. */
-  advance(numId, level, def, catalog) {
+  advance(numId, level2, def, catalog) {
     const counts = this.forNum(numId);
     const started = this.startedLevels(numId);
-    const next = started.has(level) ? (counts.get(level) ?? def.start) + 1 : def.start;
-    counts.set(level, next);
-    started.add(level);
+    const next = started.has(level2) ? (counts.get(level2) ?? def.start) + 1 : def.start;
+    counts.set(level2, next);
+    started.add(level2);
     for (const deeper of [...started]) {
-      if (deeper <= level) continue;
+      if (deeper <= level2) continue;
       const deeperDef = resolveNumberingLevel(catalog, numId, deeper);
       const restart = deeperDef?.lvlRestart;
       if (restart === 0) continue;
       const trigger = restart !== void 0 && restart > 0 && restart <= deeper ? restart - 1 : deeper - 1;
-      if (level > trigger) continue;
+      if (level2 > trigger) continue;
       counts.delete(deeper);
       started.delete(deeper);
     }
-    for (let ancestor = 0; ancestor < level; ancestor++) {
+    for (let ancestor = 0; ancestor < level2; ancestor++) {
       if (started.has(ancestor)) continue;
       const ancestorDef = resolveNumberingLevel(catalog, numId, ancestor);
       if (!ancestorDef) continue;
@@ -14986,14 +15576,14 @@ var NumberingCounters = class {
     return next;
   }
   /** Current value for an ancestor placeholder, defaulting to its own start when never instantiated. */
-  current(numId, level, start) {
-    return this.forNum(numId).get(level) ?? start;
+  current(numId, level2, start) {
+    return this.forNum(numId).get(level2) ?? start;
   }
 };
-function substituteLvlText(lvlText, numId, level, catalog, counters, forceDecimal) {
+function substituteLvlText(lvlText, numId, level2, catalog, counters, forceDecimal) {
   return lvlText.replace(/%([1-9])/g, (match, digit) => {
     const ancestorLevel = Number(digit) - 1;
-    if (ancestorLevel > level) return match;
+    if (ancestorLevel > level2) return match;
     const ancestorDef = resolveNumberingLevel(catalog, numId, ancestorLevel);
     const start = ancestorDef?.start ?? 1;
     const value = counters.current(numId, ancestorLevel, start);
@@ -15010,15 +15600,15 @@ function computeListLabels(model) {
     const numbering = resolveParagraphNumbering(paragraph, model.paragraphStyles, catalog);
     if (!numbering) continue;
     const numId = String(numbering.numId);
-    const level = Math.min(8, Math.max(0, numbering.level));
-    const def = resolveNumberingLevel(catalog, numId, level);
+    const level2 = Math.min(8, Math.max(0, numbering.level));
+    const def = resolveNumberingLevel(catalog, numId, level2);
     if (!def) continue;
     if (def.numFmt === "none") continue;
-    counters.advance(numId, level, def, catalog);
-    const text2 = def.numFmt === "bullet" ? def.lvlText : substituteLvlText(def.lvlText, numId, level, catalog, counters, Boolean(def.isLgl));
+    counters.advance(numId, level2, def, catalog);
+    const text2 = def.numFmt === "bullet" ? def.lvlText : substituteLvlText(def.lvlText, numId, level2, catalog, counters, Boolean(def.isLgl));
     labels.set(paragraph.id, {
       numId,
-      level,
+      level: level2,
       text: text2,
       suffix: def.suffix ?? "tab",
       ...definedProps({
@@ -15481,12 +16071,12 @@ function headerFooterSlotForPage(model, page, pageNumber) {
   return page.pageInSection === 0 && section?.titlePage ? "first" : model.evenAndOddHeaders && pageNumber % 2 === 0 ? "even" : "default";
 }
 function headerFooterForPage(model, page, pageNumber, kind) {
-  const sections = model.sections ?? [];
-  const section = sections[page.sectionIndex];
+  const sections2 = model.sections ?? [];
+  const section = sections2[page.sectionIndex];
   if (!section) return void 0;
   const slot = headerFooterSlotForPage(model, page, pageNumber);
   for (let index = page.sectionIndex; index >= 0; index--) {
-    const content = sections[index]?.[kind]?.[slot];
+    const content = sections2[index]?.[kind]?.[slot];
     if (content) return content;
   }
   return void 0;
@@ -17223,11 +17813,11 @@ function completedNoteStoryMinimum(row2, stories, pendingBlocks, available) {
   for (const [index, cell] of row2.cells.entries()) {
     const groups = /* @__PURE__ */ new Map();
     for (const box of cell) {
-      const group = stories.get(box.blockId);
-      if (group !== void 0) {
-        const boxes = groups.get(group) ?? [];
+      const group2 = stories.get(box.blockId);
+      if (group2 !== void 0) {
+        const boxes = groups.get(group2) ?? [];
         boxes.push(box);
-        groups.set(group, boxes);
+        groups.set(group2, boxes);
       }
     }
     for (const boxes of groups.values()) {
@@ -17293,8 +17883,8 @@ var TableFootnotes = class {
       for (const cell of row2.cells) {
         for (const paragraph of cellParagraphs(cell))
           if (paragraph.footnotes?.length) this.paragraphs.set(paragraph.id, paragraph);
-        for (const [id, group] of (measured ? independentNoteStories(cell) : void 0) ?? []) {
-          this.stories.set(id, group);
+        for (const [id, group2] of (measured ? independentNoteStories(cell) : void 0) ?? []) {
+          this.stories.set(id, group2);
         }
       }
     }
@@ -17427,11 +18017,11 @@ var TableFootnotes = class {
           for (const [index, cell] of row2.cells.entries()) {
             const groups = /* @__PURE__ */ new Map();
             for (const box of cell) {
-              const group = this.stories.get(box.blockId);
-              if (group !== void 0) {
-                const boxes = groups.get(group) ?? [];
+              const group2 = this.stories.get(box.blockId);
+              if (group2 !== void 0) {
+                const boxes = groups.get(group2) ?? [];
                 boxes.push(box);
-                groups.set(group, boxes);
+                groups.set(group2, boxes);
               }
             }
             for (const boxes of groups.values()) {
@@ -19955,14 +20545,14 @@ function adaptDocumentModel(model, note = () => {
       note2.blocks.filter((block) => block.type === "paragraph").map((paragraph) => adaptParagraph(paragraph))
     ])
   ) : void 0;
-  const sections = model.sections;
+  const sections2 = model.sections;
   const modernFootnoteSeparator = model.compatibilityMode === 15;
   const legacyFootnoteColumns = model.compatibilityMode === 12 || model.compatibilityMode === 14;
   if (!modernFootnoteSeparator && !legacyFootnoteColumns && model.sections?.some((section) => section.footnoteColumns !== void 0))
     reportOnce(
       "Footnote column settings are preserved, but this compatibility mode has not been verified against native Word; Print Layout uses the existing page-wide fallback."
     );
-  if (!sections || !sections.length) {
+  if (!sections2 || !sections2.length) {
     return {
       sections: [
         {
@@ -19984,8 +20574,8 @@ function adaptDocumentModel(model, note = () => {
   }
   const indexById = new Map(model.blocks.map((block, index) => [block.id, index]));
   let start = 0;
-  const result = sections.map((section, index) => {
-    const last = index === sections.length - 1;
+  const result = sections2.map((section, index) => {
+    const last = index === sections2.length - 1;
     const endIndex = last ? blocks.length : (indexById.get(section.endsAtBlockId) ?? start - 1) + 1;
     const end = Math.max(start, endIndex);
     const slice = blocks.slice(start, end);