@extend-ai/react-xlsx 0.20.1 → 0.20.3

package/dist/{chart-renderer-K6GORT3R.cjs → chart-renderer-2EKXNHUD.cjs}

@@ -2,7 +2,12 @@
 
 
 
-var _chunk54YBFWL3cjs = require('./chunk-54YBFWL3.cjs');
+var _chunkWGRRI25Icjs = require('./chunk-WGRRI25I.cjs');
+
+
+
+
+var _chunkIDNIGBUMcjs = require('./chunk-IDNIGBUM.cjs');
 
 
 
@@ -36,14 +41,14 @@ var _d3shape = require('d3-shape');
 var _jsxruntime = require('react/jsx-runtime');
 
 function RegionMapPlot({ chart, palette, layout, selectedChartElement }) {
-  const resources = _chunk54YBFWL3cjs.useChartModule.call(void 0, _chunk54YBFWL3cjs.regionMapResources);
+  const resources = _chunkWGRRI25Icjs.useChartModule.call(void 0, _chunkWGRRI25Icjs.regionMapResources);
   return resources ? renderRegionMapChart(chart, palette, layout, selectedChartElement, resources) : null;
 }
 function SurfaceChartComposite({
   loadingFallback,
   ...props
 }) {
-  const renderer = _chunk54YBFWL3cjs.useChartModule.call(void 0, _chunk54YBFWL3cjs.surfaceRenderer);
+  const renderer = _chunkWGRRI25Icjs.useChartModule.call(void 0, _chunkWGRRI25Icjs.surfaceRenderer);
   return renderer ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, renderer.MemoSurfaceChartComposite, { ...props }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: loadingFallback });
 }
 function chartElementDataProps(seriesIndex, pointIndex, options) {
@@ -60,84 +65,14 @@ function chartElementDataProps(seriesIndex, pointIndex, options) {
 function barChartElementDataProps(seriesIndex, pointIndex) {
   return chartElementDataProps(seriesIndex, pointIndex, { selectionMode: "seriesFirst" });
 }
-function resolveChartElementTarget(target) {
-  if (!(target instanceof Element)) {
-    return null;
-  }
-  return target.closest("[data-xlsx-chart-series-index]");
-}
-function resolveChartSelectionFromTarget(chart, target, selectedChartElement) {
-  const element = resolveChartElementTarget(target);
-  if (!element) {
-    return _optionalChain([selectedChartElement, 'optionalAccess', _4 => _4.chartId]) === chart.id ? { chartId: chart.id, kind: "chart" } : { chartId: chart.id, kind: "chart" };
-  }
-  const seriesIndex = Number(element.dataset.xlsxChartSeriesIndex);
-  if (!Number.isInteger(seriesIndex) || seriesIndex < 0 || seriesIndex >= chart.series.length) {
-    return null;
-  }
-  const series = chart.series[seriesIndex];
-  if (!series) {
-    return null;
-  }
-  const rawPointIndex = element.dataset.xlsxChartPointIndex;
-  const rawElementKind = element.dataset.xlsxChartElementKind;
-  const selectionMode = element.dataset.xlsxChartSelectionMode;
-  const pointIndex = rawPointIndex == null || rawPointIndex === "" ? null : Number(rawPointIndex);
-  const hasPoint = pointIndex != null && Number.isInteger(pointIndex) && pointIndex >= 0;
-  const sameSelectedSeries = _optionalChain([selectedChartElement, 'optionalAccess', _5 => _5.chartId]) === chart.id && selectedChartElement.kind !== "chart" && selectedChartElement.seriesIndex === seriesIndex;
-  if (hasPoint && (selectionMode !== "seriesFirst" || sameSelectedSeries)) {
-    return {
-      chartId: chart.id,
-      kind: "point",
-      pointIndex,
-      seriesId: series.id,
-      seriesIndex
-    };
-  }
-  return {
-    chartId: chart.id,
-    kind: rawElementKind === "legendEntry" ? "legendEntry" : "series",
-    seriesId: series.id,
-    seriesIndex
-  };
-}
 function isSelectedChartSeries(selectedChartElement, chartId, seriesIndex) {
-  return _optionalChain([selectedChartElement, 'optionalAccess', _6 => _6.chartId]) === chartId && selectedChartElement.kind !== "chart" && selectedChartElement.seriesIndex === seriesIndex;
+  return _optionalChain([selectedChartElement, 'optionalAccess', _4 => _4.chartId]) === chartId && selectedChartElement.kind !== "chart" && selectedChartElement.seriesIndex === seriesIndex;
 }
 function isSelectedChartPoint(selectedChartElement, chartId, seriesIndex, pointIndex) {
-  return _optionalChain([selectedChartElement, 'optionalAccess', _7 => _7.chartId]) === chartId && selectedChartElement.kind === "point" && selectedChartElement.seriesIndex === seriesIndex && selectedChartElement.pointIndex === pointIndex;
+  return _optionalChain([selectedChartElement, 'optionalAccess', _5 => _5.chartId]) === chartId && selectedChartElement.kind === "point" && selectedChartElement.seriesIndex === seriesIndex && selectedChartElement.pointIndex === pointIndex;
 }
 function isSelectedChartPointOrSeries(selectedChartElement, chartId, seriesIndex, pointIndex) {
-  return isSelectedChartPoint(selectedChartElement, chartId, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chartId, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _8 => _8.kind]) !== "point";
-}
-function renderSelectionRectHandles(key, left, top, width, height, color = "#64748b") {
-  return renderSelectionPointHandles(
-    key,
-    [
-      { x: left, y: top },
-      { x: left + width, y: top },
-      { x: left, y: top + height },
-      { x: left + width, y: top + height }
-    ],
-    color
-  );
-}
-function renderSelectionPointHandles(key, points, color = "#64748b") {
-  const radius = 3;
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "g", { pointerEvents: "none", children: points.map((point, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
-    "circle",
-    {
-      cx: point.x,
-      cy: point.y,
-      fill: "#ffffff",
-      r: radius,
-      stroke: color,
-      strokeWidth: 1.1,
-      style: { filter: "drop-shadow(0 1px 2px rgba(15, 23, 42, 0.18))" },
-      vectorEffect: "non-scaling-stroke"
-    },
-    `${key}-handle-${index}`
-  )) }, key);
+  return isSelectedChartPoint(selectedChartElement, chartId, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chartId, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _6 => _6.kind]) !== "point";
 }
 function parseRgbColor(color) {
   const match = /^#?([0-9a-f]{6})$/i.exec(color);
@@ -230,23 +165,23 @@ function safeNumber(value) {
 }
 function chartSeriesColor(chart, seriesIndex) {
   const series = chart.series[seriesIndex];
-  const paletteColor = _optionalChain([chart, 'access', _9 => _9.chartColorPalette, 'optionalAccess', _10 => _10[seriesIndex % Math.max(1, chart.chartColorPalette.length)]]);
-  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _11 => _11.color]), () => ( _optionalChain([series, 'optionalAccess', _12 => _12.lineColor]))), () => ( paletteColor)), () => ( chart.textColor)), () => ( "#222222"));
+  const paletteColor = _optionalChain([chart, 'access', _7 => _7.chartColorPalette, 'optionalAccess', _8 => _8[seriesIndex % Math.max(1, chart.chartColorPalette.length)]]);
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _9 => _9.color]), () => ( _optionalChain([series, 'optionalAccess', _10 => _10.lineColor]))), () => ( paletteColor)), () => ( chart.textColor)), () => ( "#222222"));
 }
 function chartSeriesStrokeColor(chart, seriesIndex) {
   const series = chart.series[seriesIndex];
-  const paletteColor = _optionalChain([chart, 'access', _13 => _13.chartColorPalette, 'optionalAccess', _14 => _14[seriesIndex % Math.max(1, chart.chartColorPalette.length)]]);
-  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _15 => _15.lineColor]), () => ( _optionalChain([series, 'optionalAccess', _16 => _16.color]))), () => ( paletteColor)), () => ( chart.textColor)), () => ( "#222222"));
+  const paletteColor = _optionalChain([chart, 'access', _11 => _11.chartColorPalette, 'optionalAccess', _12 => _12[seriesIndex % Math.max(1, chart.chartColorPalette.length)]]);
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _13 => _13.lineColor]), () => ( _optionalChain([series, 'optionalAccess', _14 => _14.color]))), () => ( paletteColor)), () => ( chart.textColor)), () => ( "#222222"));
 }
 function variesBarColorsByCategory(chart) {
   return chart.series.length === 1 && chart.varyColors !== false && !chart.chartExLayout && ["ColumnClustered", "ColumnStacked", "ColumnPercentStacked", "BarClustered", "BarStacked", "BarPercentStacked"].includes(chart.chartType);
 }
 function chartPointColor(chart, pointIndex, seriesIndex = 0) {
-  const pointStyle = _optionalChain([chart, 'access', _17 => _17.series, 'access', _18 => _18[seriesIndex], 'optionalAccess', _19 => _19.dataPointStyles, 'optionalAccess', _20 => _20.find, 'call', _21 => _21((entry) => entry.index === pointIndex)]);
-  if (_optionalChain([pointStyle, 'optionalAccess', _22 => _22.color])) {
+  const pointStyle = _optionalChain([chart, 'access', _15 => _15.series, 'access', _16 => _16[seriesIndex], 'optionalAccess', _17 => _17.dataPointStyles, 'optionalAccess', _18 => _18.find, 'call', _19 => _19((entry) => entry.index === pointIndex)]);
+  if (_optionalChain([pointStyle, 'optionalAccess', _20 => _20.color])) {
     return pointStyle.color;
   }
-  const rawPoint = _optionalChain([chart, 'access', _23 => _23.series, 'access', _24 => _24[seriesIndex], 'optionalAccess', _25 => _25.dataPoints, 'optionalAccess', _26 => _26[pointIndex]]);
+  const rawPoint = _optionalChain([chart, 'access', _21 => _21.series, 'access', _22 => _22[seriesIndex], 'optionalAccess', _23 => _23.dataPoints, 'optionalAccess', _24 => _24[pointIndex]]);
   if (rawPoint && typeof rawPoint === "object") {
     const pointRecord = rawPoint;
     if (typeof pointRecord.color === "string") {
@@ -269,8 +204,8 @@ function chartPointColor(chart, pointIndex, seriesIndex = 0) {
       }
     }
   }
-  const themeColors = _optionalChain([chart, 'access', _27 => _27.raw, 'optionalAccess', _28 => _28.builtinThemeColors]);
-  const pointCount = Math.max(1, _nullishCoalesce(_optionalChain([chart, 'access', _29 => _29.series, 'access', _30 => _30[seriesIndex], 'optionalAccess', _31 => _31.values, 'access', _32 => _32.length]), () => ( 0)));
+  const themeColors = _optionalChain([chart, 'access', _25 => _25.raw, 'optionalAccess', _26 => _26.builtinThemeColors]);
+  const pointCount = Math.max(1, _nullishCoalesce(_optionalChain([chart, 'access', _27 => _27.series, 'access', _28 => _28[seriesIndex], 'optionalAccess', _29 => _29.values, 'access', _30 => _30.length]), () => ( 0)));
   const builtinColor = themeColors ? _chunk5ERNVHSOcjs.resolveBuiltinChartColor.call(void 0, _chunk5ERNVHSOcjs.getBuiltinChartColor.call(void 0, chart.chartStyleId, pointIndex, pointCount), themeColors) : void 0;
   if (builtinColor) return builtinColor;
   const palette = chart.chartColorPalette;
@@ -281,14 +216,14 @@ function chartPointColor(chart, pointIndex, seriesIndex = 0) {
   return chartSeriesColor(chart, seriesIndex);
 }
 function isHistogramLikeSeries(series) {
-  const raw = _optionalChain([series, 'optionalAccess', _33 => _33.raw]) && typeof series.raw === "object" ? series.raw : null;
-  return Array.isArray(_optionalChain([raw, 'optionalAccess', _34 => _34.chartExHistogramBins])) && raw.chartExHistogramBins.length > 0;
+  const raw = _optionalChain([series, 'optionalAccess', _31 => _31.raw]) && typeof series.raw === "object" ? series.raw : null;
+  return Array.isArray(_optionalChain([raw, 'optionalAccess', _32 => _32.chartExHistogramBins])) && raw.chartExHistogramBins.length > 0;
 }
 function isHistogramLikeChart(chart) {
   return chart.series.some((series) => isHistogramLikeSeries(series));
 }
 function resolveRegionMapBaseColor(chart, seriesIndex) {
-  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _35 => _35.series, 'access', _36 => _36[seriesIndex], 'optionalAccess', _37 => _37.color]), () => ( _optionalChain([chart, 'access', _38 => _38.series, 'access', _39 => _39[seriesIndex], 'optionalAccess', _40 => _40.lineColor]))), () => ( _optionalChain([chart, 'access', _41 => _41.chartColorPalette, 'optionalAccess', _42 => _42[0]]))), () => ( chartSeriesColor(chart, seriesIndex)));
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _33 => _33.series, 'access', _34 => _34[seriesIndex], 'optionalAccess', _35 => _35.color]), () => ( _optionalChain([chart, 'access', _36 => _36.series, 'access', _37 => _37[seriesIndex], 'optionalAccess', _38 => _38.lineColor]))), () => ( _optionalChain([chart, 'access', _39 => _39.chartColorPalette, 'optionalAccess', _40 => _40[0]]))), () => ( chartSeriesColor(chart, seriesIndex)));
 }
 function resolveRegionMapDataColor(chart, seriesIndex) {
   const pointColor = normalizeRendererHexColor(chartPointColor(chart, 0, seriesIndex));
@@ -305,21 +240,21 @@ function resolveRegionMapDataColor(chart, seriesIndex) {
       return paletteColor;
     }
   }
-  return _nullishCoalesce(normalizeRendererHexColor(_nullishCoalesce(_optionalChain([chart, 'access', _43 => _43.series, 'access', _44 => _44[seriesIndex], 'optionalAccess', _45 => _45.color]), () => ( _optionalChain([chart, 'access', _46 => _46.series, 'access', _47 => _47[seriesIndex], 'optionalAccess', _48 => _48.lineColor])))), () => ( "#4f81bd"));
+  return _nullishCoalesce(normalizeRendererHexColor(_nullishCoalesce(_optionalChain([chart, 'access', _41 => _41.series, 'access', _42 => _42[seriesIndex], 'optionalAccess', _43 => _43.color]), () => ( _optionalChain([chart, 'access', _44 => _44.series, 'access', _45 => _45[seriesIndex], 'optionalAccess', _46 => _46.lineColor])))), () => ( "#4f81bd"));
 }
 function resolveRegionMapValueColors(series) {
-  const raw = _optionalChain([series, 'optionalAccess', _49 => _49.raw]) && typeof series.raw === "object" ? series.raw : null;
-  const colors = Array.isArray(_optionalChain([raw, 'optionalAccess', _50 => _50.valueColors])) ? raw.valueColors.map((value) => normalizeRendererHexColor(value)).filter((value) => Boolean(value)) : [];
+  const raw = _optionalChain([series, 'optionalAccess', _47 => _47.raw]) && typeof series.raw === "object" ? series.raw : null;
+  const colors = Array.isArray(_optionalChain([raw, 'optionalAccess', _48 => _48.valueColors])) ? raw.valueColors.map((value) => normalizeRendererHexColor(value)).filter((value) => Boolean(value)) : [];
   return colors.length >= 2 ? colors : null;
 }
 function resolveRegionMapColorStrings(series) {
-  const raw = _optionalChain([series, 'optionalAccess', _51 => _51.raw]) && typeof series.raw === "object" ? series.raw : null;
-  const values = Array.isArray(_optionalChain([raw, 'optionalAccess', _52 => _52.chartExColorStrings])) ? raw.chartExColorStrings.map((value) => typeof value === "string" ? value.trim() : "") : [];
+  const raw = _optionalChain([series, 'optionalAccess', _49 => _49.raw]) && typeof series.raw === "object" ? series.raw : null;
+  const values = Array.isArray(_optionalChain([raw, 'optionalAccess', _50 => _50.chartExColorStrings])) ? raw.chartExColorStrings.map((value) => typeof value === "string" ? value.trim() : "") : [];
   return values.some((value) => value.length > 0) ? values : null;
 }
 function resolveRegionMapLayoutProperties(series) {
-  const raw = _optionalChain([series, 'optionalAccess', _53 => _53.raw]) && typeof series.raw === "object" ? series.raw : null;
-  return _optionalChain([raw, 'optionalAccess', _54 => _54.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const raw = _optionalChain([series, 'optionalAccess', _51 => _51.raw]) && typeof series.raw === "object" ? series.raw : null;
+  return _optionalChain([raw, 'optionalAccess', _52 => _52.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
 }
 function resolveRegionMapValueColorFromStops(stops, ratio) {
   if (stops.length === 0) {
@@ -361,7 +296,7 @@ function buildRegionMapLegendItems(chart) {
       label: value
     }));
   }
-  const values = (_nullishCoalesce(_optionalChain([chart, 'access', _55 => _55.series, 'access', _56 => _56[primarySeriesIndex], 'optionalAccess', _57 => _57.values]), () => ( []))).map((value) => safeNumber(value)).filter((value) => value != null);
+  const values = (_nullishCoalesce(_optionalChain([chart, 'access', _53 => _53.series, 'access', _54 => _54[primarySeriesIndex], 'optionalAccess', _55 => _55.values]), () => ( []))).map((value) => safeNumber(value)).filter((value) => value != null);
   if (values.length === 0) {
     return [];
   }
@@ -379,12 +314,12 @@ function normalizeBuiltinPieStyleId(styleId) {
   return styleId >= 100 ? styleId - 100 : styleId;
 }
 function getBuiltinPiePalette(chart, seriesIndex) {
-  if (_optionalChain([chart, 'access', _58 => _58.raw, 'optionalAccess', _59 => _59.builtinThemeColors])) return null;
+  if (_optionalChain([chart, 'access', _56 => _56.raw, 'optionalAccess', _57 => _57.builtinThemeColors])) return null;
   const normalized = normalizeBuiltinPieStyleId(chart.chartStyleId);
   if (normalized !== 32) {
     return null;
   }
-  const baseColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _60 => _60.series, 'access', _61 => _61[seriesIndex], 'optionalAccess', _62 => _62.color]), () => ( _optionalChain([chart, 'access', _63 => _63.series, 'access', _64 => _64[seriesIndex], 'optionalAccess', _65 => _65.lineColor]))), () => ( _optionalChain([chart, 'access', _66 => _66.chartColorPalette, 'optionalAccess', _67 => _67[0]]))), () => ( null));
+  const baseColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _58 => _58.series, 'access', _59 => _59[seriesIndex], 'optionalAccess', _60 => _60.color]), () => ( _optionalChain([chart, 'access', _61 => _61.series, 'access', _62 => _62[seriesIndex], 'optionalAccess', _63 => _63.lineColor]))), () => ( _optionalChain([chart, 'access', _64 => _64.chartColorPalette, 'optionalAccess', _65 => _65[0]]))), () => ( null));
   if (!baseColor) {
     return null;
   }
