@rivet-health/design-system 40.44.0 → 40.44.2

package/esm2022/lib/visualization/chart/chart.mjs

@@ -0,0 +1,3768 @@
+import { CurrencyPipe } from '@angular/common';
+import { scaleLinear } from 'd3-scale';
+import { arc, area, line, pie } from 'd3-shape';
+import { utcFormat } from 'd3-time-format';
+import { sum, uniq } from 'lodash';
+import { DaysPipe } from '../../format/pipes/days.pipe';
+import { NumberPipe } from '../../format/pipes/number.pipe';
+import { PercentagePipe } from '../../format/pipes/percentage.pipe';
+import { SmallCurrencyPipe } from '../../format/pipes/small-currency.pipe';
+import { SmallNumberPipe } from '../../format/pipes/small-number.pipe';
+import { DefaultDonutSizingConfig, emptyChartScaleValues, getDefaultScalingConfigByChartType, } from './chart-scaling';
+export var Chart;
+(function (Chart) {
+    Chart.defaultColorPalette = [
+        //Base colors
+        '--baja-blast-50',
+        '--teal-diamond-50',
+        '--fyre-50',
+        '--tang-50',
+        '--purp-60',
+        '--rosi-70',
+        //Shift lighter from base by -20
+        '--baja-blast-30',
+        '--teal-diamond-30',
+        '--fyre-30',
+        '--tang-30',
+        '--purp-40',
+        '--rosi-50',
+        //Shift darker from base by +20
+        '--baja-blast-70',
+        '--teal-diamond-70',
+        '--fyre-70',
+        '--tang-70',
+        '--purp-80',
+        '--rosi-90',
+    ];
+    function chart(config, data, dimensions) {
+        return config.type === 'line'
+            ? lines(config, data, dimensions)
+            : config.type === 'area'
+                ? areas(config, data, dimensions)
+                : config.type === 'donut'
+                    ? arcs(config, data, dimensions)
+                    : config.type === 'horizontal-bar'
+                        ? horizontalBars(config, data, dimensions)
+                        : config.type === 'bar'
+                            ? bars(config, data, dimensions)
+                            : config.type === 'waterfall'
+                                ? waterfall(config, data, dimensions)
+                                : config.type === 'funnel'
+                                    ? funnel(config, data, dimensions)
+                                    : config.type === 'flow'
+                                        ? flows(config, data, dimensions)
+                                        : emptyChart;
+    }
+    Chart.chart = chart;
+    function lines(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'line')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        const { data: hiddenData, visibleIndices } = hide(allData);
+        if (hiddenData.type === 'labeled') {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Labeled series aren't currently supported for line charts");
+            return emptyChart;
+        }
+        if (hasSupplementaryData(hiddenData)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Supplementary y values aren't supported for non-bar charts");
+            return emptyChart;
+        }
+        warnUnsupportedPatterns(hiddenData, ['striped', 'dots'], 'line');
+        //This assignment makes typescript recognize the actual type (TimeseriesData)
+        const data = hiddenData;
+        const { dateFormat, pipeTransform, colors } = getFormattingAndColors(allData, data, config);
+        const chartSizingValues = getFullChartScaleValues(config, data, dimensions, pipeTransform, dateFormat);
+        if (chartSizingValues === null) {
+            return { ...emptyChart, chartError: 'sizing' };
+        }
+        const tickCount = getBucketTickCount(chartSizingValues);
+        const xTicks = generateTimeseriesTicks(data, config, tickCount, chartSizingValues, dateFormat).map(tick => toXTick(tick));
+        const xScale = (index) => {
+            return (chartSizingValues.totalLeftOffset + chartSizingValues.bucketGap * index);
+        };
+        const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(data, pipeTransform, config, chartSizingValues);
+        const yTicks = dataTicks.map(tick => toYTick(tick));
+        const indices = data.x.map((_, i) => i);
+        const lines = data.x.length > 1
+            ? data.ys.map(y => ({
+                line: line(i => xScale(i), i => scale(y.values[i], y.isSecondary))(indices),
+                pattern: y.pattern,
+            }))
+            : [];
+        const circles = data.x.length === 1
+            ? data.ys.map((ySeries, i) => ({
+                cx: xScale(0),
+                cy: scale(ySeries.values[0], checkIfSecondary(data, i, 0)),
+            }))
+            : [];
+        const yOffset = chartSizingValues.dataLabelPadding;
+        const dataLabels = data.ys.flatMap((y, yIndex) => {
+            const subLabels = y.values.map((val, xIndex) => ({
+                elementType: 'dataLabel',
+                label: pipeTransform(val, checkIfSecondary(data, yIndex, xIndex)),
+                yPos: scale(val, checkIfSecondary(data, yIndex, xIndex)) - yOffset,
+                xPos: xScale(xIndex),
+                anchor: 'middle',
+            }));
+            return subLabels;
+        });
+        function hover(pos) {
+            const realPosX = pos.x + pos.containerScrollX;
+            const realPosY = pos.y + pos.containerScrollY;
+            if (chartSizingValues === null ||
+                getIfHoverOutOfBounds(pos.x, pos.y, realPosX, realPosY, chartSizingValues, dimensions)) {
+                return null;
+            }
+            const xHoverIndices = getBucketAndClusterNumForHover(realPosX, chartSizingValues, data, config, data.x.length);
+            if (!xHoverIndices) {
+                return null;
+            }
+            const { bucketNum: xIndex } = xHoverIndices;
+            const x = xScale(xIndex);
+            const visibleYIndex = findNearestIndexWithSecondary(data.ys.map((y, i) => ({
+                value: y.values[xIndex],
+                isSecondary: checkIfSecondary(data, i, xIndex),
+            })), pos.y, scale);
+            const yIndex = visibleIndices[visibleYIndex];
+            const ys = data.ys.map((y, i) => scale(y.values[xIndex], checkIfSecondary(data, i, xIndex)));
+            const format = (date) => formatedDate(config.dateFormat || 'day', date);
+            // Clamp in chart-local coordinates first so the tooltip stays within the
+            // visible chart area, then translate to viewport coordinates by adding
+            // pos.rect.x/y (which are viewport-relative from getBoundingClientRect).
+            const localAnchorX = x - pos.containerScrollX;
+            const localAnchorY = ys[visibleYIndex] - pos.containerScrollY;
+            const { anchorX, anchorY } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions);
+            const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, SMALL_PADDING, 0);
+            return {
+                hoverType: 'standard',
+                x,
+                xIndex,
+                ys,
+                yIndex,
+                visibleYIndex,
+                tooltip: {
+                    anchor,
+                    date: format(new Date(data.x[xIndex])),
+                    metrics: data.ys
+                        .map((y, index) => ({
+                        color: colors[index % colors.length],
+                        label: y.label,
+                        pattern: y.pattern,
+                        value: pipeTransform(y.values[xIndex], checkIfSecondary(data, index, xIndex), true) ?? '-',
+                    }))
+                        .filter((_, i) => config.groupedTooltip || i === visibleYIndex),
+                },
+            };
+        }
+        return {
+            chartWidth: chartSizingValues.totalWidth,
+            chartHeight: chartSizingValues.totalHeight,
+            chartSizingValues,
+            xTicks,
+            yTicks,
+            colors,
+            lines,
+            circles,
+            hover,
+            bars: [],
+            areas: [],
+            arcs: [],
+            horizontalBars: [],
+            dataLabels,
+            waterfallLines: [],
+            gradients: [],
+            flowConnections: [],
+            horizontalContainerScale: chartSizingValues.horizontalContainerScale,
+            verticalContainerScale: chartSizingValues.verticalContainerScale,
+            chartError: null,
+        };
+    }
+    function areas(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'area')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        const { data: uncheckedData, visibleIndices } = hide(allData);
+        if (uncheckedData.type === 'labeled') {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Labeled series aren't currently supported for area charts");
+            return emptyChart;
+        }
+        if (config.showDataLabels === true) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Data labels aren't supported for any stacked chart type");
+            return emptyChart;
+        }
+        if (hasSupplementaryData(uncheckedData)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Supplementary y values aren't supported for non-bar charts");
+            return emptyChart;
+        }
+        warnUnsupportedPatterns(uncheckedData, ['striped'], 'area');
+        //This assignment makes typescript recognize the actual type (TimeseriesData)
+        const data = uncheckedData;
+        const { dateFormat, pipeTransform, colors } = getFormattingAndColors(allData, data, config);
+        const chartSizingValues = getFullChartScaleValues(config, data, dimensions, pipeTransform, dateFormat);
+        if (chartSizingValues === null) {
+            return { ...emptyChart, chartError: 'sizing' };
+        }
+        const tickCount = getBucketTickCount(chartSizingValues);
+        const xTicks = generateTimeseriesTicks(data, config, tickCount, chartSizingValues, dateFormat).map(tick => toXTick(tick));
+        const xScale = (index) => {
+            return (chartSizingValues.totalLeftOffset + chartSizingValues.bucketGap * index);
+        };
+        const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(data, pipeTransform, config, chartSizingValues);
+        const yTicks = dataTicks.map(tick => toYTick(tick));
+        const zeroAxisPosVal = scale(0, true);
+        const indices = data.x.map((_, i) => i);
+        const areas = data.ys.map((y, yIndex) => ({
+            pattern: y.pattern,
+            area: area(i => xScale(i), i => getBarYInfo(data, config, yIndex, i, scale).yValue, i => getBarYInfo(data, config, yIndex, i, scale).yValue +
+                getBarYInfo(data, config, yIndex, i, scale).height)(indices),
+        }));
+        function hover(pos) {
+            const realPosX = pos.x + pos.containerScrollX;
+            const realPosY = pos.y + pos.containerScrollY;
+            if (chartSizingValues === null ||
+                getIfHoverOutOfBounds(pos.x, pos.y, realPosX, realPosY, chartSizingValues, dimensions)) {
+                return null;
+            }
+            const xHoverIndices = getBucketAndClusterNumForHover(realPosX, chartSizingValues, data, config, data.x.length);
+            if (!xHoverIndices) {
+                return null;
+            }
+            const { bucketNum: xIndex } = xHoverIndices;
+            const x = xScale(xIndex);
+            const fullYs = data.ys.map((_, mapYIndex) => getBarYInfo(data, config, mapYIndex, xIndex, scale));
+            const ys = fullYs.map(y => y.yValue);
+            //This is the ys array, but shifted so that the y position for negative values is away from the axis (for the hover circles)
+            const shiftedYs = fullYs.map(y => {
+                if (y.yValue >= zeroAxisPosVal) {
+                    return y.yValue + y.height;
+                }
+                return y.yValue;
+            });
+            const yPosSign = zeroAxisPosVal - pos.y;
+            let visibleYIndex = -1;
+            if (yPosSign < 0 && data.ys.find(y => y.values.find(val => val < 0))) {
+                for (let i = ys.length - 1; i >= 0; i--) {
+                    if (ys[i] >= zeroAxisPosVal && ys[i] < pos.y) {
+                        visibleYIndex = i;
+                        break;
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < ys.length; i++) {
+                    if (ys[i] <= zeroAxisPosVal && ys[i] < pos.y) {
+                        visibleYIndex = i;
+                        break;
+                    }
+                }
+            }
+            if (visibleYIndex === -1) {
+                if (pos.y <= zeroAxisPosVal) {
+                    visibleYIndex = ys.indexOf(Math.min(...ys));
+                }
+                else {
+                    visibleYIndex = ys.indexOf(Math.max(...ys));
+                }
+            }
+            const yIndex = visibleIndices[visibleYIndex];
+            const localAnchorX = x - pos.containerScrollX;
+            const localAnchorY = ys[visibleYIndex] - pos.containerScrollY;
+            const { anchorX, anchorY } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions);
+            const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, SMALL_PADDING, 0);
+            return {
+                hoverType: 'standard',
+                x,
+                xIndex,
+                ys: shiftedYs,
+                yIndex,
+                visibleYIndex,
+                tooltip: {
+                    anchor,
+                    date: utcFormat('%B %d, %Y')(new Date(data.x[xIndex])),
+                    metrics: data.ys
+                        .map((y, index) => ({
+                        color: colors[index % colors.length],
+                        label: y.label,
+                        pattern: y.pattern,
+                        value: pipeTransform(y.values[xIndex], checkIfSecondary(data, index, xIndex), true),
+                    }))
+                        .filter((_, i) => config.groupedTooltip || i === visibleYIndex),
+                },
+            };
+        }
+        return {
+            chartWidth: chartSizingValues.totalWidth,
+            chartHeight: chartSizingValues.totalHeight,
+            chartSizingValues,
+            xTicks,
+            yTicks,
+            colors,
+            areas,
+            lines: [],
+            circles: [],
+            hover,
+            bars: [],
+            arcs: [],
+            horizontalBars: [],
+            dataLabels: [],
+            waterfallLines: [],
+            gradients: [],
+            flowConnections: [],
+            horizontalContainerScale: chartSizingValues.horizontalContainerScale,
+            verticalContainerScale: chartSizingValues.verticalContainerScale,
+            chartError: null,
+        };
+    }
+    function bars(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'bar')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        const { data, visibleIndices, visibleSuppIndices } = hide(allData);
+        if (config.showDataLabels === true &&
+            isStackedData(config) &&
+            !isGroupingTypeException(data, config)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Data labels aren't supported for any stacked chart type");
+            return emptyChart;
+        }
+        if (hasSupplementaryData(data) &&
+            isClusteredData(data, config, false) &&
+            !isGroupingTypeException(data, config)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Supplementary y values aren't supported for clustered data (just use another normal y series)");
+            return emptyChart;
+        }
+        return barsHelper(config, allData, data, visibleIndices, visibleSuppIndices, dimensions, false, false);
+    }
+    function funnel(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'funnel')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        const { data, visibleIndices, visibleSuppIndices } = hide(allData);
+        return barsHelper(config, allData, data, visibleIndices, visibleSuppIndices, dimensions, true, false);
+    }
+    function waterfall(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'waterfall')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        const { data: uncheckedData, visibleIndices } = hide(allData);
+        if (hasSupplementaryData(uncheckedData)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Supplementary y values aren't supported for non-bar charts");
+            return emptyChart;
+        }
+        if (config.secondaryValueType) {
+            // eslint-disable-next-line no-console
+            console.warn('Heads up! Waterfall charts do not currently have two-axis support');
+            return emptyChart;
+        }
+        warnUnsupportedPatterns(uncheckedData, [], 'waterfall');
+        return barsHelper(config, allData, uncheckedData, visibleIndices, [], dimensions, false, true);
+    }
+    function barsHelper(config, allData, uncheckedData, visibleIndices, visibleSuppIndices, dimensions, isFunnel, isWaterfall) {
+        const { dateFormat, pipeTransform, colorIndices, colors } = getFormattingAndColors(allData, uncheckedData, config);
+        const waterfallData = waterfallTransform(uncheckedData, isWaterfall);
+        const data = isWaterfall ? waterfallData.data : uncheckedData;
+        const chartSizingValues = getFullChartScaleValues(config, data, dimensions, pipeTransform, dateFormat);
+        if (chartSizingValues === null) {
+            return { ...emptyChart, chartError: 'sizing' };
+        }
+        const tickCount = getBucketTickCount(chartSizingValues);
+        const xTicks = (data.type === 'labeled'
+            ? generateLabelledTicks(data, config, tickCount, chartSizingValues)
+            : generateTimeseriesTicks(data, config, tickCount, chartSizingValues, dateFormat)).map(tick => toXTick(tick));
+        const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(data, pipeTransform, config, chartSizingValues);
+        const yTicks = dataTicks.map(tick => toYTick(tick));
+        const zeroAxisPosVal = scale(0, true);
+        const gradients = [];
+        const bars = data.ys.map((y, yIndex) => {
+            const indSeriesGradients = [];
+            const indSeriesBars = y.values.map((_, index) => {
+                const { yValue, height } = getBarYInfo(data, config, yIndex, index, scale);
+                const xValue = calculateBarPosition(data, config, chartSizingValues, index, isClusteredData(data, config, false) ? yIndex : 0);
+                if (isFunnel) {
+                    //The empty gradient still needs to be inserted to keep data aligned
+                    if (index === 0) {
+                        indSeriesGradients.push({
+                            elementType: 'rect',
+                            x: 0,
+                            y: 0,
+                            width: 0,
+                            height: 0,
+                        });
+                    }
+                    else {
+                        const { yValue: prevBarYVal } = getBarYInfo(data, config, yIndex, index - 1, scale);
+                        indSeriesGradients.push({
+                            elementType: 'rect',
+                            x: xValue,
+                            y: prevBarYVal,
+                            width: chartSizingValues.barSize,
+                            height: Math.max(yValue - prevBarYVal, 0),
+                        });
+                    }
+                }
+                const bar = {
+                    elementType: 'rect',
+                    x: xValue,
+                    y: yValue,
+                    width: chartSizingValues.barSize,
+                    height,
+                    offset: 0,
+                    pattern: y.pattern,
+                };
+                return bar;
+            });
+            gradients.push(indSeriesGradients);
+            return indSeriesBars;
+        });
+        let suppBars = [];
+        if (hasSupplementaryData(data)) {
+            suppBars = data.supplementaryYs.map((y, yIndex) => y.values.map((_, index) => {
+                const { yValue, height } = getBarYInfo(data, config, yIndex, index, scale, true);
+                const xValue = calculateBarPosition(data, config, chartSizingValues, index, y.supplementalIndex + 1);
+                return {
+                    elementType: 'rect',
+                    x: xValue,
+                    y: yValue,
+                    width: chartSizingValues.barSize,
+                    height,
+                    offset: 0,
+                    pattern: y.pattern,
+                };
+            }));
+            bars.push(...suppBars);
+            colors.push(...data.supplementaryYs.map(y => getColor(y, colorIndices, config.colors)));
+        }
+        const waterfallLines = [];
+        if (isWaterfall) {
+            //Move bars based on height of previous bars (except the total bar)
+            let barOffsetRunningTotal = 0;
+            for (let i = 0; i < data.x.length - 1; i++) {
+                let barOffsetChange = 0;
+                for (let j = 0; j < bars.length; j++) {
+                    const barIsNegative = bars[j][i].y >= zeroAxisPosVal && bars[j][i].height > 0;
+                    if (barIsNegative) {
+                        barOffsetChange -= bars[j][i].height;
+                    }
+                    else {
+                        barOffsetChange += bars[j][i].height;
+                    }
+                    bars[j][i].offset = barOffsetRunningTotal;
+                    bars[j][i].y -= barOffsetRunningTotal;
+                    if (j === bars.length - 1) {
+                        const x1 = bars[j][i].x + bars[bars.length - 1][i].width;
+                        const y1 = bars[j][i].y + (barIsNegative ? bars[j][i].height : 0);
+                        const x2 = bars[j][i + 1].x;
+                        const y2 = y1;
+                        waterfallLines.push({
+                            x1,
+                            y1,
+                            x2,
+                            y2,
+                        });
+                    }
+                }
+                barOffsetRunningTotal += barOffsetChange;
+            }
+        }
+        const dataLabels = data.ys.flatMap((y, yIndex) => {
+            const subLabels = y.values.map((val, xIndex) => {
+                const isNegativeBar = bars[yIndex][xIndex].y >= zeroAxisPosVal &&
+                    bars[yIndex][xIndex].height > 0;
+                const yOffset = isNegativeBar
+                    ? chartSizingValues.dataLabelPadding +
+                        chartSizingValues.dataLabelTextSize +
+                        bars[yIndex][xIndex].height
+                    : -chartSizingValues.dataLabelPadding;
+                return {
+                    elementType: 'dataLabel',
+                    label: pipeTransform(val, checkIfSecondary(data, yIndex, xIndex)) ?? '',
+                    yPos: (isFunnel && gradients[yIndex][xIndex].height !== 0
+                        ? gradients[yIndex][xIndex].y
+                        : bars[yIndex][xIndex].y) + yOffset,
+                    xPos: bars[yIndex][xIndex].x + bars[yIndex][xIndex].width / 2,
+                    anchor: 'middle',
+                };
+            });
+            return subLabels;
+        });
+        if (hasSupplementaryData(data)) {
+            const suppDataLabels = data.supplementaryYs.flatMap((y, yIndex) => {
+                const subLabels = y.values.map((val, xIndex) => {
+                    const isNegativeBar = suppBars[yIndex][xIndex].y >= zeroAxisPosVal &&
+                        suppBars[yIndex][xIndex].height > 0;
+                    const yOffset = isNegativeBar
+                        ? chartSizingValues.dataLabelPadding +
+                            suppBars[yIndex][xIndex].height
+                        : -chartSizingValues.dataLabelPadding;
+                    return {
+                        elementType: 'dataLabel',
+                        label: pipeTransform(val, checkIfSecondary(data, yIndex, xIndex, true)) ?? '',
+                        yPos: suppBars[yIndex][xIndex].y + yOffset,
+                        xPos: suppBars[yIndex][xIndex].x + suppBars[yIndex][xIndex].width / 2,
+                        anchor: 'middle',
+                    };
+                });
+                return subLabels;
+            });
+            dataLabels.push(...suppDataLabels);
+        }
+        function hover(pos) {
+            const realPosX = pos.x + pos.containerScrollX;
+            const realPosY = pos.y + pos.containerScrollY;
+            if (chartSizingValues === null ||
+                getIfHoverOutOfBounds(pos.x, pos.y, realPosX, realPosY, chartSizingValues, dimensions)) {
+                return null;
+            }
+            const suppYs = hasSupplementaryData(data) ? data.supplementaryYs : null;
+            const xHoverIndices = getBucketAndClusterNumForHover(realPosX, chartSizingValues, data, config, data.x.length);
+            if (!xHoverIndices) {
+                return null;
+            }
+            const { bucketNum: xIndex, clusterNum, clusterNormCount, clusterNumType, } = xHoverIndices;
+            let isSuppValue = false;
+            let suppIndexVal = 0;
+            if (suppYs) {
+                suppIndexVal = clusterNum - clusterNormCount;
+                if (clusterNumType === 'supp') {
+                    isSuppValue = true;
+                }
+            }
+            const calcX = calculateBarPosition(data, config, chartSizingValues, xIndex, clusterNum);
+            const ys = data.ys.map((_, mapYIndex) => isSuppValue
+                ? getSuppBarYInfoViaYIndex(data, config, mapYIndex, suppIndexVal, xIndex, scale).yValue
+                : getBarYInfo(data, config, mapYIndex, xIndex, scale).yValue -
+                    (!isSuppValue && isWaterfall
+                        ? bars[mapYIndex][xIndex].offset ?? 0
+                        : 0));
+            const yPosSign = zeroAxisPosVal - realPosY;
+            let visibleYIndex = -1;
+            let dropOffHoverDetected = false;
+            if (yPosSign < 0 && data.ys.find(y => y.values.find(val => val < 0))) {
+                for (let i = ys.length - 1; i >= 0; i--) {
+                    if (ys[i] >= zeroAxisPosVal && ys[i] < realPosY) {
+                        visibleYIndex = i;
+                        break;
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < ys.length; i++) {
+                    if (ys[i] <= zeroAxisPosVal && ys[i] < realPosY) {
+                        visibleYIndex = i;
+                        break;
+                    }
+                }
+            }
+            if (isClusteredData(data, config, false) && !suppYs) {
+                visibleYIndex = clusterNum;
+                if (isFunnel && xIndex !== 0 && ys[visibleYIndex] > realPosY) {
+                    dropOffHoverDetected = true;
+                }
+            }
+            if (visibleYIndex === -1) {
+                if (realPosY <= zeroAxisPosVal) {
+                    visibleYIndex = ys.indexOf(Math.min(...ys));
+                }
+                else {
+                    visibleYIndex = ys.indexOf(Math.max(...ys));
+                }
+            }
+            const yIndex = visibleIndices[visibleYIndex];
+            let { yValue, height } = isSuppValue
+                ? getSuppBarYInfoViaYIndex(data, config, yIndex, suppIndexVal, xIndex, scale)
+                : getBarYInfo(data, config, yIndex, xIndex, scale);
+            if (dropOffHoverDetected) {
+                yValue = gradients[yIndex][xIndex].y;
+                height = gradients[yIndex][xIndex].height;
+            }
+            const localAnchorX = calcX - pos.containerScrollX - SMALL_PADDING;
+            const width = chartSizingValues.barSize + SMALL_PADDING * 2;
+            const waterfallOffset = !isSuppValue && isWaterfall ? bars[yIndex][xIndex].offset ?? 0 : 0;
+            const localAnchorY = yValue - pos.containerScrollY - waterfallOffset;
+            const { anchorX, anchorY, anchorWidth, anchorHeight } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions, width, height);
+            const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, anchorWidth, anchorHeight);
+            //We need to preserve the original index for the later checkIfSecondary call
+            const ysForMetrics = isSuppValue && suppYs
+                ? suppYs
+                    .map((suppY, index) => ({ data: suppY, originalIndex: index }))
+                    .filter(suppY => suppY.data.supplementalIndex === suppIndexVal)
+                : data.ys.map((y, index) => ({ data: y, originalIndex: index }));
+            // Find the specific supplementary item that was hovered
+            const groupSupps = suppYs
+                ? suppYs.filter(s => s.supplementalIndex === suppIndexVal) ?? []
+                : [];
+            const suppArrayIndex = visibleYIndex; // Use the visual Y position within the layer
+            const filteredSuppYIndex = suppArrayIndex >= 0 && suppArrayIndex < groupSupps.length && suppYs
+                ? suppYs.indexOf(groupSupps[suppArrayIndex]) ?? -1
+                : -1;
+            const suppYIndex = filteredSuppYIndex >= 0 ? visibleSuppIndices[filteredSuppYIndex] : -1;
+            return {
+                hoverType: 'standard',
+                x: calcX + chartSizingValues.barSize / 2,
+                xIndex,
+                ys,
+                yIndex,
+                visibleYIndex,
+                ...(isSuppValue && suppYIndex >= 0
+                    ? {
+                        isSuppValue,
+                        suppYIndex: suppYIndex,
+                    }
+                    : {}),
+                ...(dropOffHoverDetected ? { isDropOff: true } : {}),
+                tooltip: {
+                    anchor,
+                    date: data.type === 'labeled'
+                        ? dropOffHoverDetected
+                            ? 'Drop off from '.concat(data.x[xIndex - 1].label)
+                            : data.x[xIndex].label
+                        : utcFormat('%B %d, %Y')(new Date(data.x[xIndex])),
+                    metrics: ysForMetrics
+                        .map(y => ({
+                        color: getColor(isWaterfall ? waterfallData.map.get(y.data) : y.data, colorIndices, config.colors),
+                        label: y.data.label,
+                        pattern: y.data.pattern,
+                        value: pipeTransform(dropOffHoverDetected
+                            ? Math.max(y.data.values[xIndex - 1] - y.data.values[xIndex], 0)
+                            : y.data.values[xIndex], checkIfSecondary(data, y.originalIndex, dropOffHoverDetected ? xIndex - 1 : xIndex, isSuppValue), true),
+                    }))
+                        .filter((_, i) => config.groupedTooltip || i === visibleYIndex),
+                },
+            };
+        }
+        return {
+            chartWidth: chartSizingValues.totalWidth,
+            chartHeight: chartSizingValues.totalHeight,
+            chartSizingValues,
+            xTicks,
+            yTicks,
+            colors,
+            bars,
+            lines: [],
+            circles: [],
+            areas: [],
+            hover,
+            arcs: [],
+            horizontalBars: [],
+            dataLabels,
+            waterfallLines,
+            gradients,
+            flowConnections: [],
+            horizontalContainerScale: chartSizingValues.horizontalContainerScale,
+            verticalContainerScale: chartSizingValues.verticalContainerScale,
+            chartError: null,
+        };
+    }
+    function horizontalBars(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'horizontal bar')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        //Some of this stuff gets confusing, because x and y are essentially inverted here
+        //  So, if you see a situation where a variable is named 'y', but referencing
+        //  'x' (or vice versa), that's why
+        const { data, visibleIndices, visibleSuppIndices } = hide(allData);
+        if (config.showDataLabels === true &&
+            isStackedData(config) &&
+            !isGroupingTypeException(data, config)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Data labels aren't supported for any stacked chart type");
+            return emptyChart;
+        }
+        if (hasSupplementaryData(data) &&
+            isClusteredData(data, config, false) &&
+            !isGroupingTypeException(data, config)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Supplementary y values aren't supported for clustered data (just use another normal y series)");
+            return emptyChart;
+        }
+        const { dateFormat, pipeTransform, colorIndices, colors } = getFormattingAndColors(allData, data, config);
+        const chartSizingValues = getFullChartScaleValues(config, data, dimensions, pipeTransform, dateFormat);
+        if (chartSizingValues === null) {
+            return { ...emptyChart, chartError: 'sizing' };
+        }
+        const tickCount = getBucketTickCount(chartSizingValues);
+        const yTicks = (data.type === 'labeled'
+            ? generateLabelledTicks(data, config, tickCount, chartSizingValues)
+            : generateTimeseriesTicks(data, config, tickCount, chartSizingValues, dateFormat)).map(tick => toYTick(tick));
+        const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(data, pipeTransform, config, chartSizingValues);
+        const xTicks = dataTicks.map(tick => toXTick(tick));
+        const zeroAxisPosVal = scale(0, true);
+        const simplifiedHorizontalBars = [];
+        const horizontalBars = data.ys.map((y, yIndex) => {
+            const subSimpHorBars = [];
+            const retVal = y.values.map((_, index) => {
+                const { xValue, width } = getBarXInfo(data, config, yIndex, index, scale);
+                const clusterInfo = getClusterInfoForBucket(data, config);
+                const clusterNum = clusterInfo.normClusterIndices.indexOf(yIndex);
+                const yValue = calculateBarPosition(data, config, chartSizingValues, index, isClusteredData(data, config, false) ? clusterNum : 0);
+                const horR = Math.min(DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS, Math.floor(width / 2));
+                const verR = Math.min(DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS, Math.floor(chartSizingValues.barSize / 2));
+                subSimpHorBars.push({
+                    xPos: xValue,
+                    yPos: yValue,
+                    width,
+                });
+                //If clusterNum is -1, then the value of data[yIndex][xIndex] must be zero
+                if (clusterNum === -1) {
+                    return {
+                        horizontalBar: '',
+                        pattern: y.pattern,
+                        x: xValue,
+                        y: yValue,
+                    };
+                }
+                //Don't draw anything for zero-value bars
+                if (width === 0) {
+                    return {
+                        horizontalBar: '',
+                        pattern: y.pattern,
+                        x: xValue,
+                        y: yValue,
+                    };
+                }
+                const isPositive = data.ys[yIndex].values[index] > 0;
+                const hasAnyNegativeBars = data.ys
+                    .map(y => y.values[index])
+                    .find(val => val < 0);
+                const hasAnyPositiveBars = data.ys
+                    .map(y => y.values[index])
+                    .find(val => val > 0);
+                //These checks are to make sure we still round if all previous/later values are 0
+                const allLeftZero = isPositive
+                    ? data.ys
+                        .slice(0, yIndex)
+                        .map(y => y.values[index])
+                        .filter(val => val > 0).length === 0 && !hasAnyNegativeBars
+                    : data.ys
+                        .slice(yIndex + 1, data.ys.length)
+                        .map(y => y.values[index])
+                        .filter(val => val < 0).length === 0;
+                const leftSideRound = !isStackedData(config) || allLeftZero;
+                const allRightZero = isPositive
+                    ? data.ys
+                        .slice(yIndex + 1, data.ys.length)
+                        .map(y => y.values[index])
+                        .filter(val => val > 0).length === 0
+                    : data.ys
+                        .slice(0, yIndex)
+                        .map(y => y.values[index])
+                        .filter(val => val < 0).length === 0 && !hasAnyPositiveBars;
+                const rightSideRound = !isStackedData(config) || allRightZero;
+                const pathD = calculateHorizontalBarPath(leftSideRound, rightSideRound, xValue, yValue, horR, verR, chartSizingValues.barSize, width);
+                return {
+                    horizontalBar: pathD,
+                    pattern: y.pattern,
+                    x: xValue,
+                    y: yValue,
+                };
+            });
+            simplifiedHorizontalBars.push(subSimpHorBars);
+            return retVal;
+        });
+        const suppYs = data.supplementaryYs;
+        const simplifiedSuppHorizontalBars = [];
+        if (suppYs) {
+            const suppHorizontalBars = suppYs.map((y, yIndex) => {
+                const subSimpHorBars = [];
+                const retVal = y.values.map((_, index) => {
+                    const { xValue, width } = getBarXInfo(data, config, yIndex, index, scale, true);
+                    const clusterInfo = getClusterInfoForBucket(data, config);
+                    const clusterNum = clusterInfo.suppClusterIndices.indexOf(y.supplementalIndex) +
+                        clusterInfo.normCount;
+                    const yValue = calculateBarPosition(data, config, chartSizingValues, index, clusterNum);
+                    const horR = Math.min(DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS, Math.floor(width / 2));
+                    const verR = Math.min(DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS, Math.floor(chartSizingValues.barSize / 2));
+                    subSimpHorBars.push({
+                        xPos: xValue,
+                        yPos: yValue,
+                        width,
+                    });
+                    //Don't draw anything for zero-value bars
+                    if (width === 0) {
+                        return {
+                            horizontalBar: '',
+                            pattern: y.pattern,
+                            x: xValue,
+                            y: yValue,
+                        };
+                    }
+                    const isPositive = suppYs[yIndex].values[index] > 0;
+                    const hasAnyNegativeBars = suppYs
+                        .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)
+                        .map(y => y.values[index])
+                        .find(val => val < 0);
+                    const hasAnyPositiveBars = suppYs
+                        .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)
+                        .map(y => y.values[index])
+                        .find(val => val > 0);
+                    //These checks are to make sure we still round if all previous/later values are 0
+                    const allLeftZero = isPositive
+                        ? suppYs
+                            .slice(0, yIndex)
+                            .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)
+                            .map(y => y.values[index])
+                            .filter(val => val > 0).length === 0 && !hasAnyNegativeBars
+                        : suppYs
+                            .slice(yIndex + 1, suppYs.length)
+                            .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)
+                            .map(y => y.values[index])
+                            .filter(val => val < 0).length === 0;
+                    const leftSideRound = !isStackedData(config) || allLeftZero;
+                    const allRightZero = isPositive
+                        ? suppYs
+                            .slice(yIndex + 1, suppYs.length)
+                            .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)
+                            .map(y => y.values[index])
+                            .filter(val => val > 0).length === 0
+                        : suppYs
+                            .slice(0, yIndex)
+                            .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)
+                            .map(y => y.values[index])
+                            .filter(val => val < 0).length === 0 && !hasAnyPositiveBars;
+                    const rightSideRound = !isStackedData(config) || allRightZero;
+                    const pathD = calculateHorizontalBarPath(leftSideRound, rightSideRound, xValue, yValue, horR, verR, chartSizingValues.barSize, width);
+                    return {
+                        horizontalBar: pathD,
+                        pattern: y.pattern,
+                        x: xValue,
+                        y: yValue,
+                    };
+                });
+                simplifiedSuppHorizontalBars.push(subSimpHorBars);
+                return retVal;
+            });
+            horizontalBars.push(...suppHorizontalBars);
+            colors.push(...suppYs.map(y => getColor(y, colorIndices, config.colors)));
+        }
+        const yOffset = chartSizingValues.barSize;
+        const dataLabels = data.ys.flatMap((y, yIndex) => {
+            const subLabels = y.values.map((val, xIndex) => {
+                const barIsNegative = simplifiedHorizontalBars[yIndex][xIndex].xPos < zeroAxisPosVal &&
+                    simplifiedHorizontalBars[yIndex][xIndex].width > 0;
+                const xOffset = barIsNegative
+                    ? -chartSizingValues.dataLabelPadding
+                    : simplifiedHorizontalBars[yIndex][xIndex].width +
+                        chartSizingValues.dataLabelPadding;
+                return {
+                    elementType: 'dataLabel',
+                    label: pipeTransform(val, checkIfSecondary(data, yIndex, xIndex)) ?? '',
+                    yPos: simplifiedHorizontalBars[yIndex][xIndex].yPos + yOffset,
+                    xPos: simplifiedHorizontalBars[yIndex][xIndex].xPos + xOffset,
+                    anchor: barIsNegative ? 'end' : 'start',
+                };
+            });
+            return subLabels;
+        });
+        if (suppYs) {
+            const suppDataLabels = suppYs.flatMap((y, yIndex) => {
+                const subLabels = y.values.map((val, xIndex) => {
+                    const barIsNegative = simplifiedSuppHorizontalBars[yIndex][xIndex].xPos <
+                        zeroAxisPosVal &&
+                        simplifiedSuppHorizontalBars[yIndex][xIndex].width > 0;
+                    const xOffset = barIsNegative
+                        ? -chartSizingValues.dataLabelPadding
+                        : simplifiedSuppHorizontalBars[yIndex][xIndex].width +
+                            chartSizingValues.dataLabelPadding;
+                    return {
+                        elementType: 'dataLabel',
+                        label: pipeTransform(val, checkIfSecondary(data, yIndex, xIndex, true)) ?? '',
+                        yPos: simplifiedSuppHorizontalBars[yIndex][xIndex].yPos + yOffset,
+                        xPos: simplifiedSuppHorizontalBars[yIndex][xIndex].xPos + xOffset,
+                        anchor: barIsNegative ? 'end' : 'start',
+                    };
+                });
+                return subLabels;
+            });
+            dataLabels.push(...suppDataLabels);
+        }
+        function hover(pos) {
+            const realPosX = pos.x + pos.containerScrollX;
+            const realPosY = pos.y + pos.containerScrollY;
+            if (chartSizingValues === null ||
+                getIfHoverOutOfBounds(pos.x, pos.y, realPosX, realPosY, chartSizingValues, dimensions)) {
+                return null;
+            }
+            const suppYs = hasSupplementaryData(data) ? data.supplementaryYs : null;
+            const xHoverIndices = getBucketAndClusterNumForHover(realPosY, chartSizingValues, data, config, data.x.length);
+            if (!xHoverIndices) {
+                return null;
+            }
+            const { bucketNum: xIndex, clusterNum, clusterNormCount, clusterNumType, } = xHoverIndices;
+            let x = calculateBarPosition(data, config, chartSizingValues, xIndex, clusterNum);
+            let isSuppValue = false;
+            let suppIndexVal = 0;
+            if (suppYs) {
+                suppIndexVal = clusterNum - clusterNormCount;
+                if (clusterNumType === 'supp') {
+                    isSuppValue = true;
+                }
+            }
+            // When hovering supplementary values, get bars for that supplemental layer
+            // When hovering original Ys, get bars for original Ys
+            const fullYs = hasSupplementaryData(data) && isSuppValue
+                ? (data.supplementaryYs.filter(s => s.supplementalIndex === suppIndexVal) ?? []).map(suppY => getBarXInfo(data, config, data.supplementaryYs.indexOf(suppY), xIndex, scale, true))
+                : data.ys.map((_, mapYIndex) => getBarXInfo(data, config, mapYIndex, xIndex, scale));
+            const ys = fullYs.map(y => y.xValue);
+            let visibleYIndex = -1;
+            for (let i = 0; i < fullYs.length; i++) {
+                const leftBorder = fullYs[i].xValue;
+                const rightBorderCandidates = fullYs
+                    .filter(y => y.xValue > leftBorder)
+                    .map(y => y.xValue);
+                const rightBorder = rightBorderCandidates.length > 0
+                    ? Math.min(...rightBorderCandidates)
+                    : leftBorder + fullYs[i].width;
+                if (realPosX > leftBorder && realPosX < rightBorder) {
+                    visibleYIndex = i;
+                }
+            }
+            if (isClusteredData(data, config, false)) {
+                visibleYIndex = clusterNum;
+            }
+            if (visibleYIndex === -1) {
+                if (realPosX >= zeroAxisPosVal) {
+                    visibleYIndex = ys.indexOf(Math.max(...ys));
+                }
+                else {
+                    visibleYIndex = ys.indexOf(Math.min(...ys));
+                }
+            }
+            // For supplementary bars: visibleYIndex is index within filtered supplementary array
+            // For original Ys: visibleYIndex is index within original Ys array
+            const actualSuppYIndex = hasSupplementaryData(data) && isSuppValue
+                ? data.supplementaryYs.findIndex(s => s.supplementalIndex === suppIndexVal &&
+                    data.supplementaryYs
+                        .filter(s2 => s2.supplementalIndex === suppIndexVal)
+                        .indexOf(s) === visibleYIndex) ?? -1
+                : -1;
+            const yIndex = isSuppValue ? 0 : visibleIndices[visibleYIndex];
+            //Check if we've landed on a zero-width bar (only really relevant on ends)
+            const barsToCheck = isSuppValue
+                ? simplifiedSuppHorizontalBars
+                : simplifiedHorizontalBars;
+            const barIndexToCheck = isSuppValue ? actualSuppYIndex : visibleYIndex;
+            if (barIndexToCheck >= 0 &&
+                barsToCheck[barIndexToCheck][xIndex].width === 0 &&
+                isStackedData(config)) {
+                let altBarFound = false;
+                //Check upwards
+                for (let i = barIndexToCheck + 1; i < barsToCheck.length; i++) {
+                    if (altBarFound) {
+                        break;
+                    }
+                    if (barsToCheck[i][xIndex].width !== 0) {
+                        if (hasSupplementaryData(data) && isSuppValue) {
+                            visibleYIndex = data.supplementaryYs
+                                .filter(s => s.supplementalIndex === suppIndexVal)
+                                .indexOf(data.supplementaryYs[i]);
+                        }
+                        else {
+                            visibleYIndex = i;
+                        }
+                        altBarFound = true;
+                    }
+                }
+                //Check downwards
+                for (let i = barIndexToCheck - 1; i >= 0; i--) {
+                    if (altBarFound) {
+                        break;
+                    }
+                    if (barsToCheck[i][xIndex].width !== 0) {
+                        if (hasSupplementaryData(data) && isSuppValue) {
+                            visibleYIndex = data.supplementaryYs
+                                .filter(s => s.supplementalIndex === suppIndexVal)
+                                .indexOf(data.supplementaryYs[i]);
+                        }
+                        else {
+                            visibleYIndex = i;
+                        }
+                        altBarFound = true;
+                    }
+                }
+            }
+            const originalSuppYIndex = isSuppValue && actualSuppYIndex >= 0
+                ? visibleSuppIndices[actualSuppYIndex]
+                : -1;
+            const barXPos = isSuppValue
+                ? simplifiedSuppHorizontalBars[actualSuppYIndex][xIndex].xPos
+                : simplifiedHorizontalBars[visibleYIndex][xIndex].xPos;
+            const barYPos = isSuppValue
+                ? simplifiedSuppHorizontalBars[actualSuppYIndex][xIndex].yPos
+                : simplifiedHorizontalBars[visibleYIndex][xIndex].yPos;
+            const barWidth = isSuppValue
+                ? simplifiedSuppHorizontalBars[actualSuppYIndex][xIndex].width
+                : simplifiedHorizontalBars[visibleYIndex][xIndex].width;
+            const localAnchorX = barXPos - pos.containerScrollX - SMALL_PADDING;
+            const width = barWidth + SMALL_PADDING * 2;
+            const localAnchorY = barYPos - pos.containerScrollY;
+            const height = chartSizingValues.barSize;
+            const { anchorX, anchorY, anchorWidth, anchorHeight } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions, width, height);
+            const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, anchorWidth, anchorHeight);
+            //We need to preserve the original index for the later checkIfSecondary call
+            const ysForMetrics = isSuppValue && suppYs
+                ? suppYs
+                    .map((suppY, index) => ({ data: suppY, originalIndex: index }))
+                    .filter(suppY => suppY.data.supplementalIndex === suppIndexVal)
+                : data.ys.map((y, index) => ({ data: y, originalIndex: index }));
+            return {
+                hoverType: 'standard',
+                x,
+                xIndex,
+                ys,
+                yIndex,
+                visibleYIndex,
+                ...(isSuppValue && originalSuppYIndex >= 0
+                    ? { isSuppValue, suppYIndex: originalSuppYIndex }
+                    : {}),
+                tooltip: {
+                    anchor,
+                    date: data.type === 'labeled'
+                        ? data.x[xIndex].label
+                        : utcFormat('%B %d, %Y')(new Date(data.x[xIndex])),
+                    metrics: ysForMetrics
+                        .map(y => ({
+                        color: getColor(y.data, colorIndices, config.colors),
+                        label: y.data.label,
+                        pattern: y.data.pattern,
+                        value: pipeTransform(y.data.values[xIndex], checkIfSecondary(data, y.originalIndex, xIndex, isSuppValue), true),
+                    }))
+                        .filter((_, i) => config.groupedTooltip || i === visibleYIndex),
+                },
+            };
+        }
+        return {
+            chartWidth: chartSizingValues.totalWidth,
+            chartHeight: chartSizingValues.totalHeight,
+            chartSizingValues,
+            xTicks: xTicks,
+            yTicks: yTicks,
+            hover,
+            colors,
+            bars: [],
+            lines: [],
+            circles: [],
+            areas: [],
+            arcs: [],
+            horizontalBars,
+            dataLabels,
+            waterfallLines: [],
+            gradients: [],
+            flowConnections: [],
+            horizontalContainerScale: chartSizingValues.horizontalContainerScale,
+            verticalContainerScale: chartSizingValues.verticalContainerScale,
+            chartError: null,
+        };
+    }
+    function arcs(config, allData, dimensions) {
+        if (!warnFlowData(allData, 'donut')) {
+            return { ...emptyChart, chartError: 'config' };
+        }
+        if (config.secondaryValueType &&
+            (config.valueType === 'percentage' ||
+                config.secondaryValueType === 'percentage')) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Two axes with percentage aren't supported for donut charts");
+            return emptyChart;
+        }
+        if (hasSupplementaryData(allData)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Supplementary y values aren't supported for non-bar charts");
+            return emptyChart;
+        }
+        warnUnsupportedPatterns(allData, [], 'donut');
+        const { data: unstackedData, visibleIndices } = hide(allData);
+        const donutData = Chart.convertChartDataToDonutData(unstackedData);
+        const hasNonZeroValue = donutData.some(d => d.value > 0);
+        const arcData = hasNonZeroValue
+            ? donutData
+            : [
+                {
+                    label: '',
+                    value: 1,
+                },
+            ];
+        const colors = hasNonZeroValue
+            ? visibleIndices.map(i => config.colors[i % config.colors.length])
+            : ['--gray-30'];
+        const { pipeTransform } = getFormattingAndColors(allData, unstackedData, config);
+        const donutDefaultConfig = DefaultDonutSizingConfig;
+        const dataLabelPaddingConfig = getElementScalingInfo(config.donutDisplayInfo.scalingConfig?.elementScales, donutDefaultConfig.elementScales, 'dataLabelPadding');
+        const fontSizeConfig = getElementScalingInfo(config.donutDisplayInfo.scalingConfig?.elementScales, donutDefaultConfig.elementScales, 'fontSize');
+        const dataLabelTextSizing = getDataLabelSize(unstackedData, pipeTransform, fontSizeConfig.target);
+        const horizontalContainerScale = config.donutDisplayInfo.scalingConfig?.horizontalContainerScale !==
+            undefined
+            ? config.donutDisplayInfo.scalingConfig.horizontalContainerScale
+            : donutDefaultConfig.horizontalContainerScale;
+        const verticalContainerScale = config.donutDisplayInfo.scalingConfig?.verticalContainerScale !==
+            undefined
+            ? config.donutDisplayInfo.scalingConfig.verticalContainerScale
+            : donutDefaultConfig.verticalContainerScale;
+        const outerRadiusConfig = config.donutDisplayInfo.scalingConfig?.outerRadius !== undefined
+            ? config.donutDisplayInfo.scalingConfig.outerRadius
+            : donutDefaultConfig.outerRadius;
+        const drawRadiusConfig = config.donutDisplayInfo.scalingConfig?.drawRadius !== undefined
+            ? config.donutDisplayInfo.scalingConfig.drawRadius
+            : donutDefaultConfig.drawRadius;
+        const outer = outerRadiusConfig.type === 'proportion'
+            ? (dimensions.height / 2) * outerRadiusConfig.value
+            : outerRadiusConfig.value;
+        const drawRadius = drawRadiusConfig.type === 'proportion'
+            ? outer * drawRadiusConfig.value
+            : drawRadiusConfig.value;
+        const inner = outer - drawRadius;
+        const pieArcs = pie()
+            .sortValues(null)
+            .value(d => Math.max(d.value, 0))(arcData);
+        const arcs = pieArcs.map(pieArc => arc()
+            .innerRadius(inner)
+            .outerRadius(outer)
+            .padAngle(0.013)
+            .startAngle(pieArc.startAngle)
+            .endAngle(pieArc.endAngle)(pieArc.data));
+        const dataLabels = hasNonZeroValue
+            ? pieArcs.map(arc => {
+                //Don't show data labels for zero-width donut slices (includes negative values)
+                if (arc.startAngle === arc.endAngle) {
+                    return {
+                        elementType: 'dataLabel',
+                        label: '',
+                        yPos: 0,
+                        xPos: 0,
+                        anchor: 'middle',
+                    };
+                }
+                const arcCenterAngle = (arc.startAngle + arc.endAngle) / 2;
+                const edgePoint = arcToPoint(arcCenterAngle, outer);
+                const lineEndPoint = arcToPoint(arcCenterAngle, outer + dataLabelPaddingConfig.target);
+                const middleArea = outer / 4;
+                let yOffset = 0;
+                let xOffset = 0;
+                if (lineEndPoint.y > 0) {
+                    if (Math.abs(lineEndPoint.y) < middleArea) {
+                        yOffset = SMALL_PADDING / 2;
+                    }
+                    else {
+                        yOffset = SMALL_PADDING;
+                    }
+                    if (Math.abs(lineEndPoint.x) < middleArea) {
+                        yOffset += SMALL_PADDING / 2;
+                    }
+                }
+                else {
+                    if (Math.abs(lineEndPoint.y) < middleArea) {
+                        yOffset = SMALL_PADDING / 2;
+                    }
+                    if (Math.abs(lineEndPoint.x) < middleArea) {
+                        yOffset -= SMALL_PADDING / 2;
+                    }
+                }
+                return {
+                    elementType: 'dataLabel',
+                    label: pipeTransform(arc.data.value, arc.data.isSecondary),
+                    yPos: lineEndPoint.y + yOffset,
+                    xPos: lineEndPoint.x + xOffset,
+                    anchor: Math.abs(lineEndPoint.x) < middleArea
+                        ? 'middle'
+                        : lineEndPoint.x < 0
+                            ? 'end'
+                            : 'start',
+                    line: {
+                        x1: edgePoint.x,
+                        y1: edgePoint.y,
+                        x2: lineEndPoint.x,
+                        y2: lineEndPoint.y,
+                    },
+                };
+            })
+            : [];
+        const drawWidth = (outer +
+            (config.showDataLabels
+                ? dataLabelPaddingConfig.target + dataLabelTextSizing.horizontal
+                : 0)) *
+            2;
+        const drawHeight = (outer +
+            (config.showDataLabels
+                ? dataLabelPaddingConfig.target + dataLabelTextSizing.vertical
+                : 0)) *
+            2;
+        function hover(pos) {
+            const realPosX = pos.x + pos.containerScrollX;
+            const realPosY = pos.y + pos.containerScrollY;
+            if (getIfHoverOutOfBounds(pos.x, pos.y, realPosX, realPosY, null, dimensions)) {
+                return null;
+            }
+            const centerPointX = dimensions.width / 2;
+            const centerPointY = dimensions.height / 2;
+            const donutPositionX = realPosX - centerPointX;
+            const donutPositionY = realPosY - centerPointY;
+            const hoverPosArcInfo = pointToArc(donutPositionX, donutPositionY);
+            const arcCenterLine = (outer + inner) / 2;
+            //Detect donut slice
+            let foundYIndex = -1;
+            let preferredPosition = undefined;
+            let donutXPosition = 0;
+            let donutYPosition = 0;
+            for (let i = 0; i < pieArcs.length; i++) {
+                const arc = pieArcs[i];
+                if (hoverPosArcInfo.angle > arc.startAngle &&
+                    hoverPosArcInfo.angle < arc.endAngle &&
+                    hoverPosArcInfo.radius > arcCenterLine - drawRadius &&
+                    hoverPosArcInfo.radius < arcCenterLine + drawRadius) {
+                    foundYIndex = i;
+                    const arcCenterPoint = arcToPoint((arc.startAngle + arc.endAngle) / 2, arcCenterLine);
+                    //Need to un-offset the positions
+                    donutXPosition = arcCenterPoint.x + centerPointX;
+                    donutYPosition = arcCenterPoint.y + centerPointY;
+                    const verticalArea = arcCenterPoint.y < (dimensions.height * -1) / 4
+                        ? 'top'
+                        : arcCenterPoint.y > dimensions.height / 4
+                            ? 'bottom'
+                            : 'center';
+                    //Determine the best position for the tooltip
+                    if (arcCenterPoint.x > 0) {
+                        //Right path
+                        if (!config.groupedTooltip || verticalArea === 'center') {
+                            preferredPosition = 'center-right';
+                        }
+                        else if (verticalArea === 'top') {
+                            preferredPosition = 'right-top';
+                        }
+                        else if (verticalArea === 'bottom') {
+                            preferredPosition = 'right-bottom';
+                        }
+                    }
+                    else {
+                        //Left path
+                        if (!config.groupedTooltip || verticalArea === 'center') {
+                            preferredPosition = 'center-left';
+                        }
+                        else if (verticalArea === 'top') {
+                            preferredPosition = 'left-top';
+                        }
+                        else if (verticalArea === 'bottom') {
+                            preferredPosition = 'left-bottom';
+                        }
+                    }
+                    break;
+                }
+            }
+            if (foundYIndex === -1) {
+                return null;
+            }
+            if (!hasNonZeroValue) {
+                donutXPosition = centerPointX + arcCenterLine;
+                donutYPosition = centerPointY;
+            }
+            const localAnchorX = donutXPosition - pos.containerScrollX;
+            const localAnchorY = donutYPosition - pos.containerScrollY;
+            const { anchorX, anchorY } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions);
+            const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, SMALL_PADDING, 0);
+            return {
+                hoverType: 'standard',
+                tooltip: {
+                    anchor,
+                    preferredPosition,
+                    date: null,
+                    metrics: donutData
+                        .map((y, index) => ({
+                        color: colors[index % colors.length],
+                        label: y.label,
+                        value: pipeTransform(y.value, y.isSecondary, true),
+                    }))
+                        .filter((_, i) => config.groupedTooltip || i === foundYIndex),
+                },
+                //Not used by donut charts
+                x: 0,
+                xIndex: 0,
+                ys: [],
+                yIndex: 0,
+                visibleYIndex: 0,
+            };
+        }
+        return {
+            chartWidth: drawWidth,
+            chartHeight: drawHeight,
+            chartSizingValues: {
+                ...emptyChartScaleValues,
+                dataLabelPadding: dataLabelPaddingConfig.target,
+                dataLabelTextSize: dataLabelTextSizing.horizontal,
+                fontSize: fontSizeConfig.target,
+            },
+            xTicks: [],
+            yTicks: [],
+            areas: [],
+            lines: [],
+            circles: [],
+            bars: [],
+            colors,
+            arcs,
+            horizontalBars: [],
+            dataLabels,
+            waterfallLines: [],
+            gradients: [],
+            flowConnections: [],
+            horizontalContainerScale,
+            verticalContainerScale,
+            chartError: null,
+            hover,
+        };
+    }
+    function flows(config, allData, dimensions) {
+        if (allData.type !== 'flow') {
+            // eslint-disable-next-line no-console
+            console.warn(`Heads up! The '${allData.type}' data type isn't supported for flow charts.`);
+            return { ...emptyChart, chartError: 'config' };
+        }
+        const data = flowsTransform(config, allData);
+        if (data.x.length === 0) {
+            return emptyChart;
+        }
+        const overallTotal = data.x[0].totalCount;
+        const chartSizingValues = getFullChartScaleValues(config, data, dimensions, null, null);
+        if (chartSizingValues === null) {
+            return { ...emptyChart, chartError: 'sizing' };
+        }
+        const { scale } = calcDataAxisScalesAndTicks(data, null, config, chartSizingValues);
+        const valuePipes = getPipes(config.valueType);
+        const percentPipes = getPipes('percentage');
+        const bars = [];
+        const flowConnections = [];
+        const dataLabels = [];
+        const minimumSize = getMinimumDataElementSize(config);
+        for (let i = 0; i < data.x.length; i++) {
+            const bucketBars = [];
+            let runningHeight = 0;
+            for (const bar of data.x[i].subBuckets) {
+                const continuingCount = bar.connections
+                    .filter(connection => connection.direction === 'forward')
+                    .map(connection => connection.count)
+                    .reduce((a, b) => a + b, 0);
+                const { totalSize: totalHeight, continuingSize: darkenedHeight, connectionSizes, } = getFlowSubBucketSizes(bar, value => scale(value, false) - chartSizingValues.totalTopOffset, minimumSize);
+                const connectionHeight = (connection) => connectionSizes[bar.connections.indexOf(connection)];
+                const nonDarkenedHeight = totalHeight - darkenedHeight;
+                const darkenedY = runningHeight + chartSizingValues.totalTopOffset;
+                const nonDarkenedY = darkenedY + darkenedHeight;
+                const width = chartSizingValues.barSize;
+                const x = chartSizingValues.totalLeftOffset +
+                    i * (chartSizingValues.barSize + chartSizingValues.bucketGap);
+                const colorOverride = config.flowConfig.subBucketsConfig.find(bc => bc.bucketId === bar.id)?.color;
+                if (darkenedHeight > 0) {
+                    bucketBars.push({
+                        elementType: 'rect',
+                        rectType: 'flow',
+                        height: darkenedHeight,
+                        width,
+                        y: darkenedY,
+                        x,
+                        colorOverride,
+                        darken: true,
+                        deEmphasize: isDeEmphasized(config, bar.id, true),
+                        id: bar.id,
+                        bucketIndex: i,
+                        count: continuingCount,
+                        totalCount: bar.count,
+                    });
+                }
+                if (nonDarkenedHeight > 0) {
+                    bucketBars.push({
+                        elementType: 'rect',
+                        rectType: 'flow',
+                        height: nonDarkenedHeight,
+                        width,
+                        y: nonDarkenedY,
+                        x,
+                        colorOverride,
+                        darken: false,
+                        deEmphasize: isDeEmphasized(config, bar.id, false),
+                        id: bar.id,
+                        bucketIndex: i,
+                        count: bar.count - continuingCount,
+                        totalCount: bar.count,
+                    });
+                }
+                //Invisible bar for hover highlight purposes
+                bucketBars.push({
+                    elementType: 'rect',
+                    rectType: 'flow',
+                    height: darkenedHeight + nonDarkenedHeight,
+                    width,
+                    y: darkenedY,
+                    x,
+                    nonDisplay: true,
+                    id: bar.id,
+                    bucketIndex: i,
+                    count: bar.count,
+                    totalCount: bar.count,
+                    darken: false,
+                    deEmphasize: false,
+                });
+                runningHeight +=
+                    totalHeight +
+                        chartSizingValues.dataLabelPadding +
+                        chartSizingValues.dataLabelTextSize;
+                //Connections
+                //Add new renders for forward connections
+                let verticalConnectionOffset = 0;
+                for (const connection of bar.connections.filter(connection => connection.direction === 'forward')) {
+                    const topLineY1 = darkenedY + verticalConnectionOffset;
+                    const bottomLineY1 = topLineY1 + connectionHeight(connection);
+                    const x1 = x + width;
+                    const connectionRender = {
+                        elementType: 'connection',
+                        start: connection.start,
+                        end: connection.end,
+                        count: connection.count,
+                        step: i,
+                        topLine: {
+                            y1: topLineY1,
+                            x1,
+                            //To be filled in later
+                            y2: 0,
+                            x2: 0,
+                        },
+                        bottomLine: {
+                            y1: bottomLineY1,
+                            x1,
+                            //To be filled in later
+                            y2: 0,
+                            x2: 0,
+                        },
+                        //To be filled in later
+                        path: '',
+                    };
+                    verticalConnectionOffset += connectionHeight(connection);
+                    flowConnections.push(connectionRender);
+                }
+                //Backfill position info for backwards connections
+                verticalConnectionOffset = 0;
+                for (const connection of bar.connections.filter(connection => connection.direction === 'backward')) {
+                    const matchingConnection = flowConnections.find(con => con.start === connection.start &&
+                        con.end === connection.end &&
+                        con.step === i - 1);
+                    if (matchingConnection) {
+                        const topLineY2 = darkenedY + verticalConnectionOffset;
+                        const bottomLineY2 = topLineY2 + connectionHeight(connection);
+                        matchingConnection.topLine.y2 = topLineY2;
+                        matchingConnection.topLine.x2 = x;
+                        matchingConnection.bottomLine.y2 = bottomLineY2;
+                        matchingConnection.bottomLine.x2 = x;
+                        matchingConnection.path =
+                            calculateFlowConnectionPath(matchingConnection);
+                        verticalConnectionOffset += connectionHeight(connection);
+                    }
+                }
+                //Data Labels
+                const barName = config.flowConfig.subBucketsConfig.find(sbc => sbc.bucketId === bar.id)?.bucketName;
+                if (barName !== undefined) {
+                    dataLabels.push({
+                        elementType: 'dataLabel',
+                        dataLabelType: 'flow',
+                        label: `${barName} (${percentPipes.pipe.transform(bar.count / data.x[i].totalCount)})`,
+                        xPos: x,
+                        yPos: darkenedY -
+                            (chartSizingValues.dataLabelTextSize +
+                                chartSizingValues.dataLabelPadding) /
+                                2,
+                        anchor: 'start',
+                        bold: true,
+                        bucketIndex: i,
+                        barId: bar.id,
+                    });
+                }
+                const barSubtitle = config.flowConfig.subtitleFormatString.replace('{value}', valuePipes.pipe.transform(bar.count));
+                dataLabels.push({
+                    elementType: 'dataLabel',
+                    dataLabelType: 'flow',
+                    label: barSubtitle,
+                    xPos: x,
+                    yPos: darkenedY - chartSizingValues.dataLabelPadding / 4,
+                    anchor: 'start',
+                    bucketIndex: i,
+                    barId: bar.id,
+                });
+            }
+            bars.push(bucketBars);
+        }
+        function hover(pos) {
+            const realPosX = pos.x + pos.containerScrollX;
+            const realPosY = pos.y + pos.containerScrollY;
+            if (chartSizingValues === null ||
+                getIfHoverOutOfBounds(pos.x, pos.y, realPosX, realPosY, chartSizingValues, dimensions)) {
+                return null;
+            }
+            const bucketIndexInfo = getFlowBucketIndexForHover(chartSizingValues, realPosX);
+            if (bucketIndexInfo === null || bucketIndexInfo.index >= bars.length) {
+                return null;
+            }
+            if (bucketIndexInfo.area === 'bar') {
+                for (const bar of bars[bucketIndexInfo.index]) {
+                    if (realPosY < bar.y) {
+                        //Bar title
+                        const localAnchorX = bar.x - pos.containerScrollX;
+                        const width = bar.width;
+                        const height = chartSizingValues.dataLabelPadding / 2 +
+                            chartSizingValues.dataLabelTextSize;
+                        const localAnchorY = bar.y - (pos.containerScrollY + height);
+                        const { anchorX, anchorY, anchorWidth, anchorHeight } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions, width, height);
+                        const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, anchorWidth, anchorHeight);
+                        return {
+                            hoverType: 'flow',
+                            hoverTarget: 'barTitle',
+                            barId: bar.id ?? '',
+                            bucketIndex: bucketIndexInfo.index,
+                            tooltip: {
+                                anchor,
+                                subtitle: config.flowConfig.subtitleFormatString.replace('{value}', valuePipes.pipe.transform(bar.totalCount)),
+                            },
+                        };
+                    }
+                    else if (
+                    // The invisible highlight bar spans both portions, so skip it to
+                    // avoid misreporting a portion boundary as the ending portion
+                    !bar.nonDisplay &&
+                        realPosY >= bar.y &&
+                        realPosY < bar.y + bar.height) {
+                        //Bar
+                        const localAnchorX = bar.x - pos.containerScrollX;
+                        const width = bar.width;
+                        const localAnchorY = bar.y - pos.containerScrollY;
+                        const height = bar.height;
+                        const { anchorX, anchorY, anchorWidth, anchorHeight } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions, width, height);
+                        const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, anchorWidth, anchorHeight);
+                        return {
+                            hoverType: 'flow',
+                            hoverTarget: 'bar',
+                            barId: bar.id ?? '',
+                            bucketIndex: bucketIndexInfo.index,
+                            forDarken: bar.darken === true,
+                            tooltip: {
+                                anchor,
+                                subtitle: config.flowConfig.subtitleFormatString.replace('{value}', valuePipes.pipe.transform(bar.count)),
+                            },
+                        };
+                    }
+                }
+            }
+            else {
+                for (const connection of flowConnections.filter(flowCon => flowCon.step === bucketIndexInfo.index)) {
+                    if (checkIfPointWithinConnection(connection, realPosX, realPosY)) {
+                        const localAnchorX = connection.topLine.x1 - pos.containerScrollX;
+                        const width = connection.topLine.x2 - connection.topLine.x1;
+                        const curveTop = bezierYAtX((connection.topLine.x1 + connection.topLine.x2) / 2, connection.topLine);
+                        const curveBottom = bezierYAtX((connection.topLine.x1 + connection.topLine.x2) / 2, connection.bottomLine);
+                        const localAnchorY = curveTop - pos.containerScrollY;
+                        const height = curveBottom - curveTop;
+                        const { anchorX, anchorY, anchorWidth, anchorHeight } = checkAnchorsAgainstBound(localAnchorX, localAnchorY, dimensions, width, height);
+                        const anchor = new DOMRect(anchorX + pos.rect.x, anchorY + pos.rect.y, anchorWidth, anchorHeight);
+                        return {
+                            hoverType: 'flow',
+                            hoverTarget: 'connection',
+                            startId: connection.start,
+                            endId: connection.end,
+                            startBucketIndex: connection.step,
+                            tooltip: {
+                                anchor,
+                                subtitle: config.flowConfig.subtitleFormatString.replace('{value}', valuePipes.pipe.transform(connection.count)),
+                            },
+                        };
+                    }
+                }
+            }
+            return null;
+        }
+        return {
+            chartWidth: chartSizingValues.totalWidth,
+            chartHeight: chartSizingValues.totalHeight,
+            chartSizingValues,
+            xTicks: [],
+            yTicks: [],
+            colors: [],
+            bars,
+            lines: [],
+            circles: [],
+            areas: [],
+            hover,
+            arcs: [],
+            horizontalBars: [],
+            dataLabels,
+            waterfallLines: [],
+            gradients: [],
+            flowConnections,
+            horizontalContainerScale: chartSizingValues.horizontalContainerScale,
+            verticalContainerScale: chartSizingValues.verticalContainerScale,
+            chartError: null,
+        };
+    }
+    /*
+      Mirrors the bucketing in flowsTransform: a path contributes values[i] to
+      the bar at step i, and values[i + 1] to its forward connection (which is
+      also the bar's continuing portion).
+    */
+    function flowValueAtStep(y, step) {
+        return y.steps.length > step && y.values.length > step
+            ? y.values[step]
+            : null;
+    }
+    function sumFlowValues(data, yIndices, step) {
+        return yIndices
+            .map(index => flowValueAtStep(data.ys[index], step) ?? 0)
+            .reduce((a, b) => a + b, 0);
+    }
+    function toFlowClickEvent(hover, data) {
+        const allYIndices = data.ys.map((_, index) => index);
+        if (hover.hoverTarget === 'connection') {
+            const step = hover.startBucketIndex;
+            const yIndices = allYIndices.filter(index => data.ys[index].steps[step] === hover.startId &&
+                flowValueAtStep(data.ys[index], step) !== null &&
+                data.ys[index].steps[step + 1] === hover.endId &&
+                flowValueAtStep(data.ys[index], step + 1) !== null);
+            return {
+                target: 'connection',
+                startBucketIndex: step,
+                startId: hover.startId,
+                endId: hover.endId,
+                count: sumFlowValues(data, yIndices, step + 1),
+                yIndices,
+            };
+        }
+        const step = hover.bucketIndex;
+        const barYIndices = allYIndices.filter(index => data.ys[index].steps[step] === hover.barId &&
+            flowValueAtStep(data.ys[index], step) !== null);
+        const totalCount = sumFlowValues(data, barYIndices, step);
+        const base = { bucketIndex: step, barId: hover.barId };
+        if (hover.hoverTarget === 'barTitle') {
+            return {
+                ...base,
+                target: 'title',
+                count: totalCount,
+                yIndices: barYIndices,
+            };
+        }
+        const continuingCount = sumFlowValues(data, barYIndices, step + 1);
+        if (hover.forDarken) {
+            return {
+                ...base,
+                target: 'continuing',
+                count: continuingCount,
+                totalCount,
+                yIndices: barYIndices.filter(index => (flowValueAtStep(data.ys[index], step + 1) ?? 0) > 0),
+            };
+        }
+        return {
+            ...base,
+            target: 'ending',
+            count: totalCount - continuingCount,
+            totalCount,
+            yIndices: barYIndices.filter(index => (flowValueAtStep(data.ys[index], step) ?? 0) >
+                (flowValueAtStep(data.ys[index], step + 1) ?? 0)),
+        };
+    }
+    Chart.toFlowClickEvent = toFlowClickEvent;
+    const SMALL_PADDING = 8;
+    Chart.DEFAULT_FONT_SIZE = 12; //the width constants are based on font size 12, so this variable can help w/ scaling
+    Chart.WIDTH_PER_LETTER = 6.5;
+    const WIDTH_PER_NUMBER = 7;
+    const WIDTH_PER_PERIOD = 2;
+    const WIDTH_PER_SLASH = 4;
+    //When the data axis grows, the data is always given at least this portion of the provided size
+    const GROWN_DATA_MINIMUM_RATIO = 0.5;
+    const DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS = 4;
+    const FLOW_CONNECTION_CURVE_CONSTANT = 0.5;
+    function getFormattingAndColors(originalData, data, config) {
+        const dateFormat = (date) => formatedDate(config.dateFormat || 'day', date);
+        const { pipe, fullPipe } = getPipes(config.valueType);
+        const { pipe: secondaryPipe, fullPipe: secondaryFullPipe } = config.secondaryValueType
+            ? getPipes(config.secondaryValueType)
+            : {
+                pipe,
+                fullPipe,
+            };
+        const pipeTransform = (value, isSecondary, isFull) => {
+            if (isFull !== true) {
+                if (isSecondary === true) {
+                    return secondaryPipe.transform(value);
+                }
+                return pipe.transform(value);
+            }
+            let retVal = null;
+            if (isSecondary) {
+                retVal = secondaryFullPipe.transform(value);
+            }
+            else {
+                retVal = fullPipe.transform(value);
+            }
+            return retVal !== null ? retVal : '-';
+        };
+        // Pre-calculate color indices for all items (use original data for stable colors)
+        const colorIndices = calculateColorIndices(originalData);
+        const colors = data.ys.map(y => getColor(y, colorIndices, config.colors));
+        return {
+            dateFormat,
+            pipeTransform,
+            colorIndices,
+            colors,
+        };
+    }
+    function calculateColorIndices(data) {
+        const colorMap = new Map();
+        // Original Ys: use their array index directly
+        data.ys.forEach((y, index) => {
+            colorMap.set(y, index);
+        });
+        // Supplementary Ys: group by supplementalIndex, use position within that group
+        if (hasSupplementaryData(data)) {
+            const suppGroups = new Map();
+            data.supplementaryYs.forEach(suppY => {
+                if (!suppGroups.has(suppY.supplementalIndex)) {
+                    suppGroups.set(suppY.supplementalIndex, []);
+                }
+                suppGroups.get(suppY.supplementalIndex).push(suppY);
+            });
+            suppGroups.forEach(items => {
+                items.forEach((item, positionInGroup) => {
+                    colorMap.set(item, positionInGroup);
+                });
+            });
+        }
+        return colorMap;
+    }
+    Chart.calculateColorIndices = calculateColorIndices;
+    function getColor(item, colorIndices, colors) {
+        if (item === undefined) {
+            return colors[0];
+        }
+        if (item.colorToken)
+            return item.colorToken;
+        const colorIndex = colorIndices.get(item) ?? 0;
+        return colors[colorIndex % colors.length];
+    }
+    Chart.getColor = getColor;
+    function getBucketTickCount(chartSizingValues) {
+        let availableSize = 0;
+        let minSpacing = 1;
+        if (chartSizingValues.chartDataDirection === 'vertical') {
+            availableSize =
+                chartSizingValues.totalWidth -
+                    chartSizingValues.leftPadding -
+                    chartSizingValues.rightPadding;
+            minSpacing =
+                chartSizingValues.horizontalAxisLabelTextSize + SMALL_PADDING;
+        }
+        if (chartSizingValues.chartDataDirection === 'horizontal') {
+            availableSize =
+                chartSizingValues.totalHeight -
+                    chartSizingValues.topPadding -
+                    chartSizingValues.bottomPadding;
+            minSpacing = chartSizingValues.verticalAxisLabelTextSize + SMALL_PADDING;
+        }
+        minSpacing = minSpacing * (chartSizingValues.fontSize / Chart.DEFAULT_FONT_SIZE);
+        return Math.max(2, Math.floor(availableSize / minSpacing));
+    }
+    function getClusterInfoForBucket(data, config) {
+        // Slot layout is the same for every bucket — zero values still occupy
+        // their slot, they just render with no height/width. This keeps bucket
+        // sizes, bar positions, and hover detection consistent across buckets
+        // regardless of which series happen to be zero.
+        const normClusterIndices = data.ys.map((_, yIndex) => yIndex);
+        const normClusterCount = normClusterIndices.length;
+        const suppClusterIndices = uniq(hasSupplementaryData(data)
+            ? data.supplementaryYs.map(y => y.supplementalIndex)
+            : []);
+        suppClusterIndices.sort((a, b) => a - b);
+        const suppClusterCount = suppClusterIndices.length;
+        const actualNormClusterCount = isClusteredData(data, config, false)
+            ? normClusterCount
+            : Math.min(normClusterCount, 1);
+        return {
+            normCount: actualNormClusterCount,
+            suppCount: suppClusterCount,
+            total: actualNormClusterCount + suppClusterCount,
+            normClusterIndices,
+            suppClusterIndices,
+        };
+    }
+    //This function gives the total distance from the start of the given bucket, to the end of the current bucket
+    function getBucketSize(data, config, chartSizingValues) {
+        const totalBarNumber = getClusterInfoForBucket(data, config);
+        const bucketSize = totalBarNumber.total * chartSizingValues.barSize +
+            (totalBarNumber.total - 1) * chartSizingValues.barClusterGap;
+        return bucketSize;
+    }
+    //This function gives the total distance from the start of the given bucket, to the start of the next bucket
+    function getTotalBucketGap(data, config, chartSizingValues) {
+        const bucketSize = getBucketSize(data, config, chartSizingValues);
+        return bucketSize + chartSizingValues.bucketGap;
+    }
+    //This function gives the total distance from the start of the first bucket, to the start of the given bucket
+    function getTotalPreBucketGap(data, config, chartSizingValues, bucketIndex) {
+        let cumulativeBucketGap = 0;
+        for (let i = 0; i < bucketIndex; i++) {
+            cumulativeBucketGap += getTotalBucketGap(data, config, chartSizingValues);
+        }
+        return cumulativeBucketGap;
+    }
+    function generateTimeseriesTicks(data, config, tickCount, chartSizingValues, format) {
+        const getLabel = (index) => {
+            return format(new Date(data.x[index]));
+        };
+        return getTicks(data, getLabel, config, tickCount, chartSizingValues);
+    }
+    function generateLabelledTicks(data, config, tickCount, chartSizingValues) {
+        const getLabel = (index) => {
+            return data.x[index].label;
+        };
+        return getTicks(data, getLabel, config, tickCount, chartSizingValues);
+    }
+    function getTicks(data, getLabel, config, tickCount, chartSizingValues) {
+        if (data.x.length === 0) {
+            return [];
+        }
+        if (data.x.length === 1) {
+            const labelOffset = getTickLabelOffset(data, config, chartSizingValues, 0);
+            return [{ value: labelOffset, label: getLabel(0) }];
+        }
+        const lastIndex = data.x.length - 1;
+        const tickBucketSpacing = Math.ceil(lastIndex / tickCount);
+        const numTicks = Math.floor(lastIndex / tickBucketSpacing) + 1;
+        const step = lastIndex / (numTicks - 1);
+        // Always include first and last data points.
+        // Inner ticks are approximately evenly spaced using rounding.
+        const indices = [];
+        for (let i = 0; i < numTicks; i++) {
+            indices.push(Math.round(i * step));
+        }
+        return indices.map(i => {
+            const labelOffset = getTickLabelOffset(data, config, chartSizingValues, i);
+            return {
+                value: getTotalPreBucketGap(data, config, chartSizingValues, i) +
+                    labelOffset,
+                label: getLabel(i),
+            };
+        });
+    }
+    function getTickLabelOffset(data, config, chartSizingValues, bucketIndex) {
+        const inherentOffset = chartSizingValues.chartDataDirection === 'horizontal'
+            ? chartSizingValues.totalTopOffset
+            : chartSizingValues.totalLeftOffset;
+        //To have the label be centered on the bucket's center position
+        const bucketOffset = getBucketSize(data, config, chartSizingValues) / 2;
+        let horizontalBarOffset = 0;
+        if (chartSizingValues.chartDataDirection === 'horizontal') {
+            //This account for the fact that the inherentOffset and bucketOffset result in matching y values for the bar and the label
+            //  However, for the bar, that y position is the top of the bar, while for the label, it's the bottom of the label
+            //  When exactly lined up like that, the label actually looks a little low, so that -2 makes it look correct
+            horizontalBarOffset = chartSizingValues.fontSize / 2 - 2;
+        }
+        return inherentOffset + bucketOffset + horizontalBarOffset;
+    }
+    Chart.defaultConfig = {
+        type: 'line',
+        groupedTooltip: true,
+        colors: Chart.defaultColorPalette,
+        allowLegendToggle: false,
+        zeroStateMessage: 'No data to display.',
+        sizingErrorStateMessage: 'The chart cannot display at the current size.',
+        valueType: 'currency',
+        truncateLegend: true,
+        dateFormat: 'day',
+    };
+    Chart.defaultDonutConfig = {
+        type: 'donut',
+        groupedTooltip: true,
+        colors: Chart.defaultColorPalette,
+        allowLegendToggle: false,
+        zeroStateMessage: 'No data to display.',
+        sizingErrorStateMessage: 'The chart cannot display at the current size.',
+        valueType: 'currency',
+        truncateLegend: true,
+        dateFormat: 'day',
+        donutDisplayInfo: {
+            size: 'medium',
+            displayValue: '',
+        },
+    };
+    function toXTick(tick) {
+        return {
+            x: tick.value,
+            label: tick.label,
+            secondaryLabel: tick.secondaryLabel,
+        };
+    }
+    function toYTick(tick) {
+        return {
+            y: tick.value,
+            label: tick.label,
+            secondaryLabel: tick.secondaryLabel,
+        };
+    }
+    const emptyChart = {
+        chartWidth: 0,
+        chartHeight: 0,
+        chartSizingValues: emptyChartScaleValues,
+        xTicks: [],
+        yTicks: [],
+        colors: [],
+        lines: [],
+        circles: [],
+        areas: [],
+        bars: [],
+        arcs: [],
+        horizontalBars: [],
+        dataLabels: [],
+        waterfallLines: [],
+        gradients: [],
+        flowConnections: [],
+        horizontalContainerScale: 'no-scale',
+        verticalContainerScale: 'no-scale',
+        chartError: null,
+    };
+    //'y' in this function refers to the data y, since this function
+    // is also used by horizontal-bars, where the data y is the chart x
+    function calcDataAxisScalesAndTicks(data, pipeTransformInput, config, chartSizingValues) {
+        const pipeTransform = pipeTransformInput !== null ? pipeTransformInput : () => '';
+        const { primaryDataMin, primaryDataMax, secondaryDataMin, secondaryDataMax, scaleDomainMultipleForMax, scaleDomainMultipleForNeg, } = calcDataScalingValues(data, config);
+        const startOffset = chartSizingValues.chartDataDirection === 'horizontal'
+            ? chartSizingValues.totalLeftOffset
+            : chartSizingValues.totalTopOffset;
+        let minSpacing = (chartSizingValues.chartDataDirection === 'horizontal'
+            ? chartSizingValues.horizontalAxisLabelTextSize
+            : chartSizingValues.verticalAxisLabelTextSize) + SMALL_PADDING;
+        minSpacing = minSpacing * (chartSizingValues.fontSize / Chart.DEFAULT_FONT_SIZE);
+        const spacingTickCount = Math.max(2, Math.floor(chartSizingValues.sizeForData / minSpacing));
+        const actualTargetTickCount = Math.min(spacingTickCount, chartSizingValues.targetTickCount);
+        const hasPrimary = primaryDataMin !== 0 || primaryDataMax !== 0;
+        const hasSecondary = secondaryDataMin !== 0 || secondaryDataMax !== 0;
+        const scaleRange = chartSizingValues.chartDataDirection === 'horizontal' ||
+            config.type === 'flow'
+            ? [0, chartSizingValues.sizeForData]
+            : [chartSizingValues.sizeForData, 0];
+        //These 'effective' values ensure we have room for potential stacking of secondary and non-secondary values
+        let effectivePrimaryMin = primaryDataMin * scaleDomainMultipleForNeg;
+        let effectivePrimaryMax = primaryDataMax * scaleDomainMultipleForMax;
+        //Simpler path for data w/o secondaries
+        if (!hasSecondary) {
+            const primaryYDomain = [effectivePrimaryMin, effectivePrimaryMax];
+            const yScale = scaleLinear(primaryYDomain, scaleRange);
+            const ticks = yScale
+                .ticks(actualTargetTickCount)
+                .map(tick => ({
+                value: yScale(tick) + startOffset,
+                label: pipeTransform(tick, false),
+            }));
+            const scale = (input) => {
+                return yScale(input) + startOffset;
+            };
+            return {
+                scale,
+                ticks,
+            };
+        }
+        //Simpler path for data w/o primaries
+        if (!hasPrimary) {
+            const secondaryYDomain = [secondaryDataMin, secondaryDataMax];
+            const yScale = scaleLinear(secondaryYDomain, scaleRange);
+            const ticks = yScale
+                .ticks(actualTargetTickCount)
+                .map(tick => ({
+                value: yScale(tick) + startOffset,
+                label: pipeTransform(tick, true),
+            }));
+            const scale = (input) => {
+                return yScale(input) + startOffset;
+            };
+            return {
+                scale,
+                ticks,
+            };
+        }
+        let effectiveSecondaryMax = 0;
+        let effectiveSecondaryMin = 0;
+        //This block sets the effective max for primary and secondary
+        //This to ensure that the effective maxes for both data sets are properly set so that
+        // 0 will fall at the same place on both and each will have 'room' for potential stacking
+        if ((primaryDataMax <= 0 && secondaryDataMin >= 0) ||
+            (primaryDataMin >= 0 && secondaryDataMax <= 0)) {
+            //In this scenario, one set of data is competely positive, while the other is completely negative
+            //The two data sets can scale completely independently
+            //We 'mirror' the values of the two data sets, which'll put the 0 axis in the center of the data
+            if (primaryDataMax <= 0) {
+                effectivePrimaryMax = Math.abs(effectivePrimaryMin);
+            }
+            if (primaryDataMin >= 0) {
+                effectivePrimaryMin = -Math.abs(effectivePrimaryMax);
+            }
+            if (secondaryDataMax <= 0) {
+                effectiveSecondaryMin = secondaryDataMin;
+                effectiveSecondaryMax = Math.abs(secondaryDataMin);
+            }
+            if (secondaryDataMin >= 0) {
+                effectiveSecondaryMax = secondaryDataMax;
+                effectiveSecondaryMin = -secondaryDataMax;
+            }
+        }
+        else if (primaryDataMax > 0) {
+            if (primaryDataMin < 0) {
+                //Primary data has positive and negative
+                if (secondaryDataMax > 0) {
+                    //Secondary data has positive
+                    effectiveSecondaryMax = secondaryDataMax * scaleDomainMultipleForMax;
+                    if (secondaryDataMin < 0) {
+                        //Secondary data has negative
+                        effectiveSecondaryMin =
+                            secondaryDataMin * scaleDomainMultipleForNeg;
+                    }
+                    else {
+                        //Secondary data is only positive
+                        effectiveSecondaryMin =
+                            (secondaryDataMax / primaryDataMax) *
+                                primaryDataMin *
+                                scaleDomainMultipleForNeg;
+                    }
+                }
+                else {
+                    //Secondary data has only negative
+                    effectiveSecondaryMin = secondaryDataMin * scaleDomainMultipleForNeg;
+                    effectiveSecondaryMax =
+                        (secondaryDataMin / primaryDataMin) *
+                            primaryDataMax *
+                            scaleDomainMultipleForMax;
+                }
+            }
+            else {
+                //Primary data is only positive
+                //Due to earlier check, we know that secondary data is either also all-positive, or positive and negative
+                effectiveSecondaryMax = secondaryDataMax * scaleDomainMultipleForMax;
+                effectiveSecondaryMin = secondaryDataMin * scaleDomainMultipleForNeg;
+                effectivePrimaryMin =
+                    (primaryDataMax / secondaryDataMax) *
+                        secondaryDataMin *
+                        scaleDomainMultipleForNeg;
+            }
+        }
+        else {
+            //Primary data is only negative
+            //Due to earlier check, we know that secondary data is either also all-negative, or positive and negative
+            effectiveSecondaryMax = secondaryDataMax * scaleDomainMultipleForMax;
+            effectiveSecondaryMin = secondaryDataMin * scaleDomainMultipleForNeg;
+            effectivePrimaryMax =
+                (primaryDataMin / secondaryDataMin) *
+                    secondaryDataMax *
+                    scaleDomainMultipleForMax;
+        }
+        const primaryYDomain = [effectivePrimaryMin, effectivePrimaryMax];
+        const yScale = scaleLinear(primaryYDomain, scaleRange);
+        //Figuring out the best tick count to fit the two data srouces
+        const yScalePrimaryProto = scaleLinear(primaryYDomain, scaleRange);
+        const yScaleSecondaryProto = scaleLinear([effectiveSecondaryMin, effectiveSecondaryMax], scaleRange);
+        const tickCount = Math.max(actualTargetTickCount, yScalePrimaryProto.ticks(actualTargetTickCount).length, yScaleSecondaryProto.ticks(actualTargetTickCount).length);
+        const primaryTicks = yScale.ticks(tickCount).map(tick => ({
+            value: yScale(tick) + startOffset,
+            label: pipeTransform(tick, false),
+            rawY: tick,
+        }));
+        //Finding a domain for the secondary data such that it will result in round tick values when matched with the primary ticks
+        const secondaryTicksProto = yScaleSecondaryProto
+            .ticks(tickCount)
+            .map(tick => ({
+            y: yScaleSecondaryProto(tick),
+            rawY: tick,
+            label: pipeTransform(tick, true),
+        }));
+        const primaryMinTick = Math.min(...primaryTicks.map(tick => tick.rawY));
+        const primaryMaxTick = Math.max(...primaryTicks.map(tick => tick.rawY));
+        const primaryDomainMaxTickRatio = primaryMaxTick !== 0 ? effectivePrimaryMax / primaryMaxTick : 0;
+        const primaryDomainMinTickRatio = primaryMinTick !== 0 ? effectivePrimaryMin / primaryMinTick : 0;
+        const primaryGap = primaryTicks[1].rawY - primaryTicks[0].rawY;
+        const ticksBelowZero = primaryMinTick / primaryGap;
+        const ticksAboveZero = primaryMaxTick / primaryGap;
+        const secondaryGap = secondaryTicksProto[1].rawY - secondaryTicksProto[0].rawY;
+        let calcRangeMult = 1;
+        const secondaryDomainMinMult = ticksBelowZero * secondaryGap * primaryDomainMinTickRatio;
+        const secondaryDomainMaxMult = ticksAboveZero * secondaryGap * primaryDomainMaxTickRatio;
+        //First, we ensure the calcRangeMult is big enough
+        let sizeUpComplete = false;
+        while (!sizeUpComplete) {
+            const calcRangeTooSmallForMin = secondaryDomainMinMult * calcRangeMult > effectiveSecondaryMin &&
+                secondaryDomainMinMult !== 0;
+            const calcRangeTooSmallForMax = secondaryDomainMaxMult * calcRangeMult < effectiveSecondaryMax &&
+                secondaryDomainMaxMult !== 0;
+            if (calcRangeTooSmallForMin || calcRangeTooSmallForMax) {
+                calcRangeMult = calcRangeMult * 2;
+            }
+            else {
+                sizeUpComplete = true;
+            }
+        }
+        //Then, we check if we can scale down (for this one, both conditions have to be true, so it won't undo a previous scale up)
+        let sizeDownComplete = false;
+        while (!sizeDownComplete) {
+            const calcRangeTooBigForMin = secondaryDomainMinMult * calcRangeMult < effectiveSecondaryMin * 2 &&
+                secondaryDomainMinMult !== 0;
+            const calcRangeTooBigForMax = secondaryDomainMaxMult * calcRangeMult > effectiveSecondaryMax * 2 &&
+                secondaryDomainMaxMult !== 0;
+            if (calcRangeTooBigForMin && calcRangeTooBigForMax) {
+                calcRangeMult = calcRangeMult / 2;
+            }
+            else {
+                sizeDownComplete = true;
+            }
+        }
+        let secondaryDomainMin = secondaryDomainMinMult * calcRangeMult;
+        let secondaryDomainMax = secondaryDomainMaxMult * calcRangeMult;
+        //If the data is lopsided enough, it's possible that one of positive/negative have values, but no ticks
+        if (secondaryDomainMin === 0 && effectivePrimaryMin < 0) {
+            const posSecRatio = secondaryDomainMax / effectivePrimaryMax;
+            secondaryDomainMin = posSecRatio * effectivePrimaryMin;
+        }
+        if (secondaryDomainMax === 0 && effectivePrimaryMax > 0) {
+            const posSecRatio = secondaryDomainMin / effectivePrimaryMin;
+            secondaryDomainMax = posSecRatio * effectivePrimaryMax;
+        }
+        const yScaleSecondary = scaleLinear([secondaryDomainMin, secondaryDomainMax], scaleRange);
+        const ticks = primaryTicks.map(tick => ({
+            ...tick,
+            secondaryLabel: pipeTransform(yScaleSecondary.invert(yScale(tick.rawY)), true),
+        }));
+        const scale = (input, isSecondary) => {
+            if (isSecondary) {
+                return yScaleSecondary(input) + startOffset;
+            }
+            return yScale(input) + startOffset;
+        };
+        return {
+            scale,
+            ticks,
+        };
+    }
+    function calcDataScalingValues(data, config) {
+        const isStacked = isStackedData(config);
+        const primaryDomainValues = calcYScaleDomainValues(data, isStacked, false);
+        const secondaryDomainValues = calcYScaleDomainValues(data, isStacked, true);
+        const primaryDataMax = Math.max(...primaryDomainValues.map(val => val.max));
+        const secondaryDataMax = Math.max(...secondaryDomainValues.map(val => val.max));
+        const primaryDataMin = Math.min(...primaryDomainValues.map(val => val.min));
+        const secondaryDataMin = Math.min(...secondaryDomainValues.map(val => val.min));
+        let scaleDomainMultipleForMax = 1;
+        let scaleDomainMultipleForNeg = 1;
+        //Calculating how much we need to multiple the domain by to 'fit' both axes' data
+        if (isStacked) {
+            for (let i = 0; i < primaryDomainValues.length; i++) {
+                //Check positive max
+                const primaryVal = primaryDomainValues[i].max;
+                const secondaryVal = secondaryDomainValues[i].max;
+                const primaryRatio = primaryDataMax !== 0 ? primaryVal / primaryDataMax : 0;
+                const secondaryRatio = secondaryDataMax !== 0 ? secondaryVal / secondaryDataMax : 0;
+                const multVal = primaryRatio + secondaryRatio;
+                if (multVal > scaleDomainMultipleForMax) {
+                    scaleDomainMultipleForMax = multVal;
+                }
+                //Check negative min
+                const primaryNegVal = primaryDomainValues[i].min < 0 ? primaryDomainValues[i].min : 0;
+                const secondaryNegVal = secondaryDomainValues[i].min < 0 ? secondaryDomainValues[i].min : 0;
+                const primaryNegRatio = primaryDataMin !== 0 ? primaryNegVal / primaryDataMin : 0;
+                const secondaryNegRatio = secondaryDataMin !== 0 ? secondaryNegVal / secondaryDataMin : 0;
+                const negMultVal = primaryNegRatio + secondaryNegRatio;
+                if (negMultVal > scaleDomainMultipleForNeg) {
+                    scaleDomainMultipleForNeg = negMultVal;
+                }
+            }
+        }
+        return {
+            primaryDataMin,
+            primaryDataMax,
+            secondaryDataMin,
+            secondaryDataMax,
+            scaleDomainMultipleForMax,
+            scaleDomainMultipleForNeg,
+        };
+    }
+    function calcYScaleDomainValues(data, isStacked, forSecondary) {
+        if (data.type === 'flow-processed') {
+            if (forSecondary) {
+                //Flow charts don't support secondary data
+                return [{ min: 0, max: 0 }];
+            }
+            return [
+                {
+                    min: 0,
+                    max: Math.max(...data.x.map(x => x.totalCount)),
+                },
+            ];
+        }
+        const possiblyStackedYs = data.ys.map((y, yIndex) => {
+            //Handle stacking
+            return isStacked
+                ? y.values.map((val, xIndex) => {
+                    let prevRunningTotal = 0;
+                    for (let yI = 0; yI < yIndex; yI++) {
+                        if (checkIfSecondary(data, yI, xIndex, false) !== forSecondary) {
+                            continue;
+                        }
+                        const addVal = data.ys[yI].values[xIndex];
+                        //Only stack values of the same sign
+                        if (addVal < 0 === val < 0) {
+                            prevRunningTotal += addVal;
+                        }
+                    }
+                    return val + prevRunningTotal;
+                })
+                : y.values;
+        });
+        const suppYs = hasSupplementaryData(data) ? data.supplementaryYs : null;
+        let possiblyStackedSupYs = [];
+        if (suppYs) {
+            possiblyStackedSupYs = suppYs.map((y, yIndex) => {
+                //Handle stacking
+                return isStacked
+                    ? y.values.map((val, xIndex) => {
+                        let prevRunningTotal = 0;
+                        for (let yI = 0; yI < yIndex; yI++) {
+                            if (checkIfSecondary(data, yI, xIndex, true) !== forSecondary ||
+                                suppYs[yI].supplementalIndex !== y.supplementalIndex) {
+                                continue;
+                            }
+                            const addVal = suppYs[yI].values[xIndex];
+                            //Only stack values of the same sign
+                            if (addVal < 0 === val < 0) {
+                                prevRunningTotal += addVal;
+                            }
+                        }
+                        return val + prevRunningTotal;
+                    })
+                    : y.values;
+            });
+        }
+        const scaleRange = [];
+        for (let i = 0; i < data.x.length; i++) {
+            const maxNormY = Math.max(...possiblyStackedYs.map((y, yIndex) => {
+                if (checkIfSecondary(data, yIndex, i, false) !== forSecondary) {
+                    return 0;
+                }
+                return y[i];
+            }));
+            const minNormY = Math.min(...possiblyStackedYs.map((y, yIndex) => {
+                if (checkIfSecondary(data, yIndex, i, false) !== forSecondary) {
+                    return 0;
+                }
+                return y[i];
+            }));
+            const maxSupY = suppYs
+                ? Math.max(...possiblyStackedSupYs.map((y, yIndex) => {
+                    if (checkIfSecondary(data, yIndex, i, true) !== forSecondary) {
+                        return 0;
+                    }
+                    return y[i];
+                }))
+                : 0;
+            const minSupY = suppYs
+                ? Math.min(...possiblyStackedSupYs.map((y, yIndex) => {
+                    if (checkIfSecondary(data, yIndex, i, true) !== forSecondary) {
+                        return 0;
+                    }
+                    return y[i];
+                }))
+                : 0;
+            const max = maxNormY > 0 && maxNormY > maxSupY
+                ? maxNormY
+                : maxSupY > 0
+                    ? maxSupY
+                    : 0;
+            const min = minNormY < 0 && minNormY < minSupY
+                ? minNormY
+                : minSupY < 0
+                    ? minSupY
+                    : 0;
+            scaleRange.push({ max, min });
+        }
+        return scaleRange;
+    }
+    function calculateBarPosition(data, config, chartSizingValues, bucketNum, clusterNum) {
+        const offset = chartSizingValues.chartDataDirection === 'vertical'
+            ? chartSizingValues.totalLeftOffset
+            : chartSizingValues.totalTopOffset;
+        const clusterOffset = clusterNum *
+            (chartSizingValues.barSize + chartSizingValues.barClusterGap);
+        const cumulativeBucketGap = getTotalPreBucketGap(data, config, chartSizingValues, bucketNum);
+        return offset + cumulativeBucketGap + clusterOffset;
+    }
+    function calculateHorizontalBarPath(leftSideRound, rightSideRound, xValue, yValue, horR, verR, height, width) {
+        if (leftSideRound && rightSideRound) {
+            //Both-sides rounding variation
+            const pathD = `
+        M ${xValue + horR},${yValue}
+        h ${width - horR * 2}
+        q${horR},0 ${horR},${verR}
+        v ${height - verR * 2}
+        q0,${verR} -${horR},${verR}
+        h ${-(width - horR * 2)}
+        q-${horR},0 -${horR},-${verR}
+        v -${height - verR * 2}
+        q0,-${verR} ${horR},-${verR}
+        Z
+      `;
+            return pathD;
+        }
+        if (leftSideRound) {
+            //Left-side rounding variation
+            const pathD = `
+        M ${xValue + horR},${yValue}
+        h ${width - horR}
+        v ${height}
+        h ${-(width - horR)}
+        q-${horR},0 -${horR},-${verR}
+        v -${height - verR * 2}
+        q0,-${verR} ${horR},-${verR}
+        Z
+      `;
+            return pathD;
+        }
+        if (rightSideRound) {
+            //Right-side rounding variation
+            const pathD = `
+        M ${xValue},${yValue}
+        h ${width - horR}
+        q${horR},0 ${horR},${verR}
+        v ${height - verR * 2}
+        q0,${verR} -${horR},${verR}
+        h ${-(width - horR)}
+        Z
+      `;
+            return pathD;
+        }
+        //No-rounding variation
+        const pathD = `
+      M ${xValue},${yValue}
+      h ${width}
+      v ${height}
+      h ${-width}
+      v -${height}
+      Z
+    `;
+        return pathD;
+    }
+    function getBucketAndClusterNumForHover(pos, chartSizingValues, data, config, bucketCount) {
+        let bucketLeeway = chartSizingValues.bucketGap / 4;
+        //if there's only 1 data point, use the outerGap as leeway instead
+        if (data.x.length === 1) {
+            bucketLeeway = chartSizingValues.outerGap / 4;
+        }
+        const barLeeway = chartSizingValues.barClusterGap / 2;
+        const offset = chartSizingValues.chartDataDirection === 'vertical'
+            ? chartSizingValues.totalLeftOffset
+            : chartSizingValues.totalTopOffset;
+        const relativePos = pos - offset;
+        let bucketNum = -1;
+        for (let i = 0; i < bucketCount; i++) {
+            const bucketStartPos = getTotalPreBucketGap(data, config, chartSizingValues, i);
+            if (bucketStartPos - bucketLeeway < relativePos &&
+                bucketStartPos +
+                    getBucketSize(data, config, chartSizingValues) +
+                    bucketLeeway >
+                    relativePos) {
+                bucketNum = i;
+                break;
+            }
+        }
+        if (bucketNum === -1) {
+            return null;
+        }
+        if (!isClusteredData(data, config, true)) {
+            return {
+                bucketNum,
+                clusterNum: 0,
+                clusterNormCount: 1,
+                clusterNumType: 'norm',
+            };
+        }
+        const relativeBucketPos = relativePos -
+            getTotalPreBucketGap(data, config, chartSizingValues, bucketNum);
+        const clusterCount = getClusterInfoForBucket(data, config);
+        let clusterNum = -1;
+        for (let i = 0; i < clusterCount.total; i++) {
+            const barStartPos = (chartSizingValues.barSize + chartSizingValues.barClusterGap) * i;
+            if (barStartPos - barLeeway < relativeBucketPos &&
+                barStartPos + chartSizingValues.barSize + barLeeway > relativeBucketPos) {
+                clusterNum = i;
+                break;
+            }
+        }
+        if (clusterNum === -1) {
+            return null;
+        }
+        let clusterNumType = 'norm';
+        if (clusterNum >= clusterCount.normCount) {
+            clusterNumType = 'supp';
+        }
+        return {
+            bucketNum,
+            clusterNum,
+            clusterNormCount: clusterCount.normCount,
+            clusterNumType,
+        };
+    }
+    function findNearestIndexWithSecondary(yInfo, yPos, scale) {
+        let foundIndex = 0;
+        let currMinDistance = Math.abs(scale(yInfo[0].value, yInfo[0].isSecondary) - yPos);
+        for (let i = 1; i < yInfo.length; i++) {
+            const newDistance = Math.abs(scale(yInfo[i].value, yInfo[i].isSecondary) - yPos);
+            if (newDistance < currMinDistance) {
+                foundIndex = i;
+                currMinDistance = newDistance;
+            }
+        }
+        return foundIndex;
+    }
+    function getBarYInfo(data, config, yIndex, xIndex, scale, isSupplementary = false) {
+        const isStacked = isStackedData(config);
+        const minimumSize = getMinimumDataElementSize(config);
+        const zeroVal = scale(0, true);
+        const yData = getMainOrSuppY(data, yIndex, isSupplementary);
+        const scaleValue = scale(yData.values[xIndex], checkIfSecondary(data, yIndex, xIndex, isSupplementary));
+        if (scaleValue > zeroVal) {
+            let prevBarHeights = 0;
+            if (isStacked) {
+                for (let i = 0; i < yIndex; i++) {
+                    const checkData = getMainOrSuppY(data, i, isSupplementary);
+                    //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it
+                    if (isSupplementary &&
+                        'supplementalIndex' in yData &&
+                        'supplementalIndex' in checkData) {
+                        if (yData.supplementalIndex !== checkData.supplementalIndex) {
+                            continue;
+                        }
+                    }
+                    const checkValue = scale(checkData.values[xIndex], checkIfSecondary(data, i, xIndex, isSupplementary));
+                    //Skip positive values
+                    if (checkValue < zeroVal) {
+                        continue;
+                    }
+                    prevBarHeights += applyMinimumDataElementSize(checkValue - zeroVal, checkData.values[xIndex], minimumSize);
+                }
+            }
+            const yValue = zeroVal + prevBarHeights;
+            const height = applyMinimumDataElementSize(scaleValue - zeroVal, yData.values[xIndex], minimumSize);
+            return { yValue, height };
+        }
+        let prevBarHeights = 0;
+        if (isStacked) {
+            for (let i = 0; i < yIndex; i++) {
+                const checkData = getMainOrSuppY(data, i, isSupplementary);
+                //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it
+                if (isSupplementary &&
+                    'supplementalIndex' in yData &&
+                    'supplementalIndex' in checkData) {
+                    if (yData.supplementalIndex !== checkData.supplementalIndex) {
+                        continue;
+                    }
+                }
+                const checkValue = scale(checkData.values[xIndex], checkIfSecondary(data, i, xIndex, isSupplementary));
+                //Skip negative values
+                if (checkValue > zeroVal) {
+                    continue;
+                }
+                prevBarHeights += applyMinimumDataElementSize(zeroVal - checkValue, checkData.values[xIndex], minimumSize);
+            }
+        }
+        const height = applyMinimumDataElementSize(zeroVal - scaleValue, yData.values[xIndex], minimumSize);
+        const yValue = zeroVal - height - prevBarHeights;
+        return { yValue, height };
+    }
+    function getSuppBarYInfoViaYIndex(data, config, yIndex, suppIndex, xIndex, scale) {
+        if (!hasSupplementaryData(data)) {
+            return { yValue: 0, height: 0 };
+        }
+        const suppYs = data.supplementaryYs;
+        // Find supplementary bars with the given supplementalIndex
+        const groupSupps = suppYs.filter(s => s.supplementalIndex === suppIndex);
+        // yIndex refers to which Y series (within the supplemental group) we're looking at
+        if (yIndex >= 0 && yIndex < groupSupps.length) {
+            // Find this supp in the original array
+            const suppInOriginalArray = suppYs.indexOf(groupSupps[yIndex]);
+            return getBarYInfo(data, config, suppInOriginalArray, xIndex, scale, true);
+        }
+        return { yValue: 0, height: 0 };
+    }
+    function getMainOrSuppY(data, yIndex, isSupplementary) {
+        if (hasSupplementaryData(data) && isSupplementary) {
+            return data.supplementaryYs[yIndex];
+        }
+        return data.ys[yIndex];
+    }
+    function getBarXInfo(data, config, yIndex, xIndex, scale, isSupplementary = false) {
+        const isStacked = isStackedData(config);
+        const minimumSize = getMinimumDataElementSize(config);
+        const zeroVal = scale(0, true);
+        const yData = getMainOrSuppY(data, yIndex, isSupplementary);
+        const scaleValue = scale(yData.values[xIndex], checkIfSecondary(data, yIndex, xIndex, isSupplementary));
+        if (scaleValue < zeroVal) {
+            let prevBarWidths = 0;
+            if (isStacked) {
+                for (let i = 0; i < yIndex; i++) {
+                    const checkData = getMainOrSuppY(data, i, isSupplementary);
+                    //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it
+                    if (isSupplementary &&
+                        'supplementalIndex' in yData &&
+                        'supplementalIndex' in checkData) {
+                        if (yData.supplementalIndex !== checkData.supplementalIndex) {
+                            continue;
+                        }
+                    }
+                    const checkVal = scale(checkData.values[xIndex], checkIfSecondary(data, i, xIndex, isSupplementary));
+                    //Skip positive values
+                    if (checkVal > zeroVal) {
+                        continue;
+                    }
+                    prevBarWidths += applyMinimumDataElementSize(zeroVal - checkVal, checkData.values[xIndex], minimumSize);
+                }
+            }
+            const width = applyMinimumDataElementSize(zeroVal - scaleValue, yData.values[xIndex], minimumSize);
+            const xValue = zeroVal - width - prevBarWidths;
+            return { xValue, width };
+        }
+        let prevBarWidths = 0;
+        if (isStacked) {
+            for (let i = 0; i < yIndex; i++) {
+                const checkData = getMainOrSuppY(data, i, isSupplementary);
+                //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it
+                if (isSupplementary &&
+                    'supplementalIndex' in yData &&
+                    'supplementalIndex' in checkData) {
+                    if (yData.supplementalIndex !== checkData.supplementalIndex) {
+                        continue;
+                    }
+                }
+                const checkVal = scale(checkData.values[xIndex], checkIfSecondary(data, i, xIndex, isSupplementary));
+                //Skip negative values
+                if (checkVal < zeroVal) {
+                    continue;
+                }
+                prevBarWidths += applyMinimumDataElementSize(checkVal - zeroVal, checkData.values[xIndex], minimumSize);
+            }
+        }
+        const xValue = prevBarWidths + zeroVal;
+        const width = applyMinimumDataElementSize(scaleValue - zeroVal, yData.values[xIndex], minimumSize);
+        return { xValue, width };
+    }
+    function checkIfSecondary(data, yIndex, xIndex, isSupplementary = false) {
+        if (data.type === 'labeled') {
+            if (data.x[xIndex].isSecondary === true) {
+                return true;
+            }
+        }
+        return getMainOrSuppY(data, yIndex, isSupplementary).isSecondary === true;
+    }
+    function warnUnsupportedPatterns(data, supportedPatterns, chartType) {
+        const allYs = [
+            ...data.ys,
+            ...(hasSupplementaryData(data) ? data.supplementaryYs : []),
+        ];
+        for (const y of allYs) {
+            if (y.pattern &&
+                y.pattern !== 'solid' &&
+                !supportedPatterns.includes(y.pattern)) {
+                // eslint-disable-next-line no-console
+                console.warn(`Heads up! The '${y.pattern}' pattern isn't supported for ${chartType} charts. Falling back to solid.`);
+            }
+        }
+    }
+    function warnFlowData(data, chartType) {
+        if (data.type === 'flow') {
+            // eslint-disable-next-line no-console
+            console.warn(`Heads up! The 'flow' data type isn't supported for ${chartType} charts.`);
+            return false;
+        }
+        return true;
+    }
+    // hide strips out hidden y values while retaining the original indices
+    // for the remaining visible values
+    function hide(data) {
+        const visibleIndices = data.ys
+            .map((y, i) => ({ y, i }))
+            .filter(({ y }) => !y.hidden)
+            .map(({ i }) => i);
+        const visibleSuppIndices = hasSupplementaryData(data)
+            ? data.supplementaryYs
+                .map((y, i) => ({ y, i }))
+                .filter(({ y }) => !y.hidden)
+                .map(({ i }) => i)
+            : [];
+        return {
+            data: {
+                ...data,
+                ys: visibleIndices.map(i => data.ys[i]),
+                supplementaryYs: visibleSuppIndices.map(i => data.supplementaryYs[i]),
+            },
+            visibleIndices,
+            visibleSuppIndices,
+        };
+    }
+    function waterfallTransform(data, isWaterfall) {
+        const waterfallMap = new Map();
+        if (data.type === 'timeseries' || !isWaterfall) {
+            return {
+                data: {
+                    type: 'labeled',
+                    x: [],
+                    ys: [],
+                },
+                map: waterfallMap,
+            };
+        }
+        const newData = {
+            ...data,
+            x: [...data.x, { label: 'Total' }],
+            ys: [
+                ...data.ys.map(y => {
+                    const newY = {
+                        ...y,
+                        values: [...y.values, y.values.reduce((a, b) => a + b, 0)],
+                    };
+                    waterfallMap.set(newY, y);
+                    return newY;
+                }),
+            ],
+        };
+        return {
+            data: newData,
+            map: waterfallMap,
+        };
+    }
+    function flowsTransform(config, data) {
+        const returnBuckets = [];
+        const maxPathLength = Math.max(...data.ys.map(y => y.steps.length));
+        if (maxPathLength > 0 && maxPathLength < Infinity) {
+            for (let i = 0; i < maxPathLength; i++) {
+                const flowBucket = {
+                    totalCount: 0,
+                    subBuckets: [],
+                };
+                for (const y of data.ys) {
+                    if (y.values.length > i && y.steps.length > i) {
+                        const subBucketId = y.steps[i];
+                        const foundSubBucket = flowBucket.subBuckets.find(subBucket => subBucket.id === subBucketId);
+                        let subBucket;
+                        if (foundSubBucket !== undefined) {
+                            subBucket = foundSubBucket;
+                            subBucket.count += y.values[i];
+                        }
+                        else {
+                            subBucket = {
+                                id: subBucketId,
+                                count: y.values[i],
+                                connections: [],
+                            };
+                            flowBucket.subBuckets.push(subBucket);
+                        }
+                        flowBucket.totalCount += y.values[i];
+                        //Fill in backwards connections
+                        if (i > 0) {
+                            const foundConnection = subBucket.connections.find(connection => connection.start === y.steps[i - 1] &&
+                                connection.end === subBucketId &&
+                                connection.direction === 'backward');
+                            if (foundConnection !== undefined) {
+                                foundConnection.count += y.values[i];
+                            }
+                            else {
+                                const newConnection = {
+                                    direction: 'backward',
+                                    start: y.steps[i - 1],
+                                    end: subBucketId,
+                                    count: y.values[i],
+                                };
+                                subBucket.connections.push(newConnection);
+                            }
+                        }
+                        //Fill in forwards connections
+                        if (i < y.steps.length - 1 && i < y.values.length - 1) {
+                            const foundConnection = subBucket.connections.find(connection => connection.start === subBucketId &&
+                                connection.end === y.steps[i + 1] &&
+                                connection.direction === 'forward');
+                            if (foundConnection !== undefined) {
+                                foundConnection.count += y.values[i + 1];
+                            }
+                            else {
+                                const newConnection = {
+                                    direction: 'forward',
+                                    start: subBucketId,
+                                    end: y.steps[i + 1],
+                                    count: y.values[i + 1],
+                                };
+                                subBucket.connections.push(newConnection);
+                            }
+                        }
+                    }
+                }
+                returnBuckets.push(flowBucket);
+            }
+        }
+        const subBucketOrderingMap = new Map();
+        for (let i = 0; i < config.flowConfig.subBucketsConfig.length; i++) {
+            subBucketOrderingMap.set(config.flowConfig.subBucketsConfig[i].bucketId, i);
+        }
+        const mapGet = (id) => {
+            const foundResult = subBucketOrderingMap.get(id);
+            if (foundResult !== undefined) {
+                return foundResult;
+            }
+            //If something isn't defined in the config, put it at the end
+            return Infinity;
+        };
+        //Ensure the data is sorted the same the way the config is, and drop empty
+        //bars/connections so they're neither displayed nor factored into sizing
+        return {
+            type: 'flow-processed',
+            x: returnBuckets.map(bucket => ({
+                ...bucket,
+                subBuckets: bucket.subBuckets
+                    .filter(subBucket => subBucket.count !== 0)
+                    .sort((a, b) => mapGet(a.id) - mapGet(b.id))
+                    .map(subBucket => ({
+                    ...subBucket,
+                    connections: subBucket.connections
+                        .filter(connection => connection.count !== 0)
+                        .sort((a, b) => {
+                        const firstSort = mapGet(a.start) - mapGet(b.start);
+                        if (firstSort !== 0) {
+                            return firstSort;
+                        }
+                        return mapGet(a.end) - mapGet(b.end);
+                    }),
+                })),
+            })),
+        };
+    }
+    function getPipes(valueType) {
+        switch (valueType) {
+            case 'count': {
+                return { pipe: new SmallNumberPipe(), fullPipe: new NumberPipe() };
+            }
+            case 'currency':
+                return {
+                    pipe: new SmallCurrencyPipe(),
+                    fullPipe: new CurrencyPipe('en-us'),
+                };
+            case 'percentage': {
+                const pipe = new PercentagePipe();
+                return { pipe, fullPipe: pipe };
+            }
+            case 'days': {
+                const pipe = new DaysPipe();
+                return { pipe, fullPipe: pipe };
+            }
+        }
+    }
+    Chart.getPipes = getPipes;
+    const intervals = ['year', 'quarter', 'month', 'week', 'day'];
+    function formatedDate(dateFormat, date) {
+        if (dateFormat === 'quarter') {
+            const quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
+            const year = utcFormat(getTimeIntervalFormat('year'))(date);
+            return `Q${quarter} ${year}`;
+        }
+        const format = getTimeIntervalFormat(dateFormat);
+        return utcFormat(format)(date);
+    }
+    Chart.formatedDate = formatedDate;
+    function getTimeIntervalFormat(interval) {
+        switch (interval) {
+            case 'day':
+            case 'week':
+                return '%m/%d/%Y';
+            case 'month':
+            case 'quarter':
+                return '%b %Y';
+            case 'year':
+                return '%Y';
+        }
+    }
+    function convertChartDataToDonutData(chartData) {
+        if (chartData.ys.find(y => y.values.length > 1)) {
+            // eslint-disable-next-line no-console
+            console.warn("Heads up! Pie charts don't support multiple values per series");
+        }
+        const donutData = chartData.ys.map(y => ({
+            label: y.label,
+            hidden: y.hidden,
+            value: y.values.length >= 1 ? y.values[0] : 0,
+            isSecondary: y.isSecondary,
+        }));
+        return donutData;
+    }
+    Chart.convertChartDataToDonutData = convertChartDataToDonutData;
+    function arcToPoint(angle, radius) {
+        return {
+            x: radius * Math.cos(angle - Math.PI / 2),
+            y: radius * Math.sin(angle - Math.PI / 2),
+        };
+    }
+    function pointToArc(x, y) {
+        const radius = Math.hypot(x, y);
+        let angle = Math.atan2(y, x) + Math.PI / 2;
+        //Normalize to be within range [0, 2π]
+        angle = (angle + 2 * Math.PI) % (2 * Math.PI);
+        return {
+            angle,
+            radius,
+        };
+    }
+    function getFullChartScaleValues(config, data, dimensions, pipeTransform, dateFormat) {
+        const chartDataDirection = getChartDataDirection(config);
+        const defaultScalingConfig = getDefaultScalingConfigByChartType(config.type, config.secondaryValueType !== undefined);
+        const scalingConfig = combineScalingInfo(config, defaultScalingConfig);
+        const nonDataAxisValues = calculateNonDataAxisValues(config, scalingConfig, config.scalingConfig?.elementScales, defaultScalingConfig.elementScales, dimensions, data);
+        const dataAxisValues = calculateDataAxisValues(config, scalingConfig, config.scalingConfig?.elementScales, defaultScalingConfig.elementScales, dimensions, data, pipeTransform, dateFormat);
+        if (nonDataAxisValues.sizingError === true ||
+            dataAxisValues.sizingError === true) {
+            return null;
+        }
+        const dataLabelStartPadding = getDataLabelSizingCount(data, config).start *
+            (dataAxisValues.dataLabelPadding + dataAxisValues.dataLabelTextSize);
+        const dataLabelEndPadding = getDataLabelSizingCount(data, config).end *
+            (dataAxisValues.dataLabelPadding + dataAxisValues.dataLabelTextSize);
+        return {
+            ...nonDataAxisValues,
+            ...dataAxisValues,
+            leftPadding: chartDataDirection === 'horizontal'
+                ? dataAxisValues.startPadding
+                : nonDataAxisValues.startPadding,
+            rightPadding: chartDataDirection === 'horizontal'
+                ? dataAxisValues.endPadding
+                : nonDataAxisValues.endPadding,
+            topPadding: chartDataDirection === 'horizontal'
+                ? nonDataAxisValues.startPadding
+                : dataAxisValues.startPadding,
+            bottomPadding: chartDataDirection === 'horizontal'
+                ? nonDataAxisValues.endPadding
+                : dataAxisValues.endPadding,
+            totalLeftOffset: chartDataDirection === 'horizontal'
+                ? dataAxisValues.startPadding +
+                    dataAxisValues.leftBucketLabel +
+                    dataLabelStartPadding
+                : nonDataAxisValues.startPadding + nonDataAxisValues.outerGap,
+            totalRightOffset: chartDataDirection === 'horizontal'
+                ? dataAxisValues.startPadding + dataLabelEndPadding
+                : nonDataAxisValues.endPadding + nonDataAxisValues.outerGap,
+            totalTopOffset: chartDataDirection === 'horizontal'
+                ? nonDataAxisValues.startPadding + nonDataAxisValues.outerGap
+                : dataAxisValues.startPadding + dataLabelStartPadding,
+            totalBottomOffset: chartDataDirection === 'horizontal'
+                ? nonDataAxisValues.endPadding + nonDataAxisValues.outerGap
+                : dataAxisValues.endPadding + dataLabelEndPadding,
+            targetTickCount: scalingConfig.targetTickCount,
+            sizeForData: dataAxisValues.sizeForData,
+            totalWidth: chartDataDirection === 'horizontal'
+                ? dataAxisValues.totalSize
+                : nonDataAxisValues.totalSize,
+            totalHeight: chartDataDirection === 'horizontal'
+                ? nonDataAxisValues.totalSize
+                : dataAxisValues.totalSize,
+            dataLabelTextSize: config.showDataLabels
+                ? dataAxisValues.dataLabelTextSize
+                : 0,
+            horizontalAxisLabelTextSize: chartDataDirection === 'vertical'
+                ? dataAxisValues.bucketLabelTextSize
+                : dataAxisValues.dataLabelTextSize, //Ticks and data labels use the same formatting on the same kind of data
+            verticalAxisLabelTextSize: dataAxisValues.fontSize,
+            chartDataDirection,
+            horizontalContainerScale: scalingConfig.horizontalContainerScale,
+            verticalContainerScale: scalingConfig.verticalContainerScale,
+        };
+    }
+    function calculateNonDataAxisValues(config, scalingConfig, elementScales, defaultSizing, dimensions, data) {
+        const chartDataDirection = getChartDataDirection(config);
+        const boundingDimension = chartDataDirection === 'horizontal'
+            ? dimensions.height
+            : dimensions.width;
+        const axisScale = chartDataDirection === 'horizontal'
+            ? scalingConfig?.verticalAxisScale
+            : scalingConfig?.horizontalAxisScale;
+        const barSizeConfig = getElementScalingInfo(elementScales, defaultSizing, 'barSize');
+        const barClusterGapConfig = getElementScalingInfo(elementScales, defaultSizing, 'barClusterGap');
+        const bucketGapConfig = getElementScalingInfo(elementScales, defaultSizing, 'bucketGap');
+        const outerGapConfig = getElementScalingInfo(elementScales, defaultSizing, 'outerGap');
+        const startPaddingConfig = getElementScalingInfo(elementScales, defaultSizing, chartDataDirection === 'horizontal' ? 'topPadding' : 'leftPadding');
+        const endPaddingConfig = getElementScalingInfo(elementScales, defaultSizing, chartDataDirection === 'horizontal' ? 'bottomPadding' : 'rightPadding');
+        const bucketCount = data.x.length;
+        let barCount = 0;
+        let barClusterGapCount = 0;
+        for (let i = 0; i < bucketCount; i++) {
+            if (data.type === 'flow-processed') {
+                barCount += 1;
+            }
+            else {
+                const bucketClusterCount = getClusterInfoForBucket(data, config);
+                barCount += bucketClusterCount.total;
+                barClusterGapCount += bucketClusterCount.total - 1;
+            }
+        }
+        const bucketGapCount = bucketCount - 1;
+        const barTotalSize = determinePossibleSizesOfElement(barSizeConfig, barCount);
+        const clusterGapTotalSize = determinePossibleSizesOfElement(barClusterGapConfig, barClusterGapCount);
+        const bucketGapTotalSize = determinePossibleSizesOfElement(bucketGapConfig, bucketGapCount);
+        const outerGapTotalSize = determinePossibleSizesOfElement(outerGapConfig, 2);
+        const startPaddingTotalSize = determinePossibleSizesOfElement(startPaddingConfig, 1);
+        const endPaddingTotalSize = determinePossibleSizesOfElement(endPaddingConfig, 1);
+        const calcTargetSize = barTotalSize.target +
+            clusterGapTotalSize.target +
+            bucketGapTotalSize.target +
+            outerGapTotalSize.target +
+            startPaddingTotalSize.target +
+            endPaddingTotalSize.target;
+        if (axisScale === 'no-scale' ||
+            calcTargetSize === boundingDimension ||
+            (axisScale === 'grow' && calcTargetSize > boundingDimension) ||
+            (axisScale === 'shrink' && calcTargetSize < boundingDimension)) {
+            //No element scaling necessary, return everything as it's target value
+            return {
+                barSize: barSizeConfig.target,
+                barClusterGap: barClusterGapConfig.target,
+                bucketGap: bucketGapConfig.target,
+                outerGap: outerGapConfig.target,
+                startPadding: startPaddingConfig.target,
+                endPadding: endPaddingConfig.target,
+                totalSize: calcTargetSize,
+            };
+        }
+        const calcMinSize = barTotalSize.min +
+            clusterGapTotalSize.min +
+            bucketGapTotalSize.min +
+            outerGapTotalSize.min +
+            startPaddingTotalSize.min +
+            endPaddingTotalSize.min;
+        //Note: This is only actually a max size if all elements have a defined max
+        const calcMaxSize = barTotalSize.max +
+            clusterGapTotalSize.max +
+            bucketGapTotalSize.max +
+            outerGapTotalSize.max +
+            startPaddingTotalSize.max +
+            endPaddingTotalSize.max;
+        if (calcMinSize > boundingDimension) {
+            // eslint-disable-next-line no-console
+            console.warn('The provided minimum element sizes mean the chart cannot display at this small of a size');
+            return {
+                barSize: 0,
+                barClusterGap: 0,
+                bucketGap: 0,
+                outerGap: 0,
+                startPadding: 0,
+                endPadding: 0,
+                totalSize: 0,
+                sizingError: true,
+            };
+        }
+        const configChecks = [
+            getCheckingInfoForElementConfig(barSizeConfig, barCount),
+            getCheckingInfoForElementConfig(barClusterGapConfig, barClusterGapCount),
+            getCheckingInfoForElementConfig(bucketGapConfig, bucketGapCount),
+            getCheckingInfoForElementConfig(outerGapConfig, 2),
+            getCheckingInfoForElementConfig(startPaddingConfig, 1),
+            getCheckingInfoForElementConfig(endPaddingConfig, 1),
+        ];
+        let currScalingFactor = 1;
+        if (calcTargetSize > boundingDimension) {
+            //Scaling down
+            let finalScalingFactorFound = false;
+            while (!finalScalingFactorFound) {
+                const nextScaleFactorBreakpoint = Math.max(...configChecks
+                    .map(check => check.minScaleFactor)
+                    .filter((val) => val !== undefined && !(val >= currScalingFactor)), 0);
+                const newScaleFactorSize = getSumForScaleValue(configChecks, nextScaleFactorBreakpoint);
+                if (newScaleFactorSize <= boundingDimension) {
+                    //There's a scale value that'll work between the curr and new values
+                    //These are the values that'll just be at their min
+                    const nonScaleableValues = configChecks.filter(check => check.minScaleFactor && check.minScaleFactor >= currScalingFactor);
+                    //These are the values that can still be scaled down
+                    const scaleableValues = configChecks.filter(check => !check.minScaleFactor || check.minScaleFactor < currScalingFactor);
+                    const workingSpace = boundingDimension -
+                        getSumForScaleValue(nonScaleableValues, currScalingFactor);
+                    currScalingFactor =
+                        workingSpace / getSumForScaleValue(scaleableValues, 1);
+                    finalScalingFactorFound = true;
+                }
+                else {
+                    //One of the elements is hitting their minScaleFactor, so for simplicity we'll just go again
+                    currScalingFactor = nextScaleFactorBreakpoint;
+                    //Just in case, though previous checks should make this impossible
+                    if (currScalingFactor === 0) {
+                        // eslint-disable-next-line no-console
+                        console.warn('The given size cannot contain the fixed sizes given for the elements');
+                        return {
+                            barSize: 0,
+                            barClusterGap: 0,
+                            bucketGap: 0,
+                            outerGap: 0,
+                            startPadding: 0,
+                            endPadding: 0,
+                            totalSize: 0,
+                            sizingError: true,
+                        };
+                    }
+                }
+            }
+        }
+        else {
+            //Checking to see if all elements have a defined max
+            const maximumSizePossible = configChecks.filter(check => check.maxScaleFactor === undefined)
+                .length === 0;
+            //If all elements have a defined max, and that max is less than the size we're trying to grow to, it's impossible
+            if (maximumSizePossible && calcMaxSize < boundingDimension) {
+                // eslint-disable-next-line no-console
+                console.warn('The provided maximum element widths mean the chart cannot display at this large of a size');
+                return {
+                    barSize: 0,
+                    barClusterGap: 0,
+                    bucketGap: 0,
+                    outerGap: 0,
+                    startPadding: 0,
+                    endPadding: 0,
+                    totalSize: 0,
+                    sizingError: true,
+                };
+            }
+            //Scaling up
+            let finalScalingFactorFound = false;
+            while (!finalScalingFactorFound) {
+                const nextScaleFactorBreakpoint = Math.min(...configChecks
+                    .map(check => check.maxScaleFactor)
+                    .filter((val) => val !== undefined && !(val <= currScalingFactor)));
+                const newScaleFactorSize = getSumForScaleValue(configChecks, nextScaleFactorBreakpoint);
+                if (newScaleFactorSize >= boundingDimension ||
+                    nextScaleFactorBreakpoint === Infinity) {
+                    //There's a scale value that'll work between the curr and new values
+                    //These are the values that'll just be at their max
+                    const nonScaleableValues = configChecks.filter(check => check.maxScaleFactor && check.maxScaleFactor <= currScalingFactor);
+                    //These are the values that can still be scaled up
+                    const scaleableValues = configChecks.filter(check => !check.maxScaleFactor || check.maxScaleFactor > currScalingFactor);
+                    const workingSpace = boundingDimension -
+                        getSumForScaleValue(nonScaleableValues, currScalingFactor);
+                    currScalingFactor =
+                        workingSpace / getSumForScaleValue(scaleableValues, 1);
+                    finalScalingFactorFound = true;
+                }
+                else {
+                    //One of the elements is hitting their maxScaleFactor, so for simplicity we'll just go again
+                    currScalingFactor = nextScaleFactorBreakpoint;
+                }
+            }
+        }
+        const barSize = getScaledElementSize(barSizeConfig, currScalingFactor);
+        const barClusterGap = getScaledElementSize(barClusterGapConfig, currScalingFactor);
+        const bucketGap = getScaledElementSize(bucketGapConfig, currScalingFactor);
+        return {
+            barSize,
+            barClusterGap,
+            bucketGap,
+            outerGap: getScaledElementSize(outerGapConfig, currScalingFactor),
+            startPadding: getScaledElementSize(startPaddingConfig, currScalingFactor),
+            endPadding: getScaledElementSize(endPaddingConfig, currScalingFactor),
+            totalSize: boundingDimension,
+        };
+    }
+    function calculateDataAxisValues(config, scalingConfig, elementScales, defaultSizing, dimensions, data, pipeTransform, dateFormat) {
+        const chartDataDirection = getChartDataDirection(config);
+        const boundingDimension = chartDataDirection === 'horizontal'
+            ? dimensions.width
+            : dimensions.height;
+        const axisScale = chartDataDirection === 'horizontal'
+            ? scalingConfig.horizontalAxisScale
+            : scalingConfig.verticalAxisScale;
+        const startPaddingConfig = getElementScalingInfo(elementScales, defaultSizing, chartDataDirection === 'horizontal' ? 'leftPadding' : 'topPadding');
+        const endPaddingConfig = getElementScalingInfo(elementScales, defaultSizing, chartDataDirection === 'horizontal' ? 'rightPadding' : 'bottomPadding');
+        const leftLabelConfig = getElementScalingInfo(elementScales, defaultSizing, 'leftBucketLabel');
+        const dataLabelPaddingConfig = getElementScalingInfo(elementScales, defaultSizing, 'dataLabelPadding');
+        const fontSizeConfig = getElementScalingInfo(elementScales, defaultSizing, 'fontSize');
+        const fontSize = fontSizeConfig.target;
+        const dataLabelTextSizing = getDataLabelSize(data, pipeTransform, fontSize);
+        //We always calculate and return dataLabelTextSize, since it's also used for determing axis label size
+        const dataLabelTextSize = chartDataDirection === 'horizontal'
+            ? dataLabelTextSizing.horizontal
+            : dataLabelTextSizing.vertical;
+        const dataLabelFixedSize = dataLabelTextSize * getDataLabelSizingCount(data, config).total;
+        const bucketLabelTextSize = getBucketLabelSize(data, fontSize, dateFormat);
+        //Flow charts have a data label above each sub-bucket
+        const flowLabelSize = dataLabelTextSize + dataLabelPaddingConfig.target;
+        const startPaddingTotalSize = determinePossibleSizesOfElement(startPaddingConfig, 1);
+        const endPaddingTotalSize = determinePossibleSizesOfElement(endPaddingConfig, 1);
+        const dataLabelPaddingTotalSize = determinePossibleSizesOfElement(dataLabelPaddingConfig, getDataLabelSizingCount(data, config).total);
+        let leftBucketLabelActualSize = leftLabelConfig.target;
+        if (chartDataDirection === 'horizontal' && data.type === 'labeled') {
+            //For horizontal bars, the start padding will scale based on the bucket labels
+            const longestLabelLength = Math.max(...data.x.map(x => x.label.length)) *
+                (Chart.WIDTH_PER_LETTER * (fontSize / Chart.DEFAULT_FONT_SIZE));
+            const minLength = leftLabelConfig.min
+                ? Math.max(longestLabelLength, leftLabelConfig.min)
+                : longestLabelLength;
+            leftBucketLabelActualSize = leftLabelConfig.max
+                ? Math.min(minLength, leftLabelConfig.max)
+                : longestLabelLength;
+        }
+        let fixedSizeValue = leftBucketLabelActualSize +
+            dataLabelFixedSize +
+            startPaddingTotalSize.target +
+            endPaddingTotalSize.target +
+            dataLabelPaddingTotalSize.target;
+        if (fixedSizeValue > boundingDimension) {
+            //See if further truncating the label can help
+            if (leftLabelConfig.min &&
+                fixedSizeValue - boundingDimension <
+                    leftBucketLabelActualSize - leftLabelConfig.min) {
+                leftBucketLabelActualSize =
+                    leftBucketLabelActualSize - (fixedSizeValue - boundingDimension);
+                fixedSizeValue =
+                    leftBucketLabelActualSize +
+                        startPaddingTotalSize.target +
+                        endPaddingTotalSize.target +
+                        dataLabelPaddingTotalSize.target;
+            }
+            else if (axisScale !== 'grow' &&
+                (axisScale !== 'no-scale' || scalingConfig.dataScale.type === 'fit')) {
+                //Growing and non-fitting data axes can scroll instead
+                // eslint-disable-next-line no-console
+                console.warn('The provided element sizes mean the chart cannot display at this small of a size');
+                return {
+                    startPadding: 0,
+                    endPadding: 0,
+                    leftBucketLabel: 0,
+                    dataLabelTextSize: 0,
+                    dataLabelPadding: 0,
+                    fontSize: 0,
+                    sizeForData: 0,
+                    totalSize: 0,
+                    bucketLabelTextSize: 0,
+                    sizingError: true,
+                };
+            }
+        }
+        if (axisScale === 'scale-to-fit' ||
+            axisScale === 'grow' ||
+            axisScale === 'shrink' ||
+            scalingConfig.dataScale.type === 'fit') {
+            //A growing data axis scrolls rather than squeezing the data below its minimum size
+            const availableSize = axisScale === 'grow'
+                ? Math.max(boundingDimension - fixedSizeValue, getMinimumGrownDataSize(data, config, boundingDimension, flowLabelSize))
+                : boundingDimension - fixedSizeValue;
+            const sizeForData = getFittedDataSize(data, config, availableSize, flowLabelSize);
+            if (sizeForData === null) {
+                // eslint-disable-next-line no-console
+                console.warn('The provided minimum data element size means the chart cannot display at this small of a size');
+                return {
+                    startPadding: 0,
+                    endPadding: 0,
+                    leftBucketLabel: 0,
+                    dataLabelTextSize: 0,
+                    dataLabelPadding: 0,
+                    fontSize: 0,
+                    sizeForData: 0,
+                    totalSize: 0,
+                    bucketLabelTextSize: 0,
+                    sizingError: true,
+                };
+            }
+            return {
+                startPadding: startPaddingConfig.target,
+                endPadding: endPaddingConfig.target,
+                leftBucketLabel: leftBucketLabelActualSize,
+                dataLabelTextSize,
+                dataLabelPadding: dataLabelPaddingConfig.target,
+                fontSize: fontSizeConfig.target,
+                sizeForData,
+                totalSize: fixedSizeValue + availableSize,
+                bucketLabelTextSize,
+            };
+        }
+        const { primaryDataMin, primaryDataMax, scaleDomainMultipleForMax, scaleDomainMultipleForNeg, } = calcDataScalingValues(data, config);
+        const effectivePrimaryMaxForScaling = primaryDataMax * scaleDomainMultipleForMax;
+        const effectivePrimaryMinForScaling = primaryDataMin < 0 ? primaryDataMin * scaleDomainMultipleForNeg : 0;
+        if (scalingConfig.dataScale.type === 'max') {
+            const dataSize = scalingConfig.dataScale.value *
+                ((effectivePrimaryMaxForScaling - effectivePrimaryMinForScaling) /
+                    effectivePrimaryMaxForScaling);
+            return {
+                startPadding: startPaddingConfig.target,
+                endPadding: endPaddingConfig.target,
+                leftBucketLabel: leftBucketLabelActualSize,
+                dataLabelTextSize,
+                dataLabelPadding: dataLabelPaddingConfig.target,
+                fontSize: fontSizeConfig.target,
+                sizeForData: dataSize,
+                totalSize: getScaledDataTotalSize(data, config, dataSize, flowLabelSize) +
+                    fixedSizeValue,
+                bucketLabelTextSize,
+            };
+        }
+        const dataSize = ((effectivePrimaryMaxForScaling - effectivePrimaryMinForScaling) /
+            scalingConfig.dataScale.ratio.value) *
+            scalingConfig.dataScale.ratio.px;
+        return {
+            startPadding: startPaddingConfig.target,
+            endPadding: endPaddingConfig.target,
+            leftBucketLabel: leftBucketLabelActualSize,
+            dataLabelTextSize,
+            dataLabelPadding: dataLabelPaddingConfig.target,
+            fontSize: fontSizeConfig.target,
+            sizeForData: dataSize,
+            totalSize: getScaledDataTotalSize(data, config, dataSize, flowLabelSize) +
+                fixedSizeValue,
+            bucketLabelTextSize,
+        };
+    }
+    //The least space a growing data axis gives the data: a portion of the provided size, on top of the space that
+    // elements enlarged to the minimum size need (so the data stays proportional rather than all being the minimum)
+    function getMinimumGrownDataSize(data, config, boundingDimension, labelSize) {
+        const minimumElementsSize = data.type === 'flow-processed'
+            ? getMaxFlowBucketSize(data, 0, getMinimumDataElementSize(config), labelSize) - getFlowMidLabelSize(data, labelSize)
+            : 0;
+        return boundingDimension * GROWN_DATA_MINIMUM_RATIO + minimumElementsSize;
+    }
+    //For flow charts, finds the size the data scale should map to so that every bucket (including its own data labels,
+    // and any elements enlarged to the minimum size) fits in the available size
+    //Returns null if the minimum sizes alone can't fit
+    function getFittedDataSize(data, config, availableSize, labelSize) {
+        if (data.type !== 'flow-processed') {
+            return availableSize;
+        }
+        const dataMax = Math.max(...data.x.map(x => x.totalCount));
+        if (dataMax <= 0) {
+            return availableSize;
+        }
+        const minimumSize = getMinimumDataElementSize(config);
+        const bucketAvailableSize = availableSize + getFlowMidLabelSize(data, labelSize);
+        //Calculate what the sizing would need to be for each individual column,
+        //  taking the value that is most restrictive. Not applying minimum size yet
+        const unenlargedRatio = Math.min(...data.x
+            .filter(bucket => bucket.totalCount > 0)
+            .map(bucket => (bucketAvailableSize - (bucket.subBuckets.length - 1) * labelSize) /
+            bucket.totalCount));
+        if (minimumSize === 0 ||
+            getMaxFlowBucketSize(data, unenlargedRatio, minimumSize, labelSize) <=
+                bucketAvailableSize) {
+            return unenlargedRatio * dataMax;
+        }
+        if (getMaxFlowBucketSize(data, 0, minimumSize, labelSize) >
+            bucketAvailableSize) {
+            return null;
+        }
+        //Now, we apply minimum size to the bars to calculate our true ratio (found through binary search)
+        let low = 0;
+        let high = unenlargedRatio;
+        for (let i = 0; i < 50; i++) {
+            const mid = (low + high) / 2;
+            if (getMaxFlowBucketSize(data, mid, minimumSize, labelSize) >
+                bucketAvailableSize) {
+                high = mid;
+            }
+            else {
+                low = mid;
+            }
+        }
+        return low * dataMax;
+    }
+    //The size needed along the data axis beyond the fixed size
+    //For flow charts, this is based on the tallest bucket (including its own data labels and any enlarged elements),
+    // rather than assuming the bucket with the most data also has the most sub-buckets
+    function getScaledDataTotalSize(data, config, dataSize, labelSize) {
+        if (data.type !== 'flow-processed') {
+            return dataSize;
+        }
+        const dataMax = Math.max(...data.x.map(x => x.totalCount));
+        if (dataMax <= 0) {
+            return dataSize;
+        }
+        return (getMaxFlowBucketSize(data, dataSize / dataMax, getMinimumDataElementSize(config), labelSize) - getFlowMidLabelSize(data, labelSize));
+    }
+    function getDataLabelSize(data, pipeTransform, fontSize) {
+        let normHorizontalMaxLength = 0;
+        let normSuppMaxLength = 0;
+        if (data.type !== 'flow-processed' && pipeTransform !== null) {
+            normHorizontalMaxLength = Math.max(...data.ys.map((y, yIndex) => Math.max(...y.values.map((val, xIndex) => checkLabelLength(pipeTransform(val, checkIfSecondary(data, yIndex, xIndex, false)), fontSize)))));
+            normSuppMaxLength = Math.max(...(data.supplementaryYs ?? []).map((y, yIndex) => Math.max(...y.values.map((val, xIndex) => checkLabelLength(pipeTransform(val, checkIfSecondary(data, yIndex, xIndex, true)), fontSize)))));
+        }
+        if (data.type === 'flow-processed') {
+            return {
+                horizontal: Math.max(normHorizontalMaxLength, normSuppMaxLength),
+                vertical: fontSize * 2,
+            };
+        }
+        return {
+            horizontal: Math.max(normHorizontalMaxLength, normSuppMaxLength),
+            vertical: fontSize,
+        };
+    }
+    function getBucketLabelSize(data, fontSize, dateFormat) {
+        if (dateFormat !== null) {
+            if (data.type === 'labeled') {
+                return Math.max(...data.x.map(x => checkLabelLength(x.label, fontSize)));
+            }
+            else if (data.type === 'timeseries') {
+                return Math.max(...data.x.map(x => checkLabelLength(dateFormat(new Date(x)), fontSize)));
+            }
+        }
+        return 0;
+    }
+    function checkLabelLength(value, fontSize) {
+        const periodCount = (value.match(/\./g) || []).length;
+        const slashCount = (value.match(/\//g) || []).length;
+        const fontScaleFactor = fontSize / Chart.DEFAULT_FONT_SIZE;
+        return ((value.length - (periodCount + slashCount)) *
+            (WIDTH_PER_NUMBER * fontScaleFactor) +
+            periodCount * (WIDTH_PER_PERIOD * fontScaleFactor) +
+            slashCount * (WIDTH_PER_SLASH * fontScaleFactor));
+    }
+    function isBarType(type) {
+        if (type === 'bar' ||
+            type === 'horizontal-bar' ||
+            type === 'waterfall' ||
+            type === 'funnel') {
+            return true;
+        }
+        return false;
+    }
+    Chart.isBarType = isBarType;
+    //Only bar-type and flow charts have discrete data elements that the minimum size applies to
+    function getMinimumDataElementSize(config) {
+        if (config.type === 'donut' ||
+            config.type === 'line' ||
+            config.type === 'area') {
+            return 0;
+        }
+        return config.scalingConfig?.dataScale?.minimumDataElementSize ?? 0;
+    }
+    //Any data element with a non-zero value is kept at or above the minimum size
+    function applyMinimumDataElementSize(size, value, minimumSize) {
+        return value !== 0 ? Math.max(size, minimumSize) : size;
+    }
+    function getFlowSubBucketSizes(subBucket, valueToSize, minimumSize) {
+        const connectionSizes = subBucket.connections.map(connection => applyMinimumDataElementSize(valueToSize(connection.count), connection.count, minimumSize));
+        const sumSizes = (direction) => sum(connectionSizes.filter((_, i) => subBucket.connections[i].direction === direction));
+        const continuingSize = sumSizes('forward');
+        const backwardSize = sumSizes('backward');
+        const nonContinuingCount = subBucket.count -
+            sum(subBucket.connections
+                .filter(connection => connection.direction === 'forward')
+                .map(connection => connection.count));
+        //The sub-bucket must be big enough to hold all of its (possibly enlarged) connections on either side
+        const totalSize = Math.max(applyMinimumDataElementSize(valueToSize(subBucket.count), subBucket.count, minimumSize), continuingSize +
+            applyMinimumDataElementSize(valueToSize(nonContinuingCount), nonContinuingCount, minimumSize), backwardSize);
+        //Every unit in a sub-bucket arrives through its backward connections, so they're stretched to fill the
+        // sub-bucket when it has been enlarged beyond them
+        return {
+            totalSize,
+            continuingSize,
+            connectionSizes: connectionSizes.map((size, i) => subBucket.connections[i].direction === 'backward' && backwardSize > 0
+                ? (size * totalSize) / backwardSize
+                : size),
+        };
+    }
+    //The size of the tallest flow bucket for the given scaling ratio, including the data labels between its sub-buckets
+    //  The label above the first sub-bucket is excluded, since it's part of the top offset
+    function getMaxFlowBucketSize(data, pxPerValue, minimumSize, labelSize) {
+        return Math.max(...data.x.map(bucket => sum(bucket.subBuckets.map(subBucket => getFlowSubBucketSizes(subBucket, value => value * pxPerValue, minimumSize).totalSize)) +
+            (bucket.subBuckets.length - 1) * labelSize));
+    }
+    //The fixed size reserves room for the labels between sub-buckets as if every bucket had as many sub-buckets as the
+    // bucket with the most, so this is the portion of the fixed size that each bucket can instead use based on its own labels
+    function getFlowMidLabelSize(data, labelSize) {
+        return ((Math.max(...data.x.map(bucket => bucket.subBuckets.length)) - 1) *
+            labelSize);
+    }
+    function isStackedData(config) {
+        if (config.type === 'bar' || config.type === 'horizontal-bar') {
+            if (config.groupingType === 'stacked') {
+                return true;
+            }
+        }
+        if (config.type === 'area' || config.type === 'waterfall') {
+            return true;
+        }
+        return false;
+    }
+    function isClusteredData(data, config, includeSupplementary) {
+        //It varies whether we want to include supplementary data in this check
+        if (hasSupplementaryData(data) && includeSupplementary) {
+            return true;
+        }
+        if ((config.type === 'bar' || config.type === 'horizontal-bar') &&
+            config.groupingType === 'clustered') {
+            return true;
+        }
+        if (config.type === 'funnel') {
+            return true;
+        }
+        return false;
+    }
+    //In some cases, the distinction between clustered and stacked doesn't matter
+    function isGroupingTypeException(data, config) {
+        if (data.ys.length === 1) {
+            return true;
+        }
+        //Checking for a 'metric' charts, which is a special case for horizontal bar charts,
+        // where each series is also a bucket (and vice versa)
+        if (config.type === 'horizontal-bar') {
+            if (data.x.length === data.ys.length &&
+                data.ys.length ===
+                    data.ys.filter(y => y.values.filter(val => val !== 0).length === 1)
+                        .length) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function hasSupplementaryData(data) {
+        if (data.type === 'flow') {
+            return false;
+        }
+        if (data.supplementaryYs && data.supplementaryYs.length > 0) {
+            return true;
+        }
+        return false;
+    }
+    function getElementScalingInfo(elementScales, defaultScalingConfig, element) {
+        const defaultElementConfig = defaultScalingConfig[element];
+        let inputConfig;
+        if (elementScales) {
+            const possibleConfig = elementScales[element];
+            if (possibleConfig) {
+                inputConfig = possibleConfig;
+            }
+            else {
+                inputConfig = null;
+            }
+        }
+        else {
+            inputConfig = null;
+        }
+        if (inputConfig !== null) {
+            const returnConfig = inputConfig;
+            return returnConfig;
+        }
+        if (defaultElementConfig.target !== undefined) {
+            const returnConfig = defaultElementConfig;
+            return returnConfig;
+        }
+        return {
+            target: 0,
+        };
+    }
+    function determinePossibleSizesOfElement(elementConfig, elementCount) {
+        const indMin = elementConfig.min !== undefined ? elementConfig.min : 0;
+        const indMax = elementConfig.max !== undefined ? elementConfig.max : 0;
+        const indTarget = elementConfig.target;
+        return {
+            min: indMin * elementCount,
+            max: indMax * elementCount,
+            target: indTarget * elementCount,
+        };
+    }
+    function determineTotalScaledSizeOfElement(elementConfig, elementCount, scaleValue) {
+        const scaledVal = getScaledElementSize(elementConfig, scaleValue);
+        return scaledVal * elementCount;
+    }
+    function getScaledElementSize(elementConfig, scaleValue) {
+        const scaledTarget = elementConfig.target * scaleValue;
+        if (scaleValue < 1) {
+            if (elementConfig.min && elementConfig.min > scaledTarget) {
+                return elementConfig.min;
+            }
+            return scaledTarget;
+        }
+        if (scaleValue > 1) {
+            if (elementConfig.max && elementConfig.max < scaledTarget) {
+                return elementConfig.max;
+            }
+            return scaledTarget;
+        }
+        return scaledTarget;
+    }
+    function getCheckingInfoForElementConfig(config, elementCount) {
+        let minScaleFactor = undefined;
+        if (config.min) {
+            minScaleFactor =
+                config.target !== 0 ? config.min / config.target : undefined;
+        }
+        let maxScaleFactor = undefined;
+        if (config.max) {
+            maxScaleFactor =
+                config.target !== 0 ? config.max / config.target : undefined;
+        }
+        return {
+            config,
+            minScaleFactor,
+            maxScaleFactor,
+            elementCount,
+        };
+    }
+    function getSumForScaleValue(checkInfos, scaleValue) {
+        let sum = 0;
+        for (const check of checkInfos) {
+            sum += determineTotalScaledSizeOfElement(check.config, check.elementCount, scaleValue);
+        }
+        return sum;
+    }
+    function getDataLabelSizingCount(data, config) {
+        if (config.showDataLabels !== true) {
+            return {
+                start: 0,
+                end: 0,
+                total: 0,
+            };
+        }
+        //Data labels are always shown above the data for all but these 3 types
+        if (config.type !== 'bar' &&
+            config.type !== 'horizontal-bar' &&
+            config.type !== 'waterfall' &&
+            config.type !== 'flow') {
+            return {
+                start: 1,
+                end: 0,
+                total: 1,
+            };
+        }
+        let startCount = 0;
+        let midCount = 0;
+        let endCount = 0;
+        if (data.type !== 'flow-processed') {
+            if (data.ys.find(y => y.values.find(val => val >= 0))) {
+                if (config.type === 'horizontal-bar') {
+                    endCount += 1;
+                }
+                else {
+                    startCount += 1;
+                }
+            }
+            if (data.ys.find(y => y.values.find(val => val < 0))) {
+                if (config.type === 'horizontal-bar') {
+                    startCount += 1;
+                }
+                else {
+                    endCount += 1;
+                }
+            }
+        }
+        else {
+            startCount = 1;
+            midCount = Math.max(...data.x.map(x => x.subBuckets.length)) - 1;
+        }
+        return {
+            start: startCount,
+            end: endCount,
+            total: startCount + midCount + endCount,
+        };
+    }
+    function getIfHoverOutOfBounds(
+    //Position not accounting for scrolling
+    relPosX, relPosY, 
+    //Position accounting for scrolling
+    realPosX, realPosY, chartSizingValues, dimensions) {
+        //Check if we're on top of one of the scrollbars
+        if (relPosX > dimensions.width || relPosY > dimensions.height) {
+            return true;
+        }
+        if (chartSizingValues === null) {
+            //If chartSizingValues aren't provided, no more checks
+            return false;
+        }
+        //Check if we're in one of the padding areas
+        if (realPosX < chartSizingValues.leftPadding ||
+            realPosX >
+                chartSizingValues.totalWidth - chartSizingValues.rightPadding ||
+            realPosY < chartSizingValues.topPadding ||
+            realPosY > chartSizingValues.totalHeight - chartSizingValues.bottomPadding) {
+            return true;
+        }
+        return false;
+    }
+    function getChartDataDirection(config) {
+        if (config.type === 'horizontal-bar') {
+            return 'horizontal';
+        }
+        return 'vertical';
+    }
+    function combineScalingInfo(config, defaultConfig) {
+        const providedScalingConfig = config.scalingConfig;
+        const chartDataDirection = getChartDataDirection(config);
+        //If the user provides a data scale, we don't want to override that unless they also provided a specific scale for the corresponding axis
+        const dataScale = providedScalingConfig && providedScalingConfig.dataScale
+            ? providedScalingConfig.dataScale
+            : defaultConfig.nonElementScales.dataScale;
+        let verticalAxisScale = providedScalingConfig?.verticalAxisScale;
+        if (verticalAxisScale === undefined) {
+            if (chartDataDirection === 'horizontal' || dataScale.type === 'fit') {
+                verticalAxisScale = defaultConfig.nonElementScales.verticalAxisScale;
+            }
+            else {
+                //The vertical axis is the data axis, the dataScale has a user-inputted value, and there isn't a user-inputted verticalAxisScale
+                // So, we'll prevent the axis scaling from interfering with the dataScale
+                verticalAxisScale = 'no-scale';
+            }
+        }
+        let horizontalAxisScale = providedScalingConfig?.horizontalAxisScale;
+        if (horizontalAxisScale === undefined) {
+            if (chartDataDirection === 'vertical' || dataScale.type === 'fit') {
+                horizontalAxisScale =
+                    defaultConfig.nonElementScales.horizontalAxisScale;
+            }
+            else {
+                //The horizontal axis is the data axis, the dataScale has a user-inputted value, and there isn't a user-inputted horizontalAxisScale
+                // So, we'll prevent the axis scaling from interfering with the dataScale
+                horizontalAxisScale = 'no-scale';
+            }
+        }
+        return {
+            dataScale: providedScalingConfig && providedScalingConfig.dataScale
+                ? providedScalingConfig.dataScale
+                : defaultConfig.nonElementScales.dataScale,
+            horizontalAxisScale,
+            verticalAxisScale,
+            horizontalContainerScale: providedScalingConfig && providedScalingConfig.horizontalContainerScale
+                ? providedScalingConfig.horizontalContainerScale
+                : defaultConfig.nonElementScales.horizontalContainerScale,
+            verticalContainerScale: providedScalingConfig && providedScalingConfig.verticalContainerScale
+                ? providedScalingConfig.verticalContainerScale
+                : defaultConfig.nonElementScales.verticalContainerScale,
+            targetTickCount: providedScalingConfig &&
+                providedScalingConfig.targetTickCount !== undefined
+                ? providedScalingConfig.targetTickCount
+                : defaultConfig.nonElementScales.targetTickCount,
+        };
+    }
+    function isDeEmphasized(config, id, isDarkened) {
+        const highlightedBuckets = config.flowConfig.subBucketsConfig
+            .filter(sbc => sbc.isHighlighted === true)
+            .map(sbc => sbc.bucketId);
+        if (highlightedBuckets.length === 0) {
+            return false;
+        }
+        if (isDarkened) {
+            return true;
+        }
+        if (highlightedBuckets.some(hb => hb === id)) {
+            return false;
+        }
+        return true;
+    }
+    function calculateFlowConnectionPath(connection) {
+        const dx = connection.topLine.x2 - connection.topLine.x1;
+        const curve = Math.abs(dx) * FLOW_CONNECTION_CURVE_CONSTANT;
+        const path = `
+      M ${connection.topLine.x1},${connection.topLine.y1}
+
+      C ${connection.topLine.x1 + curve},${connection.topLine.y1}
+        ${connection.topLine.x2 - curve},${connection.topLine.y2}
+        ${connection.topLine.x2},${connection.topLine.y2}
+
+      L ${connection.bottomLine.x2},${connection.bottomLine.y2}
+
+      C ${connection.bottomLine.x2 - curve},${connection.bottomLine.y2}
+        ${connection.bottomLine.x1 + curve},${connection.bottomLine.y1}
+        ${connection.bottomLine.x1},${connection.bottomLine.y1}
+
+      Z
+    `;
+        return path;
+    }
+    function cubic(a, b, c, d, t) {
+        const mt = 1 - t;
+        return mt ** 3 * a + 3 * mt ** 2 * t * b + 3 * mt * t ** 2 * c + t ** 3 * d;
+    }
+    function bezierYAtX(x, line) {
+        const curve = Math.abs(line.x2 - line.x1) * FLOW_CONNECTION_CURVE_CONSTANT;
+        const p0 = { x: line.x1, y: line.y1 };
+        const p1 = { x: line.x1 + curve, y: line.y1 };
+        const p2 = { x: line.x2 - curve, y: line.y2 };
+        const p3 = { x: line.x2, y: line.y2 };
+        let lo = 0;
+        let hi = 1;
+        // Binary search for t where bezierX(t) ~= x
+        for (let i = 0; i < 20; i++) {
+            const t = (lo + hi) / 2;
+            const bx = cubic(p0.x, p1.x, p2.x, p3.x, t);
+            if (bx < x)
+                lo = t;
+            else
+                hi = t;
+        }
+        const t = (lo + hi) / 2;
+        return cubic(p0.y, p1.y, p2.y, p3.y, t);
+    }
+    function checkIfPointWithinConnection(connection, pointX, pointY) {
+        const topY = bezierYAtX(pointX, connection.topLine);
+        const bottomY = bezierYAtX(pointX, connection.bottomLine);
+        return (pointX >= connection.topLine.x1 &&
+            pointX <= connection.topLine.x2 &&
+            pointY >= Math.min(topY, bottomY) &&
+            pointY <= Math.max(topY, bottomY));
+    }
+    function getFlowBucketIndexForHover(chartSizingValues, xPos) {
+        let bucketIndex = 0;
+        const bucketLeftEdge = chartSizingValues.totalLeftOffset;
+        const totalBucketGap = chartSizingValues.barSize + chartSizingValues.bucketGap;
+        if (bucketLeftEdge > xPos) {
+            return null;
+        }
+        while (bucketLeftEdge + bucketIndex * totalBucketGap < xPos) {
+            if (bucketLeftEdge + (bucketIndex + 1) * totalBucketGap > xPos) {
+                if (bucketLeftEdge +
+                    bucketIndex * totalBucketGap +
+                    chartSizingValues.barSize >
+                    xPos) {
+                    return {
+                        index: bucketIndex,
+                        area: 'bar',
+                    };
+                }
+                else {
+                    return {
+                        index: bucketIndex,
+                        area: 'connection',
+                    };
+                }
+            }
+            bucketIndex += 1;
+        }
+        return null;
+    }
+    function checkAnchorsAgainstBound(anchorX, anchorY, dimensions, width, height) {
+        let retAnchorX = anchorX;
+        let retAnchorY = anchorY;
+        let retWidth = width;
+        let retHeight = height;
+        if (retAnchorX > dimensions.width) {
+            retAnchorX = dimensions.width;
+            if (retWidth !== undefined) {
+                retWidth = 0;
+            }
+        }
+        if (retAnchorX < 0) {
+            retAnchorX = 0;
+            if (retWidth !== undefined) {
+                retWidth = 0;
+            }
+        }
+        if (retAnchorY > dimensions.height) {
+            retAnchorY = dimensions.height;
+            if (retHeight !== undefined) {
+                retHeight = 0;
+            }
+        }
+        if (retAnchorY < 0) {
+            retAnchorY = 0;
+            if (retHeight !== undefined) {
+                retHeight = 0;
+            }
+        }
+        return {
+            anchorX: retAnchorX,
+            anchorY: retAnchorY,
+            anchorWidth: retWidth,
+            anchorHeight: retHeight,
+        };
+    }
+})(Chart || (Chart = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.js","sourceRoot":"","sources":["../../../../../../projects/riv/src/lib/visualization/chart/chart.ts"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe } from '@angular/common';\nimport { scaleLinear } from 'd3-scale';\nimport { arc, area, line, pie } from 'd3-shape';\nimport { utcFormat } from 'd3-time-format';\nimport { sum, uniq } from 'lodash';\nimport { DaysPipe } from '../../format/pipes/days.pipe';\nimport { NumberPipe } from '../../format/pipes/number.pipe';\nimport { PercentagePipe } from '../../format/pipes/percentage.pipe';\nimport { SmallCurrencyPipe } from '../../format/pipes/small-currency.pipe';\nimport { SmallNumberPipe } from '../../format/pipes/small-number.pipe';\nimport { CalloutComponent } from '../../overlay/callout/callout.component';\nimport {\n  ChartDataDirection,\n  ChartScaleElement,\n  ContainerScalingType,\n  DefaultDonutSizingConfig,\n  DefaultScalingConfig,\n  DonutSizingConfig,\n  ElementScalingConfiguration,\n  emptyChartScaleValues,\n  FullChartScaleValues,\n  FullElementScalingConfig,\n  FullScalingConfig,\n  getDefaultScalingConfigByChartType,\n  NonElementScalingConfig,\n  PartialElementScalingConfig,\n} from './chart-scaling';\n\nexport namespace Chart {\n  export const defaultColorPalette = [\n    //Base colors\n    '--baja-blast-50',\n    '--teal-diamond-50',\n    '--fyre-50',\n    '--tang-50',\n    '--purp-60',\n    '--rosi-70',\n    //Shift lighter from base by -20\n    '--baja-blast-30',\n    '--teal-diamond-30',\n    '--fyre-30',\n    '--tang-30',\n    '--purp-40',\n    '--rosi-50',\n    //Shift darker from base by +20\n    '--baja-blast-70',\n    '--teal-diamond-70',\n    '--fyre-70',\n    '--tang-70',\n    '--purp-80',\n    '--rosi-90',\n  ];\n\n  export function chart(\n    config: Config,\n    data: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    return config.type === 'line'\n      ? lines(config, data, dimensions)\n      : config.type === 'area'\n      ? areas(config, data, dimensions)\n      : config.type === 'donut'\n      ? arcs(config, data, dimensions)\n      : config.type === 'horizontal-bar'\n      ? horizontalBars(config, data, dimensions)\n      : config.type === 'bar'\n      ? bars(config, data, dimensions)\n      : config.type === 'waterfall'\n      ? waterfall(config, data, dimensions)\n      : config.type === 'funnel'\n      ? funnel(config, data, dimensions)\n      : config.type === 'flow'\n      ? flows(config, data, dimensions)\n      : emptyChart;\n  }\n\n  function lines(\n    config: ConfigWithFullScaling,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'line')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    const { data: hiddenData, visibleIndices } = hide(allData);\n    if (hiddenData.type === 'labeled') {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Labeled series aren't currently supported for line charts\",\n      );\n      return emptyChart;\n    }\n    if (hasSupplementaryData(hiddenData)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Supplementary y values aren't supported for non-bar charts\",\n      );\n      return emptyChart;\n    }\n    warnUnsupportedPatterns(hiddenData, ['striped', 'dots'], 'line');\n    //This assignment makes typescript recognize the actual type (TimeseriesData)\n    const data = hiddenData;\n\n    const { dateFormat, pipeTransform, colors } = getFormattingAndColors(\n      allData,\n      data,\n      config,\n    );\n\n    const chartSizingValues = getFullChartScaleValues(\n      config,\n      data,\n      dimensions,\n      pipeTransform,\n      dateFormat,\n    );\n    if (chartSizingValues === null) {\n      return { ...emptyChart, chartError: 'sizing' };\n    }\n\n    const tickCount = getBucketTickCount(chartSizingValues);\n    const xTicks = generateTimeseriesTicks(\n      data,\n      config,\n      tickCount,\n      chartSizingValues,\n      dateFormat,\n    ).map(tick => toXTick(tick));\n    const xScale = (index: number): number => {\n      return (\n        chartSizingValues.totalLeftOffset + chartSizingValues.bucketGap * index\n      );\n    };\n    const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(\n      data,\n      pipeTransform,\n      config,\n      chartSizingValues,\n    );\n    const yTicks = dataTicks.map(tick => toYTick(tick));\n\n    const indices = data.x.map((_, i) => i);\n    const lines =\n      data.x.length > 1\n        ? data.ys.map(y => ({\n            line: line<number>(\n              i => xScale(i),\n              i => scale(y.values[i], y.isSecondary),\n            )(indices),\n            pattern: y.pattern,\n          }))\n        : [];\n    const circles =\n      data.x.length === 1\n        ? data.ys.map((ySeries, i) => ({\n            cx: xScale(0),\n            cy: scale(ySeries.values[0], checkIfSecondary(data, i, 0)),\n          }))\n        : [];\n\n    const yOffset = chartSizingValues.dataLabelPadding;\n    const dataLabels: DataLabel[] = data.ys.flatMap((y, yIndex) => {\n      const subLabels: DataLabel[] = y.values.map((val, xIndex) => ({\n        elementType: 'dataLabel',\n        label: pipeTransform(val, checkIfSecondary(data, yIndex, xIndex)),\n        yPos: scale(val, checkIfSecondary(data, yIndex, xIndex)) - yOffset,\n        xPos: xScale(xIndex),\n        anchor: 'middle',\n      }));\n      return subLabels;\n    });\n\n    function hover(pos: {\n      rect: DOMRect;\n      x: number;\n      y: number;\n      containerScrollX: number;\n      containerScrollY: number;\n    }): HoverReturn {\n      const realPosX = pos.x + pos.containerScrollX;\n      const realPosY = pos.y + pos.containerScrollY;\n      if (\n        chartSizingValues === null ||\n        getIfHoverOutOfBounds(\n          pos.x,\n          pos.y,\n          realPosX,\n          realPosY,\n          chartSizingValues,\n          dimensions,\n        )\n      ) {\n        return null;\n      }\n\n      const xHoverIndices = getBucketAndClusterNumForHover(\n        realPosX,\n        chartSizingValues,\n        data,\n        config,\n        data.x.length,\n      );\n      if (!xHoverIndices) {\n        return null;\n      }\n      const { bucketNum: xIndex } = xHoverIndices;\n      const x = xScale(xIndex);\n      const visibleYIndex = findNearestIndexWithSecondary(\n        data.ys.map((y, i) => ({\n          value: y.values[xIndex],\n          isSecondary: checkIfSecondary(data, i, xIndex),\n        })),\n        pos.y,\n        scale,\n      );\n      const yIndex = visibleIndices[visibleYIndex];\n      const ys = data.ys.map((y, i) =>\n        scale(y.values[xIndex], checkIfSecondary(data, i, xIndex)),\n      );\n\n      const format = (date: Date) =>\n        formatedDate(config.dateFormat || 'day', date);\n\n      // Clamp in chart-local coordinates first so the tooltip stays within the\n      // visible chart area, then translate to viewport coordinates by adding\n      // pos.rect.x/y (which are viewport-relative from getBoundingClientRect).\n      const localAnchorX = x - pos.containerScrollX;\n      const localAnchorY = ys[visibleYIndex] - pos.containerScrollY;\n      const { anchorX, anchorY } = checkAnchorsAgainstBound(\n        localAnchorX,\n        localAnchorY,\n        dimensions,\n      );\n      const anchor = new DOMRect(\n        anchorX + pos.rect.x,\n        anchorY + pos.rect.y,\n        SMALL_PADDING,\n        0,\n      );\n      return {\n        hoverType: 'standard',\n        x,\n        xIndex,\n        ys,\n        yIndex,\n        visibleYIndex,\n        tooltip: {\n          anchor,\n          date: format(new Date(data.x[xIndex])),\n          metrics: data.ys\n            .map((y, index) => ({\n              color: colors[index % colors.length],\n              label: y.label,\n              pattern: y.pattern,\n              value:\n                pipeTransform(\n                  y.values[xIndex],\n                  checkIfSecondary(data, index, xIndex),\n                  true,\n                ) ?? '-',\n            }))\n            .filter((_, i) => config.groupedTooltip || i === visibleYIndex),\n        },\n      };\n    }\n\n    return {\n      chartWidth: chartSizingValues.totalWidth,\n      chartHeight: chartSizingValues.totalHeight,\n      chartSizingValues,\n      xTicks,\n      yTicks,\n      colors,\n      lines,\n      circles,\n      hover,\n      bars: [],\n      areas: [],\n      arcs: [],\n      horizontalBars: [],\n      dataLabels,\n      waterfallLines: [],\n      gradients: [],\n      flowConnections: [],\n      horizontalContainerScale: chartSizingValues.horizontalContainerScale,\n      verticalContainerScale: chartSizingValues.verticalContainerScale,\n      chartError: null,\n    };\n  }\n\n  function areas(\n    config: ConfigWithFullScaling,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'area')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    const { data: uncheckedData, visibleIndices } = hide(allData);\n    if (uncheckedData.type === 'labeled') {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Labeled series aren't currently supported for area charts\",\n      );\n      return emptyChart;\n    }\n    if (config.showDataLabels === true) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Data labels aren't supported for any stacked chart type\",\n      );\n      return emptyChart;\n    }\n    if (hasSupplementaryData(uncheckedData)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Supplementary y values aren't supported for non-bar charts\",\n      );\n      return emptyChart;\n    }\n    warnUnsupportedPatterns(uncheckedData, ['striped'], 'area');\n    //This assignment makes typescript recognize the actual type (TimeseriesData)\n    const data = uncheckedData;\n\n    const { dateFormat, pipeTransform, colors } = getFormattingAndColors(\n      allData,\n      data,\n      config,\n    );\n    const chartSizingValues = getFullChartScaleValues(\n      config,\n      data,\n      dimensions,\n      pipeTransform,\n      dateFormat,\n    );\n    if (chartSizingValues === null) {\n      return { ...emptyChart, chartError: 'sizing' };\n    }\n\n    const tickCount = getBucketTickCount(chartSizingValues);\n    const xTicks = generateTimeseriesTicks(\n      data,\n      config,\n      tickCount,\n      chartSizingValues,\n      dateFormat,\n    ).map(tick => toXTick(tick));\n    const xScale = (index: number): number => {\n      return (\n        chartSizingValues.totalLeftOffset + chartSizingValues.bucketGap * index\n      );\n    };\n    const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(\n      data,\n      pipeTransform,\n      config,\n      chartSizingValues,\n    );\n    const yTicks = dataTicks.map(tick => toYTick(tick));\n    const zeroAxisPosVal = scale(0, true);\n\n    const indices = data.x.map((_, i) => i);\n    const areas = data.ys.map((y, yIndex) => ({\n      pattern: y.pattern,\n      area: area<number>(\n        i => xScale(i),\n        i => getBarYInfo(data, config, yIndex, i, scale).yValue,\n        i =>\n          getBarYInfo(data, config, yIndex, i, scale).yValue +\n          getBarYInfo(data, config, yIndex, i, scale).height,\n      )(indices),\n    }));\n\n    function hover(pos: {\n      rect: DOMRect;\n      x: number;\n      y: number;\n      containerScrollX: number;\n      containerScrollY: number;\n    }): HoverReturn {\n      const realPosX = pos.x + pos.containerScrollX;\n      const realPosY = pos.y + pos.containerScrollY;\n      if (\n        chartSizingValues === null ||\n        getIfHoverOutOfBounds(\n          pos.x,\n          pos.y,\n          realPosX,\n          realPosY,\n          chartSizingValues,\n          dimensions,\n        )\n      ) {\n        return null;\n      }\n\n      const xHoverIndices = getBucketAndClusterNumForHover(\n        realPosX,\n        chartSizingValues,\n        data,\n        config,\n        data.x.length,\n      );\n      if (!xHoverIndices) {\n        return null;\n      }\n      const { bucketNum: xIndex } = xHoverIndices;\n      const x = xScale(xIndex);\n      const fullYs = data.ys.map((_, mapYIndex) =>\n        getBarYInfo(data, config, mapYIndex, xIndex, scale),\n      );\n      const ys = fullYs.map(y => y.yValue);\n      //This is the ys array, but shifted so that the y position for negative values is away from the axis (for the hover circles)\n      const shiftedYs = fullYs.map(y => {\n        if (y.yValue >= zeroAxisPosVal) {\n          return y.yValue + y.height;\n        }\n        return y.yValue;\n      });\n      const yPosSign = zeroAxisPosVal - pos.y;\n      let visibleYIndex = -1;\n      if (yPosSign < 0 && data.ys.find(y => y.values.find(val => val < 0))) {\n        for (let i = ys.length - 1; i >= 0; i--) {\n          if (ys[i] >= zeroAxisPosVal && ys[i] < pos.y) {\n            visibleYIndex = i;\n            break;\n          }\n        }\n      } else {\n        for (let i = 0; i < ys.length; i++) {\n          if (ys[i] <= zeroAxisPosVal && ys[i] < pos.y) {\n            visibleYIndex = i;\n            break;\n          }\n        }\n      }\n      if (visibleYIndex === -1) {\n        if (pos.y <= zeroAxisPosVal) {\n          visibleYIndex = ys.indexOf(Math.min(...ys));\n        } else {\n          visibleYIndex = ys.indexOf(Math.max(...ys));\n        }\n      }\n      const yIndex = visibleIndices[visibleYIndex];\n      const localAnchorX = x - pos.containerScrollX;\n      const localAnchorY = ys[visibleYIndex] - pos.containerScrollY;\n      const { anchorX, anchorY } = checkAnchorsAgainstBound(\n        localAnchorX,\n        localAnchorY,\n        dimensions,\n      );\n      const anchor = new DOMRect(\n        anchorX + pos.rect.x,\n        anchorY + pos.rect.y,\n        SMALL_PADDING,\n        0,\n      );\n      return {\n        hoverType: 'standard',\n        x,\n        xIndex,\n        ys: shiftedYs,\n        yIndex,\n        visibleYIndex,\n        tooltip: {\n          anchor,\n          date: utcFormat('%B %d, %Y')(new Date(data.x[xIndex])),\n          metrics: data.ys\n            .map((y, index) => ({\n              color: colors[index % colors.length],\n              label: y.label,\n              pattern: y.pattern,\n              value: pipeTransform(\n                y.values[xIndex],\n                checkIfSecondary(data, index, xIndex),\n                true,\n              ),\n            }))\n            .filter((_, i) => config.groupedTooltip || i === visibleYIndex),\n        },\n      };\n    }\n\n    return {\n      chartWidth: chartSizingValues.totalWidth,\n      chartHeight: chartSizingValues.totalHeight,\n      chartSizingValues,\n      xTicks,\n      yTicks,\n      colors,\n      areas,\n      lines: [],\n      circles: [],\n      hover,\n      bars: [],\n      arcs: [],\n      horizontalBars: [],\n      dataLabels: [],\n      waterfallLines: [],\n      gradients: [],\n      flowConnections: [],\n      horizontalContainerScale: chartSizingValues.horizontalContainerScale,\n      verticalContainerScale: chartSizingValues.verticalContainerScale,\n      chartError: null,\n    };\n  }\n\n  function bars(\n    config: ConfigWithFullScaling,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'bar')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    const { data, visibleIndices, visibleSuppIndices } = hide(allData);\n    if (\n      config.showDataLabels === true &&\n      isStackedData(config) &&\n      !isGroupingTypeException(data, config)\n    ) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Data labels aren't supported for any stacked chart type\",\n      );\n      return emptyChart;\n    }\n    if (\n      hasSupplementaryData(data) &&\n      isClusteredData(data, config, false) &&\n      !isGroupingTypeException(data, config)\n    ) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Supplementary y values aren't supported for clustered data (just use another normal y series)\",\n      );\n      return emptyChart;\n    }\n    return barsHelper(\n      config,\n      allData,\n      data,\n      visibleIndices,\n      visibleSuppIndices,\n      dimensions,\n      false,\n      false,\n    );\n  }\n\n  function funnel(\n    config: ConfigWithFullScaling,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'funnel')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    const { data, visibleIndices, visibleSuppIndices } = hide(allData);\n    return barsHelper(\n      config,\n      allData,\n      data,\n      visibleIndices,\n      visibleSuppIndices,\n      dimensions,\n      true,\n      false,\n    );\n  }\n\n  function waterfall(\n    config: ConfigWithFullScaling,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'waterfall')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    const { data: uncheckedData, visibleIndices } = hide(allData);\n    if (hasSupplementaryData(uncheckedData)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Supplementary y values aren't supported for non-bar charts\",\n      );\n      return emptyChart;\n    }\n    if (config.secondaryValueType) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'Heads up! Waterfall charts do not currently have two-axis support',\n      );\n      return emptyChart;\n    }\n    warnUnsupportedPatterns(uncheckedData, [], 'waterfall');\n\n    return barsHelper(\n      config,\n      allData,\n      uncheckedData,\n      visibleIndices,\n      [],\n      dimensions,\n      false,\n      true,\n    );\n  }\n\n  function barsHelper(\n    config: ConfigWithFullScaling,\n    allData: NonFlowData,\n    uncheckedData: NonFlowData,\n    visibleIndices: number[],\n    visibleSuppIndices: number[],\n    dimensions: Dimensions,\n    isFunnel: boolean,\n    isWaterfall: boolean,\n  ): RenderedChart {\n    const { dateFormat, pipeTransform, colorIndices, colors } =\n      getFormattingAndColors(allData, uncheckedData, config);\n    const waterfallData = waterfallTransform(uncheckedData, isWaterfall);\n    const data = isWaterfall ? waterfallData.data : uncheckedData;\n\n    const chartSizingValues = getFullChartScaleValues(\n      config,\n      data,\n      dimensions,\n      pipeTransform,\n      dateFormat,\n    );\n    if (chartSizingValues === null) {\n      return { ...emptyChart, chartError: 'sizing' };\n    }\n\n    const tickCount = getBucketTickCount(chartSizingValues);\n    const xTicks = (\n      data.type === 'labeled'\n        ? generateLabelledTicks(data, config, tickCount, chartSizingValues)\n        : generateTimeseriesTicks(\n            data,\n            config,\n            tickCount,\n            chartSizingValues,\n            dateFormat,\n          )\n    ).map(tick => toXTick(tick));\n    const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(\n      data,\n      pipeTransform,\n      config,\n      chartSizingValues,\n    );\n    const yTicks = dataTicks.map(tick => toYTick(tick));\n    const zeroAxisPosVal = scale(0, true);\n\n    const gradients: Rect[][] = [];\n    const bars: Rect[][] = data.ys.map((y, yIndex) => {\n      const indSeriesGradients: Rect[] = [];\n      const indSeriesBars = y.values.map((_, index) => {\n        const { yValue, height } = getBarYInfo(\n          data,\n          config,\n          yIndex,\n          index,\n          scale,\n        );\n        const xValue = calculateBarPosition(\n          data,\n          config,\n          chartSizingValues,\n          index,\n          isClusteredData(data, config, false) ? yIndex : 0,\n        );\n        if (isFunnel) {\n          //The empty gradient still needs to be inserted to keep data aligned\n          if (index === 0) {\n            indSeriesGradients.push({\n              elementType: 'rect',\n              x: 0,\n              y: 0,\n              width: 0,\n              height: 0,\n            });\n          } else {\n            const { yValue: prevBarYVal } = getBarYInfo(\n              data,\n              config,\n              yIndex,\n              index - 1,\n              scale,\n            );\n\n            indSeriesGradients.push({\n              elementType: 'rect',\n              x: xValue,\n              y: prevBarYVal,\n              width: chartSizingValues.barSize,\n              height: Math.max(yValue - prevBarYVal, 0),\n            });\n          }\n        }\n\n        const bar: Rect = {\n          elementType: 'rect',\n          x: xValue,\n          y: yValue,\n          width: chartSizingValues.barSize,\n          height,\n          offset: 0,\n          pattern: y.pattern,\n        };\n        return bar;\n      });\n      gradients.push(indSeriesGradients);\n      return indSeriesBars;\n    });\n    let suppBars: Rect[][] = [];\n    if (hasSupplementaryData(data)) {\n      suppBars = data.supplementaryYs.map((y, yIndex) =>\n        y.values.map((_, index) => {\n          const { yValue, height } = getBarYInfo(\n            data,\n            config,\n            yIndex,\n            index,\n            scale,\n            true,\n          );\n          const xValue = calculateBarPosition(\n            data,\n            config,\n            chartSizingValues,\n            index,\n            y.supplementalIndex + 1,\n          );\n          return {\n            elementType: 'rect',\n            x: xValue,\n            y: yValue,\n            width: chartSizingValues.barSize,\n            height,\n            offset: 0,\n            pattern: y.pattern,\n          };\n        }),\n      );\n      bars.push(...suppBars);\n      colors.push(\n        ...data.supplementaryYs.map(y =>\n          getColor(y, colorIndices, config.colors),\n        ),\n      );\n    }\n\n    const waterfallLines: {\n      x1: number;\n      x2: number;\n      y1: number;\n      y2: number;\n    }[] = [];\n    if (isWaterfall) {\n      //Move bars based on height of previous bars (except the total bar)\n      let barOffsetRunningTotal = 0;\n      for (let i = 0; i < data.x.length - 1; i++) {\n        let barOffsetChange = 0;\n        for (let j = 0; j < bars.length; j++) {\n          const barIsNegative =\n            bars[j][i].y >= zeroAxisPosVal && bars[j][i].height > 0;\n          if (barIsNegative) {\n            barOffsetChange -= bars[j][i].height;\n          } else {\n            barOffsetChange += bars[j][i].height;\n          }\n          bars[j][i].offset = barOffsetRunningTotal;\n          bars[j][i].y -= barOffsetRunningTotal;\n          if (j === bars.length - 1) {\n            const x1 = bars[j][i].x + bars[bars.length - 1][i].width;\n            const y1 = bars[j][i].y + (barIsNegative ? bars[j][i].height : 0);\n            const x2 = bars[j][i + 1].x;\n            const y2 = y1;\n            waterfallLines.push({\n              x1,\n              y1,\n              x2,\n              y2,\n            });\n          }\n        }\n        barOffsetRunningTotal += barOffsetChange;\n      }\n    }\n\n    const dataLabels: DataLabel[] = data.ys.flatMap((y, yIndex) => {\n      const subLabels: DataLabel[] = y.values.map((val, xIndex) => {\n        const isNegativeBar =\n          bars[yIndex][xIndex].y >= zeroAxisPosVal &&\n          bars[yIndex][xIndex].height > 0;\n        const yOffset = isNegativeBar\n          ? chartSizingValues.dataLabelPadding +\n            chartSizingValues.dataLabelTextSize +\n            bars[yIndex][xIndex].height\n          : -chartSizingValues.dataLabelPadding;\n        return {\n          elementType: 'dataLabel',\n          label:\n            pipeTransform(val, checkIfSecondary(data, yIndex, xIndex)) ?? '',\n          yPos:\n            (isFunnel && gradients[yIndex][xIndex].height !== 0\n              ? gradients[yIndex][xIndex].y\n              : bars[yIndex][xIndex].y) + yOffset,\n          xPos: bars[yIndex][xIndex].x + bars[yIndex][xIndex].width / 2,\n          anchor: 'middle',\n        };\n      });\n      return subLabels;\n    });\n    if (hasSupplementaryData(data)) {\n      const suppDataLabels: DataLabel[] = data.supplementaryYs.flatMap(\n        (y, yIndex) => {\n          const subLabels: DataLabel[] = y.values.map((val, xIndex) => {\n            const isNegativeBar =\n              suppBars[yIndex][xIndex].y >= zeroAxisPosVal &&\n              suppBars[yIndex][xIndex].height > 0;\n            const yOffset = isNegativeBar\n              ? chartSizingValues.dataLabelPadding +\n                suppBars[yIndex][xIndex].height\n              : -chartSizingValues.dataLabelPadding;\n            return {\n              elementType: 'dataLabel',\n              label:\n                pipeTransform(\n                  val,\n                  checkIfSecondary(data, yIndex, xIndex, true),\n                ) ?? '',\n              yPos: suppBars[yIndex][xIndex].y + yOffset,\n              xPos:\n                suppBars[yIndex][xIndex].x + suppBars[yIndex][xIndex].width / 2,\n              anchor: 'middle',\n            };\n          });\n          return subLabels;\n        },\n      );\n      dataLabels.push(...suppDataLabels);\n    }\n\n    function hover(pos: {\n      rect: DOMRect;\n      x: number;\n      y: number;\n      containerScrollX: number;\n      containerScrollY: number;\n    }): HoverReturn {\n      const realPosX = pos.x + pos.containerScrollX;\n      const realPosY = pos.y + pos.containerScrollY;\n      if (\n        chartSizingValues === null ||\n        getIfHoverOutOfBounds(\n          pos.x,\n          pos.y,\n          realPosX,\n          realPosY,\n          chartSizingValues,\n          dimensions,\n        )\n      ) {\n        return null;\n      }\n\n      const suppYs = hasSupplementaryData(data) ? data.supplementaryYs : null;\n\n      const xHoverIndices = getBucketAndClusterNumForHover(\n        realPosX,\n        chartSizingValues,\n        data,\n        config,\n        data.x.length,\n      );\n      if (!xHoverIndices) {\n        return null;\n      }\n      const {\n        bucketNum: xIndex,\n        clusterNum,\n        clusterNormCount,\n        clusterNumType,\n      } = xHoverIndices;\n\n      let isSuppValue: boolean = false;\n      let suppIndexVal = 0;\n      if (suppYs) {\n        suppIndexVal = clusterNum - clusterNormCount;\n        if (clusterNumType === 'supp') {\n          isSuppValue = true;\n        }\n      }\n\n      const calcX = calculateBarPosition(\n        data,\n        config,\n        chartSizingValues,\n        xIndex,\n        clusterNum,\n      );\n      const ys = data.ys.map((_, mapYIndex) =>\n        isSuppValue\n          ? getSuppBarYInfoViaYIndex(\n              data,\n              config,\n              mapYIndex,\n              suppIndexVal,\n              xIndex,\n              scale,\n            ).yValue\n          : getBarYInfo(data, config, mapYIndex, xIndex, scale).yValue -\n            (!isSuppValue && isWaterfall\n              ? bars[mapYIndex][xIndex].offset ?? 0\n              : 0),\n      );\n      const yPosSign = zeroAxisPosVal - realPosY;\n      let visibleYIndex = -1;\n      let dropOffHoverDetected = false;\n      if (yPosSign < 0 && data.ys.find(y => y.values.find(val => val < 0))) {\n        for (let i = ys.length - 1; i >= 0; i--) {\n          if (ys[i] >= zeroAxisPosVal && ys[i] < realPosY) {\n            visibleYIndex = i;\n            break;\n          }\n        }\n      } else {\n        for (let i = 0; i < ys.length; i++) {\n          if (ys[i] <= zeroAxisPosVal && ys[i] < realPosY) {\n            visibleYIndex = i;\n            break;\n          }\n        }\n      }\n      if (isClusteredData(data, config, false) && !suppYs) {\n        visibleYIndex = clusterNum;\n        if (isFunnel && xIndex !== 0 && ys[visibleYIndex] > realPosY) {\n          dropOffHoverDetected = true;\n        }\n      }\n      if (visibleYIndex === -1) {\n        if (realPosY <= zeroAxisPosVal) {\n          visibleYIndex = ys.indexOf(Math.min(...ys));\n        } else {\n          visibleYIndex = ys.indexOf(Math.max(...ys));\n        }\n      }\n      const yIndex = visibleIndices[visibleYIndex];\n      let { yValue, height } = isSuppValue\n        ? getSuppBarYInfoViaYIndex(\n            data,\n            config,\n            yIndex,\n            suppIndexVal,\n            xIndex,\n            scale,\n          )\n        : getBarYInfo(data, config, yIndex, xIndex, scale);\n      if (dropOffHoverDetected) {\n        yValue = gradients[yIndex][xIndex].y;\n        height = gradients[yIndex][xIndex].height;\n      }\n\n      const localAnchorX = calcX - pos.containerScrollX - SMALL_PADDING;\n      const width = chartSizingValues.barSize + SMALL_PADDING * 2;\n      const waterfallOffset =\n        !isSuppValue && isWaterfall ? bars[yIndex][xIndex].offset ?? 0 : 0;\n      const localAnchorY = yValue - pos.containerScrollY - waterfallOffset;\n      const { anchorX, anchorY, anchorWidth, anchorHeight } =\n        checkAnchorsAgainstBound(\n          localAnchorX,\n          localAnchorY,\n          dimensions,\n          width,\n          height,\n        );\n      const anchor = new DOMRect(\n        anchorX + pos.rect.x,\n        anchorY + pos.rect.y,\n        anchorWidth,\n        anchorHeight,\n      );\n      //We need to preserve the original index for the later checkIfSecondary call\n      const ysForMetrics: {\n        data: SupplementaryDataY | DataY;\n        originalIndex: number;\n      }[] =\n        isSuppValue && suppYs\n          ? suppYs\n              .map((suppY, index) => ({ data: suppY, originalIndex: index }))\n              .filter(suppY => suppY.data.supplementalIndex === suppIndexVal)\n          : data.ys.map((y, index) => ({ data: y, originalIndex: index }));\n      // Find the specific supplementary item that was hovered\n      const groupSupps = suppYs\n        ? suppYs.filter(s => s.supplementalIndex === suppIndexVal) ?? []\n        : [];\n      const suppArrayIndex = visibleYIndex; // Use the visual Y position within the layer\n      const filteredSuppYIndex =\n        suppArrayIndex >= 0 && suppArrayIndex < groupSupps.length && suppYs\n          ? suppYs.indexOf(groupSupps[suppArrayIndex]) ?? -1\n          : -1;\n      const suppYIndex =\n        filteredSuppYIndex >= 0 ? visibleSuppIndices[filteredSuppYIndex] : -1;\n\n      return {\n        hoverType: 'standard',\n        x: calcX + chartSizingValues.barSize / 2,\n        xIndex,\n        ys,\n        yIndex,\n        visibleYIndex,\n        ...(isSuppValue && suppYIndex >= 0\n          ? {\n              isSuppValue,\n              suppYIndex: suppYIndex,\n            }\n          : {}),\n        ...(dropOffHoverDetected ? { isDropOff: true } : {}),\n        tooltip: {\n          anchor,\n          date:\n            data.type === 'labeled'\n              ? dropOffHoverDetected\n                ? 'Drop off from '.concat(data.x[xIndex - 1].label)\n                : data.x[xIndex].label\n              : utcFormat('%B %d, %Y')(new Date(data.x[xIndex])),\n          metrics: ysForMetrics\n            .map(y => ({\n              color: getColor(\n                isWaterfall ? waterfallData.map.get(y.data) : y.data,\n                colorIndices,\n                config.colors,\n              ),\n              label: y.data.label,\n              pattern: y.data.pattern,\n              value: pipeTransform(\n                dropOffHoverDetected\n                  ? Math.max(\n                      y.data.values[xIndex - 1] - y.data.values[xIndex],\n                      0,\n                    )\n                  : y.data.values[xIndex],\n                checkIfSecondary(\n                  data,\n                  y.originalIndex,\n                  dropOffHoverDetected ? xIndex - 1 : xIndex,\n                  isSuppValue,\n                ),\n                true,\n              ),\n            }))\n            .filter((_, i) => config.groupedTooltip || i === visibleYIndex),\n        },\n      };\n    }\n\n    return {\n      chartWidth: chartSizingValues.totalWidth,\n      chartHeight: chartSizingValues.totalHeight,\n      chartSizingValues,\n      xTicks,\n      yTicks,\n      colors,\n      bars,\n      lines: [],\n      circles: [],\n      areas: [],\n      hover,\n      arcs: [],\n      horizontalBars: [],\n      dataLabels,\n      waterfallLines,\n      gradients,\n      flowConnections: [],\n      horizontalContainerScale: chartSizingValues.horizontalContainerScale,\n      verticalContainerScale: chartSizingValues.verticalContainerScale,\n      chartError: null,\n    };\n  }\n\n  function horizontalBars(\n    config: ConfigWithFullScaling,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'horizontal bar')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    //Some of this stuff gets confusing, because x and y are essentially inverted here\n    //  So, if you see a situation where a variable is named 'y', but referencing\n    //  'x' (or vice versa), that's why\n    const { data, visibleIndices, visibleSuppIndices } = hide(allData);\n    if (\n      config.showDataLabels === true &&\n      isStackedData(config) &&\n      !isGroupingTypeException(data, config)\n    ) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Data labels aren't supported for any stacked chart type\",\n      );\n      return emptyChart;\n    }\n    if (\n      hasSupplementaryData(data) &&\n      isClusteredData(data, config, false) &&\n      !isGroupingTypeException(data, config)\n    ) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Supplementary y values aren't supported for clustered data (just use another normal y series)\",\n      );\n      return emptyChart;\n    }\n\n    const { dateFormat, pipeTransform, colorIndices, colors } =\n      getFormattingAndColors(allData, data, config);\n\n    const chartSizingValues = getFullChartScaleValues(\n      config,\n      data,\n      dimensions,\n      pipeTransform,\n      dateFormat,\n    );\n    if (chartSizingValues === null) {\n      return { ...emptyChart, chartError: 'sizing' };\n    }\n\n    const tickCount = getBucketTickCount(chartSizingValues);\n    const yTicks = (\n      data.type === 'labeled'\n        ? generateLabelledTicks(data, config, tickCount, chartSizingValues)\n        : generateTimeseriesTicks(\n            data,\n            config,\n            tickCount,\n            chartSizingValues,\n            dateFormat,\n          )\n    ).map(tick => toYTick(tick));\n    const { scale, ticks: dataTicks } = calcDataAxisScalesAndTicks(\n      data,\n      pipeTransform,\n      config,\n      chartSizingValues,\n    );\n    const xTicks = dataTicks.map(tick => toXTick(tick));\n    const zeroAxisPosVal = scale(0, true);\n\n    const simplifiedHorizontalBars: {\n      xPos: number;\n      yPos: number;\n      width: number;\n    }[][] = [];\n    const horizontalBars = data.ys.map((y, yIndex) => {\n      const subSimpHorBars: {\n        xPos: number;\n        yPos: number;\n        width: number;\n      }[] = [];\n      const retVal = y.values.map((_, index) => {\n        const { xValue, width } = getBarXInfo(\n          data,\n          config,\n          yIndex,\n          index,\n          scale,\n        );\n        const clusterInfo = getClusterInfoForBucket(data, config);\n        const clusterNum = clusterInfo.normClusterIndices.indexOf(yIndex);\n        const yValue = calculateBarPosition(\n          data,\n          config,\n          chartSizingValues,\n          index,\n          isClusteredData(data, config, false) ? clusterNum : 0,\n        );\n\n        const horR = Math.min(\n          DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS,\n          Math.floor(width / 2),\n        );\n        const verR = Math.min(\n          DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS,\n          Math.floor(chartSizingValues.barSize / 2),\n        );\n        subSimpHorBars.push({\n          xPos: xValue,\n          yPos: yValue,\n          width,\n        });\n        //If clusterNum is -1, then the value of data[yIndex][xIndex] must be zero\n        if (clusterNum === -1) {\n          return {\n            horizontalBar: '',\n            pattern: y.pattern,\n            x: xValue,\n            y: yValue,\n          };\n        }\n        //Don't draw anything for zero-value bars\n        if (width === 0) {\n          return {\n            horizontalBar: '',\n            pattern: y.pattern,\n            x: xValue,\n            y: yValue,\n          };\n        }\n\n        const isPositive = data.ys[yIndex].values[index] > 0;\n        const hasAnyNegativeBars = data.ys\n          .map(y => y.values[index])\n          .find(val => val < 0);\n        const hasAnyPositiveBars = data.ys\n          .map(y => y.values[index])\n          .find(val => val > 0);\n\n        //These checks are to make sure we still round if all previous/later values are 0\n        const allLeftZero = isPositive\n          ? data.ys\n              .slice(0, yIndex)\n              .map(y => y.values[index])\n              .filter(val => val > 0).length === 0 && !hasAnyNegativeBars\n          : data.ys\n              .slice(yIndex + 1, data.ys.length)\n              .map(y => y.values[index])\n              .filter(val => val < 0).length === 0;\n        const leftSideRound = !isStackedData(config) || allLeftZero;\n        const allRightZero = isPositive\n          ? data.ys\n              .slice(yIndex + 1, data.ys.length)\n              .map(y => y.values[index])\n              .filter(val => val > 0).length === 0\n          : data.ys\n              .slice(0, yIndex)\n              .map(y => y.values[index])\n              .filter(val => val < 0).length === 0 && !hasAnyPositiveBars;\n        const rightSideRound = !isStackedData(config) || allRightZero;\n        const pathD = calculateHorizontalBarPath(\n          leftSideRound,\n          rightSideRound,\n          xValue,\n          yValue,\n          horR,\n          verR,\n          chartSizingValues.barSize,\n          width,\n        );\n        return {\n          horizontalBar: pathD,\n          pattern: y.pattern,\n          x: xValue,\n          y: yValue,\n        };\n      });\n      simplifiedHorizontalBars.push(subSimpHorBars);\n      return retVal;\n    });\n    const suppYs = data.supplementaryYs;\n    const simplifiedSuppHorizontalBars: {\n      xPos: number;\n      yPos: number;\n      width: number;\n    }[][] = [];\n    if (suppYs) {\n      const suppHorizontalBars = suppYs.map((y, yIndex) => {\n        const subSimpHorBars: {\n          xPos: number;\n          yPos: number;\n          width: number;\n        }[] = [];\n        const retVal = y.values.map((_, index) => {\n          const { xValue, width } = getBarXInfo(\n            data,\n            config,\n            yIndex,\n            index,\n            scale,\n            true,\n          );\n          const clusterInfo = getClusterInfoForBucket(data, config);\n          const clusterNum =\n            clusterInfo.suppClusterIndices.indexOf(y.supplementalIndex) +\n            clusterInfo.normCount;\n          const yValue = calculateBarPosition(\n            data,\n            config,\n            chartSizingValues,\n            index,\n            clusterNum,\n          );\n\n          const horR = Math.min(\n            DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS,\n            Math.floor(width / 2),\n          );\n          const verR = Math.min(\n            DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS,\n            Math.floor(chartSizingValues.barSize / 2),\n          );\n          subSimpHorBars.push({\n            xPos: xValue,\n            yPos: yValue,\n            width,\n          });\n          //Don't draw anything for zero-value bars\n          if (width === 0) {\n            return {\n              horizontalBar: '',\n              pattern: y.pattern,\n              x: xValue,\n              y: yValue,\n            };\n          }\n\n          const isPositive = suppYs[yIndex].values[index] > 0;\n          const hasAnyNegativeBars = suppYs\n            .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)\n            .map(y => y.values[index])\n            .find(val => val < 0);\n          const hasAnyPositiveBars = suppYs\n            .filter(suppY => suppY.supplementalIndex === y.supplementalIndex)\n            .map(y => y.values[index])\n            .find(val => val > 0);\n\n          //These checks are to make sure we still round if all previous/later values are 0\n          const allLeftZero = isPositive\n            ? suppYs\n                .slice(0, yIndex)\n                .filter(\n                  suppY => suppY.supplementalIndex === y.supplementalIndex,\n                )\n                .map(y => y.values[index])\n                .filter(val => val > 0).length === 0 && !hasAnyNegativeBars\n            : suppYs\n                .slice(yIndex + 1, suppYs.length)\n                .filter(\n                  suppY => suppY.supplementalIndex === y.supplementalIndex,\n                )\n                .map(y => y.values[index])\n                .filter(val => val < 0).length === 0;\n          const leftSideRound = !isStackedData(config) || allLeftZero;\n          const allRightZero = isPositive\n            ? suppYs\n                .slice(yIndex + 1, suppYs.length)\n                .filter(\n                  suppY => suppY.supplementalIndex === y.supplementalIndex,\n                )\n                .map(y => y.values[index])\n                .filter(val => val > 0).length === 0\n            : suppYs\n                .slice(0, yIndex)\n                .filter(\n                  suppY => suppY.supplementalIndex === y.supplementalIndex,\n                )\n                .map(y => y.values[index])\n                .filter(val => val < 0).length === 0 && !hasAnyPositiveBars;\n          const rightSideRound = !isStackedData(config) || allRightZero;\n          const pathD = calculateHorizontalBarPath(\n            leftSideRound,\n            rightSideRound,\n            xValue,\n            yValue,\n            horR,\n            verR,\n            chartSizingValues.barSize,\n            width,\n          );\n          return {\n            horizontalBar: pathD,\n            pattern: y.pattern,\n            x: xValue,\n            y: yValue,\n          };\n        });\n        simplifiedSuppHorizontalBars.push(subSimpHorBars);\n        return retVal;\n      });\n      horizontalBars.push(...suppHorizontalBars);\n      colors.push(...suppYs.map(y => getColor(y, colorIndices, config.colors)));\n    }\n\n    const yOffset = chartSizingValues.barSize;\n    const dataLabels: DataLabel[] = data.ys.flatMap((y, yIndex) => {\n      const subLabels: DataLabel[] = y.values.map((val, xIndex) => {\n        const barIsNegative =\n          simplifiedHorizontalBars[yIndex][xIndex].xPos < zeroAxisPosVal &&\n          simplifiedHorizontalBars[yIndex][xIndex].width > 0;\n        const xOffset = barIsNegative\n          ? -chartSizingValues.dataLabelPadding\n          : simplifiedHorizontalBars[yIndex][xIndex].width +\n            chartSizingValues.dataLabelPadding;\n        return {\n          elementType: 'dataLabel',\n          label:\n            pipeTransform(val, checkIfSecondary(data, yIndex, xIndex)) ?? '',\n          yPos: simplifiedHorizontalBars[yIndex][xIndex].yPos + yOffset,\n          xPos: simplifiedHorizontalBars[yIndex][xIndex].xPos + xOffset,\n          anchor: barIsNegative ? 'end' : 'start',\n        };\n      });\n      return subLabels;\n    });\n    if (suppYs) {\n      const suppDataLabels: DataLabel[] = suppYs.flatMap((y, yIndex) => {\n        const subLabels: DataLabel[] = y.values.map((val, xIndex) => {\n          const barIsNegative =\n            simplifiedSuppHorizontalBars[yIndex][xIndex].xPos <\n              zeroAxisPosVal &&\n            simplifiedSuppHorizontalBars[yIndex][xIndex].width > 0;\n          const xOffset = barIsNegative\n            ? -chartSizingValues.dataLabelPadding\n            : simplifiedSuppHorizontalBars[yIndex][xIndex].width +\n              chartSizingValues.dataLabelPadding;\n          return {\n            elementType: 'dataLabel',\n            label:\n              pipeTransform(\n                val,\n                checkIfSecondary(data, yIndex, xIndex, true),\n              ) ?? '',\n            yPos: simplifiedSuppHorizontalBars[yIndex][xIndex].yPos + yOffset,\n            xPos: simplifiedSuppHorizontalBars[yIndex][xIndex].xPos + xOffset,\n            anchor: barIsNegative ? 'end' : 'start',\n          };\n        });\n        return subLabels;\n      });\n      dataLabels.push(...suppDataLabels);\n    }\n\n    function hover(pos: {\n      rect: DOMRect;\n      x: number;\n      y: number;\n      containerScrollX: number;\n      containerScrollY: number;\n    }): HoverReturn {\n      const realPosX = pos.x + pos.containerScrollX;\n      const realPosY = pos.y + pos.containerScrollY;\n      if (\n        chartSizingValues === null ||\n        getIfHoverOutOfBounds(\n          pos.x,\n          pos.y,\n          realPosX,\n          realPosY,\n          chartSizingValues,\n          dimensions,\n        )\n      ) {\n        return null;\n      }\n\n      const suppYs = hasSupplementaryData(data) ? data.supplementaryYs : null;\n      const xHoverIndices = getBucketAndClusterNumForHover(\n        realPosY,\n        chartSizingValues,\n        data,\n        config,\n        data.x.length,\n      );\n      if (!xHoverIndices) {\n        return null;\n      }\n      const {\n        bucketNum: xIndex,\n        clusterNum,\n        clusterNormCount,\n        clusterNumType,\n      } = xHoverIndices;\n\n      let x = calculateBarPosition(\n        data,\n        config,\n        chartSizingValues,\n        xIndex,\n        clusterNum,\n      );\n      let isSuppValue: boolean = false;\n      let suppIndexVal = 0;\n      if (suppYs) {\n        suppIndexVal = clusterNum - clusterNormCount;\n        if (clusterNumType === 'supp') {\n          isSuppValue = true;\n        }\n      }\n\n      // When hovering supplementary values, get bars for that supplemental layer\n      // When hovering original Ys, get bars for original Ys\n      const fullYs =\n        hasSupplementaryData(data) && isSuppValue\n          ? (\n              data.supplementaryYs.filter(\n                s => s.supplementalIndex === suppIndexVal,\n              ) ?? []\n            ).map(suppY =>\n              getBarXInfo(\n                data,\n                config,\n                data.supplementaryYs.indexOf(suppY),\n                xIndex,\n                scale,\n                true,\n              ),\n            )\n          : data.ys.map((_, mapYIndex) =>\n              getBarXInfo(data, config, mapYIndex, xIndex, scale),\n            );\n      const ys = fullYs.map(y => y.xValue);\n      let visibleYIndex = -1;\n      for (let i = 0; i < fullYs.length; i++) {\n        const leftBorder = fullYs[i].xValue;\n        const rightBorderCandidates = fullYs\n          .filter(y => y.xValue > leftBorder)\n          .map(y => y.xValue);\n        const rightBorder =\n          rightBorderCandidates.length > 0\n            ? Math.min(...rightBorderCandidates)\n            : leftBorder + fullYs[i].width;\n        if (realPosX > leftBorder && realPosX < rightBorder) {\n          visibleYIndex = i;\n        }\n      }\n      if (isClusteredData(data, config, false)) {\n        visibleYIndex = clusterNum;\n      }\n\n      if (visibleYIndex === -1) {\n        if (realPosX >= zeroAxisPosVal) {\n          visibleYIndex = ys.indexOf(Math.max(...ys));\n        } else {\n          visibleYIndex = ys.indexOf(Math.min(...ys));\n        }\n      }\n      // For supplementary bars: visibleYIndex is index within filtered supplementary array\n      // For original Ys: visibleYIndex is index within original Ys array\n      const actualSuppYIndex =\n        hasSupplementaryData(data) && isSuppValue\n          ? data.supplementaryYs.findIndex(\n              s =>\n                s.supplementalIndex === suppIndexVal &&\n                data.supplementaryYs\n                  .filter(s2 => s2.supplementalIndex === suppIndexVal)\n                  .indexOf(s) === visibleYIndex,\n            ) ?? -1\n          : -1;\n\n      const yIndex = isSuppValue ? 0 : visibleIndices[visibleYIndex];\n\n      //Check if we've landed on a zero-width bar (only really relevant on ends)\n      const barsToCheck = isSuppValue\n        ? simplifiedSuppHorizontalBars\n        : simplifiedHorizontalBars;\n      const barIndexToCheck = isSuppValue ? actualSuppYIndex : visibleYIndex;\n\n      if (\n        barIndexToCheck >= 0 &&\n        barsToCheck[barIndexToCheck][xIndex].width === 0 &&\n        isStackedData(config)\n      ) {\n        let altBarFound = false;\n        //Check upwards\n        for (let i = barIndexToCheck + 1; i < barsToCheck.length; i++) {\n          if (altBarFound) {\n            break;\n          }\n          if (barsToCheck[i][xIndex].width !== 0) {\n            if (hasSupplementaryData(data) && isSuppValue) {\n              visibleYIndex = data.supplementaryYs\n                .filter(s => s.supplementalIndex === suppIndexVal)\n                .indexOf(data.supplementaryYs[i])!;\n            } else {\n              visibleYIndex = i;\n            }\n            altBarFound = true;\n          }\n        }\n\n        //Check downwards\n        for (let i = barIndexToCheck - 1; i >= 0; i--) {\n          if (altBarFound) {\n            break;\n          }\n          if (barsToCheck[i][xIndex].width !== 0) {\n            if (hasSupplementaryData(data) && isSuppValue) {\n              visibleYIndex = data.supplementaryYs\n                .filter(s => s.supplementalIndex === suppIndexVal)\n                .indexOf(data.supplementaryYs[i])!;\n            } else {\n              visibleYIndex = i;\n            }\n            altBarFound = true;\n          }\n        }\n      }\n\n      const originalSuppYIndex =\n        isSuppValue && actualSuppYIndex >= 0\n          ? visibleSuppIndices[actualSuppYIndex]\n          : -1;\n\n      const barXPos = isSuppValue\n        ? simplifiedSuppHorizontalBars[actualSuppYIndex][xIndex].xPos\n        : simplifiedHorizontalBars[visibleYIndex][xIndex].xPos;\n      const barYPos = isSuppValue\n        ? simplifiedSuppHorizontalBars[actualSuppYIndex][xIndex].yPos\n        : simplifiedHorizontalBars[visibleYIndex][xIndex].yPos;\n      const barWidth = isSuppValue\n        ? simplifiedSuppHorizontalBars[actualSuppYIndex][xIndex].width\n        : simplifiedHorizontalBars[visibleYIndex][xIndex].width;\n\n      const localAnchorX = barXPos - pos.containerScrollX - SMALL_PADDING;\n      const width = barWidth + SMALL_PADDING * 2;\n      const localAnchorY = barYPos - pos.containerScrollY;\n      const height = chartSizingValues.barSize;\n      const { anchorX, anchorY, anchorWidth, anchorHeight } =\n        checkAnchorsAgainstBound(\n          localAnchorX,\n          localAnchorY,\n          dimensions,\n          width,\n          height,\n        );\n      const anchor = new DOMRect(\n        anchorX + pos.rect.x,\n        anchorY + pos.rect.y,\n        anchorWidth,\n        anchorHeight,\n      );\n      //We need to preserve the original index for the later checkIfSecondary call\n      const ysForMetrics: {\n        data: SupplementaryDataY | DataY;\n        originalIndex: number;\n      }[] =\n        isSuppValue && suppYs\n          ? suppYs\n              .map((suppY, index) => ({ data: suppY, originalIndex: index }))\n              .filter(suppY => suppY.data.supplementalIndex === suppIndexVal)\n          : data.ys.map((y, index) => ({ data: y, originalIndex: index }));\n      return {\n        hoverType: 'standard',\n        x,\n        xIndex,\n        ys,\n        yIndex,\n        visibleYIndex,\n        ...(isSuppValue && originalSuppYIndex >= 0\n          ? { isSuppValue, suppYIndex: originalSuppYIndex }\n          : {}),\n        tooltip: {\n          anchor,\n          date:\n            data.type === 'labeled'\n              ? data.x[xIndex].label\n              : utcFormat('%B %d, %Y')(new Date(data.x[xIndex])),\n          metrics: ysForMetrics\n            .map(y => ({\n              color: getColor(y.data, colorIndices, config.colors),\n              label: y.data.label,\n              pattern: y.data.pattern,\n              value: pipeTransform(\n                y.data.values[xIndex],\n                checkIfSecondary(data, y.originalIndex, xIndex, isSuppValue),\n                true,\n              ),\n            }))\n            .filter((_, i) => config.groupedTooltip || i === visibleYIndex),\n        },\n      };\n    }\n\n    return {\n      chartWidth: chartSizingValues.totalWidth,\n      chartHeight: chartSizingValues.totalHeight,\n      chartSizingValues,\n      xTicks: xTicks,\n      yTicks: yTicks,\n      hover,\n      colors,\n      bars: [],\n      lines: [],\n      circles: [],\n      areas: [],\n      arcs: [],\n      horizontalBars,\n      dataLabels,\n      waterfallLines: [],\n      gradients: [],\n      flowConnections: [],\n      horizontalContainerScale: chartSizingValues.horizontalContainerScale,\n      verticalContainerScale: chartSizingValues.verticalContainerScale,\n      chartError: null,\n    };\n  }\n\n  function arcs(\n    config: DonutConfig,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (!warnFlowData(allData, 'donut')) {\n      return { ...emptyChart, chartError: 'config' };\n    }\n    if (\n      config.secondaryValueType &&\n      (config.valueType === 'percentage' ||\n        config.secondaryValueType === 'percentage')\n    ) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Two axes with percentage aren't supported for donut charts\",\n      );\n      return emptyChart;\n    }\n    if (hasSupplementaryData(allData)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Supplementary y values aren't supported for non-bar charts\",\n      );\n      return emptyChart;\n    }\n    warnUnsupportedPatterns(allData, [], 'donut');\n    const { data: unstackedData, visibleIndices } = hide(allData);\n    const donutData = Chart.convertChartDataToDonutData(unstackedData);\n    const hasNonZeroValue = donutData.some(d => d.value > 0);\n    const arcData = hasNonZeroValue\n      ? donutData\n      : [\n          {\n            label: '',\n            value: 1,\n          },\n        ];\n    const colors = hasNonZeroValue\n      ? visibleIndices.map(i => config.colors[i % config.colors.length])\n      : ['--gray-30'];\n    const { pipeTransform } = getFormattingAndColors(\n      allData,\n      unstackedData,\n      config,\n    );\n\n    const donutDefaultConfig = DefaultDonutSizingConfig;\n    const dataLabelPaddingConfig = getElementScalingInfo(\n      config.donutDisplayInfo.scalingConfig?.elementScales,\n      donutDefaultConfig.elementScales,\n      'dataLabelPadding',\n    );\n    const fontSizeConfig = getElementScalingInfo(\n      config.donutDisplayInfo.scalingConfig?.elementScales,\n      donutDefaultConfig.elementScales,\n      'fontSize',\n    );\n    const dataLabelTextSizing = getDataLabelSize(\n      unstackedData,\n      pipeTransform,\n      fontSizeConfig.target,\n    );\n\n    const horizontalContainerScale =\n      config.donutDisplayInfo.scalingConfig?.horizontalContainerScale !==\n      undefined\n        ? config.donutDisplayInfo.scalingConfig.horizontalContainerScale\n        : donutDefaultConfig.horizontalContainerScale;\n    const verticalContainerScale =\n      config.donutDisplayInfo.scalingConfig?.verticalContainerScale !==\n      undefined\n        ? config.donutDisplayInfo.scalingConfig.verticalContainerScale\n        : donutDefaultConfig.verticalContainerScale;\n    const outerRadiusConfig =\n      config.donutDisplayInfo.scalingConfig?.outerRadius !== undefined\n        ? config.donutDisplayInfo.scalingConfig.outerRadius\n        : donutDefaultConfig.outerRadius;\n    const drawRadiusConfig =\n      config.donutDisplayInfo.scalingConfig?.drawRadius !== undefined\n        ? config.donutDisplayInfo.scalingConfig.drawRadius\n        : donutDefaultConfig.drawRadius;\n\n    const outer =\n      outerRadiusConfig.type === 'proportion'\n        ? (dimensions.height / 2) * outerRadiusConfig.value\n        : outerRadiusConfig.value;\n    const drawRadius =\n      drawRadiusConfig.type === 'proportion'\n        ? outer * drawRadiusConfig.value\n        : drawRadiusConfig.value;\n    const inner = outer - drawRadius;\n\n    const pieArcs = pie<DonutData>()\n      .sortValues(null)\n      .value(d => Math.max(d.value, 0))(arcData);\n\n    const arcs = pieArcs.map(pieArc =>\n      arc<DonutData>()\n        .innerRadius(inner)\n        .outerRadius(outer)\n        .padAngle(0.013)\n        .startAngle(pieArc.startAngle)\n        .endAngle(pieArc.endAngle)(pieArc.data),\n    );\n\n    const dataLabels: DataLabel[] = hasNonZeroValue\n      ? pieArcs.map(arc => {\n          //Don't show data labels for zero-width donut slices (includes negative values)\n          if (arc.startAngle === arc.endAngle) {\n            return {\n              elementType: 'dataLabel',\n              label: '',\n              yPos: 0,\n              xPos: 0,\n              anchor: 'middle',\n            };\n          }\n          const arcCenterAngle = (arc.startAngle + arc.endAngle) / 2;\n          const edgePoint = arcToPoint(arcCenterAngle, outer);\n          const lineEndPoint = arcToPoint(\n            arcCenterAngle,\n            outer + dataLabelPaddingConfig.target,\n          );\n          const middleArea = outer / 4;\n          let yOffset = 0;\n          let xOffset = 0;\n          if (lineEndPoint.y > 0) {\n            if (Math.abs(lineEndPoint.y) < middleArea) {\n              yOffset = SMALL_PADDING / 2;\n            } else {\n              yOffset = SMALL_PADDING;\n            }\n            if (Math.abs(lineEndPoint.x) < middleArea) {\n              yOffset += SMALL_PADDING / 2;\n            }\n          } else {\n            if (Math.abs(lineEndPoint.y) < middleArea) {\n              yOffset = SMALL_PADDING / 2;\n            }\n            if (Math.abs(lineEndPoint.x) < middleArea) {\n              yOffset -= SMALL_PADDING / 2;\n            }\n          }\n          return {\n            elementType: 'dataLabel',\n            label: pipeTransform(arc.data.value, arc.data.isSecondary),\n            yPos: lineEndPoint.y + yOffset,\n            xPos: lineEndPoint.x + xOffset,\n            anchor:\n              Math.abs(lineEndPoint.x) < middleArea\n                ? 'middle'\n                : lineEndPoint.x < 0\n                ? 'end'\n                : 'start',\n            line: {\n              x1: edgePoint.x,\n              y1: edgePoint.y,\n              x2: lineEndPoint.x,\n              y2: lineEndPoint.y,\n            },\n          };\n        })\n      : [];\n\n    const drawWidth =\n      (outer +\n        (config.showDataLabels\n          ? dataLabelPaddingConfig.target + dataLabelTextSizing.horizontal\n          : 0)) *\n      2;\n    const drawHeight =\n      (outer +\n        (config.showDataLabels\n          ? dataLabelPaddingConfig.target + dataLabelTextSizing.vertical\n          : 0)) *\n      2;\n\n    function hover(pos: {\n      rect: DOMRect;\n      x: number;\n      y: number;\n      containerScrollX: number;\n      containerScrollY: number;\n    }): HoverReturn {\n      const realPosX = pos.x + pos.containerScrollX;\n      const realPosY = pos.y + pos.containerScrollY;\n      if (\n        getIfHoverOutOfBounds(\n          pos.x,\n          pos.y,\n          realPosX,\n          realPosY,\n          null,\n          dimensions,\n        )\n      ) {\n        return null;\n      }\n      const centerPointX = dimensions.width / 2;\n      const centerPointY = dimensions.height / 2;\n      const donutPositionX = realPosX - centerPointX;\n      const donutPositionY = realPosY - centerPointY;\n      const hoverPosArcInfo = pointToArc(donutPositionX, donutPositionY);\n      const arcCenterLine = (outer + inner) / 2;\n\n      //Detect donut slice\n      let foundYIndex = -1;\n      let preferredPosition: CalloutComponent.AnchoredPosition | undefined =\n        undefined;\n      let donutXPosition = 0;\n      let donutYPosition = 0;\n      for (let i = 0; i < pieArcs.length; i++) {\n        const arc = pieArcs[i];\n\n        if (\n          hoverPosArcInfo.angle > arc.startAngle &&\n          hoverPosArcInfo.angle < arc.endAngle &&\n          hoverPosArcInfo.radius > arcCenterLine - drawRadius &&\n          hoverPosArcInfo.radius < arcCenterLine + drawRadius\n        ) {\n          foundYIndex = i;\n          const arcCenterPoint = arcToPoint(\n            (arc.startAngle + arc.endAngle) / 2,\n            arcCenterLine,\n          );\n\n          //Need to un-offset the positions\n          donutXPosition = arcCenterPoint.x + centerPointX;\n          donutYPosition = arcCenterPoint.y + centerPointY;\n          const verticalArea =\n            arcCenterPoint.y < (dimensions.height * -1) / 4\n              ? 'top'\n              : arcCenterPoint.y > dimensions.height / 4\n              ? 'bottom'\n              : 'center';\n\n          //Determine the best position for the tooltip\n          if (arcCenterPoint.x > 0) {\n            //Right path\n            if (!config.groupedTooltip || verticalArea === 'center') {\n              preferredPosition = 'center-right';\n            } else if (verticalArea === 'top') {\n              preferredPosition = 'right-top';\n            } else if (verticalArea === 'bottom') {\n              preferredPosition = 'right-bottom';\n            }\n          } else {\n            //Left path\n            if (!config.groupedTooltip || verticalArea === 'center') {\n              preferredPosition = 'center-left';\n            } else if (verticalArea === 'top') {\n              preferredPosition = 'left-top';\n            } else if (verticalArea === 'bottom') {\n              preferredPosition = 'left-bottom';\n            }\n          }\n          break;\n        }\n      }\n      if (foundYIndex === -1) {\n        return null;\n      }\n      if (!hasNonZeroValue) {\n        donutXPosition = centerPointX + arcCenterLine;\n        donutYPosition = centerPointY;\n      }\n\n      const localAnchorX = donutXPosition - pos.containerScrollX;\n      const localAnchorY = donutYPosition - pos.containerScrollY;\n      const { anchorX, anchorY } = checkAnchorsAgainstBound(\n        localAnchorX,\n        localAnchorY,\n        dimensions,\n      );\n      const anchor = new DOMRect(\n        anchorX + pos.rect.x,\n        anchorY + pos.rect.y,\n        SMALL_PADDING,\n        0,\n      );\n      return {\n        hoverType: 'standard',\n        tooltip: {\n          anchor,\n          preferredPosition,\n          date: null,\n          metrics: donutData\n            .map((y, index) => ({\n              color: colors[index % colors.length],\n              label: y.label,\n              value: pipeTransform(y.value, y.isSecondary, true),\n            }))\n            .filter((_, i) => config.groupedTooltip || i === foundYIndex),\n        },\n        //Not used by donut charts\n        x: 0,\n        xIndex: 0,\n        ys: [],\n        yIndex: 0,\n        visibleYIndex: 0,\n      };\n    }\n\n    return {\n      chartWidth: drawWidth,\n      chartHeight: drawHeight,\n      chartSizingValues: {\n        ...emptyChartScaleValues,\n        dataLabelPadding: dataLabelPaddingConfig.target,\n        dataLabelTextSize: dataLabelTextSizing.horizontal,\n        fontSize: fontSizeConfig.target,\n      },\n      xTicks: [],\n      yTicks: [],\n      areas: [],\n      lines: [],\n      circles: [],\n      bars: [],\n      colors,\n      arcs,\n      horizontalBars: [],\n      dataLabels,\n      waterfallLines: [],\n      gradients: [],\n      flowConnections: [],\n      horizontalContainerScale,\n      verticalContainerScale,\n      chartError: null,\n      hover,\n    };\n  }\n\n  function flows(\n    config: FlowConfig,\n    allData: InputData,\n    dimensions: Dimensions,\n  ): RenderedChart {\n    if (allData.type !== 'flow') {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `Heads up! The '${allData.type}' data type isn't supported for flow charts.`,\n      );\n      return { ...emptyChart, chartError: 'config' };\n    }\n\n    const data = flowsTransform(config, allData);\n    if (data.x.length === 0) {\n      return emptyChart;\n    }\n    const overallTotal = data.x[0].totalCount;\n\n    const chartSizingValues = getFullChartScaleValues(\n      config,\n      data,\n      dimensions,\n      null,\n      null,\n    );\n    if (chartSizingValues === null) {\n      return { ...emptyChart, chartError: 'sizing' };\n    }\n\n    const { scale } = calcDataAxisScalesAndTicks(\n      data,\n      null,\n      config,\n      chartSizingValues,\n    );\n    const valuePipes = getPipes(config.valueType);\n    const percentPipes = getPipes('percentage');\n\n    const bars: FlowRect[][] = [];\n    const flowConnections: FlowConnectionRender[] = [];\n    const dataLabels: FlowDataLabel[] = [];\n    const minimumSize = getMinimumDataElementSize(config);\n    for (let i = 0; i < data.x.length; i++) {\n      const bucketBars: FlowRect[] = [];\n      let runningHeight = 0;\n      for (const bar of data.x[i].subBuckets) {\n        const continuingCount = bar.connections\n          .filter(connection => connection.direction === 'forward')\n          .map(connection => connection.count)\n          .reduce((a, b) => a + b, 0);\n        const {\n          totalSize: totalHeight,\n          continuingSize: darkenedHeight,\n          connectionSizes,\n        } = getFlowSubBucketSizes(\n          bar,\n          value => scale(value, false) - chartSizingValues.totalTopOffset,\n          minimumSize,\n        );\n        const connectionHeight = (connection: FlowConnection): number =>\n          connectionSizes[bar.connections.indexOf(connection)];\n        const nonDarkenedHeight = totalHeight - darkenedHeight;\n        const darkenedY = runningHeight + chartSizingValues.totalTopOffset;\n        const nonDarkenedY = darkenedY + darkenedHeight;\n\n        const width = chartSizingValues.barSize;\n        const x =\n          chartSizingValues.totalLeftOffset +\n          i * (chartSizingValues.barSize + chartSizingValues.bucketGap);\n        const colorOverride = config.flowConfig.subBucketsConfig.find(\n          bc => bc.bucketId === bar.id,\n        )?.color;\n        if (darkenedHeight > 0) {\n          bucketBars.push({\n            elementType: 'rect',\n            rectType: 'flow',\n            height: darkenedHeight,\n            width,\n            y: darkenedY,\n            x,\n            colorOverride,\n            darken: true,\n            deEmphasize: isDeEmphasized(config, bar.id, true),\n            id: bar.id,\n            bucketIndex: i,\n            count: continuingCount,\n            totalCount: bar.count,\n          });\n        }\n        if (nonDarkenedHeight > 0) {\n          bucketBars.push({\n            elementType: 'rect',\n            rectType: 'flow',\n            height: nonDarkenedHeight,\n            width,\n            y: nonDarkenedY,\n            x,\n            colorOverride,\n            darken: false,\n            deEmphasize: isDeEmphasized(config, bar.id, false),\n            id: bar.id,\n            bucketIndex: i,\n            count: bar.count - continuingCount,\n            totalCount: bar.count,\n          });\n        }\n        //Invisible bar for hover highlight purposes\n        bucketBars.push({\n          elementType: 'rect',\n          rectType: 'flow',\n          height: darkenedHeight + nonDarkenedHeight,\n          width,\n          y: darkenedY,\n          x,\n          nonDisplay: true,\n          id: bar.id,\n          bucketIndex: i,\n          count: bar.count,\n          totalCount: bar.count,\n          darken: false,\n          deEmphasize: false,\n        });\n        runningHeight +=\n          totalHeight +\n          chartSizingValues.dataLabelPadding +\n          chartSizingValues.dataLabelTextSize;\n\n        //Connections\n        //Add new renders for forward connections\n        let verticalConnectionOffset = 0;\n        for (const connection of bar.connections.filter(\n          connection => connection.direction === 'forward',\n        )) {\n          const topLineY1 = darkenedY + verticalConnectionOffset;\n          const bottomLineY1 = topLineY1 + connectionHeight(connection);\n          const x1 = x + width;\n          const connectionRender: FlowConnectionRender = {\n            elementType: 'connection',\n            start: connection.start,\n            end: connection.end,\n            count: connection.count,\n            step: i,\n            topLine: {\n              y1: topLineY1,\n              x1,\n              //To be filled in later\n              y2: 0,\n              x2: 0,\n            },\n            bottomLine: {\n              y1: bottomLineY1,\n              x1,\n              //To be filled in later\n              y2: 0,\n              x2: 0,\n            },\n            //To be filled in later\n            path: '',\n          };\n          verticalConnectionOffset += connectionHeight(connection);\n          flowConnections.push(connectionRender);\n        }\n        //Backfill position info for backwards connections\n        verticalConnectionOffset = 0;\n        for (const connection of bar.connections.filter(\n          connection => connection.direction === 'backward',\n        )) {\n          const matchingConnection = flowConnections.find(\n            con =>\n              con.start === connection.start &&\n              con.end === connection.end &&\n              con.step === i - 1,\n          );\n          if (matchingConnection) {\n            const topLineY2 = darkenedY + verticalConnectionOffset;\n            const bottomLineY2 = topLineY2 + connectionHeight(connection);\n            matchingConnection.topLine.y2 = topLineY2;\n            matchingConnection.topLine.x2 = x;\n            matchingConnection.bottomLine.y2 = bottomLineY2;\n            matchingConnection.bottomLine.x2 = x;\n            matchingConnection.path =\n              calculateFlowConnectionPath(matchingConnection);\n\n            verticalConnectionOffset += connectionHeight(connection);\n          }\n        }\n\n        //Data Labels\n        const barName = config.flowConfig.subBucketsConfig.find(\n          sbc => sbc.bucketId === bar.id,\n        )?.bucketName;\n        if (barName !== undefined) {\n          dataLabels.push({\n            elementType: 'dataLabel',\n            dataLabelType: 'flow',\n            label: `${barName} (${percentPipes.pipe.transform(\n              bar.count / data.x[i].totalCount,\n            )})`,\n            xPos: x,\n            yPos:\n              darkenedY -\n              (chartSizingValues.dataLabelTextSize +\n                chartSizingValues.dataLabelPadding) /\n                2,\n            anchor: 'start',\n            bold: true,\n            bucketIndex: i,\n            barId: bar.id,\n          });\n        }\n        const barSubtitle = config.flowConfig.subtitleFormatString.replace(\n          '{value}',\n          valuePipes.pipe.transform(bar.count),\n        );\n        dataLabels.push({\n          elementType: 'dataLabel',\n          dataLabelType: 'flow',\n          label: barSubtitle,\n          xPos: x,\n          yPos: darkenedY - chartSizingValues.dataLabelPadding / 4,\n          anchor: 'start',\n          bucketIndex: i,\n          barId: bar.id,\n        });\n      }\n      bars.push(bucketBars);\n    }\n\n    function hover(pos: {\n      rect: DOMRect;\n      x: number;\n      y: number;\n      containerScrollX: number;\n      containerScrollY: number;\n    }): HoverReturn {\n      const realPosX = pos.x + pos.containerScrollX;\n      const realPosY = pos.y + pos.containerScrollY;\n      if (\n        chartSizingValues === null ||\n        getIfHoverOutOfBounds(\n          pos.x,\n          pos.y,\n          realPosX,\n          realPosY,\n          chartSizingValues,\n          dimensions,\n        )\n      ) {\n        return null;\n      }\n\n      const bucketIndexInfo = getFlowBucketIndexForHover(\n        chartSizingValues,\n        realPosX,\n      );\n      if (bucketIndexInfo === null || bucketIndexInfo.index >= bars.length) {\n        return null;\n      }\n      if (bucketIndexInfo.area === 'bar') {\n        for (const bar of bars[bucketIndexInfo.index]) {\n          if (realPosY < bar.y) {\n            //Bar title\n            const localAnchorX = bar.x - pos.containerScrollX;\n            const width = bar.width;\n            const height =\n              chartSizingValues.dataLabelPadding / 2 +\n              chartSizingValues.dataLabelTextSize;\n            const localAnchorY = bar.y - (pos.containerScrollY + height);\n            const { anchorX, anchorY, anchorWidth, anchorHeight } =\n              checkAnchorsAgainstBound(\n                localAnchorX,\n                localAnchorY,\n                dimensions,\n                width,\n                height,\n              );\n            const anchor = new DOMRect(\n              anchorX + pos.rect.x,\n              anchorY + pos.rect.y,\n              anchorWidth,\n              anchorHeight,\n            );\n            return {\n              hoverType: 'flow',\n              hoverTarget: 'barTitle',\n              barId: bar.id ?? '',\n              bucketIndex: bucketIndexInfo.index,\n              tooltip: {\n                anchor,\n                subtitle: config.flowConfig.subtitleFormatString.replace(\n                  '{value}',\n                  valuePipes.pipe.transform(bar.totalCount),\n                ),\n              },\n            };\n          } else if (\n            // The invisible highlight bar spans both portions, so skip it to\n            // avoid misreporting a portion boundary as the ending portion\n            !bar.nonDisplay &&\n            realPosY >= bar.y &&\n            realPosY < bar.y + bar.height\n          ) {\n            //Bar\n            const localAnchorX = bar.x - pos.containerScrollX;\n            const width = bar.width;\n            const localAnchorY = bar.y - pos.containerScrollY;\n            const height = bar.height;\n            const { anchorX, anchorY, anchorWidth, anchorHeight } =\n              checkAnchorsAgainstBound(\n                localAnchorX,\n                localAnchorY,\n                dimensions,\n                width,\n                height,\n              );\n            const anchor = new DOMRect(\n              anchorX + pos.rect.x,\n              anchorY + pos.rect.y,\n              anchorWidth,\n              anchorHeight,\n            );\n            return {\n              hoverType: 'flow',\n              hoverTarget: 'bar',\n              barId: bar.id ?? '',\n              bucketIndex: bucketIndexInfo.index,\n              forDarken: bar.darken === true,\n              tooltip: {\n                anchor,\n                subtitle: config.flowConfig.subtitleFormatString.replace(\n                  '{value}',\n                  valuePipes.pipe.transform(bar.count),\n                ),\n              },\n            };\n          }\n        }\n      } else {\n        for (const connection of flowConnections.filter(\n          flowCon => flowCon.step === bucketIndexInfo.index,\n        )) {\n          if (checkIfPointWithinConnection(connection, realPosX, realPosY)) {\n            const localAnchorX = connection.topLine.x1 - pos.containerScrollX;\n            const width = connection.topLine.x2 - connection.topLine.x1;\n            const curveTop = bezierYAtX(\n              (connection.topLine.x1 + connection.topLine.x2) / 2,\n              connection.topLine,\n            );\n            const curveBottom = bezierYAtX(\n              (connection.topLine.x1 + connection.topLine.x2) / 2,\n              connection.bottomLine,\n            );\n            const localAnchorY = curveTop - pos.containerScrollY;\n            const height = curveBottom - curveTop;\n            const { anchorX, anchorY, anchorWidth, anchorHeight } =\n              checkAnchorsAgainstBound(\n                localAnchorX,\n                localAnchorY,\n                dimensions,\n                width,\n                height,\n              );\n            const anchor = new DOMRect(\n              anchorX + pos.rect.x,\n              anchorY + pos.rect.y,\n              anchorWidth,\n              anchorHeight,\n            );\n            return {\n              hoverType: 'flow',\n              hoverTarget: 'connection',\n              startId: connection.start,\n              endId: connection.end,\n              startBucketIndex: connection.step,\n              tooltip: {\n                anchor,\n                subtitle: config.flowConfig.subtitleFormatString.replace(\n                  '{value}',\n                  valuePipes.pipe.transform(connection.count),\n                ),\n              },\n            };\n          }\n        }\n      }\n\n      return null;\n    }\n\n    return {\n      chartWidth: chartSizingValues.totalWidth,\n      chartHeight: chartSizingValues.totalHeight,\n      chartSizingValues,\n      xTicks: [],\n      yTicks: [],\n      colors: [],\n      bars,\n      lines: [],\n      circles: [],\n      areas: [],\n      hover,\n      arcs: [],\n      horizontalBars: [],\n      dataLabels,\n      waterfallLines: [],\n      gradients: [],\n      flowConnections,\n      horizontalContainerScale: chartSizingValues.horizontalContainerScale,\n      verticalContainerScale: chartSizingValues.verticalContainerScale,\n      chartError: null,\n    };\n  }\n\n  /*\n    Mirrors the bucketing in flowsTransform: a path contributes values[i] to\n    the bar at step i, and values[i + 1] to its forward connection (which is\n    also the bar's continuing portion).\n  */\n  function flowValueAtStep(y: FlowY, step: number): number | null {\n    return y.steps.length > step && y.values.length > step\n      ? y.values[step]\n      : null;\n  }\n\n  function sumFlowValues(\n    data: FlowData,\n    yIndices: number[],\n    step: number,\n  ): number {\n    return yIndices\n      .map(index => flowValueAtStep(data.ys[index], step) ?? 0)\n      .reduce((a, b) => a + b, 0);\n  }\n\n  export function toFlowClickEvent(\n    hover: FlowHoverTarget,\n    data: FlowData,\n  ): FlowClickEvent {\n    const allYIndices = data.ys.map((_, index) => index);\n    if (hover.hoverTarget === 'connection') {\n      const step = hover.startBucketIndex;\n      const yIndices = allYIndices.filter(\n        index =>\n          data.ys[index].steps[step] === hover.startId &&\n          flowValueAtStep(data.ys[index], step) !== null &&\n          data.ys[index].steps[step + 1] === hover.endId &&\n          flowValueAtStep(data.ys[index], step + 1) !== null,\n      );\n      return {\n        target: 'connection',\n        startBucketIndex: step,\n        startId: hover.startId,\n        endId: hover.endId,\n        count: sumFlowValues(data, yIndices, step + 1),\n        yIndices,\n      };\n    }\n\n    const step = hover.bucketIndex;\n    const barYIndices = allYIndices.filter(\n      index =>\n        data.ys[index].steps[step] === hover.barId &&\n        flowValueAtStep(data.ys[index], step) !== null,\n    );\n    const totalCount = sumFlowValues(data, barYIndices, step);\n    const base = { bucketIndex: step, barId: hover.barId };\n    if (hover.hoverTarget === 'barTitle') {\n      return {\n        ...base,\n        target: 'title',\n        count: totalCount,\n        yIndices: barYIndices,\n      };\n    }\n\n    const continuingCount = sumFlowValues(data, barYIndices, step + 1);\n    if (hover.forDarken) {\n      return {\n        ...base,\n        target: 'continuing',\n        count: continuingCount,\n        totalCount,\n        yIndices: barYIndices.filter(\n          index => (flowValueAtStep(data.ys[index], step + 1) ?? 0) > 0,\n        ),\n      };\n    }\n    return {\n      ...base,\n      target: 'ending',\n      count: totalCount - continuingCount,\n      totalCount,\n      yIndices: barYIndices.filter(\n        index =>\n          (flowValueAtStep(data.ys[index], step) ?? 0) >\n          (flowValueAtStep(data.ys[index], step + 1) ?? 0),\n      ),\n    };\n  }\n\n  const SMALL_PADDING = 8;\n  export const DEFAULT_FONT_SIZE = 12; //the width constants are based on font size 12, so this variable can help w/ scaling\n  export const WIDTH_PER_LETTER = 6.5;\n  const WIDTH_PER_NUMBER = 7;\n  const WIDTH_PER_PERIOD = 2;\n  const WIDTH_PER_SLASH = 4;\n  //When the data axis grows, the data is always given at least this portion of the provided size\n  const GROWN_DATA_MINIMUM_RATIO = 0.5;\n  const DEFAULT_HORIZONTAL_BAR_CORNER_RADIUS = 4;\n  const FLOW_CONNECTION_CURVE_CONSTANT = 0.5;\n\n  function getFormattingAndColors(\n    originalData: NonFlowData,\n    data: NonFlowData,\n    config: Config,\n  ) {\n    const dateFormat = (date: Date) =>\n      formatedDate(config.dateFormat || 'day', date);\n    const { pipe, fullPipe } = getPipes(config.valueType);\n    const { pipe: secondaryPipe, fullPipe: secondaryFullPipe } =\n      config.secondaryValueType\n        ? getPipes(config.secondaryValueType)\n        : {\n            pipe,\n            fullPipe,\n          };\n    const pipeTransform = (\n      value: number,\n      isSecondary: boolean | undefined,\n      isFull?: boolean,\n    ): string => {\n      if (isFull !== true) {\n        if (isSecondary === true) {\n          return secondaryPipe.transform(value);\n        }\n        return pipe.transform(value);\n      }\n      let retVal: string | null = null;\n      if (isSecondary) {\n        retVal = secondaryFullPipe.transform(value);\n      } else {\n        retVal = fullPipe.transform(value);\n      }\n      return retVal !== null ? retVal : '-';\n    };\n\n    // Pre-calculate color indices for all items (use original data for stable colors)\n    const colorIndices = calculateColorIndices(originalData);\n    const colors = data.ys.map(y => getColor(y, colorIndices, config.colors));\n\n    return {\n      dateFormat,\n      pipeTransform,\n      colorIndices,\n      colors,\n    };\n  }\n\n  export function calculateColorIndices(\n    data: NonFlowData,\n  ): Map<DataY | SupplementaryDataY, number> {\n    const colorMap = new Map<DataY | SupplementaryDataY, number>();\n\n    // Original Ys: use their array index directly\n    data.ys.forEach((y, index) => {\n      colorMap.set(y, index);\n    });\n\n    // Supplementary Ys: group by supplementalIndex, use position within that group\n    if (hasSupplementaryData(data)) {\n      const suppGroups = new Map<number, SupplementaryDataY[]>();\n\n      data.supplementaryYs.forEach(suppY => {\n        if (!suppGroups.has(suppY.supplementalIndex)) {\n          suppGroups.set(suppY.supplementalIndex, []);\n        }\n        suppGroups.get(suppY.supplementalIndex)!.push(suppY);\n      });\n\n      suppGroups.forEach(items => {\n        items.forEach((item, positionInGroup) => {\n          colorMap.set(item, positionInGroup);\n        });\n      });\n    }\n\n    return colorMap;\n  }\n\n  export function getColor(\n    item: DataY | SupplementaryDataY | undefined,\n    colorIndices: Map<DataY | SupplementaryDataY, number>,\n    colors: readonly string[],\n  ): string {\n    if (item === undefined) {\n      return colors[0];\n    }\n    if (item.colorToken) return item.colorToken;\n    const colorIndex = colorIndices.get(item) ?? 0;\n    return colors[colorIndex % colors.length];\n  }\n\n  function getBucketTickCount(chartSizingValues: FullChartScaleValues): number {\n    let availableSize = 0;\n    let minSpacing = 1;\n    if (chartSizingValues.chartDataDirection === 'vertical') {\n      availableSize =\n        chartSizingValues.totalWidth -\n        chartSizingValues.leftPadding -\n        chartSizingValues.rightPadding;\n      minSpacing =\n        chartSizingValues.horizontalAxisLabelTextSize + SMALL_PADDING;\n    }\n    if (chartSizingValues.chartDataDirection === 'horizontal') {\n      availableSize =\n        chartSizingValues.totalHeight -\n        chartSizingValues.topPadding -\n        chartSizingValues.bottomPadding;\n      minSpacing = chartSizingValues.verticalAxisLabelTextSize + SMALL_PADDING;\n    }\n    minSpacing = minSpacing * (chartSizingValues.fontSize / DEFAULT_FONT_SIZE);\n    return Math.max(2, Math.floor(availableSize / minSpacing));\n  }\n\n  function getClusterInfoForBucket(\n    data: NonFlowData,\n    config: Config,\n  ): {\n    normCount: number;\n    suppCount: number;\n    total: number;\n    normClusterIndices: number[];\n    suppClusterIndices: number[];\n  } {\n    // Slot layout is the same for every bucket — zero values still occupy\n    // their slot, they just render with no height/width. This keeps bucket\n    // sizes, bar positions, and hover detection consistent across buckets\n    // regardless of which series happen to be zero.\n    const normClusterIndices = data.ys.map((_, yIndex) => yIndex);\n    const normClusterCount = normClusterIndices.length;\n    const suppClusterIndices = uniq(\n      hasSupplementaryData(data)\n        ? data.supplementaryYs.map(y => y.supplementalIndex)\n        : [],\n    );\n    suppClusterIndices.sort((a, b) => a - b);\n\n    const suppClusterCount = suppClusterIndices.length;\n    const actualNormClusterCount = isClusteredData(data, config, false)\n      ? normClusterCount\n      : Math.min(normClusterCount, 1);\n\n    return {\n      normCount: actualNormClusterCount,\n      suppCount: suppClusterCount,\n      total: actualNormClusterCount + suppClusterCount,\n      normClusterIndices,\n      suppClusterIndices,\n    };\n  }\n\n  //This function gives the total distance from the start of the given bucket, to the end of the current bucket\n  function getBucketSize(\n    data: NonFlowData,\n    config: Config,\n    chartSizingValues: FullChartScaleValues,\n  ): number {\n    const totalBarNumber = getClusterInfoForBucket(data, config);\n    const bucketSize =\n      totalBarNumber.total * chartSizingValues.barSize +\n      (totalBarNumber.total - 1) * chartSizingValues.barClusterGap;\n\n    return bucketSize;\n  }\n\n  //This function gives the total distance from the start of the given bucket, to the start of the next bucket\n  function getTotalBucketGap(\n    data: NonFlowData,\n    config: Config,\n    chartSizingValues: FullChartScaleValues,\n  ): number {\n    const bucketSize = getBucketSize(data, config, chartSizingValues);\n    return bucketSize + chartSizingValues.bucketGap;\n  }\n\n  //This function gives the total distance from the start of the first bucket, to the start of the given bucket\n  function getTotalPreBucketGap(\n    data: NonFlowData,\n    config: Config,\n    chartSizingValues: FullChartScaleValues,\n    bucketIndex: number,\n  ): number {\n    let cumulativeBucketGap = 0;\n    for (let i = 0; i < bucketIndex; i++) {\n      cumulativeBucketGap += getTotalBucketGap(data, config, chartSizingValues);\n    }\n    return cumulativeBucketGap;\n  }\n\n  function generateTimeseriesTicks(\n    data: TimeseriesData,\n    config: Config,\n    tickCount: number,\n    chartSizingValues: FullChartScaleValues,\n    format: (date: Date) => string,\n  ): GenericTick[] {\n    const getLabel = (index: number) => {\n      return format(new Date(data.x[index]));\n    };\n    return getTicks(data, getLabel, config, tickCount, chartSizingValues);\n  }\n\n  function generateLabelledTicks(\n    data: LabeledData,\n    config: Config,\n    tickCount: number,\n    chartSizingValues: FullChartScaleValues,\n  ): GenericTick[] {\n    const getLabel = (index: number) => {\n      return data.x[index].label;\n    };\n    return getTicks(data, getLabel, config, tickCount, chartSizingValues);\n  }\n\n  function getTicks(\n    data: NonFlowData,\n    getLabel: (index: number) => string,\n    config: Config,\n    tickCount: number,\n    chartSizingValues: FullChartScaleValues,\n  ): GenericTick[] {\n    if (data.x.length === 0) {\n      return [];\n    }\n    if (data.x.length === 1) {\n      const labelOffset = getTickLabelOffset(\n        data,\n        config,\n        chartSizingValues,\n        0,\n      );\n      return [{ value: labelOffset, label: getLabel(0) }];\n    }\n\n    const lastIndex = data.x.length - 1;\n    const tickBucketSpacing = Math.ceil(lastIndex / tickCount);\n    const numTicks = Math.floor(lastIndex / tickBucketSpacing) + 1;\n    const step = lastIndex / (numTicks - 1);\n\n    // Always include first and last data points.\n    // Inner ticks are approximately evenly spaced using rounding.\n    const indices: number[] = [];\n    for (let i = 0; i < numTicks; i++) {\n      indices.push(Math.round(i * step));\n    }\n\n    return indices.map(i => {\n      const labelOffset = getTickLabelOffset(\n        data,\n        config,\n        chartSizingValues,\n        i,\n      );\n      return {\n        value:\n          getTotalPreBucketGap(data, config, chartSizingValues, i) +\n          labelOffset,\n        label: getLabel(i),\n      };\n    });\n  }\n\n  function getTickLabelOffset(\n    data: NonFlowData,\n    config: Config,\n    chartSizingValues: FullChartScaleValues,\n    bucketIndex: number,\n  ) {\n    const inherentOffset =\n      chartSizingValues.chartDataDirection === 'horizontal'\n        ? chartSizingValues.totalTopOffset\n        : chartSizingValues.totalLeftOffset;\n    //To have the label be centered on the bucket's center position\n    const bucketOffset = getBucketSize(data, config, chartSizingValues) / 2;\n    let horizontalBarOffset = 0;\n    if (chartSizingValues.chartDataDirection === 'horizontal') {\n      //This account for the fact that the inherentOffset and bucketOffset result in matching y values for the bar and the label\n      //  However, for the bar, that y position is the top of the bar, while for the label, it's the bottom of the label\n      //  When exactly lined up like that, the label actually looks a little low, so that -2 makes it look correct\n      horizontalBarOffset = chartSizingValues.fontSize / 2 - 2;\n    }\n\n    return inherentOffset + bucketOffset + horizontalBarOffset;\n  }\n\n  export type InputData = LabeledData | TimeseriesData | FlowData;\n  export type ProcessData = LabeledData | TimeseriesData | ProcessedFlowData;\n  export type NonFlowData = LabeledData | TimeseriesData;\n\n  type BaseData = {\n    ys: DataY[];\n    supplementaryYs?: SupplementaryDataY[];\n  };\n\n  export type Pattern = 'solid' | 'striped' | 'dots';\n\n  export type DataY = {\n    label: string;\n    colorToken?: string;\n    hidden?: boolean;\n    isSecondary?: boolean;\n    pattern?: Pattern;\n    showLegendItem?: boolean;\n    clickable?: boolean;\n    values: number[];\n  };\n\n  export type SupplementaryDataY = DataY & {\n    supplementalIndex: number;\n  };\n\n  export type FlowY = {\n    steps: string[]; //Should always match in length w/ values\n    values: number[]; //FlowY values should always be weakly decreasing\n    clickable?: boolean;\n  };\n\n  //Currently only supported for horizontal bar charts\n  export type LabeledData = BaseData & {\n    type: 'labeled';\n    x: { label: string; isSecondary?: boolean }[];\n  };\n\n  export type TimeseriesData = BaseData & {\n    type: 'timeseries';\n    x: number[];\n  };\n\n  export type FlowData = {\n    type: 'flow';\n    ys: FlowY[];\n  };\n\n  export type ProcessedFlowData = {\n    type: 'flow-processed';\n    x: FlowBucket[];\n  };\n\n  type FlowBucket = {\n    totalCount: number;\n    subBuckets: FlowSubBucket[];\n  };\n\n  type FlowSubBucket = {\n    id: string;\n    count: number;\n    connections: FlowConnection[];\n  };\n\n  type FlowConnection = {\n    direction: 'forward' | 'backward';\n    start: string;\n    end: string;\n    count: number;\n  };\n\n  export type FlowConnectionRender = Omit<FlowConnection, 'direction'> & {\n    elementType: 'connection';\n    step: number;\n    path: string;\n    emphasize?: boolean;\n    topLine: {\n      x1: number;\n      y1: number;\n      x2: number;\n      y2: number;\n    };\n    bottomLine: {\n      x1: number;\n      y1: number;\n      x2: number;\n      y2: number;\n    };\n  };\n\n  type DonutData = {\n    label: string;\n    hidden?: boolean;\n    value: number;\n    isSecondary?: boolean;\n  };\n\n  type Dimensions = {\n    width: number;\n    height: number;\n  };\n\n  export type ChartType =\n    | 'line'\n    | 'area'\n    | 'bar'\n    | 'horizontal-bar'\n    | 'donut'\n    | 'waterfall'\n    | 'funnel'\n    | 'flow';\n\n  type BaseConfig = {\n    type: ChartType;\n    groupedTooltip: boolean;\n    colors: string[];\n    allowLegendToggle: boolean;\n    zeroStateMessage: string;\n    sizingErrorStateMessage: string;\n    valueType: ValueType;\n    secondaryValueType?: ValueType;\n    truncateLegend: boolean;\n    dateFormat?: Interval;\n    showDataLabels?: boolean;\n  };\n\n  type DonutSubConfig = {\n    size: 'xsmall' | 'small' | 'medium' | 'large';\n    displayValue: string;\n    displayLabel?: string;\n    scalingConfig?: DonutSizingConfig;\n  };\n\n  type FlowSubConfig = {\n    subtitleFormatString: string;\n    subBucketsConfig: {\n      bucketId: string;\n      bucketName: string;\n      color: string;\n      isHighlighted?: boolean;\n    }[];\n    connectionColor?: string;\n  };\n\n  export type Config = BaseConfig &\n    (\n      | {\n          type: 'line' | 'area' | 'waterfall' | 'funnel';\n          scalingConfig?: FullScalingConfig;\n        }\n      | {\n          type: 'bar' | 'horizontal-bar';\n          groupingType: 'stacked' | 'clustered';\n          scalingConfig?: FullScalingConfig;\n        }\n      | {\n          type: 'donut';\n          donutDisplayInfo: DonutSubConfig;\n        }\n      | {\n          type: 'flow';\n          showDataLabels: true;\n          flowConfig: FlowSubConfig;\n          scalingConfig?: FullScalingConfig;\n        }\n    );\n\n  type DonutConfig = Extract<Config, { type: 'donut' }>;\n\n  type FlowConfig = Extract<Config, { type: 'flow' }>;\n\n  type ConfigWithFullScaling = Extract<\n    Config,\n    {\n      type:\n        | 'bar'\n        | 'horizontal-bar'\n        | 'line'\n        | 'area'\n        | 'waterfall'\n        | 'funnel'\n        | 'flow';\n    }\n  >;\n\n  export const defaultConfig: Config = {\n    type: 'line',\n    groupedTooltip: true,\n    colors: defaultColorPalette,\n    allowLegendToggle: false,\n    zeroStateMessage: 'No data to display.',\n    sizingErrorStateMessage: 'The chart cannot display at the current size.',\n    valueType: 'currency',\n    truncateLegend: true,\n    dateFormat: 'day',\n  };\n\n  export const defaultDonutConfig: Config = {\n    type: 'donut',\n    groupedTooltip: true,\n    colors: defaultColorPalette,\n    allowLegendToggle: false,\n    zeroStateMessage: 'No data to display.',\n    sizingErrorStateMessage: 'The chart cannot display at the current size.',\n    valueType: 'currency',\n    truncateLegend: true,\n    dateFormat: 'day',\n    donutDisplayInfo: {\n      size: 'medium',\n      displayValue: '',\n    },\n  };\n\n  type GenericTick = {\n    value: number;\n    label: string;\n    secondaryLabel?: string;\n  };\n\n  type XTick = Omit<GenericTick, 'value'> & {\n    x: number;\n  };\n\n  function toXTick(tick: GenericTick): XTick {\n    return {\n      x: tick.value,\n      label: tick.label,\n      secondaryLabel: tick.secondaryLabel,\n    };\n  }\n\n  type YTick = Omit<GenericTick, 'value'> & {\n    y: number;\n  };\n\n  function toYTick(tick: GenericTick): YTick {\n    return {\n      y: tick.value,\n      label: tick.label,\n      secondaryLabel: tick.secondaryLabel,\n    };\n  }\n\n  type BasicRect = {\n    elementType: 'rect';\n    rectType?: string;\n    x: number;\n    y: number;\n    width: number;\n    height: number;\n    offset?: number;\n    pattern?: Pattern;\n    rounding?: 'top' | 'bottom' | 'all' | 'none';\n    nonDisplay?: boolean;\n  };\n\n  type FlowRect = BasicRect & {\n    rectType: 'flow';\n    id: string;\n    bucketIndex: number;\n    count: number;\n    totalCount: number;\n    colorOverride?: string;\n    darken: boolean;\n    deEmphasize: boolean;\n  };\n\n  export type Rect = (BasicRect & { rectType?: undefined }) | FlowRect;\n\n  type Circle = {\n    cx: number;\n    cy: number;\n  };\n\n  export type FlowHoverTarget =\n    | {\n        hoverTarget: 'barTitle';\n        bucketIndex: number;\n        barId: string;\n      }\n    | {\n        hoverTarget: 'bar';\n        bucketIndex: number;\n        barId: string;\n        forDarken: boolean;\n      }\n    | {\n        hoverTarget: 'connection';\n        startId: string;\n        endId: string;\n        startBucketIndex: number;\n      };\n\n  export type FlowHoverReturn = {\n    hoverType: 'flow';\n\n    tooltip: {\n      anchor: DOMRect;\n      subtitle: string;\n      secondarySubtitle?: string;\n    };\n  } & FlowHoverTarget;\n\n  /**\n   * Emitted when a clickable flow element is clicked. `yIndices` are the\n   * indices into `FlowData.ys` of the paths that make up the clicked element.\n   */\n  export type FlowClickEvent = {\n    count: number;\n    yIndices: number[];\n  } & (\n    | ({\n        bucketIndex: number;\n        barId: string;\n      } & (\n        | {\n            target: 'title';\n          }\n        | {\n            target: 'continuing' | 'ending';\n            totalCount: number;\n          }\n      ))\n    | {\n        target: 'connection';\n        startBucketIndex: number;\n        startId: string;\n        endId: string;\n      }\n  );\n\n  export type HoverReturn =\n    | {\n        hoverType: 'standard';\n        // the indices into the data of the closest point\n        xIndex: number;\n        // we want to know which visible y index is hovered\n        // and which actual y index is hovered\n        yIndex: number;\n        visibleYIndex: number;\n        isSuppValue?: boolean;\n        suppYIndex?: number;\n        //Funnel only, for when dropOff section is hovered\n        isDropOff?: boolean;\n\n        // the viewport x and ys of the hovered items\n        x: number;\n        ys: number[];\n\n        tooltip: {\n          anchor: DOMRect;\n          preferredPosition?: CalloutComponent.AnchoredPosition;\n          date: string | null;\n          metrics: {\n            color: string;\n            label: string;\n            value: string;\n            pattern?: Pattern;\n          }[];\n        };\n      }\n    | FlowHoverReturn\n    | null;\n\n  // Hover is a function that takes a viewport x and y and returns a rich\n  // set of information about what values are being hovered and what the tooltip\n  // should look like\n  export type Hover = (pos: {\n    rect: DOMRect;\n    x: number;\n    y: number;\n    containerScrollX: number;\n    containerScrollY: number;\n  }) => HoverReturn;\n\n  export type TooltipContext = {\n    xIndex: number;\n    yIndex: number;\n    isSuppValue?: boolean;\n    suppYIndex?: number;\n  };\n\n  // RenderedChart represents all of the parts of a chart\n  // that end up on screen. Every chart has x and y ticks\n  // and hover functionality, even though they might be\n  // different from chart to chart.\n  export type RenderedChart = {\n    chartWidth: number;\n    chartHeight: number;\n    chartSizingValues: FullChartScaleValues;\n    xTicks: XTick[];\n    yTicks: YTick[];\n    hover?: Hover;\n    colors: string[];\n    lines: { pattern?: Pattern; line: string | null }[];\n    circles: Circle[]; //Line fallback for a single point\n    areas: { pattern?: Pattern; area: string | null }[];\n    bars: Rect[][];\n    arcs: (string | null)[];\n    horizontalBars: {\n      pattern?: Pattern;\n      horizontalBar: string | null;\n      x: number;\n      y: number;\n    }[][];\n    dataLabels: DataLabel[];\n    waterfallLines: {\n      x1: number;\n      x2: number;\n      y1: number;\n      y2: number;\n    }[];\n    gradients: Rect[][];\n    flowConnections: FlowConnectionRender[];\n    horizontalContainerScale: ContainerScalingType;\n    verticalContainerScale: ContainerScalingType;\n    chartError: 'sizing' | 'config' | null;\n  };\n\n  type BasicDataLabel = {\n    elementType: 'dataLabel';\n    dataLabelType?: string;\n    label: string;\n    xPos: number;\n    yPos: number;\n    anchor: 'start' | 'middle' | 'end';\n    line?: {\n      x1: number;\n      y1: number;\n      x2: number;\n      y2: number;\n    };\n    bold?: boolean;\n  };\n\n  type FlowDataLabel = BasicDataLabel & {\n    elementType: 'dataLabel';\n    dataLabelType: 'flow';\n    //Helper data for flows\n    bucketIndex: number;\n    barId: string;\n  };\n\n  export type DataLabel =\n    | (BasicDataLabel & { dataLabelType?: undefined })\n    | FlowDataLabel;\n\n  const emptyChart: RenderedChart = {\n    chartWidth: 0,\n    chartHeight: 0,\n    chartSizingValues: emptyChartScaleValues,\n    xTicks: [],\n    yTicks: [],\n    colors: [],\n    lines: [],\n    circles: [],\n    areas: [],\n    bars: [],\n    arcs: [],\n    horizontalBars: [],\n    dataLabels: [],\n    waterfallLines: [],\n    gradients: [],\n    flowConnections: [],\n    horizontalContainerScale: 'no-scale',\n    verticalContainerScale: 'no-scale',\n    chartError: null,\n  };\n\n  //'y' in this function refers to the data y, since this function\n  // is also used by horizontal-bars, where the data y is the chart x\n  function calcDataAxisScalesAndTicks(\n    data: ProcessData,\n    pipeTransformInput:\n      | ((value: number, isSecondary: boolean) => string)\n      | null,\n    config: Config,\n    chartSizingValues: FullChartScaleValues,\n  ): {\n    scale: (input: number, isSecondary: boolean | undefined) => number;\n    ticks: GenericTick[];\n  } {\n    const pipeTransform =\n      pipeTransformInput !== null ? pipeTransformInput : () => '';\n    const {\n      primaryDataMin,\n      primaryDataMax,\n      secondaryDataMin,\n      secondaryDataMax,\n      scaleDomainMultipleForMax,\n      scaleDomainMultipleForNeg,\n    } = calcDataScalingValues(data, config);\n    const startOffset =\n      chartSizingValues.chartDataDirection === 'horizontal'\n        ? chartSizingValues.totalLeftOffset\n        : chartSizingValues.totalTopOffset;\n    let minSpacing =\n      (chartSizingValues.chartDataDirection === 'horizontal'\n        ? chartSizingValues.horizontalAxisLabelTextSize\n        : chartSizingValues.verticalAxisLabelTextSize) + SMALL_PADDING;\n    minSpacing = minSpacing * (chartSizingValues.fontSize / DEFAULT_FONT_SIZE);\n    const spacingTickCount = Math.max(\n      2,\n      Math.floor(chartSizingValues.sizeForData / minSpacing),\n    );\n    const actualTargetTickCount = Math.min(\n      spacingTickCount,\n      chartSizingValues.targetTickCount,\n    );\n\n    const hasPrimary = primaryDataMin !== 0 || primaryDataMax !== 0;\n    const hasSecondary = secondaryDataMin !== 0 || secondaryDataMax !== 0;\n    const scaleRange =\n      chartSizingValues.chartDataDirection === 'horizontal' ||\n      config.type === 'flow'\n        ? [0, chartSizingValues.sizeForData]\n        : [chartSizingValues.sizeForData, 0];\n    //These 'effective' values ensure we have room for potential stacking of secondary and non-secondary values\n    let effectivePrimaryMin = primaryDataMin * scaleDomainMultipleForNeg;\n    let effectivePrimaryMax = primaryDataMax * scaleDomainMultipleForMax;\n\n    //Simpler path for data w/o secondaries\n    if (!hasSecondary) {\n      const primaryYDomain = [effectivePrimaryMin, effectivePrimaryMax];\n\n      const yScale = scaleLinear(primaryYDomain, scaleRange);\n      const ticks: GenericTick[] = yScale\n        .ticks(actualTargetTickCount)\n        .map(tick => ({\n          value: yScale(tick) + startOffset,\n          label: pipeTransform(tick, false),\n        }));\n      const scale = (input: number): number => {\n        return yScale(input) + startOffset;\n      };\n      return {\n        scale,\n        ticks,\n      };\n    }\n    //Simpler path for data w/o primaries\n    if (!hasPrimary) {\n      const secondaryYDomain = [secondaryDataMin, secondaryDataMax];\n\n      const yScale = scaleLinear(secondaryYDomain, scaleRange);\n      const ticks: GenericTick[] = yScale\n        .ticks(actualTargetTickCount)\n        .map(tick => ({\n          value: yScale(tick) + startOffset,\n          label: pipeTransform(tick, true),\n        }));\n      const scale = (input: number): number => {\n        return yScale(input) + startOffset;\n      };\n      return {\n        scale,\n        ticks,\n      };\n    }\n    let effectiveSecondaryMax = 0;\n    let effectiveSecondaryMin = 0;\n\n    //This block sets the effective max for primary and secondary\n    //This to ensure that the effective maxes for both data sets are properly set so that\n    // 0 will fall at the same place on both and each will have 'room' for potential stacking\n    if (\n      (primaryDataMax <= 0 && secondaryDataMin >= 0) ||\n      (primaryDataMin >= 0 && secondaryDataMax <= 0)\n    ) {\n      //In this scenario, one set of data is competely positive, while the other is completely negative\n      //The two data sets can scale completely independently\n      //We 'mirror' the values of the two data sets, which'll put the 0 axis in the center of the data\n      if (primaryDataMax <= 0) {\n        effectivePrimaryMax = Math.abs(effectivePrimaryMin);\n      }\n      if (primaryDataMin >= 0) {\n        effectivePrimaryMin = -Math.abs(effectivePrimaryMax);\n      }\n      if (secondaryDataMax <= 0) {\n        effectiveSecondaryMin = secondaryDataMin;\n        effectiveSecondaryMax = Math.abs(secondaryDataMin);\n      }\n      if (secondaryDataMin >= 0) {\n        effectiveSecondaryMax = secondaryDataMax;\n        effectiveSecondaryMin = -secondaryDataMax;\n      }\n    } else if (primaryDataMax > 0) {\n      if (primaryDataMin < 0) {\n        //Primary data has positive and negative\n        if (secondaryDataMax > 0) {\n          //Secondary data has positive\n          effectiveSecondaryMax = secondaryDataMax * scaleDomainMultipleForMax;\n          if (secondaryDataMin < 0) {\n            //Secondary data has negative\n            effectiveSecondaryMin =\n              secondaryDataMin * scaleDomainMultipleForNeg;\n          } else {\n            //Secondary data is only positive\n            effectiveSecondaryMin =\n              (secondaryDataMax / primaryDataMax) *\n              primaryDataMin *\n              scaleDomainMultipleForNeg;\n          }\n        } else {\n          //Secondary data has only negative\n          effectiveSecondaryMin = secondaryDataMin * scaleDomainMultipleForNeg;\n          effectiveSecondaryMax =\n            (secondaryDataMin / primaryDataMin) *\n            primaryDataMax *\n            scaleDomainMultipleForMax;\n        }\n      } else {\n        //Primary data is only positive\n        //Due to earlier check, we know that secondary data is either also all-positive, or positive and negative\n        effectiveSecondaryMax = secondaryDataMax * scaleDomainMultipleForMax;\n        effectiveSecondaryMin = secondaryDataMin * scaleDomainMultipleForNeg;\n        effectivePrimaryMin =\n          (primaryDataMax / secondaryDataMax) *\n          secondaryDataMin *\n          scaleDomainMultipleForNeg;\n      }\n    } else {\n      //Primary data is only negative\n      //Due to earlier check, we know that secondary data is either also all-negative, or positive and negative\n      effectiveSecondaryMax = secondaryDataMax * scaleDomainMultipleForMax;\n      effectiveSecondaryMin = secondaryDataMin * scaleDomainMultipleForNeg;\n      effectivePrimaryMax =\n        (primaryDataMin / secondaryDataMin) *\n        secondaryDataMax *\n        scaleDomainMultipleForMax;\n    }\n    const primaryYDomain = [effectivePrimaryMin, effectivePrimaryMax];\n\n    const yScale = scaleLinear(primaryYDomain, scaleRange);\n\n    //Figuring out the best tick count to fit the two data srouces\n    const yScalePrimaryProto = scaleLinear(primaryYDomain, scaleRange);\n    const yScaleSecondaryProto = scaleLinear(\n      [effectiveSecondaryMin, effectiveSecondaryMax],\n      scaleRange,\n    );\n    const tickCount = Math.max(\n      actualTargetTickCount,\n      yScalePrimaryProto.ticks(actualTargetTickCount).length,\n      yScaleSecondaryProto.ticks(actualTargetTickCount).length,\n    );\n    const primaryTicks = yScale.ticks(tickCount).map(tick => ({\n      value: yScale(tick) + startOffset,\n      label: pipeTransform(tick, false),\n      rawY: tick,\n    }));\n\n    //Finding a domain for the secondary data such that it will result in round tick values when matched with the primary ticks\n    const secondaryTicksProto = yScaleSecondaryProto\n      .ticks(tickCount)\n      .map(tick => ({\n        y: yScaleSecondaryProto(tick),\n        rawY: tick,\n        label: pipeTransform(tick, true),\n      }));\n    const primaryMinTick = Math.min(...primaryTicks.map(tick => tick.rawY));\n    const primaryMaxTick = Math.max(...primaryTicks.map(tick => tick.rawY));\n    const primaryDomainMaxTickRatio =\n      primaryMaxTick !== 0 ? effectivePrimaryMax / primaryMaxTick : 0;\n    const primaryDomainMinTickRatio =\n      primaryMinTick !== 0 ? effectivePrimaryMin / primaryMinTick : 0;\n\n    const primaryGap = primaryTicks[1].rawY - primaryTicks[0].rawY;\n    const ticksBelowZero = primaryMinTick / primaryGap;\n    const ticksAboveZero = primaryMaxTick / primaryGap;\n\n    const secondaryGap =\n      secondaryTicksProto[1].rawY - secondaryTicksProto[0].rawY;\n    let calcRangeMult = 1;\n    const secondaryDomainMinMult =\n      ticksBelowZero * secondaryGap * primaryDomainMinTickRatio;\n    const secondaryDomainMaxMult =\n      ticksAboveZero * secondaryGap * primaryDomainMaxTickRatio;\n    //First, we ensure the calcRangeMult is big enough\n    let sizeUpComplete = false;\n    while (!sizeUpComplete) {\n      const calcRangeTooSmallForMin =\n        secondaryDomainMinMult * calcRangeMult > effectiveSecondaryMin &&\n        secondaryDomainMinMult !== 0;\n      const calcRangeTooSmallForMax =\n        secondaryDomainMaxMult * calcRangeMult < effectiveSecondaryMax &&\n        secondaryDomainMaxMult !== 0;\n      if (calcRangeTooSmallForMin || calcRangeTooSmallForMax) {\n        calcRangeMult = calcRangeMult * 2;\n      } else {\n        sizeUpComplete = true;\n      }\n    }\n    //Then, we check if we can scale down (for this one, both conditions have to be true, so it won't undo a previous scale up)\n    let sizeDownComplete = false;\n    while (!sizeDownComplete) {\n      const calcRangeTooBigForMin =\n        secondaryDomainMinMult * calcRangeMult < effectiveSecondaryMin * 2 &&\n        secondaryDomainMinMult !== 0;\n      const calcRangeTooBigForMax =\n        secondaryDomainMaxMult * calcRangeMult > effectiveSecondaryMax * 2 &&\n        secondaryDomainMaxMult !== 0;\n      if (calcRangeTooBigForMin && calcRangeTooBigForMax) {\n        calcRangeMult = calcRangeMult / 2;\n      } else {\n        sizeDownComplete = true;\n      }\n    }\n    let secondaryDomainMin = secondaryDomainMinMult * calcRangeMult;\n    let secondaryDomainMax = secondaryDomainMaxMult * calcRangeMult;\n    //If the data is lopsided enough, it's possible that one of positive/negative have values, but no ticks\n    if (secondaryDomainMin === 0 && effectivePrimaryMin < 0) {\n      const posSecRatio = secondaryDomainMax / effectivePrimaryMax;\n      secondaryDomainMin = posSecRatio * effectivePrimaryMin;\n    }\n    if (secondaryDomainMax === 0 && effectivePrimaryMax > 0) {\n      const posSecRatio = secondaryDomainMin / effectivePrimaryMin;\n      secondaryDomainMax = posSecRatio * effectivePrimaryMax;\n    }\n    const yScaleSecondary = scaleLinear(\n      [secondaryDomainMin, secondaryDomainMax],\n      scaleRange,\n    );\n\n    const ticks: GenericTick[] = primaryTicks.map(tick => ({\n      ...tick,\n      secondaryLabel: pipeTransform(\n        yScaleSecondary.invert(yScale(tick.rawY)),\n        true,\n      ),\n    }));\n\n    const scale = (input: number, isSecondary: boolean | undefined): number => {\n      if (isSecondary) {\n        return yScaleSecondary(input) + startOffset;\n      }\n      return yScale(input) + startOffset;\n    };\n    return {\n      scale,\n      ticks,\n    };\n  }\n\n  function calcDataScalingValues(data: ProcessData, config: Config) {\n    const isStacked = isStackedData(config);\n    const primaryDomainValues = calcYScaleDomainValues(data, isStacked, false);\n    const secondaryDomainValues = calcYScaleDomainValues(data, isStacked, true);\n    const primaryDataMax = Math.max(...primaryDomainValues.map(val => val.max));\n    const secondaryDataMax = Math.max(\n      ...secondaryDomainValues.map(val => val.max),\n    );\n    const primaryDataMin = Math.min(...primaryDomainValues.map(val => val.min));\n    const secondaryDataMin = Math.min(\n      ...secondaryDomainValues.map(val => val.min),\n    );\n    let scaleDomainMultipleForMax = 1;\n    let scaleDomainMultipleForNeg = 1;\n\n    //Calculating how much we need to multiple the domain by to 'fit' both axes' data\n    if (isStacked) {\n      for (let i = 0; i < primaryDomainValues.length; i++) {\n        //Check positive max\n        const primaryVal = primaryDomainValues[i].max;\n        const secondaryVal = secondaryDomainValues[i].max;\n        const primaryRatio =\n          primaryDataMax !== 0 ? primaryVal / primaryDataMax : 0;\n        const secondaryRatio =\n          secondaryDataMax !== 0 ? secondaryVal / secondaryDataMax : 0;\n        const multVal = primaryRatio + secondaryRatio;\n        if (multVal > scaleDomainMultipleForMax) {\n          scaleDomainMultipleForMax = multVal;\n        }\n\n        //Check negative min\n        const primaryNegVal =\n          primaryDomainValues[i].min < 0 ? primaryDomainValues[i].min : 0;\n        const secondaryNegVal =\n          secondaryDomainValues[i].min < 0 ? secondaryDomainValues[i].min : 0;\n        const primaryNegRatio =\n          primaryDataMin !== 0 ? primaryNegVal / primaryDataMin : 0;\n        const secondaryNegRatio =\n          secondaryDataMin !== 0 ? secondaryNegVal / secondaryDataMin : 0;\n        const negMultVal = primaryNegRatio + secondaryNegRatio;\n        if (negMultVal > scaleDomainMultipleForNeg) {\n          scaleDomainMultipleForNeg = negMultVal;\n        }\n      }\n    }\n\n    return {\n      primaryDataMin,\n      primaryDataMax,\n      secondaryDataMin,\n      secondaryDataMax,\n      scaleDomainMultipleForMax,\n      scaleDomainMultipleForNeg,\n    };\n  }\n\n  function calcYScaleDomainValues(\n    data: ProcessData,\n    isStacked: boolean,\n    forSecondary: boolean,\n  ): { max: number; min: number }[] {\n    if (data.type === 'flow-processed') {\n      if (forSecondary) {\n        //Flow charts don't support secondary data\n        return [{ min: 0, max: 0 }];\n      }\n      return [\n        {\n          min: 0,\n          max: Math.max(...data.x.map(x => x.totalCount)),\n        },\n      ];\n    }\n    const possiblyStackedYs = data.ys.map((y, yIndex) => {\n      //Handle stacking\n      return isStacked\n        ? y.values.map((val, xIndex) => {\n            let prevRunningTotal = 0;\n            for (let yI = 0; yI < yIndex; yI++) {\n              if (checkIfSecondary(data, yI, xIndex, false) !== forSecondary) {\n                continue;\n              }\n              const addVal = data.ys[yI].values[xIndex];\n              //Only stack values of the same sign\n              if (addVal < 0 === val < 0) {\n                prevRunningTotal += addVal;\n              }\n            }\n            return val + prevRunningTotal;\n          })\n        : y.values;\n    });\n    const suppYs = hasSupplementaryData(data) ? data.supplementaryYs : null;\n    let possiblyStackedSupYs: number[][] = [];\n    if (suppYs) {\n      possiblyStackedSupYs = suppYs.map((y, yIndex) => {\n        //Handle stacking\n        return isStacked\n          ? y.values.map((val, xIndex) => {\n              let prevRunningTotal = 0;\n              for (let yI = 0; yI < yIndex; yI++) {\n                if (\n                  checkIfSecondary(data, yI, xIndex, true) !== forSecondary ||\n                  suppYs[yI].supplementalIndex !== y.supplementalIndex\n                ) {\n                  continue;\n                }\n                const addVal = suppYs[yI].values[xIndex];\n                //Only stack values of the same sign\n                if (addVal < 0 === val < 0) {\n                  prevRunningTotal += addVal;\n                }\n              }\n              return val + prevRunningTotal;\n            })\n          : y.values;\n      });\n    }\n\n    const scaleRange: { max: number; min: number }[] = [];\n    for (let i = 0; i < data.x.length; i++) {\n      const maxNormY = Math.max(\n        ...possiblyStackedYs.map((y, yIndex) => {\n          if (checkIfSecondary(data, yIndex, i, false) !== forSecondary) {\n            return 0;\n          }\n          return y[i];\n        }),\n      );\n      const minNormY = Math.min(\n        ...possiblyStackedYs.map((y, yIndex) => {\n          if (checkIfSecondary(data, yIndex, i, false) !== forSecondary) {\n            return 0;\n          }\n          return y[i];\n        }),\n      );\n      const maxSupY = suppYs\n        ? Math.max(\n            ...possiblyStackedSupYs.map((y, yIndex) => {\n              if (checkIfSecondary(data, yIndex, i, true) !== forSecondary) {\n                return 0;\n              }\n              return y[i];\n            }),\n          )\n        : 0;\n      const minSupY = suppYs\n        ? Math.min(\n            ...possiblyStackedSupYs.map((y, yIndex) => {\n              if (checkIfSecondary(data, yIndex, i, true) !== forSecondary) {\n                return 0;\n              }\n              return y[i];\n            }),\n          )\n        : 0;\n      const max =\n        maxNormY > 0 && maxNormY > maxSupY\n          ? maxNormY\n          : maxSupY > 0\n          ? maxSupY\n          : 0;\n      const min =\n        minNormY < 0 && minNormY < minSupY\n          ? minNormY\n          : minSupY < 0\n          ? minSupY\n          : 0;\n      scaleRange.push({ max, min });\n    }\n    return scaleRange;\n  }\n\n  function calculateBarPosition(\n    data: NonFlowData,\n    config: Config,\n    chartSizingValues: FullChartScaleValues,\n    bucketNum: number,\n    clusterNum: number,\n  ): number {\n    const offset =\n      chartSizingValues.chartDataDirection === 'vertical'\n        ? chartSizingValues.totalLeftOffset\n        : chartSizingValues.totalTopOffset;\n    const clusterOffset =\n      clusterNum *\n      (chartSizingValues.barSize + chartSizingValues.barClusterGap);\n    const cumulativeBucketGap = getTotalPreBucketGap(\n      data,\n      config,\n      chartSizingValues,\n      bucketNum,\n    );\n    return offset + cumulativeBucketGap + clusterOffset;\n  }\n\n  function calculateHorizontalBarPath(\n    leftSideRound: boolean,\n    rightSideRound: boolean,\n    xValue: number,\n    yValue: number,\n    horR: number,\n    verR: number,\n    height: number,\n    width: number,\n  ): string {\n    if (leftSideRound && rightSideRound) {\n      //Both-sides rounding variation\n      const pathD = `\n        M ${xValue + horR},${yValue}\n        h ${width - horR * 2}\n        q${horR},0 ${horR},${verR}\n        v ${height - verR * 2}\n        q0,${verR} -${horR},${verR}\n        h ${-(width - horR * 2)}\n        q-${horR},0 -${horR},-${verR}\n        v -${height - verR * 2}\n        q0,-${verR} ${horR},-${verR}\n        Z\n      `;\n      return pathD;\n    }\n    if (leftSideRound) {\n      //Left-side rounding variation\n      const pathD = `\n        M ${xValue + horR},${yValue}\n        h ${width - horR}\n        v ${height}\n        h ${-(width - horR)}\n        q-${horR},0 -${horR},-${verR}\n        v -${height - verR * 2}\n        q0,-${verR} ${horR},-${verR}\n        Z\n      `;\n      return pathD;\n    }\n    if (rightSideRound) {\n      //Right-side rounding variation\n      const pathD = `\n        M ${xValue},${yValue}\n        h ${width - horR}\n        q${horR},0 ${horR},${verR}\n        v ${height - verR * 2}\n        q0,${verR} -${horR},${verR}\n        h ${-(width - horR)}\n        Z\n      `;\n      return pathD;\n    }\n    //No-rounding variation\n    const pathD = `\n      M ${xValue},${yValue}\n      h ${width}\n      v ${height}\n      h ${-width}\n      v -${height}\n      Z\n    `;\n    return pathD;\n  }\n\n  function getBucketAndClusterNumForHover(\n    pos: number,\n    chartSizingValues: FullChartScaleValues,\n    data: NonFlowData,\n    config: Config,\n    bucketCount: number,\n  ): {\n    bucketNum: number;\n    clusterNum: number;\n    clusterNormCount: number;\n    clusterNumType: 'norm' | 'supp';\n  } | null {\n    let bucketLeeway = chartSizingValues.bucketGap / 4;\n    //if there's only 1 data point, use the outerGap as leeway instead\n    if (data.x.length === 1) {\n      bucketLeeway = chartSizingValues.outerGap / 4;\n    }\n    const barLeeway = chartSizingValues.barClusterGap / 2;\n\n    const offset =\n      chartSizingValues.chartDataDirection === 'vertical'\n        ? chartSizingValues.totalLeftOffset\n        : chartSizingValues.totalTopOffset;\n    const relativePos = pos - offset;\n    let bucketNum = -1;\n    for (let i = 0; i < bucketCount; i++) {\n      const bucketStartPos = getTotalPreBucketGap(\n        data,\n        config,\n        chartSizingValues,\n        i,\n      );\n      if (\n        bucketStartPos - bucketLeeway < relativePos &&\n        bucketStartPos +\n          getBucketSize(data, config, chartSizingValues) +\n          bucketLeeway >\n          relativePos\n      ) {\n        bucketNum = i;\n        break;\n      }\n    }\n    if (bucketNum === -1) {\n      return null;\n    }\n    if (!isClusteredData(data, config, true)) {\n      return {\n        bucketNum,\n        clusterNum: 0,\n        clusterNormCount: 1,\n        clusterNumType: 'norm',\n      };\n    }\n\n    const relativeBucketPos =\n      relativePos -\n      getTotalPreBucketGap(data, config, chartSizingValues, bucketNum);\n    const clusterCount = getClusterInfoForBucket(data, config);\n    let clusterNum = -1;\n    for (let i = 0; i < clusterCount.total; i++) {\n      const barStartPos =\n        (chartSizingValues.barSize + chartSizingValues.barClusterGap) * i;\n      if (\n        barStartPos - barLeeway < relativeBucketPos &&\n        barStartPos + chartSizingValues.barSize + barLeeway > relativeBucketPos\n      ) {\n        clusterNum = i;\n        break;\n      }\n    }\n    if (clusterNum === -1) {\n      return null;\n    }\n    let clusterNumType: 'norm' | 'supp' = 'norm';\n    if (clusterNum >= clusterCount.normCount) {\n      clusterNumType = 'supp';\n    }\n\n    return {\n      bucketNum,\n      clusterNum,\n      clusterNormCount: clusterCount.normCount,\n      clusterNumType,\n    };\n  }\n\n  function findNearestIndexWithSecondary(\n    yInfo: { value: number; isSecondary: boolean }[],\n    yPos: number,\n    scale: (input: number, isSecondary: boolean | undefined) => number,\n  ) {\n    let foundIndex = 0;\n    let currMinDistance = Math.abs(\n      scale(yInfo[0].value, yInfo[0].isSecondary) - yPos,\n    );\n    for (let i = 1; i < yInfo.length; i++) {\n      const newDistance = Math.abs(\n        scale(yInfo[i].value, yInfo[i].isSecondary) - yPos,\n      );\n      if (newDistance < currMinDistance) {\n        foundIndex = i;\n        currMinDistance = newDistance;\n      }\n    }\n    return foundIndex;\n  }\n\n  function getBarYInfo(\n    data: NonFlowData,\n    config: Config,\n    yIndex: number,\n    xIndex: number,\n    scale: (input: number, isSecondary: boolean | undefined) => number,\n    isSupplementary: boolean = false,\n  ): { yValue: number; height: number } {\n    const isStacked = isStackedData(config);\n    const minimumSize = getMinimumDataElementSize(config);\n    const zeroVal = scale(0, true);\n    const yData = getMainOrSuppY(data, yIndex, isSupplementary);\n    const scaleValue = scale(\n      yData.values[xIndex],\n      checkIfSecondary(data, yIndex, xIndex, isSupplementary),\n    );\n    if (scaleValue > zeroVal) {\n      let prevBarHeights = 0;\n      if (isStacked) {\n        for (let i = 0; i < yIndex; i++) {\n          const checkData = getMainOrSuppY(data, i, isSupplementary);\n          //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it\n          if (\n            isSupplementary &&\n            'supplementalIndex' in yData &&\n            'supplementalIndex' in checkData\n          ) {\n            if (yData.supplementalIndex !== checkData.supplementalIndex) {\n              continue;\n            }\n          }\n          const checkValue = scale(\n            checkData.values[xIndex],\n            checkIfSecondary(data, i, xIndex, isSupplementary),\n          );\n          //Skip positive values\n          if (checkValue < zeroVal) {\n            continue;\n          }\n          prevBarHeights += applyMinimumDataElementSize(\n            checkValue - zeroVal,\n            checkData.values[xIndex],\n            minimumSize,\n          );\n        }\n      }\n      const yValue = zeroVal + prevBarHeights;\n      const height = applyMinimumDataElementSize(\n        scaleValue - zeroVal,\n        yData.values[xIndex],\n        minimumSize,\n      );\n      return { yValue, height };\n    }\n    let prevBarHeights = 0;\n    if (isStacked) {\n      for (let i = 0; i < yIndex; i++) {\n        const checkData = getMainOrSuppY(data, i, isSupplementary);\n        //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it\n        if (\n          isSupplementary &&\n          'supplementalIndex' in yData &&\n          'supplementalIndex' in checkData\n        ) {\n          if (yData.supplementalIndex !== checkData.supplementalIndex) {\n            continue;\n          }\n        }\n        const checkValue = scale(\n          checkData.values[xIndex],\n          checkIfSecondary(data, i, xIndex, isSupplementary),\n        );\n        //Skip negative values\n        if (checkValue > zeroVal) {\n          continue;\n        }\n        prevBarHeights += applyMinimumDataElementSize(\n          zeroVal - checkValue,\n          checkData.values[xIndex],\n          minimumSize,\n        );\n      }\n    }\n    const height = applyMinimumDataElementSize(\n      zeroVal - scaleValue,\n      yData.values[xIndex],\n      minimumSize,\n    );\n    const yValue = zeroVal - height - prevBarHeights;\n    return { yValue, height };\n  }\n\n  function getSuppBarYInfoViaYIndex(\n    data: NonFlowData,\n    config: Config,\n    yIndex: number,\n    suppIndex: number,\n    xIndex: number,\n    scale: (input: number, isSecondary: boolean | undefined) => number,\n  ): { yValue: number; height: number } {\n    if (!hasSupplementaryData(data)) {\n      return { yValue: 0, height: 0 };\n    }\n    const suppYs = data.supplementaryYs;\n    // Find supplementary bars with the given supplementalIndex\n    const groupSupps = suppYs.filter(s => s.supplementalIndex === suppIndex);\n    // yIndex refers to which Y series (within the supplemental group) we're looking at\n    if (yIndex >= 0 && yIndex < groupSupps.length) {\n      // Find this supp in the original array\n      const suppInOriginalArray = suppYs.indexOf(groupSupps[yIndex]);\n      return getBarYInfo(\n        data,\n        config,\n        suppInOriginalArray,\n        xIndex,\n        scale,\n        true,\n      );\n    }\n    return { yValue: 0, height: 0 };\n  }\n\n  function getMainOrSuppY(\n    data: NonFlowData,\n    yIndex: number,\n    isSupplementary: boolean,\n  ): DataY | SupplementaryDataY {\n    if (hasSupplementaryData(data) && isSupplementary) {\n      return data.supplementaryYs[yIndex];\n    }\n    return data.ys[yIndex];\n  }\n\n  function getBarXInfo(\n    data: NonFlowData,\n    config: Config,\n    yIndex: number,\n    xIndex: number,\n    scale: (input: number, isSecondary: boolean | undefined) => number,\n    isSupplementary: boolean = false,\n  ): { xValue: number; width: number } {\n    const isStacked = isStackedData(config);\n    const minimumSize = getMinimumDataElementSize(config);\n    const zeroVal = scale(0, true);\n    const yData = getMainOrSuppY(data, yIndex, isSupplementary);\n    const scaleValue = scale(\n      yData.values[xIndex],\n      checkIfSecondary(data, yIndex, xIndex, isSupplementary),\n    );\n    if (scaleValue < zeroVal) {\n      let prevBarWidths = 0;\n      if (isStacked) {\n        for (let i = 0; i < yIndex; i++) {\n          const checkData = getMainOrSuppY(data, i, isSupplementary);\n          //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it\n          if (\n            isSupplementary &&\n            'supplementalIndex' in yData &&\n            'supplementalIndex' in checkData\n          ) {\n            if (yData.supplementalIndex !== checkData.supplementalIndex) {\n              continue;\n            }\n          }\n          const checkVal = scale(\n            checkData.values[xIndex],\n            checkIfSecondary(data, i, xIndex, isSupplementary),\n          );\n          //Skip positive values\n          if (checkVal > zeroVal) {\n            continue;\n          }\n          prevBarWidths += applyMinimumDataElementSize(\n            zeroVal - checkVal,\n            checkData.values[xIndex],\n            minimumSize,\n          );\n        }\n      }\n      const width = applyMinimumDataElementSize(\n        zeroVal - scaleValue,\n        yData.values[xIndex],\n        minimumSize,\n      );\n      const xValue = zeroVal - width - prevBarWidths;\n      return { xValue, width };\n    }\n    let prevBarWidths = 0;\n    if (isStacked) {\n      for (let i = 0; i < yIndex; i++) {\n        const checkData = getMainOrSuppY(data, i, isSupplementary);\n        //Both yData and checkData are definitely SupplementaryDataYs if isSupplementary is true, but they don't realize it\n        if (\n          isSupplementary &&\n          'supplementalIndex' in yData &&\n          'supplementalIndex' in checkData\n        ) {\n          if (yData.supplementalIndex !== checkData.supplementalIndex) {\n            continue;\n          }\n        }\n        const checkVal = scale(\n          checkData.values[xIndex],\n          checkIfSecondary(data, i, xIndex, isSupplementary),\n        );\n        //Skip negative values\n        if (checkVal < zeroVal) {\n          continue;\n        }\n        prevBarWidths += applyMinimumDataElementSize(\n          checkVal - zeroVal,\n          checkData.values[xIndex],\n          minimumSize,\n        );\n      }\n    }\n    const xValue = prevBarWidths + zeroVal;\n    const width = applyMinimumDataElementSize(\n      scaleValue - zeroVal,\n      yData.values[xIndex],\n      minimumSize,\n    );\n    return { xValue, width };\n  }\n\n  function checkIfSecondary(\n    data: NonFlowData,\n    yIndex: number,\n    xIndex: number,\n    isSupplementary: boolean = false,\n  ): boolean {\n    if (data.type === 'labeled') {\n      if (data.x[xIndex].isSecondary === true) {\n        return true;\n      }\n    }\n    return getMainOrSuppY(data, yIndex, isSupplementary).isSecondary === true;\n  }\n\n  function warnUnsupportedPatterns(\n    data: NonFlowData,\n    supportedPatterns: Pattern[],\n    chartType: string,\n  ): void {\n    const allYs: DataY[] = [\n      ...data.ys,\n      ...(hasSupplementaryData(data) ? data.supplementaryYs : []),\n    ];\n    for (const y of allYs) {\n      if (\n        y.pattern &&\n        y.pattern !== 'solid' &&\n        !supportedPatterns.includes(y.pattern)\n      ) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `Heads up! The '${y.pattern}' pattern isn't supported for ${chartType} charts. Falling back to solid.`,\n        );\n      }\n    }\n  }\n\n  function warnFlowData(\n    data: InputData,\n    chartType: string,\n  ): data is NonFlowData {\n    if (data.type === 'flow') {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `Heads up! The 'flow' data type isn't supported for ${chartType} charts.`,\n      );\n      return false;\n    }\n    return true;\n  }\n\n  // hide strips out hidden y values while retaining the original indices\n  // for the remaining visible values\n  function hide(data: NonFlowData): {\n    data: NonFlowData;\n    visibleIndices: number[];\n    visibleSuppIndices: number[];\n  } {\n    const visibleIndices = data.ys\n      .map((y, i) => ({ y, i }))\n      .filter(({ y }) => !y.hidden)\n      .map(({ i }) => i);\n    const visibleSuppIndices = hasSupplementaryData(data)\n      ? data.supplementaryYs\n          .map((y, i) => ({ y, i }))\n          .filter(({ y }) => !y.hidden)\n          .map(({ i }) => i)\n      : [];\n    return {\n      data: {\n        ...data,\n        ys: visibleIndices.map(i => data.ys[i]),\n        supplementaryYs: visibleSuppIndices.map(i => data.supplementaryYs![i]),\n      },\n      visibleIndices,\n      visibleSuppIndices,\n    };\n  }\n\n  function waterfallTransform(\n    data: NonFlowData,\n    isWaterfall: boolean,\n  ): { data: LabeledData; map: Map<DataY, DataY> } {\n    const waterfallMap = new Map<DataY, DataY>();\n    if (data.type === 'timeseries' || !isWaterfall) {\n      return {\n        data: {\n          type: 'labeled',\n          x: [],\n          ys: [],\n        },\n        map: waterfallMap,\n      };\n    }\n    const newData: LabeledData = {\n      ...data,\n      x: [...data.x, { label: 'Total' }],\n      ys: [\n        ...data.ys.map(y => {\n          const newY: DataY = {\n            ...y,\n            values: [...y.values, y.values.reduce((a, b) => a + b, 0)],\n          };\n          waterfallMap.set(newY, y);\n          return newY;\n        }),\n      ],\n    };\n    return {\n      data: newData,\n      map: waterfallMap,\n    };\n  }\n\n  function flowsTransform(\n    config: FlowConfig,\n    data: FlowData,\n  ): ProcessedFlowData {\n    const returnBuckets: FlowBucket[] = [];\n    const maxPathLength = Math.max(...data.ys.map(y => y.steps.length));\n    if (maxPathLength > 0 && maxPathLength < Infinity) {\n      for (let i = 0; i < maxPathLength; i++) {\n        const flowBucket: FlowBucket = {\n          totalCount: 0,\n          subBuckets: [],\n        };\n        for (const y of data.ys) {\n          if (y.values.length > i && y.steps.length > i) {\n            const subBucketId = y.steps[i];\n            const foundSubBucket = flowBucket.subBuckets.find(\n              subBucket => subBucket.id === subBucketId,\n            );\n            let subBucket: FlowSubBucket;\n            if (foundSubBucket !== undefined) {\n              subBucket = foundSubBucket;\n              subBucket.count += y.values[i];\n            } else {\n              subBucket = {\n                id: subBucketId,\n                count: y.values[i],\n                connections: [],\n              };\n              flowBucket.subBuckets.push(subBucket);\n            }\n            flowBucket.totalCount += y.values[i];\n\n            //Fill in backwards connections\n            if (i > 0) {\n              const foundConnection = subBucket.connections.find(\n                connection =>\n                  connection.start === y.steps[i - 1] &&\n                  connection.end === subBucketId &&\n                  connection.direction === 'backward',\n              );\n              if (foundConnection !== undefined) {\n                foundConnection.count += y.values[i];\n              } else {\n                const newConnection: FlowConnection = {\n                  direction: 'backward',\n                  start: y.steps[i - 1],\n                  end: subBucketId,\n                  count: y.values[i],\n                };\n                subBucket.connections.push(newConnection);\n              }\n            }\n\n            //Fill in forwards connections\n            if (i < y.steps.length - 1 && i < y.values.length - 1) {\n              const foundConnection = subBucket.connections.find(\n                connection =>\n                  connection.start === subBucketId &&\n                  connection.end === y.steps[i + 1] &&\n                  connection.direction === 'forward',\n              );\n              if (foundConnection !== undefined) {\n                foundConnection.count += y.values[i + 1];\n              } else {\n                const newConnection: FlowConnection = {\n                  direction: 'forward',\n                  start: subBucketId,\n                  end: y.steps[i + 1],\n                  count: y.values[i + 1],\n                };\n                subBucket.connections.push(newConnection);\n              }\n            }\n          }\n        }\n        returnBuckets.push(flowBucket);\n      }\n    }\n\n    const subBucketOrderingMap = new Map<string, number>();\n    for (let i = 0; i < config.flowConfig.subBucketsConfig.length; i++) {\n      subBucketOrderingMap.set(\n        config.flowConfig.subBucketsConfig[i].bucketId,\n        i,\n      );\n    }\n    const mapGet = (id: string): number => {\n      const foundResult = subBucketOrderingMap.get(id);\n      if (foundResult !== undefined) {\n        return foundResult;\n      }\n      //If something isn't defined in the config, put it at the end\n      return Infinity;\n    };\n\n    //Ensure the data is sorted the same the way the config is, and drop empty\n    //bars/connections so they're neither displayed nor factored into sizing\n    return {\n      type: 'flow-processed',\n      x: returnBuckets.map(bucket => ({\n        ...bucket,\n        subBuckets: bucket.subBuckets\n          .filter(subBucket => subBucket.count !== 0)\n          .sort((a, b) => mapGet(a.id) - mapGet(b.id))\n          .map(subBucket => ({\n            ...subBucket,\n            connections: subBucket.connections\n              .filter(connection => connection.count !== 0)\n              .sort((a, b) => {\n                const firstSort = mapGet(a.start) - mapGet(b.start);\n                if (firstSort !== 0) {\n                  return firstSort;\n                }\n                return mapGet(a.end) - mapGet(b.end);\n              }),\n          })),\n      })),\n    };\n  }\n\n  type ValueType = 'count' | 'currency' | 'percentage' | 'days';\n\n  export function getPipes(valueType: ValueType) {\n    switch (valueType) {\n      case 'count': {\n        return { pipe: new SmallNumberPipe(), fullPipe: new NumberPipe() };\n      }\n      case 'currency':\n        return {\n          pipe: new SmallCurrencyPipe(),\n          fullPipe: new CurrencyPipe('en-us'),\n        };\n      case 'percentage': {\n        const pipe = new PercentagePipe();\n        return { pipe, fullPipe: pipe };\n      }\n      case 'days': {\n        const pipe = new DaysPipe();\n        return { pipe, fullPipe: pipe };\n      }\n    }\n  }\n\n  const intervals = ['year', 'quarter', 'month', 'week', 'day'] as const;\n  export type Interval = (typeof intervals)[number];\n\n  export function formatedDate(dateFormat: Interval, date: Date) {\n    if (dateFormat === 'quarter') {\n      const quarter = Math.ceil((date.getUTCMonth() + 1) / 3);\n      const year = utcFormat(getTimeIntervalFormat('year'))(date);\n      return `Q${quarter} ${year}`;\n    }\n    const format = getTimeIntervalFormat(dateFormat);\n    return utcFormat(format)(date);\n  }\n\n  function getTimeIntervalFormat(interval: Interval): string {\n    switch (interval) {\n      case 'day':\n      case 'week':\n        return '%m/%d/%Y';\n      case 'month':\n      case 'quarter':\n        return '%b %Y';\n      case 'year':\n        return '%Y';\n    }\n  }\n\n  export function convertChartDataToDonutData(\n    chartData: NonFlowData,\n  ): DonutData[] {\n    if (chartData.ys.find(y => y.values.length > 1)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        \"Heads up! Pie charts don't support multiple values per series\",\n      );\n    }\n\n    const donutData = chartData.ys.map(y => ({\n      label: y.label,\n      hidden: y.hidden,\n      value: y.values.length >= 1 ? y.values[0] : 0,\n      isSecondary: y.isSecondary,\n    }));\n    return donutData;\n  }\n\n  function arcToPoint(angle: number, radius: number) {\n    return {\n      x: radius * Math.cos(angle - Math.PI / 2),\n      y: radius * Math.sin(angle - Math.PI / 2),\n    };\n  }\n\n  function pointToArc(x: number, y: number) {\n    const radius = Math.hypot(x, y);\n    let angle = Math.atan2(y, x) + Math.PI / 2;\n    //Normalize to be within range [0, 2π]\n    angle = (angle + 2 * Math.PI) % (2 * Math.PI);\n\n    return {\n      angle,\n      radius,\n    };\n  }\n\n  function getFullChartScaleValues(\n    config: ConfigWithFullScaling,\n    data: ProcessData,\n    dimensions: Dimensions,\n    pipeTransform: ((value: number, isSecondary: boolean) => string) | null,\n    dateFormat: ((date: Date) => string) | null,\n  ): FullChartScaleValues | null {\n    const chartDataDirection = getChartDataDirection(config);\n    const defaultScalingConfig = getDefaultScalingConfigByChartType(\n      config.type,\n      config.secondaryValueType !== undefined,\n    );\n    const scalingConfig = combineScalingInfo(config, defaultScalingConfig);\n    const nonDataAxisValues = calculateNonDataAxisValues(\n      config,\n      scalingConfig,\n      config.scalingConfig?.elementScales,\n      defaultScalingConfig.elementScales,\n      dimensions,\n      data,\n    );\n    const dataAxisValues = calculateDataAxisValues(\n      config,\n      scalingConfig,\n      config.scalingConfig?.elementScales,\n      defaultScalingConfig.elementScales,\n      dimensions,\n      data,\n      pipeTransform,\n      dateFormat,\n    );\n    if (\n      nonDataAxisValues.sizingError === true ||\n      dataAxisValues.sizingError === true\n    ) {\n      return null;\n    }\n    const dataLabelStartPadding =\n      getDataLabelSizingCount(data, config).start *\n      (dataAxisValues.dataLabelPadding + dataAxisValues.dataLabelTextSize);\n    const dataLabelEndPadding =\n      getDataLabelSizingCount(data, config).end *\n      (dataAxisValues.dataLabelPadding + dataAxisValues.dataLabelTextSize);\n\n    return {\n      ...nonDataAxisValues,\n      ...dataAxisValues,\n      leftPadding:\n        chartDataDirection === 'horizontal'\n          ? dataAxisValues.startPadding\n          : nonDataAxisValues.startPadding,\n      rightPadding:\n        chartDataDirection === 'horizontal'\n          ? dataAxisValues.endPadding\n          : nonDataAxisValues.endPadding,\n      topPadding:\n        chartDataDirection === 'horizontal'\n          ? nonDataAxisValues.startPadding\n          : dataAxisValues.startPadding,\n      bottomPadding:\n        chartDataDirection === 'horizontal'\n          ? nonDataAxisValues.endPadding\n          : dataAxisValues.endPadding,\n      totalLeftOffset:\n        chartDataDirection === 'horizontal'\n          ? dataAxisValues.startPadding +\n            dataAxisValues.leftBucketLabel +\n            dataLabelStartPadding\n          : nonDataAxisValues.startPadding + nonDataAxisValues.outerGap,\n      totalRightOffset:\n        chartDataDirection === 'horizontal'\n          ? dataAxisValues.startPadding + dataLabelEndPadding\n          : nonDataAxisValues.endPadding + nonDataAxisValues.outerGap,\n      totalTopOffset:\n        chartDataDirection === 'horizontal'\n          ? nonDataAxisValues.startPadding + nonDataAxisValues.outerGap\n          : dataAxisValues.startPadding + dataLabelStartPadding,\n      totalBottomOffset:\n        chartDataDirection === 'horizontal'\n          ? nonDataAxisValues.endPadding + nonDataAxisValues.outerGap\n          : dataAxisValues.endPadding + dataLabelEndPadding,\n      targetTickCount: scalingConfig.targetTickCount,\n      sizeForData: dataAxisValues.sizeForData,\n      totalWidth:\n        chartDataDirection === 'horizontal'\n          ? dataAxisValues.totalSize\n          : nonDataAxisValues.totalSize,\n      totalHeight:\n        chartDataDirection === 'horizontal'\n          ? nonDataAxisValues.totalSize\n          : dataAxisValues.totalSize,\n      dataLabelTextSize: config.showDataLabels\n        ? dataAxisValues.dataLabelTextSize\n        : 0,\n      horizontalAxisLabelTextSize:\n        chartDataDirection === 'vertical'\n          ? dataAxisValues.bucketLabelTextSize\n          : dataAxisValues.dataLabelTextSize, //Ticks and data labels use the same formatting on the same kind of data\n      verticalAxisLabelTextSize: dataAxisValues.fontSize,\n      chartDataDirection,\n      horizontalContainerScale: scalingConfig.horizontalContainerScale,\n      verticalContainerScale: scalingConfig.verticalContainerScale,\n    };\n  }\n\n  function calculateNonDataAxisValues(\n    config: Config,\n    scalingConfig: NonElementScalingConfig,\n    elementScales: PartialElementScalingConfig | undefined,\n    defaultSizing: FullElementScalingConfig,\n    dimensions: Dimensions,\n    data: ProcessData,\n  ): {\n    barSize: number;\n    barClusterGap: number;\n    bucketGap: number;\n    outerGap: number;\n    startPadding: number;\n    endPadding: number;\n    totalSize: number;\n    sizingError?: boolean;\n  } {\n    const chartDataDirection = getChartDataDirection(config);\n    const boundingDimension =\n      chartDataDirection === 'horizontal'\n        ? dimensions.height\n        : dimensions.width;\n    const axisScale =\n      chartDataDirection === 'horizontal'\n        ? scalingConfig?.verticalAxisScale\n        : scalingConfig?.horizontalAxisScale;\n\n    const barSizeConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'barSize',\n    );\n    const barClusterGapConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'barClusterGap',\n    );\n    const bucketGapConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'bucketGap',\n    );\n    const outerGapConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'outerGap',\n    );\n    const startPaddingConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      chartDataDirection === 'horizontal' ? 'topPadding' : 'leftPadding',\n    );\n    const endPaddingConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      chartDataDirection === 'horizontal' ? 'bottomPadding' : 'rightPadding',\n    );\n\n    const bucketCount = data.x.length;\n    let barCount = 0;\n    let barClusterGapCount = 0;\n    for (let i = 0; i < bucketCount; i++) {\n      if (data.type === 'flow-processed') {\n        barCount += 1;\n      } else {\n        const bucketClusterCount = getClusterInfoForBucket(data, config);\n        barCount += bucketClusterCount.total;\n        barClusterGapCount += bucketClusterCount.total - 1;\n      }\n    }\n    const bucketGapCount = bucketCount - 1;\n\n    const barTotalSize = determinePossibleSizesOfElement(\n      barSizeConfig,\n      barCount,\n    );\n    const clusterGapTotalSize = determinePossibleSizesOfElement(\n      barClusterGapConfig,\n      barClusterGapCount,\n    );\n    const bucketGapTotalSize = determinePossibleSizesOfElement(\n      bucketGapConfig,\n      bucketGapCount,\n    );\n    const outerGapTotalSize = determinePossibleSizesOfElement(\n      outerGapConfig,\n      2,\n    );\n    const startPaddingTotalSize = determinePossibleSizesOfElement(\n      startPaddingConfig,\n      1,\n    );\n    const endPaddingTotalSize = determinePossibleSizesOfElement(\n      endPaddingConfig,\n      1,\n    );\n\n    const calcTargetSize =\n      barTotalSize.target +\n      clusterGapTotalSize.target +\n      bucketGapTotalSize.target +\n      outerGapTotalSize.target +\n      startPaddingTotalSize.target +\n      endPaddingTotalSize.target;\n\n    if (\n      axisScale === 'no-scale' ||\n      calcTargetSize === boundingDimension ||\n      (axisScale === 'grow' && calcTargetSize > boundingDimension) ||\n      (axisScale === 'shrink' && calcTargetSize < boundingDimension)\n    ) {\n      //No element scaling necessary, return everything as it's target value\n      return {\n        barSize: barSizeConfig.target,\n        barClusterGap: barClusterGapConfig.target,\n        bucketGap: bucketGapConfig.target,\n        outerGap: outerGapConfig.target,\n        startPadding: startPaddingConfig.target,\n        endPadding: endPaddingConfig.target,\n        totalSize: calcTargetSize,\n      };\n    }\n\n    const calcMinSize =\n      barTotalSize.min +\n      clusterGapTotalSize.min +\n      bucketGapTotalSize.min +\n      outerGapTotalSize.min +\n      startPaddingTotalSize.min +\n      endPaddingTotalSize.min;\n\n    //Note: This is only actually a max size if all elements have a defined max\n    const calcMaxSize =\n      barTotalSize.max +\n      clusterGapTotalSize.max +\n      bucketGapTotalSize.max +\n      outerGapTotalSize.max +\n      startPaddingTotalSize.max +\n      endPaddingTotalSize.max;\n\n    if (calcMinSize > boundingDimension) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'The provided minimum element sizes mean the chart cannot display at this small of a size',\n      );\n      return {\n        barSize: 0,\n        barClusterGap: 0,\n        bucketGap: 0,\n        outerGap: 0,\n        startPadding: 0,\n        endPadding: 0,\n        totalSize: 0,\n        sizingError: true,\n      };\n    }\n    const configChecks = [\n      getCheckingInfoForElementConfig(barSizeConfig, barCount),\n      getCheckingInfoForElementConfig(barClusterGapConfig, barClusterGapCount),\n      getCheckingInfoForElementConfig(bucketGapConfig, bucketGapCount),\n      getCheckingInfoForElementConfig(outerGapConfig, 2),\n      getCheckingInfoForElementConfig(startPaddingConfig, 1),\n      getCheckingInfoForElementConfig(endPaddingConfig, 1),\n    ];\n    let currScalingFactor = 1;\n    if (calcTargetSize > boundingDimension) {\n      //Scaling down\n      let finalScalingFactorFound = false;\n      while (!finalScalingFactorFound) {\n        const nextScaleFactorBreakpoint = Math.max(\n          ...configChecks\n            .map(check => check.minScaleFactor)\n            .filter(\n              (val): val is number =>\n                val !== undefined && !(val >= currScalingFactor),\n            ),\n          0,\n        );\n        const newScaleFactorSize = getSumForScaleValue(\n          configChecks,\n          nextScaleFactorBreakpoint,\n        );\n\n        if (newScaleFactorSize <= boundingDimension) {\n          //There's a scale value that'll work between the curr and new values\n          //These are the values that'll just be at their min\n          const nonScaleableValues = configChecks.filter(\n            check =>\n              check.minScaleFactor && check.minScaleFactor >= currScalingFactor,\n          );\n          //These are the values that can still be scaled down\n          const scaleableValues = configChecks.filter(\n            check =>\n              !check.minScaleFactor || check.minScaleFactor < currScalingFactor,\n          );\n          const workingSpace =\n            boundingDimension -\n            getSumForScaleValue(nonScaleableValues, currScalingFactor);\n          currScalingFactor =\n            workingSpace / getSumForScaleValue(scaleableValues, 1);\n          finalScalingFactorFound = true;\n        } else {\n          //One of the elements is hitting their minScaleFactor, so for simplicity we'll just go again\n          currScalingFactor = nextScaleFactorBreakpoint;\n\n          //Just in case, though previous checks should make this impossible\n          if (currScalingFactor === 0) {\n            // eslint-disable-next-line no-console\n            console.warn(\n              'The given size cannot contain the fixed sizes given for the elements',\n            );\n            return {\n              barSize: 0,\n              barClusterGap: 0,\n              bucketGap: 0,\n              outerGap: 0,\n              startPadding: 0,\n              endPadding: 0,\n              totalSize: 0,\n              sizingError: true,\n            };\n          }\n        }\n      }\n    } else {\n      //Checking to see if all elements have a defined max\n      const maximumSizePossible =\n        configChecks.filter(check => check.maxScaleFactor === undefined)\n          .length === 0;\n      //If all elements have a defined max, and that max is less than the size we're trying to grow to, it's impossible\n      if (maximumSizePossible && calcMaxSize < boundingDimension) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          'The provided maximum element widths mean the chart cannot display at this large of a size',\n        );\n        return {\n          barSize: 0,\n          barClusterGap: 0,\n          bucketGap: 0,\n          outerGap: 0,\n          startPadding: 0,\n          endPadding: 0,\n          totalSize: 0,\n          sizingError: true,\n        };\n      }\n      //Scaling up\n      let finalScalingFactorFound = false;\n      while (!finalScalingFactorFound) {\n        const nextScaleFactorBreakpoint = Math.min(\n          ...configChecks\n            .map(check => check.maxScaleFactor)\n            .filter(\n              (val): val is number =>\n                val !== undefined && !(val <= currScalingFactor),\n            ),\n        );\n        const newScaleFactorSize = getSumForScaleValue(\n          configChecks,\n          nextScaleFactorBreakpoint,\n        );\n\n        if (\n          newScaleFactorSize >= boundingDimension ||\n          nextScaleFactorBreakpoint === Infinity\n        ) {\n          //There's a scale value that'll work between the curr and new values\n          //These are the values that'll just be at their max\n          const nonScaleableValues = configChecks.filter(\n            check =>\n              check.maxScaleFactor && check.maxScaleFactor <= currScalingFactor,\n          );\n          //These are the values that can still be scaled up\n          const scaleableValues = configChecks.filter(\n            check =>\n              !check.maxScaleFactor || check.maxScaleFactor > currScalingFactor,\n          );\n          const workingSpace =\n            boundingDimension -\n            getSumForScaleValue(nonScaleableValues, currScalingFactor);\n          currScalingFactor =\n            workingSpace / getSumForScaleValue(scaleableValues, 1);\n          finalScalingFactorFound = true;\n        } else {\n          //One of the elements is hitting their maxScaleFactor, so for simplicity we'll just go again\n          currScalingFactor = nextScaleFactorBreakpoint;\n        }\n      }\n    }\n    const barSize = getScaledElementSize(barSizeConfig, currScalingFactor);\n    const barClusterGap = getScaledElementSize(\n      barClusterGapConfig,\n      currScalingFactor,\n    );\n    const bucketGap = getScaledElementSize(bucketGapConfig, currScalingFactor);\n    return {\n      barSize,\n      barClusterGap,\n      bucketGap,\n      outerGap: getScaledElementSize(outerGapConfig, currScalingFactor),\n      startPadding: getScaledElementSize(startPaddingConfig, currScalingFactor),\n      endPadding: getScaledElementSize(endPaddingConfig, currScalingFactor),\n      totalSize: boundingDimension,\n    };\n  }\n\n  function calculateDataAxisValues(\n    config: Config,\n    scalingConfig: NonElementScalingConfig,\n    elementScales: PartialElementScalingConfig | undefined,\n    defaultSizing: FullElementScalingConfig,\n    dimensions: Dimensions,\n    data: ProcessData,\n    pipeTransform: ((value: number, isSecondary: boolean) => string) | null,\n    dateFormat: ((date: Date) => string) | null,\n  ): {\n    startPadding: number;\n    endPadding: number;\n    leftBucketLabel: number;\n    dataLabelTextSize: number;\n    dataLabelPadding: number;\n    fontSize: number;\n    sizeForData: number;\n    totalSize: number;\n    bucketLabelTextSize: number;\n    sizingError?: boolean;\n  } {\n    const chartDataDirection = getChartDataDirection(config);\n    const boundingDimension =\n      chartDataDirection === 'horizontal'\n        ? dimensions.width\n        : dimensions.height;\n    const axisScale =\n      chartDataDirection === 'horizontal'\n        ? scalingConfig.horizontalAxisScale\n        : scalingConfig.verticalAxisScale;\n\n    const startPaddingConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      chartDataDirection === 'horizontal' ? 'leftPadding' : 'topPadding',\n    );\n    const endPaddingConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      chartDataDirection === 'horizontal' ? 'rightPadding' : 'bottomPadding',\n    );\n    const leftLabelConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'leftBucketLabel',\n    );\n    const dataLabelPaddingConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'dataLabelPadding',\n    );\n    const fontSizeConfig = getElementScalingInfo(\n      elementScales,\n      defaultSizing,\n      'fontSize',\n    );\n    const fontSize = fontSizeConfig.target;\n    const dataLabelTextSizing = getDataLabelSize(data, pipeTransform, fontSize);\n    //We always calculate and return dataLabelTextSize, since it's also used for determing axis label size\n    const dataLabelTextSize =\n      chartDataDirection === 'horizontal'\n        ? dataLabelTextSizing.horizontal\n        : dataLabelTextSizing.vertical;\n    const dataLabelFixedSize =\n      dataLabelTextSize * getDataLabelSizingCount(data, config).total;\n    const bucketLabelTextSize = getBucketLabelSize(data, fontSize, dateFormat);\n    //Flow charts have a data label above each sub-bucket\n    const flowLabelSize = dataLabelTextSize + dataLabelPaddingConfig.target;\n\n    const startPaddingTotalSize = determinePossibleSizesOfElement(\n      startPaddingConfig,\n      1,\n    );\n    const endPaddingTotalSize = determinePossibleSizesOfElement(\n      endPaddingConfig,\n      1,\n    );\n    const dataLabelPaddingTotalSize = determinePossibleSizesOfElement(\n      dataLabelPaddingConfig,\n      getDataLabelSizingCount(data, config).total,\n    );\n\n    let leftBucketLabelActualSize = leftLabelConfig.target;\n    if (chartDataDirection === 'horizontal' && data.type === 'labeled') {\n      //For horizontal bars, the start padding will scale based on the bucket labels\n      const longestLabelLength =\n        Math.max(...data.x.map(x => x.label.length)) *\n        (WIDTH_PER_LETTER * (fontSize / DEFAULT_FONT_SIZE));\n      const minLength = leftLabelConfig.min\n        ? Math.max(longestLabelLength, leftLabelConfig.min)\n        : longestLabelLength;\n      leftBucketLabelActualSize = leftLabelConfig.max\n        ? Math.min(minLength, leftLabelConfig.max)\n        : longestLabelLength;\n    }\n\n    let fixedSizeValue =\n      leftBucketLabelActualSize +\n      dataLabelFixedSize +\n      startPaddingTotalSize.target +\n      endPaddingTotalSize.target +\n      dataLabelPaddingTotalSize.target;\n    if (fixedSizeValue > boundingDimension) {\n      //See if further truncating the label can help\n      if (\n        leftLabelConfig.min &&\n        fixedSizeValue - boundingDimension <\n          leftBucketLabelActualSize - leftLabelConfig.min\n      ) {\n        leftBucketLabelActualSize =\n          leftBucketLabelActualSize - (fixedSizeValue - boundingDimension);\n        fixedSizeValue =\n          leftBucketLabelActualSize +\n          startPaddingTotalSize.target +\n          endPaddingTotalSize.target +\n          dataLabelPaddingTotalSize.target;\n      } else if (\n        axisScale !== 'grow' &&\n        (axisScale !== 'no-scale' || scalingConfig.dataScale.type === 'fit')\n      ) {\n        //Growing and non-fitting data axes can scroll instead\n        // eslint-disable-next-line no-console\n        console.warn(\n          'The provided element sizes mean the chart cannot display at this small of a size',\n        );\n        return {\n          startPadding: 0,\n          endPadding: 0,\n          leftBucketLabel: 0,\n          dataLabelTextSize: 0,\n          dataLabelPadding: 0,\n          fontSize: 0,\n          sizeForData: 0,\n          totalSize: 0,\n          bucketLabelTextSize: 0,\n          sizingError: true,\n        };\n      }\n    }\n    if (\n      axisScale === 'scale-to-fit' ||\n      axisScale === 'grow' ||\n      axisScale === 'shrink' ||\n      scalingConfig.dataScale.type === 'fit'\n    ) {\n      //A growing data axis scrolls rather than squeezing the data below its minimum size\n      const availableSize =\n        axisScale === 'grow'\n          ? Math.max(\n              boundingDimension - fixedSizeValue,\n              getMinimumGrownDataSize(\n                data,\n                config,\n                boundingDimension,\n                flowLabelSize,\n              ),\n            )\n          : boundingDimension - fixedSizeValue;\n      const sizeForData = getFittedDataSize(\n        data,\n        config,\n        availableSize,\n        flowLabelSize,\n      );\n      if (sizeForData === null) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          'The provided minimum data element size means the chart cannot display at this small of a size',\n        );\n        return {\n          startPadding: 0,\n          endPadding: 0,\n          leftBucketLabel: 0,\n          dataLabelTextSize: 0,\n          dataLabelPadding: 0,\n          fontSize: 0,\n          sizeForData: 0,\n          totalSize: 0,\n          bucketLabelTextSize: 0,\n          sizingError: true,\n        };\n      }\n      return {\n        startPadding: startPaddingConfig.target,\n        endPadding: endPaddingConfig.target,\n        leftBucketLabel: leftBucketLabelActualSize,\n        dataLabelTextSize,\n        dataLabelPadding: dataLabelPaddingConfig.target,\n        fontSize: fontSizeConfig.target,\n        sizeForData,\n        totalSize: fixedSizeValue + availableSize,\n        bucketLabelTextSize,\n      };\n    }\n\n    const {\n      primaryDataMin,\n      primaryDataMax,\n      scaleDomainMultipleForMax,\n      scaleDomainMultipleForNeg,\n    } = calcDataScalingValues(data, config);\n\n    const effectivePrimaryMaxForScaling =\n      primaryDataMax * scaleDomainMultipleForMax;\n    const effectivePrimaryMinForScaling =\n      primaryDataMin < 0 ? primaryDataMin * scaleDomainMultipleForNeg : 0;\n\n    if (scalingConfig.dataScale.type === 'max') {\n      const dataSize =\n        scalingConfig.dataScale.value *\n        ((effectivePrimaryMaxForScaling - effectivePrimaryMinForScaling) /\n          effectivePrimaryMaxForScaling);\n      return {\n        startPadding: startPaddingConfig.target,\n        endPadding: endPaddingConfig.target,\n        leftBucketLabel: leftBucketLabelActualSize,\n        dataLabelTextSize,\n        dataLabelPadding: dataLabelPaddingConfig.target,\n        fontSize: fontSizeConfig.target,\n        sizeForData: dataSize,\n        totalSize:\n          getScaledDataTotalSize(data, config, dataSize, flowLabelSize) +\n          fixedSizeValue,\n        bucketLabelTextSize,\n      };\n    }\n\n    const dataSize =\n      ((effectivePrimaryMaxForScaling - effectivePrimaryMinForScaling) /\n        scalingConfig.dataScale.ratio.value) *\n      scalingConfig.dataScale.ratio.px;\n    return {\n      startPadding: startPaddingConfig.target,\n      endPadding: endPaddingConfig.target,\n      leftBucketLabel: leftBucketLabelActualSize,\n      dataLabelTextSize,\n      dataLabelPadding: dataLabelPaddingConfig.target,\n      fontSize: fontSizeConfig.target,\n      sizeForData: dataSize,\n      totalSize:\n        getScaledDataTotalSize(data, config, dataSize, flowLabelSize) +\n        fixedSizeValue,\n      bucketLabelTextSize,\n    };\n  }\n\n  //The least space a growing data axis gives the data: a portion of the provided size, on top of the space that\n  // elements enlarged to the minimum size need (so the data stays proportional rather than all being the minimum)\n  function getMinimumGrownDataSize(\n    data: ProcessData,\n    config: Config,\n    boundingDimension: number,\n    labelSize: number,\n  ): number {\n    const minimumElementsSize =\n      data.type === 'flow-processed'\n        ? getMaxFlowBucketSize(\n            data,\n            0,\n            getMinimumDataElementSize(config),\n            labelSize,\n          ) - getFlowMidLabelSize(data, labelSize)\n        : 0;\n    return boundingDimension * GROWN_DATA_MINIMUM_RATIO + minimumElementsSize;\n  }\n\n  //For flow charts, finds the size the data scale should map to so that every bucket (including its own data labels,\n  // and any elements enlarged to the minimum size) fits in the available size\n  //Returns null if the minimum sizes alone can't fit\n  function getFittedDataSize(\n    data: ProcessData,\n    config: Config,\n    availableSize: number,\n    labelSize: number,\n  ): number | null {\n    if (data.type !== 'flow-processed') {\n      return availableSize;\n    }\n    const dataMax = Math.max(...data.x.map(x => x.totalCount));\n    if (dataMax <= 0) {\n      return availableSize;\n    }\n    const minimumSize = getMinimumDataElementSize(config);\n    const bucketAvailableSize =\n      availableSize + getFlowMidLabelSize(data, labelSize);\n    //Calculate what the sizing would need to be for each individual column,\n    //  taking the value that is most restrictive. Not applying minimum size yet\n    const unenlargedRatio = Math.min(\n      ...data.x\n        .filter(bucket => bucket.totalCount > 0)\n        .map(\n          bucket =>\n            (bucketAvailableSize - (bucket.subBuckets.length - 1) * labelSize) /\n            bucket.totalCount,\n        ),\n    );\n    if (\n      minimumSize === 0 ||\n      getMaxFlowBucketSize(data, unenlargedRatio, minimumSize, labelSize) <=\n        bucketAvailableSize\n    ) {\n      return unenlargedRatio * dataMax;\n    }\n    if (\n      getMaxFlowBucketSize(data, 0, minimumSize, labelSize) >\n      bucketAvailableSize\n    ) {\n      return null;\n    }\n    //Now, we apply minimum size to the bars to calculate our true ratio (found through binary search)\n    let low = 0;\n    let high = unenlargedRatio;\n    for (let i = 0; i < 50; i++) {\n      const mid = (low + high) / 2;\n      if (\n        getMaxFlowBucketSize(data, mid, minimumSize, labelSize) >\n        bucketAvailableSize\n      ) {\n        high = mid;\n      } else {\n        low = mid;\n      }\n    }\n    return low * dataMax;\n  }\n\n  //The size needed along the data axis beyond the fixed size\n  //For flow charts, this is based on the tallest bucket (including its own data labels and any enlarged elements),\n  // rather than assuming the bucket with the most data also has the most sub-buckets\n  function getScaledDataTotalSize(\n    data: ProcessData,\n    config: Config,\n    dataSize: number,\n    labelSize: number,\n  ): number {\n    if (data.type !== 'flow-processed') {\n      return dataSize;\n    }\n    const dataMax = Math.max(...data.x.map(x => x.totalCount));\n    if (dataMax <= 0) {\n      return dataSize;\n    }\n    return (\n      getMaxFlowBucketSize(\n        data,\n        dataSize / dataMax,\n        getMinimumDataElementSize(config),\n        labelSize,\n      ) - getFlowMidLabelSize(data, labelSize)\n    );\n  }\n\n  function getDataLabelSize(\n    data: ProcessData,\n    pipeTransform: ((value: number, isSecondary: boolean) => string) | null,\n    fontSize: number,\n  ): { horizontal: number; vertical: number } {\n    let normHorizontalMaxLength = 0;\n    let normSuppMaxLength = 0;\n    if (data.type !== 'flow-processed' && pipeTransform !== null) {\n      normHorizontalMaxLength = Math.max(\n        ...data.ys.map((y, yIndex) =>\n          Math.max(\n            ...y.values.map((val, xIndex) =>\n              checkLabelLength(\n                pipeTransform(\n                  val,\n                  checkIfSecondary(data, yIndex, xIndex, false),\n                ),\n                fontSize,\n              ),\n            ),\n          ),\n        ),\n      );\n      normSuppMaxLength = Math.max(\n        ...(data.supplementaryYs ?? []).map((y, yIndex) =>\n          Math.max(\n            ...y.values.map((val, xIndex) =>\n              checkLabelLength(\n                pipeTransform(\n                  val,\n                  checkIfSecondary(data, yIndex, xIndex, true),\n                ),\n                fontSize,\n              ),\n            ),\n          ),\n        ),\n      );\n    }\n    if (data.type === 'flow-processed') {\n      return {\n        horizontal: Math.max(normHorizontalMaxLength, normSuppMaxLength),\n        vertical: fontSize * 2,\n      };\n    }\n    return {\n      horizontal: Math.max(normHorizontalMaxLength, normSuppMaxLength),\n      vertical: fontSize,\n    };\n  }\n\n  function getBucketLabelSize(\n    data: ProcessData,\n    fontSize: number,\n    dateFormat: ((date: Date) => string) | null,\n  ) {\n    if (dateFormat !== null) {\n      if (data.type === 'labeled') {\n        return Math.max(\n          ...data.x.map(x => checkLabelLength(x.label, fontSize)),\n        );\n      } else if (data.type === 'timeseries') {\n        return Math.max(\n          ...data.x.map(x =>\n            checkLabelLength(dateFormat(new Date(x)), fontSize),\n          ),\n        );\n      }\n    }\n    return 0;\n  }\n\n  function checkLabelLength(value: string, fontSize: number): number {\n    const periodCount = (value.match(/\\./g) || []).length;\n    const slashCount = (value.match(/\\//g) || []).length;\n    const fontScaleFactor = fontSize / DEFAULT_FONT_SIZE;\n    return (\n      (value.length - (periodCount + slashCount)) *\n        (WIDTH_PER_NUMBER * fontScaleFactor) +\n      periodCount * (WIDTH_PER_PERIOD * fontScaleFactor) +\n      slashCount * (WIDTH_PER_SLASH * fontScaleFactor)\n    );\n  }\n\n  export function isBarType(type: Chart.ChartType): boolean {\n    if (\n      type === 'bar' ||\n      type === 'horizontal-bar' ||\n      type === 'waterfall' ||\n      type === 'funnel'\n    ) {\n      return true;\n    }\n    return false;\n  }\n\n  //Only bar-type and flow charts have discrete data elements that the minimum size applies to\n  function getMinimumDataElementSize(config: Config): number {\n    if (\n      config.type === 'donut' ||\n      config.type === 'line' ||\n      config.type === 'area'\n    ) {\n      return 0;\n    }\n    return config.scalingConfig?.dataScale?.minimumDataElementSize ?? 0;\n  }\n\n  //Any data element with a non-zero value is kept at or above the minimum size\n  function applyMinimumDataElementSize(\n    size: number,\n    value: number,\n    minimumSize: number,\n  ): number {\n    return value !== 0 ? Math.max(size, minimumSize) : size;\n  }\n\n  function getFlowSubBucketSizes(\n    subBucket: FlowSubBucket,\n    valueToSize: (value: number) => number,\n    minimumSize: number,\n  ): {\n    totalSize: number;\n    continuingSize: number;\n    connectionSizes: number[];\n  } {\n    const connectionSizes = subBucket.connections.map(connection =>\n      applyMinimumDataElementSize(\n        valueToSize(connection.count),\n        connection.count,\n        minimumSize,\n      ),\n    );\n    const sumSizes = (direction: FlowConnection['direction']): number =>\n      sum(\n        connectionSizes.filter(\n          (_, i) => subBucket.connections[i].direction === direction,\n        ),\n      );\n    const continuingSize = sumSizes('forward');\n    const backwardSize = sumSizes('backward');\n    const nonContinuingCount =\n      subBucket.count -\n      sum(\n        subBucket.connections\n          .filter(connection => connection.direction === 'forward')\n          .map(connection => connection.count),\n      );\n    //The sub-bucket must be big enough to hold all of its (possibly enlarged) connections on either side\n    const totalSize = Math.max(\n      applyMinimumDataElementSize(\n        valueToSize(subBucket.count),\n        subBucket.count,\n        minimumSize,\n      ),\n      continuingSize +\n        applyMinimumDataElementSize(\n          valueToSize(nonContinuingCount),\n          nonContinuingCount,\n          minimumSize,\n        ),\n      backwardSize,\n    );\n    //Every unit in a sub-bucket arrives through its backward connections, so they're stretched to fill the\n    // sub-bucket when it has been enlarged beyond them\n    return {\n      totalSize,\n      continuingSize,\n      connectionSizes: connectionSizes.map((size, i) =>\n        subBucket.connections[i].direction === 'backward' && backwardSize > 0\n          ? (size * totalSize) / backwardSize\n          : size,\n      ),\n    };\n  }\n\n  //The size of the tallest flow bucket for the given scaling ratio, including the data labels between its sub-buckets\n  //  The label above the first sub-bucket is excluded, since it's part of the top offset\n  function getMaxFlowBucketSize(\n    data: ProcessedFlowData,\n    pxPerValue: number,\n    minimumSize: number,\n    labelSize: number,\n  ): number {\n    return Math.max(\n      ...data.x.map(\n        bucket =>\n          sum(\n            bucket.subBuckets.map(\n              subBucket =>\n                getFlowSubBucketSizes(\n                  subBucket,\n                  value => value * pxPerValue,\n                  minimumSize,\n                ).totalSize,\n            ),\n          ) +\n          (bucket.subBuckets.length - 1) * labelSize,\n      ),\n    );\n  }\n\n  //The fixed size reserves room for the labels between sub-buckets as if every bucket had as many sub-buckets as the\n  // bucket with the most, so this is the portion of the fixed size that each bucket can instead use based on its own labels\n  function getFlowMidLabelSize(\n    data: ProcessedFlowData,\n    labelSize: number,\n  ): number {\n    return (\n      (Math.max(...data.x.map(bucket => bucket.subBuckets.length)) - 1) *\n      labelSize\n    );\n  }\n\n  function isStackedData(config: Config): boolean {\n    if (config.type === 'bar' || config.type === 'horizontal-bar') {\n      if (config.groupingType === 'stacked') {\n        return true;\n      }\n    }\n    if (config.type === 'area' || config.type === 'waterfall') {\n      return true;\n    }\n    return false;\n  }\n\n  function isClusteredData(\n    data: NonFlowData,\n    config: Config,\n    includeSupplementary: boolean,\n  ): boolean {\n    //It varies whether we want to include supplementary data in this check\n    if (hasSupplementaryData(data) && includeSupplementary) {\n      return true;\n    }\n    if (\n      (config.type === 'bar' || config.type === 'horizontal-bar') &&\n      config.groupingType === 'clustered'\n    ) {\n      return true;\n    }\n    if (config.type === 'funnel') {\n      return true;\n    }\n    return false;\n  }\n\n  //In some cases, the distinction between clustered and stacked doesn't matter\n  function isGroupingTypeException(data: NonFlowData, config: Config): boolean {\n    if (data.ys.length === 1) {\n      return true;\n    }\n    //Checking for a 'metric' charts, which is a special case for horizontal bar charts,\n    // where each series is also a bucket (and vice versa)\n    if (config.type === 'horizontal-bar') {\n      if (\n        data.x.length === data.ys.length &&\n        data.ys.length ===\n          data.ys.filter(y => y.values.filter(val => val !== 0).length === 1)\n            .length\n      ) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  function hasSupplementaryData(data: InputData): data is NonFlowData & {\n    supplementaryYs: NonNullable<NonFlowData['supplementaryYs']>;\n  } {\n    if (data.type === 'flow') {\n      return false;\n    }\n    if (data.supplementaryYs && data.supplementaryYs.length > 0) {\n      return true;\n    }\n    return false;\n  }\n\n  function getElementScalingInfo(\n    elementScales: PartialElementScalingConfig | undefined,\n    defaultScalingConfig: FullElementScalingConfig,\n    element: ChartScaleElement,\n  ): ElementScalingConfiguration {\n    const defaultElementConfig = defaultScalingConfig[element];\n    let inputConfig: ElementScalingConfiguration | null;\n    if (elementScales) {\n      const possibleConfig = elementScales[element];\n      if (possibleConfig) {\n        inputConfig = possibleConfig;\n      } else {\n        inputConfig = null;\n      }\n    } else {\n      inputConfig = null;\n    }\n\n    if (inputConfig !== null) {\n      const returnConfig = inputConfig as ElementScalingConfiguration;\n      return returnConfig;\n    }\n    if (defaultElementConfig.target !== undefined) {\n      const returnConfig = defaultElementConfig as ElementScalingConfiguration;\n      return returnConfig;\n    }\n    return {\n      target: 0,\n    };\n  }\n\n  function determinePossibleSizesOfElement(\n    elementConfig: ElementScalingConfiguration,\n    elementCount: number,\n  ): { min: number; max: number; target: number } {\n    const indMin = elementConfig.min !== undefined ? elementConfig.min : 0;\n    const indMax = elementConfig.max !== undefined ? elementConfig.max : 0;\n    const indTarget = elementConfig.target;\n    return {\n      min: indMin * elementCount,\n      max: indMax * elementCount,\n      target: indTarget * elementCount,\n    };\n  }\n\n  function determineTotalScaledSizeOfElement(\n    elementConfig: ElementScalingConfiguration,\n    elementCount: number,\n    scaleValue: number,\n  ): number {\n    const scaledVal = getScaledElementSize(elementConfig, scaleValue);\n    return scaledVal * elementCount;\n  }\n\n  function getScaledElementSize(\n    elementConfig: ElementScalingConfiguration,\n    scaleValue: number,\n  ): number {\n    const scaledTarget = elementConfig.target * scaleValue;\n    if (scaleValue < 1) {\n      if (elementConfig.min && elementConfig.min > scaledTarget) {\n        return elementConfig.min;\n      }\n      return scaledTarget;\n    }\n    if (scaleValue > 1) {\n      if (elementConfig.max && elementConfig.max < scaledTarget) {\n        return elementConfig.max;\n      }\n      return scaledTarget;\n    }\n    return scaledTarget;\n  }\n\n  type ElementScaleCheckInfo = {\n    config: ElementScalingConfiguration;\n    minScaleFactor?: number;\n    maxScaleFactor?: number;\n    elementCount: number;\n  };\n\n  function getCheckingInfoForElementConfig(\n    config: ElementScalingConfiguration,\n    elementCount: number,\n  ): ElementScaleCheckInfo {\n    let minScaleFactor: number | undefined = undefined;\n    if (config.min) {\n      minScaleFactor =\n        config.target !== 0 ? config.min / config.target : undefined;\n    }\n    let maxScaleFactor: number | undefined = undefined;\n    if (config.max) {\n      maxScaleFactor =\n        config.target !== 0 ? config.max / config.target : undefined;\n    }\n    return {\n      config,\n      minScaleFactor,\n      maxScaleFactor,\n      elementCount,\n    };\n  }\n\n  function getSumForScaleValue(\n    checkInfos: ElementScaleCheckInfo[],\n    scaleValue: number,\n  ): number {\n    let sum = 0;\n    for (const check of checkInfos) {\n      sum += determineTotalScaledSizeOfElement(\n        check.config,\n        check.elementCount,\n        scaleValue,\n      );\n    }\n    return sum;\n  }\n\n  function getDataLabelSizingCount(\n    data: ProcessData,\n    config: Config,\n  ): { start: number; end: number; total: number } {\n    if (config.showDataLabels !== true) {\n      return {\n        start: 0,\n        end: 0,\n        total: 0,\n      };\n    }\n    //Data labels are always shown above the data for all but these 3 types\n    if (\n      config.type !== 'bar' &&\n      config.type !== 'horizontal-bar' &&\n      config.type !== 'waterfall' &&\n      config.type !== 'flow'\n    ) {\n      return {\n        start: 1,\n        end: 0,\n        total: 1,\n      };\n    }\n    let startCount = 0;\n    let midCount = 0;\n    let endCount = 0;\n    if (data.type !== 'flow-processed') {\n      if (data.ys.find(y => y.values.find(val => val >= 0))) {\n        if (config.type === 'horizontal-bar') {\n          endCount += 1;\n        } else {\n          startCount += 1;\n        }\n      }\n      if (data.ys.find(y => y.values.find(val => val < 0))) {\n        if (config.type === 'horizontal-bar') {\n          startCount += 1;\n        } else {\n          endCount += 1;\n        }\n      }\n    } else {\n      startCount = 1;\n      midCount = Math.max(...data.x.map(x => x.subBuckets.length)) - 1;\n    }\n    return {\n      start: startCount,\n      end: endCount,\n      total: startCount + midCount + endCount,\n    };\n  }\n\n  function getIfHoverOutOfBounds(\n    //Position not accounting for scrolling\n    relPosX: number,\n    relPosY: number,\n    //Position accounting for scrolling\n    realPosX: number,\n    realPosY: number,\n    chartSizingValues: FullChartScaleValues | null,\n    dimensions: Dimensions,\n  ): boolean {\n    //Check if we're on top of one of the scrollbars\n    if (relPosX > dimensions.width || relPosY > dimensions.height) {\n      return true;\n    }\n    if (chartSizingValues === null) {\n      //If chartSizingValues aren't provided, no more checks\n      return false;\n    }\n    //Check if we're in one of the padding areas\n    if (\n      realPosX < chartSizingValues.leftPadding ||\n      realPosX >\n        chartSizingValues.totalWidth - chartSizingValues.rightPadding ||\n      realPosY < chartSizingValues.topPadding ||\n      realPosY > chartSizingValues.totalHeight - chartSizingValues.bottomPadding\n    ) {\n      return true;\n    }\n    return false;\n  }\n\n  function getChartDataDirection(config: Config): ChartDataDirection {\n    if (config.type === 'horizontal-bar') {\n      return 'horizontal';\n    }\n    return 'vertical';\n  }\n\n  function combineScalingInfo(\n    config: ConfigWithFullScaling,\n    defaultConfig: DefaultScalingConfig,\n  ): NonElementScalingConfig {\n    const providedScalingConfig = config.scalingConfig;\n    const chartDataDirection = getChartDataDirection(config);\n\n    //If the user provides a data scale, we don't want to override that unless they also provided a specific scale for the corresponding axis\n    const dataScale =\n      providedScalingConfig && providedScalingConfig.dataScale\n        ? providedScalingConfig.dataScale\n        : defaultConfig.nonElementScales.dataScale;\n    let verticalAxisScale = providedScalingConfig?.verticalAxisScale;\n    if (verticalAxisScale === undefined) {\n      if (chartDataDirection === 'horizontal' || dataScale.type === 'fit') {\n        verticalAxisScale = defaultConfig.nonElementScales.verticalAxisScale;\n      } else {\n        //The vertical axis is the data axis, the dataScale has a user-inputted value, and there isn't a user-inputted verticalAxisScale\n        // So, we'll prevent the axis scaling from interfering with the dataScale\n        verticalAxisScale = 'no-scale';\n      }\n    }\n    let horizontalAxisScale = providedScalingConfig?.horizontalAxisScale;\n    if (horizontalAxisScale === undefined) {\n      if (chartDataDirection === 'vertical' || dataScale.type === 'fit') {\n        horizontalAxisScale =\n          defaultConfig.nonElementScales.horizontalAxisScale;\n      } else {\n        //The horizontal axis is the data axis, the dataScale has a user-inputted value, and there isn't a user-inputted horizontalAxisScale\n        // So, we'll prevent the axis scaling from interfering with the dataScale\n        horizontalAxisScale = 'no-scale';\n      }\n    }\n    return {\n      dataScale:\n        providedScalingConfig && providedScalingConfig.dataScale\n          ? providedScalingConfig.dataScale\n          : defaultConfig.nonElementScales.dataScale,\n      horizontalAxisScale,\n      verticalAxisScale,\n      horizontalContainerScale:\n        providedScalingConfig && providedScalingConfig.horizontalContainerScale\n          ? providedScalingConfig.horizontalContainerScale\n          : defaultConfig.nonElementScales.horizontalContainerScale,\n      verticalContainerScale:\n        providedScalingConfig && providedScalingConfig.verticalContainerScale\n          ? providedScalingConfig.verticalContainerScale\n          : defaultConfig.nonElementScales.verticalContainerScale,\n      targetTickCount:\n        providedScalingConfig &&\n        providedScalingConfig.targetTickCount !== undefined\n          ? providedScalingConfig.targetTickCount\n          : defaultConfig.nonElementScales.targetTickCount,\n    };\n  }\n\n  function isDeEmphasized(\n    config: FlowConfig,\n    id: string,\n    isDarkened: boolean,\n  ): boolean {\n    const highlightedBuckets = config.flowConfig.subBucketsConfig\n      .filter(sbc => sbc.isHighlighted === true)\n      .map(sbc => sbc.bucketId);\n    if (highlightedBuckets.length === 0) {\n      return false;\n    }\n    if (isDarkened) {\n      return true;\n    }\n    if (highlightedBuckets.some(hb => hb === id)) {\n      return false;\n    }\n    return true;\n  }\n\n  function calculateFlowConnectionPath(\n    connection: FlowConnectionRender,\n  ): string {\n    const dx = connection.topLine.x2 - connection.topLine.x1;\n    const curve = Math.abs(dx) * FLOW_CONNECTION_CURVE_CONSTANT;\n\n    const path = `\n      M ${connection.topLine.x1},${connection.topLine.y1}\n\n      C ${connection.topLine.x1 + curve},${connection.topLine.y1}\n        ${connection.topLine.x2 - curve},${connection.topLine.y2}\n        ${connection.topLine.x2},${connection.topLine.y2}\n\n      L ${connection.bottomLine.x2},${connection.bottomLine.y2}\n\n      C ${connection.bottomLine.x2 - curve},${connection.bottomLine.y2}\n        ${connection.bottomLine.x1 + curve},${connection.bottomLine.y1}\n        ${connection.bottomLine.x1},${connection.bottomLine.y1}\n\n      Z\n    `;\n\n    return path;\n  }\n\n  function cubic(\n    a: number,\n    b: number,\n    c: number,\n    d: number,\n    t: number,\n  ): number {\n    const mt = 1 - t;\n    return mt ** 3 * a + 3 * mt ** 2 * t * b + 3 * mt * t ** 2 * c + t ** 3 * d;\n  }\n\n  function bezierYAtX(\n    x: number,\n    line: {\n      x1: number;\n      y1: number;\n      x2: number;\n      y2: number;\n    },\n  ): number {\n    const curve = Math.abs(line.x2 - line.x1) * FLOW_CONNECTION_CURVE_CONSTANT;\n    const p0 = { x: line.x1, y: line.y1 };\n    const p1 = { x: line.x1 + curve, y: line.y1 };\n    const p2 = { x: line.x2 - curve, y: line.y2 };\n    const p3 = { x: line.x2, y: line.y2 };\n\n    let lo = 0;\n    let hi = 1;\n\n    // Binary search for t where bezierX(t) ~= x\n    for (let i = 0; i < 20; i++) {\n      const t = (lo + hi) / 2;\n      const bx = cubic(p0.x, p1.x, p2.x, p3.x, t);\n\n      if (bx < x) lo = t;\n      else hi = t;\n    }\n\n    const t = (lo + hi) / 2;\n    return cubic(p0.y, p1.y, p2.y, p3.y, t);\n  }\n\n  function checkIfPointWithinConnection(\n    connection: FlowConnectionRender,\n    pointX: number,\n    pointY: number,\n  ): boolean {\n    const topY = bezierYAtX(pointX, connection.topLine);\n\n    const bottomY = bezierYAtX(pointX, connection.bottomLine);\n\n    return (\n      pointX >= connection.topLine.x1 &&\n      pointX <= connection.topLine.x2 &&\n      pointY >= Math.min(topY, bottomY) &&\n      pointY <= Math.max(topY, bottomY)\n    );\n  }\n\n  function getFlowBucketIndexForHover(\n    chartSizingValues: FullChartScaleValues,\n    xPos: number,\n  ): { index: number; area: 'bar' | 'connection' } | null {\n    let bucketIndex = 0;\n    const bucketLeftEdge = chartSizingValues.totalLeftOffset;\n    const totalBucketGap =\n      chartSizingValues.barSize + chartSizingValues.bucketGap;\n    if (bucketLeftEdge > xPos) {\n      return null;\n    }\n    while (bucketLeftEdge + bucketIndex * totalBucketGap < xPos) {\n      if (bucketLeftEdge + (bucketIndex + 1) * totalBucketGap > xPos) {\n        if (\n          bucketLeftEdge +\n            bucketIndex * totalBucketGap +\n            chartSizingValues.barSize >\n          xPos\n        ) {\n          return {\n            index: bucketIndex,\n            area: 'bar',\n          };\n        } else {\n          return {\n            index: bucketIndex,\n            area: 'connection',\n          };\n        }\n      }\n      bucketIndex += 1;\n    }\n    return null;\n  }\n\n  //These overloads ensure the function knows that, if width and height are defined on input, they'll be defined on output\n  function checkAnchorsAgainstBound(\n    anchorX: number,\n    anchorY: number,\n    dimensions: Dimensions,\n  ): { anchorX: number; anchorY: number };\n\n  function checkAnchorsAgainstBound(\n    anchorX: number,\n    anchorY: number,\n    dimensions: Dimensions,\n    width: number,\n    height: number,\n  ): {\n    anchorX: number;\n    anchorY: number;\n    anchorWidth: number;\n    anchorHeight: number;\n  };\n\n  function checkAnchorsAgainstBound(\n    anchorX: number,\n    anchorY: number,\n    dimensions: Dimensions,\n    width?: number,\n    height?: number,\n  ): {\n    anchorX: number;\n    anchorY: number;\n    anchorWidth?: number;\n    anchorHeight?: number;\n  } {\n    let retAnchorX = anchorX;\n    let retAnchorY = anchorY;\n    let retWidth: number | undefined = width;\n    let retHeight: number | undefined = height;\n    if (retAnchorX > dimensions.width) {\n      retAnchorX = dimensions.width;\n      if (retWidth !== undefined) {\n        retWidth = 0;\n      }\n    }\n    if (retAnchorX < 0) {\n      retAnchorX = 0;\n      if (retWidth !== undefined) {\n        retWidth = 0;\n      }\n    }\n    if (retAnchorY > dimensions.height) {\n      retAnchorY = dimensions.height;\n      if (retHeight !== undefined) {\n        retHeight = 0;\n      }\n    }\n    if (retAnchorY < 0) {\n      retAnchorY = 0;\n      if (retHeight !== undefined) {\n        retHeight = 0;\n      }\n    }\n\n    return {\n      anchorX: retAnchorX,\n      anchorY: retAnchorY,\n      anchorWidth: retWidth,\n      anchorHeight: retHeight,\n    };\n  }\n}\n"]}