@extend-ai/react-xlsx 0.20.2 → 0.20.4

package/dist/{chart-renderer-LGW4EH4M.cjs → chart-renderer-6CWSXOSC.cjs}

@@ -2,33 +2,61 @@
 
 
 
-var _chunkD2UA4P6Ncjs = require('./chunk-D2UA4P6N.cjs');
 
 
 
 
-var _chunkIDNIGBUMcjs = require('./chunk-IDNIGBUM.cjs');
-
 
+var _chunkO3V2MCOCcjs = require('./chunk-O3V2MCOC.cjs');
 
 
 
+var _chunkNAYVSTCXcjs = require('./chunk-NAYVSTCX.cjs');
 
 
 
 
-var _chunkO3V2MCOCcjs = require('./chunk-O3V2MCOC.cjs');
+var _chunk5ERNVHSOcjs = require('./chunk-5ERNVHSO.cjs');
 
 
 
 
-var _chunk5ERNVHSOcjs = require('./chunk-5ERNVHSO.cjs');
+var _chunkIDNIGBUMcjs = require('./chunk-IDNIGBUM.cjs');
 require('./chunk-AD4CGQN2.cjs');
 
 // src/chart-renderer.tsx
 var _d3hierarchy = require('d3-hierarchy');
 var _react = require('react'); var React = _interopRequireWildcard(_react);
-var _d3scale = require('d3-scale');
+
+// src/chart-scales.ts
+function linearScale([low, high], [start, end]) {
+  if (high < low) return linearScale([high, low], [end, start]);
+  const span = high - low;
+  return (value) => {
+    const t = span === 0 ? 0.5 : (value - low) / span;
+    return start * (1 - t) + end * t;
+  };
+}
+function bandScale(domain, [from, to], inner, outer) {
+  const indices = /* @__PURE__ */ new Map();
+  for (const value of domain) {
+    if (!indices.has(value)) indices.set(value, indices.size);
+  }
+  const count = indices.size;
+  const width = Math.abs(to - from);
+  const step = width / Math.max(1, count - inner + 2 * outer);
+  const origin = Math.min(from, to) + (width - step * (count - inner)) / 2;
+  const locate = (value) => {
+    const index = indices.get(value);
+    return index == null ? void 0 : origin + step * (to < from ? count - 1 - index : index);
+  };
+  return Object.assign(locate, { bandwidth: step * (1 - inner) });
+}
+function pointScale(domain, range) {
+  return bandScale(domain, range, 1, 0);
+}
+
+// src/chart-renderer.tsx
 
 
 
@@ -40,15 +68,11 @@ var _d3scale = require('d3-scale');
 var _d3shape = require('d3-shape');
 var _jsxruntime = require('react/jsx-runtime');
 
-function RegionMapPlot({ chart, palette, layout, selectedChartElement }) {
-  const resources = _chunkD2UA4P6Ncjs.useChartModule.call(void 0, _chunkD2UA4P6Ncjs.regionMapResources);
-  return resources ? renderRegionMapChart(chart, palette, layout, selectedChartElement, resources) : null;
-}
 function SurfaceChartComposite({
   loadingFallback,
   ...props
 }) {
-  const renderer = _chunkD2UA4P6Ncjs.useChartModule.call(void 0, _chunkD2UA4P6Ncjs.surfaceRenderer);
+  const renderer = _chunkNAYVSTCXcjs.useChartModule.call(void 0, _chunkNAYVSTCXcjs.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) {
@@ -222,9 +246,6 @@ function isHistogramLikeSeries(series) {
 function isHistogramLikeChart(chart) {
   return chart.series.some((series) => isHistogramLikeSeries(series));
 }
-function resolveRegionMapBaseColor(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));
   if (pointColor) {
@@ -240,22 +261,18 @@ function resolveRegionMapDataColor(chart, seriesIndex) {
       return paletteColor;
     }
   }
-  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"));
+  return _nullishCoalesce(normalizeRendererHexColor(_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])))), () => ( "#4f81bd"));
 }
 function resolveRegionMapValueColors(series) {
-  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)) : [];
+  const raw = _optionalChain([series, 'optionalAccess', _39 => _39.raw]) && typeof series.raw === "object" ? series.raw : null;
+  const colors = Array.isArray(_optionalChain([raw, 'optionalAccess', _40 => _40.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', _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() : "") : [];
+  const raw = _optionalChain([series, 'optionalAccess', _41 => _41.raw]) && typeof series.raw === "object" ? series.raw : null;
+  const values = Array.isArray(_optionalChain([raw, 'optionalAccess', _42 => _42.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', _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) {
     return "#4f81bd";
@@ -282,10 +299,6 @@ function resolveRegionMapValueColor(chart, seriesIndex, ratio) {
     darkenColor(baseColor, 0.08)
   ], ratio);
 }
-function resolveRegionMapNoDataColor(chart, seriesIndex) {
-  const baseColor = resolveRegionMapBaseColor(chart, seriesIndex);
-  return _nullishCoalesce(normalizeRendererHexColor(baseColor), () => ( chartSeriesColor(chart, seriesIndex)));
-}
 function buildRegionMapLegendItems(chart) {
   const primarySeriesIndex = Math.max(0, chart.series.findIndex((series) => series.hidden !== true));
   const categoricalValues = resolveRegionMapColorStrings(_nullishCoalesce(chart.series[primarySeriesIndex], () => ( null)));
@@ -296,7 +309,7 @@ function buildRegionMapLegendItems(chart) {
       label: value
     }));
   }
-  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);
+  const values = (_nullishCoalesce(_optionalChain([chart, 'access', _43 => _43.series, 'access', _44 => _44[primarySeriesIndex], 'optionalAccess', _45 => _45.values]), () => ( []))).map((value) => safeNumber(value)).filter((value) => value != null);
   if (values.length === 0) {
     return [];
   }
@@ -314,12 +327,12 @@ function normalizeBuiltinPieStyleId(styleId) {
   return styleId >= 100 ? styleId - 100 : styleId;
 }
 function getBuiltinPiePalette(chart, seriesIndex) {
-  if (_optionalChain([chart, 'access', _56 => _56.raw, 'optionalAccess', _57 => _57.builtinThemeColors])) return null;
+  if (_optionalChain([chart, 'access', _46 => _46.raw, 'optionalAccess', _47 => _47.builtinThemeColors])) return null;
   const normalized = normalizeBuiltinPieStyleId(chart.chartStyleId);
   if (normalized !== 32) {
     return 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));
+  const baseColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _48 => _48.series, 'access', _49 => _49[seriesIndex], 'optionalAccess', _50 => _50.color]), () => ( _optionalChain([chart, 'access', _51 => _51.series, 'access', _52 => _52[seriesIndex], 'optionalAccess', _53 => _53.lineColor]))), () => ( _optionalChain([chart, 'access', _54 => _54.chartColorPalette, 'optionalAccess', _55 => _55[0]]))), () => ( null));
   if (!baseColor) {
     return null;
   }