@@ -398,8 +333,8 @@ function getBuiltinPiePalette(chart, seriesIndex) {
   ];
 }
 function resolvePiePointColor(chart, pointIndex, seriesIndex = 0) {
-  const pointStyle = _optionalChain([chart, 'access', _68 => _68.series, 'access', _69 => _69[seriesIndex], 'optionalAccess', _70 => _70.dataPointStyles, 'optionalAccess', _71 => _71.find, 'call', _72 => _72((entry) => entry.index === pointIndex)]);
-  if (_optionalChain([pointStyle, 'optionalAccess', _73 => _73.color])) {
+  const pointStyle = _optionalChain([chart, 'access', _66 => _66.series, 'access', _67 => _67[seriesIndex], 'optionalAccess', _68 => _68.dataPointStyles, 'optionalAccess', _69 => _69.find, 'call', _70 => _70((entry) => entry.index === pointIndex)]);
+  if (_optionalChain([pointStyle, 'optionalAccess', _71 => _71.color])) {
     return pointStyle.color;
   }
   const builtinPalette = getBuiltinPiePalette(chart, seriesIndex);
@@ -433,8 +368,8 @@ function chartSeriesBarColors(chart, seriesIndex, value, negativeFillMode) {
   const series = chart.series[seriesIndex];
   const defaultFill = chartSeriesColor(chart, seriesIndex);
   const defaultStroke = chartSeriesStrokeColor(chart, seriesIndex);
-  const defaultStrokeWidth = typeof _optionalChain([series, 'optionalAccess', _74 => _74.lineWidthPx]) === "number" && Number.isFinite(series.lineWidthPx) ? Math.max(0.8, Math.min(4, series.lineWidthPx)) : 1;
-  if (value < 0 && _optionalChain([series, 'optionalAccess', _75 => _75.invertIfNegative])) {
+  const defaultStrokeWidth = typeof _optionalChain([series, 'optionalAccess', _72 => _72.lineWidthPx]) === "number" && Number.isFinite(series.lineWidthPx) ? Math.max(0.8, Math.min(4, series.lineWidthPx)) : 1;
+  if (value < 0 && _optionalChain([series, 'optionalAccess', _73 => _73.invertIfNegative])) {
     const resolvedNegativeFill = negativeFillMode === "none" ? "none" : _nullishCoalesce(_nullishCoalesce(series.negativeColor, () => ( (negativeFillMode === "chartArea" ? chart.chartAreaFillColor : void 0))), () => ( defaultFill));
     return {
       fill: resolvedNegativeFill,
@@ -524,13 +459,13 @@ function estimateReferencePointCount(formula) {
   return Math.abs(endRow - startRow) + 1;
 }
 function getCategoryLabels(chart) {
-  const primaryCategories = _nullishCoalesce(_optionalChain([chart, 'access', _76 => _76.series, 'access', _77 => _77[0], 'optionalAccess', _78 => _78.categories]), () => ( []));
+  const primaryCategories = _nullishCoalesce(_optionalChain([chart, 'access', _74 => _74.series, 'access', _75 => _75[0], 'optionalAccess', _76 => _76.categories]), () => ( []));
   const includeReferenceCategoryCount = chart.plotVisibleOnly !== true;
   const referenceCategoryCount = includeReferenceCategoryCount ? Math.max(
     0,
     ...chart.series.map((series) => Math.max(
-      estimateReferencePointCount(_optionalChain([series, 'access', _79 => _79.categoriesRef, 'optionalAccess', _80 => _80.formula])),
-      estimateReferencePointCount(_optionalChain([series, 'access', _81 => _81.valuesRef, 'optionalAccess', _82 => _82.formula]))
+      estimateReferencePointCount(_optionalChain([series, 'access', _77 => _77.categoriesRef, 'optionalAccess', _78 => _78.formula])),
+      estimateReferencePointCount(_optionalChain([series, 'access', _79 => _79.valuesRef, 'optionalAccess', _80 => _80.formula]))
     ))
   ) : 0;
   const categoryCount = Math.max(
@@ -654,7 +589,7 @@ function coerceLooseNumber(value) {
 }
 function buildPieEntries(chart, seriesIndex = selectPrimaryPieSeriesIndex(chart)) {
   const categories = getCategoryLabels(chart);
-  const values = _nullishCoalesce(_optionalChain([chart, 'access', _83 => _83.series, 'access', _84 => _84[seriesIndex], 'optionalAccess', _85 => _85.values]), () => ( []));
+  const values = _nullishCoalesce(_optionalChain([chart, 'access', _81 => _81.series, 'access', _82 => _82[seriesIndex], 'optionalAccess', _83 => _83.values]), () => ( []));
   return values.map((rawValue, index) => ({
     color: resolvePiePointColor(chart, index, seriesIndex),
     index,
@@ -664,9 +599,9 @@ function buildPieEntries(chart, seriesIndex = selectPrimaryPieSeriesIndex(chart)
 }
 function resolveChartStageSubtotal(series) {
   const raw = series.raw && typeof series.raw === "object" ? series.raw : null;
-  const layoutProperties = _optionalChain([raw, 'optionalAccess', _86 => _86.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
-  const subtotals = Array.isArray(_optionalChain([layoutProperties, 'optionalAccess', _87 => _87.subtotals])) ? layoutProperties.subtotals : [];
-  return subtotals.length > 0 || _optionalChain([layoutProperties, 'optionalAccess', _88 => _88.aggregation]) === true;
+  const layoutProperties = _optionalChain([raw, 'optionalAccess', _84 => _84.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const subtotals = Array.isArray(_optionalChain([layoutProperties, 'optionalAccess', _85 => _85.subtotals])) ? layoutProperties.subtotals : [];
+  return subtotals.length > 0 || _optionalChain([layoutProperties, 'optionalAccess', _86 => _86.aggregation]) === true;
 }
 function buildChartStages(chart) {
   if (chart.chartType === "Funnel" || chart.chartType === "Waterfall") {
@@ -694,7 +629,7 @@ function buildChartStages(chart) {
     if (!Number.isFinite(value)) {
       return null;
     }
-    const formula = typeof _optionalChain([series, 'access', _89 => _89.valuesRef, 'optionalAccess', _90 => _90.formula]) === "string" ? series.valuesRef.formula : "";
+    const formula = typeof _optionalChain([series, 'access', _87 => _87.valuesRef, 'optionalAccess', _88 => _88.formula]) === "string" ? series.valuesRef.formula : "";
     const label = _nullishCoalesce(series.name, () => ( (formula.length > 0 ? formula.replace(/^.*!/, "").replace(/\$/g, "") : `Series ${index + 1}`)));
     return {
       color: chartSeriesColor(chart, typeof series.formatIdx === "number" ? series.formatIdx : index),
@@ -713,7 +648,7 @@ function buildHierarchyData(chart) {
   const topLevelIndexByName = /* @__PURE__ */ new Map();
   const primaryHierarchySeries = _nullishCoalesce(chart.series.find((series) => {
     const raw = series.raw && typeof series.raw === "object" ? series.raw : null;
-    return Array.isArray(_optionalChain([raw, 'optionalAccess', _91 => _91.chartExHierarchyCategories]));
+    return Array.isArray(_optionalChain([raw, 'optionalAccess', _89 => _89.chartExHierarchyCategories]));
   }), () => ( null));
   const primaryHierarchyPaths = (() => {
     if (!primaryHierarchySeries) {
@@ -724,7 +659,7 @@ function buildHierarchyData(chart) {
   })();
   const rowCount = primaryHierarchyPaths ? primaryHierarchyPaths.length : Math.max(0, ...chart.series.map((series) => series.values.length));
   for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
-    const path = _nullishCoalesce(_optionalChain([primaryHierarchyPaths, 'optionalAccess', _92 => _92[rowIndex]]), () => ( chart.series.map((series) => normalizeCategoryLabel(_nullishCoalesce(series.categories[rowIndex], () => ( series.values[rowIndex])))).filter((value) => value.length > 0)));
+    const path = _nullishCoalesce(_optionalChain([primaryHierarchyPaths, 'optionalAccess', _90 => _90[rowIndex]]), () => ( chart.series.map((series) => normalizeCategoryLabel(_nullishCoalesce(series.categories[rowIndex], () => ( series.values[rowIndex])))).filter((value) => value.length > 0)));
     if (path.length === 0) {
       continue;
     }
@@ -747,25 +682,25 @@ function buildHierarchyData(chart) {
       current = next;
     });
     const valueSource = _nullishCoalesce(_nullishCoalesce(primaryHierarchySeries, () => ( chart.series[chart.series.length - 1])), () => ( null));
-    current.value = (_nullishCoalesce(current.value, () => ( 0))) + Math.max(1e-4, _nullishCoalesce(safeNumber(_optionalChain([valueSource, 'optionalAccess', _93 => _93.values, 'access', _94 => _94[rowIndex]])), () => ( 1)));
+    current.value = (_nullishCoalesce(current.value, () => ( 0))) + Math.max(1e-4, _nullishCoalesce(safeNumber(_optionalChain([valueSource, 'optionalAccess', _91 => _91.values, 'access', _92 => _92[rowIndex]])), () => ( 1)));
   }
   return rootChildren.length > 0 ? root : null;
 }
 function resolveBoxWhiskerQuartileMethod(series) {
   const raw = series.raw && typeof series.raw === "object" ? series.raw : null;
-  const layoutProperties = _optionalChain([raw, 'optionalAccess', _95 => _95.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
-  const statistics = _optionalChain([layoutProperties, 'optionalAccess', _96 => _96.statistics]) && typeof layoutProperties.statistics === "object" ? layoutProperties.statistics : null;
-  return _optionalChain([statistics, 'optionalAccess', _97 => _97.quartileMethod]) === "inclusive" ? "inclusive" : "exclusive";
+  const layoutProperties = _optionalChain([raw, 'optionalAccess', _93 => _93.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const statistics = _optionalChain([layoutProperties, 'optionalAccess', _94 => _94.statistics]) && typeof layoutProperties.statistics === "object" ? layoutProperties.statistics : null;
+  return _optionalChain([statistics, 'optionalAccess', _95 => _95.quartileMethod]) === "inclusive" ? "inclusive" : "exclusive";
 }
 function resolveBoxWhiskerVisibility(series) {
   const raw = series.raw && typeof series.raw === "object" ? series.raw : null;
-  const layoutProperties = _optionalChain([raw, 'optionalAccess', _98 => _98.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
-  const visibility = _optionalChain([layoutProperties, 'optionalAccess', _99 => _99.visibility]) && typeof layoutProperties.visibility === "object" ? layoutProperties.visibility : null;
+  const layoutProperties = _optionalChain([raw, 'optionalAccess', _96 => _96.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const visibility = _optionalChain([layoutProperties, 'optionalAccess', _97 => _97.visibility]) && typeof layoutProperties.visibility === "object" ? layoutProperties.visibility : null;
   return {
-    meanLine: _optionalChain([visibility, 'optionalAccess', _100 => _100.meanLine]) === true,
-    meanMarker: _optionalChain([visibility, 'optionalAccess', _101 => _101.meanMarker]) !== false,
-    nonoutliers: _optionalChain([visibility, 'optionalAccess', _102 => _102.nonoutliers]) === true,
-    outliers: _optionalChain([visibility, 'optionalAccess', _103 => _103.outliers]) !== false
+    meanLine: _optionalChain([visibility, 'optionalAccess', _98 => _98.meanLine]) === true,
+    meanMarker: _optionalChain([visibility, 'optionalAccess', _99 => _99.meanMarker]) !== false,
+    nonoutliers: _optionalChain([visibility, 'optionalAccess', _100 => _100.nonoutliers]) === true,
+    outliers: _optionalChain([visibility, 'optionalAccess', _101 => _101.outliers]) !== false
   };
 }
 function computePercentile(sortedValues, percentile, method) {
@@ -825,7 +760,7 @@ function computeBoxWhiskerStats(series) {
 function resolveHierarchyNodeColor(chart, node) {
   const lineage = node.ancestors().reverse();
   const topLevel = lineage[1];
-  const baseIndex = _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _104 => _104.data, 'access', _105 => _105.colorIndex]), () => ( 0));
+  const baseIndex = _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _102 => _102.data, 'access', _103 => _103.colorIndex]), () => ( 0));
   const baseColor = chartSeriesColor(chart, baseIndex);
   const depth = Math.max(0, node.depth - 1);
   return depth === 0 ? baseColor : lightenColor(baseColor, clamp(depth * 0.16, 0, 0.5));
@@ -833,7 +768,7 @@ function resolveHierarchyNodeColor(chart, node) {
 function resolveTreemapNodeColor(chart, node) {
   const lineage = node.ancestors().reverse();
   const topLevel = lineage[1];
-  return chartSeriesColor(chart, _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _106 => _106.data, 'access', _107 => _107.colorIndex]), () => ( 0)));
+  return chartSeriesColor(chart, _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _104 => _104.data, 'access', _105 => _105.colorIndex]), () => ( 0)));
 }
 function excelTreemapTile(node, x0, y0, x1, y1) {
   if (!node.children || node.children.length === 0) {
@@ -848,12 +783,12 @@ function excelTreemapTile(node, x0, y0, x1, y1) {
   node.children.forEach((child) => excelTreemapTile(child, child.x0, child.y0, child.x1, child.y1));
 }
 function resolveSurfaceBaseColor(chart, palette) {
-  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _108 => _108.chartColorPalette, 'optionalAccess', _109 => _109[0]]), () => ( _optionalChain([chart, 'access', _110 => _110.series, 'access', _111 => _111[0], 'optionalAccess', _112 => _112.color]))), () => ( _optionalChain([chart, 'access', _113 => _113.series, 'access', _114 => _114[0], 'optionalAccess', _115 => _115.lineColor]))), () => ( chart.axisLineColor)), () => ( chart.textColor)), () => ( palette.text));
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _106 => _106.chartColorPalette, 'optionalAccess', _107 => _107[0]]), () => ( _optionalChain([chart, 'access', _108 => _108.series, 'access', _109 => _109[0], 'optionalAccess', _110 => _110.color]))), () => ( _optionalChain([chart, 'access', _111 => _111.series, 'access', _112 => _112[0], 'optionalAccess', _113 => _113.lineColor]))), () => ( chart.axisLineColor)), () => ( chart.textColor)), () => ( palette.text));
 }
 function resolveExplicitSurfaceSeriesColor(chart, kind) {
-  const shape = _optionalChain([chart, 'access', _116 => _116.series, 'access', _117 => _117[0], 'optionalAccess', _118 => _118.shapeProperties]);
-  if (kind === "fill" ? _optionalChain([shape, 'optionalAccess', _119 => _119.xmlFillHidden]) === true : _optionalChain([shape, 'optionalAccess', _120 => _120.xmlLineHidden]) === true) return "transparent";
-  const color = kind === "fill" ? _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _121 => _121.xmlFillColor]), () => ( _optionalChain([shape, 'optionalAccess', _122 => _122.solidFillHex]))) : _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _123 => _123.xmlLineColor]), () => ( _optionalChain([shape, 'optionalAccess', _124 => _124.lineColorHex])));
+  const shape = _optionalChain([chart, 'access', _114 => _114.series, 'access', _115 => _115[0], 'optionalAccess', _116 => _116.shapeProperties]);
+  if (kind === "fill" ? _optionalChain([shape, 'optionalAccess', _117 => _117.xmlFillHidden]) === true : _optionalChain([shape, 'optionalAccess', _118 => _118.xmlLineHidden]) === true) return "transparent";
+  const color = kind === "fill" ? _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _119 => _119.xmlFillColor]), () => ( _optionalChain([shape, 'optionalAccess', _120 => _120.solidFillHex]))) : _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _121 => _121.xmlLineColor]), () => ( _optionalChain([shape, 'optionalAccess', _122 => _122.lineColorHex])));
   return normalizeRendererHexColor(color);
 }
 function getSurfaceColorStops(chart, palette) {
@@ -868,7 +803,7 @@ function resolveSurfaceBandPaletteColor(chart, palette, domain, value) {
   if (explicitColor) return explicitColor;
   const explicitFill = resolveExplicitSurfaceSeriesColor(chart, "fill");
   if (explicitFill) return explicitFill;
-  const themeColors = _optionalChain([chart, 'access', _125 => _125.raw, 'optionalAccess', _126 => _126.builtinThemeColors]);
+  const themeColors = _optionalChain([chart, 'access', _123 => _123.raw, 'optionalAccess', _124 => _124.builtinThemeColors]);
   const paletteCount = Math.trunc((domain.safeMax - domain.minValue) / (domain.ticks[1] - domain.ticks[0])) + 1;
   const builtinColor = themeColors ? _chunk5ERNVHSOcjs.resolveBuiltinChartColor.call(void 0, _chunk5ERNVHSOcjs.getBuiltinChartColor.call(void 0, chart.chartStyleId, bandIndex % paletteCount, paletteCount), themeColors) : void 0;
   if (builtinColor) return builtinColor;
@@ -883,8 +818,8 @@ function getSurfaceDomain(chart) {
   if (numericValues.length === 0) {
     return null;
   }
-  const explicitMin = typeof _optionalChain([chart, 'access', _127 => _127.valueAxis, 'optionalAccess', _128 => _128.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? chart.valueAxis.min : null;
-  const explicitMax = typeof _optionalChain([chart, 'access', _129 => _129.valueAxis, 'optionalAccess', _130 => _130.max]) === "number" && Number.isFinite(chart.valueAxis.max) ? chart.valueAxis.max : null;
+  const explicitMin = typeof _optionalChain([chart, 'access', _125 => _125.valueAxis, 'optionalAccess', _126 => _126.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? chart.valueAxis.min : null;
+  const explicitMax = typeof _optionalChain([chart, 'access', _127 => _127.valueAxis, 'optionalAccess', _128 => _128.max]) === "number" && Number.isFinite(chart.valueAxis.max) ? chart.valueAxis.max : null;
   const rawMin = Math.min(...numericValues);
   const rawMax = Math.max(...numericValues);
   const spanBase = Math.max(1e-6, rawMax - Math.min(0, rawMin));
@@ -892,7 +827,7 @@ function getSurfaceDomain(chart) {
   const magnitude = 10 ** Math.floor(Math.log10(Math.max(roughStep, 1e-6)));
   const normalized = roughStep / magnitude;
   const niceNormalized = normalized <= 1 ? 1 : normalized <= 2 ? 2 : normalized <= 5 ? 5 : 10;
-  const step = typeof _optionalChain([chart, 'access', _131 => _131.valueAxis, 'optionalAccess', _132 => _132.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : niceNormalized * magnitude;
+  const step = typeof _optionalChain([chart, 'access', _129 => _129.valueAxis, 'optionalAccess', _130 => _130.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : niceNormalized * magnitude;
   const minValue = _nullishCoalesce(explicitMin, () => ( (rawMin >= 0 ? 0 : Math.floor(rawMin / step) * step)));
   const maxValue = _nullishCoalesce(explicitMax, () => ( Math.ceil(rawMax / step) * step));
   const safeMax = maxValue <= minValue ? minValue + step : maxValue;
@@ -922,14 +857,14 @@ function resolveSurfaceBandIndex(domain, value) {
   return Math.max(0, ticks.length - 2);
 }
 function resolveSurfaceBandFormatColor(chart, key, index) {
-  const colors = _optionalChain([chart, 'access', _133 => _133.raw, 'optionalAccess', _134 => _134[key]]);
+  const colors = _optionalChain([chart, 'access', _131 => _131.raw, 'optionalAccess', _132 => _132[key]]);
   if (!colors || typeof colors !== "object" || !Object.prototype.hasOwnProperty.call(colors, index)) return null;
   const color = colors[index];
   return typeof color === "string" && color.length > 0 ? color : null;
 }
 function resolveSurfaceWireframeColor(chart, palette, domain, value) {
   const bandIndex = resolveSurfaceBandIndex(domain, value);
-  const themeColors = _optionalChain([chart, 'access', _135 => _135.raw, 'optionalAccess', _136 => _136.builtinThemeColors]);
+  const themeColors = _optionalChain([chart, 'access', _133 => _133.raw, 'optionalAccess', _134 => _134.builtinThemeColors]);
   const paletteCount = Math.trunc((domain.safeMax - domain.minValue) / (domain.ticks[1] - domain.ticks[0])) + 1;
   const builtinLine = themeColors ? _chunk5ERNVHSOcjs.resolveBuiltinChartColor.call(void 0, _chunk5ERNVHSOcjs.getBuiltinChartSurfaceLine.call(void 0, chart.chartStyleId, bandIndex, paletteCount), themeColors) : void 0;
   return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(resolveSurfaceBandFormatColor(chart, "bandFormatLineColors", bandIndex), () => ( resolveExplicitSurfaceSeriesColor(chart, "line"))), () => ( builtinLine)), () => ( resolveSurfaceBandPaletteColor(chart, palette, domain, value)));
@@ -939,7 +874,7 @@ function resolveSurfacePlotRect(chart, layout) {
     return layout.plot;
   }
   const columnCount = Math.max(1, getCategoryLabels(chart).length);
-  const depthScale = Math.max(0.01, (_nullishCoalesce(_optionalChain([chart, 'access', _137 => _137.view3d, 'optionalAccess', _138 => _138.depthPercent]), () => ( 100))) / 100);
+  const depthScale = Math.max(0.01, (_nullishCoalesce(_optionalChain([chart, 'access', _135 => _135.view3d, 'optionalAccess', _136 => _136.depthPercent]), () => ( 100))) / 100);
   const targetAspect = columnCount / Math.max(1, chart.series.length) / depthScale;
   let width = layout.plot.width;
   let height = layout.plot.height;
@@ -983,7 +918,7 @@ function isContourSurfaceChart(chart) {
   return chart.chartType === "Surface" && chart.is3d !== true;
 }
 function renderSurfaceAxes(chart, layout) {
-  if (_optionalChain([chart, 'access', _139 => _139.categoryAxis, 'optionalAccess', _140 => _140.delete]) && _optionalChain([chart, 'access', _141 => _141.seriesAxis, 'optionalAccess', _142 => _142.delete]) && _optionalChain([chart, 'access', _143 => _143.valueAxis, 'optionalAccess', _144 => _144.delete])) {
+  if (_optionalChain([chart, 'access', _137 => _137.categoryAxis, 'optionalAccess', _138 => _138.delete]) && _optionalChain([chart, 'access', _139 => _139.seriesAxis, 'optionalAccess', _140 => _140.delete]) && _optionalChain([chart, 'access', _141 => _141.valueAxis, 'optionalAccess', _142 => _142.delete])) {
     return null;
   }
   const plot = resolveSurfacePlotRect(chart, layout);
@@ -993,7 +928,7 @@ function renderSurfaceAxes(chart, layout) {
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( "#888888"));
   const rowCount = Math.max(1, seriesLabels.length);
   const columnCount = Math.max(1, categories.length);
-  const columnPositions = categories.map((_, index) => plot.left + (isContourSurfaceChart(chart) && _optionalChain([chart, 'access', _145 => _145.valueAxis, 'optionalAccess', _146 => _146.crossBetween]) !== "midCat" ? (index + 0.5) / columnCount * plot.width : columnCount <= 1 ? plot.width / 2 : index / (columnCount - 1) * plot.width));
+  const columnPositions = categories.map((_, index) => plot.left + (isContourSurfaceChart(chart) && _optionalChain([chart, 'access', _143 => _143.valueAxis, 'optionalAccess', _144 => _144.crossBetween]) !== "midCat" ? (index + 0.5) / columnCount * plot.width : columnCount <= 1 ? plot.width / 2 : index / (columnCount - 1) * plot.width));
   const rowPositions = seriesLabels.map((_, index) => plot.top + plot.height - (rowCount <= 1 ? plot.height / 2 : index / (rowCount - 1) * plot.height));
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
     isContourSurfaceChart(chart) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -1008,7 +943,7 @@ function renderSurfaceAxes(chart, layout) {
         y: plot.top
       }
     ),
-    _optionalChain([chart, 'access', _147 => _147.categoryAxis, 'optionalAccess', _148 => _148.delete]) !== true && _optionalChain([chart, 'access', _149 => _149.categoryAxis, 'optionalAccess', _150 => _150.labelPosition]) !== "none" && categories.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _optionalChain([chart, 'access', _145 => _145.categoryAxis, 'optionalAccess', _146 => _146.delete]) !== true && _optionalChain([chart, 'access', _147 => _147.categoryAxis, 'optionalAccess', _148 => _148.labelPosition]) !== "none" && categories.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "text",
       {
         fill: labelColor,
@@ -1020,7 +955,7 @@ function renderSurfaceAxes(chart, layout) {
       },
       `surface-x-label-${index}`
     )),
-    _optionalChain([chart, 'access', _151 => _151.seriesAxis, 'optionalAccess', _152 => _152.delete]) !== true && _optionalChain([chart, 'access', _153 => _153.seriesAxis, 'optionalAccess', _154 => _154.labelPosition]) !== "none" && seriesLabels.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _optionalChain([chart, 'access', _149 => _149.seriesAxis, 'optionalAccess', _150 => _150.delete]) !== true && _optionalChain([chart, 'access', _151 => _151.seriesAxis, 'optionalAccess', _152 => _152.labelPosition]) !== "none" && seriesLabels.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "text",
       {
         fill: labelColor,
@@ -1075,7 +1010,7 @@ function getLegendItems(chart, chartType, palette) {
   }
   if (chartType === "Sunburst" || chartType === "Treemap") {
     const hierarchyData = buildHierarchyData(chart);
-    if (!_optionalChain([hierarchyData, 'optionalAccess', _155 => _155.children])) {
+    if (!_optionalChain([hierarchyData, 'optionalAccess', _153 => _153.children])) {
       return [];
     }
     return hierarchyData.children.map((child, index) => ({
@@ -1086,7 +1021,7 @@ function getLegendItems(chart, chartType, palette) {
   if (chartType === "Pie" || chartType === "Pie3D" || chartType === "PieExploded" || chartType === "Doughnut" || chartType === "BarOfPie") {
     if (chartType === "BarOfPie") {
       const categories = getCategoryLabels(chart);
-      const values = _nullishCoalesce(_optionalChain([chart, 'access', _156 => _156.series, 'access', _157 => _157[0], 'optionalAccess', _158 => _158.values]), () => ( []));
+      const values = _nullishCoalesce(_optionalChain([chart, 'access', _154 => _154.series, 'access', _155 => _155[0], 'optionalAccess', _156 => _156.values]), () => ( []));
       return categories.map((label, index) => ({
         color: chartPointColor(chart, index),
         label: normalizeCategoryLabel(label),
@@ -1111,8 +1046,8 @@ function buildLayout(chart, rect, legendItems) {
   const width = Math.max(80, Math.round(rect.width));
   const height = Math.max(60, Math.round(rect.height));
   const isSurfaceChart = chart.chartType === "Surface" || chart.raw && typeof chart.raw === "object" && typeof chart.raw.xmlChartType === "string" && String(chart.raw.xmlChartType).includes("surface");
-  const titleHeight = chart.title && !(isSurfaceChart && _optionalChain([chart, 'access', _159 => _159.raw, 'optionalAccess', _160 => _160.titleOverlay]) === true) ? isSurfaceChart ? 30 : 24 : 8;
-  const legendPosition = normalizeLegendPosition(_optionalChain([chart, 'access', _161 => _161.legend, 'optionalAccess', _162 => _162.position]));
+  const titleHeight = chart.title && !(isSurfaceChart && _optionalChain([chart, 'access', _157 => _157.raw, 'optionalAccess', _158 => _158.titleOverlay]) === true) ? isSurfaceChart ? 30 : 24 : 8;
+  const legendPosition = normalizeLegendPosition(_optionalChain([chart, 'access', _159 => _159.legend, 'optionalAccess', _160 => _160.position]));
   const legendVertical = legendItems.length > 0 && (legendPosition === "right" || legendPosition === "left");
   const compactWidth = width <= 280;
   const compactHeight = height <= 200;
@@ -1122,10 +1057,10 @@ function buildLayout(chart, rect, legendItems) {
   const horizontalMapGradient = chart.chartType === "RegionMap" && legendItems.length > 0 && !resolveRegionMapColorStrings(primarySeries) && (layoutLegendPosition === "top" || layoutLegendPosition === "bottom");
   const horizontalLegendHeight = horizontalMapGradient ? Math.min(48, Math.max(24, height - titleHeight - 8)) : 24;
   const legendWidth = isSurfaceChart ? Math.max(32, ...legendItems.map((item) => 20 + item.label.length * 5.4)) : 98;
-  const plotLeft = (isSurfaceChart && _optionalChain([chart, 'access', _163 => _163.valueAxis, 'optionalAccess', _164 => _164.delete]) ? 12 : 42) + (layoutLegendPosition === "left" ? legendWidth : 0);
+  const plotLeft = (isSurfaceChart && _optionalChain([chart, 'access', _161 => _161.valueAxis, 'optionalAccess', _162 => _162.delete]) ? 12 : 42) + (layoutLegendPosition === "left" ? legendWidth : 0);
   const plotRight = 16 + (layoutLegendPosition === "right" ? legendWidth : 0);
   const plotTop = titleHeight + (layoutLegendPosition === "top" ? horizontalLegendHeight : 0);
-  const plotBottom = (horizontalMapGradient || isSurfaceChart && _optionalChain([chart, 'access', _165 => _165.categoryAxis, 'optionalAccess', _166 => _166.delete]) ? 8 : 28) + (layoutLegendPosition === "bottom" ? horizontalLegendHeight : 0);
+  const plotBottom = (horizontalMapGradient || isSurfaceChart && _optionalChain([chart, 'access', _163 => _163.categoryAxis, 'optionalAccess', _164 => _164.delete]) ? 8 : 28) + (layoutLegendPosition === "bottom" ? horizontalLegendHeight : 0);
   const plotWidth = Math.max(horizontalMapGradient ? 1 : 40, width - plotLeft - plotRight);
   return {
     height,
@@ -1198,30 +1133,30 @@ function resolveNumericAxisDomain(minValue, maxValue, majorUnit, includeZero = f
   };
 }
 function resolveAxisDomainWithChartOverrides(axis, minValue, maxValue, includeZero = false) {
-  const hasExplicitMin = typeof _optionalChain([axis, 'optionalAccess', _167 => _167.min]) === "number" && Number.isFinite(axis.min);
-  const hasExplicitMax = typeof _optionalChain([axis, 'optionalAccess', _168 => _168.max]) === "number" && Number.isFinite(axis.max);
-  const rawMin = hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _169 => _169.min])) : minValue;
-  const rawMax = hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _170 => _170.max])) : maxValue;
-  const domain = resolveNumericAxisDomain(rawMin, rawMax, _optionalChain([axis, 'optionalAccess', _171 => _171.majorUnit]), includeZero);
+  const hasExplicitMin = typeof _optionalChain([axis, 'optionalAccess', _165 => _165.min]) === "number" && Number.isFinite(axis.min);
+  const hasExplicitMax = typeof _optionalChain([axis, 'optionalAccess', _166 => _166.max]) === "number" && Number.isFinite(axis.max);
+  const rawMin = hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _167 => _167.min])) : minValue;
+  const rawMax = hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _168 => _168.max])) : maxValue;
+  const domain = resolveNumericAxisDomain(rawMin, rawMax, _optionalChain([axis, 'optionalAccess', _169 => _169.majorUnit]), includeZero);
   return {
     hasExplicitMax,
     hasExplicitMin,
-    majorUnit: _optionalChain([axis, 'optionalAccess', _172 => _172.majorUnit]),
-    max: hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _173 => _173.max])) : domain.max,
-    min: hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _174 => _174.min])) : domain.min,
+    majorUnit: _optionalChain([axis, 'optionalAccess', _170 => _170.majorUnit]),
+    max: hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _171 => _171.max])) : domain.max,
+    min: hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _172 => _172.min])) : domain.min,
     ticks: hasExplicitMin || hasExplicitMax ? buildNumericTickValues(
-      hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _175 => _175.min])) : domain.min,
-      hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _176 => _176.max])) : domain.max,
-      _optionalChain([axis, 'optionalAccess', _177 => _177.majorUnit])
+      hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _173 => _173.min])) : domain.min,
+      hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _174 => _174.max])) : domain.max,
+      _optionalChain([axis, 'optionalAccess', _175 => _175.majorUnit])
     ) : domain.ticks
   };
 }
 function resolve3dFrameOffsets(chart, baseDepthX = 11, baseDepthY = 8) {
-  const depthRatio = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _178 => _178.view3d, 'optionalAccess', _179 => _179.depthPercent]), () => ( 100))) / 100, 0.35, 3.2);
-  const rotX = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _180 => _180.view3d, 'optionalAccess', _181 => _181.rotX]), () => ( 20)), -80, 80);
-  const rotY = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _182 => _182.view3d, 'optionalAccess', _183 => _183.rotY]), () => ( 20)), -80, 80);
-  const usePerspective = _optionalChain([chart, 'access', _184 => _184.view3d, 'optionalAccess', _185 => _185.rAngAx]) === false;
-  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _186 => _186.view3d, 'optionalAccess', _187 => _187.perspective]), () => ( (usePerspective ? 26 : 0)))) / 100, 0, 1);
+  const depthRatio = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _176 => _176.view3d, 'optionalAccess', _177 => _177.depthPercent]), () => ( 100))) / 100, 0.35, 3.2);
+  const rotX = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _178 => _178.view3d, 'optionalAccess', _179 => _179.rotX]), () => ( 20)), -80, 80);
+  const rotY = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _180 => _180.view3d, 'optionalAccess', _181 => _181.rotY]), () => ( 20)), -80, 80);
+  const usePerspective = _optionalChain([chart, 'access', _182 => _182.view3d, 'optionalAccess', _183 => _183.rAngAx]) === false;
+  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _184 => _184.view3d, 'optionalAccess', _185 => _185.perspective]), () => ( (usePerspective ? 26 : 0)))) / 100, 0, 1);
   const projectedOrigin = projectCartesian3dPoint(
     0,
     0,
@@ -1319,9 +1254,9 @@ function formatExcelDateSerial(value, formatCode, use1904) {
 function formatCategoryLabel(chart, value, fallback = "") {
   const rawRecord = chart.raw && typeof chart.raw === "object" ? chart.raw : null;
   const numeric = typeof value === "number" && Number.isFinite(value) ? value : null;
-  const formatCode = _optionalChain([chart, 'access', _188 => _188.categoryAxis, 'optionalAccess', _189 => _189.numberFormat, 'optionalAccess', _190 => _190.formatCode]);
+  const formatCode = _optionalChain([chart, 'access', _186 => _186.categoryAxis, 'optionalAccess', _187 => _187.numberFormat, 'optionalAccess', _188 => _188.formatCode]);
   if (numeric != null && isLikelyDateFormatCode(formatCode)) {
-    return formatExcelDateSerial(numeric, formatCode, _optionalChain([rawRecord, 'optionalAccess', _191 => _191.date1904]) === true);
+    return formatExcelDateSerial(numeric, formatCode, _optionalChain([rawRecord, 'optionalAccess', _189 => _189.date1904]) === true);
   }
   const normalized = normalizeCategoryLabel(value);
   if (normalized.length > 0) {
@@ -1481,18 +1416,18 @@ function renderLegend(chart, layout, palette) {
     if (!resolveRegionMapColorStrings(series)) {
       const vertical = legendPos === "left" || legendPos === "right";
       const x = vertical ? legendPos === "right" ? layout.plot.left + layout.plot.width + 8 : 8 : layout.plot.left;
-      const showSeriesName = vertical || (_nullishCoalesce(_optionalChain([layout, 'access', _192 => _192.legendBounds, 'optionalAccess', _193 => _193.height]), () => ( 48))) >= 44;
-      const y = vertical ? layout.plot.top + 26 : (_nullishCoalesce(_optionalChain([layout, 'access', _194 => _194.legendBounds, 'optionalAccess', _195 => _195.top]), () => ( layout.height - 48))) + (showSeriesName ? 20 : 4);
+      const showSeriesName = vertical || (_nullishCoalesce(_optionalChain([layout, 'access', _190 => _190.legendBounds, 'optionalAccess', _191 => _191.height]), () => ( 48))) >= 44;
+      const y = vertical ? layout.plot.top + 26 : (_nullishCoalesce(_optionalChain([layout, 'access', _192 => _192.legendBounds, 'optionalAccess', _193 => _193.top]), () => ( layout.height - 48))) + (showSeriesName ? 20 : 4);
       const length = vertical ? Math.min(100, Math.max(24, layout.plot.height - 42)) : Math.min(160, layout.plot.width);
       const gradientId = `map-legend-${chart.id}`;
       const stops = resolveRegionMapValueColors(series);
-      const count = _nullishCoalesce(_optionalChain([stops, 'optionalAccess', _196 => _196.length]), () => ( 3));
+      const count = _nullishCoalesce(_optionalChain([stops, 'optionalAccess', _194 => _194.length]), () => ( 3));
       return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "defs", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "linearGradient", { id: gradientId, x1: "0%", x2: vertical ? "0%" : "100%", y1: vertical ? "100%" : "0%", y2: "0%", children: Array.from({ length: count }, (_, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: `${index / (count - 1) * 100}%`, stopColor: resolveRegionMapValueColor(chart, seriesIndex, index / (count - 1)) }, index)) }) }),
-        showSeriesName && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, x, y: y - 12, children: _nullishCoalesce(_optionalChain([series, 'optionalAccess', _197 => _197.name]), () => ( "")) }),
+        showSeriesName && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, x, y: y - 12, children: _nullishCoalesce(_optionalChain([series, 'optionalAccess', _195 => _195.name]), () => ( "")) }),
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "rect", { fill: `url(#${gradientId})`, x, y, width: vertical ? 8 : length, height: vertical ? length : 8 }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, x: vertical ? x + 12 : x, y: vertical ? y + length : y + 20, children: _optionalChain([items, 'access', _198 => _198[0], 'optionalAccess', _199 => _199.label]) }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, textAnchor: vertical ? "start" : "end", x: vertical ? x + 12 : x + length, y: vertical ? y + 7 : y + 20, children: _optionalChain([items, 'access', _200 => _200[1], 'optionalAccess', _201 => _201.label]) })
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, x: vertical ? x + 12 : x, y: vertical ? y + length : y + 20, children: _optionalChain([items, 'access', _196 => _196[0], 'optionalAccess', _197 => _197.label]) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, textAnchor: vertical ? "start" : "end", x: vertical ? x + 12 : x + length, y: vertical ? y + 7 : y + 20, children: _optionalChain([items, 'access', _198 => _198[1], 'optionalAccess', _199 => _199.label]) })
       ] });
     }
   }
