mal-ui 0.1.3

package/dist/charts/index.js

@@ -0,0 +1,3499 @@
+"use client";
+import {
+  Box,
+  ColorSwatch,
+  Group,
+  Paper,
+  Text,
+  Tooltip,
+  createVarsResolver,
+  factory,
+  getAutoContrastValue,
+  getSpacing,
+  getThemeColor,
+  isLightColor,
+  parseThemeColor,
+  rem,
+  useMantineTheme,
+  useProps,
+  useResolvedStylesApi,
+  useStyles
+} from "../chunks/index-3ffbn0gc.js";
+import {
+  useId$1
+} from "../chunks/index-syjq3515.js";
+import"../chunks/index-mc01z7m9.js";
+
+// node_modules/@mantine/charts/esm/utils/get-series-labels/get-series-labels.mjs
+
+function getSeriesLabels(series) {
+  if (!series)
+    return {};
+  return series.reduce((acc, item) => {
+    const matchFound = item.name.search(/\./);
+    if (matchFound >= 0) {
+      const key = item.name.substring(matchFound + 1);
+      acc[key] = item.label;
+      return acc;
+    }
+    acc[item.name] = item.label;
+    return acc;
+  }, {});
+}
+
+// node_modules/@mantine/charts/esm/ChartTooltip/ChartTooltip.module.mjs
+
+var ChartTooltip_module_default = {
+  tooltip: "m_e4d36c9b",
+  tooltipLabel: "m_7f4bcb19",
+  tooltipBody: "m_3de554dd",
+  tooltipItemColor: "m_b30369b5",
+  tooltipItem: "m_3de8964e",
+  tooltipItemBody: "m_50186d10",
+  tooltipItemName: "m_501dadf9",
+  tooltipItemData: "m_50192318"
+};
+
+// node_modules/@mantine/charts/esm/ChartTooltip/ChartTooltip.mjs
+import { jsx, jsxs } from "react/jsx-runtime";
+
+function updateChartTooltipPayload(payload) {
+  return payload.map((item) => {
+    if (!item.payload || item.payload[item.name])
+      return item;
+    const matchFound = item.name.search(/\./);
+    if (matchFound >= 0) {
+      const newDataKey = item.name.substring(0, matchFound);
+      const nestedPayload = { ...item.payload[newDataKey] };
+      const shallowPayload = Object.entries(item.payload).reduce((acc, current) => {
+        const [k, v] = current;
+        return k === newDataKey ? acc : {
+          ...acc,
+          [k]: v
+        };
+      }, {});
+      return {
+        ...item,
+        name: item.name.substring(matchFound + 1),
+        payload: {
+          ...shallowPayload,
+          ...nestedPayload
+        }
+      };
+    }
+    return item;
+  });
+}
+function getFilteredChartTooltipPayload(payload, segmentId) {
+  const duplicatesFilter = updateChartTooltipPayload(payload.filter((item) => item.fill !== "none" || !item.color));
+  if (!segmentId)
+    return duplicatesFilter;
+  return duplicatesFilter.filter((item) => item.name === segmentId);
+}
+function getData(item, type) {
+  if (type === "radial" || type === "scatter") {
+    if (Array.isArray(item.value))
+      return item.value[1] - item.value[0];
+    return item.value;
+  }
+  if (Array.isArray(item.payload[item.dataKey]))
+    return item.payload[item.dataKey][1] - item.payload[item.dataKey][0];
+  return item.payload[item.name];
+}
+var defaultProps = {
+  type: "area",
+  showColor: true
+};
+var ChartTooltip = factory((_props) => {
+  const props = useProps("ChartTooltip", defaultProps, _props);
+  const { classNames, className, style, styles, unstyled, vars, payload, label, unit, type, segmentId, mod, series, valueFormatter, showColor, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "ChartTooltip",
+    classes: ChartTooltip_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes
+  });
+  if (!payload)
+    return null;
+  const filteredPayload = getFilteredChartTooltipPayload(payload, segmentId);
+  const scatterLabel = type === "scatter" ? payload[0]?.payload?.name : null;
+  const labels = getSeriesLabels(series);
+  const _label = label || scatterLabel;
+  const items = filteredPayload.map((item) => /* @__PURE__ */ jsxs("div", {
+    "data-type": type,
+    ...getStyles("tooltipItem"),
+    children: [/* @__PURE__ */ jsxs("div", {
+      ...getStyles("tooltipItemBody"),
+      children: [showColor && /* @__PURE__ */ jsx("svg", {
+        ...getStyles("tooltipItemColor"),
+        children: /* @__PURE__ */ jsx("circle", {
+          r: 6,
+          fill: getThemeColor(item.color, theme),
+          width: 12,
+          height: 12,
+          cx: 6,
+          cy: 6
+        })
+      }), /* @__PURE__ */ jsx("div", {
+        ...getStyles("tooltipItemName"),
+        children: labels[item.name] || item.name
+      })]
+    }), /* @__PURE__ */ jsxs("div", {
+      ...getStyles("tooltipItemData"),
+      children: [typeof valueFormatter === "function" ? valueFormatter(getData(item, type)) : getData(item, type), unit || item.unit]
+    })]
+  }, item?.key ?? item.name));
+  return /* @__PURE__ */ jsxs(Box, {
+    ...getStyles("tooltip"),
+    mod: [{ type }, mod],
+    ...others,
+    children: [_label && /* @__PURE__ */ jsx("div", {
+      ...getStyles("tooltipLabel"),
+      children: _label
+    }), /* @__PURE__ */ jsx("div", {
+      ...getStyles("tooltipBody"),
+      children: items
+    })]
+  });
+});
+ChartTooltip.displayName = "@mantine/charts/ChartTooltip";
+
+// node_modules/@mantine/charts/esm/ChartLegend/ChartLegend.module.mjs
+
+var ChartLegend_module_default = {
+  legend: "m_847eaf",
+  legendItem: "m_17da7e62",
+  legendItemColor: "m_6e236e21",
+  legendItemName: "m_8ff56c0d"
+};
+
+// node_modules/@mantine/charts/esm/ChartLegend/ChartLegend.mjs
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+
+function updateChartLegendPayload(payload) {
+  return payload.map((item) => {
+    const newDataKey = item.dataKey?.split(".").pop();
+    return {
+      ...item,
+      dataKey: newDataKey,
+      payload: {
+        ...item.payload,
+        name: newDataKey,
+        dataKey: newDataKey
+      }
+    };
+  });
+}
+function getFilteredChartLegendPayload(payload) {
+  return updateChartLegendPayload(payload.filter((item) => item.color !== "none"));
+}
+var ChartLegend = factory((_props) => {
+  const props = useProps("ChartLegend", null, _props);
+  const { classNames, className, style, styles, unstyled, vars, payload, onHighlight, legendPosition, mod, series, showColor, centered, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: "ChartLegend",
+    classes: ChartLegend_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    rootSelector: "legend"
+  });
+  if (!payload)
+    return null;
+  const filteredPayload = getFilteredChartLegendPayload(payload);
+  const labels = getSeriesLabels(series);
+  const items = filteredPayload.map((item, index) => /* @__PURE__ */ jsxs2("div", {
+    ...getStyles("legendItem"),
+    onMouseEnter: () => onHighlight(item.dataKey),
+    "data-without-color": showColor === false || undefined,
+    children: [/* @__PURE__ */ jsx2(ColorSwatch, {
+      color: item.color,
+      size: 12,
+      ...getStyles("legendItemColor"),
+      withShadow: false
+    }), /* @__PURE__ */ jsx2("p", {
+      ...getStyles("legendItemName"),
+      children: labels[item.dataKey] || item.dataKey
+    })]
+  }, index));
+  return /* @__PURE__ */ jsx2(Box, {
+    mod: [{
+      position: legendPosition,
+      centered
+    }, mod],
+    ...getStyles("legend"),
+    ...others,
+    onMouseLeave: (event) => {
+      others.onMouseLeave?.(event);
+      onHighlight(null);
+    },
+    children: items
+  });
+});
+ChartLegend.displayName = "@mantine/charts/ChartLegend";
+ChartLegend.classes = ChartLegend_module_default;
+
+// node_modules/@mantine/charts/esm/AreaChart/AreaGradient.mjs
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+
+function AreaGradient({ color, id, withGradient, fillOpacity }) {
+  return /* @__PURE__ */ jsx3(Fragment, { children: withGradient ? /* @__PURE__ */ jsxs3("linearGradient", {
+    id,
+    x1: "0",
+    y1: "0",
+    x2: "0",
+    y2: "1",
+    children: [/* @__PURE__ */ jsx3("stop", {
+      offset: "0%",
+      stopColor: color,
+      stopOpacity: fillOpacity
+    }), /* @__PURE__ */ jsx3("stop", {
+      offset: "100%",
+      stopColor: color,
+      stopOpacity: 0.01
+    })]
+  }) : /* @__PURE__ */ jsx3("linearGradient", {
+    id,
+    x1: "0",
+    y1: "0",
+    x2: "0",
+    y2: "1",
+    children: /* @__PURE__ */ jsx3("stop", {
+      stopColor: color,
+      stopOpacity: fillOpacity ?? 0.2
+    })
+  }) });
+}
+AreaGradient.displayName = "@mantine/charts/AreaGradient";
+
+// node_modules/@mantine/charts/esm/AreaChart/get-split-offset.mjs
+
+function getSplitOffset({ data, dataKey }) {
+  const dataMax = Math.max(...data.map((item) => item[dataKey]));
+  const dataMin = Math.min(...data.map((item) => item[dataKey]));
+  if (dataMax <= 0)
+    return 0;
+  if (dataMin >= 0)
+    return 1;
+  return dataMax / (dataMax - dataMin);
+}
+function getDefaultSplitOffset({ data, series }) {
+  if (series.length === 1) {
+    const dataKey = series[0].name;
+    return getSplitOffset({
+      data,
+      dataKey
+    });
+  }
+  return 0.5;
+}
+
+// node_modules/@mantine/charts/esm/PointLabel/PointLabel.mjs
+import { jsx as jsx4 } from "react/jsx-runtime";
+
+function PointLabel({ x, y, value, valueFormatter }) {
+  return /* @__PURE__ */ jsx4("g", {
+    transform: `translate(${x},${y})`,
+    children: /* @__PURE__ */ jsx4("text", {
+      x: 0,
+      y: 0,
+      dy: -8,
+      dx: -10,
+      textAnchor: "start",
+      fill: "var(--chart-text-color, var(--mantine-color-dimmed))",
+      fontSize: 8,
+      children: valueFormatter ? valueFormatter(value) : value
+    })
+  });
+}
+
+// node_modules/@mantine/charts/esm/AreaChart/AreaSplit.mjs
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+
+function AreaSplit({ offset, id, colors, fillOpacity }) {
+  const theme = useMantineTheme();
+  return /* @__PURE__ */ jsxs4("linearGradient", {
+    id,
+    x1: "0",
+    y1: "0",
+    x2: "0",
+    y2: "1",
+    children: [/* @__PURE__ */ jsx5("stop", {
+      offset,
+      stopColor: getThemeColor(colors[0], theme),
+      stopOpacity: fillOpacity ?? 0.2
+    }), /* @__PURE__ */ jsx5("stop", {
+      offset,
+      stopColor: getThemeColor(colors[1], theme),
+      stopOpacity: fillOpacity ?? 0.2
+    })]
+  });
+}
+AreaSplit.displayName = "@mantine/charts/AreaSplit";
+
+// node_modules/@mantine/charts/esm/grid-chart.module.mjs
+
+var grid_chart_module_default = {
+  root: "m_a50f3e58",
+  container: "m_af9188cb",
+  grid: "m_a50a48bc",
+  axis: "m_a507a517",
+  axisLabel: "m_2293801d",
+  tooltip: "m_92b296cd"
+};
+
+// node_modules/@mantine/charts/esm/AreaChart/AreaChart.mjs
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Fragment as Fragment$1, createElement, useId, useState } from "react";
+import { Area, AreaChart, CartesianGrid, Label, Legend, ReferenceLine, ResponsiveContainer, Tooltip as Tooltip$1, XAxis, YAxis } from "recharts";
+
+function valueToPercent(value) {
+  return `${(value * 100).toFixed(0)}%`;
+}
+var defaultProps2 = {
+  withXAxis: true,
+  withYAxis: true,
+  withDots: true,
+  withTooltip: true,
+  connectNulls: true,
+  strokeWidth: 2,
+  tooltipAnimationDuration: 0,
+  fillOpacity: 0.2,
+  tickLine: "y",
+  strokeDasharray: "5 5",
+  curveType: "monotone",
+  gridAxis: "x",
+  type: "default",
+  splitColors: ["green.7", "red.7"],
+  orientation: "horizontal"
+};
+var varsResolver = createVarsResolver((theme, { textColor, gridColor }) => ({ root: {
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined
+} }));
+var AreaChart$1 = factory((_props) => {
+  const props = useProps("AreaChart", defaultProps2, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, series, withGradient, dataKey, withXAxis, withYAxis, curveType, gridProps, withDots, tickLine, strokeDasharray, gridAxis, unit, yAxisProps, xAxisProps, dotProps, activeDotProps, strokeWidth, tooltipAnimationDuration, type, legendProps, tooltipProps, withLegend, withTooltip, areaChartProps, fillOpacity, splitColors, splitOffset, connectNulls, onMouseLeave, orientation, referenceLines, dir, valueFormatter, children, areaProps, xAxisLabel, yAxisLabel, withRightYAxis, rightYAxisLabel, rightYAxisProps, withPointLabels, gridColor, textColor, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const baseId = useId();
+  const splitId = `${baseId}-split`;
+  const withXTickLine = gridAxis !== "none" && (tickLine === "x" || tickLine === "xy");
+  const withYTickLine = gridAxis !== "none" && (tickLine === "y" || tickLine === "xy");
+  const isAnimationActive = (tooltipAnimationDuration || 0) > 0;
+  const _withGradient = typeof withGradient === "boolean" ? withGradient : type === "default";
+  const stacked = type === "stacked" || type === "percent";
+  const [highlightedArea, setHighlightedArea] = useState(null);
+  const shouldHighlight = highlightedArea !== null;
+  const handleMouseLeave = (event) => {
+    setHighlightedArea(null);
+    onMouseLeave?.(event);
+  };
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const getStyles = useStyles({
+    name: "AreaChart",
+    classes: grid_chart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver
+  });
+  const dotsAreas = series.map((item) => {
+    const color = getThemeColor(item.color, theme);
+    const dimmed = shouldHighlight && highlightedArea !== item.name;
+    return /* @__PURE__ */ createElement(Area, {
+      ...getStyles("area"),
+      activeDot: {
+        fill: theme.white,
+        stroke: color,
+        strokeWidth: 2,
+        r: 4,
+        ...activeDotProps
+      },
+      dot: {
+        fill: color,
+        fillOpacity: dimmed ? 0 : 1,
+        strokeWidth: 2,
+        r: 4,
+        ...dotProps
+      },
+      key: item.name,
+      name: item.name,
+      type: curveType,
+      dataKey: item.name,
+      fill: "none",
+      strokeWidth,
+      stroke: "none",
+      isAnimationActive: false,
+      connectNulls,
+      stackId: stacked ? "stack-dots" : undefined,
+      yAxisId: item.yAxisId || undefined,
+      ...typeof areaProps === "function" ? areaProps(item) : areaProps
+    });
+  });
+  const areas = series.map((item) => {
+    const id = `${baseId}-${item.color.replace(/[^a-zA-Z0-9]/g, "")}`;
+    const color = getThemeColor(item.color, theme);
+    const dimmed = shouldHighlight && highlightedArea !== item.name;
+    return /* @__PURE__ */ jsxs5(Fragment$1, { children: [/* @__PURE__ */ jsx6("defs", { children: /* @__PURE__ */ jsx6(AreaGradient, {
+      color,
+      withGradient: _withGradient,
+      id,
+      fillOpacity
+    }) }), /* @__PURE__ */ jsx6(Area, {
+      ...getStyles("area"),
+      activeDot: false,
+      dot: false,
+      name: item.name,
+      type: item.curveType ?? curveType,
+      dataKey: item.name,
+      fill: type === "split" ? `url(#${splitId})` : `url(#${id})`,
+      strokeWidth,
+      stroke: color,
+      isAnimationActive: false,
+      connectNulls,
+      stackId: stacked ? "stack" : undefined,
+      fillOpacity: dimmed ? 0 : 1,
+      strokeOpacity: dimmed ? 0.5 : 1,
+      strokeDasharray: item.strokeDasharray,
+      yAxisId: item.yAxisId || undefined,
+      label: withPointLabels ? /* @__PURE__ */ jsx6(PointLabel, { valueFormatter }) : undefined,
+      ...typeof areaProps === "function" ? areaProps(item) : areaProps
+    })] }, item.name);
+  });
+  const referenceLinesItems = referenceLines?.map((line, index) => {
+    const color = getThemeColor(line.color, theme);
+    return /* @__PURE__ */ jsx6(ReferenceLine, {
+      stroke: line.color ? color : "var(--chart-grid-color)",
+      strokeWidth: 1,
+      yAxisId: line.yAxisId || undefined,
+      ...line,
+      label: {
+        fill: line.color ? color : "currentColor",
+        fontSize: 12,
+        position: line.labelPosition ?? "insideBottomLeft",
+        ...typeof line.label === "object" ? line.label : { value: line.label }
+      },
+      ...getStyles("referenceLine")
+    }, index);
+  });
+  const tickFormatter = type === "percent" ? valueToPercent : valueFormatter;
+  const sharedYAxisProps = {
+    axisLine: false,
+    ...orientation === "vertical" ? {
+      dataKey,
+      type: "category"
+    } : { type: "number" },
+    tickLine: withYTickLine ? { stroke: "currentColor" } : false,
+    allowDecimals: true,
+    unit,
+    tickFormatter: orientation === "vertical" ? undefined : tickFormatter,
+    ...getStyles("axis")
+  };
+  return /* @__PURE__ */ jsx6(Box, {
+    ...getStyles("root"),
+    onMouseLeave: handleMouseLeave,
+    dir: dir || "ltr",
+    ...others,
+    children: /* @__PURE__ */ jsx6(ResponsiveContainer, {
+      ...getStyles("container"),
+      children: /* @__PURE__ */ jsxs5(AreaChart, {
+        data,
+        stackOffset: type === "percent" ? "expand" : undefined,
+        layout: orientation,
+        margin: {
+          bottom: xAxisLabel ? 30 : undefined,
+          left: yAxisLabel ? 10 : undefined,
+          right: yAxisLabel ? 5 : undefined
+        },
+        ...areaChartProps,
+        children: [
+          referenceLinesItems,
+          withLegend && /* @__PURE__ */ jsx6(Legend, {
+            verticalAlign: "top",
+            content: (payload) => /* @__PURE__ */ jsx6(ChartLegend, {
+              payload: payload.payload,
+              onHighlight: setHighlightedArea,
+              legendPosition: legendProps?.verticalAlign || "top",
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              attributes
+            }),
+            ...legendProps
+          }),
+          /* @__PURE__ */ jsx6(CartesianGrid, {
+            strokeDasharray,
+            vertical: gridAxis === "y" || gridAxis === "xy",
+            horizontal: gridAxis === "x" || gridAxis === "xy",
+            ...getStyles("grid"),
+            ...gridProps
+          }),
+          /* @__PURE__ */ jsxs5(XAxis, {
+            hide: !withXAxis,
+            ...orientation === "vertical" ? { type: "number" } : { dataKey },
+            tick: {
+              transform: "translate(0, 10)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            stroke: "",
+            interval: "preserveStartEnd",
+            tickLine: withXTickLine ? { stroke: "currentColor" } : false,
+            minTickGap: 5,
+            tickFormatter: orientation === "vertical" ? tickFormatter : undefined,
+            ...getStyles("axis"),
+            ...xAxisProps,
+            children: [xAxisLabel && /* @__PURE__ */ jsx6(Label, {
+              position: "insideBottom",
+              offset: -20,
+              fontSize: 12,
+              ...getStyles("axisLabel"),
+              children: xAxisLabel
+            }), xAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs5(YAxis, {
+            orientation: "left",
+            tick: {
+              transform: "translate(-10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withYAxis,
+            ...sharedYAxisProps,
+            ...yAxisProps,
+            children: [yAxisLabel && /* @__PURE__ */ jsx6(Label, {
+              position: "insideLeft",
+              angle: -90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: yAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs5(YAxis, {
+            yAxisId: "right",
+            orientation: "right",
+            tick: {
+              transform: "translate(10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withRightYAxis,
+            ...sharedYAxisProps,
+            ...rightYAxisProps,
+            children: [rightYAxisLabel && /* @__PURE__ */ jsx6(Label, {
+              position: "insideRight",
+              angle: 90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: rightYAxisLabel
+            }), yAxisProps?.children]
+          }),
+          withTooltip && /* @__PURE__ */ jsx6(Tooltip$1, {
+            animationDuration: tooltipAnimationDuration,
+            isAnimationActive,
+            position: orientation === "vertical" ? {} : { y: 0 },
+            cursor: {
+              stroke: "var(--chart-grid-color)",
+              strokeWidth: 1,
+              strokeDasharray
+            },
+            content: ({ label, payload, labelFormatter }) => /* @__PURE__ */ jsx6(ChartTooltip, {
+              label: labelFormatter && payload ? labelFormatter(label, payload) : label,
+              payload,
+              unit,
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              valueFormatter,
+              attributes
+            }),
+            ...tooltipProps
+          }),
+          type === "split" && /* @__PURE__ */ jsx6("defs", { children: /* @__PURE__ */ jsx6(AreaSplit, {
+            colors: splitColors,
+            id: splitId,
+            offset: splitOffset ?? getDefaultSplitOffset({
+              data,
+              series
+            }),
+            fillOpacity
+          }) }),
+          areas,
+          withDots && dotsAreas,
+          children
+        ]
+      })
+    })
+  });
+});
+AreaChart$1.classes = grid_chart_module_default;
+AreaChart$1.varsResolver = varsResolver;
+AreaChart$1.displayName = "@mantine/charts/AreaChart";
+
+// node_modules/@mantine/charts/esm/BarChart/BarChart.mjs
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import React, { createElement as createElement2, useState as useState2 } from "react";
+import { Bar, BarChart, CartesianGrid as CartesianGrid2, Label as Label2, LabelList, Legend as Legend2, Rectangle, ReferenceLine as ReferenceLine2, ResponsiveContainer as ResponsiveContainer2, Tooltip as Tooltip$12, XAxis as XAxis2, YAxis as YAxis2 } from "recharts";
+
+function valueToPercent2(value) {
+  return `${(value * 100).toFixed(0)}%`;
+}
+var defaultProps3 = {
+  withXAxis: true,
+  withYAxis: true,
+  withTooltip: true,
+  tooltipAnimationDuration: 0,
+  fillOpacity: 1,
+  tickLine: "y",
+  strokeDasharray: "5 5",
+  gridAxis: "x",
+  type: "default"
+};
+var varsResolver2 = createVarsResolver((theme, { textColor, gridColor, cursorFill, barLabelColor }) => ({ root: {
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined,
+  "--chart-cursor-fill": cursorFill ? getThemeColor(cursorFill, theme) : undefined,
+  "--chart-bar-label-color": barLabelColor ? getThemeColor(barLabelColor, theme) : undefined
+} }));
+function calculateCumulativeTotal(waterfallData, dataKey) {
+  let start = 0;
+  let end = 0;
+  return waterfallData.map((item) => {
+    if (item.standalone) {
+      for (const prop in item)
+        if (typeof item[prop] === "number" && prop !== dataKey)
+          item[prop] = [0, item[prop]];
+    } else
+      for (const prop in item)
+        if (typeof item[prop] === "number" && prop !== dataKey) {
+          end += item[prop];
+          item[prop] = [start, end];
+          start = end;
+        }
+    return item;
+  });
+}
+function getBarFill(barProps, series) {
+  if (typeof barProps === "function")
+    return barProps(series).fill;
+  return barProps?.fill;
+}
+var BarChart$1 = factory((_props) => {
+  const props = useProps("BarChart", defaultProps3, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withLegend, legendProps, series, onMouseLeave, dataKey, withTooltip, withXAxis, withYAxis, gridAxis, tickLine, xAxisProps, yAxisProps, unit, tooltipAnimationDuration, strokeDasharray, gridProps, tooltipProps, referenceLines, fillOpacity, barChartProps, type, orientation, dir, valueFormatter, children, barProps, xAxisLabel, yAxisLabel, withBarValueLabel, valueLabelProps, withRightYAxis, rightYAxisLabel, rightYAxisProps, minBarSize, maxBarWidth, mod, getBarColor, gridColor, textColor, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const withXTickLine = gridAxis !== "none" && (tickLine === "x" || tickLine === "xy");
+  const withYTickLine = gridAxis !== "none" && (tickLine === "y" || tickLine === "xy");
+  const [highlightedArea, setHighlightedArea] = useState2(null);
+  const shouldHighlight = highlightedArea !== null;
+  const stacked = type === "stacked" || type === "percent";
+  const tickFormatter = type === "percent" ? valueToPercent2 : valueFormatter;
+  const handleMouseLeave = (event) => {
+    setHighlightedArea(null);
+    onMouseLeave?.(event);
+  };
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const inputData = type === "waterfall" ? calculateCumulativeTotal(data, dataKey) : data;
+  const getStyles = useStyles({
+    name: "BarChart",
+    classes: grid_chart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver2
+  });
+  const bars = series.map((item) => {
+    const color = getThemeColor(item.color, theme);
+    const dimmed = shouldHighlight && highlightedArea !== item.name;
+    const resolvedBarProps = typeof barProps === "function" ? barProps(item) : barProps;
+    const userShape = resolvedBarProps?.shape;
+    return /* @__PURE__ */ createElement2(Bar, {
+      ...getStyles("bar"),
+      key: item.name,
+      name: item.name,
+      dataKey: item.name,
+      fill: color,
+      stroke: color,
+      isAnimationActive: false,
+      fillOpacity: dimmed ? 0.1 : fillOpacity,
+      strokeOpacity: dimmed ? 0.2 : 0,
+      stackId: stacked ? "stack" : item.stackId || undefined,
+      yAxisId: item.yAxisId || undefined,
+      minPointSize: minBarSize,
+      ...resolvedBarProps,
+      shape: (shapeProps) => {
+        const entry = shapeProps.payload;
+        const cellColor = entry?.color ? getThemeColor(entry.color, theme) : typeof getBarColor === "function" ? getThemeColor(getBarColor(entry?.[item.name], item), theme) : getBarFill(barProps, item) || color;
+        const coloredProps = {
+          ...shapeProps,
+          fill: cellColor
+        };
+        if (typeof userShape === "function")
+          return userShape(coloredProps);
+        if (React.isValidElement(userShape))
+          return React.cloneElement(userShape, coloredProps);
+        if (typeof userShape === "object" && userShape)
+          return /* @__PURE__ */ jsx7(Rectangle, {
+            ...coloredProps,
+            ...userShape
+          });
+        return /* @__PURE__ */ jsx7(Rectangle, { ...coloredProps });
+      }
+    }, withBarValueLabel && /* @__PURE__ */ jsx7(LabelList, {
+      position: orientation === "vertical" ? "right" : "top",
+      fontSize: 12,
+      fill: "var(--chart-bar-label-color, var(--mantine-color-dimmed))",
+      formatter: (val) => tickFormatter?.(val),
+      ...typeof valueLabelProps === "function" ? valueLabelProps(item) : valueLabelProps
+    }));
+  });
+  const referenceLinesItems = referenceLines?.map((line, index) => {
+    const color = getThemeColor(line.color, theme);
+    return /* @__PURE__ */ jsx7(ReferenceLine2, {
+      stroke: line.color ? color : "var(--chart-grid-color)",
+      strokeWidth: 1,
+      yAxisId: line.yAxisId || undefined,
+      ...line,
+      label: {
+        fill: line.color ? color : "currentColor",
+        fontSize: 12,
+        position: line.labelPosition ?? "insideBottomLeft",
+        ...typeof line.label === "object" ? line.label : { value: line.label }
+      },
+      ...getStyles("referenceLine")
+    }, index);
+  });
+  const sharedYAxisProps = {
+    axisLine: false,
+    ...orientation === "vertical" ? {
+      dataKey,
+      type: "category"
+    } : { type: "number" },
+    tickLine: withYTickLine ? { stroke: "currentColor" } : false,
+    allowDecimals: true,
+    unit,
+    tickFormatter: orientation === "vertical" ? undefined : tickFormatter,
+    ...getStyles("axis")
+  };
+  return /* @__PURE__ */ jsx7(Box, {
+    ...getStyles("root"),
+    onMouseLeave: handleMouseLeave,
+    dir: dir || "ltr",
+    mod: [{ orientation }, mod],
+    ...others,
+    children: /* @__PURE__ */ jsx7(ResponsiveContainer2, {
+      ...getStyles("container"),
+      children: /* @__PURE__ */ jsxs6(BarChart, {
+        data: inputData,
+        stackOffset: type === "percent" ? "expand" : undefined,
+        layout: orientation,
+        maxBarSize: maxBarWidth,
+        margin: {
+          bottom: xAxisLabel ? 30 : undefined,
+          left: yAxisLabel ? 10 : undefined,
+          right: yAxisLabel ? 5 : undefined
+        },
+        ...barChartProps,
+        children: [
+          withLegend && /* @__PURE__ */ jsx7(Legend2, {
+            verticalAlign: "top",
+            content: (payload) => /* @__PURE__ */ jsx7(ChartLegend, {
+              payload: payload.payload,
+              onHighlight: setHighlightedArea,
+              legendPosition: legendProps?.verticalAlign || "top",
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              showColor: type !== "waterfall",
+              attributes
+            }),
+            ...legendProps
+          }),
+          /* @__PURE__ */ jsxs6(XAxis2, {
+            hide: !withXAxis,
+            ...orientation === "vertical" ? { type: "number" } : { dataKey },
+            tick: {
+              transform: "translate(0, 10)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            stroke: "",
+            interval: "preserveStartEnd",
+            tickLine: withXTickLine ? { stroke: "currentColor" } : false,
+            minTickGap: 5,
+            tickFormatter: orientation === "vertical" ? tickFormatter : undefined,
+            ...getStyles("axis"),
+            ...xAxisProps,
+            children: [xAxisLabel && /* @__PURE__ */ jsx7(Label2, {
+              position: "insideBottom",
+              offset: -20,
+              fontSize: 12,
+              ...getStyles("axisLabel"),
+              children: xAxisLabel
+            }), xAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs6(YAxis2, {
+            orientation: "left",
+            tick: {
+              transform: "translate(-10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withYAxis,
+            ...sharedYAxisProps,
+            ...yAxisProps,
+            children: [yAxisLabel && /* @__PURE__ */ jsx7(Label2, {
+              position: "insideLeft",
+              angle: -90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: yAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs6(YAxis2, {
+            yAxisId: "right",
+            orientation: "right",
+            tick: {
+              transform: "translate(10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withRightYAxis,
+            ...sharedYAxisProps,
+            ...rightYAxisProps,
+            children: [rightYAxisLabel && /* @__PURE__ */ jsx7(Label2, {
+              position: "insideRight",
+              angle: 90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: rightYAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsx7(CartesianGrid2, {
+            strokeDasharray,
+            vertical: gridAxis === "y" || gridAxis === "xy",
+            horizontal: gridAxis === "x" || gridAxis === "xy",
+            ...getStyles("grid"),
+            ...gridProps
+          }),
+          withTooltip && /* @__PURE__ */ jsx7(Tooltip$12, {
+            animationDuration: tooltipAnimationDuration,
+            isAnimationActive: tooltipAnimationDuration !== 0,
+            position: orientation === "vertical" ? {} : { y: 0 },
+            cursor: {
+              stroke: "var(--chart-grid-color)",
+              strokeWidth: 1,
+              strokeDasharray,
+              fill: "var(--chart-cursor-fill)"
+            },
+            content: ({ label, payload, labelFormatter }) => /* @__PURE__ */ jsx7(ChartTooltip, {
+              label: labelFormatter && payload ? labelFormatter(label, payload) : label,
+              payload,
+              type: type === "waterfall" ? "scatter" : undefined,
+              unit,
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              valueFormatter,
+              attributes
+            }),
+            ...tooltipProps
+          }),
+          bars,
+          referenceLinesItems,
+          children
+        ]
+      })
+    })
+  });
+});
+BarChart$1.displayName = "@mantine/charts/BarChart";
+BarChart$1.classes = grid_chart_module_default;
+BarChart$1.varsResolver = varsResolver2;
+
+// node_modules/@mantine/charts/esm/LineChart/LineChart.mjs
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { createElement as createElement3, useState as useState3 } from "react";
+import { CartesianGrid as CartesianGrid3, Label as Label3, Legend as Legend3, Line, LineChart, ReferenceLine as ReferenceLine3, ResponsiveContainer as ResponsiveContainer3, Tooltip as Tooltip$13, XAxis as XAxis3, YAxis as YAxis3 } from "recharts";
+
+var defaultProps4 = {
+  withXAxis: true,
+  withYAxis: true,
+  withTooltip: true,
+  tooltipAnimationDuration: 0,
+  fillOpacity: 1,
+  tickLine: "y",
+  strokeDasharray: "5 5",
+  gridAxis: "x",
+  withDots: true,
+  connectNulls: true,
+  strokeWidth: 2,
+  curveType: "monotone",
+  gradientStops: [{
+    offset: 0,
+    color: "red"
+  }, {
+    offset: 100,
+    color: "blue"
+  }]
+};
+var varsResolver3 = createVarsResolver((theme, { textColor, gridColor }) => ({ root: {
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined
+} }));
+var LineChart$1 = factory((_props) => {
+  const props = useProps("LineChart", defaultProps4, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withLegend, legendProps, series, onMouseLeave, dataKey, withTooltip, withXAxis, withYAxis, gridAxis, tickLine, xAxisProps, yAxisProps, unit, tooltipAnimationDuration, strokeDasharray, gridProps, tooltipProps, referenceLines, withDots, dotProps, activeDotProps, strokeWidth, lineChartProps, connectNulls, fillOpacity, curveType, orientation, dir, valueFormatter, children, lineProps, xAxisLabel, yAxisLabel, type, gradientStops, withRightYAxis, rightYAxisLabel, rightYAxisProps, withPointLabels, attributes, gridColor, ...others } = props;
+  const theme = useMantineTheme();
+  const withXTickLine = gridAxis !== "none" && (tickLine === "x" || tickLine === "xy");
+  const withYTickLine = gridAxis !== "none" && (tickLine === "y" || tickLine === "xy");
+  const [highlightedArea, setHighlightedArea] = useState3(null);
+  const shouldHighlight = highlightedArea !== null;
+  const handleMouseLeave = (event) => {
+    setHighlightedArea(null);
+    onMouseLeave?.(event);
+  };
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const getStyles = useStyles({
+    name: "LineChart",
+    classes: grid_chart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver3
+  });
+  const gradientId = `line-chart-gradient-${useId$1()}`;
+  const stops = gradientStops?.map((stop) => /* @__PURE__ */ jsx8("stop", {
+    offset: `${stop.offset}%`,
+    stopColor: getThemeColor(stop.color, theme)
+  }, stop.color));
+  const lines = series.map((item) => {
+    const color = getThemeColor(item.color, theme);
+    const dimmed = shouldHighlight && highlightedArea !== item.name;
+    return /* @__PURE__ */ createElement3(Line, {
+      ...getStyles("line"),
+      key: item.name,
+      name: item.name,
+      dataKey: item.name,
+      dot: withDots ? {
+        fillOpacity: dimmed ? 0 : 1,
+        strokeOpacity: dimmed ? 0 : 1,
+        strokeWidth: 1,
+        fill: type === "gradient" ? "var(--mantine-color-gray-7)" : color,
+        stroke: type === "gradient" ? "white" : color,
+        ...dotProps
+      } : false,
+      activeDot: withDots ? {
+        fill: type === "gradient" ? "var(--mantine-color-gray-7)" : color,
+        stroke: type === "gradient" ? "white" : color,
+        ...activeDotProps
+      } : false,
+      fill: color,
+      stroke: type === "gradient" ? `url(#${gradientId})` : color,
+      strokeWidth,
+      isAnimationActive: false,
+      fillOpacity: dimmed ? 0 : fillOpacity,
+      strokeOpacity: dimmed ? 0.5 : fillOpacity,
+      connectNulls,
+      type: item.curveType ?? curveType,
+      strokeDasharray: item.strokeDasharray,
+      yAxisId: item.yAxisId || undefined,
+      label: withPointLabels ? /* @__PURE__ */ jsx8(PointLabel, { valueFormatter }) : undefined,
+      ...typeof lineProps === "function" ? lineProps(item) : lineProps
+    });
+  });
+  const referenceLinesItems = referenceLines?.map((line, index) => {
+    const color = getThemeColor(line.color, theme);
+    return /* @__PURE__ */ jsx8(ReferenceLine3, {
+      stroke: line.color ? color : "var(--chart-grid-color)",
+      strokeWidth: 1,
+      yAxisId: line.yAxisId || undefined,
+      ...line,
+      label: {
+        fill: line.color ? color : "currentColor",
+        fontSize: 12,
+        position: line.labelPosition ?? "insideBottomLeft",
+        ...typeof line.label === "object" ? line.label : { value: line.label }
+      },
+      ...getStyles("referenceLine")
+    }, index);
+  });
+  const sharedYAxisProps = {
+    axisLine: false,
+    ...orientation === "vertical" ? {
+      dataKey,
+      type: "category"
+    } : { type: "number" },
+    tickLine: withYTickLine ? { stroke: "currentColor" } : false,
+    allowDecimals: true,
+    unit,
+    tickFormatter: orientation === "vertical" ? undefined : valueFormatter,
+    ...getStyles("axis")
+  };
+  return /* @__PURE__ */ jsx8(Box, {
+    ...getStyles("root"),
+    onMouseLeave: handleMouseLeave,
+    dir: dir || "ltr",
+    ...others,
+    children: /* @__PURE__ */ jsx8(ResponsiveContainer3, {
+      ...getStyles("container"),
+      children: /* @__PURE__ */ jsxs7(LineChart, {
+        data,
+        layout: orientation,
+        margin: {
+          bottom: xAxisLabel ? 30 : undefined,
+          left: yAxisLabel ? 10 : undefined,
+          right: yAxisLabel ? 5 : undefined
+        },
+        ...lineChartProps,
+        children: [
+          type === "gradient" && /* @__PURE__ */ jsx8("defs", { children: /* @__PURE__ */ jsx8("linearGradient", {
+            id: gradientId,
+            x1: "0",
+            y1: "0",
+            x2: "0",
+            y2: "1",
+            children: stops
+          }) }),
+          withLegend && /* @__PURE__ */ jsx8(Legend3, {
+            verticalAlign: "top",
+            content: (payload) => /* @__PURE__ */ jsx8(ChartLegend, {
+              payload: payload.payload,
+              onHighlight: setHighlightedArea,
+              legendPosition: legendProps?.verticalAlign || "top",
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              showColor: type !== "gradient",
+              attributes
+            }),
+            ...legendProps
+          }),
+          /* @__PURE__ */ jsxs7(XAxis3, {
+            hide: !withXAxis,
+            ...orientation === "vertical" ? { type: "number" } : { dataKey },
+            tick: {
+              transform: "translate(0, 10)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            stroke: "",
+            interval: "preserveStartEnd",
+            tickLine: withXTickLine ? { stroke: "currentColor" } : false,
+            minTickGap: 5,
+            tickFormatter: orientation === "vertical" ? valueFormatter : undefined,
+            ...getStyles("axis"),
+            ...xAxisProps,
+            children: [xAxisLabel && /* @__PURE__ */ jsx8(Label3, {
+              position: "insideBottom",
+              offset: -20,
+              fontSize: 12,
+              ...getStyles("axisLabel"),
+              children: xAxisLabel
+            }), xAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs7(YAxis3, {
+            tick: {
+              transform: "translate(-10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withYAxis,
+            ...sharedYAxisProps,
+            ...yAxisProps,
+            children: [yAxisLabel && /* @__PURE__ */ jsx8(Label3, {
+              position: "insideLeft",
+              angle: -90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: yAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs7(YAxis3, {
+            yAxisId: "right",
+            orientation: "right",
+            tick: {
+              transform: "translate(10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withRightYAxis,
+            ...sharedYAxisProps,
+            ...rightYAxisProps,
+            children: [rightYAxisLabel && /* @__PURE__ */ jsx8(Label3, {
+              position: "insideRight",
+              angle: 90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: rightYAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsx8(CartesianGrid3, {
+            strokeDasharray,
+            vertical: gridAxis === "y" || gridAxis === "xy",
+            horizontal: gridAxis === "x" || gridAxis === "xy",
+            ...getStyles("grid"),
+            ...gridProps
+          }),
+          withTooltip && /* @__PURE__ */ jsx8(Tooltip$13, {
+            animationDuration: tooltipAnimationDuration,
+            isAnimationActive: tooltipAnimationDuration !== 0,
+            position: orientation === "vertical" ? {} : { y: 0 },
+            cursor: {
+              stroke: "var(--chart-grid-color)",
+              strokeWidth: 1,
+              strokeDasharray
+            },
+            content: ({ label, payload, labelFormatter }) => /* @__PURE__ */ jsx8(ChartTooltip, {
+              label: labelFormatter && payload ? labelFormatter(label, payload) : label,
+              payload,
+              unit,
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              valueFormatter,
+              showColor: type !== "gradient",
+              attributes
+            }),
+            ...tooltipProps
+          }),
+          lines,
+          referenceLinesItems,
+          children
+        ]
+      })
+    })
+  });
+});
+LineChart$1.displayName = "@mantine/charts/LineChart";
+LineChart$1.classes = grid_chart_module_default;
+LineChart$1.varsResolver = varsResolver3;
+
+// node_modules/@mantine/charts/esm/Sparkline/Sparkline.module.mjs
+
+var Sparkline_module_default = { root: "m_f9458cfe" };
+
+// node_modules/@mantine/charts/esm/Sparkline/Sparkline.mjs
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+import { useId as useId2, useMemo } from "react";
+import { Area as Area2, AreaChart as AreaChart2, ResponsiveContainer as ResponsiveContainer4 } from "recharts";
+
+var defaultProps5 = {
+  withGradient: true,
+  connectNulls: true,
+  fillOpacity: 0.6,
+  strokeWidth: 2,
+  curveType: "linear"
+};
+function getTrendColor(data, trendColors) {
+  const first = data[0];
+  const last = data[data.length - 1];
+  if (first === null || last === null)
+    return trendColors.neutral || trendColors.positive;
+  if (first < last)
+    return trendColors.positive;
+  if (first > last)
+    return trendColors.negative;
+  return trendColors.neutral || trendColors.positive;
+}
+var varsResolver4 = createVarsResolver((theme, { color, data, trendColors }) => ({ root: { "--chart-color": trendColors ? getThemeColor(getTrendColor(data, trendColors), theme) : color ? getThemeColor(color, theme) : undefined } }));
+var Sparkline = factory((_props) => {
+  const props = useProps("Sparkline", defaultProps5, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withGradient, fillOpacity, curveType, strokeWidth, trendColors, connectNulls, areaProps, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: "Sparkline",
+    classes: Sparkline_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver4
+  });
+  const id = useId2();
+  const mappedData = useMemo(() => data.map((value, index) => ({
+    value,
+    index
+  })), [data]);
+  return /* @__PURE__ */ jsx9(Box, {
+    ...getStyles("root"),
+    ...others,
+    dir: "ltr",
+    children: /* @__PURE__ */ jsx9(ResponsiveContainer4, { children: /* @__PURE__ */ jsxs8(AreaChart2, {
+      data: mappedData,
+      children: [/* @__PURE__ */ jsx9(Area2, {
+        dataKey: "value",
+        type: curveType,
+        fill: `url(#${id})`,
+        stroke: "var(--chart-color, var(--mantine-color-blue-filled))",
+        isAnimationActive: false,
+        connectNulls,
+        strokeWidth,
+        fillOpacity: 1,
+        activeDot: false,
+        ...areaProps
+      }), /* @__PURE__ */ jsx9("defs", { children: /* @__PURE__ */ jsx9(AreaGradient, {
+        id,
+        color: "var(--chart-color, var(--mantine-color-blue-filled))",
+        fillOpacity,
+        withGradient
+      }) })]
+    }) })
+  });
+});
+Sparkline.displayName = "@mantine/charts/Sparkline";
+Sparkline.classes = Sparkline_module_default;
+Sparkline.varsResolver = varsResolver4;
+
+// node_modules/@mantine/charts/esm/DonutChart/DonutChart.module.mjs
+
+var DonutChart_module_default = {
+  root: "m_a410e613",
+  label: "m_ddb0bfe3"
+};
+
+// node_modules/@mantine/charts/esm/DonutChart/DonutChart.mjs
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Pie, PieChart, ResponsiveContainer as ResponsiveContainer5, Tooltip as Tooltip$14 } from "recharts";
+
+var defaultProps6 = {
+  withTooltip: true,
+  withLabelsLine: true,
+  paddingAngle: 0,
+  thickness: 20,
+  size: 160,
+  strokeWidth: 1,
+  startAngle: 0,
+  endAngle: 360,
+  labelsType: "value",
+  tooltipDataSource: "all"
+};
+var varsResolver5 = createVarsResolver((theme, { strokeColor, labelColor, withLabels, size }) => ({ root: {
+  "--chart-stroke-color": strokeColor ? getThemeColor(strokeColor, theme) : undefined,
+  "--chart-labels-color": labelColor ? getThemeColor(labelColor, theme) : undefined,
+  "--chart-size": withLabels ? rem(size + 80) : rem(size)
+} }));
+var getLabelValue = (labelsType, value, percent, valueFormatter) => {
+  if (labelsType === "percent")
+    return `${((percent || 0) * 100).toFixed(0)}%`;
+  if (typeof valueFormatter === "function")
+    return valueFormatter(value || 0);
+  return value;
+};
+var getLabel = (labelsType, valueFormatter) => ({ x, y, cx, cy, percent, value }) => /* @__PURE__ */ jsx10("text", {
+  x,
+  y,
+  cx,
+  cy,
+  textAnchor: x > Number(cx) ? "start" : "end",
+  fill: "var(--chart-labels-color, var(--mantine-color-dimmed))",
+  fontFamily: "var(--mantine-font-family)",
+  fontSize: 12,
+  children: /* @__PURE__ */ jsx10("tspan", {
+    x,
+    children: getLabelValue(labelsType, Number(value), Number(percent), valueFormatter)
+  })
+});
+var DonutChart = factory((_props) => {
+  const props = useProps("DonutChart", defaultProps6, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withTooltip, tooltipAnimationDuration, tooltipProps, pieProps, paddingAngle, withLabels, withLabelsLine, size, thickness, strokeWidth, startAngle, endAngle, tooltipDataSource, chartLabel, children, pieChartProps, valueFormatter, strokeColor, labelsType, attributes, cellProps, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "DonutChart",
+    classes: DonutChart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver5
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const pieData = data.map((item) => ({
+    ...item,
+    fill: getThemeColor(item.color, theme),
+    stroke: "var(--chart-stroke-color, var(--mantine-color-body))",
+    strokeWidth,
+    ...typeof cellProps === "function" ? cellProps(item) : cellProps
+  }));
+  return /* @__PURE__ */ jsx10(Box, {
+    size,
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx10(ResponsiveContainer5, { children: /* @__PURE__ */ jsxs9(PieChart, {
+      ...pieChartProps,
+      children: [
+        /* @__PURE__ */ jsx10(Pie, {
+          data: pieData,
+          innerRadius: size / 2 - thickness,
+          outerRadius: size / 2,
+          dataKey: "value",
+          isAnimationActive: false,
+          paddingAngle,
+          startAngle,
+          endAngle,
+          label: withLabels ? getLabel(labelsType || "value", valueFormatter) : false,
+          labelLine: withLabelsLine ? {
+            stroke: "var(--chart-label-color, var(--mantine-color-dimmed))",
+            strokeWidth: 1
+          } : false,
+          ...pieProps
+        }),
+        chartLabel && /* @__PURE__ */ jsx10("text", {
+          x: "50%",
+          y: "50%",
+          textAnchor: "middle",
+          dominantBaseline: "middle",
+          ...getStyles("label"),
+          children: chartLabel
+        }),
+        withTooltip && /* @__PURE__ */ jsx10(Tooltip$14, {
+          animationDuration: tooltipAnimationDuration,
+          isAnimationActive: false,
+          content: ({ payload }) => /* @__PURE__ */ jsx10(ChartTooltip, {
+            payload: data,
+            classNames: resolvedClassNames,
+            styles: resolvedStyles,
+            type: "radial",
+            segmentId: tooltipDataSource === "segment" ? payload?.[0]?.name : undefined,
+            valueFormatter,
+            attributes
+          }),
+          ...tooltipProps
+        }),
+        children
+      ]
+    }) })
+  });
+});
+DonutChart.displayName = "@mantine/charts/DonutChart";
+DonutChart.classes = DonutChart_module_default;
+DonutChart.varsResolver = varsResolver5;
+
+// node_modules/@mantine/charts/esm/PieChart/PieChart.module.mjs
+
+var PieChart_module_default = { root: "m_cd8943fd" };
+
+// node_modules/@mantine/charts/esm/PieChart/PieChart.mjs
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Pie as Pie2, PieChart as PieChart2, ResponsiveContainer as ResponsiveContainer6, Tooltip as Tooltip$15 } from "recharts";
+
+var defaultProps7 = {
+  withTooltip: false,
+  withLabelsLine: true,
+  paddingAngle: 0,
+  size: 160,
+  strokeWidth: 1,
+  startAngle: 0,
+  endAngle: 360,
+  tooltipDataSource: "all",
+  labelsPosition: "outside",
+  labelsType: "value"
+};
+var varsResolver6 = createVarsResolver((theme, { strokeColor, labelColor, withLabels, size, labelsPosition }) => ({ root: {
+  "--chart-stroke-color": strokeColor ? getThemeColor(strokeColor, theme) : undefined,
+  "--chart-labels-color": labelColor ? getThemeColor(labelColor, theme) : undefined,
+  "--chart-size": withLabels && labelsPosition === "outside" ? rem(size + 80) : rem(size)
+} }));
+var getLabelValue2 = (labelsType, value, percent, valueFormatter) => {
+  if (labelsType === "percent" && typeof percent === "number")
+    return `${(percent * 100).toFixed(0)}%`;
+  if (typeof valueFormatter === "function" && typeof value === "number")
+    return valueFormatter(value);
+  return value;
+};
+var getInsideLabel = (labelsType, valueFormatter) => ({ cx, cy, midAngle, innerRadius, outerRadius, value, percent }) => {
+  const RADIAN = Math.PI / 180;
+  const radius = Number(innerRadius) + (Number(outerRadius) - Number(innerRadius)) * 0.5;
+  const x = Number(cx) + radius * Math.cos(-(midAngle || 0) * RADIAN);
+  return /* @__PURE__ */ jsx11("text", {
+    x,
+    y: Number(cy) + radius * Math.sin(-(midAngle || 0) * RADIAN),
+    textAnchor: x > Number(cx) ? "start" : "end",
+    dominantBaseline: "central",
+    className: PieChart_module_default.label,
+    children: getLabelValue2(labelsType, Number(value), Number(percent), valueFormatter)
+  });
+};
+var getOutsideLabel = (labelsType, valueFormatter) => ({ x, y, cx, cy, percent, value }) => /* @__PURE__ */ jsx11("text", {
+  x,
+  y,
+  cx,
+  cy,
+  textAnchor: x > Number(cx) ? "start" : "end",
+  fill: "var(--chart-labels-color, var(--mantine-color-dimmed))",
+  fontFamily: "var(--mantine-font-family)",
+  fontSize: 12,
+  children: /* @__PURE__ */ jsx11("tspan", {
+    x,
+    children: getLabelValue2(labelsType, Number(value), Number(percent), valueFormatter)
+  })
+});
+var PieChart$1 = factory((_props) => {
+  const props = useProps("PieChart", defaultProps7, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withTooltip, tooltipAnimationDuration, tooltipProps, pieProps, paddingAngle, withLabels, withLabelsLine, size, strokeWidth, startAngle, endAngle, tooltipDataSource, children, pieChartProps, labelsPosition, valueFormatter, labelsType, strokeColor, attributes, cellProps, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "PieChart",
+    classes: PieChart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver6
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const pieData = data.map((item) => ({
+    ...item,
+    fill: getThemeColor(item.color, theme),
+    stroke: "var(--chart-stroke-color, var(--mantine-color-body))",
+    strokeWidth,
+    ...typeof cellProps === "function" ? cellProps(item) : cellProps
+  }));
+  return /* @__PURE__ */ jsx11(Box, {
+    size,
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx11(ResponsiveContainer6, { children: /* @__PURE__ */ jsxs10(PieChart2, {
+      ...pieChartProps,
+      children: [
+        /* @__PURE__ */ jsx11(Pie2, {
+          data: pieData,
+          innerRadius: 0,
+          outerRadius: size / 2,
+          dataKey: "value",
+          isAnimationActive: false,
+          paddingAngle,
+          startAngle,
+          endAngle,
+          label: withLabels ? labelsPosition === "inside" ? getInsideLabel(labelsType || "value", valueFormatter) : getOutsideLabel(labelsType || "value", valueFormatter) : false,
+          labelLine: withLabelsLine && labelsPosition === "outside" ? {
+            stroke: "var(--chart-label-color, var(--mantine-color-dimmed))",
+            strokeWidth: 1
+          } : false,
+          ...pieProps
+        }),
+        withTooltip && /* @__PURE__ */ jsx11(Tooltip$15, {
+          animationDuration: tooltipAnimationDuration,
+          isAnimationActive: false,
+          content: ({ payload }) => /* @__PURE__ */ jsx11(ChartTooltip, {
+            payload: data,
+            classNames: resolvedClassNames,
+            styles: resolvedStyles,
+            type: "radial",
+            segmentId: tooltipDataSource === "segment" ? payload?.[0]?.name : undefined,
+            valueFormatter,
+            attributes
+          }),
+          ...tooltipProps
+        }),
+        children
+      ]
+    }) })
+  });
+});
+PieChart$1.displayName = "@mantine/charts/PieChart";
+PieChart$1.classes = PieChart_module_default;
+PieChart$1.varsResolver = varsResolver6;
+
+// node_modules/@mantine/charts/esm/RadarChart/RadarChart.module.mjs
+
+var RadarChart_module_default = {
+  root: "m_1f271cf7",
+  container: "m_cf06f58c"
+};
+
+// node_modules/@mantine/charts/esm/RadarChart/RadarChart.mjs
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+import { useState as useState4 } from "react";
+import { Legend as Legend4, PolarAngleAxis, PolarGrid, PolarRadiusAxis, Radar, RadarChart, ResponsiveContainer as ResponsiveContainer7, Tooltip as Tooltip$16 } from "recharts";
+
+var defaultProps8 = {
+  withPolarGrid: true,
+  withPolarAngleAxis: true,
+  withPolarRadiusAxis: false,
+  withTooltip: false,
+  withDots: false,
+  tooltipAnimationDuration: 0
+};
+var varsResolver7 = createVarsResolver((theme, { gridColor, textColor }) => ({ root: {
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined,
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined
+} }));
+var RadarChart$1 = factory((_props) => {
+  const props = useProps("RadarChart", defaultProps8, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, series, dataKey, gridColor, textColor, radarProps, radarChartProps, polarGridProps, polarAngleAxisProps, polarRadiusAxisProps, tooltipProps, withPolarGrid, withPolarAngleAxis, withPolarRadiusAxis, withTooltip, tooltipAnimationDuration, children, withLegend, withDots, dotProps, activeDotProps, legendProps, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "RadarChart",
+    classes: RadarChart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver7
+  });
+  const [highlightedArea, setHighlightedArea] = useState4(null);
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const radars = series.map((item, index) => /* @__PURE__ */ jsx12(Radar, {
+    name: item.name,
+    dataKey: item.name,
+    stroke: getThemeColor(item.strokeColor || item.color, theme),
+    fill: getThemeColor(item.color, theme),
+    fillOpacity: highlightedArea ? highlightedArea === item.name ? item.opacity || 0.4 : 0.05 : item.opacity || 0.4,
+    dot: withDots ? {
+      fillOpacity: 1,
+      strokeOpacity: 0,
+      strokeWidth: 1,
+      fill: getThemeColor(item.color, theme),
+      stroke: getThemeColor(item.color, theme),
+      ...dotProps
+    } : false,
+    activeDot: withDots ? {
+      fill: getThemeColor(item.color, theme),
+      stroke: getThemeColor(item.color, theme),
+      ...activeDotProps
+    } : false,
+    strokeOpacity: highlightedArea ? highlightedArea === item.name ? 1 : 0.1 : 1,
+    isAnimationActive: false,
+    ...typeof radarProps === "function" ? radarProps(item) : radarProps
+  }, index));
+  return /* @__PURE__ */ jsx12(Box, {
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx12(ResponsiveContainer7, {
+      ...getStyles("container"),
+      children: /* @__PURE__ */ jsxs11(RadarChart, {
+        data,
+        ...radarChartProps,
+        children: [
+          withPolarGrid && /* @__PURE__ */ jsx12(PolarGrid, {
+            stroke: "var(--chart-grid-color)",
+            ...polarGridProps
+          }),
+          withPolarAngleAxis && /* @__PURE__ */ jsx12(PolarAngleAxis, {
+            dataKey,
+            ...polarAngleAxisProps
+          }),
+          withPolarRadiusAxis && /* @__PURE__ */ jsx12(PolarRadiusAxis, {
+            stroke: "var(--chart-grid-color)",
+            ...polarRadiusAxisProps
+          }),
+          withTooltip && /* @__PURE__ */ jsx12(Tooltip$16, {
+            animationDuration: tooltipAnimationDuration,
+            isAnimationActive: tooltipAnimationDuration !== 0,
+            cursor: {
+              stroke: "var(--chart-grid-color)",
+              strokeWidth: 1
+            },
+            content: ({ label, payload, labelFormatter }) => /* @__PURE__ */ jsx12(ChartTooltip, {
+              label: labelFormatter && payload ? labelFormatter(label, payload) : label,
+              payload,
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              attributes
+            }),
+            ...tooltipProps
+          }),
+          radars,
+          withLegend && /* @__PURE__ */ jsx12(Legend4, {
+            verticalAlign: "bottom",
+            content: (payload) => /* @__PURE__ */ jsx12(ChartLegend, {
+              payload: payload.payload,
+              onHighlight: setHighlightedArea,
+              legendPosition: legendProps?.verticalAlign || "bottom",
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              centered: true,
+              attributes
+            }),
+            ...legendProps
+          }),
+          children
+        ]
+      })
+    })
+  });
+});
+RadarChart$1.displayName = "@mantine/charts/RadarChart";
+RadarChart$1.classes = RadarChart_module_default;
+RadarChart$1.varsResolver = varsResolver7;
+
+// node_modules/@mantine/charts/esm/ScatterChart/ScatterChart.mjs
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+import { useState as useState5 } from "react";
+import { CartesianGrid as CartesianGrid4, Label as Label4, LabelList as LabelList2, Legend as Legend5, ReferenceLine as ReferenceLine4, ResponsiveContainer as ResponsiveContainer8, Scatter, ScatterChart, Tooltip as Tooltip$17, XAxis as XAxis4, YAxis as YAxis4 } from "recharts";
+
+function getAxis(key, dataKey) {
+  return key === dataKey.x ? "x" : "y";
+}
+var defaultProps9 = {
+  withXAxis: true,
+  withYAxis: true,
+  withTooltip: true,
+  tooltipAnimationDuration: 0,
+  tickLine: "y",
+  strokeDasharray: "5 5",
+  gridAxis: "x"
+};
+var varsResolver8 = createVarsResolver((theme, { textColor, gridColor }) => ({ root: {
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined
+} }));
+var ScatterChart$1 = factory((_props) => {
+  const props = useProps("ScatterChart", defaultProps9, _props);
+  const { classNames, className, style, styles, unstyled, vars, referenceLines, dir, withLegend, withTooltip, withXAxis, withYAxis, xAxisProps, yAxisProps, orientation, scatterChartProps, legendProps, data, gridAxis, tickLine, strokeDasharray, gridProps, tooltipAnimationDuration, tooltipProps, children, onMouseLeave, dataKey, textColor, gridColor, xAxisLabel, yAxisLabel, unit, labels, valueFormatter, scatterProps, pointLabels, attributes, ...others } = props;
+  const getFormatter = (axis) => typeof valueFormatter === "function" ? valueFormatter : valueFormatter?.[axis];
+  const xFormatter = getFormatter("x");
+  const yFormatter = getFormatter("y");
+  const theme = useMantineTheme();
+  const mappedData = data.map((item) => ({
+    ...item,
+    data: item.data.map((point) => ({
+      ...point,
+      name: item.name
+    }))
+  }));
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const getStyles = useStyles({
+    name: "ScatterChart",
+    classes: grid_chart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver8
+  });
+  const withXTickLine = gridAxis !== "none" && (tickLine === "x" || tickLine === "xy");
+  const withYTickLine = gridAxis !== "none" && (tickLine === "y" || tickLine === "xy");
+  const [highlightedArea, setHighlightedArea] = useState5(null);
+  const shouldHighlight = highlightedArea !== null;
+  const handleMouseLeave = (event) => {
+    setHighlightedArea(null);
+    onMouseLeave?.(event);
+  };
+  const referenceLinesItems = referenceLines?.map((line, index) => {
+    const color = getThemeColor(line.color, theme);
+    return /* @__PURE__ */ jsx13(ReferenceLine4, {
+      stroke: line.color ? color : "var(--chart-grid-color)",
+      strokeWidth: 1,
+      ...line,
+      label: {
+        fill: line.color ? color : "currentColor",
+        fontSize: 12,
+        position: line.labelPosition ?? "insideBottomLeft",
+        ...typeof line.label === "object" ? line.label : { value: line.label }
+      },
+      ...getStyles("referenceLine")
+    }, index);
+  });
+  const scatters = mappedData.map((item, index) => {
+    const dimmed = shouldHighlight && highlightedArea !== item.name;
+    return /* @__PURE__ */ jsxs12(Scatter, {
+      data: item.data,
+      fill: getThemeColor(item.color, theme),
+      isAnimationActive: false,
+      fillOpacity: dimmed ? 0.1 : 1,
+      ...scatterProps,
+      children: [pointLabels && /* @__PURE__ */ jsx13(LabelList2, {
+        dataKey: dataKey[pointLabels],
+        fontSize: 8,
+        dy: 10
+      }), scatterProps?.children]
+    }, index);
+  });
+  return /* @__PURE__ */ jsx13(Box, {
+    ...getStyles("root"),
+    onMouseLeave: handleMouseLeave,
+    dir: dir || "ltr",
+    ...others,
+    children: /* @__PURE__ */ jsx13(ResponsiveContainer8, {
+      ...getStyles("container"),
+      children: /* @__PURE__ */ jsxs12(ScatterChart, {
+        margin: {
+          bottom: xAxisLabel ? 30 : undefined,
+          left: yAxisLabel ? 10 : undefined,
+          right: yAxisLabel ? 5 : undefined
+        },
+        ...scatterChartProps,
+        children: [
+          /* @__PURE__ */ jsx13(CartesianGrid4, {
+            strokeDasharray,
+            vertical: gridAxis === "y" || gridAxis === "xy",
+            horizontal: gridAxis === "x" || gridAxis === "xy",
+            ...getStyles("grid"),
+            ...gridProps
+          }),
+          /* @__PURE__ */ jsxs12(XAxis4, {
+            type: "number",
+            hide: !withXAxis,
+            dataKey: dataKey.x,
+            tick: {
+              transform: "translate(0, 10)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            stroke: "",
+            interval: "preserveStartEnd",
+            tickLine: withXTickLine ? { stroke: "currentColor" } : false,
+            minTickGap: 5,
+            unit: unit?.x,
+            tickFormatter: xFormatter,
+            ...getStyles("axis"),
+            ...xAxisProps,
+            children: [xAxisLabel && /* @__PURE__ */ jsx13(Label4, {
+              position: "insideBottom",
+              offset: -20,
+              fontSize: 12,
+              ...getStyles("axisLabel"),
+              children: xAxisLabel
+            }), xAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs12(YAxis4, {
+            type: "number",
+            hide: !withYAxis,
+            axisLine: false,
+            dataKey: dataKey.y,
+            tickLine: withYTickLine ? { stroke: "currentColor" } : false,
+            tick: {
+              transform: "translate(-10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            allowDecimals: true,
+            unit: unit?.y,
+            tickFormatter: yFormatter,
+            ...getStyles("axis"),
+            ...yAxisProps,
+            children: [yAxisLabel && /* @__PURE__ */ jsx13(Label4, {
+              position: "insideLeft",
+              angle: -90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: yAxisLabel
+            }), yAxisProps?.children]
+          }),
+          withTooltip && /* @__PURE__ */ jsx13(Tooltip$17, {
+            animationDuration: tooltipAnimationDuration,
+            isAnimationActive: tooltipAnimationDuration !== 0,
+            position: { y: 0 },
+            cursor: {
+              stroke: "var(--chart-grid-color)",
+              strokeWidth: 1,
+              strokeDasharray
+            },
+            content: ({ label, payload, labelFormatter }) => /* @__PURE__ */ jsx13(ChartTooltip, {
+              type: "scatter",
+              label: labelFormatter && payload ? labelFormatter(label, payload) : label,
+              payload: labels ? payload?.map((item) => ({
+                ...item,
+                name: labels[getAxis(item.name, dataKey)] || item.name,
+                value: getFormatter(getAxis(item.name, dataKey))?.(item.value) ?? item.value
+              })) : payload?.map((item) => ({
+                ...item,
+                value: getFormatter(getAxis(item.name, dataKey))?.(item.value) ?? item.value
+              })),
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series: data,
+              attributes
+            }),
+            ...tooltipProps
+          }),
+          withLegend && /* @__PURE__ */ jsx13(Legend5, {
+            verticalAlign: "top",
+            content: (payload) => /* @__PURE__ */ jsx13(ChartLegend, {
+              payload: payload.payload?.map((item, index) => ({
+                ...item,
+                dataKey: data[index].name
+              })),
+              onHighlight: setHighlightedArea,
+              legendPosition: legendProps?.verticalAlign || "top",
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series: data,
+              attributes
+            }),
+            height: 44,
+            ...legendProps
+          }),
+          referenceLinesItems,
+          scatters
+        ]
+      })
+    })
+  });
+});
+ScatterChart$1.displayName = "@mantine/charts/ScatterChart";
+ScatterChart$1.classes = grid_chart_module_default;
+ScatterChart$1.varsResolver = varsResolver8;
+
+// node_modules/@mantine/charts/esm/BubbleChart/BubbleChart.mjs
+import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
+import { ResponsiveContainer as ResponsiveContainer9, Scatter as Scatter2, ScatterChart as ScatterChart2, Tooltip as Tooltip$18, XAxis as XAxis5, YAxis as YAxis5, ZAxis } from "recharts";
+
+function getDomain(data, key) {
+  const values = data.map((item) => item[key]);
+  return [Math.min(...values), Math.max(...values)];
+}
+function BubbleChartTooltip({ active, payload, getStyles, dataKey, valueFormatter }) {
+  if (active && payload && payload.length) {
+    const data = payload[0] && payload[0].payload;
+    return /* @__PURE__ */ jsx14("div", {
+      ...getStyles("tooltip"),
+      children: /* @__PURE__ */ jsxs13(Group, {
+        justify: "space-between",
+        children: [/* @__PURE__ */ jsx14(Text, {
+          fz: "sm",
+          children: data[dataKey.x]
+        }), /* @__PURE__ */ jsx14(Text, {
+          fz: "sm",
+          children: valueFormatter ? valueFormatter(data[dataKey.z]) : data[dataKey.z]
+        })]
+      })
+    });
+  }
+  return null;
+}
+var defaultProps10 = {
+  color: "blue.6",
+  withTooltip: true
+};
+var varsResolver9 = createVarsResolver((theme, { textColor, gridColor }) => ({ root: {
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined
+} }));
+var BubbleChart = factory((_props) => {
+  const props = useProps("BubbleChart", defaultProps10, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, xAxisProps, yAxisProps, zAxisProps, tooltipProps, scatterProps, color, label, withTooltip, dataKey, range, valueFormatter, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "BubbleChart",
+    classes: grid_chart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver9
+  });
+  const yAxisWidth = label ? undefined : { width: 0 };
+  return /* @__PURE__ */ jsx14(Box, {
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx14(ResponsiveContainer9, { children: /* @__PURE__ */ jsxs13(ScatterChart2, { children: [
+      /* @__PURE__ */ jsx14(XAxis5, {
+        type: "category",
+        dataKey: dataKey.x,
+        interval: 0,
+        tick: {
+          fontSize: 12,
+          fill: "currentColor"
+        },
+        tickLine: {
+          transform: "translate(0, -6)",
+          stroke: "currentColor"
+        },
+        stroke: "currentColor",
+        ...getStyles("axis"),
+        ...xAxisProps
+      }),
+      /* @__PURE__ */ jsx14(YAxis5, {
+        type: "number",
+        dataKey: dataKey.y,
+        height: 10,
+        ...yAxisWidth,
+        tick: false,
+        tickLine: false,
+        axisLine: false,
+        label: {
+          value: label,
+          position: "insideRight",
+          fontSize: 12,
+          fill: "currentColor"
+        },
+        ...getStyles("axis"),
+        ...yAxisProps
+      }),
+      /* @__PURE__ */ jsx14(ZAxis, {
+        type: "number",
+        dataKey: dataKey.z,
+        domain: getDomain(data, dataKey.z),
+        range,
+        ...zAxisProps
+      }),
+      withTooltip && /* @__PURE__ */ jsx14(Tooltip$18, {
+        animationDuration: 100,
+        isAnimationActive: false,
+        cursor: {
+          stroke: "var(--chart-grid-color)",
+          strokeWidth: 1,
+          strokeDasharray: "3 3"
+        },
+        content: (payload) => /* @__PURE__ */ jsx14(BubbleChartTooltip, {
+          dataKey,
+          active: payload.active,
+          payload: payload.payload,
+          getStyles,
+          valueFormatter
+        }),
+        ...tooltipProps
+      }),
+      /* @__PURE__ */ jsx14(Scatter2, {
+        data,
+        fill: getThemeColor(color, theme),
+        isAnimationActive: false,
+        ...scatterProps
+      })
+    ] }) })
+  });
+});
+BubbleChart.displayName = "@mantine/charts/BubbleChart";
+BubbleChart.classes = grid_chart_module_default;
+BubbleChart.varsResolver = varsResolver9;
+
+// node_modules/@mantine/charts/esm/CompositeChart/CompositeChart.mjs
+import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
+import { createElement as createElement4, useState as useState6 } from "react";
+import { Area as Area3, Bar as Bar2, CartesianGrid as CartesianGrid5, ComposedChart, Label as Label5, LabelList as LabelList3, Legend as Legend6, Line as Line2, ReferenceLine as ReferenceLine5, ResponsiveContainer as ResponsiveContainer10, Tooltip as Tooltip$19, XAxis as XAxis6, YAxis as YAxis6 } from "recharts";
+
+var defaultProps11 = {
+  withXAxis: true,
+  withYAxis: true,
+  withTooltip: true,
+  tooltipAnimationDuration: 0,
+  tickLine: "y",
+  strokeDasharray: "5 5",
+  gridAxis: "x",
+  withDots: true,
+  connectNulls: true,
+  strokeWidth: 2,
+  curveType: "monotone"
+};
+var varsResolver10 = createVarsResolver((theme, { textColor, gridColor }) => ({ root: {
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-grid-color": gridColor ? getThemeColor(gridColor, theme) : undefined
+} }));
+var CompositeChart = factory((_props) => {
+  const props = useProps("CompositeChart", defaultProps11, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withLegend, legendProps, series, onMouseLeave, dataKey, withTooltip, withXAxis, withYAxis, gridAxis, tickLine, xAxisProps, yAxisProps, unit, tooltipAnimationDuration, strokeDasharray, gridProps, tooltipProps, referenceLines, withDots, dotProps, activeDotProps, strokeWidth, connectNulls, curveType, dir, valueFormatter, children, lineProps, xAxisLabel, yAxisLabel, withRightYAxis, rightYAxisLabel, rightYAxisProps, withPointLabels, areaProps, barProps, withBarValueLabel, minBarSize, maxBarWidth, composedChartProps, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const withXTickLine = gridAxis !== "none" && (tickLine === "x" || tickLine === "xy");
+  const withYTickLine = gridAxis !== "none" && (tickLine === "y" || tickLine === "xy");
+  const [highlightedArea, setHighlightedArea] = useState6(null);
+  const shouldHighlight = highlightedArea !== null;
+  const handleMouseLeave = (event) => {
+    setHighlightedArea(null);
+    onMouseLeave?.(event);
+  };
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const getStyles = useStyles({
+    name: "CompositeChart",
+    classes: grid_chart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver10
+  });
+  const lines = series.map((item) => {
+    const color = getThemeColor(item.color, theme);
+    const dimmed = shouldHighlight && highlightedArea !== item.name;
+    if (item.type === "line")
+      return /* @__PURE__ */ createElement4(Line2, {
+        ...getStyles("line"),
+        key: item.name,
+        name: item.name,
+        dataKey: item.name,
+        dot: withDots ? {
+          fillOpacity: dimmed ? 0 : 1,
+          strokeOpacity: dimmed ? 0 : 1,
+          strokeWidth: 1,
+          fill: color,
+          stroke: color,
+          ...dotProps
+        } : false,
+        activeDot: withDots ? {
+          fill: "var(--mantine-color-white)",
+          stroke: color,
+          ...activeDotProps
+        } : false,
+        fill: color,
+        stroke: color,
+        strokeWidth,
+        isAnimationActive: false,
+        fillOpacity: dimmed ? 0 : 1,
+        strokeOpacity: dimmed ? 0.5 : 1,
+        connectNulls,
+        type: curveType,
+        strokeDasharray: item.strokeDasharray,
+        yAxisId: item.yAxisId || undefined,
+        label: withPointLabels ? /* @__PURE__ */ jsx15(PointLabel, { valueFormatter }) : undefined,
+        ...typeof lineProps === "function" ? lineProps(item) : lineProps
+      });
+    if (item.type === "area")
+      return /* @__PURE__ */ createElement4(Area3, {
+        ...getStyles("area"),
+        key: item.name,
+        name: item.name,
+        type: curveType,
+        dataKey: item.name,
+        fill: color,
+        strokeWidth,
+        stroke: color,
+        isAnimationActive: false,
+        connectNulls,
+        dot: withDots ? {
+          fillOpacity: dimmed ? 0 : 1,
+          strokeOpacity: dimmed ? 0 : 1,
+          strokeWidth: 1,
+          fill: color,
+          stroke: color,
+          ...dotProps
+        } : false,
+        activeDot: withDots ? {
+          fill: theme.white,
+          stroke: color,
+          strokeWidth: 2,
+          r: 4,
+          ...activeDotProps
+        } : false,
+        fillOpacity: dimmed ? 0 : 0.2,
+        strokeOpacity: dimmed ? 0.5 : 1,
+        strokeDasharray: item.strokeDasharray,
+        yAxisId: item.yAxisId || undefined,
+        label: withPointLabels ? /* @__PURE__ */ jsx15(PointLabel, { valueFormatter }) : undefined,
+        ...typeof areaProps === "function" ? areaProps(item) : areaProps
+      });
+    if (item.type === "bar")
+      return /* @__PURE__ */ createElement4(Bar2, {
+        ...getStyles("bar"),
+        key: item.name,
+        name: item.name,
+        dataKey: item.name,
+        fill: color,
+        stroke: color,
+        isAnimationActive: false,
+        fillOpacity: dimmed ? 0.1 : 1,
+        strokeOpacity: dimmed ? 0.2 : 0,
+        yAxisId: item.yAxisId || undefined,
+        minPointSize: minBarSize,
+        ...typeof barProps === "function" ? barProps(item) : barProps
+      }, withBarValueLabel && /* @__PURE__ */ jsx15(LabelList3, {
+        position: "top",
+        fontSize: 12,
+        fill: "var(--chart-bar-label-color, var(--mantine-color-dimmed))",
+        formatter: (val) => valueFormatter?.(val)
+      }));
+    return null;
+  });
+  const referenceLinesItems = referenceLines?.map((line, index) => {
+    const color = getThemeColor(line.color, theme);
+    return /* @__PURE__ */ jsx15(ReferenceLine5, {
+      stroke: line.color ? color : "var(--chart-grid-color)",
+      strokeWidth: 1,
+      yAxisId: line.yAxisId || undefined,
+      ...line,
+      label: {
+        fill: line.color ? color : "currentColor",
+        fontSize: 12,
+        position: line.labelPosition ?? "insideBottomLeft",
+        ...typeof line.label === "object" ? line.label : { value: line.label }
+      },
+      ...getStyles("referenceLine")
+    }, index);
+  });
+  const sharedYAxisProps = {
+    axisLine: false,
+    type: "number",
+    tickLine: withYTickLine ? { stroke: "currentColor" } : false,
+    allowDecimals: true,
+    unit,
+    tickFormatter: valueFormatter,
+    ...getStyles("axis")
+  };
+  return /* @__PURE__ */ jsx15(Box, {
+    ...getStyles("root"),
+    onMouseLeave: handleMouseLeave,
+    dir: dir || "ltr",
+    ...others,
+    children: /* @__PURE__ */ jsx15(ResponsiveContainer10, {
+      ...getStyles("container"),
+      children: /* @__PURE__ */ jsxs14(ComposedChart, {
+        data,
+        maxBarSize: maxBarWidth,
+        margin: {
+          bottom: xAxisLabel ? 30 : undefined,
+          left: yAxisLabel ? 10 : undefined,
+          right: yAxisLabel ? 5 : undefined
+        },
+        ...composedChartProps,
+        children: [
+          withLegend && /* @__PURE__ */ jsx15(Legend6, {
+            verticalAlign: "top",
+            content: (payload) => /* @__PURE__ */ jsx15(ChartLegend, {
+              payload: payload.payload,
+              onHighlight: setHighlightedArea,
+              legendPosition: legendProps?.verticalAlign || "top",
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              attributes
+            }),
+            ...legendProps
+          }),
+          /* @__PURE__ */ jsxs14(XAxis6, {
+            hide: !withXAxis,
+            dataKey,
+            tick: {
+              transform: "translate(0, 10)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            stroke: "",
+            interval: "preserveStartEnd",
+            tickLine: withXTickLine ? { stroke: "currentColor" } : false,
+            minTickGap: 5,
+            ...getStyles("axis"),
+            ...xAxisProps,
+            children: [xAxisLabel && /* @__PURE__ */ jsx15(Label5, {
+              position: "insideBottom",
+              offset: -20,
+              fontSize: 12,
+              ...getStyles("axisLabel"),
+              children: xAxisLabel
+            }), xAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs14(YAxis6, {
+            orientation: "left",
+            tick: {
+              transform: "translate(-10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withYAxis,
+            ...sharedYAxisProps,
+            ...yAxisProps,
+            children: [yAxisLabel && /* @__PURE__ */ jsx15(Label5, {
+              position: "insideLeft",
+              angle: -90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: yAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsxs14(YAxis6, {
+            yAxisId: "right",
+            orientation: "right",
+            tick: {
+              transform: "translate(10, 0)",
+              fontSize: 12,
+              fill: "currentColor"
+            },
+            hide: !withRightYAxis,
+            ...sharedYAxisProps,
+            ...rightYAxisProps,
+            children: [rightYAxisLabel && /* @__PURE__ */ jsx15(Label5, {
+              position: "insideRight",
+              angle: 90,
+              textAnchor: "middle",
+              fontSize: 12,
+              offset: -5,
+              ...getStyles("axisLabel"),
+              children: rightYAxisLabel
+            }), yAxisProps?.children]
+          }),
+          /* @__PURE__ */ jsx15(CartesianGrid5, {
+            strokeDasharray,
+            vertical: gridAxis === "y" || gridAxis === "xy",
+            horizontal: gridAxis === "x" || gridAxis === "xy",
+            ...getStyles("grid"),
+            ...gridProps
+          }),
+          withTooltip && /* @__PURE__ */ jsx15(Tooltip$19, {
+            animationDuration: tooltipAnimationDuration,
+            isAnimationActive: tooltipAnimationDuration !== 0,
+            position: { y: 0 },
+            cursor: {
+              stroke: "var(--chart-grid-color)",
+              strokeWidth: 1,
+              strokeDasharray
+            },
+            content: ({ label, payload, labelFormatter }) => /* @__PURE__ */ jsx15(ChartTooltip, {
+              label: labelFormatter && payload ? labelFormatter(label, payload) : label,
+              payload,
+              unit,
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              series,
+              valueFormatter,
+              attributes
+            }),
+            ...tooltipProps
+          }),
+          lines,
+          referenceLinesItems,
+          children
+        ]
+      })
+    })
+  });
+});
+CompositeChart.displayName = "@mantine/charts/CompositeChart";
+CompositeChart.classes = grid_chart_module_default;
+CompositeChart.varsResolver = varsResolver10;
+
+// node_modules/@mantine/charts/esm/RadialBarChart/RadialBarChart.module.mjs
+
+var RadialBarChart_module_default = {
+  root: "m_cd2bd9e5",
+  tooltip: "m_6bcc3420"
+};
+
+// node_modules/@mantine/charts/esm/RadialBarChart/RadialBarChart.mjs
+import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
+import { useState as useState7 } from "react";
+import { Legend as Legend7, RadialBar, RadialBarChart, ResponsiveContainer as ResponsiveContainer11, Tooltip as Tooltip$110 } from "recharts";
+
+var defaultProps12 = {
+  barSize: 20,
+  startAngle: 90,
+  endAngle: -270,
+  withBackground: true,
+  withTooltip: true
+};
+var varsResolver11 = createVarsResolver((theme, { emptyBackgroundColor }) => ({ root: { "--chart-empty-background": emptyBackgroundColor ? getThemeColor(emptyBackgroundColor, theme) : undefined } }));
+var RadialBarChart$1 = factory((_props) => {
+  const props = useProps("RadialBarChart", defaultProps12, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, barSize, withBackground, dataKey, radialBarProps, radialBarChartProps, withLabels, withLegend, legendProps, withTooltip, tooltipProps, startAngle, endAngle, attributes, ...others } = props;
+  const [highlightedArea, setHighlightedArea] = useState7(null);
+  const getStyles = useStyles({
+    name: "RadialBarChart",
+    classes: RadialBarChart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver11
+  });
+  const theme = useMantineTheme();
+  const dataWithResolvedColor = data.map(({ color, ...item }) => {
+    const resolvedColor = getThemeColor(color, theme);
+    return {
+      ...item,
+      fill: resolvedColor,
+      fillOpacity: highlightedArea ? highlightedArea === item.name ? item.opacity || 1 : 0.05 : item.opacity || 1
+    };
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  return /* @__PURE__ */ jsx16(Box, {
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx16(ResponsiveContainer11, { children: /* @__PURE__ */ jsxs15(RadialBarChart, {
+      margin: {
+        top: 0,
+        bottom: 0,
+        left: 0,
+        right: 0
+      },
+      innerRadius: "10%",
+      outerRadius: "100%",
+      cx: "50%",
+      cy: "50%",
+      barSize,
+      startAngle,
+      endAngle,
+      data: dataWithResolvedColor,
+      ...radialBarChartProps,
+      children: [
+        /* @__PURE__ */ jsx16(RadialBar, {
+          label: withLabels ? {
+            position: "insideStart",
+            fill: "var(--mantine-color-white)",
+            fontSize: 12
+          } : undefined,
+          background: withBackground ? { fill: "var(--chart-empty-background)" } : undefined,
+          dataKey,
+          isAnimationActive: false,
+          ...radialBarProps
+        }),
+        withLegend && /* @__PURE__ */ jsx16(Legend7, {
+          verticalAlign: "bottom",
+          content: (payload) => /* @__PURE__ */ jsx16(ChartLegend, {
+            payload: payload.payload?.map((item) => ({
+              ...item,
+              dataKey: item.payload?.name
+            })),
+            onHighlight: setHighlightedArea,
+            legendPosition: legendProps?.verticalAlign || "bottom",
+            classNames: resolvedClassNames,
+            styles: resolvedStyles,
+            centered: true,
+            attributes
+          }),
+          ...legendProps
+        }),
+        withTooltip && /* @__PURE__ */ jsx16(Tooltip$110, {
+          animationDuration: 0,
+          isAnimationActive: false,
+          cursor: { stroke: "var(--chart-cursor-color)" },
+          content: ({ payload }) => /* @__PURE__ */ jsxs15(Paper, {
+            ...getStyles("tooltip"),
+            children: [/* @__PURE__ */ jsxs15(Group, {
+              gap: "sm",
+              children: [/* @__PURE__ */ jsx16(ColorSwatch, {
+                color: payload?.[0]?.payload.fill,
+                size: 12,
+                withShadow: false
+              }), /* @__PURE__ */ jsx16("span", { children: payload?.[0]?.payload.name })]
+            }), /* @__PURE__ */ jsx16("span", { children: payload?.[0]?.payload[dataKey] })]
+          }),
+          ...tooltipProps
+        })
+      ]
+    }) })
+  });
+});
+RadialBarChart$1.displayName = "@mantine/core/RadialBarChart";
+RadialBarChart$1.classes = RadialBarChart_module_default;
+RadialBarChart$1.varsResolver = varsResolver11;
+
+// node_modules/@mantine/charts/esm/FunnelChart/FunnelChart.module.mjs
+
+var FunnelChart_module_default = { root: "m_80d531e7" };
+
+// node_modules/@mantine/charts/esm/FunnelChart/FunnelChart.mjs
+import { jsx as jsx17, jsxs as jsxs16 } from "react/jsx-runtime";
+import { Funnel, FunnelChart, LabelList as LabelList4, ResponsiveContainer as ResponsiveContainer12, Tooltip as Tooltip$111 } from "recharts";
+
+var defaultProps13 = {
+  withTooltip: true,
+  size: 300,
+  strokeWidth: 1,
+  withLabels: false,
+  labelsPosition: "right",
+  tooltipDataSource: "all"
+};
+var varsResolver12 = createVarsResolver((theme, { strokeColor, labelColor, size }) => ({ root: {
+  "--chart-stroke-color": strokeColor ? getThemeColor(strokeColor, theme) : undefined,
+  "--chart-labels-color": labelColor ? getThemeColor(labelColor, theme) : undefined,
+  "--chart-size": rem(size)
+} }));
+var FunnelChart$1 = factory((_props) => {
+  const props = useProps("FunnelChart", defaultProps13, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, withTooltip, tooltipAnimationDuration, tooltipProps, strokeWidth, withLabels, size, valueFormatter, children, funnelChartProps, funnelProps, labelsPosition, tooltipDataSource, strokeColor, labelColor, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "FunnelChart",
+    classes: FunnelChart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver12
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  return /* @__PURE__ */ jsx17(Box, {
+    size,
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx17(ResponsiveContainer12, { children: /* @__PURE__ */ jsxs16(FunnelChart, {
+      ...funnelChartProps,
+      children: [
+        /* @__PURE__ */ jsx17(Funnel, {
+          data: data.map((entry) => ({
+            ...entry,
+            fill: getThemeColor(entry.color, theme)
+          })),
+          dataKey: "value",
+          isAnimationActive: false,
+          stroke: "var(--chart-stroke-color, var(--mantine-color-body))",
+          strokeWidth,
+          ...funnelProps,
+          children: withLabels && /* @__PURE__ */ jsx17(LabelList4, {
+            position: labelsPosition,
+            fill: labelsPosition === "inside" ? "var(--chart-labels-color, var(--mantine-color-white))" : "var(--chart-labels-color, var(--mantine-color-dimmed))",
+            stroke: "none",
+            fontFamily: "var(--mantine-font-family)",
+            fontSize: 12,
+            dataKey: (entry) => {
+              return typeof valueFormatter === "function" ? valueFormatter(entry.value) : entry.value;
+            }
+          })
+        }),
+        withTooltip && /* @__PURE__ */ jsx17(Tooltip$111, {
+          animationDuration: tooltipAnimationDuration,
+          isAnimationActive: false,
+          content: ({ payload }) => /* @__PURE__ */ jsx17(ChartTooltip, {
+            payload: data,
+            classNames: resolvedClassNames,
+            styles: resolvedStyles,
+            type: "radial",
+            segmentId: tooltipDataSource === "segment" ? payload?.[0]?.name : undefined,
+            valueFormatter,
+            attributes
+          }),
+          ...tooltipProps
+        }),
+        children
+      ]
+    }) })
+  });
+});
+FunnelChart$1.displayName = "@mantine/charts/FunnelChart";
+FunnelChart$1.classes = FunnelChart_module_default;
+FunnelChart$1.varsResolver = varsResolver12;
+
+// node_modules/@mantine/charts/esm/Heatmap/get-boundaries/get-boundaries.mjs
+
+function getBoundaries({ data, domain }) {
+  if (Array.isArray(domain))
+    return domain;
+  const values = Object.values(data);
+  return [Math.min(...values), Math.max(...values)];
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/get-columns/get-columns.mjs
+
+function getColumns(datesRange, splitMonths) {
+  if (!splitMonths)
+    return datesRange.map((week, weekIndex) => {
+      const firstDay = week.find((d) => d !== null);
+      return {
+        type: "column",
+        month: new Date(firstDay).getUTCMonth(),
+        weekIndex
+      };
+    });
+  const tmp = [];
+  datesRange.forEach((week, weekIndex) => {
+    const months = week.map((d) => d ? new Date(d).getUTCMonth() : null);
+    let firstMonth = null;
+    let boundaryIndex = null;
+    for (let i = 0;i < months.length; i += 1) {
+      if (months[i] === null)
+        continue;
+      if (firstMonth === null)
+        firstMonth = months[i];
+      else if (months[i] !== firstMonth) {
+        boundaryIndex = i;
+        break;
+      }
+    }
+    if (firstMonth === null)
+      return;
+    if (boundaryIndex === null)
+      tmp.push({
+        type: "column",
+        month: firstMonth,
+        weekIndex
+      });
+    else {
+      let nextMonth = null;
+      for (let i = boundaryIndex;i < months.length; i += 1)
+        if (months[i] !== null) {
+          nextMonth = months[i];
+          break;
+        }
+      if (nextMonth === null)
+        tmp.push({
+          type: "column",
+          month: firstMonth,
+          weekIndex
+        });
+      else {
+        tmp.push({
+          type: "column",
+          month: firstMonth,
+          weekIndex
+        });
+        tmp.push({
+          type: "column",
+          month: nextMonth,
+          weekIndex
+        });
+      }
+    }
+  });
+  const columns = [];
+  for (let i = 0;i < tmp.length; i += 1) {
+    if (i > 0 && tmp[i].month !== tmp[i - 1].month)
+      columns.push({ type: "spacer" });
+    columns.push(tmp[i]);
+  }
+  return columns;
+}
+function getFirstMonthColumnIndex(columns, month) {
+  for (let i = 0;i < columns.length; i += 1) {
+    const c = columns[i];
+    if (c.type === "column" && c.month === month)
+      return i;
+  }
+  return -1;
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/get-dates-range/get-dates-range.mjs
+
+function formatDate(date) {
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+}
+function addDays(date, days) {
+  return new Date(date.getTime() + days * 86400000);
+}
+function toUtcMidnight(input) {
+  if (typeof input === "string") {
+    const m = input.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (m) {
+      const year = Number(m[1]);
+      const month = Number(m[2]) - 1;
+      const day = Number(m[3]);
+      return new Date(Date.UTC(year, month, day));
+    }
+    const d = new Date(input);
+    return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+  }
+  return new Date(Date.UTC(input.getFullYear(), input.getMonth(), input.getDate()));
+}
+function startOfWeekUtc(date, firstDayOfWeek) {
+  let value = new Date(date);
+  while (value.getUTCDay() !== firstDayOfWeek)
+    value = addDays(value, -1);
+  return value;
+}
+function endOfWeekUtc(date, firstDayOfWeek) {
+  const day = date.getUTCDay();
+  return addDays(date, 6 - ((day < firstDayOfWeek ? 7 : 0) + day - firstDayOfWeek));
+}
+function getDatesRange({ startDate, endDate, withOutsideDates = true, firstDayOfWeek = 1 } = {}) {
+  const now = /* @__PURE__ */ new Date;
+  const defaultStartLocal = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+  const defaultEndLocal = now;
+  const start = startDate ? toUtcMidnight(startDate) : toUtcMidnight(defaultStartLocal);
+  const end = endDate ? toUtcMidnight(endDate) : toUtcMidnight(defaultEndLocal);
+  const startWeek = startOfWeekUtc(start, firstDayOfWeek);
+  const endWeek = endOfWeekUtc(end, firstDayOfWeek);
+  const dates = [];
+  let current = startWeek;
+  while (current <= endWeek) {
+    const week = Array.from({ length: 7 }, (_, i) => {
+      const day = addDays(current, i);
+      return withOutsideDates || day >= start && day <= end ? formatDate(day) : null;
+    });
+    dates.push(week);
+    current = addDays(current, 7);
+  }
+  return dates;
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/get-months-range/get-months-range.mjs
+
+function getMonthsRange(weeksData) {
+  let position = 0;
+  let current = null;
+  const result = [];
+  weeksData.forEach((week) => {
+    const day = week[0] === null ? week[week.length - 1] : week[0];
+    const month = new Date(day).getUTCMonth();
+    if (current !== month) {
+      current = month;
+      result.push({
+        month: current,
+        position,
+        size: 0
+      });
+    }
+    result[result.length - 1].size += 1;
+    position += 1;
+  });
+  return result;
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/get-heat-color/get-heat-color.mjs
+
+function getHeatColor({ value, min, max, colors }) {
+  const percent = max === min ? 1 : (value - min) / (max - min);
+  return colors[Math.round((colors.length - 1) * percent)];
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/HeatmapSplitWeeks.mjs
+import { Fragment as Fragment2, jsx as jsx18 } from "react/jsx-runtime";
+
+function HeatmapSplitWeeks({ data, datesRange, rectSize, gap, rectRadius, min, max, colors, withTooltip, setHoveredRect, getRectProps, getStyles }) {
+  const rectSizeWithGap = rectSize + gap;
+  return /* @__PURE__ */ jsx18(Fragment2, { children: getColumns(datesRange, true).map((col, columnIndex) => {
+    if (col.type === "spacer")
+      return /* @__PURE__ */ jsx18("g", { transform: `translate(${columnIndex * rectSizeWithGap}, 0)` }, `spacer-${columnIndex}`);
+    const days = datesRange[col.weekIndex].map((date, dayIndex) => {
+      if (!date)
+        return null;
+      if (new Date(date).getUTCMonth() !== col.month)
+        return null;
+      const hasValue = date in data && data[date] !== null;
+      const rectValue = hasValue ? data[date] : null;
+      return /* @__PURE__ */ jsx18("rect", {
+        width: rectSize,
+        height: rectSize,
+        x: gap,
+        y: dayIndex * rectSizeWithGap + gap,
+        rx: rectRadius,
+        "data-empty": !hasValue || undefined,
+        fill: hasValue ? getHeatColor({
+          value: data[date],
+          min,
+          max,
+          colors
+        }) : undefined,
+        onPointerEnter: withTooltip ? () => setHoveredRect({
+          date,
+          value: rectValue
+        }) : undefined,
+        ...getRectProps?.({
+          date,
+          value: rectValue
+        }),
+        ...getStyles("rect")
+      }, `${date}-${col.month}`);
+    });
+    return /* @__PURE__ */ jsx18("g", {
+      transform: `translate(${columnIndex * rectSizeWithGap}, 0)`,
+      "data-id": "week",
+      children: days
+    }, `col-${col.weekIndex}-${col.month}-${columnIndex}`);
+  }) });
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/HeatmapWeeks.mjs
+import { Fragment as Fragment3, jsx as jsx19 } from "react/jsx-runtime";
+
+function HeatmapWeeks({ data, datesRange, rectSize, gap, rectRadius, min, max, colors, withTooltip, setHoveredRect, getRectProps, getStyles }) {
+  const rectSizeWithGap = rectSize + gap;
+  return /* @__PURE__ */ jsx19(Fragment3, { children: datesRange.map((week, weekIndex) => {
+    const days = week.map((date, dayIndex) => {
+      if (!date)
+        return null;
+      const hasValue = date in data && data[date] !== null;
+      const rectValue = hasValue ? data[date] : null;
+      return /* @__PURE__ */ jsx19("rect", {
+        width: rectSize,
+        height: rectSize,
+        x: gap,
+        y: dayIndex * rectSizeWithGap + gap,
+        rx: rectRadius,
+        "data-empty": !hasValue || undefined,
+        fill: hasValue ? getHeatColor({
+          value: data[date],
+          min,
+          max,
+          colors
+        }) : undefined,
+        onPointerEnter: withTooltip ? () => setHoveredRect({
+          date,
+          value: rectValue
+        }) : undefined,
+        ...getRectProps?.({
+          date,
+          value: rectValue
+        }),
+        ...getStyles("rect")
+      }, date);
+    });
+    return /* @__PURE__ */ jsx19("g", {
+      transform: `translate(${weekIndex * rectSizeWithGap}, 0)`,
+      "data-id": "week",
+      children: days
+    }, weekIndex);
+  }) });
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/rotate-weekdays-names/rotate-weekdays-names.mjs
+
+function rotateWeekdaysNames(weekdayNames, firstDayOfWeek) {
+  const rotated = [...weekdayNames];
+  for (let i = 0;i < firstDayOfWeek; i += 1)
+    rotated.push(rotated.shift());
+  return rotated;
+}
+
+// node_modules/@mantine/charts/esm/Heatmap/Heatmap.module.mjs
+
+var Heatmap_module_default = {
+  root: "m_2ef228c3",
+  rect: "m_2ef201c5",
+  monthLabel: "m_7e977775",
+  weekdayLabel: "m_c4b68f8d",
+  legendLabel: "m_75b4f3e6",
+  legendRect: "m_da847eb2"
+};
+
+// node_modules/@mantine/charts/esm/Heatmap/Heatmap.mjs
+import { jsx as jsx20, jsxs as jsxs17 } from "react/jsx-runtime";
+import { useMemo as useMemo2, useState as useState8 } from "react";
+
+var defaultProps14 = {
+  monthLabels: [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ],
+  weekdayLabels: [
+    "Sun",
+    "Mon",
+    "",
+    "Wed",
+    "",
+    "Fri",
+    ""
+  ],
+  withOutsideDates: true,
+  firstDayOfWeek: 1,
+  rectSize: 10,
+  weekdaysLabelsWidth: 30,
+  monthsLabelsHeight: 14,
+  gap: 1,
+  rectRadius: 2,
+  fontSize: 12,
+  colors: [
+    "var(--heatmap-level-1)",
+    "var(--heatmap-level-2)",
+    "var(--heatmap-level-3)",
+    "var(--heatmap-level-4)"
+  ],
+  legendLabels: ["Less", "More"]
+};
+var Heatmap = factory((_props) => {
+  const props = useProps("Heatmap", defaultProps14, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, startDate, endDate, withMonthLabels, withWeekdayLabels, weekdayLabels, withOutsideDates, monthLabels, firstDayOfWeek, rectSize = 10, gap = 1, rectRadius, domain, colors, weekdaysLabelsWidth, monthsLabelsHeight, fontSize, getTooltipLabel, withTooltip, tooltipProps, getRectProps, splitMonths, withLegend, legendLabels, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: "Heatmap",
+    classes: Heatmap_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars
+  });
+  const [hoveredRect, setHoveredRect] = useState8(null);
+  const rectSizeWithGap = rectSize + gap;
+  const weekdaysOffset = withWeekdayLabels ? weekdaysLabelsWidth : 0;
+  const monthsOffset = withMonthLabels ? monthsLabelsHeight : 0;
+  const [min, max] = getBoundaries({
+    data,
+    domain
+  });
+  const rotatedWeekdayLabels = useMemo2(() => rotateWeekdaysNames(weekdayLabels, firstDayOfWeek), [weekdayLabels, firstDayOfWeek]);
+  const datesRange = getDatesRange({
+    startDate,
+    endDate,
+    withOutsideDates,
+    firstDayOfWeek
+  });
+  const monthsRange = withMonthLabels || splitMonths ? getMonthsRange(datesRange) : [];
+  const weeksProps = {
+    data,
+    datesRange,
+    rectSize,
+    gap,
+    rectRadius,
+    min,
+    max,
+    colors,
+    withTooltip,
+    setHoveredRect,
+    getRectProps,
+    getStyles
+  };
+  const weeks = splitMonths ? /* @__PURE__ */ jsx20(HeatmapSplitWeeks, { ...weeksProps }) : /* @__PURE__ */ jsx20(HeatmapWeeks, { ...weeksProps });
+  const totalColumns = splitMonths ? getColumns(datesRange, splitMonths).length : datesRange.length;
+  const computeMonthLabelX = (monthPosition, monthIndex) => {
+    if (!splitMonths)
+      return monthPosition * rectSizeWithGap + gap + weekdaysOffset;
+    const firstMonth = monthsRange[monthIndex];
+    const i = getFirstMonthColumnIndex(getColumns(datesRange, splitMonths), firstMonth.month);
+    return ((i >= 0 ? i : monthPosition) + 1) * rectSizeWithGap + gap + weekdaysOffset;
+  };
+  const monthsLabelsNodes = withMonthLabels && monthLabels ? monthsRange.map((month, monthIndex) => {
+    const minSize = splitMonths ? 2 : 3;
+    if (month.size < minSize)
+      return null;
+    const monthLabel = monthLabels[month.month];
+    return /* @__PURE__ */ jsx20("text", {
+      x: computeMonthLabelX(month.position, monthIndex),
+      y: monthsLabelsHeight - 4,
+      width: month.size * rectSizeWithGap,
+      fontSize,
+      ...getStyles("monthLabel"),
+      children: monthLabel
+    }, monthIndex);
+  }) : null;
+  const weekdayLabelsNodes = withWeekdayLabels && weekdayLabels ? rotatedWeekdayLabels.map((weekdayLabel, dayIndex) => /* @__PURE__ */ jsx20("text", {
+    x: 0,
+    y: (dayIndex + 1) * rectSizeWithGap - gap + monthsOffset,
+    width: weekdaysLabelsWidth,
+    fontSize,
+    ...getStyles("weekdayLabel"),
+    children: weekdayLabel
+  }, dayIndex)) : null;
+  const label = getTooltipLabel && hoveredRect && withTooltip ? getTooltipLabel(hoveredRect) : null;
+  const legendPadding = 10;
+  const legendHeight = withLegend ? legendPadding + rectSize : 0;
+  const svgWidth = rectSizeWithGap * totalColumns + gap + weekdaysOffset;
+  const legendNode = withLegend ? (() => {
+    const lessLabel = legendLabels[0];
+    const moreLabel = legendLabels[1];
+    const textGap = 6;
+    const charWidth = fontSize * 0.6;
+    const lessWidth = lessLabel.length * charWidth;
+    const allColors = [undefined, ...colors || []];
+    const rectsWidth = allColors.length * rectSize + (allColors.length - 1) * gap;
+    const moreWidth = moreLabel.length * charWidth;
+    return /* @__PURE__ */ jsxs17("g", {
+      transform: `translate(${svgWidth - (lessWidth + textGap + rectsWidth + textGap + moreWidth)}, ${rectSizeWithGap * 7 + gap + monthsOffset + legendPadding})`,
+      "data-id": "legend",
+      ...getStyles("legend"),
+      children: [
+        /* @__PURE__ */ jsx20("text", {
+          x: 0,
+          y: rectSize / 2,
+          fontSize,
+          dominantBaseline: "central",
+          ...getStyles("legendLabel"),
+          children: lessLabel
+        }),
+        allColors.map((color, i) => /* @__PURE__ */ jsx20("rect", {
+          x: lessWidth + textGap + i * (rectSize + gap),
+          y: 0,
+          width: rectSize,
+          height: rectSize,
+          rx: rectRadius,
+          fill: color,
+          "data-empty": color === undefined || undefined,
+          ...getStyles("legendRect")
+        }, i)),
+        /* @__PURE__ */ jsx20("text", {
+          x: lessWidth + textGap + rectsWidth + textGap,
+          y: rectSize / 2,
+          fontSize,
+          dominantBaseline: "central",
+          ...getStyles("legendLabel"),
+          children: moreLabel
+        })
+      ]
+    });
+  })() : null;
+  return /* @__PURE__ */ jsxs17(Box, {
+    component: "svg",
+    width: svgWidth,
+    height: rectSizeWithGap * 7 + gap + monthsOffset + legendHeight,
+    ...getStyles("root"),
+    ...others,
+    children: [
+      /* @__PURE__ */ jsx20(Tooltip.Floating, {
+        label,
+        disabled: !withTooltip || !label,
+        position: "top",
+        ...tooltipProps,
+        children: /* @__PURE__ */ jsxs17("g", {
+          transform: `translate(${weekdaysOffset}, ${monthsOffset})`,
+          "data-id": "all-weeks",
+          children: [withTooltip && /* @__PURE__ */ jsx20("rect", {
+            fill: "transparent",
+            width: rectSizeWithGap * totalColumns + gap,
+            height: rectSizeWithGap * 7 + gap
+          }), weeks]
+        })
+      }),
+      weekdayLabelsNodes,
+      monthsLabelsNodes,
+      legendNode
+    ]
+  });
+});
+Heatmap.displayName = "@mantine/charts/Heatmap";
+Heatmap.classes = Heatmap_module_default;
+
+// node_modules/@mantine/charts/esm/BarsList/BarsList.module.mjs
+
+var BarsList_module_default = {
+  root: "m_1ea785b1",
+  labelsRow: "m_294011ec",
+  bar: "m_9de42164",
+  barLabel: "m_6f89abf0",
+  barValue: "m_7016be6d"
+};
+
+// node_modules/@mantine/charts/esm/BarsList/BarsList.mjs
+import { jsx as jsx21, jsxs as jsxs18 } from "react/jsx-runtime";
+import { useMemo as useMemo3 } from "react";
+
+var defaultProps15 = {
+  barGap: 5,
+  minBarSize: 0,
+  barHeight: 32
+};
+var varsResolver13 = createVarsResolver((_theme, { barGap, minBarSize, barHeight }) => ({ root: {
+  "--bars-list-gap": getSpacing(barGap),
+  "--bars-list-min-bar-size": rem(minBarSize),
+  "--bars-list-bar-height": rem(barHeight)
+} }));
+var BarsList = factory((_props) => {
+  const props = useProps("BarsList", defaultProps15, _props);
+  const { classNames, className, style, styles, unstyled, vars, attributes, data, valueFormatter, barsLabel, valueLabel, getBarProps, renderBar, barGap, minBarSize, barHeight, barColor, barTextColor, autoContrast, variant, ...others } = props;
+  const theme = useMantineTheme();
+  const getStyles = useStyles({
+    name: "BarsList",
+    classes: BarsList_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver13
+  });
+  const maxValue = useMemo3(() => Math.max(...data.map((item) => item.value), 0), [data]);
+  const formatValue = (value) => {
+    if (valueFormatter)
+      return valueFormatter(value);
+    return value.toString();
+  };
+  const bars = data.map((item, index) => {
+    const percentage = maxValue > 0 ? item.value / maxValue * 100 : 0;
+    const { style: barPropsStyle, className: barPropsClassName, ...restBarProps } = getBarProps ? getBarProps(item) : {};
+    const itemBarColor = item.color || barColor || theme.primaryColor;
+    const colors = theme.variantColorResolver({
+      color: itemBarColor,
+      theme,
+      variant: item.variant || variant || "light",
+      autoContrast
+    });
+    const backgroundColor = colors.background;
+    const textColor = item.textColor || barTextColor ? getThemeColor(item.textColor || barTextColor, theme) : colors.color;
+    const defaultBar = /* @__PURE__ */ jsxs18("div", {
+      ...getStyles("bar"),
+      children: [/* @__PURE__ */ jsx21("div", {
+        ...getStyles("barLabel", {
+          className: barPropsClassName,
+          style: {
+            width: `${percentage}%`,
+            backgroundColor,
+            color: textColor,
+            padding: percentage === 0 ? 0 : undefined,
+            ...barPropsStyle
+          }
+        }),
+        ...restBarProps,
+        children: item.name
+      }), /* @__PURE__ */ jsx21("div", {
+        ...getStyles("barValue"),
+        children: formatValue(item.value)
+      })]
+    }, index);
+    if (renderBar)
+      return /* @__PURE__ */ jsx21("div", { children: renderBar(item, defaultBar) }, index);
+    return defaultBar;
+  });
+  const labelsRow = barsLabel || valueLabel ? /* @__PURE__ */ jsxs18("div", {
+    ...getStyles("labelsRow"),
+    children: [/* @__PURE__ */ jsx21("div", { children: barsLabel }), /* @__PURE__ */ jsx21("div", { children: valueLabel })]
+  }) : null;
+  return /* @__PURE__ */ jsxs18(Box, {
+    ...getStyles("root"),
+    variant,
+    ...others,
+    children: [labelsRow, bars]
+  });
+});
+BarsList.displayName = "@mantine/charts/BarsList";
+BarsList.classes = BarsList_module_default;
+BarsList.varsResolver = varsResolver13;
+
+// node_modules/@mantine/charts/esm/Treemap/Treemap.module.mjs
+
+var Treemap_module_default = { root: "m_3c064071" };
+
+// node_modules/@mantine/charts/esm/Treemap/Treemap.mjs
+import { jsx as jsx22, jsxs as jsxs19 } from "react/jsx-runtime";
+import"react";
+import { ResponsiveContainer as ResponsiveContainer13, Tooltip as Tooltip$112, Treemap } from "recharts";
+
+var defaultProps16 = {
+  dataKey: "value",
+  withTooltip: true,
+  tooltipAnimationDuration: 0,
+  height: 300,
+  strokeWidth: 1,
+  aspectRatio: 0.5 * (1 + Math.sqrt(5))
+};
+var varsResolver14 = createVarsResolver((theme, { strokeColor, height }) => ({ root: {
+  "--chart-stroke-color": strokeColor ? getThemeColor(strokeColor, theme) : undefined,
+  "--chart-height": rem(height)
+} }));
+function TreemapContent({ x, y, width, height, depth, name, resolvedColors, resolvedLabelColors, index, strokeWidth }) {
+  const fill = resolvedColors[name] || `var(--mantine-color-blue-${index % 9 + 1})`;
+  const labelColor = resolvedLabelColors[name] || "var(--mantine-color-white)";
+  return /* @__PURE__ */ jsxs19("g", { children: [/* @__PURE__ */ jsx22("rect", {
+    x,
+    y,
+    width,
+    height,
+    fill: depth >= 1 ? fill : "transparent",
+    stroke: "var(--chart-stroke-color, var(--mantine-color-body))",
+    strokeWidth: depth >= 1 ? strokeWidth : 0
+  }), depth >= 1 && width > 30 && height > 20 && /* @__PURE__ */ jsx22("text", {
+    x: x + width / 2,
+    y: y + height / 2,
+    textAnchor: "middle",
+    dominantBaseline: "central",
+    fill: labelColor,
+    fontSize: 12,
+    fontFamily: "var(--mantine-font-family)",
+    children: name
+  })] });
+}
+function resolveColors(data, theme, parentColor) {
+  const result = {};
+  for (const item of data) {
+    const color = item.color || parentColor;
+    if (color)
+      result[item.name] = parseThemeColor({
+        color,
+        theme
+      }).value;
+    if (item.children)
+      Object.assign(result, resolveColors(item.children, theme, color));
+  }
+  return result;
+}
+function resolveLabelColors(resolvedColors, autoContrast, luminanceThreshold, textColor) {
+  const result = {};
+  for (const [name, color] of Object.entries(resolvedColors))
+    if (textColor)
+      result[name] = textColor;
+    else if (autoContrast)
+      result[name] = isLightColor(color, luminanceThreshold) ? "var(--mantine-color-black)" : "var(--mantine-color-white)";
+  return result;
+}
+var Treemap$1 = factory((_props) => {
+  const props = useProps("Treemap", defaultProps16, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, dataKey, aspectRatio, withTooltip, tooltipAnimationDuration, tooltipProps, treemapProps, strokeColor, textColor, height: chartHeight, strokeWidth, valueFormatter, autoContrast, children, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const resolvedColors = resolveColors(data, theme);
+  const _autoContrast = getAutoContrastValue(autoContrast, theme);
+  const _textColor = textColor ? getThemeColor(textColor, theme) : undefined;
+  const resolvedLabelColors = resolveLabelColors(resolvedColors, _autoContrast, theme.luminanceThreshold, _textColor);
+  const getStyles = useStyles({
+    name: "Treemap",
+    classes: Treemap_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver14
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  return /* @__PURE__ */ jsx22(Box, {
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx22(ResponsiveContainer13, {
+      height: chartHeight,
+      children: /* @__PURE__ */ jsxs19(Treemap, {
+        data,
+        dataKey,
+        aspectRatio,
+        isAnimationActive: false,
+        content: (nodeProps) => /* @__PURE__ */ jsx22(TreemapContent, {
+          ...nodeProps,
+          resolvedColors,
+          resolvedLabelColors,
+          strokeWidth
+        }),
+        ...treemapProps,
+        children: [withTooltip && /* @__PURE__ */ jsx22(Tooltip$112, {
+          animationDuration: tooltipAnimationDuration,
+          isAnimationActive: false,
+          content: ({ payload }) => /* @__PURE__ */ jsx22(ChartTooltip, {
+            payload: payload?.map((item) => ({
+              name: item.name,
+              value: item.value,
+              color: resolvedColors[item.name] || "var(--mantine-color-blue-6)"
+            })) || [],
+            classNames: resolvedClassNames,
+            styles: resolvedStyles,
+            type: "radial",
+            valueFormatter,
+            attributes
+          }),
+          ...tooltipProps
+        }), children]
+      })
+    })
+  });
+});
+Treemap$1.displayName = "@mantine/charts/Treemap";
+Treemap$1.classes = Treemap_module_default;
+Treemap$1.varsResolver = varsResolver14;
+
+// node_modules/@mantine/charts/esm/SankeyChart/SankeyChart.module.mjs
+
+var SankeyChart_module_default = { root: "m_b42d2970" };
+
+// node_modules/@mantine/charts/esm/SankeyChart/SankeyChart.mjs
+import { Fragment as Fragment4, jsx as jsx23, jsxs as jsxs20 } from "react/jsx-runtime";
+import"react";
+import { ResponsiveContainer as ResponsiveContainer14, Sankey, Tooltip as Tooltip$113 } from "recharts";
+
+var defaultProps17 = {
+  height: 300,
+  nodeWidth: 10,
+  nodePadding: 10,
+  linkCurvature: 0.5,
+  iterations: 32,
+  linkOpacity: 0.4,
+  withTooltip: true,
+  tooltipAnimationDuration: 0
+};
+var varsResolver15 = createVarsResolver((theme, { nodeColor, linkColor, textColor, height }) => ({ root: {
+  "--chart-node-color": nodeColor ? getThemeColor(nodeColor, theme) : undefined,
+  "--chart-link-color": linkColor ? getThemeColor(linkColor, theme) : undefined,
+  "--chart-text-color": textColor ? getThemeColor(textColor, theme) : undefined,
+  "--chart-height": rem(height)
+} }));
+var DEFAULT_COLORS = [
+  "var(--mantine-color-blue-filled)",
+  "var(--mantine-color-cyan-filled)",
+  "var(--mantine-color-teal-filled)",
+  "var(--mantine-color-green-filled)",
+  "var(--mantine-color-lime-filled)",
+  "var(--mantine-color-yellow-filled)",
+  "var(--mantine-color-orange-filled)",
+  "var(--mantine-color-red-filled)",
+  "var(--mantine-color-pink-filled)",
+  "var(--mantine-color-grape-filled)",
+  "var(--mantine-color-violet-filled)",
+  "var(--mantine-color-indigo-filled)"
+];
+function SankeyNodeContent({ x, y, width, height, index, payload, resolvedNodeColors, resolvedDefaultColors, valueFormatter }) {
+  const fill = resolvedNodeColors[index] || `var(--chart-node-color, ${resolvedDefaultColors[index % resolvedDefaultColors.length]})`;
+  const isLeaf = !payload.targetNodes || payload.targetNodes.length === 0;
+  const labelX = isLeaf ? x - 6 : x + width + 6;
+  const textAnchor = isLeaf ? "end" : "start";
+  const formattedValue = valueFormatter ? valueFormatter(payload.value) : payload.value;
+  return /* @__PURE__ */ jsxs20("g", { children: [/* @__PURE__ */ jsx23("rect", {
+    x,
+    y,
+    width,
+    height,
+    fill,
+    stroke: "none"
+  }), height >= 28 ? /* @__PURE__ */ jsxs20(Fragment4, { children: [/* @__PURE__ */ jsx23("text", {
+    x: labelX,
+    y: y + height / 2 - 7,
+    textAnchor,
+    dominantBaseline: "central",
+    fill: "var(--chart-text-color, var(--mantine-color-text))",
+    fontSize: 12,
+    fontFamily: "var(--mantine-font-family)",
+    children: payload.name
+  }), /* @__PURE__ */ jsx23("text", {
+    x: labelX,
+    y: y + height / 2 + 7,
+    textAnchor,
+    dominantBaseline: "central",
+    fill: "var(--chart-text-color, var(--mantine-color-text))",
+    fontSize: 12,
+    fontFamily: "var(--mantine-font-family)",
+    opacity: 0.8,
+    children: formattedValue
+  })] }) : /* @__PURE__ */ jsxs20("text", {
+    x: labelX,
+    y: y + height / 2,
+    textAnchor,
+    dominantBaseline: "central",
+    fill: "var(--chart-text-color, var(--mantine-color-text))",
+    fontSize: 12,
+    fontFamily: "var(--mantine-font-family)",
+    children: [
+      payload.name,
+      " ",
+      /* @__PURE__ */ jsx23("tspan", {
+        opacity: 0.8,
+        children: formattedValue
+      })
+    ]
+  })] });
+}
+function SankeyLinkContent({ sourceX, targetX, sourceY, targetY, sourceControlX, targetControlX, linkWidth, sourceResolvedColor, linkOpacity }) {
+  const fill = sourceResolvedColor || "var(--chart-link-color, var(--mantine-color-gray-4))";
+  return /* @__PURE__ */ jsx23("path", {
+    d: `
+        M${sourceX},${sourceY + linkWidth / 2}
+        C${sourceControlX},${sourceY + linkWidth / 2}
+          ${targetControlX},${targetY + linkWidth / 2}
+          ${targetX},${targetY + linkWidth / 2}
+        L${targetX},${targetY - linkWidth / 2}
+        C${targetControlX},${targetY - linkWidth / 2}
+          ${sourceControlX},${sourceY - linkWidth / 2}
+          ${sourceX},${sourceY - linkWidth / 2}
+        Z
+      `,
+    fill,
+    opacity: linkOpacity,
+    stroke: "none"
+  });
+}
+var SankeyChart = factory((_props) => {
+  const props = useProps("SankeyChart", defaultProps17, _props);
+  const { classNames, className, style, styles, unstyled, vars, data, height: chartHeight, nodeWidth, nodePadding, linkCurvature, iterations, nodeColor, colors, linkColor, linkOpacity, textColor, withTooltip, tooltipAnimationDuration, tooltipProps, sankeyProps, valueFormatter, children, attributes, ...others } = props;
+  const theme = useMantineTheme();
+  const resolvedNodeColors = {};
+  data.nodes.forEach((node, index) => {
+    if (node.color)
+      resolvedNodeColors[index] = getThemeColor(node.color, theme);
+  });
+  const resolvedDefaultColors = colors ? colors.map((color) => getThemeColor(color, theme)) : DEFAULT_COLORS;
+  const getStyles = useStyles({
+    name: "SankeyChart",
+    classes: SankeyChart_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver15
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  return /* @__PURE__ */ jsx23(Box, {
+    ...getStyles("root"),
+    ...others,
+    children: /* @__PURE__ */ jsx23(ResponsiveContainer14, {
+      height: chartHeight,
+      children: /* @__PURE__ */ jsxs20(Sankey, {
+        data,
+        nodeWidth,
+        nodePadding,
+        linkCurvature,
+        iterations,
+        node: (nodeProps) => /* @__PURE__ */ jsx23(SankeyNodeContent, {
+          ...nodeProps,
+          resolvedNodeColors,
+          resolvedDefaultColors,
+          valueFormatter
+        }),
+        link: (linkProps) => {
+          const sourceIndex = linkProps.index >= 0 && linkProps.index < data.links.length ? data.links[linkProps.index].source : -1;
+          return /* @__PURE__ */ jsx23(SankeyLinkContent, {
+            ...linkProps,
+            sourceResolvedColor: resolvedNodeColors[sourceIndex],
+            linkOpacity
+          });
+        },
+        ...sankeyProps,
+        children: [withTooltip && /* @__PURE__ */ jsx23(Tooltip$113, {
+          animationDuration: tooltipAnimationDuration,
+          isAnimationActive: false,
+          content: ({ payload }) => {
+            const resolveColor = (item) => {
+              const nodeIndex = data.nodes.findIndex((n) => n.name === item.name);
+              if (nodeIndex !== -1)
+                return resolvedNodeColors[nodeIndex] || resolvedDefaultColors[nodeIndex % resolvedDefaultColors.length];
+              const sourceNode = item.payload?.source;
+              if (sourceNode) {
+                const sourceIndex = data.nodes.findIndex((n) => n.name === sourceNode.name);
+                if (sourceIndex !== -1)
+                  return resolvedNodeColors[sourceIndex] || resolvedDefaultColors[sourceIndex % resolvedDefaultColors.length];
+              }
+              return "var(--mantine-color-blue-6)";
+            };
+            return /* @__PURE__ */ jsx23(ChartTooltip, {
+              payload: payload?.map((item) => ({
+                name: item.name,
+                value: item.value,
+                color: resolveColor(item)
+              })) || [],
+              classNames: resolvedClassNames,
+              styles: resolvedStyles,
+              type: "radial",
+              valueFormatter,
+              attributes
+            });
+          },
+          ...tooltipProps
+        }), children]
+      })
+    })
+  });
+});
+SankeyChart.displayName = "@mantine/charts/SankeyChart";
+SankeyChart.classes = SankeyChart_module_default;
+SankeyChart.varsResolver = varsResolver15;
+export {
+  getSplitOffset,
+  getFilteredChartTooltipPayload,
+  getFilteredChartLegendPayload,
+  Treemap$1 as Treemap,
+  Sparkline,
+  ScatterChart$1 as ScatterChart,
+  SankeyChart,
+  RadialBarChart$1 as RadialBarChart,
+  RadarChart$1 as RadarChart,
+  PieChart$1 as PieChart,
+  LineChart$1 as LineChart,
+  Heatmap,
+  FunnelChart$1 as FunnelChart,
+  DonutChart,
+  CompositeChart,
+  ChartTooltip,
+  ChartLegend,
+  BubbleChart,
+  BarsList,
+  BarChart$1 as BarChart,
+  AreaGradient,
+  AreaChart$1 as AreaChart
+};
+
+//# debugId=0118A727390D092864756E2164756E21