@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-WY4AURRE.mjs

@@ -0,0 +1,2419 @@
+import { advanceCategoryLerp, initCategoryLerp, snapCategoryLerp, initTimeDomainLerp, initDomainLerp, initDomainLerpTickFade, snapDomainLerp, snapTimeDomainLerp, advanceDomainLerp, advanceTimeDomainLerp } from './chunk-KNDZP446.mjs';
+import { transformValues, computeStackBases, detectCartesianMode, computeWaterfallBases } from './chunk-WFTX4AQJ.mjs';
+import { renderCartesianOverlay } from './chunk-QQBXUDM4.mjs';
+import { computeBarDatasetTotals } from './chunk-7QQ6ETB4.mjs';
+import { calculateAxisSpace, calculateAxisLayout } from './chunk-ZTL2FQEW.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { getResponsiveTier, getAdaptiveDefaults, getAdaptiveTickCount } from './chunk-YBJ56XJS.mjs';
+import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
+import { computeCartesianDomain, selectGroupingInterval, groupTimeData, resolveIncludeZero, computeDomainContribution, mergeDomainContributions, expandScatterBubblePadding, expandDataLabelPadding, computeVisibleValues } from './chunk-22ST6YPP.mjs';
+import { collectItems } from './chunk-FFMT6OCO.mjs';
+import { measureTextWidth } from './chunk-XTVE4P3L.mjs';
+import { resolveFontSize, DEFAULT_GROUP_LABEL_FONT_SIZE, DEFAULT_TICK_FONT_SIZE, DEFAULT_DATA_LABEL_FONT_SIZE, DEFAULT_BRACKET_GAP, DEFAULT_BRACKET_DEPTH_LAYER_SIZE } from './chunk-NKUYIWAP.mjs';
+import { decimate } from './chunk-OWW3K55O.mjs';
+import { batchResolveRequired, batchResolveAccessor, FIELD_DEFAULTS, resolveAccessor, makeItemContext } from './chunk-O2X6FF45.mjs';
+import { generateNiceTicks, calculateNiceDomain, toTimestamp, generateTimeTicks, formatTimeTick, generateIntervalTicks, createBandScale, calculateNiceTimeDomain, MS, createOrdinalTimeScale, createOrdinalTimeBandAdapter, createTimeScale, createTimeBandAdapter, createVariwideBandScale, createLogScale, createLinearScale, calculateGroupedBarLayout, calculateNiceLogDomain } from './chunk-RQ3CKQOX.mjs';
+
+// src/cartesian/chart-area.ts
+function isLayoutCriticalFeature(type) {
+  return type.startsWith("axisGroup") || type === "stacking";
+}
+function computeNaturalAxisWidths(naturalArea, chartArea) {
+  return {
+    left: naturalArea.x - chartArea.x,
+    right: chartArea.x + chartArea.width - naturalArea.x - naturalArea.width
+  };
+}
+function needsAxisPadding(naturalArea, chartArea, maxWidths) {
+  const { left, right } = computeNaturalAxisWidths(naturalArea, chartArea);
+  return left < maxWidths.left || right < maxWidths.right;
+}
+function estimateStackedValueDomain(perDataset, distinctStackIds, tickCount, exactTickCount, includeZero) {
+  if (perDataset.length === 0) return null;
+  const series = perDataset.map((d) => ({
+    values: d.values,
+    categories: d.categoryField ? batchResolveRequired(d.categoryField, d.data, "categoryField") : d.values.map((_, i) => String(i)),
+    stackId: d.stackId
+  }));
+  const catIndex = /* @__PURE__ */ new Map();
+  for (const d of series) {
+    for (const c of d.categories) {
+      if (!catIndex.has(c)) catIndex.set(c, catIndex.size);
+    }
+  }
+  const categoryCount = Math.max(1, catIndex.size);
+  const align = (d) => {
+    const arr = new Array(categoryCount).fill(0);
+    for (let i = 0; i < d.values.length; i++) {
+      const ci = catIndex.get(d.categories[i] ?? String(i));
+      const v = d.values[i];
+      if (ci !== void 0 && typeof v === "number" && !Number.isNaN(v)) arr[ci] += v;
+    }
+    return arr;
+  };
+  if (distinctStackIds > 1) {
+    const groupSums = /* @__PURE__ */ new Map();
+    for (const d of series) {
+      const sid = d.stackId ?? "";
+      const sums = groupSums.get(sid) ?? new Array(categoryCount).fill(0);
+      const aligned = align(d);
+      for (let c = 0; c < categoryCount; c++) sums[c] += aligned[c];
+      groupSums.set(sid, sums);
+    }
+    const synthetic = [...groupSums.values()];
+    return computeCartesianDomain({
+      valuesPerDataset: synthetic,
+      visibleMask: synthetic.map(() => true),
+      categoryCount,
+      mode: { isStacked: false, isWaterfall: false, isPercentStacked: false },
+      tickCount,
+      exactTickCount,
+      includeZero
+    });
+  }
+  const valuesPerDataset = series.map(align);
+  return computeCartesianDomain({
+    valuesPerDataset,
+    visibleMask: valuesPerDataset.map(() => true),
+    categoryCount,
+    mode: { isStacked: true, isWaterfall: false, isPercentStacked: false },
+    tickCount,
+    exactTickCount,
+    includeZero
+  });
+}
+function calculateCartesianArea(outerArea, axes, datasets, features, globalFont, locale, renderersByType, minPadding) {
+  let orientation = "vertical";
+  for (const [, dataset] of datasets) {
+    if (dataset.type === "bar") {
+      orientation = dataset.props.orientation ?? "vertical";
+      break;
+    }
+  }
+  let groupLabelSpace = 0;
+  const categoryAxisGroupDefs = [];
+  const valueRangeGroupDefs = [];
+  for (const [key, feature] of features) {
+    const k = key;
+    if (k.startsWith("axisGroup:")) {
+      const props = feature.props;
+      const isCategoryAxis = orientation === "vertical" && k.startsWith("axisGroup:x") || orientation === "horizontal" && k.startsWith("axisGroup:y");
+      const isValueAxis = orientation === "vertical" && k.startsWith("axisGroup:y") || orientation === "horizontal" && k.startsWith("axisGroup:x");
+      if (isCategoryAxis) {
+        categoryAxisGroupDefs.push(...props.groups.filter((g) => g.categories && g.categories.length > 0));
+      }
+      if (isValueAxis) {
+        valueRangeGroupDefs.push(...props.groups.filter((g) => g.range !== void 0));
+      }
+    }
+  }
+  const legacyAxisGroup = features.get("axisGroup")?.props;
+  if (legacyAxisGroup && categoryAxisGroupDefs.length === 0) {
+    categoryAxisGroupDefs.push(...legacyAxisGroup.groups.filter((g) => g.categories && g.categories.length > 0));
+  }
+  if (categoryAxisGroupDefs.length > 0) {
+    const depthLevels = new Set(categoryAxisGroupDefs.map((g) => g.depth ?? 0)).size;
+    if (orientation === "horizontal") {
+      const resolvedGroupFontSize = resolveFontSize(DEFAULT_GROUP_LABEL_FONT_SIZE, globalFont);
+      let maxWidth = 0;
+      for (const g of categoryAxisGroupDefs) {
+        const w = measureTextWidth(g.label, g.labelStyle?.fontSize ?? resolvedGroupFontSize);
+        if (w > maxWidth) maxWidth = w;
+      }
+      groupLabelSpace = (maxWidth + 16) * depthLevels;
+    } else {
+      groupLabelSpace = 24 * depthLevels;
+    }
+  }
+  let rangeLabelSpace = 0;
+  if (valueRangeGroupDefs.length > 0) {
+    if (orientation === "vertical") {
+      const resolvedGroupFontSize = resolveFontSize(DEFAULT_GROUP_LABEL_FONT_SIZE, globalFont);
+      let maxWidth = 0;
+      for (const r of valueRangeGroupDefs) {
+        const w = measureTextWidth(r.label, r.labelStyle?.fontSize ?? resolvedGroupFontSize);
+        if (w > maxWidth) maxWidth = w;
+      }
+      rangeLabelSpace = maxWidth + 16;
+    } else {
+      rangeLabelSpace = 24;
+    }
+  }
+  let leftTotal = 0;
+  let rightTotal = 0;
+  let topTotal = 0;
+  let bottomTotal = 0;
+  let xEdgeLeft = 0;
+  let xEdgeRight = 0;
+  const stackingCfg = features.get("stacking")?.props;
+  const isPctStacking = stackingCfg?.mode === "percent";
+  const hasWaterfall = features.has("waterfall");
+  const firstYAxisId = axes.y.size > 0 ? axes.y.keys().next().value : void 0;
+  for (const [yAxisId, yAxisConfig] of axes.y) {
+    const yAxisProps = yAxisConfig.props;
+    const yPos = yAxisProps?.position ?? "left";
+    let yTickLabels;
+    if (orientation === "horizontal") {
+      for (const [, dataset] of datasets) {
+        if (!dataset.props.categoryField || !Array.isArray(dataset.props.data)) continue;
+        yTickLabels = batchResolveRequired(dataset.props.categoryField, dataset.props.data, "categoryField");
+        break;
+      }
+    } else {
+      if (isPctStacking) {
+        const tickCount = yAxisProps?.tickCount ?? 5;
+        const ticks = generateNiceTicks(0, 100, tickCount, yAxisProps?.tickCount !== void 0);
+        yTickLabels = ticks.map((v) => `${v}%`);
+      } else {
+        const allValues = [];
+        const perDatasetValues = [];
+        const valueDatasets = [];
+        const stackIdSet = /* @__PURE__ */ new Set();
+        for (const [, dataset] of datasets) {
+          if (!Array.isArray(dataset.props.data)) continue;
+          const targetId = dataset.props.yAxisId ?? firstYAxisId;
+          if (targetId !== yAxisId) continue;
+          const r = renderersByType?.get(dataset.type);
+          if (r?.getAxisHints) {
+            const hints = r.getAxisHints(dataset.props, dataset.props.data);
+            if (hints.domainValues?.length) {
+              for (const v of hints.domainValues) allValues.push(v);
+              perDatasetValues.push(hints.domainValues);
+              continue;
+            }
+          }
+          if (dataset.props.valueField) {
+            const values = batchResolveRequired(dataset.props.valueField, dataset.props.data, "valueField");
+            for (const v of values) allValues.push(v);
+            perDatasetValues.push(values);
+            const sid = dataset.props.stackId;
+            valueDatasets.push({ data: dataset.props.data, categoryField: dataset.props.categoryField, values, stackId: sid });
+            if (sid !== void 0) stackIdSet.add(sid);
+          }
+        }
+        const explicitMin = yAxisProps?.min;
+        const explicitMax = yAxisProps?.max;
+        const isStacked = stackIdSet.size > 0 && !hasWaterfall;
+        const stackedDomain = isStacked ? estimateStackedValueDomain(valueDatasets, stackIdSet.size, yAxisProps?.tickCount ?? 5, yAxisProps?.tickCount !== void 0, yAxisProps?.startFromZero ?? true) : null;
+        let domain = null;
+        if (typeof explicitMin === "number" && typeof explicitMax === "number") {
+          domain = [explicitMin, explicitMax];
+        } else if (stackedDomain) {
+          domain = [typeof explicitMin === "number" ? explicitMin : stackedDomain[0], typeof explicitMax === "number" ? explicitMax : stackedDomain[1]];
+        } else if (allValues.length > 0) {
+          const nice = calculateNiceDomain(allValues, { includeZero: true });
+          domain = [typeof explicitMin === "number" ? explicitMin : nice[0], typeof explicitMax === "number" ? explicitMax : nice[1]];
+        }
+        if (domain) {
+          const tickInterval = yAxisProps?.tickInterval;
+          const tickCount = yAxisProps?.tickCount ?? 5;
+          const formatter = yAxisProps?.tickFormat;
+          const labelsForDomain = (d) => {
+            const ticks = tickInterval !== void 0 ? generateIntervalTicks(d[0], d[1], tickInterval) : generateNiceTicks(d[0], d[1], tickCount, yAxisProps?.tickCount !== void 0);
+            return ticks.map((v, i) => formatter && typeof formatter === "function" ? formatter(v, i) : v.toLocaleString(locale, { maximumFractionDigits: 2 }));
+          };
+          const domainPinned = typeof explicitMin === "number" && typeof explicitMax === "number";
+          const labels = new Set(labelsForDomain(domain));
+          if (!domainPinned && !isStacked && perDatasetValues.length > 1) {
+            for (const vals of perDatasetValues) {
+              if (vals.length === 0) continue;
+              const nice = calculateNiceDomain(vals, { includeZero: true });
+              const candidate = [typeof explicitMin === "number" ? explicitMin : nice[0], typeof explicitMax === "number" ? explicitMax : nice[1]];
+              for (const label of labelsForDomain(candidate)) labels.add(label);
+            }
+          }
+          yTickLabels = [...labels];
+        }
+      }
+    }
+    const space = calculateAxisSpace(
+      yPos,
+      !!yAxisProps?.label,
+      {
+        tickLabels: yTickLabels,
+        tickRotation: yAxisProps?.tickRotation,
+        titleGap: yAxisProps?.titleGap,
+        showTicks: yAxisProps?.showTicks,
+        tickStyle: (() => {
+          const s = yAxisProps?.tickStyle;
+          return typeof s === "function" ? void 0 : s;
+        })()
+      },
+      void 0,
+      globalFont
+    );
+    if (yPos === "left") leftTotal += space;
+    else rightTotal += space;
+  }
+  const firstXAxisId = axes.x.size > 0 ? axes.x.keys().next().value : void 0;
+  for (const [xAxisId, xAxisConfig] of axes.x) {
+    const xAxisProps = xAxisConfig.props;
+    const xPos = xAxisProps?.position ?? "bottom";
+    let xTickLabels;
+    let xCategoryWeights;
+    if (orientation === "vertical") {
+      const isTimeAxis = xAxisProps?.type === "time";
+      if (isTimeAxis) {
+        const allTimestamps = [];
+        for (const [, dataset] of datasets) {
+          if (!Array.isArray(dataset.props.data) || !dataset.props.categoryField) continue;
+          const rawValues = batchResolveAccessor(dataset.props.categoryField, dataset.props.data);
+          for (const v of rawValues) {
+            const ts = toTimestamp(v);
+            if (!isNaN(ts)) allTimestamps.push(ts);
+          }
+        }
+        if (allTimestamps.length >= 2) {
+          let min = allTimestamps[0];
+          let max = allTimestamps[0];
+          for (let i = 1; i < allTimestamps.length; i++) {
+            if (allTimestamps[i] < min) min = allTimestamps[i];
+            if (allTimestamps[i] > max) max = allTimestamps[i];
+          }
+          const estimatedWidth = Math.max(200, outerArea.width - leftTotal - rightTotal);
+          const { ticks, interval } = generateTimeTicks(min, max, estimatedWidth);
+          xTickLabels = ticks.map((ts) => formatTimeTick(ts, interval.unit, xAxisProps?.timezone, xAxisProps?.dateTimeFormats, locale));
+        }
+      } else {
+        for (const [, dataset] of datasets) {
+          if (!Array.isArray(dataset.props.data)) continue;
+          const r = renderersByType?.get(dataset.type);
+          if (r?.getAxisHints) {
+            const hints = r.getAxisHints(dataset.props, dataset.props.data);
+            if (hints.categoryLabels?.length) {
+              xTickLabels = hints.categoryLabels;
+              xCategoryWeights = hints.categoryWeights;
+              break;
+            }
+          }
+          if (dataset.props.categoryField) {
+            xTickLabels = batchResolveRequired(dataset.props.categoryField, dataset.props.data, "categoryField");
+            break;
+          }
+        }
+      }
+    } else {
+      if (isPctStacking) {
+        const tickCount = xAxisProps?.tickCount ?? 5;
+        const ticks = generateNiceTicks(0, 100, tickCount, xAxisProps?.tickCount !== void 0);
+        xTickLabels = ticks.map((v) => `${v}%`);
+      } else {
+        const allValues = [];
+        const valueDatasets = [];
+        const stackIdSet = /* @__PURE__ */ new Set();
+        for (const [, dataset] of datasets) {
+          if (!dataset.props.valueField || !Array.isArray(dataset.props.data)) continue;
+          const targetId = dataset.props.xAxisId ?? firstXAxisId;
+          if (targetId !== xAxisId) continue;
+          const values = batchResolveRequired(dataset.props.valueField, dataset.props.data, "valueField");
+          for (const v of values) allValues.push(v);
+          const sid = dataset.props.stackId;
+          valueDatasets.push({ data: dataset.props.data, categoryField: dataset.props.categoryField, values, stackId: sid });
+          if (sid !== void 0) stackIdSet.add(sid);
+        }
+        const isStacked = stackIdSet.size > 0 && !hasWaterfall;
+        const stackedDomain = isStacked ? estimateStackedValueDomain(valueDatasets, stackIdSet.size, xAxisProps?.tickCount ?? 5, xAxisProps?.tickCount !== void 0, xAxisProps?.startFromZero ?? true) : null;
+        const domain = stackedDomain ?? (allValues.length > 0 ? calculateNiceDomain(allValues, { includeZero: true }) : null);
+        if (domain) {
+          const tickInterval = xAxisProps?.tickInterval;
+          const tickCount = xAxisProps?.tickCount ?? 5;
+          const ticks = tickInterval !== void 0 ? generateIntervalTicks(domain[0], domain[1], tickInterval) : generateNiceTicks(domain[0], domain[1], tickCount, xAxisProps?.tickCount !== void 0);
+          const formatter = xAxisProps?.tickFormat;
+          xTickLabels = ticks.map((v, i) => formatter && typeof formatter === "function" ? formatter(v, i) : v.toLocaleString(locale, { maximumFractionDigits: 2 }));
+        }
+      }
+    }
+    const xTickStyleRaw = xAxisProps?.tickStyle;
+    const xTickStyleComputed = typeof xTickStyleRaw === "function" ? void 0 : xTickStyleRaw;
+    const estimatedChartWidth = Math.max(0, outerArea.width - leftTotal - rightTotal);
+    const xAutoRotate = xAxisProps?.autoRotate ?? true;
+    const xAutoRotateAngle = xAxisProps?.autoRotateAngle ?? -45;
+    let xEstimatedPositions;
+    if (xAutoRotate && xTickLabels && xTickLabels.length > 1 && estimatedChartWidth > 0) {
+      if (xCategoryWeights && xCategoryWeights.length === xTickLabels.length) {
+        const totalWeight = xCategoryWeights.reduce((s, w) => s + Math.max(w, 0), 0) || xCategoryWeights.length;
+        let cursor = 0;
+        xEstimatedPositions = xCategoryWeights.map((w) => {
+          const bw = Math.max(w, 0) / totalWeight * estimatedChartWidth;
+          const center = cursor + bw / 2;
+          cursor += bw;
+          return center;
+        });
+      } else {
+        const bandScale = createBandScale(xTickLabels, [0, estimatedChartWidth]);
+        const halfBand = bandScale.bandwidth() / 2;
+        xEstimatedPositions = xTickLabels.map((label) => bandScale(label) + halfBand);
+      }
+    }
+    const space = calculateAxisSpace(
+      xPos,
+      !!xAxisProps?.label,
+      {
+        tickLabels: xTickLabels,
+        tickRotation: xAxisProps?.tickRotation,
+        titleGap: xAxisProps?.titleGap,
+        showTicks: xAxisProps?.showTicks,
+        tickStyle: xTickStyleComputed,
+        autoRotate: xAutoRotate,
+        autoRotateAngle: xAutoRotateAngle,
+        tickPositions: xEstimatedPositions,
+        axisLength: estimatedChartWidth,
+        labelMinSpacing: xAxisProps?.labelMinSpacing,
+        tickCount: xAxisProps?.tickCount,
+        autoSkip: xAxisProps?.autoSkip
+      },
+      void 0,
+      globalFont
+    );
+    if (xPos === "bottom") bottomTotal += space;
+    else topTotal += space;
+    if (xTickLabels && xTickLabels.length > 0) {
+      const xTickRotation = xAxisProps?.tickRotation ?? 0;
+      const xFontSize = xTickStyleComputed?.fontSize ?? DEFAULT_TICK_FONT_SIZE;
+      if (xTickRotation) {
+        const radians = Math.abs(xTickRotation * Math.PI / 180);
+        const textH = xFontSize * 1.2;
+        const firstW = measureTextWidth(xTickLabels[0], xFontSize);
+        const lastW = measureTextWidth(xTickLabels[xTickLabels.length - 1], xFontSize);
+        xEdgeLeft = Math.max(xEdgeLeft, Math.ceil((firstW * Math.cos(radians) + textH * Math.sin(radians)) / 2));
+        xEdgeRight = Math.max(xEdgeRight, Math.ceil((lastW * Math.cos(radians) + textH * Math.sin(radians)) / 2));
+      } else {
+        xEdgeLeft = Math.max(xEdgeLeft, Math.ceil(measureTextWidth(xTickLabels[0], xFontSize) / 2));
+        xEdgeRight = Math.max(xEdgeRight, Math.ceil(measureTextWidth(xTickLabels[xTickLabels.length - 1], xFontSize) / 2));
+      }
+    }
+  }
+  const extraLeft = Math.max(0, xEdgeLeft - leftTotal);
+  const extraRight = Math.max(0, xEdgeRight - rightTotal);
+  const groupLeft = orientation === "horizontal" ? groupLabelSpace : 0;
+  const groupBottom = orientation === "vertical" ? groupLabelSpace : 0;
+  const rangeLeft = orientation === "vertical" ? rangeLabelSpace : 0;
+  const rangeBottom = orientation === "horizontal" ? rangeLabelSpace : 0;
+  const finalLeft = Math.max(leftTotal + extraLeft + groupLeft + rangeLeft, minPadding?.left ?? 0);
+  const finalRight = Math.max(rightTotal + extraRight, minPadding?.right ?? 0);
+  return {
+    x: outerArea.x + finalLeft,
+    y: outerArea.y + topTotal,
+    width: Math.max(0, outerArea.width - finalLeft - finalRight),
+    height: Math.max(0, outerArea.height - topTotal - bottomTotal - groupBottom - rangeBottom)
+  };
+}
+
+// src/cartesian/frame.utils.ts
+function createAnimationDriver() {
+  return {
+    domainLerpStates: /* @__PURE__ */ new Map(),
+    categorySortLerpState: /* @__PURE__ */ new Map(),
+    prevSortOrder: "",
+    cachedLayout: null,
+    lastFrame: null,
+    timeDomainLerp: null,
+    // NEW:
+    animRafId: null,
+    settleRafId: null,
+    isInitial: true,
+    lastFingerprint: "",
+    lastCategorySortProgress: 0
+  };
+}
+function buildFrameParams(ctx, cached, input) {
+  let yAxisLayout = cached.yAxisLayout;
+  let xAxisLayout = cached.xAxisLayout;
+  for (const [, info] of input.axisLayouts) {
+    if (info.isPrimary) {
+      if (info.axis === "y") yAxisLayout = info.layout;
+      else xAxisLayout = info.layout;
+    }
+  }
+  return {
+    renderer: ctx.renderer,
+    theme: ctx.theme,
+    group: ctx.group,
+    gridGroup: ctx.gridGroup,
+    canvas: ctx.canvas,
+    xAxisLayout,
+    yAxisLayout,
+    orientation: cached.orientation,
+    styledBoundaries: cached.styledBoundaries,
+    categoryScale: input.categoryScale ?? cached.sharedCategoryScale,
+    cartesianArea: cached.cartesianArea,
+    categoryAxisSpace: cached.categoryAxisSpace,
+    styledRangeBoundaries: cached.styledRangeBoundaries,
+    valueAxisSpace: cached.valueAxisSpace,
+    valueDomain: cached.valueDomain,
+    valueScaleRange: cached.valueScaleRange,
+    axisLayouts: input.axisLayouts,
+    valueScales: input.valueScales,
+    valueDomains: input.valueDomains,
+    valueXScales: input.valueXScales,
+    customTickOverlayRefs: ctx.customTickOverlayRefs,
+    referenceLines: cached.referenceLines,
+    referenceBands: cached.referenceBands,
+    isZoomed: ctx.isZoomed,
+    rtl: ctx.rtl,
+    globalFont: ctx.globalFont
+  };
+}
+function buildStaticFrame(ctx, cached, axisTransition) {
+  const transitioned = axisTransition.apply(cached.axisLayouts);
+  return buildFrameParams(ctx, cached, {
+    axisLayouts: transitioned,
+    valueScales: cached.valueScales,
+    valueDomains: cached.valueDomains,
+    valueXScales: cached.scatterXScales
+  });
+}
+function buildAnimatedFrame(ctx, cached, axisTransition, animatedInput) {
+  const transitioned = axisTransition.apply(animatedInput.axisLayouts);
+  return buildFrameParams(ctx, cached, {
+    axisLayouts: transitioned,
+    valueScales: animatedInput.valueScales,
+    valueDomains: animatedInput.valueDomains,
+    categoryScale: animatedInput.categoryScale,
+    valueXScales: animatedInput.valueXScales
+  });
+}
+function resolveHoverRepaintFrame(driver, ctx, buildStatic) {
+  return driver.lastFrame ? { ...driver.lastFrame, ...ctx } : buildStatic();
+}
+function renderWithCompositor(frameParams, renderFrameFn, options) {
+  const { renderer, canvas, compositor, overlayCanvas, registry, hover, markerOverlays, onImageLoad } = options;
+  if (renderer === "canvas" && compositor) {
+    compositor.setBackground(() => {
+      renderFrameFn({ ...frameParams, phase: "background" });
+    });
+    compositor.setForeground(() => {
+      renderFrameFn({ ...frameParams, phase: "foreground" });
+    });
+    if (compositor.hasLayers()) {
+      const ctx = canvas?.getContext("2d");
+      if (ctx) {
+        compositor.repaint(ctx);
+      }
+    } else {
+      renderFrameFn(frameParams);
+    }
+  } else {
+    renderFrameFn(frameParams);
+  }
+  if (overlayCanvas && registry) {
+    renderCartesianOverlay({
+      canvas: overlayCanvas,
+      axisLayouts: frameParams.axisLayouts,
+      hover: hover ?? { datasetId: null, index: null },
+      registry,
+      cartesianArea: frameParams.cartesianArea,
+      onImageLoad,
+      markerOverlays
+    });
+  }
+}
+function detectPhase(driver, fingerprint) {
+  if (driver.isInitial) return "entrance";
+  if (driver.lastFingerprint !== "" && fingerprint !== "" && fingerprint !== driver.lastFingerprint) return "update";
+  return "static";
+}
+function commitPhase(driver, fingerprint) {
+  driver.isInitial = false;
+  driver.lastFingerprint = fingerprint;
+}
+function cancelDriverRafs(driver) {
+  if (driver.animRafId !== null) {
+    cancelRaf(driver.animRafId);
+    driver.animRafId = null;
+  }
+  if (driver.settleRafId !== null) {
+    cancelRaf(driver.settleRafId);
+    driver.settleRafId = null;
+  }
+}
+function runTimedAnimation(driver, opts) {
+  if (driver.animRafId !== null) {
+    cancelRaf(driver.animRafId);
+    driver.animRafId = null;
+  }
+  const startAt = performance.now();
+  const tick = (now) => {
+    driver.animRafId = null;
+    const raw = (now - startAt) / opts.duration;
+    if (raw >= 1) {
+      opts.onFrame(opts.easing(1));
+      opts.onComplete?.();
+      return;
+    }
+    opts.onFrame(opts.easing(raw < 0 ? 0 : raw));
+    driver.animRafId = raf(tick);
+  };
+  driver.animRafId = raf(tick);
+}
+function runSettleLoop(driver, opts) {
+  if (driver.settleRafId !== null) {
+    cancelRaf(driver.settleRafId);
+    driver.settleRafId = null;
+  }
+  const loop = () => {
+    if (opts.tick()) {
+      opts.onFrame();
+      driver.settleRafId = raf(loop);
+    } else {
+      driver.settleRafId = null;
+    }
+  };
+  if (opts.tick()) {
+    driver.settleRafId = raf(loop);
+  }
+}
+function driveCartesianUpdate(layout, driver, axisTransition, animConfig, renderFrame, buildStatic, buildAnimated, globalFont, locale) {
+  const currentSortOrder = layout.sortedCategoryOrder?.join(",") ?? "";
+  const isSortChange = currentSortOrder !== driver.prevSortOrder && driver.prevSortOrder !== "" && currentSortOrder !== "";
+  if (isSortChange && driver.cachedLayout) {
+    const isCategoryLerpActive = driver.categorySortLerpState.size > 0;
+    const prevSourceLayouts = isCategoryLerpActive ? advanceCategoryLerp(driver.cachedLayout.axisLayouts, driver.categorySortLerpState, driver.lastCategorySortProgress, driver.cachedLayout.orientation) : driver.cachedLayout.axisLayouts;
+    driver.categorySortLerpState = initCategoryLerp(prevSourceLayouts, driver.cachedLayout.orientation);
+  } else if (!isSortChange) {
+    snapCategoryLerp(driver.categorySortLerpState);
+  }
+  driver.prevSortOrder = currentSortOrder;
+  driver.cachedLayout = layout;
+  axisTransition.setTargets(layout.axisLayouts);
+  const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+  const timeDomainFp = layout.timeDomain ? `${layout.timeDomain[0]},${layout.timeDomain[1]}` : "";
+  const lerpTargets = new Map(layout.valueDomains);
+  if (layout.scatterXScales) {
+    for (const [id, scale] of layout.scatterXScales) lerpTargets.set(`x:${id}`, scale.domain());
+  }
+  const currentFingerprint = `${[...lerpTargets.entries()].map(([k, v]) => `${k}:${v[0]},${v[1]}`).join(";")}|${layout.orientation}|${currentSortOrder}|${timeDomainFp}`;
+  const phase = detectPhase(driver, currentFingerprint);
+  const hasTimeDomain = !!layout.timeDomain;
+  const prevTimeDomain = driver.timeDomainLerp ? [driver.timeDomainLerp.minTarget, driver.timeDomainLerp.maxTarget] : null;
+  if (hasTimeDomain) {
+    driver.timeDomainLerp = initTimeDomainLerp(driver.timeDomainLerp, layout.timeDomain);
+  } else {
+    driver.timeDomainLerp = null;
+  }
+  const hasDomains = layout.valueDomains.size > 0 || !!layout.scatterXScales?.size;
+  const animationActive = animEnabled && phase === "update" && (hasDomains || isSortChange || hasTimeDomain);
+  const isStreamingAppend = hasTimeDomain && (!prevTimeDomain || prevTimeDomain[0] !== layout.timeDomain[0] || prevTimeDomain[1] !== layout.timeDomain[1]);
+  if (animationActive) {
+    initDomainLerp(driver.domainLerpStates, lerpTargets, { expansionStart: isStreamingAppend });
+    initDomainLerpTickFade(driver.domainLerpStates, layout.axisLayouts, layout.valueScaleRange, layout.cartesianArea, layout.orientation, axisTransition, globalFont, locale);
+    cancelDriverRafs(driver);
+    runTimedAnimation(driver, {
+      duration,
+      easing,
+      onFrame: (progress) => {
+        axisTransition.tick();
+        const cached = driver.cachedLayout;
+        const frame = advanceDomainLerp(driver.domainLerpStates, progress, cached.axisLayouts, cached.valueScaleRange, cached.cartesianArea, cached.orientation, cached.valueScales, cached.valueDomains, globalFont, locale, axisTransition);
+        let animatedCategoryScale = void 0;
+        let mergedAxisLayouts = frame.axisLayouts;
+        if (driver.timeDomainLerp && cached.timeDomain) {
+          const timestamps = cached.sharedCategoryScale.domain().map(Number).filter((t) => !isNaN(t));
+          const timeFrame = advanceTimeDomainLerp(driver.timeDomainLerp, progress, frame.axisLayouts, {
+            orientation: cached.orientation,
+            cartesianArea: cached.cartesianArea,
+            timestamps
+          });
+          animatedCategoryScale = timeFrame.categoryScale;
+          mergedAxisLayouts = timeFrame.axisLayouts;
+        }
+        const sortedAxisLayouts = advanceCategoryLerp(mergedAxisLayouts, driver.categorySortLerpState, progress, cached.orientation);
+        driver.lastCategorySortProgress = progress;
+        renderFrame(buildAnimated(frame.valueScales, frame.valueDomains, sortedAxisLayouts, animatedCategoryScale, frame.valueXScales));
+      },
+      onComplete: () => {
+        snapCategoryLerp(driver.categorySortLerpState);
+        driver.lastCategorySortProgress = 0;
+        if (driver.timeDomainLerp) {
+          snapTimeDomainLerp(driver.timeDomainLerp);
+        }
+        runSettleLoop(driver, {
+          tick: () => axisTransition.tick(),
+          onFrame: () => renderFrame(buildStatic())
+        });
+      }
+    });
+  } else {
+    cancelDriverRafs(driver);
+    initDomainLerp(driver.domainLerpStates, lerpTargets);
+    snapDomainLerp(driver.domainLerpStates);
+    snapCategoryLerp(driver.categorySortLerpState);
+    driver.lastCategorySortProgress = 0;
+    if (driver.timeDomainLerp) {
+      snapTimeDomainLerp(driver.timeDomainLerp);
+    }
+    renderFrame(buildStatic());
+    runSettleLoop(driver, {
+      tick: () => axisTransition.tick(),
+      onFrame: () => renderFrame(buildStatic())
+    });
+  }
+  commitPhase(driver, currentFingerprint);
+}
+
+// src/cartesian/grouping.ts
+function resolveStyleShorthand(value, defaultEnabled) {
+  if (value === void 0) {
+    return defaultEnabled ? {} : false;
+  }
+  if (typeof value === "boolean") {
+    return value ? {} : false;
+  }
+  return value;
+}
+function buildBoundariesFromAxisGroups(groups, dataCategories) {
+  const sortedCategories = [];
+  const styledBoundaries = [];
+  const usedCategories = /* @__PURE__ */ new Set();
+  const dataCategorySet = new Set(dataCategories);
+  const maxDepth = Math.max(0, ...groups.map((g) => g.depth ?? 0));
+  const leafGroups = groups.filter((g) => (g.depth ?? 0) === maxDepth);
+  const parentGroups = groups.filter((g) => (g.depth ?? 0) < maxDepth).sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
+  for (const group of leafGroups) {
+    if (!group.categories) continue;
+    const startIdx = sortedCategories.length;
+    for (const cat of group.categories) {
+      if (dataCategorySet.has(cat)) {
+        sortedCategories.push(cat);
+        usedCategories.add(cat);
+      }
+    }
+    if (sortedCategories.length > startIdx) {
+      styledBoundaries.push({
+        label: group.label,
+        startIdx,
+        endIdx: sortedCategories.length - 1,
+        depth: group.depth ?? 0,
+        bracket: resolveStyleShorthand(group.bracket, false),
+        separator: resolveStyleShorthand(group.separator, false),
+        fill: resolveStyleShorthand(group.fill, false),
+        labelStyle: group.labelStyle,
+        tickSeparator: resolveStyleShorthand(group.tickSeparator, false),
+        render: group.render
+      });
+    }
+  }
+  for (const group of parentGroups) {
+    if (!group.categories || group.categories.length === 0) continue;
+    let startIdx = Infinity;
+    let endIdx = -Infinity;
+    for (const cat of group.categories) {
+      const idx = sortedCategories.indexOf(cat);
+      if (idx !== -1) {
+        startIdx = Math.min(startIdx, idx);
+        endIdx = Math.max(endIdx, idx);
+      }
+    }
+    if (startIdx <= endIdx) {
+      styledBoundaries.push({
+        label: group.label,
+        startIdx,
+        endIdx,
+        depth: group.depth ?? 0,
+        bracket: resolveStyleShorthand(group.bracket, false),
+        separator: resolveStyleShorthand(group.separator, false),
+        fill: resolveStyleShorthand(group.fill, false),
+        labelStyle: group.labelStyle,
+        tickSeparator: resolveStyleShorthand(group.tickSeparator, false),
+        render: group.render
+      });
+    }
+  }
+  for (const cat of dataCategories) {
+    if (!usedCategories.has(cat)) {
+      sortedCategories.push(cat);
+    }
+  }
+  return { sortedCategories, styledBoundaries };
+}
+function buildStyledRanges(groups) {
+  return groups.filter((g) => g.range !== void 0).map((g) => ({
+    label: g.label,
+    from: g.range[0],
+    to: g.range[1],
+    bracket: resolveStyleShorthand(g.bracket, false),
+    separator: resolveStyleShorthand(g.separator, false),
+    fill: resolveStyleShorthand(g.fill, false),
+    labelStyle: g.labelStyle,
+    tickSeparator: resolveStyleShorthand(g.tickSeparator, false),
+    render: g.render
+  }));
+}
+
+// src/cartesian/hittest-wrappers/shared.ts
+function resolveNearestHit(hit1, hit2, x, y) {
+  const d1 = Math.sqrt((x - hit1.snapX) ** 2 + (y - hit1.snapY) ** 2);
+  const d2 = Math.sqrt((x - hit2.snapX) ** 2 + (y - hit2.snapY) ** 2);
+  return d1 <= d2 ? hit1 : hit2;
+}
+function mergeAllNearestResults(results, x, y) {
+  const valid = results.filter((r) => r !== null);
+  if (valid.length === 0) return null;
+  if (valid.length === 1) return valid[0];
+  const allSeries = valid.flatMap((r) => r.allSeries);
+  const primary = valid.reduce((best, r) => {
+    const d = Math.sqrt((x - r.primary.snapX) ** 2 + (y - r.primary.snapY) ** 2);
+    const bestD = Math.sqrt((x - best.primary.snapX) ** 2 + (y - best.primary.snapY) ** 2);
+    return d < bestD ? r : best;
+  }).primary;
+  return { primary, allSeries };
+}
+
+// src/cartesian/layout.helpers.ts
+function findAxisGroupFeatures(features, prefix) {
+  const results = [];
+  for (const [key, feature] of features) {
+    if (key === prefix || key.startsWith(`${prefix}:`)) {
+      results.push(feature.props);
+    }
+  }
+  return results;
+}
+function createOffsetChartArea(area, position, offset) {
+  switch (position) {
+    case "left":
+      return { ...area, x: area.x - offset, width: area.width + offset };
+    case "right":
+      return { ...area, width: area.width + offset };
+    case "top":
+      return { ...area, y: area.y - offset, height: area.height + offset };
+    case "bottom":
+      return { ...area, height: area.height + offset };
+    default:
+      return area;
+  }
+}
+function computeHiddenValueAxes(params) {
+  const { barDatasets, lineDatasets, scatterDatasets, candlestickDatasets, datasetAxisMap, firstValueAxisId, axisIdProp, valueAxesSize } = params;
+  const hiddenValueAxes = /* @__PURE__ */ new Set();
+  const axisVisibility = /* @__PURE__ */ new Map();
+  const trackDataset = (axisId, visible) => {
+    const entry = axisVisibility.get(axisId) ?? { hasDataset: false, hasVisible: false };
+    entry.hasDataset = true;
+    if (visible) entry.hasVisible = true;
+    axisVisibility.set(axisId, entry);
+  };
+  for (const ds of barDatasets) {
+    trackDataset(datasetAxisMap.get(ds.id) ?? firstValueAxisId, ds.visible);
+  }
+  for (const ds of lineDatasets) {
+    trackDataset(ds.props[axisIdProp] ?? firstValueAxisId, ds.visible);
+  }
+  for (const ds of scatterDatasets) {
+    trackDataset(ds.props[axisIdProp] ?? firstValueAxisId, ds.visible);
+  }
+  for (const ds of candlestickDatasets) {
+    trackDataset(ds.props[axisIdProp] ?? firstValueAxisId, ds.visible);
+  }
+  for (const [axisId, info] of axisVisibility) {
+    if (info.hasDataset && !info.hasVisible) {
+      hiddenValueAxes.add(axisId);
+    }
+  }
+  if (valueAxesSize <= 1 && hiddenValueAxes.size > 0) {
+    const hasAnyVisible = [...axisVisibility.values()].some((v) => v.hasVisible);
+    if (!hasAnyVisible) {
+      hiddenValueAxes.clear();
+    }
+  }
+  return hiddenValueAxes;
+}
+
+// src/cartesian/layout.axis-layouts.ts
+function computeAxisLayouts(params) {
+  const {
+    axes,
+    isRtl,
+    orientation,
+    valueScales,
+    sharedValueScale,
+    sharedTimeScale,
+    sharedCategoryScale,
+    scatterXScales,
+    valueDomains,
+    scatterXDomains,
+    mode,
+    adaptive,
+    cartesianArea,
+    styledBoundaries,
+    rangeLabelOffset,
+    hiddenValueAxes,
+    lastVisibleLayouts,
+    globalFont,
+    locale
+  } = params;
+  const axisLayouts = /* @__PURE__ */ new Map();
+  let xAxisLayout = null;
+  let yAxisLayout = null;
+  const sideOffsets = { left: 0, right: 0, top: 0, bottom: 0 };
+  const sidePrimarySet = /* @__PURE__ */ new Set();
+  for (const [yAxisId, yAxisConfig] of axes.y) {
+    const yPos = yAxisConfig.props.position ?? (isRtl ? "right" : "left");
+    const isPrimary = !sidePrimarySet.has(yPos);
+    if (isPrimary) sidePrimarySet.add(yPos);
+    const isValueAxis = orientation === "vertical";
+    const yScale = isValueAxis ? valueScales.get(yAxisId) ?? sharedValueScale : sharedTimeScale ?? sharedCategoryScale;
+    let yProps = yAxisConfig.props;
+    if (isValueAxis) {
+      if (mode.isPercentStacked && !yProps.tickFormat) {
+        yProps = { ...yProps, tickFormat: (v) => `${v}%` };
+      }
+    }
+    if (yProps.gridLines === void 0) {
+      yProps = { ...yProps, gridLines: isPrimary && isValueAxis };
+    }
+    {
+      const existingTickStyle = yProps?.tickStyle;
+      if (typeof existingTickStyle !== "function" && !existingTickStyle?.fontSize) {
+        yProps = { ...yProps, tickStyle: { ...existingTickStyle, fontSize: adaptive.tickFontSize } };
+      }
+    }
+    const offset = sideOffsets[yPos];
+    const offsetArea = offset > 0 ? createOffsetChartArea(cartesianArea, yPos, offset) : cartesianArea;
+    const yCatBracketOffset = isPrimary && !isValueAxis && styledBoundaries && styledBoundaries.length > 0 ? DEFAULT_BRACKET_GAP + (Math.max(0, ...styledBoundaries.map((b) => b.depth)) + 1) * DEFAULT_BRACKET_DEPTH_LAYER_SIZE : 0;
+    const yExtraTitleOffset = isPrimary ? isValueAxis && rangeLabelOffset > 0 ? rangeLabelOffset : yCatBracketOffset : 0;
+    let visibleLayout = calculateAxisLayout(yScale, yPos, offsetArea, yProps, yExtraTitleOffset || void 0, globalFont, locale);
+    let layout = visibleLayout;
+    const isAxisHidden = isValueAxis && hiddenValueAxes.has(yAxisId);
+    const axisKey = `y:${yAxisId}`;
+    if (!isAxisHidden) {
+      lastVisibleLayouts.set(axisKey, visibleLayout);
+    } else {
+      const stored = lastVisibleLayouts.get(axisKey);
+      if (stored) visibleLayout = stored;
+    }
+    if (isAxisHidden) {
+      const minTitleOffset = 16;
+      const { x, width } = offsetArea;
+      layout = {
+        ...layout,
+        // Hide axis line, ticks, and grid lines when all datasets on this axis are hidden
+        axisLine: { x1: 0, y1: 0, x2: 0, y2: 0 },
+        ticks: [],
+        gridLines: [],
+        ...layout.title && {
+          title: {
+            ...layout.title,
+            x: yPos === "left" ? x - minTitleOffset : x + width + minTitleOffset
+          }
+        }
+      };
+    }
+    const HIDDEN_AXIS_TITLE_SPACE = 30;
+    const space = yProps?.visible === false ? 0 : isAxisHidden ? yProps?.label ? HIDDEN_AXIS_TITLE_SPACE : 0 : calculateAxisSpace(
+      yPos,
+      !!yProps?.label,
+      {
+        tickLabels: layout.ticks.map((t) => t.label ?? ""),
+        tickRotation: layout.ticks.find((t) => t.label)?.rotation ?? yProps?.tickRotation ?? 0,
+        titleGap: yProps?.titleGap,
+        showTicks: yProps?.showTicks,
+        tickStyle: (() => {
+          const s = yProps?.tickStyle;
+          return typeof s === "function" ? void 0 : s;
+        })()
+      },
+      yExtraTitleOffset || void 0,
+      globalFont
+    );
+    sideOffsets[yPos] += space;
+    axisLayouts.set(`y:${yAxisId}`, {
+      id: yAxisId,
+      axis: "y",
+      position: yPos,
+      layout,
+      scale: yScale,
+      domain: isValueAxis ? valueDomains.get(yAxisId) : sharedTimeScale ? sharedTimeScale.domain() : void 0,
+      props: yProps,
+      isPrimary,
+      offset,
+      space,
+      isHidden: isAxisHidden,
+      visibleLayout,
+      extraTitleOffset: yExtraTitleOffset || void 0
+    });
+    if (!yAxisLayout) yAxisLayout = layout;
+  }
+  for (const [xAxisId, xAxisConfig] of axes.x) {
+    const xPos = xAxisConfig.props.position ?? "bottom";
+    const isPrimary = !sidePrimarySet.has(xPos);
+    if (isPrimary) sidePrimarySet.add(xPos);
+    const isValueAxis = orientation === "horizontal";
+    const xAxisType = xAxisConfig.props?.type;
+    const scatterXScale = scatterXScales.get(xAxisId);
+    const useScatterScale = !!scatterXScale && (xAxisType === "linear" || xAxisType === "logarithmic" || !xAxisType);
+    const xScale = isValueAxis ? valueScales.get(xAxisId) ?? sharedValueScale : useScatterScale ? scatterXScale : sharedTimeScale ?? sharedCategoryScale;
+    let xProps = xAxisConfig.props;
+    if (isValueAxis || useScatterScale) {
+      if (mode.isPercentStacked && !xProps.tickFormat) {
+        xProps = { ...xProps, tickFormat: (v) => `${v}%` };
+      }
+    }
+    if (xProps.gridLines === void 0) {
+      xProps = { ...xProps, gridLines: isPrimary && (isValueAxis || useScatterScale) };
+    }
+    {
+      const existingTickStyle = xProps?.tickStyle;
+      if (typeof existingTickStyle !== "function" && !existingTickStyle?.fontSize) {
+        xProps = { ...xProps, tickStyle: { ...existingTickStyle, fontSize: adaptive.tickFontSize } };
+      }
+    }
+    const offset = sideOffsets[xPos];
+    const offsetArea = offset > 0 ? createOffsetChartArea(cartesianArea, xPos, offset) : cartesianArea;
+    const xCatBracketOffset = isPrimary && !isValueAxis && styledBoundaries && styledBoundaries.length > 0 ? DEFAULT_BRACKET_GAP + (Math.max(0, ...styledBoundaries.map((b) => b.depth)) + 1) * DEFAULT_BRACKET_DEPTH_LAYER_SIZE : 0;
+    const xExtraTitleOffset = isPrimary ? isValueAxis && rangeLabelOffset > 0 ? rangeLabelOffset : xCatBracketOffset : 0;
+    const visibleXLayout = calculateAxisLayout(xScale, xPos, offsetArea, xProps, xExtraTitleOffset || void 0, globalFont, locale);
+    let layout = visibleXLayout;
+    const isAxisHidden = isValueAxis && hiddenValueAxes.has(xAxisId);
+    if (isAxisHidden) {
+      const minTitleOffset = 16;
+      const { y, height } = offsetArea;
+      layout = {
+        ...layout,
+        // Hide axis line, ticks, and grid lines when all datasets on this axis are hidden
+        axisLine: { x1: 0, y1: 0, x2: 0, y2: 0 },
+        ticks: [],
+        gridLines: [],
+        ...layout.title && {
+          title: {
+            ...layout.title,
+            y: xPos === "top" ? y - minTitleOffset : y + height + minTitleOffset
+          }
+        }
+      };
+    }
+    const HIDDEN_AXIS_TITLE_SPACE = 30;
+    const space = xProps?.visible === false ? 0 : isAxisHidden ? xProps?.label ? HIDDEN_AXIS_TITLE_SPACE : 0 : calculateAxisSpace(
+      xPos,
+      !!xProps?.label,
+      {
+        tickLabels: layout.ticks.map((t) => t.label ?? ""),
+        tickRotation: layout.ticks.find((t) => t.label)?.rotation ?? xProps?.tickRotation ?? 0,
+        titleGap: xProps?.titleGap,
+        showTicks: xProps?.showTicks,
+        tickStyle: (() => {
+          const s = xProps?.tickStyle;
+          return typeof s === "function" ? void 0 : s;
+        })()
+      },
+      xExtraTitleOffset || void 0,
+      globalFont
+    );
+    sideOffsets[xPos] += space;
+    axisLayouts.set(`x:${xAxisId}`, {
+      id: xAxisId,
+      axis: "x",
+      position: xPos,
+      layout,
+      scale: xScale,
+      domain: isValueAxis ? valueDomains.get(xAxisId) : scatterXDomains.get(xAxisId) ?? (sharedTimeScale ? sharedTimeScale.domain() : void 0),
+      props: xProps,
+      isPrimary,
+      offset,
+      space,
+      isHidden: isAxisHidden,
+      visibleLayout: visibleXLayout,
+      extraTitleOffset: xExtraTitleOffset || void 0
+    });
+    if (!xAxisLayout) xAxisLayout = layout;
+  }
+  return { axisLayouts, xAxisLayout, yAxisLayout };
+}
+
+// src/cartesian/category-sort.ts
+function sortCategories(cats, sort, aggregate, allCategories, valuesPerDataset, categoryTotals) {
+  if (sort === "label-asc") return [...cats].sort((a, b) => a.localeCompare(b));
+  if (sort === "label-desc") return [...cats].sort((a, b) => b.localeCompare(a));
+  const catIndexMap = new Map(allCategories.map((c, i) => [c, i]));
+  const getAggregateValue = (cat) => {
+    const idx = catIndexMap.get(cat);
+    if (idx === void 0) return 0;
+    if (aggregate === "sum" && categoryTotals) return categoryTotals[idx] ?? 0;
+    const vals = valuesPerDataset.map((ds) => ds[idx] ?? 0).filter((v) => !isNaN(v));
+    if (vals.length === 0) return 0;
+    switch (aggregate) {
+      case "sum":
+        return vals.reduce((a, b) => a + b, 0);
+      case "max":
+        return Math.max(...vals);
+      case "min":
+        return Math.min(...vals);
+      case "first":
+        return vals[0] ?? 0;
+    }
+  };
+  return [...cats].sort((a, b) => {
+    const va = getAggregateValue(a);
+    const vb = getAggregateValue(b);
+    return sort === "value-asc" ? va - vb : vb - va;
+  });
+}
+
+// src/cartesian/layout.bar-pipeline.ts
+function computeBarPipeline(params) {
+  const { features, barDatasets, lineDatasets, orientation, categories, globalFont, isTimeAxis, axisIdProp, firstValueAxisId, valueAxes, cartesianArea, valueDomains, datasetAxisMap } = params;
+  let mode = params.mode;
+  let isVariwide = false;
+  let valuesPerDataset = [];
+  let waterfallBases;
+  let effectiveScaleCategories = params.effectiveScaleCategories;
+  let effectiveWeights;
+  let sortedCategoryOrder;
+  let styledBoundaries;
+  let styledRangeBoundaries;
+  let rangeLabelOffset = 0;
+  const stackingConfig = features.get("stacking")?.props;
+  const waterfallConfig = features.get("waterfall")?.props;
+  const overlapFeature = features.get("overlap");
+  mode = detectCartesianMode(barDatasets, {
+    stacking: stackingConfig,
+    waterfall: waterfallConfig,
+    overlap: overlapFeature ? {} : void 0
+  });
+  const xAxisGroupFeatures = findAxisGroupFeatures(features, "axisGroup:x");
+  const yAxisGroupFeatures = findAxisGroupFeatures(features, "axisGroup:y");
+  const legacyAxisGroup = features.get("axisGroup")?.props;
+  const categoryAxisGroups = orientation === "vertical" ? xAxisGroupFeatures : yAxisGroupFeatures;
+  const valueAxisGroups = orientation === "vertical" ? yAxisGroupFeatures : xAxisGroupFeatures;
+  const categoryGroupDefs = categoryAxisGroups.flatMap((f) => f.groups).filter((g) => g.categories && g.categories.length > 0);
+  const valueRangeGroupDefs = valueAxisGroups.flatMap((f) => f.groups).filter((g) => g.range !== void 0);
+  if (valueRangeGroupDefs.length > 0) {
+    styledRangeBoundaries = buildStyledRanges(valueRangeGroupDefs);
+  }
+  if (styledRangeBoundaries && styledRangeBoundaries.length > 0) {
+    if (orientation === "vertical") {
+      const maxWidth = Math.max(...styledRangeBoundaries.map((r) => measureTextWidth(r.label, resolveFontSize(DEFAULT_GROUP_LABEL_FONT_SIZE, globalFont))));
+      rangeLabelOffset = maxWidth + 16;
+    } else {
+      rangeLabelOffset = 24;
+    }
+  }
+  let sortedCategories;
+  if (categoryGroupDefs.length > 0) {
+    const result = buildBoundariesFromAxisGroups(categoryGroupDefs, categories);
+    sortedCategories = result.sortedCategories;
+    styledBoundaries = result.styledBoundaries;
+  } else if (legacyAxisGroup && legacyAxisGroup.groups.length > 0) {
+    const result = buildBoundariesFromAxisGroups(legacyAxisGroup.groups, categories);
+    sortedCategories = result.sortedCategories;
+    styledBoundaries = result.styledBoundaries;
+  }
+  const variwideProps = barDatasets.find((d) => d.props.weightField)?.props;
+  isVariwide = variwideProps?.weightField !== void 0;
+  const weights = isVariwide ? batchResolveRequired(variwideProps.weightField, variwideProps.data, "weightField") : void 0;
+  const rawResolvedPerDataset = barDatasets.map((d) => d.visible ? batchResolveAccessor(d.props.valueField, d.props.data) : []);
+  const barRawResolved = rawResolvedPerDataset;
+  const openResolvedPerDataset = barDatasets.map((d) => {
+    const openAccessor = d.props.openField;
+    if (!d.visible || !openAccessor) return void 0;
+    return batchResolveAccessor(openAccessor, d.props.data);
+  });
+  const rawValues = barDatasets.map((d, i) => {
+    if (!d.visible) return new Array(categories.length).fill(0);
+    return rawResolvedPerDataset[i].map((v) => v === null || v === void 0 || Number.isNaN(v) ? 0 : v);
+  });
+  const openValuesPerDataset = openResolvedPerDataset.map((raw) => {
+    if (!raw) return void 0;
+    return raw.map((v) => v === null || v === void 0 || Number.isNaN(v) ? 0 : v);
+  });
+  const transformed = transformValues(rawValues, categories.length, mode);
+  valuesPerDataset = transformed.transformed;
+  const categoryTotals = transformed.categoryTotals;
+  for (let i = 0; i < openValuesPerDataset.length; i++) {
+    const openVals = openValuesPerDataset[i];
+    if (openVals) {
+      valuesPerDataset[i] = [...valuesPerDataset[i], ...openVals];
+    }
+  }
+  const isSkipMode = (cn) => cn === void 0 || cn === "gap" || cn === false;
+  const anySkipNull = barDatasets.some((d) => isSkipMode(d.props.connectNulls));
+  effectiveWeights = weights;
+  if (anySkipNull) {
+    const keepMask = new Array(categories.length).fill(false);
+    for (let dsIdx = 0; dsIdx < barDatasets.length; dsIdx++) {
+      const ds = barDatasets[dsIdx];
+      if (!ds.visible) continue;
+      if (!isSkipMode(ds.props.connectNulls)) {
+        keepMask.fill(true);
+        break;
+      }
+      const raw = rawResolvedPerDataset[dsIdx];
+      for (let i = 0; i < raw.length; i++) {
+        const v = raw[i];
+        if (v !== null && v !== void 0 && !Number.isNaN(v)) {
+          keepMask[i] = true;
+        }
+      }
+    }
+    if (!keepMask.some(Boolean)) {
+      keepMask.fill(true);
+    } else if (!keepMask.every(Boolean)) {
+      for (const ld of lineDatasets) {
+        if (!ld.visible) continue;
+        keepMask.fill(true);
+        break;
+      }
+    }
+    const filteredCategories = categories.filter((_, i) => keepMask[i]);
+    if (sortedCategories) {
+      const filteredSet = new Set(filteredCategories);
+      effectiveScaleCategories = sortedCategories.filter((cat) => filteredSet.has(cat));
+    } else {
+      effectiveScaleCategories = filteredCategories;
+    }
+    if (weights) {
+      effectiveWeights = weights.filter((_, i) => keepMask[i]);
+    }
+  } else {
+    effectiveScaleCategories = sortedCategories ?? categories;
+  }
+  const sortSourceProps = barDatasets[0]?.props;
+  const sortProp = !isTimeAxis ? sortSourceProps?.sort : void 0;
+  if (sortProp) {
+    const sortAggregate = sortSourceProps?.sortAggregate ?? "sum";
+    effectiveScaleCategories = sortCategories(effectiveScaleCategories, sortProp, sortAggregate, categories, valuesPerDataset, categoryTotals);
+    sortedCategoryOrder = effectiveScaleCategories.slice();
+  }
+  const firstBarProps = barDatasets[0].props;
+  if (mode.isWaterfall && waterfallConfig) {
+    waterfallBases = computeWaterfallBases(valuesPerDataset, categories.length, firstBarProps.data, waterfallConfig.totalField);
+  }
+  for (const ds of barDatasets) {
+    const targetId = ds.props[axisIdProp] ?? firstValueAxisId;
+    datasetAxisMap.set(ds.id, targetId);
+  }
+  const boundAxisIds = new Set(datasetAxisMap.values());
+  for (const axisId of boundAxisIds) {
+    const axisConfig = valueAxes.get(axisId);
+    const userTickCount = axisConfig?.props?.tickCount;
+    const valueAxisLength = orientation === "vertical" ? cartesianArea.height : cartesianArea.width;
+    const axisTickCount = getAdaptiveTickCount(valueAxisLength, userTickCount);
+    const axisType = axisConfig?.props?.type;
+    const axisStartFromZero = axisConfig?.props?.startFromZero;
+    const axisBoundMask = barDatasets.map((ds) => datasetAxisMap.get(ds.id) === axisId);
+    if (!axisBoundMask.some((v) => v)) continue;
+    const axisVisibleMask = barDatasets.map((ds, i) => axisBoundMask[i] && ds.visible);
+    const hasVisibleDatasets = axisVisibleMask.some((v) => v);
+    let domain;
+    if (hasVisibleDatasets) {
+      if (axisType === "logarithmic") {
+        const logRawValues = [];
+        for (let i = 0; i < barDatasets.length; i++) {
+          if (!axisVisibleMask[i]) continue;
+          for (const v of valuesPerDataset[i]) {
+            if (v > 0) logRawValues.push(v);
+          }
+        }
+        domain = calculateNiceLogDomain(logRawValues);
+      } else if (mode.isGrouped && mode.isStacked) {
+        const groupSumMap = /* @__PURE__ */ new Map();
+        const groupVisibleMap = /* @__PURE__ */ new Map();
+        for (let i = 0; i < barDatasets.length; i++) {
+          const sid = barDatasets[i].stackId;
+          const catSums = groupSumMap.get(sid) ?? new Array(categories.length).fill(0);
+          const isVis = groupVisibleMap.get(sid) ?? false;
+          if (axisVisibleMask[i]) {
+            for (let c = 0; c < categories.length; c++) {
+              catSums[c] += valuesPerDataset[i][c] ?? 0;
+            }
+            groupVisibleMap.set(sid, true);
+          } else {
+            if (!isVis) groupVisibleMap.set(sid, false);
+          }
+          groupSumMap.set(sid, catSums);
+        }
+        const syntheticValues = [...groupSumMap.values()];
+        const syntheticVisible = [...groupSumMap.keys()].map((sid) => groupVisibleMap.get(sid) ?? false);
+        domain = computeCartesianDomain({
+          valuesPerDataset: syntheticValues,
+          visibleMask: syntheticVisible,
+          categoryCount: categories.length,
+          mode: { isStacked: false, isWaterfall: false, isPercentStacked: false },
+          tickCount: axisTickCount,
+          exactTickCount: userTickCount !== void 0,
+          includeZero: axisStartFromZero ?? true
+        });
+      } else {
+        domain = computeCartesianDomain({
+          valuesPerDataset,
+          visibleMask: axisVisibleMask,
+          categoryCount: categories.length,
+          mode,
+          waterfallBases,
+          tickCount: axisTickCount,
+          exactTickCount: userTickCount !== void 0,
+          includeZero: axisStartFromZero ?? true
+        });
+      }
+    } else {
+      if (axisType === "logarithmic") {
+        const logRawValues = [];
+        for (let i = 0; i < barDatasets.length; i++) {
+          if (!axisBoundMask[i]) continue;
+          for (const v of rawResolvedPerDataset[i]) {
+            if (v > 0) logRawValues.push(v);
+          }
+        }
+        domain = calculateNiceLogDomain(logRawValues);
+      } else {
+        const originalValuesForDomain = barDatasets.map((_ds, i) => {
+          if (!axisBoundMask[i]) return new Array(categories.length).fill(0);
+          const vals = rawResolvedPerDataset[i].map((v) => v === null || v === void 0 || Number.isNaN(v) ? 0 : v);
+          const openRaw = openResolvedPerDataset[i];
+          if (openRaw) {
+            const openVals = openRaw.map((v) => v === null || v === void 0 || Number.isNaN(v) ? 0 : v);
+            return [...vals, ...openVals];
+          }
+          return vals;
+        });
+        domain = computeCartesianDomain({
+          valuesPerDataset: originalValuesForDomain,
+          visibleMask: axisBoundMask,
+          categoryCount: categories.length,
+          mode: { isStacked: false, isWaterfall: false, isPercentStacked: false },
+          waterfallBases: void 0,
+          tickCount: axisTickCount,
+          exactTickCount: userTickCount !== void 0,
+          includeZero: axisStartFromZero ?? true
+        });
+      }
+    }
+    valueDomains.set(axisId, domain);
+  }
+  return {
+    mode,
+    isVariwide,
+    valuesPerDataset,
+    categoryTotals,
+    waterfallBases,
+    effectiveScaleCategories,
+    effectiveWeights,
+    sortedCategoryOrder,
+    styledBoundaries,
+    styledRangeBoundaries,
+    rangeLabelOffset,
+    barRawResolved
+  };
+}
+
+// src/cartesian/layout.domain-contributions.ts
+function computeDomainContributions(params) {
+  const {
+    orientation,
+    axes,
+    barDatasets,
+    lineDatasets,
+    scatterDatasets,
+    candlestickDatasets,
+    datasetAxisMap,
+    firstValueAxisId,
+    valueAxes,
+    categoryAxes,
+    axisIdProp,
+    lineStackBasesMap,
+    lineTransformedValues,
+    isLinePercentStacked,
+    scatterStackBasesMap,
+    cartesianArea,
+    features,
+    mode,
+    styledRangeBoundaries,
+    barRawResolved,
+    primaryCategoryAxisConfig,
+    isTimeAxis,
+    timestamps,
+    valuesPerDataset,
+    zoomState,
+    valueDomains
+  } = params;
+  const firstCategoryAxisId = (orientation === "vertical" ? axes.x : axes.y).keys().next().value ?? "default";
+  const barAxisIds = /* @__PURE__ */ new Set();
+  for (const ds of barDatasets) {
+    if (ds.visible) barAxisIds.add(datasetAxisMap.get(ds.id) ?? firstValueAxisId);
+  }
+  const valueSeries = [];
+  const categorySeries = [];
+  const scatterLogYValues = /* @__PURE__ */ new Map();
+  const collectLogValues = (axisId, values) => {
+    if (valueAxes.get(axisId)?.props?.type !== "logarithmic") return;
+    const bucket = scatterLogYValues.get(axisId) ?? [];
+    for (const v of values) if (v > 0) bucket.push(v);
+    scatterLogYValues.set(axisId, bucket);
+  };
+  for (const ld of lineDatasets) {
+    if (!ld.visible) continue;
+    const targetAxisId = ld.props[axisIdProp] ?? firstValueAxisId;
+    const includeZero = resolveIncludeZero(targetAxisId, valueAxes, barAxisIds);
+    const stackBases = lineStackBasesMap?.get(ld.id);
+    if (stackBases) {
+      if (isLinePercentStacked) {
+        valueDomains.set(targetAxisId, [0, 100]);
+      } else {
+        const transformedVals = lineTransformedValues?.get(ld.id) ?? [];
+        const cumulativeValues = transformedVals.map((v, i) => (stackBases[i] ?? 0) + v);
+        valueSeries.push({ axisId: targetAxisId, values: [includeZero ? 0 : Math.min(...cumulativeValues), Math.max(...cumulativeValues)], includeZero });
+        collectLogValues(targetAxisId, cumulativeValues);
+      }
+    } else {
+      const lineValues = (lineTransformedValues?.get(ld.id) ?? []).filter((v) => !Number.isNaN(v));
+      if (lineValues.length > 0) {
+        valueSeries.push({ axisId: targetAxisId, values: lineValues, includeZero });
+        collectLogValues(targetAxisId, lineValues);
+      }
+    }
+  }
+  const scatterLogXValues = /* @__PURE__ */ new Map();
+  for (const sd of scatterDatasets) {
+    if (!sd.visible) continue;
+    const targetYAxisId = sd.props.yAxisId ?? firstValueAxisId;
+    const rawYValues = batchResolveAccessor(sd.props.yField, sd.props.data ?? []);
+    const stackBases = scatterStackBasesMap?.get(sd.id);
+    const effectiveYValues = stackBases ? rawYValues.map((v, i) => v === null || v === void 0 || isNaN(Number(v)) ? null : Number(v) + (stackBases[i] ?? 0)) : rawYValues;
+    const yValues = effectiveYValues.filter((v) => v !== null && v !== void 0 && !isNaN(Number(v))).map(Number);
+    if (yValues.length > 0) {
+      valueSeries.push({ axisId: targetYAxisId, values: yValues, includeZero: false });
+      collectLogValues(targetYAxisId, yValues);
+    }
+    const targetXAxisId = sd.props.xAxisId ?? firstCategoryAxisId;
+    const xValues = batchResolveAccessor(sd.props.xField, sd.props.data ?? []).filter((v) => v !== null && v !== void 0 && !isNaN(Number(v))).map(Number);
+    if (xValues.length > 0) {
+      categorySeries.push({ axisId: targetXAxisId, values: xValues, includeZero: false });
+      if (categoryAxes.get(targetXAxisId)?.props?.type === "logarithmic") {
+        const bucket = scatterLogXValues.get(targetXAxisId) ?? [];
+        for (const v of xValues) if (v > 0) bucket.push(v);
+        scatterLogXValues.set(targetXAxisId, bucket);
+      }
+    }
+  }
+  for (const cd of candlestickDatasets) {
+    if (!cd.visible) continue;
+    const targetAxisId = cd.props.yAxisId ?? firstValueAxisId;
+    const lows = batchResolveAccessor(cd.props.lowField, cd.props.data ?? []);
+    const highs = batchResolveAccessor(cd.props.highField, cd.props.data ?? []);
+    const validValues = [...lows.filter((v) => v !== null && v !== void 0 && !isNaN(Number(v))).map(Number), ...highs.filter((v) => v !== null && v !== void 0 && !isNaN(Number(v))).map(Number)];
+    if (validValues.length > 0) valueSeries.push({ axisId: targetAxisId, values: validValues, includeZero: false });
+  }
+  const domainContributions = [];
+  if (valueSeries.length > 0 || categorySeries.length > 0) {
+    domainContributions.push(computeDomainContribution(valueSeries, categorySeries.length > 0 ? categorySeries : void 0));
+  }
+  const scatterXDomains = mergeDomainContributions(valueDomains, domainContributions);
+  for (const [axisId, positives] of scatterLogYValues) {
+    if (positives.length > 0) valueDomains.set(axisId, calculateNiceLogDomain(positives));
+  }
+  for (const [axisId, positives] of scatterLogXValues) {
+    if (positives.length > 0) scatterXDomains.set(axisId, calculateNiceLogDomain(positives));
+  }
+  if (scatterDatasets.length > 0) {
+    expandScatterBubblePadding({
+      scatterDatasets,
+      valueDomains,
+      scatterXDomains,
+      firstValueAxisId,
+      firstCategoryAxisId,
+      chartArea: cartesianArea,
+      isLogValueAxis: (axisId) => valueAxes.get(axisId)?.props?.type === "logarithmic",
+      isLogCategoryAxis: (axisId) => categoryAxes.get(axisId)?.props?.type === "logarithmic"
+    });
+  }
+  const dataLabelProps = features.get("dataLabels")?.props;
+  if (dataLabelProps && !dataLabelProps.render) {
+    const dataLabelFontSize = dataLabelProps.fontSize ?? DEFAULT_DATA_LABEL_FONT_SIZE;
+    const dataLabelAxisIds = /* @__PURE__ */ new Set([...barAxisIds, ...lineDatasets.filter((d) => d.visible).map((d) => d.props[axisIdProp] ?? firstValueAxisId)]);
+    expandDataLabelPadding({
+      valueDomains,
+      dataLabelFontSize,
+      orientation,
+      chartArea: cartesianArea,
+      axisIds: dataLabelAxisIds,
+      isLogAxis: (axisId) => valueAxes.get(axisId)?.props?.type === "logarithmic",
+      isPercentStackedAxis: (axisId) => {
+        if (mode.isPercentStacked && barAxisIds.has(axisId)) return true;
+        if (isLinePercentStacked && lineDatasets.some((d) => d.visible && (d.props[axisIdProp] ?? firstValueAxisId) === axisId)) return true;
+        return false;
+      }
+    });
+  }
+  for (const [axisId] of valueAxes) {
+    if (!valueDomains.has(axisId)) {
+      valueDomains.set(axisId, [0, 100]);
+    }
+  }
+  for (const [axisId, domain] of valueDomains) {
+    const axisConfig = valueAxes.get(axisId);
+    const axisSoftMin = axisConfig?.props?.softMin;
+    const axisSoftMax = axisConfig?.props?.softMax;
+    if (axisSoftMin !== void 0 && domain[0] > axisSoftMin) {
+      domain[0] = axisSoftMin;
+    }
+    if (axisSoftMax !== void 0 && domain[1] < axisSoftMax) {
+      domain[1] = axisSoftMax;
+    }
+  }
+  for (const [axisId, domain] of valueDomains) {
+    const axisConfig = valueAxes.get(axisId);
+    const axisMin = axisConfig?.props?.min;
+    const axisMax = axisConfig?.props?.max;
+    if (typeof axisMin === "number") domain[0] = axisMin;
+    if (typeof axisMax === "number") domain[1] = axisMax;
+  }
+  for (const [axisId, domain] of scatterXDomains) {
+    const axisConfig = categoryAxes.get(axisId);
+    const axisMin = axisConfig?.props?.min;
+    const axisMax = axisConfig?.props?.max;
+    if (typeof axisMin === "number") domain[0] = axisMin;
+    if (typeof axisMax === "number") domain[1] = axisMax;
+  }
+  for (const [axisId, domain] of valueDomains) {
+    const axisConfig = valueAxes.get(axisId);
+    if (typeof axisConfig?.props?.max === "number") continue;
+    const userTickCount = axisConfig?.props?.tickCount;
+    const valueAxisLength = orientation === "vertical" ? cartesianArea.height : cartesianArea.width;
+    const axisTickCount = getAdaptiveTickCount(valueAxisLength, userTickCount);
+    const ticks = generateNiceTicks(domain[0], domain[1], axisTickCount, userTickCount !== void 0);
+    if (ticks.length >= 2) {
+      const lastTick = ticks[ticks.length - 1];
+      let rawMax = -Infinity;
+      if (barRawResolved) {
+        for (let idx = 0; idx < barDatasets.length; idx++) {
+          const ds = barDatasets[idx];
+          if (!ds.visible || (datasetAxisMap.get(ds.id) ?? firstValueAxisId) !== axisId) continue;
+          if (idx < barRawResolved.length) {
+            for (const v of barRawResolved[idx]) {
+              if (typeof v === "number" && v > rawMax) rawMax = v;
+            }
+          }
+        }
+      }
+      for (const ld of lineDatasets) {
+        if (!ld.visible) continue;
+        const targetAxisId = ld.props[axisIdProp] ?? firstValueAxisId;
+        if (targetAxisId !== axisId) continue;
+        const vals = lineTransformedValues?.get(ld.id);
+        if (vals) {
+          for (const v of vals) {
+            if (!Number.isNaN(v) && v > rawMax) rawMax = v;
+          }
+        }
+      }
+      const tickStep = ticks[ticks.length - 1] - ticks[ticks.length - 2];
+      if (rawMax > -Infinity && !isLinePercentStacked && !mode.isStacked && !mode.isPercentStacked && !mode.isWaterfall) {
+        if (userTickCount === void 0 && tickStep > 0) {
+          const eps = tickStep * 1e-9;
+          let niceTop = Math.ceil((rawMax - eps) / tickStep) * tickStep;
+          if (niceTop <= rawMax) niceTop += tickStep;
+          domain[1] = niceTop;
+        } else if (lastTick <= rawMax) {
+          domain[1] = lastTick + tickStep;
+        }
+      }
+    }
+  }
+  const scatterAxisLength = orientation === "vertical" ? cartesianArea.width : cartesianArea.height;
+  for (const [axisId, domain] of scatterXDomains) {
+    const axisProps = categoryAxes.get(axisId)?.props;
+    if (axisProps?.type === "logarithmic") continue;
+    const userTickCount = axisProps?.tickCount;
+    if (userTickCount !== void 0) continue;
+    const hasExplicitMin = typeof axisProps?.min === "number";
+    const hasExplicitMax = typeof axisProps?.max === "number";
+    if (hasExplicitMin && hasExplicitMax) continue;
+    const ticks = generateNiceTicks(domain[0], domain[1], getAdaptiveTickCount(scatterAxisLength, userTickCount), false);
+    if (ticks.length >= 2) {
+      const tickStep = ticks[ticks.length - 1] - ticks[ticks.length - 2];
+      if (tickStep > 0) {
+        const eps = tickStep * 1e-9;
+        if (!hasExplicitMax) {
+          const niceTop = Math.ceil((domain[1] - eps) / tickStep) * tickStep;
+          if (niceTop > domain[1]) domain[1] = niceTop;
+        }
+        if (!hasExplicitMin) {
+          const niceFloor = Math.floor((domain[0] + eps) / tickStep) * tickStep;
+          if (niceFloor < domain[0]) domain[0] = niceFloor;
+        }
+      }
+    }
+  }
+  const valueDomain = (valueDomains.get(firstValueAxisId) ?? [0, 100]).slice();
+  if (styledRangeBoundaries && styledRangeBoundaries.length > 0) {
+    for (const rb of styledRangeBoundaries) {
+      if (rb.from < valueDomain[0]) valueDomain[0] = rb.from;
+      if (rb.to > valueDomain[1]) valueDomain[1] = rb.to;
+    }
+    valueDomains.set(firstValueAxisId, valueDomain);
+  }
+  const originalDomains = {};
+  const minUnit = primaryCategoryAxisConfig?.props?.minUnit;
+  let computedMinRange;
+  if (minUnit) {
+    computedMinRange = MS[minUnit] * 10;
+  } else if (isTimeAxis && timestamps && timestamps.length >= 2) {
+    const sorted = [...timestamps].filter((t) => !isNaN(t)).sort((a, b) => a - b);
+    let minInterval = Infinity;
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i] - sorted[i - 1];
+      if (gap > 0 && gap < minInterval) minInterval = gap;
+    }
+    if (isFinite(minInterval)) {
+      computedMinRange = minInterval * 5;
+    }
+  }
+  if (computedMinRange !== void 0) {
+    if (orientation === "vertical") {
+      originalDomains.minRangeX = computedMinRange;
+    } else {
+      originalDomains.minRangeY = computedMinRange;
+    }
+  }
+  const primaryValueDomain = valueDomains.get(firstValueAxisId);
+  if (primaryValueDomain) {
+    if (orientation === "vertical") {
+      originalDomains.y = [...primaryValueDomain];
+    } else {
+      originalDomains.x = [...primaryValueDomain];
+    }
+  }
+  if (scatterXDomains.size > 0) {
+    const firstScatterXDomain = scatterXDomains.values().next().value;
+    if (firstScatterXDomain) {
+      if (orientation === "vertical" && !originalDomains.x) {
+        originalDomains.x = [...firstScatterXDomain];
+      } else if (orientation !== "vertical" && !originalDomains.y) {
+        originalDomains.y = [...firstScatterXDomain];
+      }
+    }
+  }
+  const zoomCategoryAxisForAdaptive = orientation === "vertical" ? zoomState?.x : zoomState?.y;
+  const zoomValueAxisExplicit = orientation === "vertical" ? zoomState?.y : zoomState?.x;
+  if (zoomCategoryAxisForAdaptive && !zoomValueAxisExplicit && (isTimeAxis && timestamps || scatterXDomains.size > 0)) {
+    const xMin = zoomCategoryAxisForAdaptive.min;
+    const xMax = zoomCategoryAxisForAdaptive.max;
+    const adaptiveSeries = [];
+    if (timestamps) {
+      if (valuesPerDataset) {
+        for (let di = 0; di < barDatasets.length; di++) {
+          if (!barDatasets[di].visible) continue;
+          adaptiveSeries.push({
+            axisId: datasetAxisMap.get(barDatasets[di].id) ?? firstValueAxisId,
+            xValues: timestamps,
+            yValues: valuesPerDataset[di]
+          });
+        }
+      }
+      for (const ld of lineDatasets) {
+        if (!ld.visible) continue;
+        const resolved = lineTransformedValues?.get(ld.id);
+        if (!resolved) continue;
+        adaptiveSeries.push({
+          axisId: ld.props[axisIdProp] ?? firstValueAxisId,
+          xValues: timestamps,
+          yValues: resolved
+        });
+      }
+    }
+    for (const sd of scatterDatasets) {
+      if (!sd.visible) continue;
+      adaptiveSeries.push({
+        axisId: sd.props.yAxisId ?? firstValueAxisId,
+        xValues: batchResolveAccessor(sd.props.xField, sd.props.data ?? []),
+        yValues: batchResolveAccessor(sd.props.yField, sd.props.data ?? [])
+      });
+    }
+    const adaptiveValues = computeVisibleValues(adaptiveSeries, xMin, xMax);
+    for (const [axisId, vals] of adaptiveValues) {
+      if (vals.length === 0) continue;
+      const includeZero = resolveIncludeZero(axisId, valueAxes, barAxisIds);
+      const adaptiveDomain = calculateNiceDomain(vals, { includeZero });
+      valueDomains.set(axisId, adaptiveDomain);
+      if (axisId === firstValueAxisId) {
+        valueDomain[0] = adaptiveDomain[0];
+        valueDomain[1] = adaptiveDomain[1];
+      }
+    }
+  }
+  if (zoomValueAxisExplicit) {
+    valueDomains.set(firstValueAxisId, [zoomValueAxisExplicit.min, zoomValueAxisExplicit.max]);
+    valueDomain[0] = zoomValueAxisExplicit.min;
+    valueDomain[1] = zoomValueAxisExplicit.max;
+  }
+  const zoomCategoryAxis = orientation === "vertical" ? zoomState?.x : zoomState?.y;
+  if (zoomCategoryAxis && scatterXDomains.size > 0) {
+    for (const [axisId] of scatterXDomains) {
+      scatterXDomains.set(axisId, [zoomCategoryAxis.min, zoomCategoryAxis.max]);
+    }
+  }
+  return { scatterXDomains, valueDomain, originalDomains };
+}
+
+// src/cartesian/layout.data-reduction.ts
+function applyDataGrouping(params) {
+  const { groupingConfig, isTimeAxis, categoryDataSource, categoryKey, barDatasets, lineDatasets } = params;
+  let { categories, timestamps, originalTimestamps, groupedDataOverride } = params;
+  if (groupingConfig && isTimeAxis && timestamps && timestamps.length > 0) {
+    const targetPoints = groupingConfig.targetPoints ?? 500;
+    const method = groupingConfig.method ?? "average";
+    const enabled = groupingConfig.enabled ?? categoryDataSource.length > targetPoints;
+    if (enabled) {
+      const interval = groupingConfig.interval ?? selectGroupingInterval(timestamps[timestamps.length - 1] - timestamps[0], categoryDataSource.length, targetPoints);
+      const catKey = categoryKey;
+      for (const ds of barDatasets) {
+        if (!ds.props.data || ds.props.data.length === 0) continue;
+        const valueKey = ds.props.valueField ?? FIELD_DEFAULTS.valueField;
+        const grouped = groupTimeData(ds.props.data, catKey, valueKey, interval, method);
+        if (grouped.length < ds.props.data.length) {
+          ds.props = { ...ds.props, data: grouped };
+        }
+      }
+      for (const ds of lineDatasets) {
+        if (!ds.props.data || ds.props.data.length === 0) continue;
+        const valueKey = ds.props.valueField ?? FIELD_DEFAULTS.valueField;
+        const grouped = groupTimeData(ds.props.data, catKey, valueKey, interval, method);
+        if (grouped.length < ds.props.data.length) {
+          ds.props = { ...ds.props, data: grouped };
+          if (!groupedDataOverride) groupedDataOverride = /* @__PURE__ */ new Map();
+          groupedDataOverride.set(ds.id, ds.props.data);
+        }
+      }
+      const groupedSource = barDatasets[0]?.props.data ?? lineDatasets[0]?.props.data ?? [];
+      const groupedRaw = batchResolveAccessor(catKey, groupedSource);
+      timestamps = groupedRaw.map(toTimestamp);
+      originalTimestamps = timestamps;
+      categories = timestamps.map(String);
+    }
+  }
+  return { categories, timestamps, originalTimestamps, groupedDataOverride };
+}
+function applyDecimation(params) {
+  const { decimationConfig, zoomX, barDatasets, lineDatasets, isTimeAxis } = params;
+  let { categories, timestamps, groupedDataOverride } = params;
+  let decimatedIndices;
+  if (decimationConfig) {
+    const samples = decimationConfig.samples ?? 500;
+    const threshold = decimationConfig.threshold ?? samples;
+    const algorithm = decimationConfig.algorithm ?? "lttb";
+    const allBarLineDatasets = [...barDatasets, ...lineDatasets];
+    const firstVisible = allBarLineDatasets.find((d) => d.visible) ?? allBarLineDatasets[0];
+    if (firstVisible && firstVisible.props.data.length > threshold) {
+      const yField = firstVisible.props.valueField;
+      const sourceData = firstVisible.props.data;
+      let keptIndicesArr;
+      if (zoomX && timestamps) {
+        const zoomIndices = [];
+        const zoomYVals = [];
+        for (let i = 0; i < timestamps.length; i++) {
+          if (timestamps[i] >= zoomX.min && timestamps[i] <= zoomX.max) {
+            zoomIndices.push(i);
+            zoomYVals.push(resolveAccessor(yField, makeItemContext(sourceData[i], i)));
+          }
+        }
+        if (zoomIndices.length <= samples) {
+          keptIndicesArr = zoomIndices;
+        } else {
+          const relKept = decimate(zoomYVals, { algorithm, threshold, samples });
+          keptIndicesArr = relKept.map((ri) => zoomIndices[ri]);
+        }
+      } else {
+        const allYVals = batchResolveRequired(yField, sourceData, "yField");
+        keptIndicesArr = decimate(allYVals, { algorithm, threshold, samples });
+      }
+      for (const ds of allBarLineDatasets) {
+        const data = ds.props.data;
+        ds.props = { ...ds.props, data: keptIndicesArr.map((i) => data[i]) };
+      }
+      categories = keptIndicesArr.map((i) => categories[i]);
+      if (isTimeAxis && timestamps) {
+        timestamps = keptIndicesArr.map((i) => timestamps[i]);
+      }
+      if (lineDatasets.length > 0) {
+        if (!groupedDataOverride) groupedDataOverride = /* @__PURE__ */ new Map();
+        for (const ld of lineDatasets) {
+          groupedDataOverride.set(ld.id, ld.props.data);
+        }
+      }
+      decimatedIndices = keptIndicesArr;
+    }
+  }
+  return { categories, timestamps, groupedDataOverride, decimatedIndices };
+}
+
+// src/cartesian/layout.ts
+function computeCartesianLayout(input, lastVisibleLayouts) {
+  const { cartesianArea, datasets, axes, features, datasetVisibility, chartId, renderer, dimensions, zoomState, dir, font: globalFont, locale } = input;
+  const isRtl = dir === "rtl";
+  const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+  const collected = collectItems(sortedDatasets, datasetVisibility);
+  const barDatasets = collected.bar;
+  const lineDatasets = collected.line;
+  const scatterDatasets = collected.scatter;
+  const candlestickDatasets = collected.candlestick;
+  if (barDatasets.length === 0 && lineDatasets.length === 0 && scatterDatasets.length === 0 && candlestickDatasets.length === 0) {
+    return null;
+  }
+  const visibleBarDatasets = barDatasets.filter((d) => d.visible);
+  const { width, height } = dimensions;
+  const responsiveFeature = features.get("responsive")?.props;
+  const tier = getResponsiveTier(width, responsiveFeature?.breakpoints);
+  const adaptive = responsiveFeature?.disableAutoAdaptive ? getAdaptiveDefaults("lg", globalFont) : getAdaptiveDefaults(tier, globalFont);
+  const allCatSources = [];
+  for (const ds of barDatasets) {
+    const key = ds.props.categoryField ?? FIELD_DEFAULTS.categoryField;
+    const data = ds.props.data ?? [];
+    if (data.length > 0) allCatSources.push({ key, data, tier: 0 });
+  }
+  for (const ds of candlestickDatasets) {
+    const key = ds.props.timeField;
+    const data = ds.props.data ?? [];
+    if (data.length > 0) allCatSources.push({ key, data, tier: 1 });
+  }
+  for (const ds of lineDatasets) {
+    const key = ds.props.categoryField ?? FIELD_DEFAULTS.categoryField;
+    const data = ds.props.data ?? [];
+    if (data.length > 0) allCatSources.push({ key, data, tier: 2 });
+  }
+  allCatSources.sort((a, b) => b.data.length - a.data.length || a.tier - b.tier);
+  const primaryCatSource = allCatSources[0];
+  let categoryKey;
+  let categoryDataSource;
+  if (primaryCatSource) {
+    categoryKey = primaryCatSource.key;
+    categoryDataSource = primaryCatSource.data;
+  } else {
+    categoryKey = "__scatter_no_category__";
+    categoryDataSource = [];
+  }
+  const orientation = barDatasets[0]?.props?.orientation ?? "vertical";
+  const categoryAxes = orientation === "vertical" ? axes.x : axes.y;
+  const primaryCategoryAxisConfig = categoryAxes.size > 0 ? categoryAxes.values().next().value : void 0;
+  const isTimeAxis = primaryCategoryAxisConfig?.props?.type === "time";
+  let categories;
+  let timestamps;
+  let originalTimestamps;
+  let groupedDataOverride;
+  if (isTimeAxis) {
+    const seenTs = /* @__PURE__ */ new Set();
+    const allTs = [];
+    for (const src of allCatSources) {
+      const rawValues = batchResolveAccessor(src.key, src.data);
+      for (const v of rawValues) {
+        const t = toTimestamp(v);
+        if (!isNaN(t) && !seenTs.has(t)) {
+          seenTs.add(t);
+          allTs.push(t);
+        }
+      }
+    }
+    allTs.sort((a, b) => a - b);
+    timestamps = allTs;
+    originalTimestamps = timestamps;
+    categories = timestamps.map(String);
+  } else {
+    const seenCats = /* @__PURE__ */ new Set();
+    categories = [];
+    for (const src of allCatSources) {
+      const cats = batchResolveRequired(src.key, src.data, "categoryField");
+      for (const cat of cats) {
+        if (!seenCats.has(cat)) {
+          seenCats.add(cat);
+          categories.push(cat);
+        }
+      }
+    }
+  }
+  const valueAxes = orientation === "vertical" ? axes.y : axes.x;
+  const firstValueAxisId = valueAxes.size > 0 ? valueAxes.keys().next().value : "default";
+  const axisIdProp = orientation === "vertical" ? "yAxisId" : "xAxisId";
+  const datasetAxisMap = /* @__PURE__ */ new Map();
+  let mode = { isStacked: false, isWaterfall: false, isPercentStacked: false, isGrouped: false, isOverlap: false };
+  let isVariwide = false;
+  let valuesPerDataset = [];
+  let categoryTotals;
+  let waterfallBases;
+  let effectiveScaleCategories = categories.slice();
+  let effectiveWeights;
+  let sortedCategoryOrder;
+  let styledBoundaries;
+  let styledRangeBoundaries;
+  let rangeLabelOffset = 0;
+  const valueDomains = /* @__PURE__ */ new Map();
+  const groupingConfig = isTimeAxis ? primaryCategoryAxisConfig?.props?.grouping : void 0;
+  ({ categories, timestamps, originalTimestamps, groupedDataOverride } = applyDataGrouping({
+    groupingConfig,
+    isTimeAxis,
+    timestamps,
+    originalTimestamps,
+    categories,
+    categoryDataSource,
+    categoryKey,
+    barDatasets,
+    lineDatasets,
+    groupedDataOverride
+  }));
+  const decimationConfig = features.get("decimation")?.props;
+  const decimationZoomX = orientation === "vertical" ? zoomState?.x : zoomState?.y;
+  const decimation = applyDecimation({
+    decimationConfig,
+    zoomX: decimationZoomX,
+    barDatasets,
+    lineDatasets,
+    timestamps,
+    categories,
+    isTimeAxis,
+    groupedDataOverride
+  });
+  categories = decimation.categories;
+  timestamps = decimation.timestamps;
+  groupedDataOverride = decimation.groupedDataOverride;
+  const decimatedIndices = decimation.decimatedIndices;
+  let barRawResolved;
+  if (barDatasets.length > 0) {
+    ({ mode, isVariwide, valuesPerDataset, categoryTotals, waterfallBases, effectiveScaleCategories, effectiveWeights, sortedCategoryOrder, styledBoundaries, styledRangeBoundaries, rangeLabelOffset, barRawResolved } = computeBarPipeline({
+      features,
+      barDatasets,
+      lineDatasets,
+      orientation,
+      categories,
+      globalFont,
+      isTimeAxis,
+      axisIdProp,
+      firstValueAxisId,
+      valueAxes,
+      cartesianArea,
+      valueDomains,
+      datasetAxisMap,
+      mode,
+      effectiveScaleCategories
+    }));
+  }
+  let lineStackBasesMap;
+  let lineTransformedValues;
+  const stackedLineDatasets = lineDatasets.filter((d) => d.stackId !== void 0);
+  const stackingConfig = features.get("stacking")?.props;
+  const isLinePercentStacked = stackedLineDatasets.length > 0 && stackingConfig?.mode === "percent";
+  if (stackedLineDatasets.length > 0) {
+    const rawLineValues = stackedLineDatasets.map((ld) => {
+      if (!ld.visible) return new Array(categories.length).fill(0);
+      const valueKey = ld.props.valueField ?? FIELD_DEFAULTS.valueField;
+      const raw = batchResolveAccessor(valueKey, ld.props.data ?? []);
+      return raw.map((v) => v === null || v === void 0 || Number.isNaN(Number(v)) ? 0 : Number(v));
+    });
+    const lineMode = {
+      isPercentStacked: stackingConfig?.mode === "percent"
+    };
+    const transformed = transformValues(rawLineValues, categories.length, lineMode);
+    const lineValuesPerDataset = transformed.transformed;
+    lineTransformedValues = /* @__PURE__ */ new Map();
+    for (let i = 0; i < stackedLineDatasets.length; i++) {
+      lineTransformedValues.set(stackedLineDatasets[i].id, lineValuesPerDataset[i]);
+    }
+    const lineSignsPerDataset = isLinePercentStacked ? void 0 : stackedLineDatasets.map((ld) => {
+      const valueKey = ld.props.valueField ?? FIELD_DEFAULTS.valueField;
+      const raw = batchResolveAccessor(valueKey, ld.props.data ?? []);
+      return (raw ?? []).map((v) => typeof v === "number" && isFinite(v) && v < 0 ? -1 : v === 0 ? 0 : 1);
+    });
+    lineStackBasesMap = computeStackBases(
+      stackedLineDatasets.map((d) => d.id),
+      lineValuesPerDataset,
+      categories.length,
+      { isStacked: true, isWaterfall: false },
+      void 0,
+      lineSignsPerDataset
+    );
+  }
+  for (const ld of lineDatasets) {
+    if (ld.stackId !== void 0) continue;
+    const valueKey = ld.props.valueField ?? FIELD_DEFAULTS.valueField;
+    const raw = batchResolveAccessor(valueKey, ld.props.data ?? []);
+    const resolved = raw.map((v) => v === null || v === void 0 || isNaN(Number(v)) ? NaN : Number(v));
+    if (!lineTransformedValues) lineTransformedValues = /* @__PURE__ */ new Map();
+    lineTransformedValues.set(ld.id, resolved);
+  }
+  let scatterStackBasesMap;
+  const stackedScatterDatasets = scatterDatasets.filter((d) => d.stackId !== void 0);
+  if (stackedScatterDatasets.length > 0) {
+    const scatterPointCount = stackedScatterDatasets.reduce((max, sd) => Math.max(max, sd.props.data?.length ?? 0), 0);
+    const rawScatterValues = stackedScatterDatasets.map((sd) => {
+      if (!sd.visible) return new Array(scatterPointCount).fill(0);
+      const raw = batchResolveAccessor(sd.props.yField, sd.props.data ?? []);
+      const padded = new Array(scatterPointCount).fill(0);
+      for (let i = 0; i < raw.length; i++) {
+        const v = raw[i];
+        padded[i] = v === null || v === void 0 || Number.isNaN(Number(v)) ? 0 : Number(v);
+      }
+      return padded;
+    });
+    const scatterSignsPerDataset = stackedScatterDatasets.map((sd) => {
+      const raw = batchResolveAccessor(sd.props.yField, sd.props.data ?? []);
+      const signs = new Array(scatterPointCount).fill(1);
+      for (let i = 0; i < raw.length; i++) {
+        const v = raw[i];
+        signs[i] = typeof v === "number" && isFinite(v) && v < 0 ? -1 : v === 0 ? 0 : 1;
+      }
+      return signs;
+    });
+    scatterStackBasesMap = computeStackBases(
+      stackedScatterDatasets.map((d) => d.id),
+      rawScatterValues,
+      scatterPointCount,
+      { isStacked: true, isWaterfall: false },
+      void 0,
+      scatterSignsPerDataset
+    );
+  }
+  const { scatterXDomains, valueDomain, originalDomains } = computeDomainContributions({
+    orientation,
+    axes,
+    barDatasets,
+    lineDatasets,
+    scatterDatasets,
+    candlestickDatasets,
+    datasetAxisMap,
+    firstValueAxisId,
+    valueAxes,
+    categoryAxes,
+    axisIdProp,
+    lineStackBasesMap,
+    lineTransformedValues,
+    isLinePercentStacked,
+    scatterStackBasesMap,
+    cartesianArea,
+    features,
+    mode,
+    styledRangeBoundaries,
+    barRawResolved,
+    primaryCategoryAxisConfig,
+    isTimeAxis,
+    timestamps,
+    valuesPerDataset,
+    zoomState,
+    valueDomains
+  });
+  const categoryScaleAxisProps = orientation === "vertical" ? axes.x.values().next().value?.props : axes.y.values().next().value?.props;
+  const firstBarProps = barDatasets[0]?.props;
+  const bandScaleOptions = categoryScaleAxisProps?.scale === "point" ? {
+    categoryGap: 1,
+    chartPaddingMin: categoryScaleAxisProps?.chartPaddingMin ?? 0.05,
+    chartPaddingMax: categoryScaleAxisProps?.chartPaddingMax ?? 0.05
+  } : {
+    ...firstBarProps?.categoryGap !== void 0 && { categoryGap: firstBarProps.categoryGap },
+    ...categoryScaleAxisProps?.chartPaddingMin !== void 0 && { chartPaddingMin: categoryScaleAxisProps.chartPaddingMin },
+    ...categoryScaleAxisProps?.chartPaddingMax !== void 0 && { chartPaddingMax: categoryScaleAxisProps.chartPaddingMax }
+  };
+  const scaleCategories = effectiveScaleCategories;
+  let sharedCategoryScale;
+  let sharedTimeScale;
+  let timeAxisTimezone;
+  let rawStreamTimeDomain;
+  const valueScaleRange = orientation === "vertical" ? [cartesianArea.y + cartesianArea.height, cartesianArea.y] : [cartesianArea.x, cartesianArea.x + cartesianArea.width];
+  if (isTimeAxis && timestamps && timestamps.length > 0) {
+    const validTs = timestamps.filter((t) => !isNaN(t));
+    const domainTs = (originalTimestamps ?? timestamps).filter((t) => !isNaN(t));
+    const timeAxisProps = primaryCategoryAxisConfig?.props;
+    timeAxisTimezone = timeAxisProps?.timezone;
+    let rawTsMin = Infinity;
+    let rawTsMax = -Infinity;
+    for (const t of domainTs) {
+      if (t < rawTsMin) rawTsMin = t;
+      if (t > rawTsMax) rawTsMax = t;
+    }
+    let [tsMin, tsMax] = calculateNiceTimeDomain(domainTs, {
+      min: timeAxisProps?.min,
+      max: timeAxisProps?.max
+    });
+    if (orientation === "vertical") {
+      originalDomains.x = [tsMin, tsMax];
+    } else {
+      originalDomains.y = [tsMin, tsMax];
+    }
+    const zoomCategoryAxis = orientation === "vertical" ? zoomState?.x : zoomState?.y;
+    if (zoomCategoryAxis) {
+      tsMin = zoomCategoryAxis.min;
+      tsMax = zoomCategoryAxis.max;
+    }
+    const timeReversed = primaryCategoryAxisConfig?.props?.reversed ?? false;
+    const effectiveTimeReversed = orientation === "vertical" ? isRtl ? !timeReversed : timeReversed : timeReversed;
+    const catRange = orientation === "vertical" ? effectiveTimeReversed ? [cartesianArea.x + cartesianArea.width, cartesianArea.x] : [cartesianArea.x, cartesianArea.x + cartesianArea.width] : effectiveTimeReversed ? [cartesianArea.y + cartesianArea.height, cartesianArea.y] : [cartesianArea.y, cartesianArea.y + cartesianArea.height];
+    let minDataInterval = Infinity;
+    if (validTs.length >= 2) {
+      const sortedTs = [...validTs].sort((a, b) => a - b);
+      for (let i = 1; i < sortedTs.length; i++) {
+        const gap = sortedTs[i] - sortedTs[i - 1];
+        if (gap > 0 && gap < minDataInterval) minDataInterval = gap;
+      }
+    }
+    if (!zoomCategoryAxis && isFinite(rawTsMin) && isFinite(rawTsMax)) {
+      const span = rawTsMax - rawTsMin;
+      const padMin = (timeAxisProps?.chartPaddingMin ?? 0) * span;
+      const padMax = (timeAxisProps?.chartPaddingMax ?? 0) * span;
+      rawStreamTimeDomain = [rawTsMin - padMin, rawTsMax + padMax];
+    }
+    let effectiveTickConfig = timeAxisProps?.tickConfig;
+    if (!effectiveTickConfig?.baseInterval && !effectiveTickConfig?.minInterval && isFinite(minDataInterval)) {
+      const detectedUnit = minDataInterval >= MS.year ? { unit: "year", count: 1 } : minDataInterval >= MS.month ? { unit: "month", count: 1 } : minDataInterval >= MS.week ? { unit: "week", count: 1 } : minDataInterval >= MS.day ? { unit: "day", count: 1 } : minDataInterval >= MS.hour ? { unit: "hour", count: 1 } : minDataInterval >= MS.minute ? { unit: "minute", count: 1 } : minDataInterval >= MS.second ? { unit: "second", count: 1 } : { unit: "millisecond", count: 1 };
+      effectiveTickConfig = { ...effectiveTickConfig, minInterval: detectedUnit };
+    }
+    const scaleDomain = rawStreamTimeDomain ?? [tsMin, tsMax];
+    if (timeAxisProps?.gapless && validTs.length > 0) {
+      const sortedUnique = [...new Set(validTs)].sort((a, b) => a - b);
+      const gaplessDefaultPad = sortedUnique.length > 1 ? 0.5 / (sortedUnique.length - 1) : 0;
+      const gaplessPadStart = zoomCategoryAxis ? 0 : timeAxisProps?.chartPaddingMin ?? gaplessDefaultPad;
+      const gaplessPadEnd = zoomCategoryAxis ? 0 : timeAxisProps?.chartPaddingMax ?? gaplessDefaultPad;
+      sharedTimeScale = createOrdinalTimeScale(sortedUnique, catRange, { visibleDomain: [tsMin, tsMax], tickConfig: effectiveTickConfig, padStart: gaplessPadStart, padEnd: gaplessPadEnd });
+      sharedCategoryScale = createOrdinalTimeBandAdapter(sortedUnique, sharedTimeScale);
+    } else {
+      sharedTimeScale = createTimeScale(scaleDomain, catRange, { tickConfig: effectiveTickConfig });
+      sharedCategoryScale = createTimeBandAdapter(validTs, sharedTimeScale);
+    }
+  } else {
+    const totalCategories = scaleCategories.length;
+    if (totalCategories > 0) {
+      const catMinRange = Math.min(1, totalCategories - 1);
+      if (orientation === "vertical") {
+        if (!originalDomains.x) originalDomains.x = [0, totalCategories - 1];
+        if (!originalDomains.minRangeX) originalDomains.minRangeX = catMinRange;
+      } else {
+        if (!originalDomains.y) originalDomains.y = [0, totalCategories - 1];
+        if (!originalDomains.minRangeY) originalDomains.minRangeY = catMinRange;
+      }
+    }
+    const zoomCatAxis = orientation === "vertical" ? zoomState?.x : zoomState?.y;
+    let visibleCategories = scaleCategories;
+    let visibleWeights = effectiveWeights;
+    if (zoomCatAxis && totalCategories > 0) {
+      const startIdx = Math.max(0, Math.floor(zoomCatAxis.min));
+      const endIdx = Math.min(totalCategories - 1, Math.ceil(zoomCatAxis.max));
+      visibleCategories = scaleCategories.slice(startIdx, endIdx + 1);
+      if (visibleWeights) {
+        visibleWeights = visibleWeights.slice(startIdx, endIdx + 1);
+      }
+    }
+    if (orientation === "vertical") {
+      const catReversed = primaryCategoryAxisConfig?.props?.reversed ?? false;
+      const effectiveCatReversed = isRtl ? !catReversed : catReversed;
+      const catRangeX = effectiveCatReversed ? [cartesianArea.x + cartesianArea.width, cartesianArea.x] : [cartesianArea.x, cartesianArea.x + cartesianArea.width];
+      sharedCategoryScale = isVariwide && visibleWeights ? createVariwideBandScale(visibleCategories, catRangeX, { ...bandScaleOptions, weights: visibleWeights }) : createBandScale(visibleCategories, catRangeX, bandScaleOptions);
+    } else {
+      const catReversed = primaryCategoryAxisConfig?.props?.reversed ?? false;
+      const catRangeY = catReversed ? [cartesianArea.y + cartesianArea.height, cartesianArea.y] : [cartesianArea.y, cartesianArea.y + cartesianArea.height];
+      sharedCategoryScale = isVariwide && visibleWeights ? createVariwideBandScale(visibleCategories, catRangeY, { ...bandScaleOptions, weights: visibleWeights }) : createBandScale(visibleCategories, catRangeY, bandScaleOptions);
+    }
+  }
+  for (const [axisId, domain] of valueDomains) {
+    const axisProps = valueAxes.get(axisId)?.props;
+    const padMin = axisProps?.chartPaddingMin ?? 0;
+    const padMax = axisProps?.chartPaddingMax ?? 0;
+    if (padMin === 0 && padMax === 0) continue;
+    if (axisProps?.type === "logarithmic" && domain[0] > 0 && domain[1] > 0) {
+      const lo = Math.log10(domain[0]);
+      const hi = Math.log10(domain[1]);
+      const span = hi - lo;
+      domain[0] = Math.pow(10, lo - span * padMin);
+      domain[1] = Math.pow(10, hi + span * padMax);
+    } else {
+      const span = domain[1] - domain[0];
+      domain[0] = domain[0] - span * padMin;
+      domain[1] = domain[1] + span * padMax;
+    }
+  }
+  const valueScales = /* @__PURE__ */ new Map();
+  for (const [axisId, domain] of valueDomains) {
+    const axisConfig = valueAxes.get(axisId);
+    const axisType = axisConfig?.props?.type;
+    const axisReversed = axisConfig?.props?.reversed ?? false;
+    const range = axisReversed ? [valueScaleRange[1], valueScaleRange[0]] : valueScaleRange;
+    if (axisType === "logarithmic") {
+      valueScales.set(axisId, createLogScale(domain, range));
+    } else {
+      valueScales.set(axisId, createLinearScale(domain, range));
+    }
+  }
+  const primaryReversed = valueAxes.get(firstValueAxisId)?.props?.reversed ?? false;
+  const primaryRange = primaryReversed ? [valueScaleRange[1], valueScaleRange[0]] : valueScaleRange;
+  const sharedValueScale = valueScales.get(firstValueAxisId) ?? createLinearScale(valueDomain, primaryRange);
+  const scatterXScales = /* @__PURE__ */ new Map();
+  const categoryScaleRange = orientation === "vertical" ? [cartesianArea.x, cartesianArea.x + cartesianArea.width] : [cartesianArea.y, cartesianArea.y + cartesianArea.height];
+  for (const [axisId, domain] of scatterXDomains) {
+    const scatterAxisConfig = categoryAxes.get(axisId);
+    const scatterAxisProps = scatterAxisConfig?.props;
+    const scatterReversed = scatterAxisProps?.reversed ?? false;
+    const effectiveScatterReversed = orientation === "vertical" ? isRtl ? !scatterReversed : scatterReversed : scatterReversed;
+    const scatterRange = effectiveScatterReversed ? [categoryScaleRange[1], categoryScaleRange[0]] : categoryScaleRange;
+    const scatterAxisType = scatterAxisProps?.type;
+    const padMin = scatterAxisProps?.chartPaddingMin ?? 0;
+    const padMax = scatterAxisProps?.chartPaddingMax ?? 0;
+    let paddedDomain = domain;
+    if (padMin !== 0 || padMax !== 0) {
+      if (scatterAxisType === "logarithmic" && domain[0] > 0 && domain[1] > 0) {
+        const lo = Math.log10(domain[0]);
+        const hi = Math.log10(domain[1]);
+        const span = hi - lo;
+        paddedDomain = [Math.pow(10, lo - span * padMin), Math.pow(10, hi + span * padMax)];
+      } else {
+        const span = domain[1] - domain[0];
+        paddedDomain = [domain[0] - span * padMin, domain[1] + span * padMax];
+      }
+      scatterXDomains.set(axisId, paddedDomain);
+    }
+    scatterXScales.set(axisId, scatterAxisType === "logarithmic" ? createLogScale(paddedDomain, scatterRange) : createLinearScale(paddedDomain, scatterRange));
+  }
+  let stackBasesMap;
+  let groupLayout;
+  if (mode.isStacked || mode.isWaterfall) {
+    const signsPerDataset = mode.isPercentStacked ? void 0 : barDatasets.map((d, i) => {
+      const raw = d.visible ? barRawResolved?.[i] : batchResolveAccessor(d.props.valueField, d.props.data);
+      return (raw ?? []).map((v) => typeof v === "number" && isFinite(v) && v < 0 ? -1 : v === 0 ? 0 : 1);
+    });
+    if (mode.isGrouped) {
+      const groupMap = /* @__PURE__ */ new Map();
+      for (let dsIdx = 0; dsIdx < barDatasets.length; dsIdx++) {
+        const sid = barDatasets[dsIdx].stackId;
+        if (!groupMap.has(sid)) groupMap.set(sid, { dsIndices: [], dsIds: [], values: [] });
+        const g = groupMap.get(sid);
+        g.dsIndices.push(dsIdx);
+        g.dsIds.push(barDatasets[dsIdx].id);
+        g.values.push(valuesPerDataset[dsIdx]);
+      }
+      stackBasesMap = /* @__PURE__ */ new Map();
+      for (const { dsIds, dsIndices, values } of groupMap.values()) {
+        const groupSigns = signsPerDataset ? dsIndices.map((i) => signsPerDataset[i]) : void 0;
+        const groupBases = computeStackBases(dsIds, values, categories.length, { isStacked: true, isWaterfall: false }, void 0, groupSigns);
+        for (const [id, bases] of groupBases) stackBasesMap.set(id, bases);
+      }
+    } else {
+      stackBasesMap = computeStackBases(
+        barDatasets.map((d) => d.id),
+        valuesPerDataset,
+        categories.length,
+        mode,
+        waterfallBases,
+        signsPerDataset
+      );
+    }
+  }
+  const barGap = barDatasets[0]?.props?.barGap;
+  let fullGroupLayout = null;
+  if (mode.isGrouped) {
+    if (mode.isStacked) {
+      const visibleStackIds = [...new Set(visibleBarDatasets.map((d) => d.stackId))];
+      const allStackIds = [...new Set(barDatasets.map((d) => d.stackId))];
+      groupLayout = calculateGroupedBarLayout(visibleStackIds.length, sharedCategoryScale.bandwidth(), barGap);
+      fullGroupLayout = calculateGroupedBarLayout(allStackIds.length, sharedCategoryScale.bandwidth(), barGap);
+    } else {
+      groupLayout = calculateGroupedBarLayout(visibleBarDatasets.length, sharedCategoryScale.bandwidth(), barGap);
+      fullGroupLayout = calculateGroupedBarLayout(barDatasets.length, sharedCategoryScale.bandwidth(), barGap);
+    }
+  }
+  const hiddenValueAxes = computeHiddenValueAxes({
+    barDatasets,
+    lineDatasets,
+    scatterDatasets,
+    candlestickDatasets,
+    datasetAxisMap,
+    firstValueAxisId,
+    axisIdProp,
+    valueAxesSize: valueAxes.size
+  });
+  const { axisLayouts, xAxisLayout, yAxisLayout } = computeAxisLayouts({
+    axes,
+    isRtl,
+    orientation,
+    valueScales,
+    sharedValueScale,
+    sharedTimeScale,
+    sharedCategoryScale,
+    scatterXScales,
+    valueDomains,
+    scatterXDomains,
+    mode,
+    adaptive,
+    cartesianArea,
+    styledBoundaries,
+    rangeLabelOffset,
+    hiddenValueAxes,
+    lastVisibleLayouts,
+    globalFont,
+    locale
+  });
+  let categoryAxisSpace = 0;
+  const primaryCatAxisKey = orientation === "horizontal" ? `y:${axes.y.keys().next().value}` : `x:${axes.x.keys().next().value}`;
+  const primaryCatAxis = axisLayouts.get(primaryCatAxisKey);
+  if (styledBoundaries && primaryCatAxis) {
+    const catBaseProps = primaryCatAxis.props;
+    const catPosition = primaryCatAxis.position;
+    const catIsHorizontal = catPosition === "top" || catPosition === "bottom";
+    let catTickPositions;
+    const catAutoRotate = catBaseProps?.autoRotate ?? true;
+    const catAutoRotateAngle = catBaseProps?.autoRotateAngle ?? -45;
+    if (catAutoRotate && catIsHorizontal && scaleCategories.length > 1 && sharedCategoryScale) {
+      catTickPositions = scaleCategories.map((cat, i) => {
+        const pos = sharedCategoryScale(cat);
+        const bw = sharedCategoryScale.bandwidthAt?.(i) ?? sharedCategoryScale.bandwidth();
+        return pos != null ? pos + bw / 2 : 0;
+      });
+    }
+    const catAxisLength = catIsHorizontal ? cartesianArea.width : cartesianArea.height;
+    categoryAxisSpace = calculateAxisSpace(
+      catPosition,
+      false,
+      {
+        tickLabels: scaleCategories,
+        tickRotation: catBaseProps?.tickRotation,
+        tickStyle: (() => {
+          const s = catBaseProps?.tickStyle;
+          return typeof s === "function" ? void 0 : s;
+        })(),
+        autoRotate: catAutoRotate,
+        autoRotateAngle: catAutoRotateAngle,
+        tickPositions: catTickPositions,
+        axisLength: catAxisLength,
+        labelMinSpacing: catBaseProps?.labelMinSpacing,
+        tickCount: catBaseProps?.tickCount,
+        autoSkip: catBaseProps?.autoSkip
+      },
+      void 0,
+      globalFont
+    );
+  }
+  let valueAxisSpace = 0;
+  const primaryValAxisKey = orientation === "vertical" ? `y:${firstValueAxisId}` : `x:${firstValueAxisId}`;
+  const primaryValAxis = axisLayouts.get(primaryValAxisKey);
+  if (styledRangeBoundaries && styledRangeBoundaries.length > 0 && primaryValAxis) {
+    const valBaseProps = primaryValAxis.props;
+    const valTickFormat = typeof valBaseProps?.tickFormat === "function" ? valBaseProps.tickFormat : void 0;
+    const valAxisLength = orientation === "vertical" ? cartesianArea.height : cartesianArea.width;
+    const valTickCount = getAdaptiveTickCount(valAxisLength, valBaseProps?.tickCount);
+    const step = (valueDomain[1] - valueDomain[0]) / valTickCount;
+    const tickLabels = [];
+    for (let i = 0; i <= valTickCount; i++) {
+      const v = valueDomain[0] + step * i;
+      tickLabels.push(valTickFormat ? valTickFormat(v, i) : String(v));
+    }
+    valueAxisSpace = calculateAxisSpace(
+      primaryValAxis.position,
+      !!primaryValAxis.props?.label,
+      {
+        tickLabels,
+        tickRotation: valBaseProps?.tickRotation,
+        titleGap: valBaseProps?.titleGap,
+        tickStyle: (() => {
+          const s = valBaseProps?.tickStyle;
+          return typeof s === "function" ? void 0 : s;
+        })()
+      },
+      void 0,
+      globalFont
+    );
+  }
+  const barIntermediate = barDatasets.length > 0 ? {
+    barDatasets,
+    visibleBarDatasets,
+    mode,
+    valuesPerDataset,
+    stackBasesMap,
+    groupLayout,
+    fullGroupLayout: fullGroupLayout ?? void 0,
+    isVariwide,
+    barGap,
+    datasetAxisMap: (() => {
+      const m = /* @__PURE__ */ new Map();
+      for (const ds of barDatasets) m.set(ds.id, datasetAxisMap.get(ds.id) ?? firstValueAxisId);
+      return m;
+    })(),
+    firstValueAxisId
+  } : null;
+  let rangeGroups;
+  for (const ld of lineDatasets) {
+    if (!ld.rangeId) continue;
+    if (!rangeGroups) rangeGroups = /* @__PURE__ */ new Map();
+    if (!rangeGroups.has(ld.rangeId)) {
+      const featureKey = `range:${ld.rangeId}`;
+      const feat = features.get(featureKey);
+      const featProps = feat?.props;
+      rangeGroups.set(ld.rangeId, {
+        datasetIds: [],
+        color: featProps?.color,
+        fillOpacity: featProps?.fillOpacity ?? 0.3
+      });
+    }
+    rangeGroups.get(ld.rangeId).datasetIds.push(ld.id);
+  }
+  const datasetTotals = computeBarDatasetTotals(barDatasets, barRawResolved);
+  const primaryYAxis = axisLayouts.get(`y:${axes.y.keys().next().value}`);
+  const primaryXAxis = axisLayouts.get(`x:${axes.x.keys().next().value}`);
+  const valueAxisPosition = primaryYAxis ? primaryYAxis.position : "left";
+  const categoryAxisPosition = primaryXAxis ? primaryXAxis.position : "bottom";
+  const a11yConfig = features.get("accessibility")?.props;
+  const context = {
+    chartId,
+    width,
+    height,
+    renderer,
+    chartArea: cartesianArea,
+    theme: input.theme,
+    accessibility: a11yConfig?.enabled !== false ? {
+      enabled: true,
+      pointDescriptionThreshold: a11yConfig?.pointDescriptionThreshold ?? 200,
+      pointDescriptionFormatter: a11yConfig?.pointDescriptionFormatter,
+      landmarkVerbosity: a11yConfig?.landmarkVerbosity ?? "all"
+    } : void 0
+  };
+  let referenceLines;
+  let referenceBands;
+  for (const [key, feat] of features) {
+    if (typeof key === "string" && key.startsWith("referenceLine:")) {
+      if (!referenceLines) referenceLines = [];
+      referenceLines.push(feat.props);
+    }
+    if (typeof key === "string" && key.startsWith("referenceBand:")) {
+      if (!referenceBands) referenceBands = [];
+      referenceBands.push(feat.props);
+    }
+  }
+  const result = {
+    barIntermediate,
+    context,
+    cartesianArea,
+    xAxisLayout,
+    yAxisLayout,
+    datasetTotals,
+    orientation,
+    valueAxisPosition,
+    categoryAxisPosition,
+    valueScaleRange,
+    sharedCategoryScale,
+    isPercentStacked: mode.isPercentStacked,
+    isStacked: mode.isStacked,
+    isGrouped: mode.isGrouped,
+    isWaterfall: mode.isWaterfall,
+    isOverlap: mode.isOverlap,
+    categoryTotals,
+    styledBoundaries,
+    categoryAxisSpace,
+    styledRangeBoundaries,
+    valueAxisSpace,
+    valueDomain,
+    axisLayouts,
+    valueScales,
+    valueDomains,
+    // Line layouts/renderProps are computed by useLineRenderer (independent hook)
+    lineStackBasesMap,
+    lineTransformedValues,
+    groupedDataOverride,
+    decimatedIndices,
+    // Scatter layouts are computed by useScatterRenderer (independent hook)
+    scatterXScales: scatterXScales.size > 0 ? scatterXScales : void 0,
+    scatterStackBasesMap,
+    // Candlestick layouts are computed by useCandlestickRenderer (independent hook)
+    // Heatmap layouts are computed by useHeatmapRenderer (independent hook)
+    rangeGroups,
+    referenceLines,
+    referenceBands,
+    sharedTimeScale,
+    timeDomain: rawStreamTimeDomain,
+    timeAxisTimezone,
+    originalDomains,
+    sortedCategoryOrder
+  };
+  return result;
+}
+
+export { buildAnimatedFrame, buildBoundariesFromAxisGroups, buildFrameParams, buildStaticFrame, buildStyledRanges, calculateCartesianArea, cancelDriverRafs, computeCartesianLayout, computeNaturalAxisWidths, createAnimationDriver, createOffsetChartArea, driveCartesianUpdate, findAxisGroupFeatures, isLayoutCriticalFeature, mergeAllNearestResults, needsAxisPadding, renderWithCompositor, resolveHoverRepaintFrame, resolveNearestHit };