@@ -1538,10 +1473,10 @@ function renderCartesianAxes(chart, palette, plot, isHorizontal, categoryLabels,
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const labelColor = resolveChartAxisTextColor(chart);
   const zeroPosition = mapValue(0);
-  const showValueAxis = _optionalChain([chart, 'access', _202 => _202.valueAxis, 'optionalAccess', _203 => _203.delete]) !== true;
-  const showCategoryAxis = _optionalChain([chart, 'access', _204 => _204.categoryAxis, 'optionalAccess', _205 => _205.delete]) !== true;
-  const showValueLabels = showValueAxis && _optionalChain([chart, 'access', _206 => _206.valueAxis, 'optionalAccess', _207 => _207.labelPosition]) !== "none";
-  const showCategoryLabels = showCategoryAxis && _optionalChain([chart, 'access', _208 => _208.categoryAxis, 'optionalAccess', _209 => _209.labelPosition]) !== "none";
+  const showValueAxis = _optionalChain([chart, 'access', _200 => _200.valueAxis, 'optionalAccess', _201 => _201.delete]) !== true;
+  const showCategoryAxis = _optionalChain([chart, 'access', _202 => _202.categoryAxis, 'optionalAccess', _203 => _203.delete]) !== true;
+  const showValueLabels = showValueAxis && _optionalChain([chart, 'access', _204 => _204.valueAxis, 'optionalAccess', _205 => _205.labelPosition]) !== "none";
+  const showCategoryLabels = showCategoryAxis && _optionalChain([chart, 'access', _206 => _206.categoryAxis, 'optionalAccess', _207 => _207.labelPosition]) !== "none";
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
     showValueAxis ? valueTicks.map((tick) => {
       const valuePosition = mapValue(tick);
@@ -1866,22 +1801,22 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
     chart.valueAxis,
     minValue,
     maxValue,
-    isAreaChart || _optionalChain([chart, 'access', _210 => _210.valueAxis, 'optionalAccess', _211 => _211.crosses]) === "autoZero"
+    isAreaChart || _optionalChain([chart, 'access', _208 => _208.valueAxis, 'optionalAccess', _209 => _209.crosses]) === "autoZero"
   );
   minValue = valueDomain.min;
   maxValue = valueDomain.max;
   const valueSpan = Math.max(1e-6, maxValue - minValue);
   const seriesCount = Math.max(1, chart.series.length);
   const categoryCount = Math.max(1, categories.length);
-  const depthScale = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _212 => _212.view3d, 'optionalAccess', _213 => _213.depthPercent]), () => ( 100))) / 100, 0.5, 4);
+  const depthScale = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _210 => _210.view3d, 'optionalAccess', _211 => _211.depthPercent]), () => ( 100))) / 100, 0.5, 4);
   const halfDepth = (seriesCount <= 1 ? 0.82 : 1.02) * depthScale;
   const frontZ = halfDepth;
   const backZ = -halfDepth;
   const baseValue = isAreaChart ? Math.max(minValue, Math.min(maxValue, 0)) : minValue;
-  const rotXRad = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _214 => _214.view3d, 'optionalAccess', _215 => _215.rotX]), () => ( 18)), -80, 80) * (Math.PI / 180);
-  const rotYRad = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _216 => _216.view3d, 'optionalAccess', _217 => _217.rotY]), () => ( 24)), -80, 80) * (Math.PI / 180);
-  const usePerspective = _optionalChain([chart, 'access', _218 => _218.view3d, 'optionalAccess', _219 => _219.rAngAx]) === false;
-  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _220 => _220.view3d, 'optionalAccess', _221 => _221.perspective]), () => ( (usePerspective ? 26 : 0)))) / 100, 0, 1);
+  const rotXRad = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _212 => _212.view3d, 'optionalAccess', _213 => _213.rotX]), () => ( 18)), -80, 80) * (Math.PI / 180);
+  const rotYRad = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _214 => _214.view3d, 'optionalAccess', _215 => _215.rotY]), () => ( 24)), -80, 80) * (Math.PI / 180);
+  const usePerspective = _optionalChain([chart, 'access', _216 => _216.view3d, 'optionalAccess', _217 => _217.rAngAx]) === false;
+  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _218 => _218.view3d, 'optionalAccess', _219 => _219.perspective]), () => ( (usePerspective ? 26 : 0)))) / 100, 0, 1);
   const normalizeX = (categoryIndex) => categoryCount <= 1 ? 0 : (categoryIndex / (categoryCount - 1) - 0.5) * 2;
   const normalizeY = (value) => -(((value - minValue) / valueSpan - 0.5) * 2);
   const stackedAreaDepthSpan = isAreaChart && isStackedSeries ? Math.max(0.18, (frontZ - backZ) * 0.56) : 0;
@@ -1930,7 +1865,7 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
         categoryIndex,
         defined: point.defined,
         depth: top.depth,
-        depthBack: _nullishCoalesce(_optionalChain([topBack, 'optionalAccess', _222 => _222.depth]), () => ( top.depth)),
+        depthBack: _nullishCoalesce(_optionalChain([topBack, 'optionalAccess', _220 => _220.depth]), () => ( top.depth)),
         top,
         topBack
       };
@@ -2055,11 +1990,11 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
       ] : [];
       const strokeColor = chartSeriesStrokeColor(chart, seriesIndex);
       const fillColor = chartSeriesColor(chart, seriesIndex);
