ooxml-core 1.18.0 → 1.19.0

package/dist/index.mjs

@@ -141,8 +141,8 @@ function rgbToHsl(r, g2, b) {
   }
   return { h: h2, s: clampUnitInterval(s2), l: clampUnitInterval(l) };
 }
-function hslToRgb(h2, s2, l, roundChannel = Math.round, options) {
-  const sC = options?.clampSaturation === false ? s2 : clampUnitInterval(s2);
+function hslToRgb(h2, s2, l, roundChannel = Math.round, options2) {
+  const sC = options2?.clampSaturation === false ? s2 : clampUnitInterval(s2);
   const lC = clampUnitInterval(l);
   const hN = (h2 % 360 + 360) % 360;
   const c2 = (1 - Math.abs(2 * lC - 1)) * sC;
@@ -646,9 +646,11 @@ __export(chart_exports, {
   aggregateByCategory: () => aggregateByCategory,
   assertBarClusterOptions: () => assertBarClusterOptions,
   autoSeriesColor: () => autoSeriesColor,
+  automaticMarkerSymbol: () => automaticMarkerSymbol,
   axisTargetIntervals: () => axisTargetIntervals,
   buildChartGradientDef: () => buildChartGradientDef,
   buildHierarchyRoots: () => buildHierarchyRoots,
+  buildMarkerPrimitive: () => buildMarkerPrimitive,
   buildWaterfallSteps: () => buildWaterfallSteps,
   builtInChartStyleXml: () => builtInChartStyleXml,
   builtInChartTextStyle: () => builtInChartTextStyle,
@@ -660,10 +662,13 @@ __export(chart_exports, {
   chartErrorBarAmount: () => chartErrorBarAmount,
   chartExSummary: () => chartExSummary,
   chartGradientMarkup: () => chartGradientMarkup,
+  chartLineDashArray: () => chartLineDashArray,
+  chartMarkerRadius: () => chartMarkerRadius,
   chartPaletteColors: () => chartPaletteColors,
   chartPaletteSeriesColor: () => chartPaletteSeriesColor,
   chartPaletteSeriesColorChoice: () => chartPaletteSeriesColorChoice,
   chartSampleVariance: () => chartSampleVariance,
+  chartSeriesMarkerSvg: () => chartSeriesMarkerSvg,
   chartSourceValues: () => chartSourceValues,
   chartSpaceKind: () => chartSpaceKind,
   chartSummaryFromSpace: () => chartSummaryFromSpace,
@@ -674,18 +679,25 @@ __export(chart_exports, {
   chartTrendlineType: () => chartTrendlineType,
   clusteredBarGeometry: () => clusteredBarGeometry,
   composeDataLabelText: () => composeDataLabelText,
+  computeAxisStackedValueRange: () => computeAxisStackedValueRange,
+  computeAxisValueRange: () => computeAxisValueRange,
   computeBoxStats: () => computeBoxStats,
   computeBubbleRadius: () => computeBubbleRadius,
   computeHierarchicalSunburstArcs: () => computeHierarchicalSunburstArcs,
   computeHistogramBins: () => computeHistogramBins,
   computeLinearRegression: () => computeLinearRegression,
+  computeLogValueRange: () => computeLogValueRange,
   computeRSquared: () => computeRSquared,
   computeRadarPoints: () => computeRadarPoints,
   computeStackedSeriesPlots: () => computeStackedSeriesPlots,
+  computeStackedValueRangeForAxis: () => computeStackedValueRangeForAxis,
   computeSunburstArcs: () => computeSunburstArcs,
+  computeValueRangeForAxis: () => computeValueRangeForAxis,
+  computeValueRangeForChart: () => computeValueRangeForChart,
   computeWaterfallRange: () => computeWaterfallRange,
   effectiveBuiltInChartStyle: () => effectiveBuiltInChartStyle,
   findChartColorPalette: () => findChartColorPalette,
+  findLogAxis: () => findLogAxis,
   fitChartTrendline: () => fitChartTrendline,
   fitPolynomial: () => fitPolynomial,
   formatChartNumber: () => formatChartNumber,
@@ -697,6 +709,9 @@ __export(chart_exports, {
   formatPolynomialEquation: () => formatPolynomialEquation,
   formatPowerEquation: () => formatPowerEquation,
   formatTrendlineCoefficient: () => formatTrendlineCoefficient,
+  generateAxisTicks: () => generateAxisTicks,
+  generateLogTicks: () => generateLogTicks,
+  generateMinorAxisTicks: () => generateMinorAxisTicks,
   getChartStylePalette: () => getChartStylePalette,
   groupRowsByCategory: () => groupRowsByCategory,
   hasManualLayoutFields: () => hasManualLayoutFields,
@@ -704,6 +719,8 @@ __export(chart_exports, {
   impliesAutoTitle: () => impliesAutoTitle,
   isChartexOnlyType: () => isChartexOnlyType,
   layoutTreemap: () => layoutTreemap,
+  markerOutline: () => markerOutline,
+  markerRadius: () => markerRadius,
   maxBubbleSize: () => maxBubbleSize,
   medianBubbleRadius: () => medianBubbleRadius,
   modulateLuminance: () => modulateLuminance,
@@ -731,16 +748,20 @@ __export(chart_exports, {
   resolveDataLabelFlags: () => resolveDataLabelFlags,
   resolveManualLayoutRect: () => resolveManualLayoutRect,
   scottBinCount: () => scottBinCount,
+  seriesMarkerViews: () => seriesMarkerViews,
   shade: () => shade,
   sortGradientStops: () => sortGradientStops,
   squarify: () => squarify,
   stockCandle: () => stockCandle,
   stockSlots: () => stockSlots,
+  summaryMarkers: () => summaryMarkers,
   sunburstArcPath: () => sunburstArcPath,
   themeColor: () => themeColor,
   tint: () => tint,
   updateGradientStop: () => updateGradientStop,
+  valueToYLog: () => valueToYLog,
   visibleRuns: () => visibleRuns,
+  withAxisBounds: () => withAxisBounds,
   withChartGradientDirection: () => withChartGradientDirection,
   withinLinearTransform: () => withinLinearTransform,
   writeChartAxisFormatting: () => writeChartAxisFormatting,
@@ -1357,12 +1378,12 @@ function formatCompactAxisValue(value, formatCode) {
 }
 
 // chart/bubble-radius.ts
-function computeBubbleRadius(sizeVal, maxBubble, medianRadius, options) {
-  const scale = (options?.bubbleScale ?? 100) / 100;
+function computeBubbleRadius(sizeVal, maxBubble, medianRadius, options2) {
+  const scale = (options2?.bubbleScale ?? 100) / 100;
   if (sizeVal === void 0) return medianRadius * scale;
   const denom = maxBubble > 0 ? maxBubble : 1;
   const magnitude = Math.abs(sizeVal);
-  const ratio = (options?.sizeRepresents ?? "w") === "area" ? Math.sqrt(magnitude) / Math.sqrt(denom) : magnitude / denom;
+  const ratio = (options2?.sizeRepresents ?? "w") === "area" ? Math.sqrt(magnitude) / Math.sqrt(denom) : magnitude / denom;
   return medianRadius * scale * 0.5 + ratio * medianRadius * scale * 1.5;
 }
 function maxBubbleSize(sizes) {
@@ -1763,14 +1784,14 @@ function scottBinCount(values, min, max) {
   const width = 3.49 * sd * values.length ** (-1 / 3);
   return Math.max(1, Math.ceil((max - min) / width));
 }
-function computeHistogramBins(values, options, format = String) {
-  const closed = options.intervalClosed ?? "l";
+function computeHistogramBins(values, options2, format = String) {
+  const closed = options2.intervalClosed ?? "l";
   const finite4 = values.map((value, sourceIndex) => ({ value, sourceIndex })).filter((item) => Number.isFinite(item.value));
   if (finite4.length === 0) {
     return [];
   }
-  const underflow = typeof options.underflow === "number" ? options.underflow : void 0;
-  const overflow = typeof options.overflow === "number" ? options.overflow : void 0;
+  const underflow = typeof options2.underflow === "number" ? options2.underflow : void 0;
+  const overflow = typeof options2.overflow === "number" ? options2.overflow : void 0;
   const under = underflow === void 0 ? [] : finite4.filter(
     (item) => closed === "r" ? item.value <= underflow : item.value < underflow
   );
@@ -1787,8 +1808,8 @@ function computeHistogramBins(values, options, format = String) {
   if (regular.length > 0) {
     const min = Math.min(...regular.map((item) => item.value));
     const max = Math.max(...regular.map((item) => item.value));
-    const requestedSize = options.binSize && options.binSize > 0 ? options.binSize : void 0;
-    const requestedCount = options.binCount && options.binCount > 0 ? options.binCount : void 0;
+    const requestedSize = options2.binSize && options2.binSize > 0 ? options2.binSize : void 0;
+    const requestedCount = options2.binCount && options2.binCount > 0 ? options2.binCount : void 0;
     const start = requestedSize ? Math.floor(min / requestedSize) * requestedSize : min;
     const count = requestedSize ? Math.max(
       closed === "l" ? Math.floor((max - start) / requestedSize) + 1 : Math.ceil((max - start) / requestedSize),
@@ -1839,9 +1860,9 @@ function aggregateByCategory(values, rawCategories) {
 }
 
 // chart/waterfall.ts
-function buildWaterfallSteps(values, options) {
+function buildWaterfallSteps(values, options2) {
   const subtotalIndices = new Set(
-    options?.subtotalIndices ?? (values.length > 0 ? [values.length - 1] : [])
+    options2?.subtotalIndices ?? (values.length > 0 ? [values.length - 1] : [])
   );
   const steps = [];
   let runningTotal = 0;
@@ -1917,13 +1938,13 @@ var noFit = () => ({
   rSquared: 0,
   coefficients: []
 });
-function fitModel(options, xVals, yVals) {
+function fitModel(options2, xVals, yVals) {
   const xs = [...xVals];
   const ys = [...yVals];
-  switch (options.kind) {
+  switch (options2.kind) {
     case "linear": {
       const reg = computeLinearRegression(xs, ys);
-      const fixed = options.intercept;
+      const fixed = options2.intercept;
       const slope = fixed !== void 0 ? ys.reduce((s2, y, i2) => s2 + (y - fixed) * xs[i2], 0) / xs.reduce((s2, x) => s2 + x * x, 0) : reg.slope;
       const b = fixed ?? reg.intercept;
       return {
@@ -1973,7 +1994,7 @@ function fitModel(options, xVals, yVals) {
       };
     }
     case "polynomial": {
-      const order = Math.min(options.order ?? 2, 6);
+      const order = Math.min(options2.order ?? 2, 6);
       const coeffs = fitPolynomial(xs, ys, order);
       const evaluate = (x) => coeffs.reduce((s2, c2, i2) => s2 + c2 * x ** i2, 0);
       return {
@@ -1987,11 +2008,11 @@ function fitModel(options, xVals, yVals) {
       return void 0;
   }
 }
-function fitChartTrendline(options, xVals, yVals) {
+function fitChartTrendline(options2, xVals, yVals) {
   const count = yVals.length;
   if (count < 2) return noFit();
-  if (options.kind === "movingAvg") {
-    const period = options.period ?? 2;
+  if (options2.kind === "movingAvg") {
+    const period = options2.period ?? 2;
     const points2 = [];
     for (let i2 = period - 1; i2 < count; i2++) {
       let sum = 0;
@@ -2000,10 +2021,10 @@ function fitChartTrendline(options, xVals, yVals) {
     }
     return { points: points2, equation: `${period}-period moving average`, rSquared: 0, coefficients: [] };
   }
-  const model = fitModel(options, xVals, yVals);
+  const model = fitModel(options2, xVals, yVals);
   if (!model) return noFit();
-  const startX = Math.min(...xVals) - (options.backward ?? 0);
-  const endX = Math.max(...xVals) + (options.forward ?? 0);
+  const startX = Math.min(...xVals) - (options2.backward ?? 0);
+  const endX = Math.max(...xVals) + (options2.forward ?? 0);
   const steps = Math.max(Math.ceil((endX - startX) * 4), 20);
   const points = [];
   for (let step = 0; step <= steps; step++) {
@@ -2026,18 +2047,18 @@ function chartSampleVariance(values) {
   const mean = values.reduce((sum, value) => sum + value, 0) / count;
   return values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / Math.max(count - 1, 1);
 }
-function chartErrorBarAmount(options, values, displayIndex, sourceIndex, side) {
-  switch (options.valueType) {
+function chartErrorBarAmount(options2, values, displayIndex, sourceIndex, side) {
+  switch (options2.valueType) {
     case "fixedVal":
-      return options.value ?? 0;
+      return options2.value ?? 0;
     case "percentage":
-      return Math.abs(values[displayIndex] ?? 0) * ((options.value ?? 0) / 100);
+      return Math.abs(values[displayIndex] ?? 0) * ((options2.value ?? 0) / 100);
     case "stdDev":
-      return Math.sqrt(chartSampleVariance(values)) * (options.value ?? 1);
+      return Math.sqrt(chartSampleVariance(values)) * (options2.value ?? 1);
     case "stdErr":
       return Math.sqrt(chartSampleVariance(values) / Math.max(values.length, 1));
     case "cust":
-      return side === "plus" ? options.customPlus?.[sourceIndex] ?? 0 : options.customMinus?.[sourceIndex] ?? 0;
+      return side === "plus" ? options2.customPlus?.[sourceIndex] ?? 0 : options2.customMinus?.[sourceIndex] ?? 0;
   }
 }
 
@@ -2308,11 +2329,11 @@ function checkXmlLimits(xml, label, limits = {}) {
       throw new Error(`${label} XML exceeds the nesting depth limit of ${maxDepth2}`);
   }
 }
-function parseXml(xml, options = {}) {
-  const label = options.label ?? "OOXML";
+function parseXml(xml, options2 = {}) {
+  const label = options2.label ?? "OOXML";
   if (/<!DOCTYPE|<!ENTITY/i.test(xml))
     throw new Error(`${label} XML with DTD or entity declarations is not supported`);
-  checkXmlLimits(xml, label, options.limits);
+  checkXmlLimits(xml, label, options2.limits);
   let parseError = "";
   let parsed;
   try {
@@ -2697,13 +2718,13 @@ var APPLIED = /* @__PURE__ */ new Set([
   "lumMod",
   "lumOff"
 ]);
-function resolveDrawingColor(color, theme, options) {
+function resolveDrawingColor(color, theme, options2) {
   const base = baseHex(color, theme);
   const rgb = base ? hexToRgbChannels(base) : null;
   if (!rgb) return void 0;
-  if (options?.transformOrder === "document") {
+  if (options2?.transformOrder === "document") {
     const value = orderedColorTransforms(rgb, color.transforms);
-    const round3 = options.hslRounding === "halfDown" ? (channel) => Math.ceil(channel - 0.5) : Math.round;
+    const round3 = options2.hslRounding === "halfDown" ? (channel) => Math.ceil(channel - 0.5) : Math.round;
     return {
       hex: `#${toHex(round3(value.r))}${toHex(round3(value.g))}${toHex(round3(value.b))}`,
       alpha: value.alpha,
@@ -2754,7 +2775,7 @@ function resolveDrawingColor(color, theme, options) {
     if (lumMod !== void 0) hsl.l = clampUnitInterval(hsl.l * lumMod);
     const lumOff = parseDrawingFraction(find("lumOff"));
     if (lumOff !== void 0) hsl.l = clampUnitInterval(hsl.l + lumOff);
-    const round3 = options?.hslRounding === "halfDown" ? (value) => Math.ceil(value - 0.5) : Math.round;
+    const round3 = options2?.hslRounding === "halfDown" ? (value) => Math.ceil(value - 0.5) : Math.round;
     ({ r, g: g2, b } = hslToRgb(hsl.h, hsl.s, hsl.l, round3));
   }
   let alpha = parseDrawingPercent(find("alpha")) ?? 1;
@@ -3740,7 +3761,7 @@ function resolveInnerRect(fillToRect, focalPoint) {
 function lerpEdge(inner, outer, t) {
   return inner + (outer - inner) * t;
 }
-function buildRectPathGradientSvg(stops, focalPoint, fillToRect, options) {
+function buildRectPathGradientSvg(stops, focalPoint, fillToRect, options2) {
   if (stops.length === 0) {
     return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"/>';
   }
@@ -3748,8 +3769,8 @@ function buildRectPathGradientSvg(stops, focalPoint, fillToRect, options) {
   const inner = resolveInnerRect(fillToRect, focalPoint);
   const rects = [];
   const alphaRects = [];
-  const masked = options?.independentOpacity && sorted.some((stop) => (stop.opacity ?? 1) < 1);
-  const bands = options?.bands ?? BAND_COUNT;
+  const masked = options2?.independentOpacity && sorted.some((stop) => (stop.opacity ?? 1) < 1);
+  const bands = options2?.bands ?? BAND_COUNT;
   if (!Number.isInteger(bands) || bands < 1) throw new RangeError("Invalid gradient band count");
   for (let i2 = bands; i2 >= 0; i2 -= 1) {
     const t = i2 / bands;
@@ -3942,12 +3963,12 @@ function chartGradientMarkup(def) {
 
 // chart/bar-cluster-geometry.ts
 var DEFAULT_BAR_GAP_WIDTH = 150;
-function assertBarClusterOptions(options) {
+function assertBarClusterOptions(options2) {
   for (const [field, min, max] of [
     ["barGapWidth", 0, 500],
     ["barOverlap", -100, 100]
   ]) {
-    const value = options[field];
+    const value = options2[field];
     if (value !== void 0 && (!Number.isInteger(value) || value < min || value > max))
       throw new RangeError(`${field} must be an integer from ${min} to ${max}`);
   }
@@ -5233,8 +5254,8 @@ function titleXml(context, title) {
     chartTextXml(context, tx, false) + layoutXml(context, title.layout) + valXml("overlay", title.overlay) + shapePropertiesXml(context, title.spPr) + textBodyXml(context, title.txPr) + raw(context, title.extLst)
   );
 }
-function labelOptionsXml(context, options) {
-  return numberFormatXml(options.numberFormat) + shapePropertiesXml(context, options.spPr) + textBodyXml(context, options.txPr) + valXml("dLblPos", options.position) + valXml("showLegendKey", options.showLegendKey) + valXml("showVal", options.showValue) + valXml("showCatName", options.showCategoryName) + valXml("showSerName", options.showSeriesName) + valXml("showPercent", options.showPercent) + valXml("showBubbleSize", options.showBubbleSize) + (options.separator === void 0 ? "" : textElement("separator", options.separator));
+function labelOptionsXml(context, options2) {
+  return numberFormatXml(options2.numberFormat) + shapePropertiesXml(context, options2.spPr) + textBodyXml(context, options2.txPr) + valXml("dLblPos", options2.position) + valXml("showLegendKey", options2.showLegendKey) + valXml("showVal", options2.showValue) + valXml("showCatName", options2.showCategoryName) + valXml("showSerName", options2.showSeriesName) + valXml("showPercent", options2.showPercent) + valXml("showBubbleSize", options2.showBubbleSize) + (options2.separator === void 0 ? "" : textElement("separator", options2.separator));
 }
 function labelXml(context, label) {
   return elementXml(
@@ -5404,7 +5425,7 @@ function styleXml(context, space3) {
   );
 }
 var relationship = (local, id, content2 = "") => id === void 0 ? "" : elementXml(local, content2, ` r:id="${escapeAttribute(id)}"`);
-function writeChartSpace(space3, options = {}) {
+function writeChartSpace(space3, options2 = {}) {
   const bindings = new Map(CHART_ROOT_BINDINGS);
   for (const { prefix, uri } of space3.namespaceDeclarations ?? [])
     if (!bindings.has(prefix) && /^[A-Za-z_][\w.-]*$/.test(prefix)) bindings.set(prefix, uri);
@@ -5419,10 +5440,204 @@ function writeChartSpace(space3, options = {}) {
     space3.externalDataRelId,
     valXml("autoUpdate", space3.externalDataAutoUpdate)
   ) + raw(context, space3.printSettings) + relationship("userShapes", space3.userShapesRelId) + raw(context, space3.extLst);
-  const breakAfter = options.declarationBreak ?? "\r\n";
+  const breakAfter = options2.declarationBreak ?? "\r\n";
   return `${DECLARATION2}${breakAfter}<c:chartSpace${declarations}>${body}</c:chartSpace>`;
 }
 
+// chart/marker-shape.ts
+var CHART_PX_PER_PT = 4 / 3;
+var DEFAULT_MARKER_OUTLINE_PT = 0.75;
+function markerOutline(marker) {
+  if (!marker.stroke) {
+    return {};
+  }
+  return {
+    stroke: marker.stroke,
+    strokeWidth: (marker.strokeWidth ?? DEFAULT_MARKER_OUTLINE_PT) * CHART_PX_PER_PT
+  };
+}
+var AUTOMATIC_MARKER_CYCLE = [
+  "diamond",
+  "square",
+  "triangle",
+  "x",
+  "star",
+  "circle",
+  "plus",
+  "dot",
+  "dash"
+];
+function automaticMarkerSymbol(seriesIdx) {
+  const length = AUTOMATIC_MARKER_CYCLE.length;
+  const normalized = (Math.trunc(seriesIdx) % length + length) % length;
+  return AUTOMATIC_MARKER_CYCLE[Number.isFinite(normalized) ? normalized : 0];
+}
+function markerRadius(size, defaultRadius) {
+  if (size === void 0 || !Number.isFinite(size) || size <= 0) {
+    return defaultRadius;
+  }
+  return size / 2;
+}
+function polygonPoints(vertices) {
+  return vertices.map(([x, y]) => `${x.toFixed(2)},${y.toFixed(2)}`).join(" ");
+}
+function starVertices(cx2, cy, r) {
+  const inner = r * 0.5;
+  const out = [];
+  for (let i2 = 0; i2 < 10; i2++) {
+    const radius = i2 % 2 === 0 ? r : inner;
+    const angle = -Math.PI / 2 + Math.PI * i2 / 5;
+    out.push([cx2 + radius * Math.cos(angle), cy + radius * Math.sin(angle)]);
+  }
+  return out;
+}
+function rectPolygon(x, y, w, h2) {
+  return polygonPoints([
+    [x, y],
+    [x + w, y],
+    [x + w, y + h2],
+    [x, y + h2]
+  ]);
+}
+function buildMarkerPrimitive(input) {
+  const { symbol, cx: cx2, cy, fill } = input;
+  const part = input.part === void 0 ? {} : { part: input.part };
+  if (symbol === "none") {
+    return null;
+  }
+  const r = markerRadius(input.size, input.defaultRadius);
+  const outline = input.stroke ? {
+    stroke: input.stroke,
+    strokeWidth: input.strokeWidth ?? DEFAULT_MARKER_OUTLINE_PT * CHART_PX_PER_PT
+  } : void 0;
+  const polygonStroke = outline ?? { stroke: fill, strokeWidth: 0 };
+  const lineStroke = input.stroke ?? fill;
+  switch (symbol) {
+    case "square":
+    case "dash": {
+      const h2 = symbol === "dash" ? r * 0.64 : r * 2;
+      const y = cy - h2 / 2;
+      if (outline) {
+        return {
+          kind: "polygon",
+          points: rectPolygon(cx2 - r, y, r * 2, h2),
+          fill,
+          ...outline,
+          ...part
+        };
+      }
+      return { kind: "rect", x: cx2 - r, y, w: r * 2, h: h2, fill, ...part };
+    }
+    case "diamond":
+      return {
+        kind: "polygon",
+        points: polygonPoints([
+          [cx2, cy - r],
+          [cx2 + r, cy],
+          [cx2, cy + r],
+          [cx2 - r, cy]
+        ]),
+        fill,
+        ...polygonStroke,
+        ...part
+      };
+    case "triangle":
+      return {
+        kind: "polygon",
+        points: polygonPoints([
+          [cx2, cy - r],
+          [cx2 + r * 0.9, cy + r * 0.75],
+          [cx2 - r * 0.9, cy + r * 0.75]
+        ]),
+        fill,
+        ...polygonStroke,
+        ...part
+      };
+    case "star":
+      return {
+        kind: "polygon",
+        points: polygonPoints(starVertices(cx2, cy, r)),
+        fill,
+        ...polygonStroke,
+        ...part
+      };
+    case "plus":
+      return {
+        kind: "path",
+        d: `M${(cx2 - r).toFixed(2)},${cy.toFixed(2)} L${(cx2 + r).toFixed(2)},${cy.toFixed(2)} M${cx2.toFixed(2)},${(cy - r).toFixed(2)} L${cx2.toFixed(2)},${(cy + r).toFixed(2)}`,
+        fill: "none",
+        stroke: lineStroke,
+        strokeWidth: Math.max(1, r * 0.4),
+        ...part
+      };
+    case "x":
+      return {
+        kind: "path",
+        d: `M${(cx2 - r).toFixed(2)},${(cy - r).toFixed(2)} L${(cx2 + r).toFixed(2)},${(cy + r).toFixed(2)} M${(cx2 + r).toFixed(2)},${(cy - r).toFixed(2)} L${(cx2 - r).toFixed(2)},${(cy + r).toFixed(2)}`,
+        fill: "none",
+        stroke: lineStroke,
+        strokeWidth: Math.max(1, r * 0.4),
+        ...part
+      };
+    case "dot":
+      return { kind: "circle", cx: cx2, cy, r: Math.max(r * 0.6, 1), fill, ...part, ...outline };
+    default:
+      return { kind: "circle", cx: cx2, cy, r, fill, ...part, ...outline };
+  }
+}
+
+// chart/render/chart-view-markers.ts
+function summaryMarkers(source, group2, seriesPosition) {
+  if (!["line", "scatter", "radar"].includes(group2.kind)) return {};
+  const enabled = group2.kind === "line" ? group2.marker === true : group2.kind === "radar" ? group2.radarStyle === "marker" : !["line", "smooth", "none"].includes(group2.scatterStyle ?? "marker");
+  const symbol = source.marker?.symbol;
+  const marker = {
+    ...source.marker,
+    symbol: symbol && symbol !== "auto" ? symbol : source.marker || enabled ? automaticMarkerSymbol(source.index ?? seriesPosition) : "none"
+  };
+  const pointMarkers = {};
+  for (const point of source.dataPoints) {
+    if (point.index === void 0 || !point.marker) continue;
+    const override = point.marker;
+    pointMarkers[point.index] = {
+      ...marker,
+      ...override,
+      ...override.symbol === "auto" || !source.marker && override.symbol === void 0 ? { symbol: automaticMarkerSymbol(source.index ?? seriesPosition) } : {},
+      ...marker.spPr || override.spPr ? {
+        spPr: {
+          ...marker.spPr,
+          ...override.spPr,
+          ...marker.spPr?.line || override.spPr?.line ? { line: { ...marker.spPr?.line, ...override.spPr?.line } } : {}
+        }
+      } : {}
+    };
+  }
+  return { marker, ...Object.keys(pointMarkers).length ? { pointMarkers } : {} };
+}
+function seriesMarkerViews(source, drawingColor) {
+  const fillColor = (fill) => fill?.kind === "none" ? "none" : fill?.kind === "solid" ? drawingColor(fill.color) : void 0;
+  const resolve = (marker) => {
+    const fill = fillColor(marker.spPr?.fill);
+    const stroke = fillColor(marker.spPr?.line?.fill);
+    const width = marker.spPr?.line?.widthEmu;
+    return {
+      ...marker.symbol !== void 0 ? { symbol: marker.symbol } : {},
+      ...marker.size !== void 0 ? { size: marker.size } : {},
+      ...fill !== void 0 ? { fill } : {},
+      ...stroke !== void 0 ? { stroke } : {},
+      ...width !== void 0 ? { strokeWidth: width / 9525 } : {}
+    };
+  };
+  return {
+    ...source.marker ? { marker: resolve(source.marker) } : {},
+    ...source.pointMarkers ? {
+      pointMarkers: Object.fromEntries(
+        Object.entries(source.pointMarkers).map(([i2, marker]) => [i2, resolve(marker)])
+      )
+    } : {}
+  };
+}
+
 // chart/render/summary-analysis.ts
 function summaryTrendline(source) {
   const kind = chartTrendlineKind(source.trendlineType);
@@ -5464,17 +5679,17 @@ function summaryAnalysis(series) {
 }
 
 // chart/render/summary-labels.ts
-function level(options, custom) {
+function level(options2, 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 (options2.deleted !== void 0) out.deleted = options2.deleted;
+  if (options2.showValue !== void 0) out.showValue = options2.showValue;
+  if (options2.showCategoryName !== void 0) out.showCategory = options2.showCategoryName;
+  if (options2.showSeriesName !== void 0) out.showSeriesName = options2.showSeriesName;
+  if (options2.showPercent !== void 0) out.showPercent = options2.showPercent;
+  if (options2.showBubbleSize !== void 0) out.showBubbleSize = options2.showBubbleSize;
+  if (options2.separator !== void 0) out.separator = options2.separator;
+  if (options2.position) out.position = options2.position;
+  if (options2.numberFormat?.formatCode) out.numberFormat = options2.numberFormat.formatCode;
   if (custom?.text !== void 0) out.text = custom.text;
   return out;
 }
@@ -5581,7 +5796,10 @@ function extraGroups(chartSpace, firstType) {
     const type = group2.kind === "bar" ? "column" : group2.kind;
     const entry3 = {
       chartType: type,
-      series: group2.series.map((source) => chartSummarySeries(source, type, group2.dataLabels)),
+      series: group2.series.map((source, index) => ({
+        ...chartSummarySeries(source, type, group2.dataLabels),
+        ...summaryMarkers(source, group2, index)
+      })),
       secondary: valueAxisId(chartSpace, group2.axisIds) !== primary
     };
     if (group2.grouping && GROUPINGS.has(group2.grouping))
@@ -5599,13 +5817,16 @@ 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, group2?.dataLabels)
-  );
+  const series = (group2?.series ?? []).map((source, index) => ({
+    ...chartSummarySeries(source, chartType, group2?.dataLabels),
+    ...group2 ? summaryMarkers(source, group2, index) : {}
+  }));
   const summary = {
     chartType,
     series,
-    showLegend: chartSpace.legend !== void 0
+    showLegend: chartSpace.legend !== void 0,
+    axes: chartSpace.plotArea.axes,
+    axisIds: group2?.axisIds ?? []
   };
   const combined = extraGroups(chartSpace, chartType);
   if (combined.length) summary.extraGroups = combined;
@@ -6259,7 +6480,7 @@ function chartTextAttributes(model, part, fallbackSize = FONT_SIZE) {
 function chartStroke(model, part) {
   const entry3 = model.appearance?.[part];
   return {
-    color: entry3?.axisVisible === false ? "none" : entry3?.lineColor ?? (part === "gridlineMajor" ? GRID_COLOR : AXIS_COLOR),
+    color: entry3?.axisVisible === false ? "none" : entry3?.lineColor ?? (part.startsWith("gridline") ? GRID_COLOR : AXIS_COLOR),
     width: entry3?.lineWidth === void 0 ? 1 : chartPointsToPixels(entry3.lineWidth)
   };
 }
@@ -6550,6 +6771,60 @@ function scatterAnalysis(model, px3, py, out) {
   });
 }
 
+// chart/render/chart-svg-markers.ts
+function chartMarkerRadius(series, index, defaultRadius = 3) {
+  const marker = { ...series.marker, ...series.pointMarkers?.[index] };
+  if (marker.symbol === "none") return 0;
+  const radius = markerRadius(marker.size, defaultRadius);
+  return marker.symbol === "dot" ? Math.max(radius * 0.6, 1) : radius;
+}
+function chartSeriesMarkerSvg(series, index, cx2, cy, defaultRadius = 3) {
+  const marker = { ...series.marker, ...series.pointMarkers?.[index] };
+  const primitive = buildMarkerPrimitive({
+    ...marker,
+    symbol: marker.symbol,
+    size: marker.size,
+    cx: cx2,
+    cy,
+    fill: marker.fill ?? series.pointColors?.[index] ?? series.color,
+    defaultRadius
+  });
+  if (!primitive) return "";
+  let geometry;
+  switch (primitive.kind) {
+    case "circle":
+      geometry = `cx="${n(primitive.cx)}" cy="${n(primitive.cy)}" r="${n(primitive.r)}"`;
+      break;
+    case "rect":
+      geometry = `x="${n(primitive.x)}" y="${n(primitive.y)}" width="${n(primitive.w)}" height="${n(primitive.h)}"`;
+      break;
+    case "path":
+      geometry = `d="${esc(primitive.d)}"`;
+      break;
+    case "polygon":
+      geometry = `points="${esc(primitive.points)}"`;
+      break;
+  }
+  const outline = primitive.stroke ? ` stroke="${esc(primitive.stroke)}" stroke-width="${n(primitive.strokeWidth ?? 1)}"` : "";
+  const filter = series.shadowFilter ? ` filter="${esc(series.shadowFilter)}"` : "";
+  return `<${primitive.kind} ${geometry} fill="${esc(primitive.fill)}"${outline}${filter}/>`;
+}
+
+// chart/line-dash.ts
+function chartLineDashArray(style, width) {
+  if (!style || style === "solid") {
+    return void 0;
+  }
+  const unit = Math.max(width, 1);
+  if (style === "dot" || style === "sysDot") {
+    return `${unit} ${unit * 2}`;
+  }
+  if (style === "lgDash") {
+    return `${unit * 6} ${unit * 3}`;
+  }
+  return `${unit * 3} ${unit * 2}`;
+}
+
 // chart/render/chart-scale.ts
 var clean = (n2) => Number(n2.toPrecision(12));
 function* units(raw2) {
@@ -6560,14 +6835,14 @@ function* units(raw2) {
     exp++;
   }
 }
-function niceScale(dataMin, dataMax, options = {}) {
-  const maxIntervals = Math.max(1, options.maxIntervals ?? 10);
+function niceScale(dataMin, dataMax, options2 = {}) {
+  const maxIntervals = Math.max(1, options2.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) {
+    else if (options2.noZero) {
       const pad2 = Math.abs(lo) * 0.1 || 1;
       lo -= pad2;
       hi += pad2;
@@ -6576,7 +6851,7 @@ function niceScale(dataMin, dataMax, options = {}) {
   }
   let fixedLo = false;
   let fixedHi = false;
-  if (!options.noZero) {
+  if (!options2.noZero) {
     if (lo >= 0 && hi - lo >= hi / 6) {
       lo = 0;
       fixedLo = true;
@@ -6616,6 +6891,329 @@ function formatAxisValue(value, percent = false) {
   return `${v < 0 ? "-" : ""}${grouped2}${frac ? `.${frac}` : ""}`;
 }
 
+// chart/render/chart-svg-axes.ts
+function axisTickText(value, axis, percent = false) {
+  return formatChartNumber(value, axis?.source.numberFormat?.formatCode) ?? formatAxisValue(value, percent);
+}
+function axisLine(model, axis, part, x1, y1, x2, y2) {
+  if (axis?.source.deleted) return "";
+  return styledAxisLine(x1, y1, x2, y2, axis?.line, chartStroke(model, part));
+}
+function styledAxisLine(x1, y1, x2, y2, paint2, fallback) {
+  const color = paint2?.color ?? fallback.color;
+  const width = paint2?.width ?? fallback.width;
+  if (color === "none" || width === 0) return "";
+  const dash = chartLineDashArray(paint2?.dash, width);
+  return line(x1, y1, x2, y2, esc(color), width).replace(
+    "/>",
+    dash ? ` stroke-dasharray="${dash}"/>` : "/>"
+  );
+}
+function axisGridlines(model, axis, ticks, position, plot, vertical) {
+  const draw2 = (values, paint2, minor2) => {
+    const fallback = chartStroke(model, minor2 ? "gridlineMinor" : "gridlineMajor");
+    return values.map((value) => {
+      const p = position(value);
+      return vertical ? styledAxisLine(p, plot.y, p, plot.y + plot.h, paint2, fallback) : styledAxisLine(plot.x, p, plot.x + plot.w, p, paint2, fallback);
+    }).join("");
+  };
+  const major = !axis || axis.source.majorGridlines ? draw2(ticks, axis?.majorGrid, false) : "";
+  const minor = axis?.source.minorGridlines ? draw2(axis.minorTicks, axis.minorGrid, true) : "";
+  return major + minor;
+}
+
+// chart/axis-range-auto.ts
+function computeAxisValueRange(series, plotHeightPx) {
+  let dataMin = Number.POSITIVE_INFINITY, dataMax = Number.NEGATIVE_INFINITY;
+  for (const item of series) {
+    for (const value of item.values) {
+      if (value !== null && Number.isFinite(value) && value < dataMin) {
+        dataMin = value;
+      }
+      if (value !== null && Number.isFinite(value) && value > dataMax) {
+        dataMax = value;
+      }
+    }
+  }
+  if (dataMin === Number.POSITIVE_INFINITY) {
+    return { min: 0, max: 1, span: 1 };
+  }
+  const { min, max, majorUnit } = niceValueAxisBounds(
+    dataMin,
+    dataMax,
+    plotHeightPx !== void 0 ? axisTargetIntervals(plotHeightPx) : void 0
+  );
+  return { min, max, span: Math.max(max - min, Number.EPSILON), majorUnit };
+}
+function computeAxisStackedValueRange(series, catCount, plotHeightPx) {
+  let maxSum = 0, minSum = 0;
+  for (let ci = 0; ci < catCount; ci++) {
+    let pos = 0, neg = 0;
+    for (const s2 of series) {
+      const v = s2.values[ci] ?? 0;
+      if (v >= 0) {
+        pos += v;
+      } else {
+        neg += v;
+      }
+    }
+    maxSum = Math.max(maxSum, pos);
+    minSum = Math.min(minSum, neg);
+  }
+  const { min, max, majorUnit } = niceValueAxisBounds(
+    Math.min(minSum, 0),
+    Math.max(maxSum, 0),
+    plotHeightPx !== void 0 ? axisTargetIntervals(plotHeightPx) : void 0
+  );
+  return { min, max, span: Math.max(max - min, Number.EPSILON), majorUnit };
+}
+
+// chart/axis-range.ts
+function computeLogValueRange(series, logBase) {
+  const allValues = series.flatMap((item) => item.values).filter((value) => value !== null && Number.isFinite(value) && value > 0);
+  if (allValues.length === 0) {
+    return { min: 1, max: logBase, span: 1, logScale: true, logBase };
+  }
+  const dataMin = Math.min(...allValues);
+  const dataMax = Math.max(...allValues);
+  const logMin = Math.floor(Math.log(dataMin) / Math.log(logBase));
+  const logMax = Math.ceil(Math.log(dataMax) / Math.log(logBase));
+  const min = logBase ** logMin;
+  const max = logBase ** Math.max(logMax, logMin + 1);
+  return {
+    min,
+    max,
+    span: Math.max(Math.log(max) / Math.log(logBase) - Math.log(min) / Math.log(logBase), 1),
+    logScale: true,
+    logBase
+  };
+}
+function computeValueRangeForAxis(series, axis, plotHeightPx) {
+  const requestedLogBase = axis?.logBase ?? 10;
+  const logBase = axis?.logScale && Number.isFinite(requestedLogBase) && requestedLogBase > 1 ? requestedLogBase : axis?.logScale ? 10 : void 0;
+  const automatic = logBase ? computeLogValueRange(series, logBase) : computeAxisValueRange(series, plotHeightPx);
+  return withAxisBounds(automatic, axis, logBase);
+}
+function computeStackedValueRangeForAxis(series, catCount, axis, isPercent, plotSizePx) {
+  if (isPercent) {
+    return {
+      ...percentStackedRange(series, catCount, plotSizePx),
+      ...axis?.orientation === "maxMin" ? { reverseOrder: true } : {}
+    };
+  }
+  return withAxisBounds(computeAxisStackedValueRange(series, catCount, plotSizePx), axis);
+}
+function percentStackedRange(series, catCount, plotSizePx) {
+  const shares = series.map((entry3) => ({
+    ...entry3,
+    values: Array.from({ length: catCount }, (_, ci) => {
+      const total = series.reduce((sum, s2) => sum + Math.abs(s2.values[ci] ?? 0), 0);
+      return total > 0 ? (entry3.values[ci] ?? 0) / total * 100 : 0;
+    })
+  }));
+  const automatic = computeAxisStackedValueRange(shares, catCount, plotSizePx);
+  if (automatic.min >= 0) {
+    return { min: 0, max: 100, span: 100 };
+  }
+  const min = Math.max(automatic.min, -100);
+  const unit = automatic.majorUnit;
+  return {
+    min,
+    max: 100,
+    span: 100 - min,
+    ...unit !== void 0 && 100 % unit === 0 && min % unit === 0 ? { majorUnit: unit } : {}
+  };
+}
+function withAxisBounds(automatic, axis, logBase) {
+  const validMin = typeof axis?.min === "number" && Number.isFinite(axis.min) && (!logBase || axis.min > 0) ? axis.min : void 0;
+  const validMax = typeof axis?.max === "number" && Number.isFinite(axis.max) && (!logBase || axis.max > 0) ? axis.max : void 0;
+  const min = validMin ?? automatic.min;
+  let max = validMax ?? automatic.max;
+  const majorUnit = validMin === void 0 && validMax === void 0 ? automatic.majorUnit : void 0;
+  if (max <= min) {
+    max = logBase ? min * logBase : min + 1;
+  }
+  const span = logBase ? Math.log(max) / Math.log(logBase) - Math.log(min) / Math.log(logBase) : max - min;
+  return {
+    min,
+    max,
+    span: Math.max(span, Number.EPSILON),
+    ...majorUnit !== void 0 ? { majorUnit } : {},
+    ...logBase ? { logScale: true, logBase } : {},
+    ...axis?.orientation === "maxMin" ? { reverseOrder: true } : {}
+  };
+}
+function valueToYLog(val2, range, topY, bottomY) {
+  const base = range.logBase ?? 10;
+  const logValue = Math.log(Math.max(val2, range.min)) / Math.log(base);
+  const logMin = Math.log(range.min) / Math.log(base);
+  const ratio = (logValue - logMin) / range.span;
+  return range.reverseOrder ? topY + ratio * (bottomY - topY) : bottomY - ratio * (bottomY - topY);
+}
+function findLogAxis(axes) {
+  return axes?.find((axis) => axis.axisType === "valAx" && axis.logScale);
+}
+function computeValueRangeForChart(series, axes, plotHeightPx) {
+  const primaryAxis = axes?.find((axis) => axis.axisType === "valAx" && axis.axPos === "l") ?? axes?.find((axis) => axis.axisType === "valAx" && axis.axPos !== "r");
+  return computeValueRangeForAxis(series, primaryAxis, plotHeightPx);
+}
+
+// chart/axis-ticks.ts
+var LOG_EXPONENT_TOLERANCE = 1e-12;
+function generateLogTicks(range) {
+  if (!range.logScale || !range.logBase) {
+    return [];
+  }
+  const base = range.logBase;
+  const logMin = Math.log(range.min) / Math.log(base);
+  const logMax = Math.log(range.max) / Math.log(base);
+  const firstExponent = Math.ceil(logMin - LOG_EXPONENT_TOLERANCE);
+  const lastExponent = Math.floor(logMax + LOG_EXPONENT_TOLERANCE);
+  if (lastExponent < firstExponent) {
+    return range.min === range.max ? [range.min] : [range.min, range.max];
+  }
+  return Array.from(
+    { length: lastExponent - firstExponent + 1 },
+    (_unused, index) => base ** (firstExponent + index)
+  );
+}
+function generateIntervalTicks(range, unit) {
+  if (!Number.isFinite(unit) || unit <= 0 || range.logScale) {
+    return [];
+  }
+  const tolerance = Math.max(1, Math.abs(range.min), Math.abs(range.max)) * 1e-12;
+  const first2 = Math.ceil((range.min - tolerance) / unit);
+  const last = Math.floor((range.max + tolerance) / unit);
+  const count = Math.min(Math.max(last - first2 + 1, 0), 2e3);
+  return Array.from({ length: count }, (_, index) => (first2 + index) * unit);
+}
+function generateAxisTicks(range, axis, defaultIntervals) {
+  if (range.logScale && range.logBase) {
+    return generateLogTicks(range);
+  }
+  const explicit = generateIntervalTicks(range, axis?.majorUnit ?? 0);
+  if (explicit.length > 0) {
+    return explicit;
+  }
+  const automatic = generateIntervalTicks(range, range.majorUnit ?? 0);
+  if (automatic.length > 0) {
+    return automatic;
+  }
+  return Array.from(
+    { length: defaultIntervals + 1 },
+    (_, index) => range.min + range.span / defaultIntervals * index
+  );
+}
+function generateMinorAxisTicks(range, axis) {
+  const minor = generateIntervalTicks(range, axis?.minorUnit ?? 0);
+  if (minor.length === 0) {
+    return [];
+  }
+  const majorUnit = axis?.majorUnit;
+  if (!majorUnit || !Number.isFinite(majorUnit) || majorUnit <= 0) {
+    return minor;
+  }
+  const tolerance = Math.max(1, Math.abs(range.min), Math.abs(range.max)) * 1e-10;
+  return minor.filter(
+    (value) => Math.abs(value / majorUnit - Math.round(value / majorUnit)) > tolerance
+  );
+}
+
+// chart/render/chart-view-axes.ts
+function chartAxisRatio(value, scale, axis) {
+  const range = axis?.range;
+  const ratio = range?.logScale ? Math.log(Math.max(value, range.min) / range.min) / Math.log(range.max / range.min) : (value - scale.min) / (scale.max - scale.min || 1);
+  return range?.reverseOrder ? 1 - ratio : ratio;
+}
+function chartAxisLabels(axis) {
+  return axis?.source.deleted !== true && axis?.source.tickLabelPosition !== "none";
+}
+function options(axis) {
+  return {
+    ...axis.scaling,
+    ...axis.scaling.logBase === void 0 ? {} : { logScale: true },
+    ...axis.majorUnit === void 0 ? {} : { majorUnit: axis.majorUnit },
+    ...axis.minorUnit === void 0 ? {} : { minorUnit: axis.minorUnit }
+  };
+}
+function applyChartAxes(model, chart, color) {
+  if (!chart.axes?.length) return;
+  const axes = chart.axes;
+  const linked = axes.filter((axis) => axis.id !== void 0 && chart.axisIds?.includes(axis.id));
+  const candidates = linked.length ? linked : axes;
+  const xy = model.type === "scatter" || model.type === "bubble";
+  const value = candidates.find((axis) => axis.kind === "val" && !["b", "t"].includes(axis.position ?? "")) ?? candidates.find((axis) => axis.kind === "val");
+  const category = candidates.find(
+    (axis) => xy ? axis.kind === "val" && axis !== value : axis.kind === "cat" || axis.kind === "date"
+  );
+  const secondary = axes.find((axis) => axis.kind === "val" && axis !== value && axis !== category);
+  const paint2 = (shape) => {
+    const ln = shape?.line;
+    const fill = ln?.fill;
+    const resolved = fill?.kind === "none" ? "none" : color(fill?.kind === "solid" ? fill.color : void 0);
+    return {
+      ...resolved === void 0 ? {} : { color: resolved },
+      ...ln?.widthEmu === void 0 ? {} : { width: ln.widthEmu / EMU_PER_PIXEL },
+      ...ln?.dash === void 0 ? {} : { dash: ln.dash }
+    };
+  };
+  const bind = (axis, scale, values) => {
+    const opts = options(axis);
+    const automatic = opts.logScale ? computeLogValueRange(
+      [{ values: values ?? [] }],
+      opts.logBase && Number.isFinite(opts.logBase) && opts.logBase > 1 ? opts.logBase : 10
+    ) : {
+      min: scale?.min ?? 0,
+      max: scale?.max ?? 1,
+      span: (scale?.max ?? 1) - (scale?.min ?? 0),
+      ...scale ? { majorUnit: scale.majorUnit } : {}
+    };
+    const logBase = automatic.logBase;
+    const range = withAxisBounds(automatic, opts, logBase);
+    if (scale) {
+      scale.min = range.min;
+      scale.max = range.max;
+      scale.ticks = generateAxisTicks(range, opts, 5);
+    }
+    return {
+      source: axis,
+      range,
+      minorTicks: generateMinorAxisTicks(range, opts),
+      line: paint2(axis.spPr),
+      majorGrid: paint2(axis.majorGridlinesSpPr),
+      minorGrid: paint2(axis.minorGridlinesSpPr)
+    };
+  };
+  const out = {};
+  if (value)
+    out.value = bind(
+      value,
+      model.valueAxis,
+      [
+        ...model.series,
+        ...model.extraGroups?.filter((g2) => !g2.secondary).flatMap((g2) => g2.series) ?? []
+      ].flatMap((s2) => s2.values)
+    );
+  if (category)
+    out.category = bind(
+      category,
+      model.xAxis ?? {
+        min: 0,
+        max: Math.max(1, model.categories.length - 1),
+        majorUnit: 1,
+        ticks: []
+      },
+      model.series.flatMap((s2) => s2.xValues ?? [])
+    );
+  if (secondary)
+    out.secondary = bind(
+      secondary,
+      model.secondaryAxis,
+      model.extraGroups?.filter((g2) => g2.secondary).flatMap((g2) => g2.series.flatMap((s2) => s2.values))
+    );
+  model.axes = out;
+}
+
 // chart/render/chart-view-analysis.ts
 function strokeOf(line3, fallback, resolve) {
   if (line3?.fill?.kind === "none") return void 0;
@@ -6665,15 +7263,15 @@ function seriesName(series, index, evaluateRef) {
   const fromRef = resolveRef(series.nameRef, evaluateRef)?.map(toText).filter((t) => t !== "").join(" ");
   return fromRef || series.name || `Series${index + 1}`;
 }
-function seriesContext(chart, theme, options) {
+function seriesContext(chart, theme, options2) {
   const scheme = chartColorScheme(theme);
   const resolver = { scheme: (name) => scheme[name] };
   return {
     theme,
     scheme,
     palette: chart.colorPalette === void 0 ? void 0 : findChartColorPalette(chart.colorPalette),
-    evaluateRef: options.evaluateRef ?? (() => []),
-    seriesColor: options.seriesColor,
+    evaluateRef: options2.evaluateRef ?? (() => []),
+    seriesColor: options2.seriesColor,
     drawingColor: (color) => color && drawingColorCss(resolveDrawingColor(color, resolver, { transformOrder: "document" })),
     gradient: (fill) => fill?.kind === "gradient" ? resolveChartGradient(
       fill,
@@ -6699,7 +7297,11 @@ function seriesView(ctx, s2, index, total, categoriesOf) {
     })
   );
   if (Object.keys(points).length) view.pointGradients = points;
-  Object.assign(view, analysisView(s2, color, ctx.drawingColor));
+  Object.assign(
+    view,
+    analysisView(s2, color, ctx.drawingColor),
+    seriesMarkerViews(s2, ctx.drawingColor)
+  );
   return view;
 }
 
@@ -6999,11 +7601,11 @@ function histogramView(chart, model) {
   const first2 = model.series[0];
   if (!first2) return;
   const raw2 = first2.values.map((v) => v ?? Number.NaN);
-  const options = chart.histogram ?? {};
-  const bins = options.aggregateByCategory ? aggregateByCategory(
+  const options2 = chart.histogram ?? {};
+  const bins = options2.aggregateByCategory ? aggregateByCategory(
     first2.values.map((v) => v ?? 0),
     model.categories
-  ) : computeHistogramBins(raw2, options, formatAxisValue);
+  ) : computeHistogramBins(raw2, options2, formatAxisValue);
   model.categories = bins.map((bin) => bin.label);
   first2.values = bins.map((bin) => bin.value);
   model.barGapWidth = 0;
@@ -7027,11 +7629,11 @@ var SUPPORTED = /* @__PURE__ */ new Set([
   "treemap",
   "sunburst"
 ]);
-function chartSummaryView(chart, theme, options = {}) {
+function chartSummaryView(chart, theme, options2 = {}) {
   const type = chart.chartType;
   const radial = type === "pie" || type === "doughnut";
   const byPoint = radial || type === "treemap" || type === "sunburst";
-  const ctx = seriesContext(chart, theme, options);
+  const ctx = seriesContext(chart, theme, options2);
   const { palette, scheme, drawingColor } = ctx;
   const grouping = chart.grouping ?? (type === "bar" || type === "column" ? "clustered" : "standard");
   const rawCategories = [];
@@ -7117,6 +7719,7 @@ function chartSummaryView(chart, theme, options = {}) {
   else if (!byPoint) model.valueAxis = valueAxis(model);
   applyDataLabels(model, chart.series, extra);
   chartExtraAxes(model);
+  applyChartAxes(model, chart, ctx.drawingColor);
   return model;
 }
 
@@ -7124,15 +7727,13 @@ function chartSummaryView(chart, theme, options = {}) {
 function cartesianAxes(model, area, out) {
   const scale = model.valueAxis;
   if (!scale) return void 0;
-  const labels = scale.ticks.map((t) => formatAxisValue(t, scale.percent));
+  const labels = scale.ticks.map((t) => axisTickText(t, model.axes?.value, scale.percent));
   const valueAttrs = chartTextAttributes(model, "valueAxis");
   const categoryAttrs = chartTextAttributes(model, "categoryAxis");
   const valueSize = valueAttrs.size ?? 10;
   const categorySize = categoryAttrs.size ?? 10;
-  const grid = chartStroke(model, "gridlineMajor");
-  const axis = chartStroke(model, "categoryAxis");
-  const valueLabels = model.appearance?.valueAxis?.labelsVisible !== false;
-  const categoryLabels = model.appearance?.categoryAxis?.labelsVisible !== false;
+  const valueLabels = chartAxisLabels(model.axes?.value) && model.appearance?.valueAxis?.labelsVisible !== false;
+  const categoryLabels = chartAxisLabels(model.axes?.category) && model.appearance?.categoryAxis?.labelsVisible !== false;
   const labelW = valueLabels ? Math.max(...labels.map((l) => textWidth(l, valueSize)), 8) + 6 : 4;
   const horizontal = model.horizontal;
   const cats = Math.max(1, model.categories.length);
@@ -7141,7 +7742,7 @@ function cartesianAxes(model, area, out) {
     Math.max(...model.categories.map((c2) => textWidth(c2, categorySize)), 8) + 6
   );
   const second = horizontal ? void 0 : model.secondaryAxis;
-  const secondLabels = second?.ticks.map((t) => formatAxisValue(t, second.percent)) ?? [];
+  const secondLabels = second?.ticks.map((t) => axisTickText(t, model.axes?.secondary, second.percent)) ?? [];
   const secondW = second ? valueLabels ? Math.max(...secondLabels.map((l) => textWidth(l, valueSize)), 8) + 8 : 4 : 0;
   const plot = horizontal ? {
     x: area.x + catW,
@@ -7154,29 +7755,47 @@ function cartesianAxes(model, area, out) {
     w: Math.max(1, area.w - labelW - 4 - secondW),
     h: Math.max(1, area.h - Math.max(20, categorySize * 1.5))
   };
-  const span = scale.max - scale.min || 1;
-  const value = horizontal ? (v) => plot.x + (v - scale.min) / span * plot.w : (v) => plot.y + plot.h - (v - scale.min) / span * plot.h;
+  const value = horizontal ? (v) => plot.x + chartAxisRatio(v, scale, model.axes?.value) * plot.w : (v) => plot.y + plot.h - chartAxisRatio(v, scale, model.axes?.value) * plot.h;
   const bandSize = (horizontal ? plot.h : plot.w) / cats;
-  const band = horizontal ? (i2) => plot.y + plot.h - bandSize * (i2 + 0.5) : (i2) => plot.x + bandSize * (i2 + 0.5);
+  const index = (i2) => model.axes?.category?.range.reverseOrder ? cats - 1 - i2 : i2;
+  const band = horizontal ? (i2) => plot.y + plot.h - bandSize * (index(i2) + 0.5) : (i2) => plot.x + bandSize * (index(i2) + 0.5);
   out.push(chartAreaRect(model, "plotArea", plot));
+  out.push(axisGridlines(model, model.axes?.value, scale.ticks, value, plot, horizontal));
+  if (model.axes?.category?.source.majorGridlines || model.axes?.category?.source.minorGridlines)
+    out.push(
+      axisGridlines(
+        model,
+        model.axes.category,
+        model.categories.map((_, i2) => i2),
+        band,
+        plot,
+        !horizontal
+      )
+    );
   scale.ticks.forEach((t, i2) => {
     const p = value(t);
     const label = labels[i2] ?? "";
     if (horizontal) {
-      out.push(line(p, plot.y, p, plot.y + plot.h, grid.color, grid.width));
       if (valueLabels)
         out.push(
           text2(p, plot.y + plot.h + valueSize + 2, label, { anchor: "middle", ...valueAttrs })
         );
     } else {
-      out.push(line(plot.x, p, plot.x + plot.w, p, grid.color, grid.width));
       if (valueLabels)
         out.push(text2(plot.x - 4, p + valueSize * 0.3, label, { anchor: "end", ...valueAttrs }));
     }
   });
-  const zero = value(Math.min(Math.max(0, scale.min), scale.max));
-  if (horizontal) out.push(line(zero, plot.y, zero, plot.y + plot.h, axis.color, axis.width));
-  else out.push(line(plot.x, zero, plot.x + plot.w, zero, axis.color, axis.width));
+  const source = model.axes?.value?.source;
+  const crossing = source?.crosses === "max" ? scale.max : source?.crosses === "min" ? scale.min : source?.crossesAt ?? 0;
+  const zero = value(Math.min(Math.max(crossing, scale.min), scale.max));
+  if (horizontal)
+    out.push(
+      axisLine(model, model.axes?.category, "categoryAxis", zero, plot.y, zero, plot.y + plot.h)
+    );
+  else
+    out.push(
+      axisLine(model, model.axes?.category, "categoryAxis", plot.x, zero, plot.x + plot.w, zero)
+    );
   const step = Math.max(
     1,
     Math.ceil(cats / Math.max(1, Math.floor((horizontal ? plot.h : plot.w) / 14)))
@@ -7201,20 +7820,23 @@ function cartesianAxes(model, area, out) {
   });
   const frame2 = { plot, value, band, bandSize };
   if (second) {
-    const secondSpan = second.max - second.min || 1;
-    frame2.secondary = (v) => plot.y + plot.h - (v - second.min) / secondSpan * plot.h;
-    const secondAxis = chartStroke(model, "valueAxis");
+    frame2.secondary = (v) => plot.y + plot.h - chartAxisRatio(v, second, model.axes?.secondary) * plot.h;
     out.push(
-      line(
+      axisLine(
+        model,
+        model.axes?.secondary,
+        "valueAxis",
         plot.x + plot.w,
         plot.y,
         plot.x + plot.w,
-        plot.y + plot.h,
-        secondAxis.color,
-        secondAxis.width
+        plot.y + plot.h
       )
     );
-    if (valueLabels)
+    if (model.axes?.secondary?.source.majorGridlines || model.axes?.secondary?.source.minorGridlines)
+      out.push(
+        axisGridlines(model, model.axes.secondary, second.ticks, frame2.secondary, plot, false)
+      );
+    if (chartAxisLabels(model.axes?.secondary))
       second.ticks.forEach(
         (t, i2) => out.push(
           text2(plot.x + plot.w + 4, frame2.secondary(t) + valueSize * 0.3, secondLabels[i2] ?? "", {
@@ -7258,18 +7880,19 @@ function linesAndAreas(model, frame2, out) {
         index: i2,
         x: frame2.band(i2),
         y: frame2.value(top),
-        radius: area ? 0 : 3
+        radius: area ? 0 : chartMarkerRadius(s2, i2, 2.5)
       });
       lower.push([frame2.band(i2), frame2.value(below2)]);
     });
     layers2.push({
+      series: s2,
       points,
       lower,
       color: s2.color,
       filter: s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : ""
     });
   });
-  for (const { points, lower, color, filter } of area ? [...layers2].reverse() : layers2) {
+  for (const { points, lower, color, filter, series } of area ? [...layers2].reverse() : layers2) {
     if (area) {
       const poly = [...points, ...[...lower].reverse()].map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
       out.push(`<polygon points="${poly}" fill="${color}" fill-opacity="0.85"${filter}/>`);
@@ -7288,9 +7911,9 @@ function linesAndAreas(model, frame2, out) {
       else segment2.push(`${n(x)},${n(y)}`);
     }
     flush();
-    for (const [x, y] of points)
-      if (!Number.isNaN(x))
-        out.push(`<circle cx="${n(x)}" cy="${n(y)}" r="2.5" fill="${color}"${filter}/>`);
+    points.forEach(([x, y], index) => {
+      if (!Number.isNaN(x)) out.push(chartSeriesMarkerSvg(series, index, x, y, 2.5));
+    });
   }
   pointLabels(model, marks, out);
 }
@@ -7300,16 +7923,14 @@ function scatter(model, area, out) {
   const ys = model.valueAxis;
   const xs = model.xAxis;
   if (!ys || !xs) return;
-  const yLabels = ys.ticks.map((t) => formatAxisValue(t));
+  const yLabels = ys.ticks.map((t) => axisTickText(t, model.axes?.value));
   const valueAttrs = chartTextAttributes(model, "valueAxis");
   const categoryAttrs = chartTextAttributes(model, "categoryAxis");
   const valueSize = valueAttrs.size ?? 10;
   const categorySize = categoryAttrs.size ?? 10;
-  const grid = chartStroke(model, "gridlineMajor");
   const xAxis = chartStroke(model, "categoryAxis");
-  const yAxis = chartStroke(model, "valueAxis");
-  const valueLabels = model.appearance?.valueAxis?.labelsVisible !== false;
-  const categoryLabels = model.appearance?.categoryAxis?.labelsVisible !== false;
+  const valueLabels = chartAxisLabels(model.axes?.value) && model.appearance?.valueAxis?.labelsVisible !== false;
+  const categoryLabels = chartAxisLabels(model.axes?.category) && model.appearance?.categoryAxis?.labelsVisible !== false;
   const labelW = valueLabels ? Math.max(...yLabels.map((l) => textWidth(l, valueSize)), 8) + 6 : 4;
   const plot = {
     x: area.x + labelW,
@@ -7329,17 +7950,24 @@ function scatter(model, area, out) {
       s2.values.forEach((_, i2) => {
         reach = Math.max(reach, radiusOf(s2.sizes?.[i2] ?? void 0) ?? 0);
       });
-  const widen = (s2, length) => {
+  const widen = (s2, length, axis) => {
+    if (axis?.range.logScale) return s2;
     const pad2 = reach * (s2.max - s2.min || 1) / Math.max(1, length - 2 * reach);
-    return { ...s2, min: s2.min - pad2, max: s2.max + pad2 };
+    return {
+      ...s2,
+      min: axis?.source.scaling.min === void 0 ? s2.min - pad2 : s2.min,
+      max: axis?.source.scaling.max === void 0 ? s2.max + pad2 : s2.max
+    };
   };
-  const xView = widen(xs, plot.w);
-  const yView = widen(ys, plot.h);
-  const px3 = (v) => plot.x + (v - xView.min) / (xView.max - xView.min || 1) * plot.w;
-  const py = (v) => plot.y + plot.h - (v - yView.min) / (yView.max - yView.min || 1) * plot.h;
+  const xView = widen(xs, plot.w, model.axes?.category);
+  const yView = widen(ys, plot.h, model.axes?.value);
+  const px3 = (v) => plot.x + chartAxisRatio(v, xView, model.axes?.category) * plot.w;
+  const py = (v) => plot.y + plot.h - chartAxisRatio(v, yView, model.axes?.value) * plot.h;
   out.push(chartAreaRect(model, "plotArea", plot));
+  out.push(axisGridlines(model, model.axes?.value, ys.ticks, py, plot, false));
+  if (model.axes?.category)
+    out.push(axisGridlines(model, model.axes.category, xs.ticks, px3, plot, true));
   ys.ticks.forEach((t, i2) => {
-    out.push(line(plot.x, py(t), plot.x + plot.w, py(t), grid.color, grid.width));
     if (valueLabels)
       out.push(
         text2(plot.x - 4, py(t) + valueSize * 0.3, yLabels[i2] ?? "", {
@@ -7349,19 +7977,30 @@ function scatter(model, area, out) {
       );
   });
   for (const t of xs.ticks) {
-    out.push(line(px3(t), plot.y + plot.h, px3(t), plot.y + plot.h + 3, xAxis.color, xAxis.width));
+    if (!model.axes?.category?.source.deleted)
+      out.push(line(px3(t), plot.y + plot.h, px3(t), plot.y + plot.h + 3, xAxis.color, xAxis.width));
     if (categoryLabels)
       out.push(
-        text2(px3(t), plot.y + plot.h + categorySize + 3, formatAxisValue(t), {
+        text2(px3(t), plot.y + plot.h + categorySize + 3, axisTickText(t, model.axes?.category), {
           anchor: "middle",
           ...categoryAttrs
         })
       );
   }
   out.push(
-    line(plot.x, plot.y + plot.h, plot.x + plot.w, plot.y + plot.h, xAxis.color, xAxis.width)
+    axisLine(
+      model,
+      model.axes?.category,
+      "categoryAxis",
+      plot.x,
+      plot.y + plot.h,
+      plot.x + plot.w,
+      plot.y + plot.h
+    )
+  );
+  out.push(
+    axisLine(model, model.axes?.value, "valueAxis", plot.x, plot.y, plot.x, plot.y + plot.h)
   );
-  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) => {
@@ -7370,8 +8009,8 @@ function scatter(model, area, out) {
       const filter = s2.shadowFilter ? ` filter="${s2.shadowFilter}"` : "";
       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 });
+        out.push(chartSeriesMarkerSvg(s2, i2, px3(x), py(v)));
+        marks.push({ series: s2, index: i2, x: px3(x), y: py(v), radius: chartMarkerRadius(s2, i2) });
         return;
       }
       const r = radiusOf(s2.sizes?.[i2] ?? void 0);
@@ -7591,32 +8230,37 @@ function radarSvg(model, area) {
   const valueSize = valueAttrs.size ?? 9;
   const categorySize = categoryAttrs.size ?? 10;
   const grid = chartStroke(model, "gridlineMajor");
-  const axis = chartStroke(model, "categoryAxis");
   const cx2 = area.x + area.w / 2;
   const cy = area.y + area.h / 2 + 4;
   const radius = Math.max(1, Math.min(area.w, area.h) / 2 - Math.max(18, categorySize * 1.8));
   const angle = (i2) => i2 / count * Math.PI * 2;
-  const r = (v) => (v - scale.min) / (scale.max - scale.min || 1) * radius;
+  const r = (v) => chartAxisRatio(v, scale, model.axes?.value) * radius;
   const labelEvery = Math.max(
     1,
     Math.ceil(12 / Math.max(1, radius / Math.max(1, scale.ticks.length - 1)))
   );
   for (const [k, t] of scale.ticks.entries()) {
     const ring = Array.from({ length: count }, (_, i2) => polar(cx2, cy, r(t), angle(i2))).map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
-    out.push(
-      `<polygon points="${ring}" fill="none" stroke="${grid.color}" stroke-width="${n(grid.width)}"/>`
-    );
-    if (model.appearance?.valueAxis?.labelsVisible !== false && k % labelEvery === 0)
+    if (!model.axes?.value || model.axes.value.source.majorGridlines)
+      out.push(
+        `<polygon points="${ring}" fill="none" stroke="${grid.color}" stroke-width="${n(grid.width)}"/>`
+      );
+    if (chartAxisLabels(model.axes?.value) && model.appearance?.valueAxis?.labelsVisible !== false && k % labelEvery === 0)
       out.push(
-        text2(cx2 + 3, cy - r(t) + valueSize * 0.3, formatAxisValue(t, scale.percent), valueAttrs)
+        text2(
+          cx2 + 3,
+          cy - r(t) + valueSize * 0.3,
+          axisTickText(t, model.axes?.value, scale.percent),
+          valueAttrs
+        )
       );
   }
   model.categories.forEach((c2, i2) => {
     const [x, y] = polar(cx2, cy, radius, angle(i2));
-    out.push(line(cx2, cy, x, y, axis.color, axis.width));
+    out.push(axisLine(model, model.axes?.category, "categoryAxis", cx2, cy, x, y));
     const [lx, ly] = polar(cx2, cy, radius + 10, angle(i2));
     const anchor = Math.abs(lx - cx2) < 2 ? "middle" : lx > cx2 ? "start" : "end";
-    if (model.appearance?.categoryAxis?.labelsVisible !== false)
+    if (chartAxisLabels(model.axes?.category) && model.appearance?.categoryAxis?.labelsVisible !== false)
       out.push(
         text2(lx, ly + categorySize * 0.3, fit(c2, area.w / 4, categorySize), {
           anchor,
@@ -7627,7 +8271,13 @@ function radarSvg(model, area) {
   const marks = [];
   for (const s2 of model.series) {
     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 }));
+    vertices.forEach(([x, y], i2) => {
+      if (s2.values[i2] === null) return;
+      const markerSeries = s2;
+      if (markerSeries.marker || markerSeries.pointMarkers)
+        out.push(chartSeriesMarkerSvg(s2, i2, x, y));
+      marks.push({ series: s2, index: i2, x, y, radius: chartMarkerRadius(s2, i2) });
+    });
     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}"` : ""}/>`
@@ -7724,33 +8374,33 @@ var CHART_FONT_FAMILY = "Calibri, Carlito, Arial, sans-serif";
 function cssFont(attrs) {
   return `${attrs.italic ? "italic" : "normal"} ${attrs.weight ?? "normal"} ${attrs.size ?? 10}px ${attrs.family ?? CHART_FONT_FAMILY}`;
 }
-function chartFontMetrics(attrs, options) {
-  const metrics = options.measureFont?.(cssFont(attrs));
+function chartFontMetrics(attrs, options2) {
+  const metrics = options2.measureFont?.(cssFont(attrs));
   return metrics && Number.isFinite(metrics.ascent) && Number.isFinite(metrics.descent) && metrics.ascent >= 0 && metrics.descent >= 0 && metrics.ascent + metrics.descent > 0 ? metrics : void 0;
 }
-function chartTextWidth(content2, attrs, options) {
-  const width = options.measureText?.(content2, cssFont(attrs));
+function chartTextWidth(content2, attrs, options2) {
+  const width = options2.measureText?.(content2, cssFont(attrs));
   return width !== void 0 && Number.isFinite(width) && width >= 0 ? width : textWidth(content2, attrs.size);
 }
-function fitChartText(content2, maxWidth, attrs, options) {
-  if (!options.measureText) return fit(content2, maxWidth, attrs.size);
-  if (chartTextWidth(content2, attrs, options) <= maxWidth) return content2;
+function fitChartText(content2, maxWidth, attrs, options2) {
+  if (!options2.measureText) return fit(content2, maxWidth, attrs.size);
+  if (chartTextWidth(content2, attrs, options2) <= maxWidth) return content2;
   const points = [...content2];
   let low = 0;
   let high = points.length;
   while (low < high) {
     const mid = Math.ceil((low + high) / 2);
-    if (chartTextWidth(`${points.slice(0, mid).join("")}\u2026`, attrs, options) <= maxWidth) low = mid;
+    if (chartTextWidth(`${points.slice(0, mid).join("")}\u2026`, attrs, options2) <= maxWidth) low = mid;
     else high = mid - 1;
   }
   return `${points.slice(0, low).join("")}\u2026`;
 }
 
 // chart/render/chart-svg-legend.ts
-function chartLegendSvg(model, area, frame2, options) {
+function chartLegendSvg(model, area, frame2, options2) {
   const automatic = [];
   const bounds2 = {};
-  const reserved = automaticLegend(model, area, automatic, options, bounds2);
+  const reserved = automaticLegend(model, area, automatic, options2, bounds2);
   const plot = model.legendOverlay ? area : reserved;
   const box = bounds2.box;
   if (!box) return { plot, markup: "", foreground: false };
@@ -7764,11 +8414,11 @@ function chartLegendSvg(model, area, frame2, options) {
   const entries = legendEntries(model);
   const attrs = chartTextAttributes(model, "legend");
   const size = attrs.size ?? 10;
-  const font = chartFontMetrics(attrs, options);
+  const font = chartFontMetrics(attrs, options2);
   const keySize = size / 2;
   const keyGap = size / 4;
   const widths = entries.map(
-    (entry3) => chartTextWidth(entry3.label, attrs, options) + keySize + keyGap
+    (entry3) => chartTextWidth(entry3.label, attrs, options2) + keySize + keyGap
   );
   const horizontal = manual.width > manual.height && widths.reduce((sum, width) => sum + width, 0) + size <= manual.width;
   const rowWidth = horizontal ? manual.width / entries.length : manual.width;
@@ -7783,8 +8433,8 @@ function chartLegendSvg(model, area, frame2, options) {
   ];
   const baselineOffset = font ? (font.ascent - font.descent) / 2 : size * 0.35;
   entries.forEach((entry3, i2) => {
-    const available = horizontal ? chartTextWidth(entry3.label, attrs, options) : Math.max(0, rowWidth - size / 2 - keySize - keyGap);
-    const label = fitChartText(entry3.label, available, attrs, options);
+    const available = horizontal ? chartTextWidth(entry3.label, attrs, options2) : Math.max(0, rowWidth - size / 2 - keySize - keyGap);
+    const label = fitChartText(entry3.label, available, attrs, options2);
     const contentWidth = Math.min(
       horizontal ? widths[i2] ?? 0 : Math.max(...widths),
       rowWidth - size / 2
@@ -7827,7 +8477,7 @@ function legendEntries(model) {
     color: s2.color
   }));
 }
-function automaticLegend(model, area, out, options, bounds2) {
+function automaticLegend(model, area, out, options2, bounds2) {
   const entries = legendEntries(model);
   if (!model.showLegend || entries.length === 0) return area;
   const pos = model.legendPosition;
@@ -7836,7 +8486,7 @@ function automaticLegend(model, area, out, options, bounds2) {
   const rowH = Math.max(16, size * 1.4);
   if (pos === "t" || pos === "b") {
     const widths = entries.map(
-      (e) => Math.min(chartTextWidth(e.label, attrs, options) + 20, area.w / 2)
+      (e) => Math.min(chartTextWidth(e.label, attrs, options2) + 20, area.w / 2)
     );
     const total = widths.reduce((a2, b) => a2 + b, 0);
     let x2 = area.x + Math.max(0, (area.w - total) / 2);
@@ -7853,14 +8503,14 @@ function automaticLegend(model, area, out, options, bounds2) {
     entries.forEach((e, i2) => {
       const w = widths[i2] ?? 0;
       out.push(rect(x2, y, 8, 8, e.color));
-      out.push(text2(x2 + 12, y + 8, fitChartText(e.label, w - 16, attrs, options), attrs));
+      out.push(text2(x2 + 12, y + 8, fitChartText(e.label, w - 16, attrs, options2), attrs));
       x2 += w;
     });
     return pos === "t" ? { x: area.x, y: area.y + rowH + 4, w: area.w, h: area.h - rowH - 4 } : { x: area.x, y: area.y, w: area.w, h: area.h - rowH - 4 };
   }
   const width = Math.min(
     area.w * 0.35,
-    Math.max(...entries.map((e) => chartTextWidth(e.label, attrs, options))) + 22
+    Math.max(...entries.map((e) => chartTextWidth(e.label, attrs, options2))) + 22
   );
   const height = entries.length * rowH;
   const x = pos === "l" ? area.x + 4 : area.x + area.w - width;
@@ -7878,14 +8528,14 @@ function automaticLegend(model, area, out, options, bounds2) {
     const y = y0 + i2 * rowH;
     if (y + rowH > area.y + area.h + 2) return;
     out.push(rect(x, y + 3, 8, 8, e.color));
-    out.push(text2(x + 12, y + 11, fitChartText(e.label, width - 16, attrs, options), attrs));
+    out.push(text2(x + 12, y + 11, fitChartText(e.label, width - 16, attrs, options2), attrs));
   });
   return pos === "l" ? { x: area.x + width + 8, y: area.y, w: area.w - width - 8, h: area.h } : { x: area.x, y: area.y, w: area.w - width - 8, h: area.h };
 }
 
 // text/wrap-styled-runs.ts
 var graphemes = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function wrapStyledRuns(runs, maxWidth, measure4, options = {}) {
+function wrapStyledRuns(runs, maxWidth, measure4, options2 = {}) {
   const groups = [];
   for (const [source, run2] of runs.entries()) {
     for (const token of run2.text.split(/(\r\n|[\r\n]|[ \t]+)/u).filter(Boolean)) {
@@ -7933,7 +8583,7 @@ function wrapStyledRuns(runs, maxWidth, measure4, options = {}) {
     if (line3.length && width(merged(line3, [...separator, ...group2.pieces])) > maxWidth) flush();
     else line3 = merged(line3, separator);
     spaces = [];
-    if (options.breakWords && wordWidth > maxWidth) {
+    if (options2.breakWords && wordWidth > maxWidth) {
       for (const piece of group2.pieces) {
         for (const { segment: segment2 } of graphemes.segment(piece.text)) {
           const next = { ...piece, text: segment2 };
@@ -7951,11 +8601,11 @@ function wrapStyledRuns(runs, maxWidth, measure4, options = {}) {
 function spacing2(value, naturalHeight, fallback) {
   return value ? value.unit === "points" ? chartPointsToPixels(value.value) : naturalHeight * value.value : fallback;
 }
-function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
+function chartRichTitleSvg(model, width, options2 = {}, frameHeight = 400) {
   if (!model.title) return void 0;
   const base = chartTextAttributes(model, "title", 14);
   const capacity = Math.max(1, width * 0.8 - 8);
-  if (!model.titleText && !hasManualLayoutFields(model.titleLayout) && !model.titleOverlay && !model.title.includes("\n") && chartTextWidth(model.title, base, options) <= capacity)
+  if (!model.titleText && !hasManualLayoutFields(model.titleLayout) && !model.titleOverlay && !model.title.includes("\n") && chartTextWidth(model.title, base, options2) <= capacity)
     return void 0;
   const paragraphs = model.titleText?.paragraphs ?? [
     {
@@ -7991,7 +8641,7 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
           "title",
           base.size
         ),
-        options
+        options2
       ),
       { breakWords: true }
     );
@@ -8015,10 +8665,10 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
     return {
       ...line3,
       runs,
-      width: runs.reduce((sum, run2) => sum + chartTextWidth(run2.text, run2.attrs, options), 0),
+      width: runs.reduce((sum, run2) => sum + chartTextWidth(run2.text, run2.attrs, options2), 0),
       size: runs.length ? Math.max(...runs.map((run2) => run2.attrs.size ?? 14)) : base.size ?? 14,
       fontMetrics: (runs.length ? runs.map((run2) => run2.attrs) : [base]).map(
-        (attrs) => chartFontMetrics(attrs, options)
+        (attrs) => chartFontMetrics(attrs, options2)
       )
     };
   });
@@ -8056,7 +8706,7 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
           anchor: "start"
         }).replace("<text ", '<tspan data-chart-title-run="true" ').replace("</text>", "</tspan>")
       );
-      x += chartTextWidth(run2.text, run2.attrs, options);
+      x += chartTextWidth(run2.text, run2.attrs, options2);
     }
   }
   const parent = text2(0, 0, "", { ...base, underline: false }).replace(
@@ -8082,7 +8732,7 @@ function chartRichTitleSvg(model, width, options = {}, frameHeight = 400) {
 }
 
 // chart/render/chart-svg.ts
-function renderChartSvg(model, width, height, options = {}) {
+function renderChartSvg(model, width, height, options2 = {}) {
   const paint2 = chartGradientPaint(model, Math.max(1, width), Math.max(1, height));
   model = paint2.model;
   const w = Math.max(1, width);
@@ -8096,7 +8746,7 @@ function renderChartSvg(model, width, height, options = {}) {
   if (paint2.defs) out.push(paint2.defs);
   out.push(chartAreaRect(model, "chartArea", { x: 0, y: 0, w, h: h2 }));
   let area = { x: 8, y: 8, w: w - 16, h: h2 - 16 };
-  const richTitle = chartRichTitleSvg(model, w, options, h2);
+  const richTitle = chartRichTitleSvg(model, w, options2, h2);
   if (richTitle) {
     if (model.titleLayout || model.titleOverlay) foregroundTitle = richTitle.markup;
     else out.push(richTitle.markup);
@@ -8105,9 +8755,9 @@ function renderChartSvg(model, width, height, options = {}) {
   } else if (model.title) {
     const attrs = chartTextAttributes(model, "title", 14);
     const size = attrs.size ?? 14;
-    const label = fitChartText(model.title, w - 16, attrs, options);
-    const titleWidth = Math.min(w - 16, chartTextWidth(label, attrs, options) + 8);
-    const font = chartFontMetrics(attrs, options);
+    const label = fitChartText(model.title, w - 16, attrs, options2);
+    const titleWidth = Math.min(w - 16, chartTextWidth(label, attrs, options2) + 8);
+    const font = chartFontMetrics(attrs, options2);
     const titleHeight = Math.max(24, font ? font.ascent + font.descent + 4 : size * 1.4 + 4);
     out.push(
       chartAreaRect(model, "title", {
@@ -8135,7 +8785,7 @@ function renderChartSvg(model, width, height, options = {}) {
     out.push("</svg>");
     return out.join("");
   }
-  const legend = chartLegendSvg(model, area, { width: w, height: h2 }, options);
+  const legend = chartLegendSvg(model, area, { width: w, height: h2 }, options2);
   area = legend.plot;
   if (!legend.foreground) out.push(legend.markup);
   if (area.w > 4 && area.h > 4) {
@@ -8182,8 +8832,8 @@ function chartSpaceKind(space3) {
   const type = chartSummaryFromSpace(space3).chartType;
   return { type, drawn: DRAWN_CHART_TYPES.has(type) };
 }
-function renderChartSpaceSvg(space3, options) {
-  const { width, height, theme, fonts, formatting, colorPalette, styleDefinition, ...svg } = options;
+function renderChartSpaceSvg(space3, options2) {
+  const { width, height, theme, fonts, formatting, colorPalette, styleDefinition, ...svg } = options2;
   const summary = chartSummaryFromSpace(space3, {
     ...formatting ? { formatting } : {},
     ...colorPalette !== void 0 ? { colorPalette } : {},
@@ -8192,8 +8842,8 @@ function renderChartSpaceSvg(space3, options) {
   const view = chartSummaryView(summary, chartThemePalette(theme, fonts));
   return renderChartSvg(view, width, height, svg);
 }
-function renderChartSummarySvg(summary, options) {
-  const { width, height, theme, fonts, ...svg } = options;
+function renderChartSummarySvg(summary, options2) {
+  const { width, height, theme, fonts, ...svg } = options2;
   const view = chartSummaryView(summary, chartThemePalette(theme, fonts));
   return renderChartSvg(view, width, height, svg);
 }
@@ -8537,7 +9187,7 @@ __export(i18n_exports, {
 // i18n/locale.ts
 var SUPPORTED_OFFICE_LOCALES = ["en", "fr", "de", "es", "zh-CN"];
 var DEFAULT_REJECTED_SUBTAGS = ["hant", "tw", "hk", "mo"];
-function normalizeLocale(input, supported, fallback, options = {}) {
+function normalizeLocale(input, supported, fallback, options2 = {}) {
   const parts = (input ?? "").trim().toLowerCase().split(/[-_]/).filter(Boolean);
   const language = parts[0];
   if (!language) return fallback;
@@ -8546,7 +9196,7 @@ function normalizeLocale(input, supported, fallback, options = {}) {
   if (exact) return exact;
   const base = find(language);
   if (base) return base;
-  const rejected = options.rejectedSubtags ?? DEFAULT_REJECTED_SUBTAGS;
+  const rejected = options2.rejectedSubtags ?? DEFAULT_REJECTED_SUBTAGS;
   if (parts.slice(1).some((part) => rejected.includes(part))) return fallback;
   return supported.find((item) => item.toLowerCase().split("-")[0] === language && item.includes("-")) ?? fallback;
 }
@@ -8584,12 +9234,12 @@ function interpolate2(template, params, placeholder = "single") {
     (match, name) => Object.prototype.hasOwnProperty.call(params, name) && params[name] !== void 0 ? String(params[name]) : match
   );
 }
-function createTranslator(messages, fallbacks = [], options = {}) {
-  const placeholder = options.placeholder ?? "single";
+function createTranslator(messages, fallbacks = [], options2 = {}) {
+  const placeholder = options2.placeholder ?? "single";
   return (key, params) => {
     let text4 = messages?.[key];
     for (let i2 = 0; text4 === void 0 && i2 < fallbacks.length; i2++) text4 = fallbacks[i2]?.[key];
-    return interpolate2(text4 ?? options.missing?.(key) ?? key, params, placeholder);
+    return interpolate2(text4 ?? options2.missing?.(key) ?? key, params, placeholder);
   };
 }
 function translateOr(translate, key, fallback, params) {
@@ -21659,9 +22309,9 @@ function evaluateCondition(condition, point, lookup) {
 // diagram/engine/pres-tree.ts
 var MAX_DEPTH = 96;
 var MAX_NODES = 1e5;
-function lookupVariable(node, name, options) {
-  if (name === "dir" && options.direction) {
-    return options.direction;
+function lookupVariable(node, name, options2) {
+  if (name === "dir" && options2.direction) {
+    return options2.direction;
   }
   let current = node;
   while (current) {
@@ -21775,8 +22425,8 @@ function buildNode(def, point, parent, state) {
   state.depth--;
   return node;
 }
-function buildPresentationTree(def, doc, options = {}) {
-  return buildNode(def.root, doc, void 0, { def, options, counter: 0, depth: 0 });
+function buildPresentationTree(def, doc, options2 = {}) {
+  return buildNode(def.root, doc, void 0, { def, options: options2, counter: 0, depth: 0 });
 }
 
 // diagram/engine/preferred-size.ts
@@ -30246,33 +30896,33 @@ function arrangeFannedHangingForest(view, nodes, box, palette, style, elementId,
 }
 
 // diagram/hierarchy/smartart-hierarchy-hanging.ts
-function placeAssistants(hc, x, parentBottom, assistants, options, cursor) {
+function placeAssistants(hc, x, parentBottom, assistants, options2, cursor) {
   for (const assistant of assistants) {
     const y = cursor.y;
-    cursor.y += hc.boxH + options.vGap;
+    cursor.y += hc.boxH + options2.vGap;
     const width = hc.boxW * 0.85;
     const height = hc.boxH * 0.85;
     pushNode(hc, assistant.node, x, y, width, height);
     stubConnector(hc, assistant.node.id, x + hc.boxH / 2, parentBottom, x + width / 2, y);
   }
 }
-function placeHangingTree(hc, t, x, options, cursor, size, level3 = 0) {
+function placeHangingTree(hc, t, x, options2, cursor, size, level3 = 0) {
   const y = cursor.y;
   const boxW = size?.w ?? hc.boxW;
   const boxH = size?.h ?? hc.boxH;
-  const align = options.columnAlign;
+  const align = options2.columnAlign;
   const placeX = align ? align.side === "right" ? align.edgeX - boxW : align.edgeX : x;
-  cursor.y += boxH + options.vGap;
+  cursor.y += boxH + options2.vGap;
   pushNode(hc, t.node, placeX, y, boxW, boxH);
-  const { assistants, normal } = partitionChildren(t, options.orgChart);
-  placeAssistants(hc, placeX, y + boxH, assistants, options, cursor);
+  const { assistants, normal } = partitionChildren(t, options2.orgChart);
+  placeAssistants(hc, placeX, y + boxH, assistants, options2, cursor);
   if (normal.length === 0) {
     return;
   }
-  if (options.foldDeeperGenerations && level3 >= 1) {
+  if (options2.foldDeeperGenerations && level3 >= 1) {
     return;
   }
-  const childX = align ? placeX : options.direction === "left" ? x - options.indent : x + options.indent;
+  const childX = align ? placeX : options2.direction === "left" ? x - options2.indent : x + options2.indent;
   for (const child3 of normal) {
     const childY = cursor.y;
     elbowConnector(
@@ -30284,13 +30934,13 @@ function placeHangingTree(hc, t, x, options, cursor, size, level3 = 0) {
       childY,
       child3.node.id
     );
-    placeHangingTree(hc, child3, childX, options, cursor, void 0, level3 + 1);
+    placeHangingTree(hc, child3, childX, options2, cursor, void 0, level3 + 1);
   }
 }
-function placeHangingForest(hc, roots2, startX, startY, options, rootSize) {
+function placeHangingForest(hc, roots2, startX, startY, options2, rootSize) {
   const cursor = { y: startY };
   for (const root of roots2) {
-    placeHangingTree(hc, root, startX, options, cursor, rootSize);
+    placeHangingTree(hc, root, startX, options2, cursor, rootSize);
   }
 }
 
@@ -30924,7 +31574,7 @@ function planFan(childCount, perRow, siblingCxs) {
   }
   return { columns: siblingCxs, overflow: childCount - siblingCxs.length };
 }
-function placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, options, placeAtFn) {
+function placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, options2, placeAtFn) {
   const fanCy = (level3 + 1) * cellH + cellH / 2;
   const fanned = normal.slice(0, plan.columns.length);
   for (let i2 = 0; i2 < fanned.length; i2++) {
@@ -30939,9 +31589,9 @@ function placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, opti
       fanCy - hc.boxH / 2,
       child3.node.id
     );
-    placeAtFn(hc, child3, childCx, fanCy, 0, 1, level3 + 1, cellW, cellH, options);
+    placeAtFn(hc, child3, childCx, fanCy, 0, 1, level3 + 1, cellW, cellH, options2);
   }
-  if (plan.overflow <= 0 || !options.hangingPlacer) {
+  if (plan.overflow <= 0 || !options2.hangingPlacer) {
     return;
   }
   const remainder = normal.slice(plan.columns.length);
@@ -30959,12 +31609,12 @@ function placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, opti
       child3.node.id
     );
   }
-  options.hangingPlacer(hc, remainder, anchorX, anchorY);
+  options2.hangingPlacer(hc, remainder, anchorX, anchorY);
 }
 
 // diagram/hierarchy/smartart-hierarchy-standard-options.ts
-function spanOf(t, options) {
-  return options.resolveSpan ? options.resolveSpan(t) : effectiveWidth(t, options.orgChart);
+function spanOf(t, options2) {
+  return options2.resolveSpan ? options2.resolveSpan(t) : effectiveWidth(t, options2.orgChart);
 }
 
 // diagram/hierarchy/smartart-hierarchy-standard-rows.ts
@@ -30984,20 +31634,20 @@ function placeAssistantRow(hc, parentId, cx2, cy, assistants) {
     x += assistW + ASSISTANT_GAP;
   }
 }
-function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level3, cellW, cellH, options, placeChild) {
+function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level3, cellW, cellH, options2, placeChild) {
   const siblingCxs = [];
   {
     let offset = xOffset;
     for (const child3 of normal) {
-      const childW = spanOf(child3, options);
+      const childW = spanOf(child3, options2);
       siblingCxs.push((offset + childW / 2) * cellW);
       offset += childW;
     }
   }
-  const cascadeShift = options.cascadeOffsetX && level3 + 1 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
+  const cascadeShift = options2.cascadeOffsetX && level3 + 1 >= options2.cascadeOffsetX.fromLevel ? options2.cascadeOffsetX.offsetPx : 0;
   let childOffset = xOffset;
   for (const child3 of normal) {
-    const childW = spanOf(child3, options);
+    const childW = spanOf(child3, options2);
     const childCx = (childOffset + childW / 2) * cellW + cascadeShift;
     const childCy = (level3 + 1) * cellH + cellH / 2;
     elbowConnector(
@@ -31019,7 +31669,7 @@ function placeFlatChildren(hc, parentId, normal, cx2, cy, xOffset, level3, cellW
       level3 + 1,
       cellW,
       cellH,
-      options,
+      options2,
       siblingCxs
     );
     childOffset += childW;
@@ -31042,9 +31692,9 @@ function wrappedGroupSlotCount(group2, orgChart) {
   }
   return group2.members.reduce((sum, m) => sum + effectiveWidth(m, orgChart), 0);
 }
-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);
+function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, level3, cellW, cellH, options2, placeAtFn) {
+  const groups = planWrappedGroups(normal, options2.perRow, options2.orgChart);
+  const totalSlots = groups.reduce((sum, g2) => sum + wrappedGroupSlotCount(g2, options2.orgChart), 0);
   const totalW = spanW * cellW;
   const leftX = xOffset * cellW;
   const unitW = totalW / Math.max(1, totalSlots);
@@ -31064,7 +31714,7 @@ function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, lev
       level3,
       cellW,
       cellH,
-      options,
+      options2,
       placeAtFn
     ) : placeColumnGroup(
       hc,
@@ -31079,24 +31729,24 @@ function placeWrappedChildren(hc, parentId, normal, cx2, cy, xOffset, spanW, lev
       cellW,
       cellH,
       level3,
-      options,
+      options2,
       placeAtFn
     );
   }
 }
-function placeRowFanGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, level3, cellW, cellH, options, placeAtFn) {
+function placeRowFanGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, level3, cellW, cellH, options2, placeAtFn) {
   let cursor = slot2;
   for (const child3 of group2.members) {
-    const childW = effectiveWidth(child3, options.orgChart);
+    const childW = effectiveWidth(child3, options2.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, level3 + 1, cellW, cellH, options);
+    placeAtFn(hc, child3, childCx, rowCy, virtualOffset, childW, level3 + 1, cellW, cellH, options2);
     cursor += childW;
   }
   return cursor;
 }
-function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, cellW, cellH, level3, options, placeAtFn) {
+function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, rowCy, cellW, cellH, level3, options2, placeAtFn) {
   const groupCx = leftX + unitW * (slot2 + 0.5);
   const subRowH = cellH / group2.members.length;
   let fromId = parentId;
@@ -31106,9 +31756,9 @@ function placeColumnGroup(hc, parentId, group2, cx2, cy, leftX, unitW, slot2, ro
     const child3 = group2.members[i2];
     const childCy = rowCy + subRowH * i2;
     elbowConnector(hc, fromId, fromX, fromY, groupCx, childCy - hc.boxH / 2, child3.node.id);
-    const childW = effectiveWidth(child3, options.orgChart);
+    const childW = effectiveWidth(child3, options2.orgChart);
     const virtualOffset = groupCx / cellW - childW / 2;
-    placeAtFn(hc, child3, groupCx, childCy, virtualOffset, childW, level3 + 1, cellW, cellH, options);
+    placeAtFn(hc, child3, groupCx, childCy, virtualOffset, childW, level3 + 1, cellW, cellH, options2);
     fromId = child3.node.id;
     fromX = groupCx;
     fromY = childCy + hc.boxH / 2;
@@ -31117,7 +31767,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, level3, cellW, cellH, options) {
+function placeFlatChildren2(hc, parentId, normal, cx2, cy, xOffset, level3, cellW, cellH, options2) {
   placeFlatChildren(
     hc,
     parentId,
@@ -31128,11 +31778,11 @@ function placeFlatChildren2(hc, parentId, normal, cx2, cy, xOffset, level3, cell
     level3,
     cellW,
     cellH,
-    options,
+    options2,
     placeAt
   );
 }
-function placeWrappedChildren2(hc, parentId, normal, cx2, cy, xOffset, spanW, level3, cellW, cellH, options) {
+function placeWrappedChildren2(hc, parentId, normal, cx2, cy, xOffset, spanW, level3, cellW, cellH, options2) {
   placeWrappedChildren(
     hc,
     parentId,
@@ -31144,32 +31794,32 @@ function placeWrappedChildren2(hc, parentId, normal, cx2, cy, xOffset, spanW, le
     level3,
     cellW,
     cellH,
-    options,
+    options2,
     placeAt
   );
 }
-function placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options, siblingCxs) {
+function placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options2, siblingCxs) {
   pushNode(hc, t.node, cx2 - hc.boxW / 2, cy - hc.boxH / 2);
-  const { assistants, normal } = partitionChildren(t, options.orgChart);
+  const { assistants, normal } = partitionChildren(t, options2.orgChart);
   placeAssistantRow(hc, t.node.id, cx2, cy, assistants);
   if (normal.length === 0) {
     return;
   }
-  if (options.foldDeeperGenerations && level3 >= 1) {
+  if (options2.foldDeeperGenerations && level3 >= 1) {
     return;
   }
-  if (options.hangingPlacer && level3 >= 1) {
-    const plan = planFan(normal.length, options.perRow, siblingCxs);
+  if (options2.hangingPlacer && level3 >= 1) {
+    const plan = planFan(normal.length, options2.perRow, siblingCxs);
     if (plan) {
-      placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, options, placeAt);
+      placeFannedRow(hc, t, normal, plan, cx2, cy, level3, cellW, cellH, options2, 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, level3, cellW, cellH, options);
+      placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level3, cellW, cellH, options2);
       return;
     }
-    const anchorY = cy + hc.boxH / 2 + (options.hangHeightRatio ?? HANG_HEIGHT_RATIO) * hc.boxH;
+    const anchorY = cy + hc.boxH / 2 + (options2.hangHeightRatio ?? HANG_HEIGHT_RATIO) * hc.boxH;
     const columnOffset = hc.boxW * HIER_TAIL_OFFSET_RATIO;
     for (const child3 of normal) {
       elbowConnector(
@@ -31182,10 +31832,10 @@ function placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options,
         child3.node.id
       );
     }
-    options.hangingPlacer(hc, normal, cx2 - hc.boxW / 2 + columnOffset, anchorY);
+    options2.hangingPlacer(hc, normal, cx2 - hc.boxW / 2 + columnOffset, anchorY);
     return;
   }
-  if (Number.isFinite(options.perRow) && normal.length > options.perRow) {
+  if (Number.isFinite(options2.perRow) && normal.length > options2.perRow) {
     placeWrappedChildren2(
       hc,
       t.node.id,
@@ -31197,18 +31847,18 @@ function placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options,
       level3,
       cellW,
       cellH,
-      options
+      options2
     );
   } else {
-    placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level3, cellW, cellH, options);
+    placeFlatChildren2(hc, t.node.id, normal, cx2, cy, xOffset, level3, cellW, cellH, options2);
   }
 }
-function placeStandardTree(hc, t, xOffset, level3, cellW, cellH, options) {
-  const spanW = spanOf(t, options);
-  const cascadeShift = options.cascadeOffsetX && level3 >= options.cascadeOffsetX.fromLevel ? options.cascadeOffsetX.offsetPx : 0;
+function placeStandardTree(hc, t, xOffset, level3, cellW, cellH, options2) {
+  const spanW = spanOf(t, options2);
+  const cascadeShift = options2.cascadeOffsetX && level3 >= options2.cascadeOffsetX.fromLevel ? options2.cascadeOffsetX.offsetPx : 0;
   const cx2 = (xOffset + spanW / 2) * cellW + cascadeShift;
   const cy = level3 * cellH + cellH / 2;
-  placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options);
+  placeAt(hc, t, cx2, cy, xOffset, spanW, level3, cellW, cellH, options2);
 }
 
 // diagram/hierarchy/smartart-hierarchy-tailed-placer.ts
@@ -32434,10 +33084,10 @@ function relativePartTarget(basePart, targetPart) {
   }
   return [...base.map(() => ".."), ...target].join("/");
 }
-async function clonePartGraph(options) {
-  const { zip, sourcePart, targetPart, shouldClone } = options;
-  const sourceZip = options.sourceZip ?? zip;
-  const copies = options.copies ?? /* @__PURE__ */ new Map();
+async function clonePartGraph(options2) {
+  const { zip, sourcePart, targetPart, shouldClone } = options2;
+  const sourceZip = options2.sourceZip ?? zip;
+  const copies = options2.copies ?? /* @__PURE__ */ new Map();
   copies.set(sourcePart, targetPart);
   const types = parseContentTypes(await sourceZip.file("[Content_Types].xml")?.async("string"));
   const reserved = new Set(Object.keys(zip.files));
@@ -35888,8 +36538,8 @@ function hashBytes(password, { algorithmName, saltValue, spinCount }, limits) {
   if (!digest || !salt || !isValidSpinCount(spinCount, limits.maxSpinCount)) return void 0;
   return spinPasswordHash(password, salt, spinCount ?? 0, digest);
 }
-function hashPassword(password, options, limits = {}) {
-  const bytes = hashBytes(password, options, limits);
+function hashPassword(password, options2, limits = {}) {
+  const bytes = hashBytes(password, options2, limits);
   return bytes && encodeBase64(bytes);
 }
 function verifyPasswordHash(password, hash, limits = {}) {
@@ -37309,8 +37959,8 @@ function routeCore(start, end, obstacles, padding, canvasWidth, canvasHeight) {
   const path2 = aStarOrthogonal(nodes, start, end, inflated);
   return simplifyPath(path2);
 }
-function routeConnector(options) {
-  const { start, end, obstacles, canvasWidth, canvasHeight, padding = PADDING_DEFAULT } = options;
+function routeConnector(options2) {
+  const { start, end, obstacles, canvasWidth, canvasHeight, padding = PADDING_DEFAULT } = options2;
   return routeCore(start, end, obstacles, padding, canvasWidth, canvasHeight);
 }
 function waypointsToPathData(waypoints) {
@@ -42714,18 +43364,18 @@ function snapBox(box, size) {
 }
 
 // geometry/align-distribute.ts
-function usesSlideReference(elementCount, options) {
-  if (!options?.slideSize) {
+function usesSlideReference(elementCount, options2) {
+  if (!options2?.slideSize) {
     return false;
   }
-  return options.reference === "slide" || options.reference === void 0 && elementCount === 1;
+  return options2.reference === "slide" || options2.reference === void 0 && elementCount === 1;
 }
-function resolveAlignReferenceBox(elements2, options) {
+function resolveAlignReferenceBox(elements2, options2) {
   if (elements2.length === 0) {
     return null;
   }
-  if (usesSlideReference(elements2.length, options)) {
-    return { minX: 0, minY: 0, maxX: options.slideSize.width, maxY: options.slideSize.height };
+  if (usesSlideReference(elements2.length, options2)) {
+    return { minX: 0, minY: 0, maxX: options2.slideSize.width, maxY: options2.slideSize.height };
   }
   if (elements2.length < 2) {
     return null;
@@ -42737,9 +43387,9 @@ function resolveAlignReferenceBox(elements2, options) {
     maxY: Math.max(...elements2.map((e) => e.y + e.height))
   };
 }
-function alignElements(elements2, edge, options) {
+function alignElements(elements2, edge, options2) {
   const result = /* @__PURE__ */ new Map();
-  const ref = resolveAlignReferenceBox(elements2, options);
+  const ref = resolveAlignReferenceBox(elements2, options2);
   if (!ref) {
     return result;
   }
@@ -42770,7 +43420,7 @@ function alignElements(elements2, edge, options) {
   }
   return result;
 }
-function distributeElements(elements2, axis, options) {
+function distributeElements(elements2, axis, options2) {
   const result = /* @__PURE__ */ new Map();
   const horizontal = axis === "horizontal";
   const start = (e) => horizontal ? e.x : e.y;
@@ -42779,11 +43429,11 @@ function distributeElements(elements2, axis, options) {
   const totalSize = sorted.reduce((sum, e) => sum + size(e), 0);
   let cursor;
   let gap;
-  if (usesSlideReference(elements2.length, options)) {
+  if (usesSlideReference(elements2.length, options2)) {
     if (sorted.length === 0) {
       return result;
     }
-    const span = horizontal ? options.slideSize.width : options.slideSize.height;
+    const span = horizontal ? options2.slideSize.width : options2.slideSize.height;
     gap = (span - totalSize) / (sorted.length + 1);
     cursor = gap;
   } else {
@@ -42817,11 +43467,11 @@ function onlyMoved(boxes, positions) {
   }
   return result;
 }
-function computeAlign(boxes, mode, options) {
-  return onlyMoved(boxes, alignElements(boxes, mode, options));
+function computeAlign(boxes, mode, options2) {
+  return onlyMoved(boxes, alignElements(boxes, mode, options2));
 }
-function computeDistribute(boxes, mode, options) {
-  return onlyMoved(boxes, distributeElements(boxes, mode, options));
+function computeDistribute(boxes, mode, options2) {
+  return onlyMoved(boxes, distributeElements(boxes, mode, options2));
 }
 
 // geometry/rotation-drag.ts
@@ -42829,7 +43479,7 @@ function computeRotation(center, pointer) {
   const deg = Math.atan2(pointer.x - center.x, center.y - pointer.y) * (180 / Math.PI);
   return (deg % 360 + 360) % 360;
 }
-function createRotationDrag(center, startPointer, startRotation, options = {}) {
+function createRotationDrag(center, startPointer, startRotation, options2 = {}) {
   const bearing = (pointer) => pointer.x === center.x && pointer.y === center.y ? void 0 : computeRotation(center, pointer);
   let startAngle = bearing(startPointer);
   let rotation = startRotation;
@@ -42844,7 +43494,7 @@ function createRotationDrag(center, startPointer, startRotation, options = {}) {
       previousAngle = angle;
       return rotation;
     }
-    if (options.unwrapped) {
+    if (options2.unwrapped) {
       const delta = (angle - (previousAngle ?? angle) + 540) % 360 - 180;
       rotation += delta;
       previousAngle = angle;
@@ -43142,10 +43792,10 @@ function placeGrid(ids, size, spacing3) {
     height: size.get(id).height
   }));
 }
-function layoutGraph(nodes, edges, style, options = {}) {
+function layoutGraph(nodes, edges, style, options2 = {}) {
   if (!GRAPH_LAYOUT_STYLES.includes(style)) throw new Error("Unknown graph layout style.");
-  const spacing3 = options.spacing ?? 0.5;
-  const layerSpacing = options.layerSpacing ?? spacing3;
+  const spacing3 = options2.spacing ?? 0.5;
+  const layerSpacing = options2.layerSpacing ?? spacing3;
   if (![spacing3, layerSpacing].every((value) => Number.isFinite(value) && value >= 0))
     throw new Error("Layout spacing must be finite and not negative.");
   const size = /* @__PURE__ */ new Map();
@@ -43245,7 +43895,7 @@ function space2(groups, start, size, minimumGap) {
   });
   return result;
 }
-function autoAlignBoxes(boxes, options = {}) {
+function autoAlignBoxes(boxes, options2 = {}) {
   if (new Set(boxes.map((box) => box.id)).size !== boxes.length)
     throw new Error("Auto align box IDs must be unique.");
   if (!boxes.every(
@@ -43254,9 +43904,9 @@ function autoAlignBoxes(boxes, options = {}) {
     throw new Error("Auto align boxes must be finite.");
   const result = /* @__PURE__ */ new Map();
   if (!boxes.length) return result;
-  const toleranceX = options.tolerance?.x ?? median(boxes.map((box) => box.width)) / 2;
-  const toleranceY = options.tolerance?.y ?? median(boxes.map((box) => box.height)) / 2;
-  const minimumGap = options.minimumGap ?? 0;
+  const toleranceX = options2.tolerance?.x ?? median(boxes.map((box) => box.width)) / 2;
+  const toleranceY = options2.tolerance?.y ?? median(boxes.map((box) => box.height)) / 2;
+  const minimumGap = options2.minimumGap ?? 0;
   const rows = clusters(boxes, (box) => box.y + box.height / 2, toleranceY);
   const columns = clusters(boxes, (box) => box.x + box.width / 2, toleranceX);
   const ys = space2(