@@ -333,8 +346,8 @@ function getBuiltinPiePalette(chart, seriesIndex) {
   ];
 }
 function resolvePiePointColor(chart, pointIndex, seriesIndex = 0) {
-  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])) {
+  const pointStyle = _optionalChain([chart, 'access', _56 => _56.series, 'access', _57 => _57[seriesIndex], 'optionalAccess', _58 => _58.dataPointStyles, 'optionalAccess', _59 => _59.find, 'call', _60 => _60((entry) => entry.index === pointIndex)]);
+  if (_optionalChain([pointStyle, 'optionalAccess', _61 => _61.color])) {
     return pointStyle.color;
   }
   const builtinPalette = getBuiltinPiePalette(chart, seriesIndex);
@@ -368,8 +381,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', _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 defaultStrokeWidth = typeof _optionalChain([series, 'optionalAccess', _62 => _62.lineWidthPx]) === "number" && Number.isFinite(series.lineWidthPx) ? Math.max(0.8, Math.min(4, series.lineWidthPx)) : 1;
+  if (value < 0 && _optionalChain([series, 'optionalAccess', _63 => _63.invertIfNegative])) {
     const resolvedNegativeFill = negativeFillMode === "none" ? "none" : _nullishCoalesce(_nullishCoalesce(series.negativeColor, () => ( (negativeFillMode === "chartArea" ? chart.chartAreaFillColor : void 0))), () => ( defaultFill));
     return {
       fill: resolvedNegativeFill,
@@ -459,13 +472,13 @@ function estimateReferencePointCount(formula) {
   return Math.abs(endRow - startRow) + 1;
 }
 function getCategoryLabels(chart) {
-  const primaryCategories = _nullishCoalesce(_optionalChain([chart, 'access', _74 => _74.series, 'access', _75 => _75[0], 'optionalAccess', _76 => _76.categories]), () => ( []));
+  const primaryCategories = _nullishCoalesce(_optionalChain([chart, 'access', _64 => _64.series, 'access', _65 => _65[0], 'optionalAccess', _66 => _66.categories]), () => ( []));
   const includeReferenceCategoryCount = chart.plotVisibleOnly !== true;
   const referenceCategoryCount = includeReferenceCategoryCount ? Math.max(
     0,
     ...chart.series.map((series) => Math.max(
-      estimateReferencePointCount(_optionalChain([series, 'access', _77 => _77.categoriesRef, 'optionalAccess', _78 => _78.formula])),
-      estimateReferencePointCount(_optionalChain([series, 'access', _79 => _79.valuesRef, 'optionalAccess', _80 => _80.formula]))
+      estimateReferencePointCount(_optionalChain([series, 'access', _67 => _67.categoriesRef, 'optionalAccess', _68 => _68.formula])),
+      estimateReferencePointCount(_optionalChain([series, 'access', _69 => _69.valuesRef, 'optionalAccess', _70 => _70.formula]))
     ))
   ) : 0;
   const categoryCount = Math.max(
@@ -589,7 +602,7 @@ function coerceLooseNumber(value) {
 }
 function buildPieEntries(chart, seriesIndex = selectPrimaryPieSeriesIndex(chart)) {
   const categories = getCategoryLabels(chart);
-  const values = _nullishCoalesce(_optionalChain([chart, 'access', _81 => _81.series, 'access', _82 => _82[seriesIndex], 'optionalAccess', _83 => _83.values]), () => ( []));
+  const values = _nullishCoalesce(_optionalChain([chart, 'access', _71 => _71.series, 'access', _72 => _72[seriesIndex], 'optionalAccess', _73 => _73.values]), () => ( []));
   return values.map((rawValue, index) => ({
     color: resolvePiePointColor(chart, index, seriesIndex),
     index,
@@ -599,9 +612,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', _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;
+  const layoutProperties = _optionalChain([raw, 'optionalAccess', _74 => _74.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const subtotals = Array.isArray(_optionalChain([layoutProperties, 'optionalAccess', _75 => _75.subtotals])) ? layoutProperties.subtotals : [];
+  return subtotals.length > 0 || _optionalChain([layoutProperties, 'optionalAccess', _76 => _76.aggregation]) === true;
 }
 function buildChartStages(chart) {
   if (chart.chartType === "Funnel" || chart.chartType === "Waterfall") {
@@ -629,7 +642,7 @@ function buildChartStages(chart) {
     if (!Number.isFinite(value)) {
       return null;
     }
-    const formula = typeof _optionalChain([series, 'access', _87 => _87.valuesRef, 'optionalAccess', _88 => _88.formula]) === "string" ? series.valuesRef.formula : "";
+    const formula = typeof _optionalChain([series, 'access', _77 => _77.valuesRef, 'optionalAccess', _78 => _78.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),
@@ -648,7 +661,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', _89 => _89.chartExHierarchyCategories]));
+    return Array.isArray(_optionalChain([raw, 'optionalAccess', _79 => _79.chartExHierarchyCategories]));
   }), () => ( null));
   const primaryHierarchyPaths = (() => {
     if (!primaryHierarchySeries) {
@@ -659,7 +672,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', _90 => _90[rowIndex]]), () => ( chart.series.map((series) => normalizeCategoryLabel(_nullishCoalesce(series.categories[rowIndex], () => ( series.values[rowIndex])))).filter((value) => value.length > 0)));
+    const path = _nullishCoalesce(_optionalChain([primaryHierarchyPaths, 'optionalAccess', _80 => _80[rowIndex]]), () => ( chart.series.map((series) => normalizeCategoryLabel(_nullishCoalesce(series.categories[rowIndex], () => ( series.values[rowIndex])))).filter((value) => value.length > 0)));
     if (path.length === 0) {
       continue;
     }
@@ -682,25 +695,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', _91 => _91.values, 'access', _92 => _92[rowIndex]])), () => ( 1)));
+    current.value = (_nullishCoalesce(current.value, () => ( 0))) + Math.max(1e-4, _nullishCoalesce(safeNumber(_optionalChain([valueSource, 'optionalAccess', _81 => _81.values, 'access', _82 => _82[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', _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";
+  const layoutProperties = _optionalChain([raw, 'optionalAccess', _83 => _83.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const statistics = _optionalChain([layoutProperties, 'optionalAccess', _84 => _84.statistics]) && typeof layoutProperties.statistics === "object" ? layoutProperties.statistics : null;
+  return _optionalChain([statistics, 'optionalAccess', _85 => _85.quartileMethod]) === "inclusive" ? "inclusive" : "exclusive";
 }
 function resolveBoxWhiskerVisibility(series) {
   const raw = series.raw && typeof series.raw === "object" ? series.raw : 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;
+  const layoutProperties = _optionalChain([raw, 'optionalAccess', _86 => _86.layoutProperties]) && typeof raw.layoutProperties === "object" ? raw.layoutProperties : null;
+  const visibility = _optionalChain([layoutProperties, 'optionalAccess', _87 => _87.visibility]) && typeof layoutProperties.visibility === "object" ? layoutProperties.visibility : null;
   return {
-    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
+    meanLine: _optionalChain([visibility, 'optionalAccess', _88 => _88.meanLine]) === true,
+    meanMarker: _optionalChain([visibility, 'optionalAccess', _89 => _89.meanMarker]) !== false,
+    nonoutliers: _optionalChain([visibility, 'optionalAccess', _90 => _90.nonoutliers]) === true,
+    outliers: _optionalChain([visibility, 'optionalAccess', _91 => _91.outliers]) !== false
   };
 }
 function computePercentile(sortedValues, percentile, method) {
@@ -760,7 +773,7 @@ function computeBoxWhiskerStats(series) {
 function resolveHierarchyNodeColor(chart, node) {
   const lineage = node.ancestors().reverse();
   const topLevel = lineage[1];
-  const baseIndex = _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _102 => _102.data, 'access', _103 => _103.colorIndex]), () => ( 0));
+  const baseIndex = _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _92 => _92.data, 'access', _93 => _93.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));
@@ -768,7 +781,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', _104 => _104.data, 'access', _105 => _105.colorIndex]), () => ( 0)));
+  return chartSeriesColor(chart, _nullishCoalesce(_optionalChain([topLevel, 'optionalAccess', _94 => _94.data, 'access', _95 => _95.colorIndex]), () => ( 0)));
 }
 function excelTreemapTile(node, x0, y0, x1, y1) {
   if (!node.children || node.children.length === 0) {
@@ -783,12 +796,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', _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));
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _96 => _96.chartColorPalette, 'optionalAccess', _97 => _97[0]]), () => ( _optionalChain([chart, 'access', _98 => _98.series, 'access', _99 => _99[0], 'optionalAccess', _100 => _100.color]))), () => ( _optionalChain([chart, 'access', _101 => _101.series, 'access', _102 => _102[0], 'optionalAccess', _103 => _103.lineColor]))), () => ( chart.axisLineColor)), () => ( chart.textColor)), () => ( palette.text));
 }
 function resolveExplicitSurfaceSeriesColor(chart, kind) {
-  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])));
+  const shape = _optionalChain([chart, 'access', _104 => _104.series, 'access', _105 => _105[0], 'optionalAccess', _106 => _106.shapeProperties]);
+  if (kind === "fill" ? _optionalChain([shape, 'optionalAccess', _107 => _107.xmlFillHidden]) === true : _optionalChain([shape, 'optionalAccess', _108 => _108.xmlLineHidden]) === true) return "transparent";
+  const color = kind === "fill" ? _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _109 => _109.xmlFillColor]), () => ( _optionalChain([shape, 'optionalAccess', _110 => _110.solidFillHex]))) : _nullishCoalesce(_optionalChain([shape, 'optionalAccess', _111 => _111.xmlLineColor]), () => ( _optionalChain([shape, 'optionalAccess', _112 => _112.lineColorHex])));
   return normalizeRendererHexColor(color);
 }
 function getSurfaceColorStops(chart, palette) {
@@ -803,7 +816,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', _123 => _123.raw, 'optionalAccess', _124 => _124.builtinThemeColors]);
+  const themeColors = _optionalChain([chart, 'access', _113 => _113.raw, 'optionalAccess', _114 => _114.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;
@@ -818,8 +831,8 @@ function getSurfaceDomain(chart) {
   if (numericValues.length === 0) {
     return 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 explicitMin = typeof _optionalChain([chart, 'access', _115 => _115.valueAxis, 'optionalAccess', _116 => _116.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? chart.valueAxis.min : null;
+  const explicitMax = typeof _optionalChain([chart, 'access', _117 => _117.valueAxis, 'optionalAccess', _118 => _118.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));
@@ -827,7 +840,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', _129 => _129.valueAxis, 'optionalAccess', _130 => _130.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : niceNormalized * magnitude;
+  const step = typeof _optionalChain([chart, 'access', _119 => _119.valueAxis, 'optionalAccess', _120 => _120.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;
@@ -857,14 +870,14 @@ function resolveSurfaceBandIndex(domain, value) {
   return Math.max(0, ticks.length - 2);
 }
 function resolveSurfaceBandFormatColor(chart, key, index) {
-  const colors = _optionalChain([chart, 'access', _131 => _131.raw, 'optionalAccess', _132 => _132[key]]);
+  const colors = _optionalChain([chart, 'access', _121 => _121.raw, 'optionalAccess', _122 => _122[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', _133 => _133.raw, 'optionalAccess', _134 => _134.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 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)));
@@ -874,7 +887,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', _135 => _135.view3d, 'optionalAccess', _136 => _136.depthPercent]), () => ( 100))) / 100);
+  const depthScale = Math.max(0.01, (_nullishCoalesce(_optionalChain([chart, 'access', _125 => _125.view3d, 'optionalAccess', _126 => _126.depthPercent]), () => ( 100))) / 100);
   const targetAspect = columnCount / Math.max(1, chart.series.length) / depthScale;
   let width = layout.plot.width;
   let height = layout.plot.height;
@@ -918,7 +931,7 @@ function isContourSurfaceChart(chart) {
   return chart.chartType === "Surface" && chart.is3d !== true;
 }
 function renderSurfaceAxes(chart, layout) {
-  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])) {
+  if (_optionalChain([chart, 'access', _127 => _127.categoryAxis, 'optionalAccess', _128 => _128.delete]) && _optionalChain([chart, 'access', _129 => _129.seriesAxis, 'optionalAccess', _130 => _130.delete]) && _optionalChain([chart, 'access', _131 => _131.valueAxis, 'optionalAccess', _132 => _132.delete])) {
     return null;
   }
   const plot = resolveSurfacePlotRect(chart, layout);
@@ -928,7 +941,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', _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 columnPositions = categories.map((_, index) => plot.left + (isContourSurfaceChart(chart) && _optionalChain([chart, 'access', _133 => _133.valueAxis, 'optionalAccess', _134 => _134.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, 
@@ -943,7 +956,7 @@ function renderSurfaceAxes(chart, layout) {
         y: plot.top
       }
     ),
-    _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, 
+    _optionalChain([chart, 'access', _135 => _135.categoryAxis, 'optionalAccess', _136 => _136.delete]) !== true && _optionalChain([chart, 'access', _137 => _137.categoryAxis, 'optionalAccess', _138 => _138.labelPosition]) !== "none" && categories.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "text",
       {
         fill: labelColor,
@@ -955,7 +968,7 @@ function renderSurfaceAxes(chart, layout) {
       },
       `surface-x-label-${index}`
     )),
-    _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, 
+    _optionalChain([chart, 'access', _139 => _139.seriesAxis, 'optionalAccess', _140 => _140.delete]) !== true && _optionalChain([chart, 'access', _141 => _141.seriesAxis, 'optionalAccess', _142 => _142.labelPosition]) !== "none" && seriesLabels.map((label, index) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "text",
       {
         fill: labelColor,
@@ -1010,7 +1023,7 @@ function getLegendItems(chart, chartType, palette) {
   }
   if (chartType === "Sunburst" || chartType === "Treemap") {
     const hierarchyData = buildHierarchyData(chart);
-    if (!_optionalChain([hierarchyData, 'optionalAccess', _153 => _153.children])) {
+    if (!_optionalChain([hierarchyData, 'optionalAccess', _143 => _143.children])) {
       return [];
     }
     return hierarchyData.children.map((child, index) => ({
@@ -1021,7 +1034,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', _154 => _154.series, 'access', _155 => _155[0], 'optionalAccess', _156 => _156.values]), () => ( []));
+      const values = _nullishCoalesce(_optionalChain([chart, 'access', _144 => _144.series, 'access', _145 => _145[0], 'optionalAccess', _146 => _146.values]), () => ( []));
       return categories.map((label, index) => ({
         color: chartPointColor(chart, index),
         label: normalizeCategoryLabel(label),
@@ -1046,8 +1059,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', _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 titleHeight = chart.title && !(isSurfaceChart && _optionalChain([chart, 'access', _147 => _147.raw, 'optionalAccess', _148 => _148.titleOverlay]) === true) ? isSurfaceChart ? 30 : 24 : 8;
+  const legendPosition = normalizeLegendPosition(_optionalChain([chart, 'access', _149 => _149.legend, 'optionalAccess', _150 => _150.position]));
   const legendVertical = legendItems.length > 0 && (legendPosition === "right" || legendPosition === "left");
   const compactWidth = width <= 280;
   const compactHeight = height <= 200;
@@ -1057,10 +1070,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', _161 => _161.valueAxis, 'optionalAccess', _162 => _162.delete]) ? 12 : 42) + (layoutLegendPosition === "left" ? legendWidth : 0);
+  const plotLeft = (isSurfaceChart && _optionalChain([chart, 'access', _151 => _151.valueAxis, 'optionalAccess', _152 => _152.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', _163 => _163.categoryAxis, 'optionalAccess', _164 => _164.delete]) ? 8 : 28) + (layoutLegendPosition === "bottom" ? horizontalLegendHeight : 0);
+  const plotBottom = (horizontalMapGradient || isSurfaceChart && _optionalChain([chart, 'access', _153 => _153.categoryAxis, 'optionalAccess', _154 => _154.delete]) ? 8 : 28) + (layoutLegendPosition === "bottom" ? horizontalLegendHeight : 0);
   const plotWidth = Math.max(horizontalMapGradient ? 1 : 40, width - plotLeft - plotRight);
   return {
     height,
@@ -1133,30 +1146,30 @@ function resolveNumericAxisDomain(minValue, maxValue, majorUnit, includeZero = f
   };
 }
 function resolveAxisDomainWithChartOverrides(axis, minValue, maxValue, includeZero = false) {
-  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);
+  const hasExplicitMin = typeof _optionalChain([axis, 'optionalAccess', _155 => _155.min]) === "number" && Number.isFinite(axis.min);
+  const hasExplicitMax = typeof _optionalChain([axis, 'optionalAccess', _156 => _156.max]) === "number" && Number.isFinite(axis.max);
+  const rawMin = hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _157 => _157.min])) : minValue;
+  const rawMax = hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _158 => _158.max])) : maxValue;
+  const domain = resolveNumericAxisDomain(rawMin, rawMax, _optionalChain([axis, 'optionalAccess', _159 => _159.majorUnit]), includeZero);
   return {
     hasExplicitMax,
     hasExplicitMin,
-    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,
+    majorUnit: _optionalChain([axis, 'optionalAccess', _160 => _160.majorUnit]),
+    max: hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _161 => _161.max])) : domain.max,
+    min: hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _162 => _162.min])) : domain.min,
     ticks: hasExplicitMin || hasExplicitMax ? buildNumericTickValues(
-      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])
+      hasExplicitMin ? Number(_optionalChain([axis, 'optionalAccess', _163 => _163.min])) : domain.min,
+      hasExplicitMax ? Number(_optionalChain([axis, 'optionalAccess', _164 => _164.max])) : domain.max,
+      _optionalChain([axis, 'optionalAccess', _165 => _165.majorUnit])
     ) : domain.ticks
   };
 }
 function resolve3dFrameOffsets(chart, baseDepthX = 11, baseDepthY = 8) {
-  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 depthRatio = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _166 => _166.view3d, 'optionalAccess', _167 => _167.depthPercent]), () => ( 100))) / 100, 0.35, 3.2);
+  const rotX = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _168 => _168.view3d, 'optionalAccess', _169 => _169.rotX]), () => ( 20)), -80, 80);
+  const rotY = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _170 => _170.view3d, 'optionalAccess', _171 => _171.rotY]), () => ( 20)), -80, 80);
+  const usePerspective = _optionalChain([chart, 'access', _172 => _172.view3d, 'optionalAccess', _173 => _173.rAngAx]) === false;
+  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _174 => _174.view3d, 'optionalAccess', _175 => _175.perspective]), () => ( (usePerspective ? 26 : 0)))) / 100, 0, 1);
   const projectedOrigin = projectCartesian3dPoint(
     0,
     0,
@@ -1254,9 +1267,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', _186 => _186.categoryAxis, 'optionalAccess', _187 => _187.numberFormat, 'optionalAccess', _188 => _188.formatCode]);
+  const formatCode = _optionalChain([chart, 'access', _176 => _176.categoryAxis, 'optionalAccess', _177 => _177.numberFormat, 'optionalAccess', _178 => _178.formatCode]);
   if (numeric != null && isLikelyDateFormatCode(formatCode)) {
-    return formatExcelDateSerial(numeric, formatCode, _optionalChain([rawRecord, 'optionalAccess', _189 => _189.date1904]) === true);
+    return formatExcelDateSerial(numeric, formatCode, _optionalChain([rawRecord, 'optionalAccess', _179 => _179.date1904]) === true);
   }
   const normalized = normalizeCategoryLabel(value);
   if (normalized.length > 0) {
@@ -1416,18 +1429,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', _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 showSeriesName = vertical || (_nullishCoalesce(_optionalChain([layout, 'access', _180 => _180.legendBounds, 'optionalAccess', _181 => _181.height]), () => ( 48))) >= 44;
+      const y = vertical ? layout.plot.top + 26 : (_nullishCoalesce(_optionalChain([layout, 'access', _182 => _182.legendBounds, 'optionalAccess', _183 => _183.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', _194 => _194.length]), () => ( 3));
+      const count = _nullishCoalesce(_optionalChain([stops, 'optionalAccess', _184 => _184.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', _195 => _195.name]), () => ( "")) }),
+        showSeriesName && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { fill: textColor, fontSize: 10, x, y: y - 12, children: _nullishCoalesce(_optionalChain([series, 'optionalAccess', _185 => _185.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', _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]) })
+        /* @__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', _186 => _186[0], 'optionalAccess', _187 => _187.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', _188 => _188[1], 'optionalAccess', _189 => _189.label]) })
       ] });
     }
   }
@@ -1473,10 +1486,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', _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";
+  const showValueAxis = _optionalChain([chart, 'access', _190 => _190.valueAxis, 'optionalAccess', _191 => _191.delete]) !== true;
+  const showCategoryAxis = _optionalChain([chart, 'access', _192 => _192.categoryAxis, 'optionalAccess', _193 => _193.delete]) !== true;
+  const showValueLabels = showValueAxis && _optionalChain([chart, 'access', _194 => _194.valueAxis, 'optionalAccess', _195 => _195.labelPosition]) !== "none";
+  const showCategoryLabels = showCategoryAxis && _optionalChain([chart, 'access', _196 => _196.categoryAxis, 'optionalAccess', _197 => _197.labelPosition]) !== "none";
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
     showValueAxis ? valueTicks.map((tick) => {
       const valuePosition = mapValue(tick);
@@ -1801,22 +1814,22 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
     chart.valueAxis,
     minValue,
     maxValue,
-    isAreaChart || _optionalChain([chart, 'access', _208 => _208.valueAxis, 'optionalAccess', _209 => _209.crosses]) === "autoZero"
+    isAreaChart || _optionalChain([chart, 'access', _198 => _198.valueAxis, 'optionalAccess', _199 => _199.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', _210 => _210.view3d, 'optionalAccess', _211 => _211.depthPercent]), () => ( 100))) / 100, 0.5, 4);
+  const depthScale = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _200 => _200.view3d, 'optionalAccess', _201 => _201.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', _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 rotXRad = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _202 => _202.view3d, 'optionalAccess', _203 => _203.rotX]), () => ( 18)), -80, 80) * (Math.PI / 180);
+  const rotYRad = clamp(_nullishCoalesce(_optionalChain([chart, 'access', _204 => _204.view3d, 'optionalAccess', _205 => _205.rotY]), () => ( 24)), -80, 80) * (Math.PI / 180);
+  const usePerspective = _optionalChain([chart, 'access', _206 => _206.view3d, 'optionalAccess', _207 => _207.rAngAx]) === false;
+  const perspectiveStrength = clamp((_nullishCoalesce(_optionalChain([chart, 'access', _208 => _208.view3d, 'optionalAccess', _209 => _209.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;
@@ -1865,7 +1878,7 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
         categoryIndex,
         defined: point.defined,
         depth: top.depth,
-        depthBack: _nullishCoalesce(_optionalChain([topBack, 'optionalAccess', _220 => _220.depth]), () => ( top.depth)),
+        depthBack: _nullishCoalesce(_optionalChain([topBack, 'optionalAccess', _210 => _210.depth]), () => ( top.depth)),
         top,
         topBack
       };
@@ -1990,11 +2003,11 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
       ] : [];
       const strokeColor = chartSeriesStrokeColor(chart, seriesIndex);
       const fillColor = chartSeriesColor(chart, seriesIndex);
-      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 markerSymbol = normalizeChartMarkerSymbol(_optionalChain([chart, 'access', _211 => _211.series, 'access', _212 => _212[seriesIndex], 'optionalAccess', _213 => _213.markerSymbol]));
+      const markerPath = markerSymbolPath(markerSymbol, markerRadiusPx(_optionalChain([chart, 'access', _214 => _214.series, 'access', _215 => _215[seriesIndex], 'optionalAccess', _216 => _216.markerSize])));
       const slabFaces = isAreaChart && isStackedSeries ? definedPoints.slice(1).map((point, pointIndex) => {
         const previous = definedPoints[pointIndex];
-        if (!_optionalChain([previous, 'optionalAccess', _227 => _227.topBack]) || !point.topBack || !previous.bottomBack || !point.bottomBack) {
+        if (!_optionalChain([previous, 'optionalAccess', _217 => _217.topBack]) || !point.topBack || !previous.bottomBack || !point.bottomBack) {
           return null;
         }
         const topFace = buildLinearSvgPath([previous.top, point.top, point.topBack, previous.topBack], true);
@@ -2026,13 +2039,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', _228 => _228.topBack]) && _optionalChain([firstDefinedPoint, 'optionalAccess', _229 => _229.bottomBack]) ? buildLinearSvgPath([
+      const startCap = isAreaChart && isStackedSeries && _optionalChain([firstDefinedPoint, 'optionalAccess', _218 => _218.topBack]) && _optionalChain([firstDefinedPoint, 'optionalAccess', _219 => _219.bottomBack]) ? buildLinearSvgPath([
         firstDefinedPoint.top,
         firstDefinedPoint.bottom,
         firstDefinedPoint.bottomBack,
         firstDefinedPoint.topBack
       ], true) : "";
-      const endCap = isAreaChart && isStackedSeries && _optionalChain([lastDefinedPoint, 'optionalAccess', _230 => _230.topBack]) && _optionalChain([lastDefinedPoint, 'optionalAccess', _231 => _231.bottomBack]) ? buildLinearSvgPath([
+      const endCap = isAreaChart && isStackedSeries && _optionalChain([lastDefinedPoint, 'optionalAccess', _220 => _220.topBack]) && _optionalChain([lastDefinedPoint, 'optionalAccess', _221 => _221.bottomBack]) ? buildLinearSvgPath([
         lastDefinedPoint.top,
         lastDefinedPoint.bottom,
         lastDefinedPoint.bottomBack,
@@ -2105,7 +2118,7 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
             fill: "none",
             stroke: strokeColor,
             strokeLinejoin: "round",
-            strokeWidth: Math.max(1.8, _nullishCoalesce(_optionalChain([chart, 'access', _232 => _232.series, 'access', _233 => _233[seriesIndex], 'optionalAccess', _234 => _234.lineWidthPx]), () => ( 2)))
+            strokeWidth: Math.max(1.8, _nullishCoalesce(_optionalChain([chart, 'access', _222 => _222.series, 'access', _223 => _223[seriesIndex], 'optionalAccess', _224 => _224.lineWidthPx]), () => ( 2)))
           }
         ),
         markerPath.length > 0 ? definedPoints.map((point, pointIndex) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -2117,8 +2130,8 @@ function renderLineOrAreaChart3d(chart, palette, layout, categories, stackedPoin
               {
                 ...chartElementDataProps(seriesIndex, point.categoryIndex),
                 d: markerPath,
-                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)),
+                fill: _nullishCoalesce(_optionalChain([chart, 'access', _225 => _225.series, 'access', _226 => _226[seriesIndex], 'optionalAccess', _227 => _227.markerColor]), () => ( fillColor)),
+                stroke: _nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _228 => _228.series, 'access', _229 => _229[seriesIndex], 'optionalAccess', _230 => _230.markerLineColor]), () => ( chart.chartAreaFillColor)), () => ( palette.surface)),
                 strokeWidth: 1
               }
             )
@@ -2180,7 +2193,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', _241 => _241.categoryAxis, 'optionalAccess', _242 => _242.orientation]) !== "maxMin";
+  const shouldReverseCategories = isHorizontal && _optionalChain([chart, 'access', _231 => _231.categoryAxis, 'optionalAccess', _232 => _232.orientation]) !== "maxMin";
   const categories = shouldReverseCategories ? sourceCategories.slice().reverse() : sourceCategories;
   const isStacked = chartType === "ColumnStacked" || chartType === "BarStacked" || isPercentStacked;
   const negativeFillMode = isPercentStacked ? "chartArea" : chartType === "ColumnClustered" ? "none" : "series";
@@ -2264,24 +2277,35 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
   minValue = valueDomain.min;
   maxValue = valueDomain.max;
   const categoryBandPadding = isHistogramLike ? { inner: 0, outer: 0 } : resolveCategoryBandPadding(chart.gapWidth);
-  const categoryScale = _d3scale.scaleBand.call(void 0, ).domain(categories).range(isHorizontal ? [plot.top, plot.top + plot.height] : [plot.left, plot.left + plot.width]).paddingInner(categoryBandPadding.inner).paddingOuter(categoryBandPadding.outer);
-  const seriesScale = _d3scale.scaleBand.call(void 0, ).domain(Array.from({ length: seriesCount }, (_, index) => String(index))).range([0, categoryScale.bandwidth()]).paddingInner(isHistogramLike ? 0 : 0.16).paddingOuter(isHistogramLike ? 0 : 0.08);
+  const categoryScale = bandScale(
+    categories,
+    isHorizontal ? [plot.top, plot.top + plot.height] : [plot.left, plot.left + plot.width],
+    categoryBandPadding.inner,
+    categoryBandPadding.outer
+  );
+  const seriesScale = bandScale(
+    Array.from({ length: seriesCount }, (_, index) => String(index)),
+    [0, categoryScale.bandwidth],
+    isHistogramLike ? 0 : 0.16,
+    isHistogramLike ? 0 : 0.08
+  );
   const usesSeriesDepthAxis = chart.is3d === true && !isHorizontal && !isStacked && seriesCount > 1 && chart.seriesAxis != null;
   const depthLaneSpread = usesSeriesDepthAxis ? clamp(1.26 + seriesCount * 0.16, 1.4, 1.96) : 1;
   const depthGridSpanX = usesSeriesDepthAxis && frameOffsets ? frameOffsets.depthX * depthLaneSpread : 0;
   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', _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(
+  const depthBarX = usesSeriesDepthAxis ? Math.sign(depthSlotX || _optionalChain([frameOffsets, 'optionalAccess', _233 => _233.depthX]) || 1) * Math.max(8, Math.abs(depthSlotX) * 1.14) : _optionalChain([frameOffsets, 'optionalAccess', _234 => _234.depthX]);
+  const depthBarY = usesSeriesDepthAxis ? Math.sign(depthSlotY || _optionalChain([frameOffsets, 'optionalAccess', _235 => _235.depthY]) || -1) * Math.max(5.5, Math.abs(depthSlotY) * 1.12) : _optionalChain([frameOffsets, 'optionalAccess', _236 => _236.depthY]);
+  const shouldReverseValueAxis = _optionalChain([chart, 'access', _237 => _237.valueAxis, 'optionalAccess', _238 => _238.orientation]) === "maxMin";
+  const valueScale = linearScale(
+    [minValue, maxValue],
     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', _249 => _249.valueAxis, 'optionalAccess', _250 => _250.majorUnit]), () => ( 20))) : valueDomain.ticks;
+  const ticks = isPercentStacked ? buildNumericTickValues(minValue, maxValue, _nullishCoalesce(_optionalChain([chart, 'access', _239 => _239.valueAxis, 'optionalAccess', _240 => _240.majorUnit]), () => ( 20))) : valueDomain.ticks;
   const categoryPositions = categories.map((category) => {
     const bandStart = _nullishCoalesce(categoryScale(category), () => ( 0));
-    return bandStart + categoryScale.bandwidth() / 2;
+    return bandStart + categoryScale.bandwidth / 2;
   });
   const bars = [];
   const positive = Array.from({ length: categoryCount }, () => 0);
@@ -2291,7 +2315,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', _251 => _251.series, 'access', _252 => _252[seriesIndex], 'optionalAccess', _253 => _253.dataPointStyles, 'optionalAccess', _254 => _254.find, 'call', _255 => _255((entry) => entry.index === pointIndex)]);
+      const pointStyle = _optionalChain([chart, 'access', _241 => _241.series, 'access', _242 => _242[seriesIndex], 'optionalAccess', _243 => _243.dataPointStyles, 'optionalAccess', _244 => _244.find, 'call', _245 => _245((entry) => entry.index === pointIndex)]);
       let start = 0;
       let end = value;
       if (isStacked) {
@@ -2306,19 +2330,19 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
         }
       }
       const colors = chartSeriesBarColors(chart, seriesIndex, rawValue, negativeFillMode);
-      const isInvertedNegative = rawValue < 0 && _optionalChain([chart, 'access', _256 => _256.series, 'access', _257 => _257[seriesIndex], 'optionalAccess', _258 => _258.invertIfNegative]) === true;
+      const isInvertedNegative = rawValue < 0 && _optionalChain([chart, 'access', _246 => _246.series, 'access', _247 => _247[seriesIndex], 'optionalAccess', _248 => _248.invertIfNegative]) === true;
       if (!isInvertedNegative) {
         if (variesBarColorsByCategory(chart)) {
           colors.fill = chartPointColor(chart, pointIndex, seriesIndex);
           colors.stroke = colors.fill;
         }
-        if (_optionalChain([pointStyle, 'optionalAccess', _259 => _259.color])) {
+        if (_optionalChain([pointStyle, 'optionalAccess', _249 => _249.color])) {
           colors.fill = pointStyle.color;
           if (!pointStyle.lineColor) {
             colors.stroke = pointStyle.color;
           }
         }
-        if (_optionalChain([pointStyle, 'optionalAccess', _260 => _260.lineColor])) {
+        if (_optionalChain([pointStyle, 'optionalAccess', _250 => _250.lineColor])) {
           colors.stroke = pointStyle.lineColor;
         }
       }
@@ -2327,11 +2351,11 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
       }
       const category = categories[categoryIndex];
       const categoryStart = _nullishCoalesce(categoryScale(category), () => ( 0));
-      const barThickness = usesSeriesDepthAxis ? Math.max(7, categoryScale.bandwidth() * 0.4) : isHistogramLike ? categoryScale.bandwidth() : isStacked ? categoryScale.bandwidth() : seriesScale.bandwidth();
-      const barOffset = usesSeriesDepthAxis ? Math.max(0, (categoryScale.bandwidth() - barThickness) * 0.5) : isHistogramLike ? 0 : isStacked ? 0 : _nullishCoalesce(seriesScale(String(seriesIndex)), () => ( 0));
+      const barThickness = usesSeriesDepthAxis ? Math.max(7, categoryScale.bandwidth * 0.4) : isHistogramLike ? categoryScale.bandwidth : isStacked ? categoryScale.bandwidth : seriesScale.bandwidth;
+      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', _261 => _261.depthX]), () => ( 0))) + depthOffsetY * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _262 => _262.depthY]), () => ( 0)));
+      const depthOrder = depthOffsetX * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _251 => _251.depthX]), () => ( 0))) + depthOffsetY * (_nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _252 => _252.depthY]), () => ( 0)));
       const shapeTaper = normalized3dShape === "pyramid" ? 0.94 : normalized3dShape === "cone" ? 1 : 0;
       let topScale = 1;
       let bottomScale = 1;
@@ -2369,8 +2393,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', _263 => _263.depthX]),
-          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _264 => _264.depthY]),
+          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _253 => _253.depthX]),
+          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _254 => _254.depthY]),
           shape3d: normalized3dShape,
           seriesIndex,
           stroke: colors.stroke,
@@ -2399,8 +2423,8 @@ function renderBarChart(chart, palette, layout, chartType, selectedChartElement)
           isHorizontal: false,
           key: `bar-${seriesIndex}-${categoryIndex}`,
           left: categoryStart + barOffset,
-          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _265 => _265.depthX]),
-          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _266 => _266.depthY]),
+          depthX: usesSeriesDepthAxis ? depthBarX : _optionalChain([frameOffsets, 'optionalAccess', _255 => _255.depthX]),
+          depthY: usesSeriesDepthAxis ? depthBarY : _optionalChain([frameOffsets, 'optionalAccess', _256 => _256.depthY]),
           shape3d: normalized3dShape,
           seriesIndex,
           stroke: colors.stroke,
@@ -2472,8 +2496,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', _267 => _267.depthX]), () => ( 0));
-  const frameDepthY = usesSeriesDepthAxis ? depthGridSpanY : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _268 => _268.depthY]), () => ( 0));
+  const frameDepthX = usesSeriesDepthAxis ? depthGridSpanX : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _257 => _257.depthX]), () => ( 0));
+  const frameDepthY = usesSeriesDepthAxis ? depthGridSpanY : _nullishCoalesce(_optionalChain([frameOffsets, 'optionalAccess', _258 => _258.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;
@@ -2568,7 +2592,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', _269 => _269.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, `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', _259 => _259.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) {
@@ -2595,11 +2619,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', _270 => _270[seriesIndex], 'optionalAccess', _271 => _271[categoryIndex]]), () => ( null));
+      const rawValue = _nullishCoalesce(_optionalChain([resolvedValuesBySeries, 'access', _260 => _260[seriesIndex], 'optionalAccess', _261 => _261[categoryIndex]]), () => ( null));
       if (rawValue == null) {
         return { defined: false, y: null, y0: null, y1: null };
       }
-      const value = isPercentStackedSeries ? rawValue / (_nullishCoalesce(_optionalChain([categoryTotals, 'optionalAccess', _272 => _272[categoryIndex]]), () => ( 1))) * 100 : rawValue;
+      const value = isPercentStackedSeries ? rawValue / (_nullishCoalesce(_optionalChain([categoryTotals, 'optionalAccess', _262 => _262[categoryIndex]]), () => ( 1))) * 100 : rawValue;
       if (value >= 0) {
         const start2 = positive[categoryIndex];
         const end2 = start2 + value;
@@ -2612,7 +2636,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', _273 => _273[seriesIndex], 'optionalAccess', _274 => _274[categoryIndex]]), () => ( null));
+    const value = _nullishCoalesce(_optionalChain([resolvedValuesBySeries, 'access', _263 => _263[seriesIndex], 'optionalAccess', _264 => _264[categoryIndex]]), () => ( null));
     return {
       defined: value != null,
       y: value,
@@ -2628,12 +2652,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', _275 => _275.valueAxis, 'optionalAccess', _276 => _276.crosses]) === "autoZero") {
+  } else if ((chartType === "Line" || isStackedLine) && _optionalChain([chart, 'access', _265 => _265.valueAxis, 'optionalAccess', _266 => _266.crosses]) === "autoZero") {
     minValue = Math.min(0, minValue);
   }
   if (isPercentStackedSeries) {
-    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);
+    const explicitMin = typeof _optionalChain([chart, 'access', _267 => _267.valueAxis, 'optionalAccess', _268 => _268.min]) === "number" && Number.isFinite(chart.valueAxis.min) ? Number(chart.valueAxis.min) : Math.min(0, minValue);
+    const explicitMax = typeof _optionalChain([chart, 'access', _269 => _269.valueAxis, 'optionalAccess', _270 => _270.max]) === "number" && Number.isFinite(chart.valueAxis.max) ? Number(chart.valueAxis.max) : Math.max(100, maxValue);
     minValue = explicitMin;
     maxValue = explicitMax <= explicitMin ? explicitMin + 1 : explicitMax;
   } else {
@@ -2641,24 +2665,24 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       chart.valueAxis,
       minValue,
       maxValue,
-      isAreaChart || _optionalChain([chart, 'access', _281 => _281.valueAxis, 'optionalAccess', _282 => _282.crosses]) === "autoZero"
+      isAreaChart || _optionalChain([chart, 'access', _271 => _271.valueAxis, 'optionalAccess', _272 => _272.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', _283 => _283.valueAxis, 'optionalAccess', _284 => _284.majorUnit]), () => ( 20))) : resolveAxisDomainWithChartOverrides(
+  const xScale = pointScale(categories, [plot.left, plot.left + plot.width]);
+  const yScale = linearScale([minValue, maxValue], [plot.top + plot.height, plot.top]);
+  const ticks = isPercentStackedSeries ? buildNumericTickValues(minValue, maxValue, _nullishCoalesce(_optionalChain([chart, 'access', _273 => _273.valueAxis, 'optionalAccess', _274 => _274.majorUnit]), () => ( 20))) : resolveAxisDomainWithChartOverrides(
     chart.valueAxis,
     minValue,
     maxValue,
-    isAreaChart || _optionalChain([chart, 'access', _285 => _285.valueAxis, 'optionalAccess', _286 => _286.crosses]) === "autoZero"
+    isAreaChart || _optionalChain([chart, 'access', _275 => _275.valueAxis, 'optionalAccess', _276 => _276.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', _287 => _287[seriesIndex], 'optionalAccess', _288 => _288[categoryIndex]]), () => ( {
+    const point = _nullishCoalesce(_optionalChain([stackedPointsBySeries, 'access', _277 => _277[seriesIndex], 'optionalAccess', _278 => _278[categoryIndex]]), () => ( {
       defined: false,
       y: null,
       y0: null,
@@ -2687,12 +2711,12 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
     );
   }
   const rawRecord = chart.raw && typeof chart.raw === "object" ? chart.raw : null;
-  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 dropLinesRecord = _optionalChain([rawRecord, 'optionalAccess', _279 => _279.dropLines]) && typeof rawRecord.dropLines === "object" ? rawRecord.dropLines : null;
+  const highLowLinesRecord = _optionalChain([rawRecord, 'optionalAccess', _280 => _280.highLowLines]) && typeof rawRecord.highLowLines === "object" ? rawRecord.highLowLines : null;
+  const upDownBarsRecord = _optionalChain([rawRecord, 'optionalAccess', _281 => _281.upDownBars]) && typeof rawRecord.upDownBars === "object" ? rawRecord.upDownBars : null;
+  const dropLineColor = _nullishCoalesce(normalizeRendererHexColor(_optionalChain([dropLinesRecord, 'optionalAccess', _282 => _282.shapeProperties, 'optionalAccess', _283 => _283.lineColorHex])), () => ( lightenColor(_nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border)), 0.45)));
+  const highLowLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(normalizeRendererHexColor(_optionalChain([highLowLinesRecord, 'optionalAccess', _284 => _284.shapeProperties, 'optionalAccess', _285 => _285.lineColorHex])), () => ( chart.axisLineColor)), () => ( chart.chartAreaBorderColor)), () => ( palette.border));
+  const upDownGapWidth = typeof _optionalChain([upDownBarsRecord, 'optionalAccess', _286 => _286.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: [
@@ -2707,7 +2731,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', _297 => _297[categoryIndex], 'optionalAccess', _298 => _298.y])).filter((value) => value != null && Number.isFinite(value));
+      const yValues = plotPointsBySeries.map((seriesPoints) => _optionalChain([seriesPoints, 'access', _287 => _287[categoryIndex], 'optionalAccess', _288 => _288.y])).filter((value) => value != null && Number.isFinite(value));
       if (yValues.length < 2) {
         return null;
       }
@@ -2726,8 +2750,8 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
       );
     }) : null,
     !isAreaChart && !isStackedSeries && upDownBarsRecord && plotPointsBySeries.length >= 2 ? categories.map((_, 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]]);
+      const first = _optionalChain([plotPointsBySeries, 'access', _289 => _289[0], 'optionalAccess', _290 => _290[categoryIndex]]);
+      const second = _optionalChain([plotPointsBySeries, 'access', _291 => _291[plotPointsBySeries.length - 1], 'optionalAccess', _292 => _292[categoryIndex]]);
       if (!first || !second || first.y == null || second.y == null) {
         return null;
       }
@@ -2755,7 +2779,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', _303 => _303.shapeProperties, 'optionalAccess', _304 => _304.xmlFillColor]) === "string" ? series.shapeProperties.xmlFillColor : chartSeriesColor(chart, seriesIndex);
+      const seriesFillColor = typeof _optionalChain([series, 'access', _293 => _293.shapeProperties, 'optionalAccess', _294 => _294.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",
@@ -2785,7 +2809,7 @@ function renderLineOrAreaChart(chart, palette, layout, chartType, selectedChartE
             ...chartElementDataProps(seriesIndex),
             d: linePath,
             fill: "none",
-            stroke: _optionalChain([series, 'access', _305 => _305.shapeProperties, 'optionalAccess', _306 => _306.xmlLineHidden]) === true ? "none" : chartSeriesStrokeColor(chart, seriesIndex),
+            stroke: _optionalChain([series, 'access', _295 => _295.shapeProperties, 'optionalAccess', _296 => _296.xmlLineHidden]) === true ? "none" : chartSeriesStrokeColor(chart, seriesIndex),
             strokeLinecap: "round",
             strokeLinejoin: "round",
             strokeWidth: Math.max(1.5, _nullishCoalesce(series.lineWidthPx, () => ( 2)))
@@ -2803,7 +2827,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', _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, 
+        points.map((point, pointIndex) => point.y != null && (isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _297 => _297.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,
@@ -2835,12 +2859,22 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
     return null;
   }
   const plot = layout.plot;
-  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 groupGapWidth = typeof _optionalChain([columnGroup, 'access', _298 => _298.raw, 'optionalAccess', _299 => _299.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);
-  const seriesScale = _d3scale.scaleBand.call(void 0, ).domain(Array.from({ length: columnGroup.series.length }, (_, index) => String(index))).range([0, categoryScale.bandwidth()]).paddingInner(histogramColumns ? 0 : 0.16).paddingOuter(histogramColumns ? 0 : 0.08);
-  const categoryPositions = categories.map((category) => (_nullishCoalesce(categoryScale(category), () => ( plot.left))) + categoryScale.bandwidth() / 2);
+  const categoryScale = bandScale(
+    categories,
+    [plot.left, plot.left + plot.width],
+    categoryBandPadding.inner,
+    categoryBandPadding.outer
+  );
+  const seriesScale = bandScale(
+    Array.from({ length: columnGroup.series.length }, (_, index) => String(index)),
+    [0, categoryScale.bandwidth],
+    histogramColumns ? 0 : 0.16,
+    histogramColumns ? 0 : 0.08
+  );
+  const categoryPositions = categories.map((category) => (_nullishCoalesce(categoryScale(category), () => ( plot.left))) + categoryScale.bandwidth / 2);
   const resolveGlobalSeriesIndex = (series) => {
     const index = chart.series.findIndex((candidate) => candidate.id === series.id);
     return index >= 0 ? index : 0;
@@ -2851,19 +2885,19 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
     return null;
   }
   const primaryDomain = resolveNumericAxisDomain(
-    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]),
+    typeof _optionalChain([columnGroup, 'access', _300 => _300.valueAxis, 'optionalAccess', _301 => _301.min]) === "number" ? columnGroup.valueAxis.min : Math.min(...primaryValues),
+    typeof _optionalChain([columnGroup, 'access', _302 => _302.valueAxis, 'optionalAccess', _303 => _303.max]) === "number" ? columnGroup.valueAxis.max : Math.max(...primaryValues),
+    _optionalChain([columnGroup, 'access', _304 => _304.valueAxis, 'optionalAccess', _305 => _305.majorUnit]),
     true
   );
   const secondaryDomain = resolveNumericAxisDomain(
-    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]),
+    typeof _optionalChain([lineGroup, 'access', _306 => _306.valueAxis, 'optionalAccess', _307 => _307.min]) === "number" ? lineGroup.valueAxis.min : Math.min(...secondaryValues),
+    typeof _optionalChain([lineGroup, 'access', _308 => _308.valueAxis, 'optionalAccess', _309 => _309.max]) === "number" ? lineGroup.valueAxis.max : Math.max(...secondaryValues),
+    _optionalChain([lineGroup, 'access', _310 => _310.valueAxis, 'optionalAccess', _311 => _311.majorUnit]),
     false
   );
-  const primaryScale = _d3scale.scaleLinear.call(void 0, ).domain([primaryDomain.min, primaryDomain.max]).range([plot.top + plot.height, plot.top]);
-  const secondaryScale = _d3scale.scaleLinear.call(void 0, ).domain([secondaryDomain.min, secondaryDomain.max]).range([plot.top + plot.height, plot.top]);
+  const primaryScale = linearScale([primaryDomain.min, primaryDomain.max], [plot.top + plot.height, plot.top]);
+  const secondaryScale = linearScale([secondaryDomain.min, secondaryDomain.max], [plot.top + plot.height, plot.top]);
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const labelColor = resolveChartAxisTextColor(chart);
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
@@ -2877,7 +2911,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
       primaryDomain.ticks,
       (value) => primaryScale(value)
     ),
-    _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) => {
+    _optionalChain([lineGroup, 'access', _312 => _312.valueAxis, 'optionalAccess', _313 => _313.delete]) !== true && _optionalChain([lineGroup, 'access', _314 => _314.valueAxis, 'optionalAccess', _315 => _315.labelPosition]) !== "none" ? secondaryDomain.ticks.map((tick) => {
       const y = secondaryScale(tick);
       return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "text",
@@ -2892,7 +2926,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
         `combo-secondary-tick-${tick}`
       );
     }) : null,
-    _optionalChain([lineGroup, 'access', _326 => _326.valueAxis, 'optionalAccess', _327 => _327.delete]) !== true ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _optionalChain([lineGroup, 'access', _316 => _316.valueAxis, 'optionalAccess', _317 => _317.delete]) !== true ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
       "line",
       {
         stroke: axisColor,
@@ -2907,12 +2941,12 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
       const globalSeriesIndex = resolveGlobalSeriesIndex(series);
       const value = _nullishCoalesce(safeNumber(series.values[categoryIndex]), () => ( 0));
       const categoryStart = _nullishCoalesce(categoryScale(category), () => ( plot.left));
-      const barWidth = Math.max(1, histogramColumns ? categoryScale.bandwidth() : seriesScale.bandwidth());
+      const barWidth = Math.max(1, histogramColumns ? categoryScale.bandwidth : seriesScale.bandwidth);
       const x = categoryStart + (histogramColumns ? 0 : _nullishCoalesce(seriesScale(String(seriesIndex)), () => ( 0)));
       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', _328 => _328.kind]) !== "point";
+      const selected = isSelectedChartPoint(selectedChartElement, chart.id, globalSeriesIndex, categoryIndex) || isSelectedChartSeries(selectedChartElement, chart.id, globalSeriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _318 => _318.kind]) !== "point";
       return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, React.Fragment, { children: [
         /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
           "rect",
@@ -2939,7 +2973,7 @@ function renderComboChart(chart, palette, layout, selectedChartElement) {
     lineGroup.series.map((series, seriesIndex) => {
       const globalSeriesIndex = resolveGlobalSeriesIndex(series);
       const points = categories.map((category, categoryIndex) => ({
-        x: (_nullishCoalesce(categoryScale(category), () => ( plot.left))) + categoryScale.bandwidth() / 2,
+        x: (_nullishCoalesce(categoryScale(category), () => ( plot.left))) + categoryScale.bandwidth / 2,
         y: safeNumber(series.values[categoryIndex])
       }));
       const lineStrokePoints = chart.displayBlanksAs === "span" ? points.filter((point) => point.y != null) : points;
@@ -3041,26 +3075,26 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
   if (allX.length === 0 || allY.length === 0) {
     return null;
   }
-  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 hasExplicitMinX = typeof _optionalChain([chart, 'access', _319 => _319.categoryAxis, 'optionalAccess', _320 => _320.min]) === "number" && Number.isFinite(chart.categoryAxis.min);
+  const hasExplicitMaxX = typeof _optionalChain([chart, 'access', _321 => _321.categoryAxis, 'optionalAccess', _322 => _322.max]) === "number" && Number.isFinite(chart.categoryAxis.max);
+  const hasExplicitMinY = typeof _optionalChain([chart, 'access', _323 => _323.valueAxis, 'optionalAccess', _324 => _324.min]) === "number" && Number.isFinite(chart.valueAxis.min);
+  const hasExplicitMaxY = typeof _optionalChain([chart, 'access', _325 => _325.valueAxis, 'optionalAccess', _326 => _326.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', _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);
+  let minX = hasExplicitMinX ? Number(_optionalChain([chart, 'access', _327 => _327.categoryAxis, 'optionalAccess', _328 => _328.min])) : Math.min(...allX);
+  let maxX = hasExplicitMaxX ? Number(_optionalChain([chart, 'access', _329 => _329.categoryAxis, 'optionalAccess', _330 => _330.max])) : Math.max(...allX);
+  let minY = hasExplicitMinY ? Number(_optionalChain([chart, 'access', _331 => _331.valueAxis, 'optionalAccess', _332 => _332.min])) : Math.min(...allY);
+  let maxY = hasExplicitMaxY ? Number(_optionalChain([chart, 'access', _333 => _333.valueAxis, 'optionalAccess', _334 => _334.max])) : Math.max(...allY);
   if (!hasExplicitMinX) {
-    minX = hasSyntheticIndexAxis ? 0 : _optionalChain([chart, 'access', _345 => _345.categoryAxis, 'optionalAccess', _346 => _346.crosses]) === "autoZero" ? Math.min(0, minX) : minX;
+    minX = hasSyntheticIndexAxis ? 0 : _optionalChain([chart, 'access', _335 => _335.categoryAxis, 'optionalAccess', _336 => _336.crosses]) === "autoZero" ? Math.min(0, minX) : minX;
   }
   if (!hasExplicitMaxX) {
-    maxX = hasSyntheticIndexAxis ? Math.max(maxX, syntheticPointCount + 1) : _optionalChain([chart, 'access', _347 => _347.categoryAxis, 'optionalAccess', _348 => _348.crosses]) === "autoZero" ? Math.max(0, maxX) : maxX;
+    maxX = hasSyntheticIndexAxis ? Math.max(maxX, syntheticPointCount + 1) : _optionalChain([chart, 'access', _337 => _337.categoryAxis, 'optionalAccess', _338 => _338.crosses]) === "autoZero" ? Math.max(0, maxX) : maxX;
   }
-  if (!hasExplicitMinY && _optionalChain([chart, 'access', _349 => _349.valueAxis, 'optionalAccess', _350 => _350.crosses]) === "autoZero") {
+  if (!hasExplicitMinY && _optionalChain([chart, 'access', _339 => _339.valueAxis, 'optionalAccess', _340 => _340.crosses]) === "autoZero") {
     minY = Math.min(0, minY);
   }
-  if (!hasExplicitMaxY && _optionalChain([chart, 'access', _351 => _351.valueAxis, 'optionalAccess', _352 => _352.crosses]) === "autoZero") {
+  if (!hasExplicitMaxY && _optionalChain([chart, 'access', _341 => _341.valueAxis, 'optionalAccess', _342 => _342.crosses]) === "autoZero") {
     maxY = Math.max(0, maxY);
   }
   if (maxX <= minX) {
@@ -3069,8 +3103,8 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
   if (maxY <= minY) {
     maxY = minY + 1;
   }
-  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);
+  const xStep = typeof _optionalChain([chart, 'access', _343 => _343.categoryAxis, 'optionalAccess', _344 => _344.majorUnit]) === "number" && chart.categoryAxis.majorUnit > 0 ? chart.categoryAxis.majorUnit : buildNiceStep(minX, maxX, 5);
+  const yStep = typeof _optionalChain([chart, 'access', _345 => _345.valueAxis, 'optionalAccess', _346 => _346.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;
   }
@@ -3085,10 +3119,10 @@ function renderScatterChart(chart, palette, layout, smooth, selectedChartElement
   }
   const safeMaxX = maxX <= minX ? minX + 1 : maxX;
   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', _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 xScale = linearScale([minX, safeMaxX], [plot.left, plot.left + plot.width]);
+  const yScale = linearScale([minY, safeMaxY], [plot.top + plot.height, plot.top]);
+  const xMajorUnit = typeof _optionalChain([chart, 'access', _347 => _347.categoryAxis, 'optionalAccess', _348 => _348.majorUnit]) === "number" && chart.categoryAxis.majorUnit > 0 ? chart.categoryAxis.majorUnit : hasSyntheticIndexAxis ? 1 : void 0;
+  const yMajorUnit = typeof _optionalChain([chart, 'access', _349 => _349.valueAxis, 'optionalAccess', _350 => _350.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));
@@ -3154,7 +3188,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', _361 => _361.shapeProperties, 'optionalAccess', _362 => _362.xmlLineHidden]) !== true && seriesPoints.points.length > 1;
+      const shouldDrawLine = styleDrawsLine && _optionalChain([series, 'access', _351 => _351.shapeProperties, 'optionalAccess', _352 => _352.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), () => ( "")) : "";
@@ -3193,7 +3227,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', _363 => _363.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
+        seriesPoints.points.map((point, pointIndex) => isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _353 => _353.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
           `scatter-selection-${seriesIndex}-${pointIndex}`,
           [{ x: xScale(point.x), y: yScale(point.y) }]
         ) : null)
@@ -3206,7 +3240,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', _364 => _364.bubbleSizes, 'optionalAccess', _365 => _365[index]]));
+    const bubble = safeNumber(_optionalChain([series, 'access', _354 => _354.bubbleSizes, 'optionalAccess', _355 => _355[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));
@@ -3225,7 +3259,7 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
   const bubbleScaleFactor = clamp((_nullishCoalesce(chart.bubbleScale, () => ( 100))) / 100, 0.2, 4);
   const minRadius = 4;
   const maxRadius = Math.max(minRadius + 2, 12 * bubbleScaleFactor);
-  const radiusScale = _d3scale.scaleLinear.call(void 0, ).domain([minBubbleMagnitude, maxBubbleMagnitude <= minBubbleMagnitude ? minBubbleMagnitude + 1 : maxBubbleMagnitude]).range([minRadius, maxRadius]);
+  const radiusScale = linearScale([minBubbleMagnitude, maxBubbleMagnitude <= minBubbleMagnitude ? minBubbleMagnitude + 1 : maxBubbleMagnitude], [minRadius, maxRadius]);
   const safeMaxX = maxX <= minX ? minX + 1 : maxX;
   const safeMaxY = maxY <= minY ? minY + 1 : maxY;
   const xSpan = safeMaxX - minX;
@@ -3236,23 +3270,23 @@ function renderBubbleChart(chart, palette, layout, selectedChartElement) {
     chart.categoryAxis,
     minX - xPad,
     safeMaxX + xPad,
-    _optionalChain([chart, 'access', _366 => _366.categoryAxis, 'optionalAccess', _367 => _367.crosses]) === "autoZero"
+    _optionalChain([chart, 'access', _356 => _356.categoryAxis, 'optionalAccess', _357 => _357.crosses]) === "autoZero"
   );
   const yDomain = resolveAxisDomainWithChartOverrides(
     chart.valueAxis,
     minY - yPad,
     safeMaxY + yPad,
-    _optionalChain([chart, 'access', _368 => _368.valueAxis, 'optionalAccess', _369 => _369.crosses]) === "autoZero"
+    _optionalChain([chart, 'access', _358 => _358.valueAxis, 'optionalAccess', _359 => _359.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]);
+  const xScale = linearScale([xDomain.min, xDomain.max], [plot.left, plot.left + plot.width]);
+  const yScale = linearScale([yDomain.min, yDomain.max], [plot.top + plot.height, plot.top]);
   const xTicks = xDomain.ticks;
   const yTicks = yDomain.ticks;
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const labelColor = resolveChartAxisTextColor(chart);
   const isBubble3d = chart.bubble3d === true || chart.is3d === true;
   const labelsEnabled = Boolean(
-    _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])
+    _optionalChain([chart, 'access', _360 => _360.dataLabels, 'optionalAccess', _361 => _361.showCategoryName]) || _optionalChain([chart, 'access', _362 => _362.dataLabels, 'optionalAccess', _363 => _363.showSeriesName]) || _optionalChain([chart, 'access', _364 => _364.dataLabels, 'optionalAccess', _365 => _365.showValue]) || _optionalChain([chart, 'access', _366 => _366.dataLabels, 'optionalAccess', _367 => _367.showBubbleSize]) || _optionalChain([chart, 'access', _368 => _368.dataLabels, 'optionalAccess', _369 => _369.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: [
@@ -3288,9 +3322,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', _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) })
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "0%", stopColor: lightenColor(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _370 => _370.series, 'access', _371 => _371[seriesIndex], 'optionalAccess', _372 => _372.color]), () => ( _optionalChain([chart, 'access', _373 => _373.series, 'access', _374 => _374[seriesIndex], 'optionalAccess', _375 => _375.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))), 0.42) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "58%", stopColor: _nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _376 => _376.series, 'access', _377 => _377[seriesIndex], 'optionalAccess', _378 => _378.color]), () => ( _optionalChain([chart, 'access', _379 => _379.series, 'access', _380 => _380[seriesIndex], 'optionalAccess', _381 => _381.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex))) }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "100%", stopColor: darkenColor(_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.18) })
       ] }) }) : null,
       [...points].sort((left, right) => {
         if (left.bubble !== right.bubble) {
@@ -3299,22 +3333,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', _398 => _398.color]), () => ( _optionalChain([series, 'optionalAccess', _399 => _399.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex)));
+        const baseColor = _nullishCoalesce(_nullishCoalesce(_optionalChain([series, 'optionalAccess', _388 => _388.color]), () => ( _optionalChain([series, 'optionalAccess', _389 => _389.lineColor]))), () => ( chartSeriesColor(chart, seriesIndex)));
         const radius = radiusScale(Math.sqrt(Math.max(0, point.bubble)));
         const pieces = [];
-        if (_optionalChain([chart, 'access', _400 => _400.dataLabels, 'optionalAccess', _401 => _401.showSeriesName]) && _optionalChain([series, 'optionalAccess', _402 => _402.name])) {
+        if (_optionalChain([chart, 'access', _390 => _390.dataLabels, 'optionalAccess', _391 => _391.showSeriesName]) && _optionalChain([series, 'optionalAccess', _392 => _392.name])) {
           pieces.push(series.name);
         }
-        if (_optionalChain([chart, 'access', _403 => _403.dataLabels, 'optionalAccess', _404 => _404.showCategoryName])) {
+        if (_optionalChain([chart, 'access', _393 => _393.dataLabels, 'optionalAccess', _394 => _394.showCategoryName])) {
           pieces.push(formatTickValue(point.x));
         }
-        if (_optionalChain([chart, 'access', _405 => _405.dataLabels, 'optionalAccess', _406 => _406.showValue])) {
+        if (_optionalChain([chart, 'access', _395 => _395.dataLabels, 'optionalAccess', _396 => _396.showValue])) {
           pieces.push(formatTickValue(point.y));
         }
-        if (_optionalChain([chart, 'access', _407 => _407.dataLabels, 'optionalAccess', _408 => _408.showBubbleSize])) {
+        if (_optionalChain([chart, 'access', _397 => _397.dataLabels, 'optionalAccess', _398 => _398.showBubbleSize])) {
           pieces.push(formatTickValue(point.bubble));
         }
-        if (_optionalChain([chart, 'access', _409 => _409.dataLabels, 'optionalAccess', _410 => _410.showPercent])) {
+        if (_optionalChain([chart, 'access', _399 => _399.dataLabels, 'optionalAccess', _400 => _400.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: [
@@ -3331,7 +3365,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', _411 => _411.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
+          isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, point.index) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _401 => _401.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionRectHandles.call(void 0, 
             `bubble-selection-${seriesIndex}-${point.index}`,
             xScale(point.x) - radius,
             yScale(point.y) - radius,
@@ -3378,22 +3412,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', _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") {
+  const hasExplicitMin = typeof _optionalChain([chart, 'access', _402 => _402.valueAxis, 'optionalAccess', _403 => _403.min]) === "number" && Number.isFinite(chart.valueAxis.min);
+  const hasExplicitMax = typeof _optionalChain([chart, 'access', _404 => _404.valueAxis, 'optionalAccess', _405 => _405.max]) === "number" && Number.isFinite(chart.valueAxis.max);
+  let minValue = hasExplicitMin ? Number(_optionalChain([chart, 'access', _406 => _406.valueAxis, 'optionalAccess', _407 => _407.min])) : Math.min(0, ...values.length ? values : [0]);
+  let maxValue = hasExplicitMax ? Number(_optionalChain([chart, 'access', _408 => _408.valueAxis, 'optionalAccess', _409 => _409.max])) : Math.max(1, ...values.length ? values : [1]);
+  if (_optionalChain([chart, 'access', _410 => _410.valueAxis, 'optionalAccess', _411 => _411.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', _422 => _422.valueAxis, 'optionalAccess', _423 => _423.majorUnit]) === "number" && chart.valueAxis.majorUnit > 0 ? chart.valueAxis.majorUnit : void 0;
+  const candidateMajorUnit = typeof _optionalChain([chart, 'access', _412 => _412.valueAxis, 'optionalAccess', _413 => _413.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', _424 => _424.categoryAxis, 'optionalAccess', _425 => _425.majorGridlines]) === true;
+  const showSpokes = _optionalChain([chart, 'access', _414 => _414.categoryAxis, 'optionalAccess', _415 => _415.majorGridlines]) === true;
   const angleAt = (index) => Math.PI * 2 * index / categories.length - Math.PI / 2;
   const radialPoint = (index, valueRatio) => {
     const angle = angleAt(index);
@@ -3495,7 +3529,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', _426 => _426.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
+        definedPoints.map((point) => isSelectedChartPoint(selectedChartElement, chart.id, seriesIndex, point.pointIndex) || isSelectedChartSeries(selectedChartElement, chart.id, seriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _416 => _416.kind]) !== "point" ? _chunkIDNIGBUMcjs.renderSelectionPointHandles.call(void 0, 
           `radar-selection-${seriesIndex}-${point.pointIndex}`,
           [{ x: point.x, y: point.y }]
         ) : null)
@@ -3520,14 +3554,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', _427 => _427.view3d, 'optionalAccess', _428 => _428.rotX]), () => ( 20));
-  const perspective = _nullishCoalesce(_optionalChain([chart, 'access', _429 => _429.view3d, 'optionalAccess', _430 => _430.perspective]), () => ( 30));
+  const rotX = _nullishCoalesce(_optionalChain([chart, 'access', _417 => _417.view3d, 'optionalAccess', _418 => _418.rotX]), () => ( 20));
+  const perspective = _nullishCoalesce(_optionalChain([chart, 'access', _419 => _419.view3d, 'optionalAccess', _420 => _420.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', _431 => _431.view3d, 'optionalAccess', _432 => _432.depthPercent]), () => ( 100))) / 100;
+  const depthScale = (_nullishCoalesce(_optionalChain([chart, 'access', _421 => _421.view3d, 'optionalAccess', _422 => _422.depthPercent]), () => ( 100))) / 100;
   const depth = isPie3d ? Math.max(9, outerRadius * 0.28 * depthScale) : 0;
-  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 dataLabelsEnabled = Boolean(_optionalChain([chart, 'access', _423 => _423.dataLabels, 'optionalAccess', _424 => _424.showCategoryName]) || _optionalChain([chart, 'access', _425 => _425.dataLabels, 'optionalAccess', _426 => _426.showPercent]) || _optionalChain([chart, 'access', _427 => _427.dataLabels, 'optionalAccess', _428 => _428.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, "-");
@@ -3538,8 +3572,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', _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 pointLabelByIndex = new Map((_nullishCoalesce(_optionalChain([chart, 'access', _429 => _429.dataLabels, 'optionalAccess', _430 => _430.pointLabels]), () => ( []))).map((label) => [label.index, label]));
+  const centerValuePointLabel = chartType === "Doughnut" ? _nullishCoalesce((_nullishCoalesce(_optionalChain([chart, 'access', _431 => _431.dataLabels, 'optionalAccess', _432 => _432.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;
@@ -3548,13 +3582,13 @@ function renderPieChart(chart, palette, layout, chartType, selectedChartElement)
     14,
     Math.min(
       Math.max(20, innerRadius * 0.72),
-      (_nullishCoalesce(_optionalChain([centerValuePointLabel, 'optionalAccess', _443 => _443.fontSizePt]), () => ( 28))) * 0.85
+      (_nullishCoalesce(_optionalChain([centerValuePointLabel, 'optionalAccess', _433 => _433.fontSizePt]), () => ( 28))) * 0.85
     )
   ) : 0;
   const resolveSliceExplosion = (pointIndex) => {
-    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)));
+    const pointStyle = _optionalChain([pieSeries, 'optionalAccess', _434 => _434.dataPointStyles, 'optionalAccess', _435 => _435.find, 'call', _436 => _436((entry) => entry.index === pointIndex)]);
+    const seriesExplosion = typeof _optionalChain([pieSeries, 'optionalAccess', _437 => _437.shapeProperties, 'optionalAccess', _438 => _438.xmlExplosion]) === "number" ? pieSeries.shapeProperties.xmlExplosion : 0;
+    const rawExplosion = Math.max(0, _nullishCoalesce(_nullishCoalesce(_optionalChain([pointStyle, 'optionalAccess', _439 => _439.explosion]), () => ( seriesExplosion)), () => ( 0)));
     if (rawExplosion <= 0) {
       return 0;
     }
@@ -3655,7 +3689,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', _450 => _450.kind]) !== "point";
+      const isSliceSelected = isSelectedChartPoint(selectedChartElement, chart.id, pieSeriesIndex, arc.data.index) || isSelectedChartSeries(selectedChartElement, chart.id, pieSeriesIndex) && _optionalChain([selectedChartElement, 'optionalAccess', _440 => _440.kind]) !== "point";
       const sliceHandlePoints = isSliceSelected ? [
         pieEllipsePoint(centerX, centerY, outerRadius, isPie3d ? tilt : 1, arc.startAngle),
         pieEllipsePoint(centerX, centerY, outerRadius, isPie3d ? tilt : 1, midAngle),
@@ -3669,12 +3703,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', _451 => _451.dataLabels, 'optionalAccess', _452 => _452.showCategoryName]) && arc.data.label.trim().length > 0) {
+      if (_optionalChain([chart, 'access', _441 => _441.dataLabels, 'optionalAccess', _442 => _442.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', _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])));
+      const showValue = _nullishCoalesce(_optionalChain([pointLabel, 'optionalAccess', _443 => _443.showValue]), () => ( _optionalChain([chart, 'access', _444 => _444.dataLabels, 'optionalAccess', _445 => _445.showValue])));
+      const showPercent = _nullishCoalesce(_optionalChain([pointLabel, 'optionalAccess', _446 => _446.showPercent]), () => ( _optionalChain([chart, 'access', _447 => _447.dataLabels, 'optionalAccess', _448 => _448.showPercent])));
       if (showValue) {
         pieces.push(formatTickValue(arc.data.value));
       }
@@ -3739,7 +3773,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', _459 => _459.values, 'access', _460 => _460.map, 'call', _461 => _461((value) => Math.max(0, _nullishCoalesce(safeNumber(value), () => ( 0))))]), () => ( []));
+  const values = _nullishCoalesce(_optionalChain([pieSeries, 'optionalAccess', _449 => _449.values, 'access', _450 => _450.map, 'call', _451 => _451((value) => Math.max(0, _nullishCoalesce(safeNumber(value), () => ( 0))))]), () => ( []));
   if (values.length === 0) {
     return null;
   }
@@ -3904,24 +3938,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', _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 ratios = _chunkO3V2MCOCcjs.surfaceDataRatios.call(void 0, rows, cols, _optionalChain([chart, 'access', _452 => _452.valueAxis, 'optionalAccess', _453 => _453.crossBetween]) !== "midCat", _optionalChain([chart, 'access', _454 => _454.view3d, 'optionalAccess', _455 => _455.heightPercent]), _optionalChain([chart, 'access', _456 => _456.view3d, 'optionalAccess', _457 => _457.depthPercent]), layout);
   const minValue = domain.minValue;
   const safeMax = domain.safeMax;
-  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))))));
+  const wallFill = _nullishCoalesce(_optionalChain([chart, 'access', _458 => _458.backWall, 'optionalAccess', _459 => _459.fillColor]), () => ( "#d9d9df"));
+  const wallLineColor = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([chart, 'access', _460 => _460.backWall, 'optionalAccess', _461 => _461.lineColor]), () => ( _optionalChain([chart, 'access', _462 => _462.sideWall, 'optionalAccess', _463 => _463.lineColor]))), () => ( _optionalChain([chart, 'access', _464 => _464.floor, 'optionalAccess', _465 => _465.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', _476 => _476.view3d, 'optionalAccess', _477 => _477.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _478 => _478.view3d, 'optionalAccess', _479 => _479.rotY]), () => ( 0)));
+    const backgroundNormal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, { x: 0, y: 1, z: 0 }, _nullishCoalesce(_optionalChain([chart, 'access', _466 => _466.view3d, 'optionalAccess', _467 => _467.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _468 => _468.view3d, 'optionalAccess', _469 => _469.rotY]), () => ( 0)));
     const backgroundFill = chart.surfaceMaterial === "flat" ? wallFill : _chunkO3V2MCOCcjs.shadeSurfaceMatteColor.call(void 0, wallFill, backgroundNormal);
-    const inset = _optionalChain([chart, 'access', _480 => _480.valueAxis, 'optionalAccess', _481 => _481.crossBetween]) !== "midCat" ? plot.width / (2 * cols) : 0;
+    const inset = _optionalChain([chart, 'access', _470 => _470.valueAxis, 'optionalAccess', _471 => _471.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', _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]]);
+        const p00 = _optionalChain([matrix, 'access', _472 => _472[rowIndex], 'optionalAccess', _473 => _473[columnIndex]]);
+        const p10 = _optionalChain([matrix, 'access', _474 => _474[rowIndex], 'optionalAccess', _475 => _475[columnIndex + 1]]);
+        const p01 = _optionalChain([matrix, 'access', _476 => _476[rowIndex + 1], 'optionalAccess', _477 => _477[columnIndex]]);
+        const p11 = _optionalChain([matrix, 'access', _478 => _478[rowIndex + 1], 'optionalAccess', _479 => _479[columnIndex + 1]]);
         if (p00 == null || p10 == null || p01 == null || p11 == null) {
           continue;
         }
@@ -3941,7 +3975,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', _490 => _490.view3d, 'optionalAccess', _491 => _491.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _492 => _492.view3d, 'optionalAccess', _493 => _493.rotY]), () => ( 0)));
+          const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _480 => _480.view3d, 'optionalAccess', _481 => _481.rotX]), () => ( 90)), _nullishCoalesce(_optionalChain([chart, 'access', _482 => _482.view3d, 'optionalAccess', _483 => _483.rotY]), () => ( 0)));
           for (let band = 0; band < domain.ticks.length - 1; band += 1) {
             const lower = domain.ticks[band];
             const upper = domain.ticks[band + 1];
@@ -3954,7 +3988,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', _494 => _494.raw, 'optionalAccess', _495 => _495.bandFormatLineWidths]);
+            const widths = _optionalChain([chart, 'access', _484 => _484.raw, 'optionalAccess', _485 => _485.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(
@@ -3964,7 +3998,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', _496 => _496[group.band]]), () => ( _optionalChain([chart, 'access', _497 => _497.series, 'access', _498 => _498[0], 'optionalAccess', _499 => _499.lineWidthPx]))), () => ( 1))
+                    strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([widths, 'optionalAccess', _486 => _486[group.band]]), () => ( _optionalChain([chart, 'access', _487 => _487.series, 'access', _488 => _488[0], 'optionalAccess', _489 => _489.lineWidthPx]))), () => ( 1))
                   },
                   `surface-edge-${key}-${group.band}`
                 )
@@ -3978,12 +4012,12 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
       /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
         "rect",
         {
-          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,
+          fill: _optionalChain([chart, 'access', _490 => _490.raw, 'optionalAccess', _491 => _491.plotAreaNoFill]) === true ? "transparent" : typeof _optionalChain([chart, 'access', _492 => _492.raw, 'optionalAccess', _493 => _493.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', _504 => _504.raw, 'optionalAccess', _505 => _505.plotAreaLineColor]) === "string" ? chart.raw.plotAreaLineColor : wallLineColor
+          stroke: typeof _optionalChain([chart, 'access', _494 => _494.raw, 'optionalAccess', _495 => _495.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 }),
@@ -3991,11 +4025,11 @@ function renderSurfaceChart(chart, palette, layout, selectedChartElement) {
       lines
     ] });
   }
-  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 rotX = (_nullishCoalesce(_optionalChain([chart, 'access', _496 => _496.view3d, 'optionalAccess', _497 => _497.rotX]), () => ( 25))) * (Math.PI / 180);
+  const rotY = (_nullishCoalesce(_optionalChain([chart, 'access', _498 => _498.view3d, 'optionalAccess', _499 => _499.rotY]), () => ( 30))) * (Math.PI / 180);
+  const usePerspective = _optionalChain([chart, 'access', _500 => _500.view3d, 'optionalAccess', _501 => _501.rAngAx]) === false;
   const perspectiveStrength = clamp(
-    (_nullishCoalesce(_optionalChain([chart, 'access', _512 => _512.view3d, 'optionalAccess', _513 => _513.perspective]), () => ( (usePerspective ? 30 : 0)))) / 100,
+    (_nullishCoalesce(_optionalChain([chart, 'access', _502 => _502.view3d, 'optionalAccess', _503 => _503.perspective]), () => ( (usePerspective ? 30 : 0)))) / 100,
     0,
     1
   );
@@ -4010,7 +4044,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', _514 => _514.view3d, 'optionalAccess', _515 => _515.rAngAx]) !== false) {
+    if (_optionalChain([chart, 'access', _504 => _504.view3d, 'optionalAccess', _505 => _505.rAngAx]) !== false) {
       return {
         depth: normalizedZ,
         hasValue,
@@ -4048,7 +4082,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', _516 => _516.view3d, 'optionalAccess', _517 => _517.rAngAx]) !== false || cosX * cosY >= 0 ? rows - 1 : 0;
+  const backRow = _optionalChain([chart, 'access', _506 => _506.view3d, 'optionalAccess', _507 => _507.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) => {
@@ -4058,18 +4092,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', _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 normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _508 => _508.view3d, 'optionalAccess', _509 => _509.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _510 => _510.view3d, 'optionalAccess', _511 => _511.rotY]), () => ( 30)), _optionalChain([chart, 'access', _512 => _512.view3d, 'optionalAccess', _513 => _513.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', _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])) {
+  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', _514 => _514.floor, 'optionalAccess', _515 => _515.fillColor]), _optionalChain([chart, 'access', _516 => _516.floor, 'optionalAccess', _517 => _517.hidden]));
+  addWall("back", [wallPoint(0, backRow, safeMax), wallPoint(cols - 1, backRow, safeMax), wallPoint(cols - 1, backRow, minValue), wallPoint(0, backRow, minValue)], _optionalChain([chart, 'access', _518 => _518.backWall, 'optionalAccess', _519 => _519.fillColor]), _optionalChain([chart, 'access', _520 => _520.backWall, 'optionalAccess', _521 => _521.hidden]));
+  addWall("side", [wallPoint(sideColumn, 0, safeMax), wallPoint(sideColumn, rows - 1, safeMax), wallPoint(sideColumn, rows - 1, minValue), wallPoint(sideColumn, 0, minValue)], _optionalChain([chart, 'access', _522 => _522.sideWall, 'optionalAccess', _523 => _523.fillColor]), _optionalChain([chart, 'access', _524 => _524.sideWall, 'optionalAccess', _525 => _525.hidden]));
+  if (_optionalChain([chart, 'access', _526 => _526.valueAxis, 'optionalAccess', _527 => _527.majorGridlines])) {
     for (const tick of domain.ticks) {
       const edges = [
-        ..._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)]]
+        ..._optionalChain([chart, 'access', _528 => _528.backWall, 'optionalAccess', _529 => _529.hidden]) ? [] : [[wallPoint(0, backRow, tick), wallPoint(cols - 1, backRow, tick)]],
+        ..._optionalChain([chart, 'access', _530 => _530.sideWall, 'optionalAccess', _531 => _531.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);
@@ -4094,7 +4128,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', _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);
+        const normal = _chunkO3V2MCOCcjs.transformSurfaceNormal.call(void 0, _chunkO3V2MCOCcjs.surfaceNormal.call(void 0, world[0], world[1], world[2]), _nullishCoalesce(_optionalChain([chart, 'access', _532 => _532.view3d, 'optionalAccess', _533 => _533.rotX]), () => ( 25)), _nullishCoalesce(_optionalChain([chart, 'access', _534 => _534.view3d, 'optionalAccess', _535 => _535.rotY]), () => ( 30)), _optionalChain([chart, 'access', _536 => _536.view3d, 'optionalAccess', _537 => _537.rAngAx]) !== false);
         for (let band = 0; band < domain.ticks.length - 1; band += 1) {
           const lower = domain.ticks[band];
           const upper = domain.ticks[band + 1];
@@ -4102,7 +4136,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', _548 => _548.raw, 'optionalAccess', _549 => _549.bandFormatLineWidths]);
+          const widths = _optionalChain([chart, 'access', _538 => _538.raw, 'optionalAccess', _539 => _539.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,
@@ -4111,7 +4145,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', _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}`);
+                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { fill: "none", stroke: resolveSurfaceWireframeColor(chart, palette, domain, edgeMidpoint), strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([widths, 'optionalAccess', _540 => _540[group.band]]), () => ( _optionalChain([chart, 'access', _541 => _541.series, 'access', _542 => _542[0], 'optionalAccess', _543 => _543.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}`)
           });
@@ -4175,7 +4209,12 @@ function renderWaterfallChart(chart, palette, layout, selectedChartElement) {
   }
   const plot = layout.plot;
   const labels = stages.map((stage) => stage.label);
-  const xScale = _d3scale.scaleBand.call(void 0, ).domain(labels).range([plot.left, plot.left + plot.width]).paddingInner(0.34).paddingOuter(0.18);
+  const xScale = bandScale(
+    labels,
+    [plot.left, plot.left + plot.width],
+    0.34,
+    0.18
+  );
   const bars = [];
   let runningTotal = 0;
   stages.forEach((stage, index) => {
@@ -4192,8 +4231,8 @@ function renderWaterfallChart(chart, palette, layout, selectedChartElement) {
   if (maxValue <= minValue) {
     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', _554 => _554.valueAxis, 'optionalAccess', _555 => _555.majorUnit]));
+  const yScale = linearScale([minValue, maxValue], [plot.top + plot.height, plot.top]);
+  const ticks = buildNumericTickValues(minValue, maxValue, _optionalChain([chart, 'access', _544 => _544.valueAxis, 'optionalAccess', _545 => _545.majorUnit]));
   const axisColor = _nullishCoalesce(_nullishCoalesce(chart.axisLineColor, () => ( chart.chartAreaBorderColor)), () => ( palette.border));
   const labelColor = resolveChartAxisTextColor(chart);
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
@@ -4215,7 +4254,7 @@ function renderWaterfallChart(chart, palette, layout, selectedChartElement) {
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "line", { stroke: axisColor, strokeWidth: 1.2, x1: plot.left, x2: plot.left + plot.width, y1: yScale(0), y2: yScale(0) }),
     bars.map((bar, index) => {
       const bandLeft = _nullishCoalesce(xScale(bar.label), () => ( plot.left));
-      const bandWidth = xScale.bandwidth();
+      const bandWidth = xScale.bandwidth;
       const topValue = Math.max(bar.start, bar.end);
       const bottomValue = Math.min(bar.start, bar.end);
       const top = yScale(topValue);
@@ -4231,7 +4270,7 @@ function renderWaterfallChart(chart, palette, layout, selectedChartElement) {
             stroke: lightenColor(axisColor, 0.35),
             strokeDasharray: "3 3",
             strokeWidth: 1,
-            x1: (_nullishCoalesce(xScale(connectorStart.label), () => ( plot.left))) + xScale.bandwidth(),
+            x1: (_nullishCoalesce(xScale(connectorStart.label), () => ( plot.left))) + xScale.bandwidth,
             x2: bandLeft,
             y1: connectorY,
             y2: connectorY
@@ -4467,8 +4506,8 @@ function renderBoxWhiskerChart(chart, palette, layout, selectedChartElement) {
   const minValue = Math.min(...allValues);
   const maxValue = Math.max(...allValues);
   const valueDomain = resolveAxisDomainWithChartOverrides(chart.valueAxis, minValue, maxValue, false);
-  const yScale = _d3scale.scaleLinear.call(void 0, ).domain([valueDomain.min, valueDomain.max]).range([layout.plot.top + layout.plot.height, layout.plot.top]);
-  const xScale = _d3scale.scalePoint.call(void 0, ).domain(seriesStats.map((_, index) => index)).range([layout.plot.left + 24, layout.plot.left + layout.plot.width - 24]);
+  const yScale = linearScale([valueDomain.min, valueDomain.max], [layout.plot.top + layout.plot.height, layout.plot.top]);
+  const xScale = pointScale(seriesStats.map((_, index) => index), [layout.plot.left + 24, layout.plot.left + layout.plot.width - 24]);
   const gap = seriesStats.length > 1 ? Math.abs((_nullishCoalesce(xScale(1), () => ( 0))) - (_nullishCoalesce(xScale(0), () => ( 0)))) : layout.plot.width * 0.5;
   const boxWidth = clamp(gap * 0.34, 20, 54);
   const capWidth = Math.max(8, boxWidth * 0.52);
@@ -4683,132 +4722,6 @@ function renderBoxWhiskerChart(chart, palette, layout, selectedChartElement) {
     })
   ] });
 }
-function renderRegionMapChart(chart, palette, layout, selectedChartElement, { geoIdentity, geoMercator, geoNaturalEarth1, geoPath, resolveRegionMapFeatureSet, resolveRegionMapFeature, getRegionMapBaseFeatures }) {
-  const primarySeriesIndex = Math.max(0, chart.series.findIndex((series) => series.hidden !== true));
-  const primarySeries = _nullishCoalesce(chart.series[primarySeriesIndex], () => ( null));
-  if (!primarySeries) {
-    return null;
-  }
-  const labels = getCategoryLabels(chart);
-  const layoutProperties = resolveRegionMapLayoutProperties(primarySeries);
-  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', _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);
-  const categoricalColorByLabel = categoricalValues ? new Map(
-    Array.from(new Set(categoricalValues.filter(Boolean))).map((value, index) => [
-      value,
-      chartPointColor(chart, index, primarySeriesIndex)
-    ])
-  ) : null;
-  const entries = labels.map((label, index) => {
-    const feature = resolveRegionMapFeature(label, featureSet);
-    const value = safeNumber(primarySeries.values[index]);
-    const colorLabel = _optionalChain([categoricalValues, 'optionalAccess', _559 => _559[index]]) || null;
-    return {
-      colorLabel,
-      feature,
-      key: normalizeCategoryLabel(label),
-      label: normalizeCategoryLabel(label),
-      value
-    };
-  }).filter((entry) => entry.feature != null && (entry.value != null || entry.colorLabel != null));
-  const fitToMatchedData = entries.length > 0 && (viewedRegionType === "dataOnly" || entries.length === 1);
-  const fitFeatures = fitToMatchedData ? entries.map((entry) => entry.feature) : availableFeatures;
-  projection.fitExtent(
-    [
-      [layout.plot.left + 8, layout.plot.top + 8],
-      [layout.plot.left + layout.plot.width - 8, layout.plot.top + layout.plot.height - 8]
-    ],
-    {
-      type: "FeatureCollection",
-      features: fitFeatures
-    }
-  );
-  const path = geoPath(projection);
-  const baseFeatures = fitToMatchedData ? fitFeatures : availableFeatures;
-  const noDataFill = resolveRegionMapNoDataColor(chart, primarySeriesIndex);
-  const outlineColor = chart.chartAreaBorderColor && chart.chartAreaBorderColor !== "transparent" ? chart.chartAreaBorderColor : darkenColor(noDataFill, 0.22);
-  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', _560 => _560.regionLabelLayout]) !== "none";
-  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
-    baseFeatures.map((feature, index) => {
-      const d = path(feature);
-      if (!d) {
-        return null;
-      }
-      return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
-        "path",
-        {
-          d,
-          fill: noDataFill,
-          stroke: outlineColor,
-          strokeLinejoin: "round",
-          strokeWidth: 0.6
-        },
-        `region-map-base-${_nullishCoalesce(feature.id, () => ( "feature"))}-${index}`
-      );
-    }),
-    entries.map((entry, index) => {
-      const d = path(entry.feature);
-      if (!d) {
-        return null;
-      }
-      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', _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]);
-      return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, React.Fragment, { children: [
-        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
-          "path",
-          {
-            ...chartElementDataProps(primarySeriesIndex, index),
-            d,
-            fill,
-            stroke: selected ? "#64748b" : darkenColor(fill, 0.18),
-            strokeLinejoin: "round",
-            strokeWidth: selected ? 1.8 : 0.85
-          }
-        ),
-        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) => {
-      const bounds = path.bounds(entry.feature);
-      const [[x0, y0], [x1, y1]] = bounds;
-      const width = x1 - x0;
-      const height = y1 - y0;
-      if (!Number.isFinite(width) || !Number.isFinite(height) || width < 26 || height < 12) {
-        return null;
-      }
-      const centroid = path.centroid(entry.feature);
-      if (!Number.isFinite(centroid[0]) || !Number.isFinite(centroid[1])) {
-        return null;
-      }
-      return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
-        "text",
-        {
-          fill: resolveChartTextColor(chart),
-          fontSize: 9,
-          fontWeight: 600,
-          textAnchor: "middle",
-          x: centroid[0],
-          y: centroid[1],
-          children: truncateSvgText(entry.label, Math.max(28, width - 4), 9)
-        },
-        `region-map-label-${entry.key || index}`
-      );
-    }) : null
-  ] });
-}
 function renderUnsupported(chart, palette, layout, chartType) {
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
@@ -4889,7 +4802,7 @@ function renderChartPlot(chart, palette, layout, chartType, selectedChartElement
     return renderTreemapChart(chart, palette, layout, selectedChartElement);
   }
   if (chartType === "RegionMap") {
-    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, RegionMapPlot, { chart, layout, palette, selectedChartElement });
+    return renderUnsupported(chart, palette, layout, chartType);
   }
   return renderUnsupported(chart, palette, layout, chartType);
 }
@@ -4905,7 +4818,7 @@ 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', _563 => _563.chartAreaNoFill]) === true || _optionalChain([chartRaw, 'optionalAccess', _564 => _564.plotAreaNoFill]) === true;
+  const explicitNoFill = _optionalChain([chartRaw, 'optionalAccess', _546 => _546.chartAreaNoFill]) === true || _optionalChain([chartRaw, 'optionalAccess', _547 => _547.plotAreaNoFill]) === true;
   const background = _nullishCoalesce(chart.chartAreaFillColor, () => ( (explicitNoFill ? "transparent" : "#ffffff")));
   const borderColor = _nullishCoalesce(chart.chartAreaBorderColor, () => ( "transparent"));
   const normalizedBackground = background.trim().toLowerCase();
@@ -4922,6 +4835,7 @@ var MemoChartSvg = React.memo(function MemoChartSvg2({
     "svg",
     {
       "aria-label": _nullishCoalesce(_nullishCoalesce(chart.title, () => ( chart.name)), () => ( "Chart")),
+      "data-xlsx-chart-renderer": "legacy",
       onDoubleClick: handleDoubleClick,
       onPointerDown: handlePointerDown,
       role: "img",
@@ -4964,4 +4878,4 @@ var MemoChartSvg = React.memo(function MemoChartSvg2({
 
 
 exports.MemoChartSvg = MemoChartSvg;
-//# sourceMappingURL=chart-renderer-LGW4EH4M.cjs.map
+//# sourceMappingURL=chart-renderer-6CWSXOSC.cjs.map