-      const markerSymbol = normalizeChartMarkerSymbol(_optionalChain([chart, 'access', _223 => _223.series, 'access', _224 => _224[seriesIndex], 'optionalAccess', _225 => _225.markerSymbol]));
-      const markerPath = markerSymbolPath(markerSymbol, markerRadiusPx(_optionalChain([chart, 'access', _226 => _226.series, 'access', _227 => _227[seriesIndex], 'optionalAccess', _228 => _228.markerSize])));
+      const markerSymbol = normalizeChartMarkerSymbol(_optionalChain([chart, 'access', _221 => _221.series, 'access', _222 => _222[seriesIndex], 'optionalAccess', _223 => _223.markerSymbol]));
+      const markerPath = markerSymbolPath(markerSymbol, markerRadiusPx(_optionalChain([chart, 'access', _224 => _224.series, 'access', _225 => _225[seriesIndex], 'optionalAccess', _226 => _226.markerSize])));
       const slabFaces = isAreaChart && isStackedSeries ? definedPoints.slice(1).map((point, pointIndex) => {
         const previous = definedPoints[pointIndex];
-        if (!_optionalChain([previous, 'optionalAccess', _229 => _229.topBack]) || !point.topBack || !previous.bottomBack || !point.bottomBack) {
+        if (!_optionalChain([previous, 'optionalAccess', _227 => _227.topBack]) || !point.topBack || !previous.bottomBack || !point.bottomBack) {
           return null;
         }
         const topFace = buildLinearSvgPath([previous.top, point.top, point.topBack, previous.topBack], true);
@@ -2091,13 +2026,13 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
       }) : [];
       const firstDefinedPoint = _nullishCoalesce(definedPoints[0], () => ( null));
       const lastDefinedPoint = _nullishCoalesce(definedPoints[definedPoints.length - 1], () => ( null));
-      const startCap = isAreaChart && isStackedSeries && _optionalChain([firstDefinedPoint, 'optionalAccess', _230 => _230.topBack]) && _optionalChain([firstDefinedPoint, 'optionalAccess', _231 => _231.bottomBack]) ? buildLinearSvgPath([
+      const startCap = isAreaChart && isStackedSeries && _optionalChain([firstDefinedPoint, 'optionalAccess', _228 => _228.topBack]) && _optionalChain([firstDefinedPoint, 'optionalAccess', _229 => _229.bottomBack]) ? buildLinearSvgPath([
         firstDefinedPoint.top,
         firstDefinedPoint.bottom,
         firstDefinedPoint.bottomBack,
         firstDefinedPoint.topBack
       ], true) : "";
-      const endCap = isAreaChart && isStackedSeries && _optionalChain([lastDefinedPoint, 'optionalAccess', _232 => _232.topBack]) && _optionalChain([lastDefinedPoint, 'optionalAccess', _233 => _233.bottomBack]) ? buildLinearSvgPath([
+      const endCap = isAreaChart && isStackedSeries && _optionalChain([lastDefinedPoint, 'optionalAccess', _230 => _230.topBack]) && _optionalChain([lastDefinedPoint, 'optionalAccess', _231 => _231.bottomBack]) ? buildLinearSvgPath([
         lastDefinedPoint.top,
         lastDefinedPoint.bottom,
         lastDefinedPoint.bottomBack,
@@ -2170,7 +2105,7 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
             fill: "none",
             stroke: strokeColor,
             strokeLinejoin: "round",
-            strokeWidth: Math.max(1.8, _nullishCoalesce(_optionalChain([chart, 'access', _234 => _234.series, 'access', _235 => _235[seriesIndex], 'optionalAccess', _236 => _236.lineWidthPx]), () => ( 2)))
+            strokeWidth: Math.max(1.8, _nullishCoalesce(_optionalChain([chart, 'access', _232 => _232.series, 'access', _233 => _233[seriesIndex], 'optionalAccess', _234 => _234.lineWidthPx]), () => ( 2)))
           }
         ),
         markerPath.length > 0 ? definedPoints.map((point, pointIndex) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -2182,8 +2117,8 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
               {
                 ...chartElementDataProps(seriesIndex, point.categoryIndex),
                 d: markerPath,
-                fill: _nullishCoalesce(_optionalChain([chart, 'access', _237 => _237.series, 'access', _238 => _238[seriesIndex], 'optionalAccess', _239 => _239.markerColor]), () => ( fillColor)),
-                stroke: _nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _240 => _240.series, 'access', _241 => _241[seriesIndex], 'optionalAccess', _242 => _242.markerLineColor]), () => ( chart.chartAreaFillColor)), () => ( palette.surface)),
+                fill: _nullishCoalesce(_optionalChain([chart, 'access', _235 => _235.series, 'access', _236 => _236[seriesIndex], 'optionalAccess', _237 => _237.markerColor]), () => ( fillColor)),
+                stroke: _nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _238 => _238.series, 'access', _239 => _239[seriesIndex], 'optionalAccess', _240 => _240.markerLineColor]), () => ( chart.chartAreaFillColor)), () => ( palette.surface)),
                 strokeWidth: 1
               }
             )
@@ -2202,7 +2137,7 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
             stroke: "none"
           }
         )),
-        definedPoints.map((point) => isSelectedChartPointOrSeries(selectedChartElement, chart.id, seriesIndex, point.categoryIndex) ? renderSelectionPointHandles(
+        definedPoints.map((point) => isSelectedChartPointOrSeries(selectedChartElement, chart.id, seriesIndex, point.categoryIndex) ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
           `line3d-selection-${seriesIndex}-${point.categoryIndex}`,
           [{ x: point.top.x, y: point.top.y }]
         ) : null)
@@ -2245,7 +2180,7 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
   const isPercentStacked = chartType === "ColumnPercentStacked" || chartType === "BarPercentStacked";
   const isHorizontal = chartType === "BarClustered" || chartType === "BarStacked" || chartType === "BarPercentStacked";
   const isHistogramLike = isHistogramLikeChart(chart) && chartType === "ColumnClustered";
-  const shouldReverseCategories = isHorizontal && _optionalChain([chart, 'access', _243 => _243.categoryAxis, 'optionalAccess', _244 => _244.orientation]) !== "maxMin";
+  const shouldReverseCategories = isHorizontal && _optionalChain([chart, 'access', _241 => _241.categoryAxis, 'optionalAccess', _242 => _242.orientation]) !== "maxMin";
   const categories = shouldReverseCategories ? sourceCategories.slice().reverse() : sourceCategories;
   const isStacked = chartType === "ColumnStacked" || chartType === "BarStacked" || isPercentStacked;
   const negativeFillMode = isPercentStacked ? "chartArea" : chartType === "ColumnClustered" ? "none" : "series";
@@ -2337,13 +2272,13 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
   const depthGridSpanY = usesSeriesDepthAxis && frameOffsets ? frameOffsets.depthY * depthLaneSpread : 0;
   const depthSlotX = usesSeriesDepthAxis ? depthGridSpanX / Math.max(1, seriesCount) : 0;
   const depthSlotY = usesSeriesDepthAxis ? depthGridSpanY / Math.max(1, seriesCount) : 0;
-  const depthBarX = usesSeriesDepthAxis ? Math.sign(depthSlotX || _optionalChain([frameOffsets, 'optionalAccess', _245 => _245.depthX]) || 1) * Math.max(8, Math.abs(depthSlotX) * 1.14) : _optionalChain([frameOffsets, 'optionalAccess', _246 => _246.depthX]);
-  const depthBarY = usesSeriesDepthAxis ? Math.sign(depthSlotY || _optionalChain([frameOffsets, 'optionalAccess', _247 => _247.depthY]) || -1) * Math.max(5.5, Math.abs(depthSlotY) * 1.12) : _optionalChain([frameOffsets, 'optionalAccess', _248 => _248.depthY]);
-  const shouldReverseValueAxis = _optionalChain([chart, 'access', _249 => _249.valueAxis, 'optionalAccess', _250 => _250.orientation]) === "maxMin";
+  const depthBarX = usesSeriesDepthAxis ? Math.sign(depthSlotX || _optionalChain([frameOffsets, 'optionalAccess', _243 => _243.depthX]) || 1) * Math.max(8, Math.abs(depthSlotX) * 1.14) : _optionalChain([frameOffsets, 'optionalAccess', _244 => _244.depthX]);
+  const depthBarY = usesSeriesDepthAxis ? Math.sign(depthSlotY || _optionalChain([frameOffsets, 'optionalAccess', _245 => _245.depthY]) || -1) * Math.max(5.5, Math.abs(depthSlotY) * 1.12) : _optionalChain([frameOffsets, 'optionalAccess', _246 => _246.depthY]);
+  const shouldReverseValueAxis = _optionalChain([chart, 'access', _247 => _247.valueAxis, 'optionalAccess', _248 => _248.orientation]) === "maxMin";
   const valueScale = _d3scale.scaleLinear.call(void 0, ).domain([minValue, maxValue]).range(
     isHorizontal ? shouldReverseValueAxis ? [plot.left + plot.width, plot.left] : [plot.left, plot.left + plot.width] : shouldReverseValueAxis ? [plot.top, plot.top + plot.height] : [plot.top + plot.height, plot.top]
   );
-  const ticks = isPercentStacked ? buildNumericTickValues(minValue, maxValue, _nullishCoalesce(_optionalChain([chart, 'access', _251 => _251.valueAxis, 'optionalAccess', _252 => _252.majorUnit]), () => ( 20))) : valueDomain.ticks;
+  const ticks = isPercentStacked ? buildNumericTickValues(minValue, maxValue, _nullishCoalesce(_optionalChain([chart, 'access', _249 => _249.valueAxis, 'optionalAccess', _250 => _250.majorUnit]), () => ( 20))) : valueDomain.ticks;
   const categoryPositions = categories.map((category) => {
     const bandStart = _nullishCoalesce(categoryScale(category), () => ( 0));
     return bandStart + categoryScale.bandwidth() / 2;
@@ -2356,7 +2291,7 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
       const value = _nullishCoalesce(matrix[seriesIndex][categoryIndex], () => ( 0));
       const rawValue = _nullishCoalesce(rawMatrix[seriesIndex][categoryIndex], () => ( value));
       const pointIndex = shouldReverseCategories ? categoryCount - 1 - categoryIndex : categoryIndex;
-      const pointStyle = _optionalChain([chart, 'access', _253 => _253.series, 'access', _254 => _254[seriesIndex], 'optionalAccess', _255 => _255.dataPointStyles, 'optionalAccess', _256 => _256.find, 'call', _257 => _257((entry) => entry.index === pointIndex)]);
+      const pointStyle = _optionalChain([chart, 'access', _251 => _251.series, 'access', _252 => _252[seriesIndex], 'optionalAccess', _253 => _253.dataPointStyles, 'optionalAccess', _254 => _254.find, 'call', _255 => _255((entry) => entry.index === pointIndex)]);
       let start = 0;
       let end = value;
       if (isStacked) {
@@ -2371,19 +2306,19 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
         }
       }
       const colors = chartSeriesBarColors(chart, seriesIndex, rawValue, negativeFillMode);
-      const isInvertedNegative = rawValue < 0 && _optionalChain([chart, 'access', _258 => _258.series, 'access', _259 => _259[seriesIndex], 'optionalAccess', _260 => _260.invertIfNegative]) === true;
+      const isInvertedNegative = rawValue < 0 && _optionalChain([chart, 'access', _256 => _256.series, 'access', _257 => _257[seriesIndex], 'optionalAccess', _258 => _258.invertIfNegative]) === true;
       if (!isInvertedNegative) {
         if (variesBarColorsByCategory(chart)) {
           colors.fill = chartPointColor(chart, pointIndex, seriesIndex);
           colors.stroke = colors.fill;
         }
-        if (_optionalChain([pointStyle, 'optionalAccess', _261 => _261.color])) {
+        if (_optionalChain([pointStyle, 'optionalAccess', _259 => _259.color])) {
           colors.fill = pointStyle.color;
           if (!pointStyle.lineColor) {
             colors.stroke = pointStyle.color;
           }
         }
-        if (_optionalChain([pointStyle, 'optionalAccess', _262 => _262.lineColor])) {
+        if (_optionalChain([pointStyle, 'optionalAccess', _260 => _260.lineColor])) {
           colors.stroke = pointStyle.lineColor;
         }
       }
@@ -2396,7 +2331,7 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
       const barOffset = usesSeriesDepthAxis ? Math.max(0, (categoryScale.bandwidth() - barThickness) * 0.5) : isHistogramLike ? 0 : isStacked ? 0 : _nullishCoalesce(seriesScale(String(seriesIndex)), () => ( 0));
       const depthOffsetX = usesSeriesDepthAxis ? depthSlotX * seriesIndex : 0;
       const depthOffsetY = usesSeriesDepthAxis ? depthSlotY * seriesIndex : 0;
-      const depthOrder = depthOffsetX * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _263 => _263.depthX]), () => ( 0))) + depthOffsetY * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _264 => _264.depthY]), () => ( 0)));
+      const depthOrder = depthOffsetX * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _261 => _261.depthX]), () => ( 0))) + depthOffsetY * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _262 => _262.depthY]), () => ( 0)));
       const shapeTaper = normalized3dShape === "pyramid" ? 0.94 : normalized3dShape === "cone" ? 1 : 0;
       let topScale = 1;
       let bottomScale = 1;
@@ -2434,8 +2369,8 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
           isHorizontal: true,
           key: `bar-${seriesIndex}-${categoryIndex}`,
           left: Math.min(x1, x2),
-          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _265 => _265.depthX]),
-          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _266 => _266.depthY]),
+          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _263 => _263.depthX]),
+          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _264 => _264.depthY]),
           shape3d: normalized3dShape,
           seriesIndex,
           stroke: colors.stroke,
@@ -2464,8 +2399,8 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
           isHorizontal: false,
           key: `bar-${seriesIndex}-${categoryIndex}`,
           left: categoryStart + barOffset,
-          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _267 => _267.depthX]),
-          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _268 => _268.depthY]),
+          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _265 => _265.depthX]),
+          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _266 => _266.depthY]),
           shape3d: normalized3dShape,
           seriesIndex,
           stroke: colors.stroke,
@@ -2537,8 +2472,8 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
   );
   const depthAxisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const depthGridColor = lightenColor(depthAxisColor, 0.48);
-  const frameDepthX = usesSeriesDepthAxis ? depthGridSpanX : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _269 => _269.depthX]), () => ( 0));
-  const frameDepthY = usesSeriesDepthAxis ? depthGridSpanY : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _270 => _270.depthY]), () => ( 0));
+  const frameDepthX = usesSeriesDepthAxis ? depthGridSpanX : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _267 => _267.depthX]), () => ( 0));
+  const frameDepthY = usesSeriesDepthAxis ? depthGridSpanY : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _268 => _268.depthY]), () => ( 0));
   const depthAxisNode = usesSeriesDepthAxis && frameOffsets ? /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
     Array.from({ length: categoryCount + 1 }, (_, boundaryIndex) => {
       const x = plot.left + boundaryIndex / Math.max(1, categoryCount) * plot.width;
@@ -2633,7 +2568,7 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
         y: bar.top
       }
     )),
-    renderedBars.map((bar) => isSelectedChartPoint(selectedChartElement, chart.id, bar.seriesIndex, bar.categoryIndex) || isSelectedChartSeries(selectedChartElement, chart.id, bar.seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _271 => _271.kind]) !== "point" ? renderSelectionRectHandles(`bar-selection-${bar.key}`, bar.left, bar.top, bar.width, bar.height) : null)
+    renderedBars.map((bar) => isSelectedChartPoint(selectedChartElement, chart.id, bar.seriesIndex, bar.categoryIndex) || isSelectedChartSeries(selectedChartElement, chart.id, bar.seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _269 => _269.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, `bar-selection-${bar.key}`, bar.left, bar.top, bar.width, bar.height) : null)
   ] });
 }
 function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartElement) {
@@ -2660,11 +2595,11 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       return Math.abs(total) < 1e-9 ? 1 : total;
     }) : null;
     return chart.series.map((_, seriesIndex) => categories.map((_2, categoryIndex) => {
-      const rawValue = _nullishCoalesce(_optionalChain([resolvedValuesBySeries, 'access', _272 => _272[seriesIndex], 'optionalAccess', _273 => _273[categoryIndex]]), () => ( null));
+      const rawValue = _nullishCoalesce(_optionalChain([resolvedValuesBySeries, 'access', _270 => _270[seriesIndex], 'optionalAccess', _271 => _271[categoryIndex]]), () => ( null));
       if (rawValue == null) {
         return { defined: false, y: null, y0: null, y1: null };
       }
-      const value = isPercentStackedSeries ? rawValue / (_nullishCoalesce(_optionalChain([categoryTotals, 'optionalAccess', _274 => _274[categoryIndex]]), () => ( 1))) * 100 : rawValue;
+      const value = isPercentStackedSeries ? rawValue / (_nullishCoalesce(_optionalChain([categoryTotals, 'optionalAccess', _272 => _272[categoryIndex]]), () => ( 1))) * 100 : rawValue;
       if (value >= 0) {
         const start2 = positive[categoryIndex];
         const end2 = start2 + value;
@@ -2677,7 +2612,7 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       return { defined: true, y: end, y0: start, y1: end };
     }));
   })() : chart.series.map((_, seriesIndex) => categories.map((_2, categoryIndex) => {
-    const value = _nullishCoalesce(_optionalChain([resolvedValuesBySeries, 'access', _275 => _275[seriesIndex], 'optionalAccess', _276 => _276[categoryIndex]]), () => ( null));
+    const value = _nullishCoalesce(_optionalChain([resolvedValuesBySeries, 'access', _273 => _273[seriesIndex], 'optionalAccess', _274 => _274[categoryIndex]]), () => ( null));
     return {
       defined: value != null,
       y: value,
@@ -2693,12 +2628,12 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
   let maxValue = Math.max(...stackedExtents);
   if (isAreaChart) {
     minValue = Math.min(0, minValue);
-  } else if ((chartType === "Line" || isStackedLine) && _optionalChain([chart, 'access', _277 => _277.valueAxis, 'optionalAccess', _278 => _278.crosses]) === "autoZero") {
+  } else if ((chartType === "Line" || isStackedLine) && _optionalChain([chart, 'access', _275 => _275.valueAxis, 'optionalAccess', _276 => _276.crosses]) === "autoZero") {
     minValue = Math.min(0, minValue);
   }
   if (isPercentStackedSeries) {
-    const explicitMin = typeof _optionalChain([chart, 'access', _279 => _279.valueAxis, 'optionalAccess', _280 => _280.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? Number(chart.valueAxis.min) : Math.min(0, minValue);
-    const explicitMax = typeof _optionalChain([chart, 'access', _281 => _281.valueAxis, 'optionalAccess', _282 => _282.max]) === "number" && Number.isFinite(chart.valueAxis.max) ? Number(chart.valueAxis.max) : Math.max(100, maxValue);
+    const explicitMin = typeof _optionalChain([chart, 'access', _277 => _277.valueAxis, 'optionalAccess', _278 => _278.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? Number(chart.valueAxis.min) : Math.min(0, minValue);
+    const explicitMax = typeof _optionalChain([chart, 'access', _279 => _279.valueAxis, 'optionalAccess', _280 => _280.max]) === "number" && Number.isFinite(chart.valueAxis.max) ? Number(chart.valueAxis.max) : Math.max(100, maxValue);
     minValue = explicitMin;
     maxValue = explicitMax <= explicitMin ? explicitMin + 1 : explicitMax;
   } else {
@@ -2706,24 +2641,24 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       chart.valueAxis,
       minValue,
       maxValue,
-      isAreaChart || _optionalChain([chart, 'access', _283 => _283.valueAxis, 'optionalAccess', _284 => _284.crosses]) === "autoZero"
+      isAreaChart || _optionalChain([chart, 'access', _281 => _281.valueAxis, 'optionalAccess', _282 => _282.crosses]) === "autoZero"
     );
     minValue = valueDomain.min;
     maxValue = valueDomain.max;
   }
   const xScale = _d3scale.scalePoint.call(void 0, ).domain(categories).range([plot.left, plot.left + plot.width]);
   const yScale = _d3scale.scaleLinear.call(void 0, ).domain([minValue, maxValue]).range([plot.top + plot.height, plot.top]);
-  const ticks = isPercentStackedSeries ? buildNumericTickValues(minValue, maxValue, _nullishCoalesce(_optionalChain([chart, 'access', _285 => _285.valueAxis, 'optionalAccess', _286 => _286.majorUnit]), () => ( 20))) : resolveAxisDomainWithChartOverrides(
+  const ticks = isPercentStackedSeries ? buildNumericTickValues(minValue, maxValue, _nullishCoalesce(_optionalChain([chart, 'access', _283 => _283.valueAxis, 'optionalAccess', _284 => _284.majorUnit]), () => ( 20))) : resolveAxisDomainWithChartOverrides(
     chart.valueAxis,
     minValue,
     maxValue,
-    isAreaChart || _optionalChain([chart, 'access', _287 => _287.valueAxis, 'optionalAccess', _288 => _288.crosses]) === "autoZero"
+    isAreaChart || _optionalChain([chart, 'access', _285 => _285.valueAxis, 'optionalAccess', _286 => _286.crosses]) === "autoZero"
   ).ticks;
   const categoryPositions = categories.map((category) => _nullishCoalesce(xScale(category), () => ( plot.left)));
   const curve = _d3shape.curveLinear;
   const areaBaseline = yScale(Math.max(minValue, 0));
   const plotPointsBySeries = chart.series.map((_, seriesIndex) => categories.map((category, categoryIndex) => {
-    const point = _nullishCoalesce(_optionalChain([stackedPointsBySeries, 'access', _289 => _289[seriesIndex], 'optionalAccess', _290 => _290[categoryIndex]]), () => ( {
+    const point = _nullishCoalesce(_optionalChain([stackedPointsBySeries, 'access', _287 => _287[seriesIndex], 'optionalAccess', _288 => _288[categoryIndex]]), () => ( {
       defined: false,
       y: null,
       y0: null,
@@ -2752,12 +2687,12 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
     );
   }
   const rawRecord = chart.raw && typeof chart.raw === "object" ? chart.raw : null;
-  const dropLinesRecord = _optionalChain([rawRecord, 'optionalAccess', _291 => _291.dropLines]) && typeof rawRecord.dropLines === "object" ? rawRecord.dropLines : null;
-  const highLowLinesRecord = _optionalChain([rawRecord, 'optionalAccess', _292 => _292.highLowLines]) && typeof rawRecord.highLowLines === "object" ? rawRecord.highLowLines : null;
-  const upDownBarsRecord = _optionalChain([rawRecord, 'optionalAccess', _293 => _293.upDownBars]) && typeof rawRecord.upDownBars === "object" ? rawRecord.upDownBars : null;
-  const dropLineColor = _nullishCoalesce(normalizeRendererHexColor(_optionalChain([dropLinesRecord, 'optionalAccess', _294 => _294.shapeProperties, 'optionalAccess', _295 => _295.lineColorHex])), () => ( lightenColor(_nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border)), 0.45)));
-  const highLowLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(normalizeRendererHexColor(_optionalChain([highLowLinesRecord, 'optionalAccess', _296 => _296.shapeProperties, 'optionalAccess', _297 => _297.lineColorHex])), () => ( chart.axisLineColor)), () => ( chart.chartAreaBorderColor)), () => ( palette.border));
-  const upDownGapWidth = typeof _optionalChain([upDownBarsRecord, 'optionalAccess', _298 => _298.gapWidth]) === "number" && Number.isFinite(upDownBarsRecord.gapWidth) ? upDownBarsRecord.gapWidth : 150;
+  const dropLinesRecord = _optionalChain([rawRecord, 'optionalAccess', _289 => _289.dropLines]) && typeof rawRecord.dropLines === "object" ? rawRecord.dropLines : null;
+  const highLowLinesRecord = _optionalChain([rawRecord, 'optionalAccess', _290 => _290.highLowLines]) && typeof rawRecord.highLowLines === "object" ? rawRecord.highLowLines : null;
+  const upDownBarsRecord = _optionalChain([rawRecord, 'optionalAccess', _291 => _291.upDownBars]) && typeof rawRecord.upDownBars === "object" ? rawRecord.upDownBars : null;
+  const dropLineColor = _nullishCoalesce(normalizeRendererHexColor(_optionalChain([dropLinesRecord, 'optionalAccess', _292 => _292.shapeProperties, 'optionalAccess', _293 => _293.lineColorHex])), () => ( lightenColor(_nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border)), 0.45)));
+  const highLowLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(normalizeRendererHexColor(_optionalChain([highLowLinesRecord, 'optionalAccess', _294 => _294.shapeProperties, 'optionalAccess', _295 => _295.lineColorHex])), () => ( chart.axisLineColor)), () => ( chart.chartAreaBorderColor)), () => ( palette.border));
+  const upDownGapWidth = typeof _optionalChain([upDownBarsRecord, 'optionalAccess', _296 => _296.gapWidth]) === "number" && Number.isFinite(upDownBarsRecord.gapWidth) ? upDownBarsRecord.gapWidth : 150;
   const categoryStep = categoryPositions.length >= 2 ? Math.min(...categoryPositions.slice(1).map((position, index) => Math.abs(position - (_nullishCoalesce(categoryPositions[index], () => ( 0))))).filter((value) => value > 0)) : plot.width;
   const upDownBarWidth = clamp(categoryStep * (1 - resolveCategoryBandPadding(upDownGapWidth).inner) * 0.82, 3, 28);
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
@@ -2772,7 +2707,7 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       (value) => yScale(value)
     ),
     !isAreaChart && !isStackedSeries && highLowLinesRecord ? categories.map((_, categoryIndex) => {
-      const yValues = plotPointsBySeries.map((seriesPoints) => _optionalChain([seriesPoints, 'access', _299 => _299[categoryIndex], 'optionalAccess', _300 => _300.y])).filter((value) => value != null && Number.isFinite(value));
+      const yValues = plotPointsBySeries.map((seriesPoints) => _optionalChain([seriesPoints, 'access', _297 => _297[categoryIndex], 'optionalAccess', _298 => _298.y])).filter((value) => value != null && Number.isFinite(value));
       if (yValues.length < 2) {
         return null;
       }
@@ -2791,8 +2726,8 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       );
     }) : null,
     !isAreaChart && !isStackedSeries && upDownBarsRecord && plotPointsBySeries.length >= 2 ? categories.map((_, categoryIndex) => {
-      const first = _optionalChain([plotPointsBySeries, 'access', _301 => _301[0], 'optionalAccess', _302 => _302[categoryIndex]]);
-      const second = _optionalChain([plotPointsBySeries, 'access', _303 => _303[plotPointsBySeries.length - 1], 'optionalAccess', _304 => _304[categoryIndex]]);
+      const first = _optionalChain([plotPointsBySeries, 'access', _299 => _299[0], 'optionalAccess', _300 => _300[categoryIndex]]);
+      const second = _optionalChain([plotPointsBySeries, 'access', _301 => _301[plotPointsBySeries.length - 1], 'optionalAccess', _302 => _302[categoryIndex]]);
       if (!first || !second || first.y == null || second.y == null) {
         return null;
       }
@@ -2820,7 +2755,7 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       const lineStrokePoints = displayBlanksAs === "span" ? points.filter((point) => point.y != null) : points;
       const linePath = _nullishCoalesce(_d3shape.line.call(void 0, ).defined((point) => point.y != null).x((point) => point.x).y((point) => yScale(_nullishCoalesce(point.y, () => ( 0)))).curve(curve)(lineStrokePoints), () => ( ""));
       const areaPath = isAreaChart ? _nullishCoalesce(_d3shape.area.call(void 0, ).defined((point) => isStackedSeries ? point.y0 != null && point.y1 != null : point.y != null).x((point) => point.x).y0((point) => isStackedSeries ? yScale(_nullishCoalesce(point.y0, () => ( 0))) : areaBaseline).y1((point) => yScale(_nullishCoalesce((isStackedSeries ? point.y1 : point.y), () => ( 0)))).curve(curve)(points), () => ( "")) : "";
-      const seriesFillColor = typeof _optionalChain([series, 'access', _305 => _305.shapeProperties, 'optionalAccess', _306 => _306.xmlFillColor]) === "string" ? series.shapeProperties.xmlFillColor : chartSeriesColor(chart, seriesIndex);
+      const seriesFillColor = typeof _optionalChain([series, 'access', _303 => _303.shapeProperties, 'optionalAccess', _304 => _304.xmlFillColor]) === "string" ? series.shapeProperties.xmlFillColor : chartSeriesColor(chart, seriesIndex);
       return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
         !isAreaChart && !isStackedSeries && dropLinesRecord ? points.map((point, pointIndex) => point.y == null ? null : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "line",
@@ -2850,7 +2785,7 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
             ...chartElementDataProps(seriesIndex),
             d: linePath,
             fill: "none",
-            stroke: _optionalChain([series, 'access', _307 => _307.shapeProperties, 'optionalAccess', _308 => _308.xmlLineHidden]) === true ? "none" : chartSeriesStrokeColor(chart, seriesIndex),
+            stroke: _optionalChain([series, 'access', _305 => _305.shapeProperties, 'optionalAccess', _306 => _306.xmlLineHidden]) === true ? "none" : chartSeriesStrokeColor(chart, seriesIndex),
             strokeLinecap: "round",
             strokeLinejoin: "round",
             strokeWidth: Math.max(1.5, _nullishCoalesce(series.lineWidthPx, () => ( 2)))
@@ -2868,7 +2803,7 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
             strokeWidth: 1
           }
         )),
-        points.map((point, pointIndex) => point.y != null && (isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _309 => _309.kind]) !== "point") ? isAreaChart ? renderSelectionPointHandles(`area-selection-${seriesIndex}-${pointIndex}`, [{ x: point.x, y: yScale(point.y) }]) : renderSelectionRectHandles(
+        points.map((point, pointIndex) => point.y != null && (isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _307 => _307.kind]) !== "point") ? isAreaChart ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, `area-selection-${seriesIndex}-${pointIndex}`, [{ x: point.x, y: yScale(point.y) }]) : _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
           `line-selection-${seriesIndex}-${pointIndex}`,
           point.x - 4,
           yScale(point.y) - 4,
@@ -2900,7 +2835,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
     return null;
   }
   const plot = layout.plot;
-  const groupGapWidth = typeof _optionalChain([columnGroup, 'access', _310 => _310.raw, 'optionalAccess', _311 => _311.gapWidth]) === "number" && Number.isFinite(columnGroup.raw.gapWidth) ? columnGroup.raw.gapWidth : _nullishCoalesce(columnGroup.gapWidth, () => ( chart.gapWidth));
+  const groupGapWidth = typeof _optionalChain([columnGroup, 'access', _308 => _308.raw, 'optionalAccess', _309 => _309.gapWidth]) === "number" && Number.isFinite(columnGroup.raw.gapWidth) ? columnGroup.raw.gapWidth : _nullishCoalesce(columnGroup.gapWidth, () => ( chart.gapWidth));
   const histogramColumns = columnGroup.series.some((series) => isHistogramLikeSeries(series));
   const categoryBandPadding = histogramColumns ? { inner: 0, outer: 0 } : resolveCategoryBandPadding(groupGapWidth);
   const categoryScale = _d3scale.scaleBand.call(void 0, ).domain(categories).range([plot.left, plot.left + plot.width]).paddingInner(categoryBandPadding.inner).paddingOuter(categoryBandPadding.outer);
@@ -2916,15 +2851,15 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
     return null;
   }
   const primaryDomain = resolveNumericAxisDomain(
-    typeof _optionalChain([columnGroup, 'access', _312 => _312.valueAxis, 'optionalAccess', _313 => _313.min]) === "number" ? columnGroup.valueAxis.min : Math.min(...primaryValues),
-    typeof _optionalChain([columnGroup, 'access', _314 => _314.valueAxis, 'optionalAccess', _315 => _315.max]) === "number" ? columnGroup.valueAxis.max : Math.max(...primaryValues),
-    _optionalChain([columnGroup, 'access', _316 => _316.valueAxis, 'optionalAccess', _317 => _317.majorUnit]),
+    typeof _optionalChain([columnGroup, 'access', _310 => _310.valueAxis, 'optionalAccess', _311 => _311.min]) === "number" ? columnGroup.valueAxis.min : Math.min(...primaryValues),
+    typeof _optionalChain([columnGroup, 'access', _312 => _312.valueAxis, 'optionalAccess', _313 => _313.max]) === "number" ? columnGroup.valueAxis.max : Math.max(...primaryValues),
+    _optionalChain([columnGroup, 'access', _314 => _314.valueAxis, 'optionalAccess', _315 => _315.majorUnit]),
     true
   );
   const secondaryDomain = resolveNumericAxisDomain(
-    typeof _optionalChain([lineGroup, 'access', _318 => _318.valueAxis, 'optionalAccess', _319 => _319.min]) === "number" ? lineGroup.valueAxis.min : Math.min(...secondaryValues),
-    typeof _optionalChain([lineGroup, 'access', _320 => _320.valueAxis, 'optionalAccess', _321 => _321.max]) === "number" ? lineGroup.valueAxis.max : Math.max(...secondaryValues),
-    _optionalChain([lineGroup, 'access', _322 => _322.valueAxis, 'optionalAccess', _323 => _323.majorUnit]),
+    typeof _optionalChain([lineGroup, 'access', _316 => _316.valueAxis, 'optionalAccess', _317 => _317.min]) === "number" ? lineGroup.valueAxis.min : Math.min(...secondaryValues),
+    typeof _optionalChain([lineGroup, 'access', _318 => _318.valueAxis, 'optionalAccess', _319 => _319.max]) === "number" ? lineGroup.valueAxis.max : Math.max(...secondaryValues),
+    _optionalChain([lineGroup, 'access', _320 => _320.valueAxis, 'optionalAccess', _321 => _321.majorUnit]),
     false
   );
   const primaryScale = _d3scale.scaleLinear.call(void 0, ).domain([primaryDomain.min, primaryDomain.max]).range([plot.top + plot.height, plot.top]);
@@ -2942,7 +2877,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
       primaryDomain.ticks,
       (value) => primaryScale(value)
     ),
-    _optionalChain([lineGroup, 'access', _324 => _324.valueAxis, 'optionalAccess', _325 => _325.delete]) !== true && _optionalChain([lineGroup, 'access', _326 => _326.valueAxis, 'optionalAccess', _327 => _327.labelPosition]) !== "none" ? secondaryDomain.ticks.map((tick) => {
+    _optionalChain([lineGroup, 'access', _322 => _322.valueAxis, 'optionalAccess', _323 => _323.delete]) !== true && _optionalChain([lineGroup, 'access', _324 => _324.valueAxis, 'optionalAccess', _325 => _325.labelPosition]) !== "none" ? secondaryDomain.ticks.map((tick) => {
       const y = secondaryScale(tick);
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "text",
@@ -2957,7 +2892,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
         `combo-secondary-tick-${tick}`
       );
     }) : null,
-    _optionalChain([lineGroup, 'access', _328 => _328.valueAxis, 'optionalAccess', _329 => _329.delete]) !== true ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _optionalChain([lineGroup, 'access', _326 => _326.valueAxis, 'optionalAccess', _327 => _327.delete]) !== true ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "line",
       {
         stroke: axisColor,
@@ -2977,7 +2912,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
       const y = primaryScale(Math.max(0, value));
       const zeroY = primaryScale(0);
       const height = Math.max(1, Math.abs(zeroY - primaryScale(value)));
-      const selected = isSelectedChartPoint(selectedChartElement, chart.id, globalSeriesIndex, categoryIndex) || isSelectedChartSeries(selectedChartElement, chart.id, globalSeriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _330 => _330.kind]) !== "point";
+      const selected = isSelectedChartPoint(selectedChartElement, chart.id, globalSeriesIndex, categoryIndex) || isSelectedChartSeries(selectedChartElement, chart.id, globalSeriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _328 => _328.kind]) !== "point";
       return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, React.Fragment, { children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "rect",
@@ -2992,7 +2927,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
             y: Math.min(y, zeroY)
           }
         ),
-        selected ? renderSelectionRectHandles(
+        selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
           `combo-bar-selection-${globalSeriesIndex}-${categoryIndex}`,
           x,
           Math.min(y, zeroY),
@@ -3034,7 +2969,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
             transform: `translate(${point.x}, ${secondaryScale(point.y)})`
           }
         )),
-        points.map((point, pointIndex) => point.y != null && isSelectedChartPointOrSeries(selectedChartElement, chart.id, globalSeriesIndex, pointIndex) ? renderSelectionRectHandles(
+        points.map((point, pointIndex) => point.y != null && isSelectedChartPointOrSeries(selectedChartElement, chart.id, globalSeriesIndex, pointIndex) ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
           `combo-line-selection-${globalSeriesIndex}-${pointIndex}`,
           point.x - 4,
           secondaryScale(point.y) - 4,
@@ -3106,26 +3041,26 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
   if (allX.length === 0 || allY.length === 0) {
     return null;
   }
-  const hasExplicitMinX = typeof _optionalChain([chart, 'access', _331 => _331.categoryAxis, 'optionalAccess', _332 => _332.min]) === "number" && Number.isFinite(chart.categoryAxis.min);
-  const hasExplicitMaxX = typeof _optionalChain([chart, 'access', _333 => _333.categoryAxis, 'optionalAccess', _334 => _334.max]) === "number" && Number.isFinite(chart.categoryAxis.max);
-  const hasExplicitMinY = typeof _optionalChain([chart, 'access', _335 => _335.valueAxis, 'optionalAccess', _336 => _336.min]) === "number" && Number.isFinite(chart.valueAxis.min);
-  const hasExplicitMaxY = typeof _optionalChain([chart, 'access', _337 => _337.valueAxis, 'optionalAccess', _338 => _338.max]) === "number" && Number.isFinite(chart.valueAxis.max);
+  const hasExplicitMinX = typeof _optionalChain([chart, 'access', _329 => _329.categoryAxis, 'optionalAccess', _330 => _330.min]) === "number" && Number.isFinite(chart.categoryAxis.min);
+  const hasExplicitMaxX = typeof _optionalChain([chart, 'access', _331 => _331.categoryAxis, 'optionalAccess', _332 => _332.max]) === "number" && Number.isFinite(chart.categoryAxis.max);
+  const hasExplicitMinY = typeof _optionalChain([chart, 'access', _333 => _333.valueAxis, 'optionalAccess', _334 => _334.min]) === "number" && Number.isFinite(chart.valueAxis.min);
+  const hasExplicitMaxY = typeof _optionalChain([chart, 'access', _335 => _335.valueAxis, 'optionalAccess', _336 => _336.max]) === "number" && Number.isFinite(chart.valueAxis.max);
   const hasSyntheticIndexAxis = pointsBySeries.some((series) => series.usesSyntheticIndex);
   const syntheticPointCount = Math.max(0, ...pointsBySeries.map((series) => series.pointCount));
-  let minX = hasExplicitMinX ? Number(_optionalChain([chart, 'access', _339 => _339.categoryAxis, 'optionalAccess', _340 => _340.min])) : Math.min(...allX);
-  let maxX = hasExplicitMaxX ? Number(_optionalChain([chart, 'access', _341 => _341.categoryAxis, 'optionalAccess', _342 => _342.max])) : Math.max(...allX);
-  let minY = hasExplicitMinY ? Number(_optionalChain([chart, 'access', _343 => _343.valueAxis, 'optionalAccess', _344 => _344.min])) : Math.min(...allY);
-  let maxY = hasExplicitMaxY ? Number(_optionalChain([chart, 'access', _345 => _345.valueAxis, 'optionalAccess', _346 => _346.max])) : Math.max(...allY);
+  let minX = hasExplicitMinX ? Number(_optionalChain([chart, 'access', _337 => _337.categoryAxis, 'optionalAccess', _338 => _338.min])) : Math.min(...allX);
+  let maxX = hasExplicitMaxX ? Number(_optionalChain([chart, 'access', _339 => _339.categoryAxis, 'optionalAccess', _340 => _340.max])) : Math.max(...allX);
+  let minY = hasExplicitMinY ? Number(_optionalChain([chart, 'access', _341 => _341.valueAxis, 'optionalAccess', _342 => _342.min])) : Math.min(...allY);
+  let maxY = hasExplicitMaxY ? Number(_optionalChain([chart, 'access', _343 => _343.valueAxis, 'optionalAccess', _344 => _344.max])) : Math.max(...allY);
   if (!hasExplicitMinX) {
-    minX = hasSyntheticIndexAxis ? 0 : _optionalChain([chart, 'access', _347 => _347.categoryAxis, 'optionalAccess', _348 => _348.crosses]) === "autoZero" ? Math.min(0, minX) : minX;
+    minX = hasSyntheticIndexAxis ? 0 : _optionalChain([chart, 'access', _345 => _345.categoryAxis, 'optionalAccess', _346 => _346.crosses]) === "autoZero" ? Math.min(0, minX) : minX;
   }
   if (!hasExplicitMaxX) {
-    maxX = hasSyntheticIndexAxis ? Math.max(maxX, syntheticPointCount + 1) : _optionalChain([chart, 'access', _349 => _349.categoryAxis, 'optionalAccess', _350 => _350.crosses]) === "autoZero" ? Math.max(0, maxX) : maxX;
+    maxX = hasSyntheticIndexAxis ? Math.max(maxX, syntheticPointCount + 1) : _optionalChain([chart, 'access', _347 => _347.categoryAxis, 'optionalAccess', _348 => _348.crosses]) === "autoZero" ? Math.max(0, maxX) : maxX;
   }
-  if (!hasExplicitMinY && _optionalChain([chart, 'access', _351 => _351.valueAxis, 'optionalAccess', _352 => _352.crosses]) === "autoZero") {
+  if (!hasExplicitMinY && _optionalChain([chart, 'access', _349 => _349.valueAxis, 'optionalAccess', _350 => _350.crosses]) === "autoZero") {
     minY = Math.min(0, minY);
   }
-  if (!hasExplicitMaxY && _optionalChain([chart, 'access', _353 => _353.valueAxis, 'optionalAccess', _354 => _354.crosses]) === "autoZero") {
+  if (!hasExplicitMaxY && _optionalChain([chart, 'access', _351 => _351.valueAxis, 'optionalAccess', _352 => _352.crosses]) === "autoZero") {
     maxY = Math.max(0, maxY);
   }
   if (maxX <= minX) {
@@ -3134,8 +3069,8 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
   if (maxY <= minY) {
     maxY = minY + 1;
   }
-  const xStep = typeof _optionalChain([chart, 'access', _355 => _355.categoryAxis, 'optionalAccess', _356 => _356.majorUnit]) === "number" && chart.categoryAxis.majorUnit > 0 ? chart.categoryAxis.majorUnit : buildNiceStep(minX, maxX, 5);
-  const yStep = typeof _optionalChain([chart, 'access', _357 => _357.valueAxis, 'optionalAccess', _358 => _358.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : buildNiceStep(minY, maxY, 5);
+  const xStep = typeof _optionalChain([chart, 'access', _353 => _353.categoryAxis, 'optionalAccess', _354 => _354.majorUnit]) === "number" && chart.categoryAxis.majorUnit > 0 ? chart.categoryAxis.majorUnit : buildNiceStep(minX, maxX, 5);
+  const yStep = typeof _optionalChain([chart, 'access', _355 => _355.valueAxis, 'optionalAccess', _356 => _356.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : buildNiceStep(minY, maxY, 5);
   if (!hasExplicitMinX && !hasSyntheticIndexAxis && Number.isFinite(xStep) && xStep > 0) {
     minX = Math.floor(minX / xStep) * xStep;
   }
@@ -3152,8 +3087,8 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
   const safeMaxY = maxY <= minY ? minY + 1 : maxY;
   const xScale = _d3scale.scaleLinear.call(void 0, ).domain([minX, safeMaxX]).range([plot.left, plot.left + plot.width]);
   const yScale = _d3scale.scaleLinear.call(void 0, ).domain([minY, safeMaxY]).range([plot.top + plot.height, plot.top]);
-  const xMajorUnit = typeof _optionalChain([chart, 'access', _359 => _359.categoryAxis, 'optionalAccess', _360 => _360.majorUnit]) === "number" && chart.categoryAxis.majorUnit > 0 ? chart.categoryAxis.majorUnit : hasSyntheticIndexAxis ? 1 : void 0;
-  const yMajorUnit = typeof _optionalChain([chart, 'access', _361 => _361.valueAxis, 'optionalAccess', _362 => _362.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : buildNiceStep(minY, safeMaxY, 6);
+  const xMajorUnit = typeof _optionalChain([chart, 'access', _357 => _357.categoryAxis, 'optionalAccess', _358 => _358.majorUnit]) === "number" && chart.categoryAxis.majorUnit > 0 ? chart.categoryAxis.majorUnit : hasSyntheticIndexAxis ? 1 : void 0;
+  const yMajorUnit = typeof _optionalChain([chart, 'access', _359 => _359.valueAxis, 'optionalAccess', _360 => _360.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : buildNiceStep(minY, safeMaxY, 6);
   const xTicks = buildNumericTickValues(minX, safeMaxX, xMajorUnit);
   const yTicks = buildNumericTickValues(minY, safeMaxY, yMajorUnit);
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
@@ -3219,7 +3154,7 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
         markerSize
       );
       const markerFill = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(series.lineColor, () => ( series.markerColor)), () => ( series.color)), () => ( chartSeriesStrokeColor(chart, seriesIndex)));
-      const shouldDrawLine = styleDrawsLine && _optionalChain([series, 'access', _363 => _363.shapeProperties, 'optionalAccess', _364 => _364.xmlLineHidden]) !== true && seriesPoints.points.length > 1;
+      const shouldDrawLine = styleDrawsLine && _optionalChain([series, 'access', _361 => _361.shapeProperties, 'optionalAccess', _362 => _362.xmlLineHidden]) !== true && seriesPoints.points.length > 1;
       const shouldDrawMarkers = styleShowsMarkers && markerPath.length > 0;
       const lineCurve = smooth || styleUsesSmoothCurve || series.smooth === true ? _d3shape.curveCatmullRom.alpha(0.5) : _d3shape.curveLinear;
       const linePath = shouldDrawLine ? _nullishCoalesce(_d3shape.line.call(void 0, ).x((point) => xScale(point.x)).y((point) => yScale(point.y)).curve(lineCurve)(seriesPoints.points), () => ( "")) : "";
@@ -3258,7 +3193,7 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
             `scatter-point-${seriesIndex}-${pointIndex}`
           );
         }),
-        seriesPoints.points.map((point, pointIndex) => isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _365 => _365.kind]) !== "point" ? renderSelectionPointHandles(
+        seriesPoints.points.map((point, pointIndex) => isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _363 => _363.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
           `scatter-selection-${seriesIndex}-${pointIndex}`,
           [{ x: xScale(point.x), y: yScale(point.y) }]
         ) : null)
@@ -3271,7 +3206,7 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
   const pointsBySeries = chart.series.map((series) => series.values.map((value, index) => {
     const x = safeNumber(series.categories[index]);
     const y = safeNumber(value);
-    const bubble = safeNumber(_optionalChain([series, 'access', _366 => _366.bubbleSizes, 'optionalAccess', _367 => _367[index]]));
+    const bubble = safeNumber(_optionalChain([series, 'access', _364 => _364.bubbleSizes, 'optionalAccess', _365 => _365[index]]));
     return x == null || y == null ? null : { bubble: _nullishCoalesce(bubble, () => ( 1)), index, x, y };
   }).filter((point) => point != null));
   const allX = pointsBySeries.flatMap((points) => points.map((point) => point.x));
@@ -3301,13 +3236,13 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
     chart.categoryAxis,
     minX - xPad,
     safeMaxX + xPad,
-    _optionalChain([chart, 'access', _368 => _368.categoryAxis, 'optionalAccess', _369 => _369.crosses]) === "autoZero"
+    _optionalChain([chart, 'access', _366 => _366.categoryAxis, 'optionalAccess', _367 => _367.crosses]) === "autoZero"
   );
   const yDomain = resolveAxisDomainWithChartOverrides(
     chart.valueAxis,
     minY - yPad,
     safeMaxY + yPad,
-    _optionalChain([chart, 'access', _370 => _370.valueAxis, 'optionalAccess', _371 => _371.crosses]) === "autoZero"
+    _optionalChain([chart, 'access', _368 => _368.valueAxis, 'optionalAccess', _369 => _369.crosses]) === "autoZero"
   );
   const xScale = _d3scale.scaleLinear.call(void 0, ).domain([xDomain.min, xDomain.max]).range([plot.left, plot.left + plot.width]);
   const yScale = _d3scale.scaleLinear.call(void 0, ).domain([yDomain.min, yDomain.max]).range([plot.top + plot.height, plot.top]);
@@ -3317,7 +3252,7 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
   const labelColor = resolveChartAxisTextColor(chart);
   const isBubble3d = chart.bubble3d === true || chart.is3d === true;
   const labelsEnabled = Boolean(
-    _optionalChain([chart, 'access', _372 => _372.dataLabels, 'optionalAccess', _373 => _373.showCategoryName]) || _optionalChain([chart, 'access', _374 => _374.dataLabels, 'optionalAccess', _375 => _375.showSeriesName]) || _optionalChain([chart, 'access', _376 => _376.dataLabels, 'optionalAccess', _377 => _377.showValue]) || _optionalChain([chart, 'access', _378 => _378.dataLabels, 'optionalAccess', _379 => _379.showBubbleSize]) || _optionalChain([chart, 'access', _380 => _380.dataLabels, 'optionalAccess', _381 => _381.showPercent])
+    _optionalChain([chart, 'access', _370 => _370.dataLabels, 'optionalAccess', _371 => _371.showCategoryName]) || _optionalChain([chart, 'access', _372 => _372.dataLabels, 'optionalAccess', _373 => _373.showSeriesName]) || _optionalChain([chart, 'access', _374 => _374.dataLabels, 'optionalAccess', _375 => _375.showValue]) || _optionalChain([chart, 'access', _376 => _376.dataLabels, 'optionalAccess', _377 => _377.showBubbleSize]) || _optionalChain([chart, 'access', _378 => _378.dataLabels, 'optionalAccess', _379 => _379.showPercent])
   );
   const bubbleTotals = pointsBySeries.map((points) => points.reduce((sum, point) => sum + Math.abs(point.bubble), 0));
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
@@ -3353,9 +3288,9 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "line", { stroke: axisColor, strokeWidth: 1.2, x1: plot.left, x2: plot.left, y1: plot.top, y2: plot.top + plot.height }),
     pointsBySeries.map((points, seriesIndex) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
       isBubble3d ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "defs", { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "radialGradient", { id: `bubble3d-grad-${chart.id}-${seriesIndex}`, cx: "35%", cy: "30%", r: "70%", children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "0%", stopColor: lightenColor(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _382 => _382.series, 'access', _383 => _383[seriesIndex], 'optionalAccess', _384 => _384.color]), () => ( _optionalChain([chart, 'access', _385 => _385.series, 'access', _386 => _386[seriesIndex], 'optionalAccess', _387 => _387.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))), 0.42) }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "58%", stopColor: _nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _388 => _388.series, 'access', _389 => _389[seriesIndex], 'optionalAccess', _390 => _390.color]), () => ( _optionalChain([chart, 'access', _391 => _391.series, 'access', _392 => _392[seriesIndex], 'optionalAccess', _393 => _393.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))) }),
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "100%", stopColor: darkenColor(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _394 => _394.series, 'access', _395 => _395[seriesIndex], 'optionalAccess', _396 => _396.color]), () => ( _optionalChain([chart, 'access', _397 => _397.series, 'access', _398 => _398[seriesIndex], 'optionalAccess', _399 => _399.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))), 0.18) })
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "0%", stopColor: lightenColor(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _380 => _380.series, 'access', _381 => _381[seriesIndex], 'optionalAccess', _382 => _382.color]), () => ( _optionalChain([chart, 'access', _383 => _383.series, 'access', _384 => _384[seriesIndex], 'optionalAccess', _385 => _385.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))), 0.42) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "58%", stopColor: _nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _386 => _386.series, 'access', _387 => _387[seriesIndex], 'optionalAccess', _388 => _388.color]), () => ( _optionalChain([chart, 'access', _389 => _389.series, 'access', _390 => _390[seriesIndex], 'optionalAccess', _391 => _391.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "100%", stopColor: darkenColor(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _392 => _392.series, 'access', _393 => _393[seriesIndex], 'optionalAccess', _394 => _394.color]), () => ( _optionalChain([chart, 'access', _395 => _395.series, 'access', _396 => _396[seriesIndex], 'optionalAccess', _397 => _397.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))), 0.18) })
       ] }) }) : null,
       [...points].sort((left, right) => {
         if (left.bubble !== right.bubble) {
@@ -3364,22 +3299,22 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
         return left.index - right.index;
       }).map((point) => {
         const series = chart.series[seriesIndex];
-        const baseColor = _nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _400 => _400.color]), () => ( _optionalChain([series, 'optionalAccess', _401 => _401.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex)));
+        const baseColor = _nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _398 => _398.color]), () => ( _optionalChain([series, 'optionalAccess', _399 => _399.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex)));
         const radius = radiusScale(Math.sqrt(Math.max(0, point.bubble)));
         const pieces = [];
-        if (_optionalChain([chart, 'access', _402 => _402.dataLabels, 'optionalAccess', _403 => _403.showSeriesName]) && _optionalChain([series, 'optionalAccess', _404 => _404.name])) {
+        if (_optionalChain([chart, 'access', _400 => _400.dataLabels, 'optionalAccess', _401 => _401.showSeriesName]) && _optionalChain([series, 'optionalAccess', _402 => _402.name])) {
           pieces.push(series.name);
         }
-        if (_optionalChain([chart, 'access', _405 => _405.dataLabels, 'optionalAccess', _406 => _406.showCategoryName])) {
+        if (_optionalChain([chart, 'access', _403 => _403.dataLabels, 'optionalAccess', _404 => _404.showCategoryName])) {
           pieces.push(formatTickValue(point.x));
         }
-        if (_optionalChain([chart, 'access', _407 => _407.dataLabels, 'optionalAccess', _408 => _408.showValue])) {
+        if (_optionalChain([chart, 'access', _405 => _405.dataLabels, 'optionalAccess', _406 => _406.showValue])) {
           pieces.push(formatTickValue(point.y));
         }
-        if (_optionalChain([chart, 'access', _409 => _409.dataLabels, 'optionalAccess', _410 => _410.showBubbleSize])) {
+        if (_optionalChain([chart, 'access', _407 => _407.dataLabels, 'optionalAccess', _408 => _408.showBubbleSize])) {
           pieces.push(formatTickValue(point.bubble));
         }
-        if (_optionalChain([chart, 'access', _411 => _411.dataLabels, 'optionalAccess', _412 => _412.showPercent])) {
+        if (_optionalChain([chart, 'access', _409 => _409.dataLabels, 'optionalAccess', _410 => _410.showPercent])) {
           pieces.push(`${Math.round(Math.abs(point.bubble) / Math.max(1, _nullishCoalesce(bubbleTotals[seriesIndex], () => ( 1))) * 100)}%`);
         }
         return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
@@ -3396,7 +3331,7 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
               strokeWidth: isBubble3d ? 1.2 : 1
             }
           ),
-          isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, point.index) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _413 => _413.kind]) !== "point" ? renderSelectionRectHandles(
+          isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, point.index) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _411 => _411.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
             `bubble-selection-${seriesIndex}-${point.index}`,
             xScale(point.x) - radius,
             yScale(point.y) - radius,
@@ -3443,22 +3378,22 @@ function renderRadarChart(chart, palette, layout, selectedChartElement) {
   const centerY = plot.top + plot.height * 0.52;
   const radius = Math.max(22, Math.min(plot.width, plot.height) * 0.38);
   const values = chart.series.flatMap((series) => series.values.slice(0, categories.length).map((value) => safeNumber(value)).filter((value) => value != null));
-  const hasExplicitMin = typeof _optionalChain([chart, 'access', _414 => _414.valueAxis, 'optionalAccess', _415 => _415.min]) === "number" && Number.isFinite(chart.valueAxis.min);
-  const hasExplicitMax = typeof _optionalChain([chart, 'access', _416 => _416.valueAxis, 'optionalAccess', _417 => _417.max]) === "number" && Number.isFinite(chart.valueAxis.max);
-  let minValue = hasExplicitMin ? Number(_optionalChain([chart, 'access', _418 => _418.valueAxis, 'optionalAccess', _419 => _419.min])) : Math.min(0, ...values.length ? values : [0]);
-  let maxValue = hasExplicitMax ? Number(_optionalChain([chart, 'access', _420 => _420.valueAxis, 'optionalAccess', _421 => _421.max])) : Math.max(1, ...values.length ? values : [1]);
-  if (_optionalChain([chart, 'access', _422 => _422.valueAxis, 'optionalAccess', _423 => _423.crosses]) === "autoZero") {
+  const hasExplicitMin = typeof _optionalChain([chart, 'access', _412 => _412.valueAxis, 'optionalAccess', _413 => _413.min]) === "number" && Number.isFinite(chart.valueAxis.min);
+  const hasExplicitMax = typeof _optionalChain([chart, 'access', _414 => _414.valueAxis, 'optionalAccess', _415 => _415.max]) === "number" && Number.isFinite(chart.valueAxis.max);
+  let minValue = hasExplicitMin ? Number(_optionalChain([chart, 'access', _416 => _416.valueAxis, 'optionalAccess', _417 => _417.min])) : Math.min(0, ...values.length ? values : [0]);
+  let maxValue = hasExplicitMax ? Number(_optionalChain([chart, 'access', _418 => _418.valueAxis, 'optionalAccess', _419 => _419.max])) : Math.max(1, ...values.length ? values : [1]);
+  if (_optionalChain([chart, 'access', _420 => _420.valueAxis, 'optionalAccess', _421 => _421.crosses]) === "autoZero") {
     minValue = Math.min(0, minValue);
   }
   const safeMax = maxValue <= minValue ? minValue + 1 : maxValue;
   const span = Math.max(1e-6, safeMax - minValue);
-  const candidateMajorUnit = typeof _optionalChain([chart, 'access', _424 => _424.valueAxis, 'optionalAccess', _425 => _425.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : void 0;
+  const candidateMajorUnit = typeof _optionalChain([chart, 'access', _422 => _422.valueAxis, 'optionalAccess', _423 => _423.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : void 0;
   const preferredMajorUnit = candidateMajorUnit && span / candidateMajorUnit >= 3 ? candidateMajorUnit : buildNiceStep(minValue, safeMax, 6);
   const ticks = buildNumericTickValues(minValue, safeMax, preferredMajorUnit);
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const labelColor = resolveChartAxisTextColor(chart);
   const filled = chart.radarStyle === "filled";
-  const showSpokes = _optionalChain([chart, 'access', _426 => _426.categoryAxis, 'optionalAccess', _427 => _427.majorGridlines]) === true;
+  const showSpokes = _optionalChain([chart, 'access', _424 => _424.categoryAxis, 'optionalAccess', _425 => _425.majorGridlines]) === true;
   const angleAt = (index) => Math.PI * 2 * index / categories.length - Math.PI / 2;
   const radialPoint = (index, valueRatio) => {
     const angle = angleAt(index);
@@ -3560,7 +3495,7 @@ function renderRadarChart(chart, palette, layout, selectedChartElement) {
           },
           `radar-point-${seriesIndex}-${point.pointIndex}`
         )) : null,
-        definedPoints.map((point) => isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, point.pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _428 => _428.kind]) !== "point" ? renderSelectionPointHandles(
+        definedPoints.map((point) => isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, point.pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _426 => _426.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
           `radar-selection-${seriesIndex}-${point.pointIndex}`,
           [{ x: point.x, y: point.y }]
         ) : null)
@@ -3585,14 +3520,14 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
   const arcs = _d3shape.pie.call(void 0, ).value((entry) => entry.value).sort(null).startAngle(startAngle).endAngle(startAngle + Math.PI * 2)(pieData);
   const arcPath = _d3shape.arc.call(void 0, ).innerRadius(innerRadius).outerRadius(outerRadius);
   const isPie3d = chartType === "Pie3D" || chartType === "PieExploded" && chart.is3d === true;
-  const rotX = _nullishCoalesce(_optionalChain([chart, 'access', _429 => _429.view3d, 'optionalAccess', _430 => _430.rotX]), () => ( 20));
-  const perspective = _nullishCoalesce(_optionalChain([chart, 'access', _431 => _431.view3d, 'optionalAccess', _432 => _432.perspective]), () => ( 30));
+  const rotX = _nullishCoalesce(_optionalChain([chart, 'access', _427 => _427.view3d, 'optionalAccess', _428 => _428.rotX]), () => ( 20));
+  const perspective = _nullishCoalesce(_optionalChain([chart, 'access', _429 => _429.view3d, 'optionalAccess', _430 => _430.perspective]), () => ( 30));
   const tiltFromRotX = clamp(0.14 + rotX / 90 * 0.72, 0.12, 0.92);
   const perspectiveCompression = clamp(1 - perspective / 180, 0.55, 1);
   const tilt = isPie3d ? clamp(tiltFromRotX * perspectiveCompression, 0.14, 0.78) : 1;
-  const depthScale = (_nullishCoalesce(_optionalChain([chart, 'access', _433 => _433.view3d, 'optionalAccess', _434 => _434.depthPercent]), () => ( 100))) / 100;
+  const depthScale = (_nullishCoalesce(_optionalChain([chart, 'access', _431 => _431.view3d, 'optionalAccess', _432 => _432.depthPercent]), () => ( 100))) / 100;
   const depth = isPie3d ? Math.max(9, outerRadius * 0.28 * depthScale) : 0;
-  const dataLabelsEnabled = Boolean(_optionalChain([chart, 'access', _435 => _435.dataLabels, 'optionalAccess', _436 => _436.showCategoryName]) || _optionalChain([chart, 'access', _437 => _437.dataLabels, 'optionalAccess', _438 => _438.showPercent]) || _optionalChain([chart, 'access', _439 => _439.dataLabels, 'optionalAccess', _440 => _440.showValue]));
+  const dataLabelsEnabled = Boolean(_optionalChain([chart, 'access', _433 => _433.dataLabels, 'optionalAccess', _434 => _434.showCategoryName]) || _optionalChain([chart, 'access', _435 => _435.dataLabels, 'optionalAccess', _436 => _436.showPercent]) || _optionalChain([chart, 'access', _437 => _437.dataLabels, 'optionalAccess', _438 => _438.showValue]));
   const total = pieData.reduce((sum, entry) => sum + entry.value, 0);
   const shadowId = `pie3d-shadow-${chart.id}`.replace(/[^A-Za-z0-9_-]/g, "-");
   const baseShadowId = `pie3d-base-shadow-${chart.id}`.replace(/[^A-Za-z0-9_-]/g, "-");
@@ -3603,8 +3538,8 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
     right: layout.width - 6,
     top: layout.plot.top + 8
   };
-  const pointLabelByIndex = new Map((_nullishCoalesce(_optionalChain([chart, 'access', _441 => _441.dataLabels, 'optionalAccess', _442 => _442.pointLabels]), () => ( []))).map((label) => [label.index, label]));
-  const centerValuePointLabel = chartType === "Doughnut" ? _nullishCoalesce((_nullishCoalesce(_optionalChain([chart, 'access', _443 => _443.dataLabels, 'optionalAccess', _444 => _444.pointLabels]), () => ( []))).find((label) => label.deleted !== true && label.showValue === true && label.showCategoryName !== true && label.showPercent !== true && label.showSeriesName !== true && label.showBubbleSize !== true), () => ( null)) : null;
+  const pointLabelByIndex = new Map((_nullishCoalesce(_optionalChain([chart, 'access', _439 => _439.dataLabels, 'optionalAccess', _440 => _440.pointLabels]), () => ( []))).map((label) => [label.index, label]));
+  const centerValuePointLabel = chartType === "Doughnut" ? _nullishCoalesce((_nullishCoalesce(_optionalChain([chart, 'access', _441 => _441.dataLabels, 'optionalAccess', _442 => _442.pointLabels]), () => ( []))).find((label) => label.deleted !== true && label.showValue === true && label.showCategoryName !== true && label.showPercent !== true && label.showSeriesName !== true && label.showBubbleSize !== true), () => ( null)) : null;
   const centerValueEntry = centerValuePointLabel ? _nullishCoalesce(pieData.find((entry) => entry.index === centerValuePointLabel.index), () => ( null)) : null;
   const shouldRenderCenterValue = chartType === "Doughnut" && centerValueEntry != null;
   const centerValueLooksPercent = centerValueEntry != null && total > 0 && total <= 1.0000001 && centerValueEntry.value >= 0 && centerValueEntry.value <= 1.0000001;
@@ -3613,13 +3548,13 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
     14,
     Math.min(
       Math.max(20, innerRadius * 0.72),
-      (_nullishCoalesce(_optionalChain([centerValuePointLabel, 'optionalAccess', _445 => _445.fontSizePt]), () => ( 28))) * 0.85
+      (_nullishCoalesce(_optionalChain([centerValuePointLabel, 'optionalAccess', _443 => _443.fontSizePt]), () => ( 28))) * 0.85
     )
   ) : 0;
   const resolveSliceExplosion = (pointIndex) => {
-    const pointStyle = _optionalChain([pieSeries, 'optionalAccess', _446 => _446.dataPointStyles, 'optionalAccess', _447 => _447.find, 'call', _448 => _448((entry) => entry.index === pointIndex)]);
-    const seriesExplosion = typeof _optionalChain([pieSeries, 'optionalAccess', _449 => _449.shapeProperties, 'optionalAccess', _450 => _450.xmlExplosion]) === "number" ? pieSeries.shapeProperties.xmlExplosion : 0;
-    const rawExplosion = Math.max(0, _nullishCoalesce(_nullishCoalesce(_optionalChain([pointStyle, 'optionalAccess', _451 => _451.explosion]), () => ( seriesExplosion)), () => ( 0)));
+    const pointStyle = _optionalChain([pieSeries, 'optionalAccess', _444 => _444.dataPointStyles, 'optionalAccess', _445 => _445.find, 'call', _446 => _446((entry) => entry.index === pointIndex)]);
+    const seriesExplosion = typeof _optionalChain([pieSeries, 'optionalAccess', _447 => _447.shapeProperties, 'optionalAccess', _448 => _448.xmlExplosion]) === "number" ? pieSeries.shapeProperties.xmlExplosion : 0;
+    const rawExplosion = Math.max(0, _nullishCoalesce(_nullishCoalesce(_optionalChain([pointStyle, 'optionalAccess', _449 => _449.explosion]), () => ( seriesExplosion)), () => ( 0)));
     if (rawExplosion <= 0) {
       return 0;
     }
@@ -3720,7 +3655,7 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
       const midAngle = (arc.startAngle + arc.endAngle) / 2;
       const explodeX = Math.sin(midAngle) * explosion;
       const explodeY = -Math.cos(midAngle) * explosion * (isPie3d ? tilt : 1);
-      const isSliceSelected = isSelectedChartPoint(selectedChartElement, chart.id, pieSeriesIndex, arc.data.index) || isSelectedChartSeries(selectedChartElement, chart.id, pieSeriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _452 => _452.kind]) !== "point";
+      const isSliceSelected = isSelectedChartPoint(selectedChartElement, chart.id, pieSeriesIndex, arc.data.index) || isSelectedChartSeries(selectedChartElement, chart.id, pieSeriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _450 => _450.kind]) !== "point";
       const sliceHandlePoints = isSliceSelected ? [
         pieEllipsePoint(centerX, centerY, outerRadius, isPie3d ? tilt : 1, arc.startAngle),
         pieEllipsePoint(centerX, centerY, outerRadius, isPie3d ? tilt : 1, midAngle),
@@ -3734,12 +3669,12 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
       const labelX = centerX + Math.sin(midAngle) * labelRadius + explodeX;
       const labelY = centerY - Math.cos(midAngle) * labelRadius * (isPie3d ? tilt : 1) + explodeY;
       const pieces = [];
-      if (_optionalChain([chart, 'access', _453 => _453.dataLabels, 'optionalAccess', _454 => _454.showCategoryName]) && arc.data.label.trim().length > 0) {
+      if (_optionalChain([chart, 'access', _451 => _451.dataLabels, 'optionalAccess', _452 => _452.showCategoryName]) && arc.data.label.trim().length > 0) {
         pieces.push(arc.data.label);
       }
       const pointLabel = pointLabelByIndex.get(arc.data.index);
-      const showValue = _nullishCoalesce(_optionalChain([pointLabel, 'optionalAccess', _455 => _455.showValue]), () => ( _optionalChain([chart, 'access', _456 => _456.dataLabels, 'optionalAccess', _457 => _457.showValue])));
-      const showPercent = _nullishCoalesce(_optionalChain([pointLabel, 'optionalAccess', _458 => _458.showPercent]), () => ( _optionalChain([chart, 'access', _459 => _459.dataLabels, 'optionalAccess', _460 => _460.showPercent])));
+      const showValue = _nullishCoalesce(_optionalChain([pointLabel, 'optionalAccess', _453 => _453.showValue]), () => ( _optionalChain([chart, 'access', _454 => _454.dataLabels, 'optionalAccess', _455 => _455.showValue])));
+      const showPercent = _nullishCoalesce(_optionalChain([pointLabel, 'optionalAccess', _456 => _456.showPercent]), () => ( _optionalChain([chart, 'access', _457 => _457.dataLabels, 'optionalAccess', _458 => _458.showPercent])));
       if (showValue) {
         pieces.push(formatTickValue(arc.data.value));
       }
@@ -3772,7 +3707,7 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
             transform: `translate(${centerX}, ${centerY})${isPie3d ? ` scale(1, ${tilt})` : ""}`
           }
         ) }),
-        isSliceSelected ? renderSelectionPointHandles(`pie-selection-${arc.data.index}`, sliceHandlePoints) : null,
+        isSliceSelected ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, `pie-selection-${arc.data.index}`, sliceHandlePoints) : null,
         dataLabelsEnabled && truncatedLabelText.length > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "text",
           {
@@ -3804,7 +3739,7 @@ function renderBarOfPieChart(chart, palette, layout, selectedChartElement) {
   const pieSeriesIndex = selectPrimaryPieSeriesIndex(chart);
   const pieSeries = chart.series[pieSeriesIndex];
   const categories = getCategoryLabels(chart);
-  const values = _nullishCoalesce(_optionalChain([pieSeries, 'optionalAccess', _461 => _461.values, 'access', _462 => _462.map, 'call', _463 => _463((value) => Math.max(0, _nullishCoalesce(safeNumber(value), () => ( 0))))]), () => ( []));
+  const values = _nullishCoalesce(_optionalChain([pieSeries, 'optionalAccess', _459 => _459.values, 'access', _460 => _460.map, 'call', _461 => _461((value) => Math.max(0, _nullishCoalesce(safeNumber(value), () => ( 0))))]), () => ( []));
   if (values.length === 0) {
     return null;
   }
@@ -3868,7 +3803,7 @@ function renderBarOfPieChart(chart, palette, layout, selectedChartElement) {
             transform: `translate(${pieCenterX}, ${pieCenterY})`
           }
         ),
-        selected ? renderSelectionPointHandles(`bar-of-pie-main-selection-${index}`, [dot]) : null
+        selected ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, `bar-of-pie-main-selection-${index}`, [dot]) : null
       ] }, `bar-of-pie-main-${index}`);
     }),
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -3909,7 +3844,7 @@ function renderBarOfPieChart(chart, palette, layout, selectedChartElement) {
             transform: `translate(${secondaryCenterX}, ${secondaryCenterY})`
           }
         ),
-        selected ? renderSelectionPointHandles(`bar-of-pie-secondary-pie-selection-${index}`, [dot]) : null
+        selected ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, `bar-of-pie-secondary-pie-selection-${index}`, [dot]) : null
       ] }, `bar-of-pie-secondary-pie-${index}`);
     }) : secondaryData.map((entry, index) => {
       const segmentHeight = index === secondaryData.length - 1 ? Math.max(1, stackedBarTop + stackedBarHeight - stackCursor) : Math.max(1, entry.value / secondaryTotalSafe * stackedBarHeight);
@@ -3930,7 +3865,7 @@ function renderBarOfPieChart(chart, palette, layout, selectedChartElement) {
             y
           }
         ),
-        selected ? renderSelectionRectHandles(
+        selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
           `bar-of-pie-secondary-bar-selection-${index}`,
           stackedBarLeft,
           y,
@@ -3969,24 +3904,24 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
     return null;
   }
   const isContour = isContourSurfaceChart(chart);
-  const ratios = _chunkO3V2MCOCcjs.surfaceDataRatios.call(void 0, rows, cols, _optionalChain([chart, 'access', _464 => _464.valueAxis, 'optionalAccess', _465 => _465.crossBetween]) !== "midCat", _optionalChain([chart, 'access', _466 => _466.view3d, 'optionalAccess', _467 => _467.heightPercent]), _optionalChain([chart, 'access', _468 => _468.view3d, 'optionalAccess', _469 => _469.depthPercent]), layout);
+  const ratios = _chunkO3V2MCOCcjs.surfaceDataRatios.call(void 0, rows, cols, _optionalChain([chart, 'access', _462 => _462.valueAxis, 'optionalAccess', _463 => _463.crossBetween]) !== "midCat", _optionalChain([chart, 'access', _464 => _464.view3d, 'optionalAccess', _465 => _465.heightPercent]), _optionalChain([chart, 'access', _466 => _466.view3d, 'optionalAccess', _467 => _467.depthPercent]), layout);
   const minValue = domain.minValue;
   const safeMax = domain.safeMax;
-  const wallFill = _nullishCoalesce(_optionalChain([chart, 'access', _470 => _470.backWall, 'optionalAccess', _471 => _471.fillColor]), () => ( "#d9d9df"));
-  const wallLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _472 => _472.backWall, 'optionalAccess', _473 => _473.lineColor]), () => ( _optionalChain([chart, 'access', _474 => _474.sideWall, 'optionalAccess', _475 => _475.lineColor]))), () => ( _optionalChain([chart, 'access', _476 => _476.floor, 'optionalAccess', _477 => _477.lineColor]))), () => ( (_nullishCoalesce(chart.axisLineColor, () => ( lightenColor(resolveSurfaceBaseColor(chart, palette), 0.4))))));
+  const wallFill = _nullishCoalesce(_optionalChain([chart, 'access', _468 => _468.backWall, 'optionalAccess', _469 => _469.fillColor]), () => ( "#d9d9df"));
+  const wallLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _470 => _470.backWall, 'optionalAccess', _471 => _471.lineColor]), () => ( _optionalChain([chart, 'access', _472 => _472.sideWall, 'optionalAccess', _473 => _473.lineColor]))), () => ( _optionalChain([chart, 'access', _474 => _474.floor, 'optionalAccess', _475 => _475.lineColor]))), () => ( (_nullishCoalesce(chart.axisLineColor, () => ( lightenColor(resolveSurfaceBaseColor(chart, palette), 0.4))))));
   if (isContour) {
     const faces2 = [];
     const lines = [];
-    const backgroundNormal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, { x: 0, y: 1, z: 0 }, _nullishCoalesce(_optionalChain([chart, 'access', _478 => _478.view3d, 'optionalAccess', _479 => _479.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _480 => _480.view3d, 'optionalAccess', _481 => _481.rotY]), () => ( 0)));
+    const backgroundNormal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, { x: 0, y: 1, z: 0 }, _nullishCoalesce(_optionalChain([chart, 'access', _476 => _476.view3d, 'optionalAccess', _477 => _477.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _478 => _478.view3d, 'optionalAccess', _479 => _479.rotY]), () => ( 0)));
     const backgroundFill = chart.surfaceMaterial === "flat" ? wallFill : _chunkO3V2MCOCcjs.shadeSurfaceMatteColor.call(void 0, wallFill, backgroundNormal);
-    const inset = _optionalChain([chart, 'access', _482 => _482.valueAxis, 'optionalAccess', _483 => _483.crossBetween]) !== "midCat" ? plot.width / (2 * cols) : 0;
+    const inset = _optionalChain([chart, 'access', _480 => _480.valueAxis, 'optionalAccess', _481 => _481.crossBetween]) !== "midCat" ? plot.width / (2 * cols) : 0;
     const dataWidth = plot.width - 2 * inset;
     for (let rowIndex = 0; rowIndex < rows - 1; rowIndex += 1) {
       for (let columnIndex = 0; columnIndex < cols - 1; columnIndex += 1) {
-        const p00 = _optionalChain([matrix, 'access', _484 => _484[rowIndex], 'optionalAccess', _485 => _485[columnIndex]]);
-        const p10 = _optionalChain([matrix, 'access', _486 => _486[rowIndex], 'optionalAccess', _487 => _487[columnIndex + 1]]);
-        const p01 = _optionalChain([matrix, 'access', _488 => _488[rowIndex + 1], 'optionalAccess', _489 => _489[columnIndex]]);
-        const p11 = _optionalChain([matrix, 'access', _490 => _490[rowIndex + 1], 'optionalAccess', _491 => _491[columnIndex + 1]]);
+        const p00 = _optionalChain([matrix, 'access', _482 => _482[rowIndex], 'optionalAccess', _483 => _483[columnIndex]]);
+        const p10 = _optionalChain([matrix, 'access', _484 => _484[rowIndex], 'optionalAccess', _485 => _485[columnIndex + 1]]);
+        const p01 = _optionalChain([matrix, 'access', _486 => _486[rowIndex + 1], 'optionalAccess', _487 => _487[columnIndex]]);
+        const p11 = _optionalChain([matrix, 'access', _488 => _488[rowIndex + 1], 'optionalAccess', _489 => _489[columnIndex + 1]]);
         if (p00 == null || p10 == null || p01 == null || p11 == null) {
           continue;
         }
@@ -4006,7 +3941,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
             y: (1 - _chunkO3V2MCOCcjs.normalizeSurfaceValue.call(void 0, point.value, domain.minValue, domain.safeMax, chart.valueAxis)) * ratios.height,
             z: (point.y - plot.top) / plot.height * ratios.depth
           }));
-          const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _492 => _492.view3d, 'optionalAccess', _493 => _493.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _494 => _494.view3d, 'optionalAccess', _495 => _495.rotY]), () => ( 0)));
+          const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _490 => _490.view3d, 'optionalAccess', _491 => _491.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _492 => _492.view3d, 'optionalAccess', _493 => _493.rotY]), () => ( 0)));
           for (let band = 0; band < domain.ticks.length - 1; band += 1) {
             const lower = domain.ticks[band];
             const upper = domain.ticks[band + 1];
@@ -4019,7 +3954,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
             if (!chart.wireframe) {
               faces2.push(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, "polygon", { fill: chart.surfaceMaterial === "flat" ? resolveSurfaceBandColor(chart, palette, domain, midpoint) : _chunkO3V2MCOCcjs.shadeSurfaceMatteColor.call(void 0, resolveSurfaceBandColor(chart, palette, domain, midpoint), normal), points: polygon.map((point) => `${point.x},${point.y}`).join(" ") }, `surface-band-${key}`));
             }
-            const widths = _optionalChain([chart, 'access', _496 => _496.raw, 'optionalAccess', _497 => _497.bandFormatLineWidths]);
+            const widths = _optionalChain([chart, 'access', _494 => _494.raw, 'optionalAccess', _495 => _495.bandFormatLineWidths]);
             for (const group of _chunkO3V2MCOCcjs.groupSurfaceBandEdges.call(void 0, polygon, triangle, band, lower, chart.wireframe === true)) {
               const edgeMidpoint = (domain.ticks[group.band] + domain.ticks[group.band + 1]) / 2;
               lines.push(
@@ -4029,7 +3964,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
                     d: group.edges.map(([from, to]) => `M ${from.x} ${from.y} L ${to.x} ${to.y}`).join(" "),
                     fill: "none",
                     stroke: resolveSurfaceWireframeColor(chart, palette, domain, edgeMidpoint),
-                    strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([widths, 'optionalAccess', _498 => _498[group.band]]), () => ( _optionalChain([chart, 'access', _499 => _499.series, 'access', _500 => _500[0], 'optionalAccess', _501 => _501.lineWidthPx]))), () => ( 1))
+                    strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([widths, 'optionalAccess', _496 => _496[group.band]]), () => ( _optionalChain([chart, 'access', _497 => _497.series, 'access', _498 => _498[0], 'optionalAccess', _499 => _499.lineWidthPx]))), () => ( 1))
                   },
                   `surface-edge-${key}-${group.band}`
                 )
@@ -4043,12 +3978,12 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "rect",
         {
-          fill: _optionalChain([chart, 'access', _502 => _502.raw, 'optionalAccess', _503 => _503.plotAreaNoFill]) === true ? "transparent" : typeof _optionalChain([chart, 'access', _504 => _504.raw, 'optionalAccess', _505 => _505.plotAreaFillColor]) === "string" ? chart.raw.plotAreaFillColor : backgroundFill,
+          fill: _optionalChain([chart, 'access', _500 => _500.raw, 'optionalAccess', _501 => _501.plotAreaNoFill]) === true ? "transparent" : typeof _optionalChain([chart, 'access', _502 => _502.raw, 'optionalAccess', _503 => _503.plotAreaFillColor]) === "string" ? chart.raw.plotAreaFillColor : backgroundFill,
           x: layout.plot.left,
           y: layout.plot.top,
           width: layout.plot.width,
           height: layout.plot.height,
-          stroke: typeof _optionalChain([chart, 'access', _506 => _506.raw, 'optionalAccess', _507 => _507.plotAreaLineColor]) === "string" ? chart.raw.plotAreaLineColor : wallLineColor
+          stroke: typeof _optionalChain([chart, 'access', _504 => _504.raw, 'optionalAccess', _505 => _505.plotAreaLineColor]) === "string" ? chart.raw.plotAreaLineColor : wallLineColor
         }
       ),
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "rect", { fill: "none", height: plot.height, stroke: wallLineColor, width: plot.width, x: plot.left, y: plot.top }),
@@ -4056,11 +3991,11 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
       lines
     ] });
   }
-  const rotX = (_nullishCoalesce(_optionalChain([chart, 'access', _508 => _508.view3d, 'optionalAccess', _509 => _509.rotX]), () => ( 25))) * (Math.PI / 180);
-  const rotY = (_nullishCoalesce(_optionalChain([chart, 'access', _510 => _510.view3d, 'optionalAccess', _511 => _511.rotY]), () => ( 30))) * (Math.PI / 180);
-  const usePerspective = _optionalChain([chart, 'access', _512 => _512.view3d, 'optionalAccess', _513 => _513.rAngAx]) === false;
+  const rotX = (_nullishCoalesce(_optionalChain([chart, 'access', _506 => _506.view3d, 'optionalAccess', _507 => _507.rotX]), () => ( 25))) * (Math.PI / 180);
+  const rotY = (_nullishCoalesce(_optionalChain([chart, 'access', _508 => _508.view3d, 'optionalAccess', _509 => _509.rotY]), () => ( 30))) * (Math.PI / 180);
+  const usePerspective = _optionalChain([chart, 'access', _510 => _510.view3d, 'optionalAccess', _511 => _511.rAngAx]) === false;
   const perspectiveStrength = clamp(
-    (_nullishCoalesce(_optionalChain([chart, 'access', _514 => _514.view3d, 'optionalAccess', _515 => _515.perspective]), () => ( (usePerspective ? 30 : 0)))) / 100,
+    (_nullishCoalesce(_optionalChain([chart, 'access', _512 => _512.view3d, 'optionalAccess', _513 => _513.perspective]), () => ( (usePerspective ? 30 : 0)))) / 100,
     0,
     1
   );
@@ -4075,7 +4010,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
     const normalizedX = cols <= 1 ? 0 : (columnIndex / (cols - 1) - 0.5) * 2;
     const normalizedY = hasValue ? -(_chunkO3V2MCOCcjs.normalizeSurfaceValue.call(void 0, value, minValue, safeMax, chart.valueAxis) - 0.5) * heightExtent : heightExtent / 2;
     const normalizedZ = rows <= 1 ? 0 : (rowIndex / (rows - 1) - 0.5) * 2 * depthScale;
-    if (_optionalChain([chart, 'access', _516 => _516.view3d, 'optionalAccess', _517 => _517.rAngAx]) !== false) {
+    if (_optionalChain([chart, 'access', _514 => _514.view3d, 'optionalAccess', _515 => _515.rAngAx]) !== false) {
       return {
         depth: normalizedZ,
         hasValue,
@@ -4113,7 +4048,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
     return { ...projected, x: centerX + (projected.x - centerRawX) * scale, y: centerY + (projected.y - centerRawY) * scale };
   };
   const wallNodes = [];
-  const backRow = _optionalChain([chart, 'access', _518 => _518.view3d, 'optionalAccess', _519 => _519.rAngAx]) !== false || cosX * cosY >= 0 ? rows - 1 : 0;
+  const backRow = _optionalChain([chart, 'access', _516 => _516.view3d, 'optionalAccess', _517 => _517.rAngAx]) !== false || cosX * cosY >= 0 ? rows - 1 : 0;
   const sideColumn = sinY >= 0 ? 0 : cols - 1;
   const wallPoint = (x, y, value) => ({ x, y, value });
   const addWall = (key, points, color, hidden) => {
@@ -4123,18 +4058,18 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
       y: (1 - _chunkO3V2MCOCcjs.normalizeSurfaceValue.call(void 0, point.value, minValue, safeMax, chart.valueAxis)) * ratios.height,
       z: (1 - point.y / Math.max(1, rows - 1)) * depthScale
     }));
-    const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _520 => _520.view3d, 'optionalAccess', _521 => _521.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _522 => _522.view3d, 'optionalAccess', _523 => _523.rotY]), () => ( 30)), _optionalChain([chart, 'access', _524 => _524.view3d, 'optionalAccess', _525 => _525.rAngAx]) !== false);
+    const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _518 => _518.view3d, 'optionalAccess', _519 => _519.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _520 => _520.view3d, 'optionalAccess', _521 => _521.rotY]), () => ( 30)), _optionalChain([chart, 'access', _522 => _522.view3d, 'optionalAccess', _523 => _523.rAngAx]) !== false);
     const baseColor = _nullishCoalesce(color, () => ( wallFill));
     wallNodes.push(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, "polygon", { fill: chart.surfaceMaterial === "flat" ? baseColor : _chunkO3V2MCOCcjs.shadeSurfaceMatteColor.call(void 0, baseColor, normal), points: points.map(projectPoint).map((point) => `${point.x},${point.y}`).join(" ") }, key));
   };
-  addWall("floor", [wallPoint(0, 0, minValue), wallPoint(cols - 1, 0, minValue), wallPoint(cols - 1, rows - 1, minValue), wallPoint(0, rows - 1, minValue)], _optionalChain([chart, 'access', _526 => _526.floor, 'optionalAccess', _527 => _527.fillColor]), _optionalChain([chart, 'access', _528 => _528.floor, 'optionalAccess', _529 => _529.hidden]));
-  addWall("back", [wallPoint(0, backRow, safeMax), wallPoint(cols - 1, backRow, safeMax), wallPoint(cols - 1, backRow, minValue), wallPoint(0, backRow, minValue)], _optionalChain([chart, 'access', _530 => _530.backWall, 'optionalAccess', _531 => _531.fillColor]), _optionalChain([chart, 'access', _532 => _532.backWall, 'optionalAccess', _533 => _533.hidden]));
-  addWall("side", [wallPoint(sideColumn, 0, safeMax), wallPoint(sideColumn, rows - 1, safeMax), wallPoint(sideColumn, rows - 1, minValue), wallPoint(sideColumn, 0, minValue)], _optionalChain([chart, 'access', _534 => _534.sideWall, 'optionalAccess', _535 => _535.fillColor]), _optionalChain([chart, 'access', _536 => _536.sideWall, 'optionalAccess', _537 => _537.hidden]));
-  if (_optionalChain([chart, 'access', _538 => _538.valueAxis, 'optionalAccess', _539 => _539.majorGridlines])) {
+  addWall("floor", [wallPoint(0, 0, minValue), wallPoint(cols - 1, 0, minValue), wallPoint(cols - 1, rows - 1, minValue), wallPoint(0, rows - 1, minValue)], _optionalChain([chart, 'access', _524 => _524.floor, 'optionalAccess', _525 => _525.fillColor]), _optionalChain([chart, 'access', _526 => _526.floor, 'optionalAccess', _527 => _527.hidden]));
+  addWall("back", [wallPoint(0, backRow, safeMax), wallPoint(cols - 1, backRow, safeMax), wallPoint(cols - 1, backRow, minValue), wallPoint(0, backRow, minValue)], _optionalChain([chart, 'access', _528 => _528.backWall, 'optionalAccess', _529 => _529.fillColor]), _optionalChain([chart, 'access', _530 => _530.backWall, 'optionalAccess', _531 => _531.hidden]));
+  addWall("side", [wallPoint(sideColumn, 0, safeMax), wallPoint(sideColumn, rows - 1, safeMax), wallPoint(sideColumn, rows - 1, minValue), wallPoint(sideColumn, 0, minValue)], _optionalChain([chart, 'access', _532 => _532.sideWall, 'optionalAccess', _533 => _533.fillColor]), _optionalChain([chart, 'access', _534 => _534.sideWall, 'optionalAccess', _535 => _535.hidden]));
+  if (_optionalChain([chart, 'access', _536 => _536.valueAxis, 'optionalAccess', _537 => _537.majorGridlines])) {
     for (const tick of domain.ticks) {
       const edges = [
-        ..._optionalChain([chart, 'access', _540 => _540.backWall, 'optionalAccess', _541 => _541.hidden]) ? [] : [[wallPoint(0, backRow, tick), wallPoint(cols - 1, backRow, tick)]],
-        ..._optionalChain([chart, 'access', _542 => _542.sideWall, 'optionalAccess', _543 => _543.hidden]) ? [] : [[wallPoint(sideColumn, 0, tick), wallPoint(sideColumn, rows - 1, tick)]]
+        ..._optionalChain([chart, 'access', _538 => _538.backWall, 'optionalAccess', _539 => _539.hidden]) ? [] : [[wallPoint(0, backRow, tick), wallPoint(cols - 1, backRow, tick)]],
+        ..._optionalChain([chart, 'access', _540 => _540.sideWall, 'optionalAccess', _541 => _541.hidden]) ? [] : [[wallPoint(sideColumn, 0, tick), wallPoint(sideColumn, rows - 1, tick)]]
       ];
       wallNodes.push(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { fill: "none", stroke: _nullishCoalesce(chart.valueAxis.majorGridlineColor, () => ( wallLineColor)), strokeWidth: 1, d: edges.map((edge) => {
         const [from, to] = edge.map(projectPoint);
@@ -4159,7 +4094,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
           y: (1 - _chunkO3V2MCOCcjs.normalizeSurfaceValue.call(void 0, point.value, minValue, safeMax, chart.valueAxis)) * ratios.height,
           z: (1 - point.y / Math.max(1, rows - 1)) * depthScale
         }));
-        const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _544 => _544.view3d, 'optionalAccess', _545 => _545.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _546 => _546.view3d, 'optionalAccess', _547 => _547.rotY]), () => ( 30)), _optionalChain([chart, 'access', _548 => _548.view3d, 'optionalAccess', _549 => _549.rAngAx]) !== false);
+        const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _542 => _542.view3d, 'optionalAccess', _543 => _543.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _544 => _544.view3d, 'optionalAccess', _545 => _545.rotY]), () => ( 30)), _optionalChain([chart, 'access', _546 => _546.view3d, 'optionalAccess', _547 => _547.rAngAx]) !== false);
         for (let band = 0; band < domain.ticks.length - 1; band += 1) {
           const lower = domain.ticks[band];
           const upper = domain.ticks[band + 1];
@@ -4167,7 +4102,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
           if (polygon.length < 3) continue;
           const projected = polygon.map(projectPoint);
           const midpoint = (lower + upper) / 2;
-          const widths = _optionalChain([chart, 'access', _550 => _550.raw, 'optionalAccess', _551 => _551.bandFormatLineWidths]);
+          const widths = _optionalChain([chart, 'access', _548 => _548.raw, 'optionalAccess', _549 => _549.bandFormatLineWidths]);
           const edgeGroups = _chunkO3V2MCOCcjs.groupSurfaceBandEdges.call(void 0, polygon, triangle, band, lower, chart.wireframe === true);
           faces.push({
             depth: projected.reduce((sum, point) => sum + point.depth, 0) / projected.length,
@@ -4176,7 +4111,7 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
               edgeGroups.map((group) => {
                 const edgeMidpoint = (domain.ticks[group.band] + domain.ticks[group.band + 1]) / 2;
                 const edges = group.edges.map(([from, to]) => [projectPoint(from), projectPoint(to)]);
-                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { fill: "none", stroke: resolveSurfaceWireframeColor(chart, palette, domain, edgeMidpoint), strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([widths, 'optionalAccess', _552 => _552[group.band]]), () => ( _optionalChain([chart, 'access', _553 => _553.series, 'access', _554 => _554[0], 'optionalAccess', _555 => _555.lineWidthPx]))), () => ( 1)), d: edges.map(([from, to]) => `M ${from.x} ${from.y} L ${to.x} ${to.y}`).join(" ") }, `surface-edge-${group.band}`);
+                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { fill: "none", stroke: resolveSurfaceWireframeColor(chart, palette, domain, edgeMidpoint), strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([widths, 'optionalAccess', _550 => _550[group.band]]), () => ( _optionalChain([chart, 'access', _551 => _551.series, 'access', _552 => _552[0], 'optionalAccess', _553 => _553.lineWidthPx]))), () => ( 1)), d: edges.map(([from, to]) => `M ${from.x} ${from.y} L ${to.x} ${to.y}`).join(" ") }, `surface-edge-${group.band}`);
               })
             ] }, `surface-band-${rowIndex}-${columnIndex}-${triangleIndex}-${band}`)
           });
@@ -4220,7 +4155,7 @@ function renderSurfaceHitOverlay(chart, layout, selectedChartElement) {
           y: top
         }
       ),
-      selected ? renderSelectionRectHandles(
+      selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
         `surface-selection-${seriesIndex}-${pointIndex}`,
         left,
         top,
@@ -4258,7 +4193,7 @@ function renderWaterfallChart(chart, palette, layout, selectedChartElement) {
     maxValue = minValue + 1;
   }
   const yScale = _d3scale.scaleLinear.call(void 0, ).domain([minValue, maxValue]).range([plot.top + plot.height, plot.top]);
-  const ticks = buildNumericTickValues(minValue, maxValue, _optionalChain([chart, 'access', _556 => _556.valueAxis, 'optionalAccess', _557 => _557.majorUnit]));
+  const ticks = buildNumericTickValues(minValue, maxValue, _optionalChain([chart, 'access', _554 => _554.valueAxis, 'optionalAccess', _555 => _555.majorUnit]));
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const labelColor = resolveChartAxisTextColor(chart);
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
@@ -4317,7 +4252,7 @@ function renderWaterfallChart(chart, palette, layout, selectedChartElement) {
             height
           }
         ),
-        selected ? renderSelectionRectHandles(`waterfall-selection-${index}`, bandLeft, top, bandWidth, height) : null,
+        selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, `waterfall-selection-${index}`, bandLeft, top, bandWidth, height) : null,
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "text",
           {
@@ -4378,7 +4313,7 @@ function renderFunnelChart(chart, palette, layout, selectedChartElement) {
           y: topY
         }
       ),
-      selected ? renderSelectionRectHandles(`funnel-selection-${index}`, left, topY, stageWidth, stageHeight) : null,
+      selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, `funnel-selection-${index}`, left, topY, stageWidth, stageHeight) : null,
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "text",
         {
@@ -4432,7 +4367,7 @@ function renderSunburstChart(chart, palette, layout, selectedChartElement) {
             strokeWidth: selected ? 2 : 1
           }
         ),
-        selected ? renderSelectionPointHandles(`sunburst-selection-${index}`, [{ x: labelX, y: labelY }]) : null,
+        selected ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, `sunburst-selection-${index}`, [{ x: labelX, y: labelY }]) : null,
         canShowLabel ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "text",
           {
@@ -4477,7 +4412,7 @@ function renderTreemapChart(chart, palette, layout, selectedChartElement) {
           height
         }
       ),
-      selected ? renderSelectionRectHandles(`treemap-selection-${index}`, leaf.x0, leaf.y0, width, height) : null,
+      selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, `treemap-selection-${index}`, leaf.x0, leaf.y0, width, height) : null,
       canShowLabel ? /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "text",
@@ -4664,7 +4599,7 @@ function renderBoxWhiskerChart(chart, palette, layout, selectedChartElement) {
           x: x - boxWidth * 0.5,
           y: boxTop
         }
-      ), selected ? renderSelectionRectHandles(
+      ), selected ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
         `box-whisker-selection-${index}`,
         x - boxWidth * 0.5,
         boxTop,
@@ -4756,10 +4691,10 @@ function renderRegionMapChart(chart, palette, layout, selectedChartElement, { ge
   }
   const labels = getCategoryLabels(chart);
   const layoutProperties = resolveRegionMapLayoutProperties(primarySeries);
-  const geography = _optionalChain([layoutProperties, 'optionalAccess', _558 => _558.geography]) && typeof layoutProperties.geography === "object" ? layoutProperties.geography : null;
+  const geography = _optionalChain([layoutProperties, 'optionalAccess', _556 => _556.geography]) && typeof layoutProperties.geography === "object" ? layoutProperties.geography : null;
   const featureSet = resolveRegionMapFeatureSet(labels, geography);
-  const viewedRegionType = typeof _optionalChain([geography, 'optionalAccess', _559 => _559.viewedRegionType]) === "string" ? geography.viewedRegionType : null;
-  const projectionType = typeof _optionalChain([geography, 'optionalAccess', _560 => _560.projectionType]) === "string" ? geography.projectionType : null;
+  const viewedRegionType = typeof _optionalChain([geography, 'optionalAccess', _557 => _557.viewedRegionType]) === "string" ? geography.viewedRegionType : null;
+  const projectionType = typeof _optionalChain([geography, 'optionalAccess', _558 => _558.projectionType]) === "string" ? geography.projectionType : null;
   const projection = featureSet === "us-state" ? geoIdentity() : projectionType === "miller" ? geoMercator() : geoNaturalEarth1();
   const availableFeatures = getRegionMapBaseFeatures(featureSet);
   const categoricalValues = resolveRegionMapColorStrings(primarySeries);
@@ -4772,7 +4707,7 @@ function renderRegionMapChart(chart, palette, layout, selectedChartElement, { ge
   const entries = labels.map((label, index) => {
     const feature = resolveRegionMapFeature(label, featureSet);
     const value = safeNumber(primarySeries.values[index]);
-    const colorLabel = _optionalChain([categoricalValues, 'optionalAccess', _561 => _561[index]]) || null;
+    const colorLabel = _optionalChain([categoricalValues, 'optionalAccess', _559 => _559[index]]) || null;
     return {
       colorLabel,
       feature,
@@ -4800,7 +4735,7 @@ function renderRegionMapChart(chart, palette, layout, selectedChartElement, { ge
   const numericEntryValues = primarySeries.values.map(safeNumber).filter((value) => typeof value === "number" && Number.isFinite(value));
   const minValue = numericEntryValues.length > 0 ? Math.min(...numericEntryValues) : 0;
   const maxValue = numericEntryValues.length > 0 ? Math.max(...numericEntryValues) : 1;
-  const showRegionLabels = _optionalChain([layoutProperties, 'optionalAccess', _562 => _562.regionLabelLayout]) !== "none";
+  const showRegionLabels = _optionalChain([layoutProperties, 'optionalAccess', _560 => _560.regionLabelLayout]) !== "none";
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
     baseFeatures.map((feature, index) => {
       const d = path(feature);
@@ -4827,7 +4762,7 @@ function renderRegionMapChart(chart, palette, layout, selectedChartElement, { ge
       const fill = entry.value != null ? (() => {
         const ratio = maxValue <= minValue ? 1 : (entry.value - minValue) / Math.max(1e-6, maxValue - minValue);
         return resolveRegionMapValueColor(chart, primarySeriesIndex, ratio);
-      })() : _nullishCoalesce(_optionalChain([categoricalColorByLabel, 'optionalAccess', _563 => _563.get, 'call', _564 => _564(_nullishCoalesce(entry.colorLabel, () => ( "")))]), () => ( resolveRegionMapDataColor(chart, primarySeriesIndex)));
+      })() : _nullishCoalesce(_optionalChain([categoricalColorByLabel, 'optionalAccess', _561 => _561.get, 'call', _562 => _562(_nullishCoalesce(entry.colorLabel, () => ( "")))]), () => ( resolveRegionMapDataColor(chart, primarySeriesIndex)));
       const selected = isSelectedChartPointOrSeries(selectedChartElement, chart.id, primarySeriesIndex, index);
       const centroid = path.centroid(entry.feature);
       const canShowSelectionDot = Number.isFinite(centroid[0]) && Number.isFinite(centroid[1]);
@@ -4843,7 +4778,7 @@ function renderRegionMapChart(chart, palette, layout, selectedChartElement, { ge
             strokeWidth: selected ? 1.8 : 0.85
           }
         ),
-        selected && canShowSelectionDot ? renderSelectionPointHandles(`region-map-selection-${index}`, [{ x: centroid[0], y: centroid[1] }]) : null
+        selected && canShowSelectionDot ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, `region-map-selection-${index}`, [{ x: centroid[0], y: centroid[1] }]) : null
       ] }, `region-map-value-${entry.key || index}`);
     }),
     showRegionLabels ? entries.map((entry, index) => {
@@ -4970,33 +4905,19 @@ var MemoChartSvg = React.memo(function MemoChartSvg2({
   const legendItems = getLegendItems(chart, renderChartType, palette);
   const layout = buildLayout(chart, rect, legendItems);
   const chartRaw = chart.raw && typeof chart.raw === "object" ? chart.raw : null;
-  const explicitNoFill = _optionalChain([chartRaw, 'optionalAccess', _565 => _565.chartAreaNoFill]) === true || _optionalChain([chartRaw, 'optionalAccess', _566 => _566.plotAreaNoFill]) === true;
+  const explicitNoFill = _optionalChain([chartRaw, 'optionalAccess', _563 => _563.chartAreaNoFill]) === true || _optionalChain([chartRaw, 'optionalAccess', _564 => _564.plotAreaNoFill]) === true;
   const background = _nullishCoalesce(chart.chartAreaFillColor, () => ( (explicitNoFill ? "transparent" : "#ffffff")));
   const borderColor = _nullishCoalesce(chart.chartAreaBorderColor, () => ( "transparent"));
   const normalizedBackground = background.trim().toLowerCase();
   const normalizedBorderColor = borderColor.trim().toLowerCase();
   const hideBackgroundRect = normalizedBackground === "transparent" && normalizedBorderColor === "transparent";
   const fontFamily = buildChartFontFamily(chart.fontFamily);
-  const handlePointerDown = React.useCallback((event) => {
-    const selection = resolveChartSelectionFromTarget(chart, event.target, selectedChartElement);
-    if (!selection) {
-      return;
-    }
-    if (resolveChartElementTarget(event.target)) {
-      event.stopPropagation();
-    }
-    _optionalChain([onChartElementPointerDown, 'optionalCall', _567 => _567(selection, event)]);
-  }, [chart, onChartElementPointerDown, selectedChartElement]);
-  const handleDoubleClick = React.useCallback((event) => {
-    const selection = resolveChartSelectionFromTarget(chart, event.target, selectedChartElement);
-    if (!selection) {
-      return;
-    }
-    if (resolveChartElementTarget(event.target)) {
-      event.stopPropagation();
-    }
-    _optionalChain([onChartElementDoubleClick, 'optionalCall', _568 => _568(selection, event)]);
-  }, [chart, onChartElementDoubleClick, selectedChartElement]);
+  const { handlePointerDown, handleDoubleClick } = _chunkIDNIGBUMcjs.useChartEvents.call(void 0, {
+    chart,
+    onChartElementPointerDown,
+    onChartElementDoubleClick,
+    selectedChartElement
+  });
   const renderSvgChart = (plot) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
     "svg",
     {
@@ -5043,4 +4964,4 @@ var MemoChartSvg = React.memo(function MemoChartSvg2({
 
 
 exports.MemoChartSvg = MemoChartSvg;
-//# sourceMappingURL=chart-renderer-K6GORT3R.cjs.map
+//# sourceMappingURL=chart-renderer-2EKXNHUD.cjs.map