@revivejs/angular-infinity-charts 2.0.0

package/vendor/infinity-charts/index.js

@@ -0,0 +1,4746 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/@revivejs/infinity-charts/dist/renderers/scene.js
+var groupNode, rectNode, pathNode, textNode, lineNode, circleNode;
+var init_scene = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/renderers/scene.js"() {
+    groupNode = (id, children = [], attrs = {}, style = {}) => ({
+      id,
+      kind: "group",
+      attrs,
+      style,
+      children
+    });
+    rectNode = (id, attrs, style = {}) => ({
+      id,
+      kind: "rect",
+      attrs,
+      style
+    });
+    pathNode = (id, attrs, style = {}) => ({
+      id,
+      kind: "path",
+      attrs,
+      style
+    });
+    textNode = (id, textContent, attrs, style = {}) => ({
+      id,
+      kind: "text",
+      attrs,
+      style,
+      textContent
+    });
+    lineNode = (id, attrs, style = {}) => ({
+      id,
+      kind: "line",
+      attrs,
+      style
+    });
+    circleNode = (id, attrs, style = {}) => ({
+      id,
+      kind: "circle",
+      attrs,
+      style
+    });
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/utils/math.js
+var clamp, sum, padExtent, formatCompactNumber, polarToCartesian;
+var init_math = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/utils/math.js"() {
+    clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+    sum = (values) => values.reduce((total, value) => total + value, 0);
+    padExtent = (minValue, maxValue, ratio = 0.08) => {
+      if (minValue === maxValue) {
+        const base = minValue === 0 ? 1 : Math.abs(minValue) * 0.2;
+        return [minValue - base, maxValue + base];
+      }
+      const span = maxValue - minValue;
+      const pad = span * ratio;
+      return [minValue - pad, maxValue + pad];
+    };
+    formatCompactNumber = (value) => new Intl.NumberFormat("en-US", {
+      notation: "compact",
+      maximumFractionDigits: value >= 100 ? 0 : 1
+    }).format(value);
+    polarToCartesian = (centerX, centerY, radius, angle) => ({
+      x: centerX + radius * Math.cos(angle - Math.PI / 2),
+      y: centerY + radius * Math.sin(angle - Math.PI / 2)
+    });
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/axes/axis-builder.js
+var formatTick, buildCartesianAxisNodes, buildContinuousAxisNodes;
+var init_axis_builder = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/axes/axis-builder.js"() {
+    init_scene();
+    init_math();
+    formatTick = (value, formatter) => {
+      if (formatter) {
+        return formatter(value);
+      }
+      return typeof value === "number" ? formatCompactNumber(value) : String(value);
+    };
+    buildCartesianAxisNodes = ({ idPrefix, frame, theme, labels, xScale, yScale, xAxis, yAxis, grid }) => {
+      const nodes = [];
+      const plotLeft = frame.plot.x;
+      const plotRight = frame.plot.x + frame.plot.width;
+      const plotTop = frame.plot.y;
+      const plotBottom = frame.plot.y + frame.plot.height;
+      const fontSize = theme.fontSize;
+      if (grid.show && grid.y) {
+        yScale.ticks(yAxis.tickCount).forEach((tick, index) => {
+          const y = yScale.scale(tick);
+          nodes.push(lineNode(`${idPrefix}-grid-y-${index}`, {
+            x1: plotLeft,
+            y1: y,
+            x2: plotRight,
+            y2: y,
+            stroke: grid.color,
+            "stroke-width": 1,
+            opacity: grid.opacity,
+            "stroke-dasharray": "4 6"
+          }));
+        });
+      }
+      if (grid.show && grid.x) {
+        labels.forEach((label, index) => {
+          const band = xScale.get(label);
+          nodes.push(lineNode(`${idPrefix}-grid-x-${index}`, {
+            x1: band.center,
+            y1: plotTop,
+            x2: band.center,
+            y2: plotBottom,
+            stroke: grid.color,
+            "stroke-width": 1,
+            opacity: grid.opacity * 0.8,
+            "stroke-dasharray": "2 6"
+          }));
+        });
+      }
+      if (yAxis.show) {
+        nodes.push(lineNode(`${idPrefix}-axis-y`, {
+          x1: plotLeft,
+          y1: plotTop,
+          x2: plotLeft,
+          y2: plotBottom,
+          stroke: theme.axis,
+          "stroke-width": 1
+        }));
+        yScale.ticks(yAxis.tickCount).forEach((tick, index) => {
+          const y = yScale.scale(tick);
+          nodes.push(lineNode(`${idPrefix}-axis-y-tick-${index}`, {
+            x1: plotLeft - 6,
+            y1: y,
+            x2: plotLeft,
+            y2: y,
+            stroke: theme.axis,
+            "stroke-width": 1
+          }));
+          nodes.push(textNode(`${idPrefix}-axis-y-label-${index}`, formatTick(tick, yAxis.format), {
+            x: plotLeft - 12,
+            y: y + 4,
+            fill: theme.mutedText,
+            "font-size": fontSize - 1,
+            "font-family": theme.fontFamily,
+            "text-anchor": "end"
+          }));
+        });
+        if (yAxis.title) {
+          nodes.push(textNode(`${idPrefix}-axis-y-title`, yAxis.title, {
+            x: plotLeft - 46,
+            y: plotTop + frame.plot.height / 2,
+            fill: theme.mutedText,
+            "font-size": fontSize - 1,
+            "font-family": theme.fontFamily,
+            "font-weight": 600,
+            transform: `rotate(-90 ${plotLeft - 46} ${plotTop + frame.plot.height / 2})`,
+            "text-anchor": "middle"
+          }));
+        }
+      }
+      if (xAxis.show) {
+        nodes.push(lineNode(`${idPrefix}-axis-x`, {
+          x1: plotLeft,
+          y1: plotBottom,
+          x2: plotRight,
+          y2: plotBottom,
+          stroke: theme.axis,
+          "stroke-width": 1
+        }));
+        labels.forEach((label, index) => {
+          const band = xScale.at(index);
+          nodes.push(lineNode(`${idPrefix}-axis-x-tick-${index}`, {
+            x1: band.center,
+            y1: plotBottom,
+            x2: band.center,
+            y2: plotBottom + 6,
+            stroke: theme.axis,
+            "stroke-width": 1
+          }));
+          nodes.push(textNode(`${idPrefix}-axis-x-label-${index}`, formatTick(label, xAxis.format), {
+            x: band.center,
+            y: plotBottom + 22,
+            fill: theme.mutedText,
+            "font-size": fontSize - 1,
+            "font-family": theme.fontFamily,
+            "text-anchor": "middle"
+          }));
+        });
+        if (xAxis.title) {
+          nodes.push(textNode(`${idPrefix}-axis-x-title`, xAxis.title, {
+            x: plotLeft + frame.plot.width / 2,
+            y: plotBottom + 38,
+            fill: theme.mutedText,
+            "font-size": fontSize - 1,
+            "font-family": theme.fontFamily,
+            "font-weight": 600,
+            "text-anchor": "middle"
+          }));
+        }
+      }
+      return [groupNode(`${idPrefix}-axes`, nodes)];
+    };
+    buildContinuousAxisNodes = ({ idPrefix, frame, theme, xScale, yScale, xAxis, yAxis, grid }) => {
+      const nodes = [];
+      const plotLeft = frame.plot.x;
+      const plotRight = frame.plot.x + frame.plot.width;
+      const plotTop = frame.plot.y;
+      const plotBottom = frame.plot.y + frame.plot.height;
+      const fontSize = theme.fontSize;
+      if (grid.show && grid.y) {
+        yScale.ticks(yAxis.tickCount).forEach((tick, index) => {
+          const y = yScale.scale(tick);
+          nodes.push(lineNode(`${idPrefix}-grid-y-${index}`, {
+            x1: plotLeft,
+            y1: y,
+            x2: plotRight,
+            y2: y,
+            stroke: grid.color,
+            "stroke-width": 1,
+            opacity: grid.opacity,
+            "stroke-dasharray": "4 6"
+          }));
+        });
+      }
+      if (grid.show && grid.x) {
+        xScale.ticks(xAxis.tickCount).forEach((tick, index) => {
+          const x = xScale.scale(tick);
+          nodes.push(lineNode(`${idPrefix}-grid-x-${index}`, {
+            x1: x,
+            y1: plotTop,
+            x2: x,
+            y2: plotBottom,
+            stroke: grid.color,
+            "stroke-width": 1,
+            opacity: grid.opacity * 0.8,
+            "stroke-dasharray": "2 6"
+          }));
+        });
+      }
+      if (yAxis.show) {
+        nodes.push(lineNode(`${idPrefix}-axis-y`, {
+          x1: plotLeft,
+          y1: plotTop,
+          x2: plotLeft,
+          y2: plotBottom,
+          stroke: theme.axis,
+          "stroke-width": 1
+        }));
+        yScale.ticks(yAxis.tickCount).forEach((tick, index) => {
+          const y = yScale.scale(tick);
+          nodes.push(lineNode(`${idPrefix}-axis-y-tick-${index}`, {
+            x1: plotLeft - 6,
+            y1: y,
+            x2: plotLeft,
+            y2: y,
+            stroke: theme.axis,
+            "stroke-width": 1
+          }));
+          nodes.push(textNode(`${idPrefix}-axis-y-label-${index}`, formatTick(tick, yAxis.format), {
+            x: plotLeft - 12,
+            y: y + 4,
+            fill: theme.mutedText,
+            "font-size": fontSize - 1,
+            "font-family": theme.fontFamily,
+            "text-anchor": "end"
+          }));
+        });
+      }
+      if (xAxis.show) {
+        nodes.push(lineNode(`${idPrefix}-axis-x`, {
+          x1: plotLeft,
+          y1: plotBottom,
+          x2: plotRight,
+          y2: plotBottom,
+          stroke: theme.axis,
+          "stroke-width": 1
+        }));
+        xScale.ticks(xAxis.tickCount).forEach((tick, index) => {
+          const x = xScale.scale(tick);
+          nodes.push(lineNode(`${idPrefix}-axis-x-tick-${index}`, {
+            x1: x,
+            y1: plotBottom,
+            x2: x,
+            y2: plotBottom + 6,
+            stroke: theme.axis,
+            "stroke-width": 1
+          }));
+          nodes.push(textNode(`${idPrefix}-axis-x-label-${index}`, formatTick(tick, xAxis.format), {
+            x,
+            y: plotBottom + 22,
+            fill: theme.mutedText,
+            "font-size": fontSize - 1,
+            "font-family": theme.fontFamily,
+            "text-anchor": "middle"
+          }));
+        });
+      }
+      return [groupNode(`${idPrefix}-axes`, nodes)];
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/cartesian-geometry.js
+var buildLinePath, buildAreaPath;
+var init_cartesian_geometry = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/common/cartesian-geometry.js"() {
+    buildLinePath = (points) => points.map((point, index) => `${index === 0 ? "M" : "L"} ${point.x} ${point.y}`).join(" ");
+    buildAreaPath = (points, baseline, lowerBoundary) => {
+      if (points.length === 0) {
+        return "";
+      }
+      if (lowerBoundary == null ? void 0 : lowerBoundary.length) {
+        const upper = buildLinePath(points);
+        const lower = [...lowerBoundary].reverse().map((point) => `L ${point.x} ${point.y}`).join(" ");
+        return `${upper} ${lower} Z`;
+      }
+      const start = points[0];
+      const end = points[points.length - 1];
+      const line = buildLinePath(points);
+      return `${line} L ${end.x} ${baseline} L ${start.x} ${baseline} Z`;
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/chrome.js
+var resolveAnchor, buildTitleNodes, buildLegendNodes, buildThresholdNodes;
+var init_chrome = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/common/chrome.js"() {
+    init_scene();
+    resolveAnchor = (align, bounds, estimatedWidth) => {
+      if (align === "center") {
+        return bounds.x + (bounds.width - estimatedWidth) / 2;
+      }
+      if (align === "end") {
+        return bounds.x + bounds.width - estimatedWidth;
+      }
+      return bounds.x + 12;
+    };
+    buildTitleNodes = (idPrefix, config, frame, theme) => {
+      if (!config.title.text && !config.title.subtitle) {
+        return [];
+      }
+      const alignMap = {
+        start: frame.header.x + 12,
+        center: frame.header.x + frame.header.width / 2,
+        end: frame.header.x + frame.header.width - 12
+      };
+      const anchorMap = {
+        start: "start",
+        center: "middle",
+        end: "end"
+      };
+      const x = alignMap[config.title.align];
+      return [
+        groupNode(`${idPrefix}-title-group`, [
+          config.title.text ? textNode(`${idPrefix}-title`, config.title.text, {
+            class: "ic-title",
+            x,
+            y: frame.header.y + 24,
+            fill: theme.title,
+            "font-family": theme.fontFamily,
+            "font-size": theme.fontSize + 3,
+            "font-weight": 700,
+            "text-anchor": anchorMap[config.title.align]
+          }) : groupNode(`${idPrefix}-title-empty`),
+          config.title.subtitle ? textNode(`${idPrefix}-subtitle`, config.title.subtitle, {
+            class: "ic-subtitle",
+            x,
+            y: frame.header.y + 44,
+            fill: theme.mutedText,
+            "font-family": theme.fontFamily,
+            "font-size": theme.fontSize,
+            "text-anchor": anchorMap[config.title.align]
+          }) : groupNode(`${idPrefix}-subtitle-empty`)
+        ])
+      ];
+    };
+    buildLegendNodes = (idPrefix, config, frame, theme, items) => {
+      const legendBounds = frame.legend;
+      if (!config.legend.show || items.length === 0 || !legendBounds) {
+        return [];
+      }
+      const vertical = config.legend.position === "left" || config.legend.position === "right";
+      const itemWidth = vertical ? legendBounds.width - 20 : 112;
+      const anchorX = resolveAnchor(config.legend.align, legendBounds, vertical ? itemWidth : itemWidth * items.length);
+      const nodes = items.flatMap((item, index) => {
+        const x = vertical ? legendBounds.x + 10 : anchorX + index * itemWidth;
+        const y = vertical ? legendBounds.y + 18 + index * 24 : legendBounds.y + 18;
+        return [
+          circleNode(`${idPrefix}-legend-dot-${item.id}`, {
+            class: "ic-legend-dot",
+            cx: x + 6,
+            cy: y - 4,
+            r: 5,
+            fill: item.color
+          }),
+          textNode(`${idPrefix}-legend-label-${item.id}`, item.label, {
+            class: "ic-legend-label",
+            x: x + 18,
+            y,
+            fill: theme.legendText,
+            "font-family": theme.fontFamily,
+            "font-size": theme.fontSize
+          })
+        ];
+      });
+      return [groupNode(`${idPrefix}-legend`, nodes)];
+    };
+    buildThresholdNodes = ({ idPrefix, thresholds, frame, theme, yScale }) => {
+      const nodes = thresholds.filter((threshold) => {
+        var _a;
+        return ((_a = threshold.axis) != null ? _a : "y") === "y";
+      }).flatMap((threshold, index) => {
+        var _a, _b, _c, _d;
+        const color = (_a = threshold.color) != null ? _a : theme.threshold;
+        const y = yScale.scale(threshold.value);
+        return [
+          lineNode(`${idPrefix}-threshold-${(_b = threshold.id) != null ? _b : index}`, {
+            class: "ic-threshold-line",
+            x1: frame.plot.x,
+            y1: y,
+            x2: frame.plot.x + frame.plot.width,
+            y2: y,
+            stroke: color,
+            "stroke-width": 1.5,
+            "stroke-dasharray": (_c = threshold.dasharray) != null ? _c : "7 7",
+            opacity: 0.92
+          }),
+          threshold.label ? textNode(`${idPrefix}-threshold-label-${(_d = threshold.id) != null ? _d : index}`, threshold.label, {
+            class: "ic-threshold-label",
+            x: frame.plot.x + frame.plot.width - 4,
+            y: y - 6,
+            fill: color,
+            "font-family": theme.fontFamily,
+            "font-size": theme.fontSize - 1,
+            "text-anchor": "end",
+            "font-weight": 600
+          }) : groupNode(`${idPrefix}-threshold-label-empty-${index}`)
+        ];
+      });
+      return nodes.length ? [groupNode(`${idPrefix}-thresholds`, nodes)] : [];
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/interaction.js
+var buildAriaLabel, createInteractionAttrs, interactiveNodeStyle;
+var init_interaction = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/common/interaction.js"() {
+    buildAriaLabel = (payload) => {
+      const fragments = [
+        payload.seriesName,
+        payload.label,
+        payload.value !== void 0 ? String(payload.value) : void 0,
+        payload.detail
+      ].filter(Boolean);
+      return fragments.join(", ");
+    };
+    createInteractionAttrs = (payload) => ({
+      "data-ic-interactive": "true",
+      "data-ic-payload": JSON.stringify(payload),
+      "aria-label": buildAriaLabel(payload)
+    });
+    interactiveNodeStyle = {
+      cursor: "pointer"
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/palette.js
+var resolveSeriesColor;
+var init_palette = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/common/palette.js"() {
+    resolveSeriesColor = (config, index, explicit) => {
+      var _a, _b;
+      return (_b = (_a = explicit != null ? explicit : config.palette[index % config.palette.length]) != null ? _a : config.theme.palette[index % config.theme.palette.length]) != null ? _b : "#2563eb";
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/value-labels.js
+var resolveLabelText, buildValueLabelNode;
+var init_value_labels = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/common/value-labels.js"() {
+    init_scene();
+    resolveLabelText = (config, value) => {
+      var _a, _b;
+      const formatted = (_b = (_a = config.yAxis).format) == null ? void 0 : _b.call(_a, value);
+      if (formatted !== void 0 && formatted !== null) {
+        return String(formatted);
+      }
+      return Number.isInteger(value) ? String(value) : value.toFixed(1);
+    };
+    buildValueLabelNode = (id, config, value, x, y, options) => {
+      var _a, _b, _c, _d;
+      return textNode(id, resolveLabelText(config, value), {
+        class: (_a = options == null ? void 0 : options.className) != null ? _a : "ic-value-label",
+        x,
+        y,
+        fill: (_b = options == null ? void 0 : options.fill) != null ? _b : config.theme.title,
+        stroke: config.theme.plotBackground,
+        "stroke-width": 4,
+        "paint-order": "stroke",
+        "font-family": config.theme.fontFamily,
+        "font-size": (_c = options == null ? void 0 : options.fontSize) != null ? _c : Math.max(10, config.theme.fontSize - 1),
+        "font-weight": 700,
+        "text-anchor": (_d = options == null ? void 0 : options.anchor) != null ? _d : "middle"
+      });
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/scales/band-scale.js
+var createBandScale;
+var init_band_scale = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/scales/band-scale.js"() {
+    createBandScale = ({ domain, range, paddingInner = 0.18, paddingOuter = 0.08 }) => {
+      const [rangeStart, rangeEnd] = range;
+      const count = Math.max(1, domain.length);
+      const span = rangeEnd - rangeStart;
+      const step = span / Math.max(1, count + paddingOuter * 2 - paddingInner);
+      const bandwidth = step * (1 - paddingInner);
+      const resolveIndex = (index) => {
+        const start = rangeStart + step * (paddingOuter + index);
+        return {
+          start,
+          center: start + bandwidth / 2,
+          width: bandwidth
+        };
+      };
+      return {
+        domain,
+        range,
+        bandwidth,
+        step,
+        get: (label) => {
+          const index = Math.max(0, domain.indexOf(label));
+          return resolveIndex(index);
+        },
+        at: resolveIndex
+      };
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/scales/linear-scale.js
+var roundFloat, niceStep, normalizeDomain, createLinearScale;
+var init_linear_scale = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/scales/linear-scale.js"() {
+    roundFloat = (value) => Number.parseFloat(value.toFixed(10));
+    niceStep = (span, tickCount) => {
+      const rawStep = span / Math.max(1, tickCount);
+      const power = Math.floor(Math.log10(rawStep));
+      const scaled = rawStep / 10 ** power;
+      const niceScaled = scaled <= 1 ? 1 : scaled <= 2 ? 2 : scaled <= 5 ? 5 : 10;
+      return niceScaled * 10 ** power;
+    };
+    normalizeDomain = ([minValue, maxValue]) => {
+      if (minValue === maxValue) {
+        const delta = minValue === 0 ? 1 : Math.abs(minValue) * 0.2;
+        return [minValue - delta, maxValue + delta];
+      }
+      return [minValue, maxValue];
+    };
+    createLinearScale = ({ domain, range, nice = true, tickCount = 5 }) => {
+      const normalized = normalizeDomain(domain);
+      const span = normalized[1] - normalized[0];
+      const resolvedDomain = nice && span > 0 ? (() => {
+        const step = niceStep(span, tickCount);
+        const minValue = Math.floor(normalized[0] / step) * step;
+        const maxValue = Math.ceil(normalized[1] / step) * step;
+        return [roundFloat(minValue), roundFloat(maxValue)];
+      })() : normalized;
+      const scale = (value) => {
+        const [domainStart, domainEnd] = resolvedDomain;
+        const [rangeStart, rangeEnd] = range;
+        const ratio = (value - domainStart) / (domainEnd - domainStart);
+        return rangeStart + ratio * (rangeEnd - rangeStart);
+      };
+      const ticks = (count = tickCount) => {
+        const [domainStart, domainEnd] = resolvedDomain;
+        const step = niceStep(domainEnd - domainStart, count);
+        const values = [];
+        for (let value = domainStart; value <= domainEnd + step * 0.5; value += step) {
+          values.push(roundFloat(value));
+        }
+        return values;
+      };
+      return {
+        domain: resolvedDomain,
+        range,
+        scale,
+        ticks
+      };
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/line/line-chart.js
+var line_chart_exports = {};
+__export(line_chart_exports, {
+  lineChart: () => lineChart
+});
+var lineChart;
+var init_line_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/line/line-chart.js"() {
+    init_axis_builder();
+    init_cartesian_geometry();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    init_math();
+    lineChart = {
+      id: "line",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const values = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const domainValues = [...values, ...thresholdValues];
+        const minValue = (_a = config.yAxis.min) != null ? _a : domainValues.length > 0 ? Math.min(...domainValues) : 0;
+        const maxValue = (_b = config.yAxis.max) != null ? _b : domainValues.length > 0 ? Math.max(...domainValues) : 1;
+        const [domainMin, domainMax] = padExtent(minValue, maxValue, 0.1);
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.42,
+          paddingOuter: 0.18
+        });
+        const yScale = createLinearScale({
+          domain: [domainMin, domainMax],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const plotChildren = [
+          rectNode("line-plot-bg", {
+            x: frame.plot.x,
+            y: frame.plot.y,
+            width: frame.plot.width,
+            height: frame.plot.height,
+            rx: 14,
+            fill: config.theme.plotBackground,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          }),
+          ...buildCartesianAxisNodes({
+            idPrefix: "line",
+            frame,
+            theme: config.theme,
+            labels: payload.labels,
+            xScale,
+            yScale,
+            xAxis: config.xAxis,
+            yAxis: config.yAxis,
+            grid: config.grid
+          }),
+          ...buildThresholdNodes({
+            idPrefix: "line",
+            thresholds: config.thresholds,
+            frame,
+            theme: config.theme,
+            yScale
+          })
+        ];
+        payload.series.forEach((series, seriesIndex) => {
+          const color = resolveSeriesColor(config, seriesIndex, series.color);
+          const points = series.data.map((datum, index) => {
+            const band = xScale.at(index);
+            return {
+              x: band.center,
+              y: yScale.scale(datum.y)
+            };
+          });
+          plotChildren.push(pathNode(`line-series-path-${series.id}`, {
+            d: buildLinePath(points),
+            fill: "none",
+            stroke: color,
+            "stroke-width": 3,
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            opacity: 0.96
+          }));
+          points.forEach((point, index) => {
+            var _a2, _b2, _c2;
+            const datum = series.data[index];
+            plotChildren.push(circleNode(`line-point-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: payload.labels.length > 18 ? 0 : 4,
+              fill: color,
+              stroke: config.theme.pointStroke,
+              "stroke-width": 2
+            }));
+            plotChildren.push(circleNode(`line-point-hit-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: 11,
+              fill: color,
+              opacity: 1e-3,
+              "pointer-events": "all",
+              ...createInteractionAttrs({
+                targetId: `line-point-${series.id}-${index}`,
+                chartType: "line",
+                kind: "datum",
+                label: (_c2 = (_b2 = datum == null ? void 0 : datum.label) != null ? _b2 : (_a2 = datum == null ? void 0 : datum.x) == null ? void 0 : _a2.toString()) != null ? _c2 : payload.labels[index],
+                seriesId: series.id,
+                seriesName: series.name,
+                value: datum == null ? void 0 : datum.y,
+                color,
+                index
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber && datum) {
+              plotChildren.push(buildValueLabelNode(`line-value-${series.id}-${index}`, config, datum.y, point.x, point.y - 12, {
+                fill: color
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("line-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_c = config.layout.background) != null ? _c : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("line", config, frame, config.theme),
+          groupNode("line-plot", plotChildren),
+          ...buildLegendNodes("line", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/area/area-chart.js
+var area_chart_exports = {};
+__export(area_chart_exports, {
+  areaChart: () => areaChart
+});
+var areaChart;
+var init_area_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/area/area-chart.js"() {
+    init_axis_builder();
+    init_cartesian_geometry();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    init_math();
+    areaChart = {
+      id: "area",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const values = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const domainValues = [...values, ...thresholdValues];
+        const minValue = (_a = config.yAxis.min) != null ? _a : domainValues.length > 0 ? Math.min(0, ...domainValues) : 0;
+        const maxValue = (_b = config.yAxis.max) != null ? _b : domainValues.length > 0 ? Math.max(...domainValues) : 1;
+        const [domainMin, domainMax] = padExtent(minValue, maxValue, 0.08);
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.42,
+          paddingOuter: 0.18
+        });
+        const yScale = createLinearScale({
+          domain: [domainMin, domainMax],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const baseline = yScale.scale(Math.max(0, domainMin));
+        const plotChildren = [
+          rectNode("area-plot-bg", {
+            x: frame.plot.x,
+            y: frame.plot.y,
+            width: frame.plot.width,
+            height: frame.plot.height,
+            rx: 14,
+            fill: config.theme.plotBackground,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          }),
+          ...buildCartesianAxisNodes({
+            idPrefix: "area",
+            frame,
+            theme: config.theme,
+            labels: payload.labels,
+            xScale,
+            yScale,
+            xAxis: config.xAxis,
+            yAxis: config.yAxis,
+            grid: config.grid
+          }),
+          ...buildThresholdNodes({
+            idPrefix: "area",
+            thresholds: config.thresholds,
+            frame,
+            theme: config.theme,
+            yScale
+          })
+        ];
+        payload.series.forEach((series, seriesIndex) => {
+          const color = resolveSeriesColor(config, seriesIndex, series.color);
+          const points = series.data.map((datum, index) => {
+            const band = xScale.at(index);
+            return {
+              x: band.center,
+              y: yScale.scale(datum.y)
+            };
+          });
+          plotChildren.push(pathNode(`area-fill-${series.id}`, {
+            d: buildAreaPath(points, baseline),
+            fill: color,
+            opacity: 0.18
+          }));
+          plotChildren.push(pathNode(`area-line-${series.id}`, {
+            d: buildLinePath(points),
+            fill: "none",
+            stroke: color,
+            "stroke-width": 3,
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            opacity: 0.98
+          }));
+          points.forEach((point, index) => {
+            var _a2, _b2, _c2;
+            const datum = series.data[index];
+            plotChildren.push(circleNode(`area-point-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: payload.labels.length > 18 ? 0 : 4,
+              fill: color,
+              stroke: config.theme.pointStroke,
+              "stroke-width": 2
+            }));
+            plotChildren.push(circleNode(`area-point-hit-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: 11,
+              fill: color,
+              opacity: 1e-3,
+              "pointer-events": "all",
+              ...createInteractionAttrs({
+                targetId: `area-point-${series.id}-${index}`,
+                chartType: "area",
+                kind: "datum",
+                label: (_c2 = (_b2 = datum == null ? void 0 : datum.label) != null ? _b2 : (_a2 = datum == null ? void 0 : datum.x) == null ? void 0 : _a2.toString()) != null ? _c2 : payload.labels[index],
+                seriesId: series.id,
+                seriesName: series.name,
+                value: datum == null ? void 0 : datum.y,
+                color,
+                index
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber && datum) {
+              plotChildren.push(buildValueLabelNode(`area-value-${series.id}-${index}`, config, datum.y, point.x, point.y - 12, {
+                fill: color
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("area-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_c = config.layout.background) != null ? _c : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("area", config, frame, config.theme),
+          groupNode("area-plot", plotChildren),
+          ...buildLegendNodes("area", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/stacked-area/stacked-area-chart.js
+var stacked_area_chart_exports = {};
+__export(stacked_area_chart_exports, {
+  stackedAreaChart: () => stackedAreaChart
+});
+var stackedAreaChart;
+var init_stacked_area_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/stacked-area/stacked-area-chart.js"() {
+    init_axis_builder();
+    init_cartesian_geometry();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    init_math();
+    stackedAreaChart = {
+      id: "stacked-area",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const stackedTotals = payload.labels.map((_, index) => payload.series.reduce((total, series) => {
+          var _a2, _b2;
+          return total + Math.max(0, (_b2 = (_a2 = series.data[index]) == null ? void 0 : _a2.y) != null ? _b2 : 0);
+        }, 0));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const maxValue = (_a = config.yAxis.max) != null ? _a : stackedTotals.length > 0 ? Math.max(...stackedTotals, ...thresholdValues, 0) : 1;
+        const [domainMin, domainMax] = padExtent((_b = config.yAxis.min) != null ? _b : 0, maxValue, 0.08);
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.36,
+          paddingOuter: 0.18
+        });
+        const yScale = createLinearScale({
+          domain: [domainMin, domainMax],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const cumulative = payload.labels.map(() => 0);
+        const plotChildren = [
+          rectNode("stacked-area-plot-bg", {
+            x: frame.plot.x,
+            y: frame.plot.y,
+            width: frame.plot.width,
+            height: frame.plot.height,
+            rx: 14,
+            fill: config.theme.plotBackground,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          }),
+          ...buildCartesianAxisNodes({
+            idPrefix: "stacked-area",
+            frame,
+            theme: config.theme,
+            labels: payload.labels,
+            xScale,
+            yScale,
+            xAxis: config.xAxis,
+            yAxis: config.yAxis,
+            grid: config.grid
+          }),
+          ...buildThresholdNodes({
+            idPrefix: "stacked-area",
+            thresholds: config.thresholds,
+            frame,
+            theme: config.theme,
+            yScale
+          })
+        ];
+        payload.series.forEach((series, seriesIndex) => {
+          const color = resolveSeriesColor(config, seriesIndex, series.color);
+          const lowerBoundary = [];
+          const upperBoundary = [];
+          series.data.forEach((datum, index) => {
+            var _a2;
+            const band = xScale.at(index);
+            const previousTotal = (_a2 = cumulative[index]) != null ? _a2 : 0;
+            const nextTotal = previousTotal + Math.max(0, datum.y);
+            lowerBoundary.push({
+              x: band.center,
+              y: yScale.scale(previousTotal)
+            });
+            upperBoundary.push({
+              x: band.center,
+              y: yScale.scale(nextTotal)
+            });
+            cumulative[index] = nextTotal;
+          });
+          plotChildren.push(pathNode(`stacked-area-fill-${series.id}`, {
+            d: buildAreaPath(upperBoundary, yScale.scale(0), lowerBoundary),
+            fill: color,
+            opacity: 0.22
+          }));
+          plotChildren.push(pathNode(`stacked-area-line-${series.id}`, {
+            d: buildLinePath(upperBoundary),
+            fill: "none",
+            stroke: color,
+            "stroke-width": 2.5,
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            opacity: 0.94
+          }));
+          upperBoundary.forEach((point, index) => {
+            var _a2, _b2, _c2, _d, _e, _f, _g;
+            plotChildren.push(circleNode(`stacked-area-point-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: payload.labels.length > 20 ? 0 : 3.5,
+              fill: color,
+              stroke: config.theme.pointStroke,
+              "stroke-width": 2
+            }));
+            plotChildren.push(circleNode(`stacked-area-point-hit-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: 11,
+              fill: color,
+              opacity: 1e-3,
+              "pointer-events": "all",
+              ...createInteractionAttrs({
+                targetId: `stacked-area-point-${series.id}-${index}`,
+                chartType: "stacked-area",
+                kind: "datum",
+                label: (_b2 = (_a2 = series.data[index]) == null ? void 0 : _a2.label) != null ? _b2 : payload.labels[index],
+                seriesId: series.id,
+                seriesName: series.name,
+                value: (_d = (_c2 = series.data[index]) == null ? void 0 : _c2.y) != null ? _d : 0,
+                detail: `Stacked total ${Math.round((_e = cumulative[index]) != null ? _e : 0)}`,
+                color,
+                index
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber) {
+              plotChildren.push(buildValueLabelNode(`stacked-area-value-${series.id}-${index}`, config, (_g = (_f = series.data[index]) == null ? void 0 : _f.y) != null ? _g : 0, point.x, point.y - 10, {
+                fill: color
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("stacked-area-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_c = config.layout.background) != null ? _c : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("stacked-area", config, frame, config.theme),
+          groupNode("stacked-area-plot", plotChildren),
+          ...buildLegendNodes("stacked-area", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: config.showNumber ? `${series.name} (${series.data.reduce((sum2, datum) => {
+              var _a2;
+              return sum2 + Math.max(0, (_a2 = datum == null ? void 0 : datum.y) != null ? _a2 : 0);
+            }, 0)})` : series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/bar/bar-chart.js
+var bar_chart_exports = {};
+__export(bar_chart_exports, {
+  barChart: () => barChart
+});
+var barChart;
+var init_bar_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/bar/bar-chart.js"() {
+    init_axis_builder();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    barChart = {
+      id: "bar",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const values = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const domainValues = [...values, ...thresholdValues];
+        const minValue = (_a = config.yAxis.min) != null ? _a : domainValues.length > 0 ? Math.min(0, ...domainValues) : 0;
+        const maxValue = (_b = config.yAxis.max) != null ? _b : domainValues.length > 0 ? Math.max(0, ...domainValues) : 1;
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.22,
+          paddingOuter: 0.12
+        });
+        const yScale = createLinearScale({
+          domain: [minValue, maxValue],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const baseline = yScale.scale(0);
+        const bars = [];
+        payload.labels.forEach((label, groupIndex) => {
+          const band = xScale.get(label);
+          const groupWidth = band.width;
+          const gap = 6;
+          const seriesWidth = (groupWidth - gap * Math.max(0, payload.series.length - 1)) / Math.max(1, payload.series.length);
+          payload.series.forEach((series, seriesIndex) => {
+            var _a2, _b2, _c2, _d, _e;
+            const datum = series.data[groupIndex];
+            const color = resolveSeriesColor(config, seriesIndex, series.color);
+            const x = band.start + seriesIndex * (seriesWidth + gap);
+            const y = yScale.scale(Math.max((_a2 = datum == null ? void 0 : datum.y) != null ? _a2 : 0, 0));
+            const height = Math.abs(yScale.scale((_b2 = datum == null ? void 0 : datum.y) != null ? _b2 : 0) - baseline);
+            bars.push(rectNode(`bar-${series.id}-${groupIndex}`, {
+              x,
+              y: datum && datum.y >= 0 ? y : baseline,
+              width: seriesWidth,
+              height,
+              rx: 8,
+              fill: color,
+              opacity: 0.92,
+              ...createInteractionAttrs({
+                targetId: `bar-${series.id}-${groupIndex}`,
+                chartType: "bar",
+                kind: "datum",
+                label: (_c2 = datum == null ? void 0 : datum.label) != null ? _c2 : label,
+                seriesId: series.id,
+                seriesName: series.name,
+                value: (_d = datum == null ? void 0 : datum.y) != null ? _d : 0,
+                color,
+                index: groupIndex
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber) {
+              bars.push(buildValueLabelNode(`bar-value-${series.id}-${groupIndex}`, config, (_e = datum == null ? void 0 : datum.y) != null ? _e : 0, x + seriesWidth / 2, datum && datum.y >= 0 ? y - 10 : baseline + height + 16, {
+                fill: color
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("bar-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_c = config.layout.background) != null ? _c : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("bar", config, frame, config.theme),
+          groupNode("bar-plot", [
+            rectNode("bar-plot-bg", {
+              x: frame.plot.x,
+              y: frame.plot.y,
+              width: frame.plot.width,
+              height: frame.plot.height,
+              rx: 14,
+              fill: config.theme.plotBackground,
+              stroke: config.theme.plotBorder,
+              "stroke-width": 1
+            }),
+            ...buildCartesianAxisNodes({
+              idPrefix: "bar",
+              frame,
+              theme: config.theme,
+              labels: payload.labels,
+              xScale,
+              yScale,
+              xAxis: config.xAxis,
+              yAxis: config.yAxis,
+              grid: config.grid
+            }),
+            ...buildThresholdNodes({
+              idPrefix: "bar",
+              thresholds: config.thresholds,
+              frame,
+              theme: config.theme,
+              yScale
+            }),
+            ...bars
+          ]),
+          ...buildLegendNodes("bar", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/bar-3d/bar-3d-chart.js
+var bar_3d_chart_exports = {};
+__export(bar_3d_chart_exports, {
+  bar3DChart: () => bar3DChart
+});
+var shadeHex, buildPolygonPath, bar3DChart;
+var init_bar_3d_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/bar-3d/bar-3d-chart.js"() {
+    init_axis_builder();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    shadeHex = (hex, amount) => {
+      var _a;
+      const normalized = hex.replace("#", "");
+      const parts = normalized.length === 3 ? normalized.split("").map((part) => part + part) : (_a = normalized.match(/.{2}/g)) != null ? _a : ["25", "99", "eb"];
+      const shifted = parts.map((part) => {
+        const channel = Number.parseInt(part, 16);
+        const next = Math.max(0, Math.min(255, Math.round(channel + 255 * amount)));
+        return next.toString(16).padStart(2, "0");
+      });
+      return `#${shifted.join("")}`;
+    };
+    buildPolygonPath = (points) => `${points.map((point, index) => `${index === 0 ? "M" : "L"} ${point.x} ${point.y}`).join(" ")} Z`;
+    bar3DChart = {
+      id: "bar-3d",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const values = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const minValue = (_a = config.yAxis.min) != null ? _a : values.length > 0 ? Math.min(0, ...values, ...thresholdValues) : 0;
+        const maxValue = (_b = config.yAxis.max) != null ? _b : values.length > 0 ? Math.max(0, ...values, ...thresholdValues) : 1;
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.22,
+          paddingOuter: 0.12
+        });
+        const yScale = createLinearScale({
+          domain: [minValue, maxValue],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const baseline = yScale.scale(0);
+        const depthX = config.bar3d.depthX;
+        const depthY = config.bar3d.depthY;
+        const floorY = frame.plot.y + frame.plot.height;
+        const backTopY = frame.plot.y - depthY;
+        const floorPlane = buildPolygonPath([
+          { x: frame.plot.x, y: floorY },
+          { x: frame.plot.x + frame.plot.width, y: floorY },
+          { x: frame.plot.x + frame.plot.width + depthX, y: floorY - depthY },
+          { x: frame.plot.x + depthX, y: floorY - depthY }
+        ]);
+        const wallPlane = buildPolygonPath([
+          { x: frame.plot.x + frame.plot.width, y: frame.plot.y },
+          { x: frame.plot.x + frame.plot.width + depthX, y: backTopY },
+          { x: frame.plot.x + frame.plot.width + depthX, y: floorY - depthY },
+          { x: frame.plot.x + frame.plot.width, y: floorY }
+        ]);
+        const bars = [];
+        const floorGuides = payload.labels.flatMap((label, index) => {
+          const band = xScale.get(label);
+          const guideX = band.center;
+          return [
+            lineNode(`bar3d-floor-guide-${index}`, {
+              x1: guideX,
+              y1: floorY,
+              x2: guideX + depthX,
+              y2: floorY - depthY,
+              stroke: config.bar3d.floorLineColor,
+              "stroke-width": 1,
+              opacity: 0.7
+            })
+          ];
+        });
+        payload.labels.forEach((label, groupIndex) => {
+          const band = xScale.get(label);
+          const groupWidth = band.width;
+          const gap = 6;
+          const seriesWidth = (groupWidth - gap * Math.max(0, payload.series.length - 1)) / Math.max(1, payload.series.length);
+          payload.series.forEach((series, seriesIndex) => {
+            var _a2, _b2;
+            const datum = series.data[groupIndex];
+            const rawValue = (_a2 = datum == null ? void 0 : datum.y) != null ? _a2 : 0;
+            const baseColor = resolveSeriesColor(config, seriesIndex, series.color);
+            const frontColor = baseColor;
+            const topColor = shadeHex(baseColor, config.bar3d.topLightness);
+            const sideColor = shadeHex(baseColor, config.bar3d.sideLightness);
+            const x = band.start + seriesIndex * (seriesWidth + gap);
+            const barTop = yScale.scale(Math.max(rawValue, 0));
+            const frontY = rawValue >= 0 ? barTop : baseline;
+            const height = Math.abs(yScale.scale(rawValue) - baseline);
+            const capY = rawValue >= 0 ? frontY : frontY + height;
+            const frontBaseY = rawValue >= 0 ? frontY + height : frontY;
+            const shadowHeight = Math.max(8, Math.min(14, height * 0.12));
+            bars.push(pathNode(`bar3d-shadow-${series.id}-${groupIndex}`, {
+              d: buildPolygonPath([
+                { x, y: frontBaseY + 1 },
+                { x: x + seriesWidth, y: frontBaseY + 1 },
+                { x: x + seriesWidth + depthX, y: frontBaseY - depthY + shadowHeight },
+                { x: x + depthX, y: frontBaseY - depthY + shadowHeight }
+              ]),
+              fill: config.bar3d.shadowColor,
+              opacity: 0.18
+            }));
+            bars.push(pathNode(`bar3d-side-${series.id}-${groupIndex}`, {
+              d: buildPolygonPath([
+                { x: x + seriesWidth, y: frontY },
+                { x: x + seriesWidth + depthX, y: frontY - depthY },
+                { x: x + seriesWidth + depthX, y: frontY + height - depthY },
+                { x: x + seriesWidth, y: frontY + height }
+              ]),
+              fill: sideColor,
+              opacity: 0.98
+            }));
+            bars.push(pathNode(`bar3d-top-${series.id}-${groupIndex}`, {
+              d: buildPolygonPath([
+                { x, y: capY },
+                { x: x + depthX, y: capY - depthY },
+                { x: x + seriesWidth + depthX, y: capY - depthY },
+                { x: x + seriesWidth, y: capY }
+              ]),
+              fill: topColor,
+              opacity: 0.99
+            }));
+            bars.push(rectNode(`bar3d-front-${series.id}-${groupIndex}`, {
+              x,
+              y: frontY,
+              width: seriesWidth,
+              height,
+              rx: 2,
+              fill: frontColor,
+              opacity: 0.99,
+              ...createInteractionAttrs({
+                targetId: `bar3d-front-${series.id}-${groupIndex}`,
+                chartType: "bar-3d",
+                kind: "datum",
+                label: (_b2 = datum == null ? void 0 : datum.label) != null ? _b2 : label,
+                seriesId: series.id,
+                seriesName: series.name,
+                value: rawValue,
+                color: frontColor,
+                index: groupIndex
+              })
+            }, interactiveNodeStyle));
+            bars.push(lineNode(`bar3d-highlight-${series.id}-${groupIndex}`, {
+              x1: x + 1,
+              y1: frontY + 1,
+              x2: x + seriesWidth - 1,
+              y2: frontY + 1,
+              stroke: shadeHex(baseColor, 0.24),
+              "stroke-width": 1.2,
+              opacity: 0.72
+            }));
+            if (config.showNumber) {
+              bars.push(buildValueLabelNode(`bar3d-value-${series.id}-${groupIndex}`, config, rawValue, x + seriesWidth / 2 + depthX * 0.32, rawValue >= 0 ? capY - depthY - 8 : frontY + height + 16, {
+                fill: topColor
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("bar3d-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_c = config.layout.background) != null ? _c : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("bar3d", config, frame, config.theme),
+          groupNode("bar3d-plot", [
+            rectNode("bar3d-plot-bg", {
+              x: frame.plot.x,
+              y: frame.plot.y,
+              width: frame.plot.width,
+              height: frame.plot.height,
+              rx: 14,
+              fill: config.theme.plotBackground,
+              stroke: config.theme.plotBorder,
+              "stroke-width": 1
+            }),
+            pathNode("bar3d-floor-plane", {
+              d: floorPlane,
+              fill: config.bar3d.floorColor,
+              stroke: config.bar3d.floorLineColor,
+              "stroke-width": 1,
+              opacity: 0.96
+            }),
+            pathNode("bar3d-wall-plane", {
+              d: wallPlane,
+              fill: shadeHex(config.bar3d.floorColor, -0.05),
+              stroke: config.bar3d.floorLineColor,
+              "stroke-width": 1,
+              opacity: 0.84
+            }),
+            ...floorGuides,
+            ...buildCartesianAxisNodes({
+              idPrefix: "bar3d",
+              frame,
+              theme: config.theme,
+              labels: payload.labels,
+              xScale,
+              yScale,
+              xAxis: config.xAxis,
+              yAxis: config.yAxis,
+              grid: config.grid
+            }),
+            ...buildThresholdNodes({
+              idPrefix: "bar3d",
+              thresholds: config.thresholds,
+              frame,
+              theme: config.theme,
+              yScale
+            }),
+            ...bars
+          ]),
+          ...buildLegendNodes("bar3d", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: config.showNumber ? `${series.name} (${series.data.reduce((sum2, datum) => {
+              var _a2;
+              return sum2 + ((_a2 = datum == null ? void 0 : datum.y) != null ? _a2 : 0);
+            }, 0)})` : series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/combo/combo-chart.js
+var combo_chart_exports = {};
+__export(combo_chart_exports, {
+  comboChart: () => comboChart
+});
+var comboChart;
+var init_combo_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/combo/combo-chart.js"() {
+    init_axis_builder();
+    init_cartesian_geometry();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    init_math();
+    comboChart = {
+      id: "combo",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const values = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const minValue = (_a = config.yAxis.min) != null ? _a : values.length > 0 ? Math.min(0, ...values, ...thresholdValues) : 0;
+        const maxValue = (_b = config.yAxis.max) != null ? _b : values.length > 0 ? Math.max(0, ...values, ...thresholdValues) : 1;
+        const [domainMin, domainMax] = padExtent(minValue, maxValue, 0.08);
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.24,
+          paddingOuter: 0.12
+        });
+        const yScale = createLinearScale({
+          domain: [domainMin, domainMax],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const baseline = yScale.scale(Math.max(0, domainMin));
+        const plotChildren = [
+          rectNode("combo-plot-bg", {
+            x: frame.plot.x,
+            y: frame.plot.y,
+            width: frame.plot.width,
+            height: frame.plot.height,
+            rx: 14,
+            fill: config.theme.plotBackground,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          }),
+          ...buildCartesianAxisNodes({
+            idPrefix: "combo",
+            frame,
+            theme: config.theme,
+            labels: payload.labels,
+            xScale,
+            yScale,
+            xAxis: config.xAxis,
+            yAxis: config.yAxis,
+            grid: config.grid
+          }),
+          ...buildThresholdNodes({
+            idPrefix: "combo",
+            thresholds: config.thresholds,
+            frame,
+            theme: config.theme,
+            yScale
+          })
+        ];
+        const barSeries = payload.series.filter((series) => series.type === "bar");
+        const groupedGap = 6;
+        payload.labels.forEach((label, groupIndex) => {
+          const band = xScale.get(label);
+          const groupWidth = band.width;
+          const seriesWidth = (groupWidth - groupedGap * Math.max(0, barSeries.length - 1)) / Math.max(1, barSeries.length);
+          barSeries.forEach((series, barIndex) => {
+            var _a2, _b2;
+            const datum = series.data[groupIndex];
+            const color = resolveSeriesColor(config, payload.series.indexOf(series), series.color);
+            const x = band.start + barIndex * (seriesWidth + groupedGap);
+            const rawValue = (_a2 = datum == null ? void 0 : datum.y) != null ? _a2 : 0;
+            const y = yScale.scale(Math.max(rawValue, 0));
+            const height = Math.abs(yScale.scale(rawValue) - baseline);
+            plotChildren.push(rectNode(`combo-bar-${series.id}-${groupIndex}`, {
+              x,
+              y: rawValue >= 0 ? y : baseline,
+              width: seriesWidth,
+              height,
+              rx: 8,
+              fill: color,
+              opacity: 0.84,
+              ...createInteractionAttrs({
+                targetId: `combo-bar-${series.id}-${groupIndex}`,
+                chartType: "combo",
+                kind: "datum",
+                label: (_b2 = datum == null ? void 0 : datum.label) != null ? _b2 : label,
+                seriesId: series.id,
+                seriesName: series.name,
+                value: rawValue,
+                color,
+                index: groupIndex
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber) {
+              plotChildren.push(buildValueLabelNode(`combo-bar-value-${series.id}-${groupIndex}`, config, rawValue, x + seriesWidth / 2, rawValue >= 0 ? y - 10 : baseline + height + 16, {
+                fill: color
+              }));
+            }
+          });
+        });
+        payload.series.forEach((series, seriesIndex) => {
+          if (series.type === "bar") {
+            return;
+          }
+          const color = resolveSeriesColor(config, seriesIndex, series.color);
+          const points = series.data.map((datum, index) => {
+            const band = xScale.at(index);
+            return {
+              x: band.center,
+              y: yScale.scale(datum.y)
+            };
+          });
+          if (series.type === "area") {
+            plotChildren.push(pathNode(`combo-area-fill-${series.id}`, {
+              d: buildAreaPath(points, baseline),
+              fill: color,
+              opacity: 0.16
+            }));
+          }
+          if (series.type === "area" || series.type === "line") {
+            plotChildren.push(pathNode(`combo-line-${series.id}`, {
+              d: buildLinePath(points),
+              fill: "none",
+              stroke: color,
+              "stroke-width": 3,
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              opacity: 0.97
+            }));
+          }
+          points.forEach((point, index) => {
+            var _a2, _b2, _c2;
+            const radius = series.type === "scatter" ? 5 : payload.labels.length > 18 ? 0 : 4;
+            const datum = series.data[index];
+            plotChildren.push(circleNode(`combo-point-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: radius,
+              fill: color,
+              stroke: config.theme.pointStroke,
+              "stroke-width": 2,
+              opacity: 0.96
+            }));
+            plotChildren.push(circleNode(`combo-point-hit-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: series.type === "scatter" ? 10 : 11,
+              fill: color,
+              opacity: 1e-3,
+              "pointer-events": "all",
+              ...createInteractionAttrs({
+                targetId: `combo-point-${series.id}-${index}`,
+                chartType: "combo",
+                kind: "datum",
+                label: (_c2 = (_b2 = datum == null ? void 0 : datum.label) != null ? _b2 : (_a2 = datum == null ? void 0 : datum.x) == null ? void 0 : _a2.toString()) != null ? _c2 : payload.labels[index],
+                seriesId: series.id,
+                seriesName: series.name,
+                value: datum == null ? void 0 : datum.y,
+                color,
+                index
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber && datum) {
+              plotChildren.push(buildValueLabelNode(`combo-point-value-${series.id}-${index}`, config, datum.y, point.x, point.y - 12, {
+                fill: color
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("combo-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_c = config.layout.background) != null ? _c : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("combo", config, frame, config.theme),
+          groupNode("combo-plot", plotChildren),
+          ...buildLegendNodes("combo", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/sparkline/sparkline-chart.js
+var sparkline_chart_exports = {};
+__export(sparkline_chart_exports, {
+  sparklineChart: () => sparklineChart
+});
+var sparklineChart;
+var init_sparkline_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/sparkline/sparkline-chart.js"() {
+    init_cartesian_geometry();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_band_scale();
+    init_linear_scale();
+    init_math();
+    sparklineChart = {
+      id: "sparkline",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c, _d;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const values = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const [domainMin, domainMax] = padExtent((_a = config.yAxis.min) != null ? _a : values.length > 0 ? Math.min(...values) : 0, (_b = config.yAxis.max) != null ? _b : values.length > 0 ? Math.max(...values) : 1, 0.1);
+        const xScale = createBandScale({
+          domain: payload.labels,
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          paddingInner: 0.52,
+          paddingOuter: 0.1
+        });
+        const yScale = createLinearScale({
+          domain: [domainMin, domainMax],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: false,
+          tickCount: 4
+        });
+        const baseline = yScale.scale(domainMin);
+        const plotChildren = [
+          rectNode("sparkline-plot-bg", {
+            x: frame.plot.x,
+            y: frame.plot.y,
+            width: frame.plot.width,
+            height: frame.plot.height,
+            rx: 14,
+            fill: config.theme.plotBackground,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          })
+        ];
+        payload.series.forEach((series, seriesIndex) => {
+          const color = resolveSeriesColor(config, seriesIndex, series.color);
+          const points = series.data.map((datum, index) => {
+            const band = xScale.at(index);
+            return {
+              x: band.center,
+              y: yScale.scale(datum.y)
+            };
+          });
+          const lastPoint = points[points.length - 1];
+          if (seriesIndex === 0) {
+            plotChildren.push(pathNode(`sparkline-fill-${series.id}`, {
+              d: buildAreaPath(points, baseline),
+              fill: color,
+              opacity: 0.12
+            }));
+          }
+          plotChildren.push(pathNode(`sparkline-line-${series.id}`, {
+            d: buildLinePath(points),
+            fill: "none",
+            stroke: color,
+            "stroke-width": 3,
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            opacity: 0.96
+          }));
+          points.forEach((point, index) => {
+            var _a2, _b2;
+            const datum = series.data[index];
+            plotChildren.push(circleNode(`sparkline-point-hit-${series.id}-${index}`, {
+              cx: point.x,
+              cy: point.y,
+              r: 9,
+              fill: color,
+              opacity: 1e-3,
+              "pointer-events": "all",
+              ...createInteractionAttrs({
+                targetId: index === points.length - 1 ? `sparkline-point-${series.id}` : `sparkline-line-${series.id}`,
+                chartType: "sparkline",
+                kind: "datum",
+                label: (_b2 = (_a2 = datum == null ? void 0 : datum.label) != null ? _a2 : payload.labels[index]) != null ? _b2 : series.name,
+                seriesId: series.id,
+                seriesName: series.name,
+                value: datum == null ? void 0 : datum.y,
+                color,
+                index
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber && datum) {
+              plotChildren.push(buildValueLabelNode(`sparkline-value-${series.id}-${index}`, config, datum.y, point.x, point.y - 10, {
+                fill: color,
+                fontSize: Math.max(9, config.theme.fontSize - 2)
+              }));
+            }
+          });
+          if (lastPoint) {
+            plotChildren.push(circleNode(`sparkline-point-${series.id}`, {
+              cx: lastPoint.x,
+              cy: lastPoint.y,
+              r: 4.5,
+              fill: color,
+              stroke: config.theme.pointStroke,
+              "stroke-width": 2
+            }));
+          }
+        });
+        const primarySeries = payload.series[0];
+        const currentValue = (_c = primarySeries == null ? void 0 : primarySeries.data[primarySeries.data.length - 1]) == null ? void 0 : _c.y;
+        return [
+          rectNode("sparkline-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_d = config.layout.background) != null ? _d : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("sparkline", config, frame, config.theme),
+          groupNode("sparkline-plot", plotChildren),
+          config.showNumber && typeof currentValue === "number" ? textNode("sparkline-current-value", `${currentValue}`, {
+            x: size.width - 18,
+            y: 24,
+            fill: config.theme.title,
+            "font-family": config.theme.fontFamily,
+            "font-size": config.theme.fontSize + 4,
+            "font-weight": 700,
+            "text-anchor": "end"
+          }) : groupNode("sparkline-current-value-empty"),
+          !config.legend.show && (primarySeries == null ? void 0 : primarySeries.name) ? textNode("sparkline-current-label", primarySeries.name, {
+            x: 18,
+            y: 24,
+            fill: config.theme.mutedText,
+            "font-family": config.theme.fontFamily,
+            "font-size": config.theme.fontSize - 1,
+            "font-weight": 600
+          }) : groupNode("sparkline-current-label-empty"),
+          ...buildLegendNodes("sparkline", config, frame, config.theme, payload.series.map((series, index) => {
+            var _a2, _b2;
+            return {
+              id: series.id,
+              label: config.showNumber ? `${series.name} (${(_b2 = (_a2 = series.data[series.data.length - 1]) == null ? void 0 : _a2.y) != null ? _b2 : 0})` : series.name,
+              color: resolveSeriesColor(config, index, series.color)
+            };
+          }))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/scatter/scatter-chart.js
+var scatter_chart_exports = {};
+__export(scatter_chart_exports, {
+  scatterChart: () => scatterChart
+});
+var scatterChart;
+var init_scatter_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/scatter/scatter-chart.js"() {
+    init_axis_builder();
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_value_labels();
+    init_scene();
+    init_linear_scale();
+    init_math();
+    scatterChart = {
+      id: "scatter",
+      family: "cartesian",
+      render: ({ config, payload, frame, size }) => {
+        var _a, _b, _c, _d, _e;
+        if (payload.kind !== "cartesian") {
+          return [];
+        }
+        const xValues = payload.series.flatMap((series) => series.data.map((datum, index) => typeof datum.x === "number" ? datum.x : index));
+        const yValues = payload.series.flatMap((series) => series.data.map((datum) => datum.y));
+        const thresholdValues = config.thresholds.filter((threshold) => {
+          var _a2;
+          return ((_a2 = threshold.axis) != null ? _a2 : "y") === "y";
+        }).map((threshold) => threshold.value);
+        const [xMin, xMax] = padExtent((_a = config.xAxis.min) != null ? _a : xValues.length > 0 ? Math.min(...xValues) : 0, (_b = config.xAxis.max) != null ? _b : xValues.length > 0 ? Math.max(...xValues) : 1, 0.08);
+        const [yMin, yMax] = padExtent((_c = config.yAxis.min) != null ? _c : yValues.length > 0 ? Math.min(...yValues, ...thresholdValues) : 0, (_d = config.yAxis.max) != null ? _d : yValues.length > 0 ? Math.max(...yValues, ...thresholdValues) : 1, 0.08);
+        const xScale = createLinearScale({
+          domain: [xMin, xMax],
+          range: [frame.plot.x, frame.plot.x + frame.plot.width],
+          nice: true,
+          tickCount: config.xAxis.tickCount
+        });
+        const yScale = createLinearScale({
+          domain: [yMin, yMax],
+          range: [frame.plot.y + frame.plot.height, frame.plot.y],
+          nice: config.yAxis.nice,
+          tickCount: config.yAxis.tickCount
+        });
+        const dots = [];
+        payload.series.forEach((series, seriesIndex) => {
+          const color = resolveSeriesColor(config, seriesIndex, series.color);
+          series.data.forEach((datum, index) => {
+            const x = xScale.scale(typeof datum.x === "number" ? datum.x : index);
+            const y = yScale.scale(datum.y);
+            dots.push(circleNode(`scatter-point-${series.id}-${index}`, {
+              cx: x,
+              cy: y,
+              r: 5.5,
+              fill: color,
+              stroke: config.theme.pointStroke,
+              "stroke-width": 1.5,
+              opacity: 0.94,
+              ...createInteractionAttrs({
+                targetId: `scatter-point-${series.id}-${index}`,
+                chartType: "scatter",
+                kind: "datum",
+                label: datum.label || `Point ${index + 1}`,
+                seriesId: series.id,
+                seriesName: series.name,
+                value: datum.y,
+                secondaryValue: typeof datum.x === "number" ? datum.x : index,
+                detail: `x=${typeof datum.x === "number" ? datum.x : index}`,
+                color,
+                index
+              })
+            }, interactiveNodeStyle));
+            if (config.showNumber) {
+              dots.push(buildValueLabelNode(`scatter-value-${series.id}-${index}`, config, datum.y, x, y - 12, {
+                fill: color
+              }));
+            }
+          });
+        });
+        return [
+          rectNode("scatter-surface", {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_e = config.layout.background) != null ? _e : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes("scatter", config, frame, config.theme),
+          groupNode("scatter-plot", [
+            rectNode("scatter-plot-bg", {
+              x: frame.plot.x,
+              y: frame.plot.y,
+              width: frame.plot.width,
+              height: frame.plot.height,
+              rx: 14,
+              fill: config.theme.plotBackground,
+              stroke: config.theme.plotBorder,
+              "stroke-width": 1
+            }),
+            ...buildContinuousAxisNodes({
+              idPrefix: "scatter",
+              frame,
+              theme: config.theme,
+              xScale,
+              yScale,
+              xAxis: config.xAxis,
+              yAxis: config.yAxis,
+              grid: config.grid
+            }),
+            ...buildThresholdNodes({
+              idPrefix: "scatter",
+              thresholds: config.thresholds,
+              frame,
+              theme: config.theme,
+              yScale
+            }),
+            ...dots
+          ]),
+          ...buildLegendNodes("scatter", config, frame, config.theme, payload.series.map((series, index) => ({
+            id: series.id,
+            label: series.name,
+            color: resolveSeriesColor(config, index, series.color)
+          })))
+        ];
+      }
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/radial-path.js
+var describeArc;
+var init_radial_path = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/common/radial-path.js"() {
+    init_math();
+    describeArc = (centerX, centerY, innerRadius, outerRadius, startAngle, endAngle) => {
+      const startOuter = polarToCartesian(centerX, centerY, outerRadius, startAngle);
+      const endOuter = polarToCartesian(centerX, centerY, outerRadius, endAngle);
+      const largeArc = endAngle - startAngle > Math.PI ? 1 : 0;
+      if (innerRadius <= 0) {
+        return [
+          `M ${centerX} ${centerY}`,
+          `L ${startOuter.x} ${startOuter.y}`,
+          `A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${endOuter.x} ${endOuter.y}`,
+          "Z"
+        ].join(" ");
+      }
+      const startInner = polarToCartesian(centerX, centerY, innerRadius, endAngle);
+      const endInner = polarToCartesian(centerX, centerY, innerRadius, startAngle);
+      return [
+        `M ${startOuter.x} ${startOuter.y}`,
+        `A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${endOuter.x} ${endOuter.y}`,
+        `L ${startInner.x} ${startInner.y}`,
+        `A ${innerRadius} ${innerRadius} 0 ${largeArc} 0 ${endInner.x} ${endInner.y}`,
+        "Z"
+      ].join(" ");
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/gauge/gauge-chart.js
+var gauge_chart_exports = {};
+__export(gauge_chart_exports, {
+  batteryChart: () => batteryChart,
+  gaugeChart: () => gaugeChart,
+  radialProgressChart: () => radialProgressChart,
+  semicircleGaugeChart: () => semicircleGaugeChart,
+  thermometerChart: () => thermometerChart,
+  thermometerHorizontalChart: () => thermometerHorizontalChart
+});
+var resolveAnchor2, getActiveSegment, getSegmentColorAtValue, createMetricTextNode, renderSurface, renderArcSegments, renderFilledArcSegments, renderGaugeArc, createArcGaugeDefinition, renderThermometer, createThermometerDefinition, createBatteryDefinition, gaugeChart, semicircleGaugeChart, radialProgressChart, thermometerChart, thermometerHorizontalChart, batteryChart;
+var init_gauge_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/gauge/gauge-chart.js"() {
+    init_chrome();
+    init_interaction();
+    init_radial_path();
+    init_scene();
+    init_math();
+    resolveAnchor2 = (centerX, x) => {
+      if (x < centerX - 8) {
+        return "end";
+      }
+      if (x > centerX + 8) {
+        return "start";
+      }
+      return "middle";
+    };
+    getActiveSegment = (payload) => {
+      var _a;
+      return (_a = payload.segments.find((segment) => payload.value >= segment.from && payload.value <= segment.to)) != null ? _a : payload.segments[payload.segments.length - 1];
+    };
+    getSegmentColorAtValue = (payload, value) => {
+      var _a, _b, _c, _d;
+      return (_d = (_c = (_a = payload.segments.find((segment) => value >= segment.from && value <= segment.to)) == null ? void 0 : _a.color) != null ? _c : (_b = payload.segments[payload.segments.length - 1]) == null ? void 0 : _b.color) != null ? _d : payload.color;
+    };
+    createMetricTextNode = (id, text, config, options) => {
+      var _a, _b;
+      return textNode(id, text, {
+        x: options.x,
+        y: options.y,
+        fill: options.fill,
+        stroke: config.theme.plotBackground,
+        "stroke-width": 6,
+        "paint-order": "stroke",
+        "font-family": config.theme.fontFamily,
+        "font-size": options.fontSize,
+        "font-weight": (_a = options.fontWeight) != null ? _a : 600,
+        "text-anchor": (_b = options.anchor) != null ? _b : "middle",
+        "dominant-baseline": "middle"
+      });
+    };
+    renderSurface = (prefix, config, frame, width, height) => {
+      var _a;
+      return [
+        rectNode(`${prefix}-surface`, {
+          x: 0,
+          y: 0,
+          width,
+          height,
+          rx: config.layout.cornerRadius,
+          fill: (_a = config.layout.background) != null ? _a : config.theme.surface,
+          stroke: config.theme.border,
+          "stroke-width": 1
+        }),
+        ...buildTitleNodes(prefix, config, frame, config.theme),
+        rectNode(`${prefix}-plot-bg`, {
+          x: frame.plot.x,
+          y: frame.plot.y,
+          width: frame.plot.width,
+          height: frame.plot.height,
+          rx: 16,
+          fill: config.theme.plotBackground,
+          stroke: config.theme.plotBorder,
+          "stroke-width": 1
+        })
+      ];
+    };
+    renderArcSegments = (prefix, payload, centerX, centerY, innerRadius, outerRadius, startAngle, endAngle) => {
+      const sweep = endAngle - startAngle;
+      const span = payload.max - payload.min || 1;
+      return payload.segments.map((segment) => {
+        const segmentStart = startAngle + (segment.from - payload.min) / span * sweep;
+        const segmentEnd = startAngle + (segment.to - payload.min) / span * sweep;
+        return pathNode(`${prefix}-segment-${segment.id}`, {
+          d: describeArc(centerX, centerY, innerRadius, outerRadius, segmentStart, segmentEnd),
+          fill: segment.color,
+          opacity: 0.26
+        });
+      });
+    };
+    renderFilledArcSegments = (prefix, payload, centerX, centerY, innerRadius, outerRadius, startAngle, endAngle, interactionAttrs) => {
+      const sweep = endAngle - startAngle;
+      const span = payload.max - payload.min || 1;
+      return payload.segments.flatMap((segment) => {
+        const filledTo = Math.min(payload.value, segment.to);
+        if (filledTo <= segment.from) {
+          return [];
+        }
+        const segmentStart = startAngle + (segment.from - payload.min) / span * sweep;
+        const segmentEnd = startAngle + (filledTo - payload.min) / span * sweep;
+        return [
+          pathNode(`${prefix}-progress-${segment.id}`, {
+            d: describeArc(centerX, centerY, innerRadius, outerRadius, segmentStart, segmentEnd),
+            fill: segment.color,
+            opacity: 0.98,
+            ...interactionAttrs
+          }, interactiveNodeStyle)
+        ];
+      });
+    };
+    renderGaugeArc = (prefix, config, payload, frame, width, height, options) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+      const centerX = frame.plot.x + frame.plot.width / 2;
+      const centerY = frame.plot.y + frame.plot.height * options.centerYRatio;
+      const startAngle = (_a = options.startAngle) != null ? _a : payload.startAngle;
+      const endAngle = (_b = options.endAngle) != null ? _b : payload.endAngle;
+      const sweep = endAngle - startAngle;
+      const valueAngle = startAngle + sweep * payload.ratio;
+      const outerRadius = Math.min(frame.plot.width * options.outerRadiusX, frame.plot.height * options.outerRadiusY);
+      const innerRadius = outerRadius * options.innerRatio;
+      const progressInnerRadius = outerRadius * options.progressInnerRatio;
+      const progressOuterRadius = outerRadius * options.progressOuterRatio;
+      const minPoint = polarToCartesian(centerX, centerY, outerRadius + 18, startAngle);
+      const maxPoint = polarToCartesian(centerX, centerY, outerRadius + 18, endAngle);
+      const needleStart = polarToCartesian(centerX, centerY, (_c = options.needleStartRadius) != null ? _c : 12, valueAngle);
+      const needleEnd = polarToCartesian(centerX, centerY, outerRadius + ((_d = options.needleEndOffset) != null ? _d : 4), valueAngle);
+      const activeSegment = getActiveSegment(payload);
+      const labelLift = config.showNumber ? 0 : -16;
+      const valueY = centerY + ((_e = options.valueYOffset) != null ? _e : options.compactLabels ? -14 : -20);
+      const labelY = centerY + ((_f = options.labelYOffset) != null ? _f : options.compactLabels ? 18 : 16) + labelLift;
+      const statusY = centerY + ((_g = options.statusYOffset) != null ? _g : options.compactLabels ? 38 : 34) + labelLift;
+      const gaugeInteraction = createInteractionAttrs({
+        targetId: `${prefix}-value`,
+        chartType: prefix,
+        kind: "gauge",
+        label: payload.label,
+        value: payload.formattedValue,
+        detail: activeSegment == null ? void 0 : activeSegment.label,
+        color: payload.color
+      });
+      return [
+        ...renderSurface(prefix, config, frame, width, height),
+        groupNode(`${prefix}-plot`, [
+          pathNode(`${prefix}-track`, {
+            d: describeArc(centerX, centerY, innerRadius, outerRadius, startAngle, endAngle),
+            fill: (_h = payload.trackColor) != null ? _h : config.theme.surfaceAlt,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1,
+            opacity: 0.9
+          }),
+          ...renderArcSegments(prefix, payload, centerX, centerY, innerRadius, outerRadius, startAngle, endAngle),
+          payload.ratio > 0 ? groupNode(`${prefix}-progress`, renderFilledArcSegments(prefix, payload, centerX, centerY, progressInnerRadius, progressOuterRadius, startAngle, endAngle, gaugeInteraction)) : groupNode(`${prefix}-progress-empty`),
+          !config.showNumber || options.showMinMax === false ? groupNode(`${prefix}-minmax-empty`) : groupNode(`${prefix}-minmax`, [
+            createMetricTextNode(`${prefix}-min`, String(payload.min), config, {
+              x: minPoint.x,
+              y: minPoint.y + 4,
+              fill: config.theme.mutedText,
+              fontSize: config.theme.fontSize - 1,
+              fontWeight: 600,
+              anchor: resolveAnchor2(centerX, minPoint.x)
+            }),
+            createMetricTextNode(`${prefix}-max`, String(payload.max), config, {
+              x: maxPoint.x,
+              y: maxPoint.y + 4,
+              fill: config.theme.mutedText,
+              fontSize: config.theme.fontSize - 1,
+              fontWeight: 600,
+              anchor: resolveAnchor2(centerX, maxPoint.x)
+            })
+          ]),
+          options.needle !== false ? lineNode(`${prefix}-needle`, {
+            x1: needleStart.x,
+            y1: needleStart.y,
+            x2: needleEnd.x,
+            y2: needleEnd.y,
+            stroke: config.theme.gaugeNeedle,
+            "stroke-width": options.compactLabels ? 4 : 4.5,
+            "stroke-linecap": "round"
+          }) : groupNode(`${prefix}-needle-empty`),
+          options.showHub === false ? groupNode(`${prefix}-hub-empty`) : groupNode(`${prefix}-hub`, [
+            circleNode(`${prefix}-hub-ring`, {
+              cx: centerX,
+              cy: centerY,
+              r: (_i = options.hubOuterRadius) != null ? _i : 8,
+              fill: config.theme.surface,
+              stroke: config.theme.gaugeNeedle,
+              "stroke-width": 3
+            }),
+            circleNode(`${prefix}-hub-core`, {
+              cx: centerX,
+              cy: centerY,
+              r: (_j = options.hubInnerRadius) != null ? _j : 3,
+              fill: payload.color
+            })
+          ]),
+          config.showNumber ? createMetricTextNode(`${prefix}-value`, payload.formattedValue, config, {
+            x: centerX,
+            y: valueY,
+            fill: config.theme.title,
+            fontSize: config.theme.fontSize + ((_k = options.valueSizeBoost) != null ? _k : options.compactLabels ? 10 : 16),
+            fontWeight: 700
+          }) : groupNode(`${prefix}-value-empty`),
+          createMetricTextNode(`${prefix}-label`, payload.label, config, {
+            x: centerX,
+            y: labelY,
+            fill: config.theme.text,
+            fontSize: config.theme.fontSize + ((_l = options.labelSizeBoost) != null ? _l : 1),
+            fontWeight: 600
+          }),
+          activeSegment ? createMetricTextNode(`${prefix}-status`, activeSegment.label, config, {
+            x: centerX,
+            y: statusY,
+            fill: activeSegment.color,
+            fontSize: config.theme.fontSize + ((_m = options.statusSizeBoost) != null ? _m : 0),
+            fontWeight: 600
+          }) : groupNode(`${prefix}-status-empty`)
+        ]),
+        ...buildLegendNodes(prefix, config, frame, config.theme, payload.segments.map((segment) => ({
+          id: segment.id,
+          label: segment.label,
+          color: segment.color
+        })))
+      ];
+    };
+    createArcGaugeDefinition = (id, options) => ({
+      id,
+      family: "radial",
+      render: ({ config, payload, frame, size }) => {
+        if (payload.kind !== "gauge") {
+          return [];
+        }
+        return renderGaugeArc(id, config, payload, frame, size.width, size.height, options);
+      }
+    });
+    renderThermometer = (prefix, config, payload, frame, width, height, horizontal) => {
+      var _a, _b, _c;
+      const activeSegment = getActiveSegment(payload);
+      if (horizontal) {
+        const trackWidth = frame.plot.width * 0.74;
+        const trackHeight = Math.min(28, frame.plot.height * 0.18);
+        const trackX = frame.plot.x + frame.plot.width * 0.11;
+        const trackY = frame.plot.y + frame.plot.height * 0.5 - trackHeight / 2;
+        const fillWidth = trackWidth * payload.ratio;
+        const fillEnd = trackX + fillWidth;
+        return [
+          ...renderSurface(prefix, config, frame, width, height),
+          groupNode(`${prefix}-plot`, [
+            rectNode(`${prefix}-track`, {
+              x: trackX,
+              y: trackY,
+              width: trackWidth,
+              height: trackHeight,
+              rx: trackHeight / 2,
+              fill: (_a = payload.trackColor) != null ? _a : config.theme.surfaceAlt,
+              stroke: config.theme.plotBorder,
+              "stroke-width": 1
+            }),
+            ...payload.segments.map((segment, index) => {
+              const ratioFrom = (segment.from - payload.min) / (payload.max - payload.min || 1);
+              const ratioTo = (segment.to - payload.min) / (payload.max - payload.min || 1);
+              return rectNode(`${prefix}-band-${segment.id}`, {
+                x: trackX + trackWidth * ratioFrom,
+                y: trackY,
+                width: trackWidth * Math.max(0, ratioTo - ratioFrom),
+                height: trackHeight,
+                rx: index === 0 || index === payload.segments.length - 1 ? trackHeight / 2 : 0,
+                fill: segment.color,
+                opacity: 0.2
+              });
+            }),
+            ...payload.segments.flatMap((segment) => {
+              const ratioFrom = (segment.from - payload.min) / (payload.max - payload.min || 1);
+              const ratioTo = (segment.to - payload.min) / (payload.max - payload.min || 1);
+              const segmentStart = trackX + trackWidth * ratioFrom;
+              const segmentEnd = trackX + trackWidth * ratioTo;
+              const visibleWidth = Math.max(0, Math.min(fillEnd, segmentEnd) - segmentStart);
+              if (visibleWidth <= 0) {
+                return [];
+              }
+              const rounded = segmentStart <= trackX + 0.5 || Math.abs(segmentStart + visibleWidth - fillEnd) < 0.5;
+              return [
+                rectNode(`${prefix}-fill-${segment.id}`, {
+                  x: segmentStart,
+                  y: trackY,
+                  width: visibleWidth,
+                  height: trackHeight,
+                  rx: rounded ? trackHeight / 2 : 0,
+                  fill: segment.color,
+                  opacity: 0.96
+                })
+              ];
+            }),
+            rectNode(`${prefix}-fill-hitbox`, {
+              x: trackX,
+              y: trackY,
+              width: Math.max(fillWidth, 12),
+              height: trackHeight,
+              rx: trackHeight / 2,
+              fill: "#ffffff",
+              opacity: 1e-3,
+              ...createInteractionAttrs({
+                targetId: `${prefix}-fill-hitbox`,
+                chartType: prefix,
+                kind: "gauge",
+                label: payload.label,
+                value: payload.formattedValue,
+                detail: activeSegment == null ? void 0 : activeSegment.label,
+                color: payload.color
+              })
+            }, interactiveNodeStyle),
+            config.showNumber ? textNode(`${prefix}-value`, payload.formattedValue, {
+              x: frame.plot.x + frame.plot.width / 2,
+              y: trackY - 18,
+              fill: config.theme.title,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize + 14,
+              "font-weight": 700,
+              "text-anchor": "middle"
+            }) : groupNode(`${prefix}-value-empty`),
+            textNode(`${prefix}-label`, payload.label, {
+              x: frame.plot.x + frame.plot.width / 2,
+              y: trackY + trackHeight + 24,
+              fill: config.theme.text,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize + 1,
+              "text-anchor": "middle"
+            }),
+            activeSegment ? textNode(`${prefix}-status`, activeSegment.label, {
+              x: frame.plot.x + frame.plot.width / 2,
+              y: trackY + trackHeight + 44,
+              fill: activeSegment.color,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize,
+              "text-anchor": "middle"
+            }) : groupNode(`${prefix}-status-empty`),
+            config.showNumber ? groupNode(`${prefix}-minmax`, [
+              textNode(`${prefix}-min`, String(payload.min), {
+                x: trackX,
+                y: trackY + trackHeight + 24,
+                fill: config.theme.mutedText,
+                "font-family": config.theme.fontFamily,
+                "font-size": config.theme.fontSize - 1
+              }),
+              textNode(`${prefix}-max`, String(payload.max), {
+                x: trackX + trackWidth,
+                y: trackY + trackHeight + 24,
+                fill: config.theme.mutedText,
+                "font-family": config.theme.fontFamily,
+                "font-size": config.theme.fontSize - 1,
+                "text-anchor": "end"
+              })
+            ]) : groupNode(`${prefix}-minmax-empty`)
+          ]),
+          ...buildLegendNodes(prefix, config, frame, config.theme, payload.segments.map((segment) => ({
+            id: segment.id,
+            label: segment.label,
+            color: segment.color
+          })))
+        ];
+      }
+      const tubeWidth = Math.min(34, frame.plot.width * 0.12);
+      const tubeHeight = frame.plot.height * 0.72;
+      const tubeX = frame.plot.x + frame.plot.width * 0.22;
+      const tubeY = frame.plot.y + frame.plot.height * 0.08;
+      const bulbRadius = tubeWidth * 0.82;
+      const bulbCx = tubeX + tubeWidth / 2;
+      const bulbCy = tubeY + tubeHeight + bulbRadius * 0.72;
+      const innerTubeX = tubeX + 4;
+      const innerTubeY = tubeY + 4;
+      const innerTubeWidth = tubeWidth - 8;
+      const innerTubeHeight = tubeHeight - 8;
+      const fillHeight = innerTubeHeight * payload.ratio;
+      const fillY = innerTubeY + innerTubeHeight - fillHeight;
+      const fillBottom = innerTubeY + innerTubeHeight;
+      return [
+        ...renderSurface(prefix, config, frame, width, height),
+        groupNode(`${prefix}-plot`, [
+          rectNode(`${prefix}-track`, {
+            x: tubeX,
+            y: tubeY,
+            width: tubeWidth,
+            height: tubeHeight,
+            rx: tubeWidth / 2,
+            fill: (_b = payload.trackColor) != null ? _b : config.theme.surfaceAlt,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          }),
+          ...payload.segments.map((segment, index) => {
+            const ratioFrom = (segment.from - payload.min) / (payload.max - payload.min || 1);
+            const ratioTo = (segment.to - payload.min) / (payload.max - payload.min || 1);
+            return rectNode(`${prefix}-band-${segment.id}`, {
+              x: tubeX,
+              y: tubeY + tubeHeight - tubeHeight * ratioTo,
+              width: tubeWidth,
+              height: tubeHeight * Math.max(0, ratioTo - ratioFrom),
+              rx: index === 0 || index === payload.segments.length - 1 ? tubeWidth / 2 : 0,
+              fill: segment.color,
+              opacity: 0.2
+            });
+          }),
+          ...payload.segments.flatMap((segment) => {
+            const ratioFrom = (segment.from - payload.min) / (payload.max - payload.min || 1);
+            const ratioTo = (segment.to - payload.min) / (payload.max - payload.min || 1);
+            const segmentTop = innerTubeY + innerTubeHeight - innerTubeHeight * ratioTo;
+            const segmentBottom = innerTubeY + innerTubeHeight - innerTubeHeight * ratioFrom;
+            const visibleTop = Math.max(fillY, segmentTop);
+            const visibleBottom = Math.min(fillBottom, segmentBottom);
+            const visibleHeight = Math.max(0, visibleBottom - visibleTop);
+            if (visibleHeight <= 0) {
+              return [];
+            }
+            const rounded = visibleTop <= fillY + 0.5 || Math.abs(visibleBottom - fillBottom) < 0.5;
+            return [
+              rectNode(`${prefix}-fill-${segment.id}`, {
+                x: innerTubeX,
+                y: visibleTop,
+                width: innerTubeWidth,
+                height: visibleHeight,
+                rx: rounded ? innerTubeWidth / 2 : 0,
+                fill: segment.color,
+                opacity: 0.96
+              })
+            ];
+          }),
+          rectNode(`${prefix}-fill-hitbox`, {
+            x: innerTubeX,
+            y: fillY,
+            width: innerTubeWidth,
+            height: Math.max(fillHeight, 12),
+            rx: innerTubeWidth / 2,
+            fill: "#ffffff",
+            opacity: 1e-3,
+            ...createInteractionAttrs({
+              targetId: `${prefix}-fill-hitbox`,
+              chartType: prefix,
+              kind: "gauge",
+              label: payload.label,
+              value: payload.formattedValue,
+              detail: activeSegment == null ? void 0 : activeSegment.label,
+              color: payload.color
+            })
+          }, interactiveNodeStyle),
+          circleNode(`${prefix}-bulb-track`, {
+            cx: bulbCx,
+            cy: bulbCy,
+            r: bulbRadius,
+            fill: (_c = payload.trackColor) != null ? _c : config.theme.surfaceAlt,
+            stroke: config.theme.plotBorder,
+            "stroke-width": 1
+          }),
+          circleNode(`${prefix}-bulb-fill`, {
+            cx: bulbCx,
+            cy: bulbCy,
+            r: bulbRadius - 5,
+            fill: payload.color
+          }),
+          config.showNumber ? textNode(`${prefix}-value`, payload.formattedValue, {
+            x: frame.plot.x + frame.plot.width * 0.68,
+            y: frame.plot.y + frame.plot.height * 0.42,
+            fill: config.theme.title,
+            "font-family": config.theme.fontFamily,
+            "font-size": config.theme.fontSize + 18,
+            "font-weight": 700,
+            "text-anchor": "middle"
+          }) : groupNode(`${prefix}-value-empty`),
+          textNode(`${prefix}-label`, payload.label, {
+            x: frame.plot.x + frame.plot.width * 0.68,
+            y: frame.plot.y + frame.plot.height * 0.42 + 28,
+            fill: config.theme.text,
+            "font-family": config.theme.fontFamily,
+            "font-size": config.theme.fontSize + 1,
+            "text-anchor": "middle"
+          }),
+          activeSegment ? textNode(`${prefix}-status`, activeSegment.label, {
+            x: frame.plot.x + frame.plot.width * 0.68,
+            y: frame.plot.y + frame.plot.height * 0.42 + 52,
+            fill: activeSegment.color,
+            "font-family": config.theme.fontFamily,
+            "font-size": config.theme.fontSize,
+            "text-anchor": "middle"
+          }) : groupNode(`${prefix}-status-empty`),
+          config.showNumber ? groupNode(`${prefix}-minmax`, [
+            textNode(`${prefix}-min`, String(payload.min), {
+              x: tubeX + tubeWidth + 12,
+              y: tubeY + tubeHeight + 2,
+              fill: config.theme.mutedText,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize - 1
+            }),
+            textNode(`${prefix}-max`, String(payload.max), {
+              x: tubeX + tubeWidth + 12,
+              y: tubeY + 10,
+              fill: config.theme.mutedText,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize - 1
+            })
+          ]) : groupNode(`${prefix}-minmax-empty`)
+        ]),
+        ...buildLegendNodes(prefix, config, frame, config.theme, payload.segments.map((segment) => ({
+          id: segment.id,
+          label: segment.label,
+          color: segment.color
+        })))
+      ];
+    };
+    createThermometerDefinition = (id, horizontal) => ({
+      id,
+      family: "widget",
+      render: ({ config, payload, frame, size }) => {
+        if (payload.kind !== "gauge") {
+          return [];
+        }
+        return renderThermometer(id, config, payload, frame, size.width, size.height, horizontal);
+      }
+    });
+    createBatteryDefinition = () => ({
+      id: "battery",
+      family: "widget",
+      render: ({ config, payload, frame, size }) => {
+        if (payload.kind !== "gauge") {
+          return [];
+        }
+        const activeSegment = getActiveSegment(payload);
+        const bodyWidth = frame.plot.width * 0.58;
+        const bodyHeight = Math.min(92, frame.plot.height * 0.34);
+        const bodyX = frame.plot.x + frame.plot.width * 0.12;
+        const bodyY = frame.plot.y + frame.plot.height * 0.36;
+        const terminalWidth = 16;
+        const terminalHeight = bodyHeight * 0.36;
+        const fillInset = 10;
+        const fillWidth = (bodyWidth - fillInset * 2) * payload.ratio;
+        const segmentGap = 6;
+        const segmentCount = 4;
+        const segmentWidth = (bodyWidth - fillInset * 2 - segmentGap * (segmentCount - 1)) / segmentCount;
+        return [
+          ...renderSurface("battery", config, frame, size.width, size.height),
+          groupNode("battery-plot", [
+            rectNode("battery-body", {
+              x: bodyX,
+              y: bodyY,
+              width: bodyWidth,
+              height: bodyHeight,
+              rx: 18,
+              fill: config.theme.surface,
+              stroke: config.theme.border,
+              "stroke-width": 2
+            }),
+            rectNode("battery-terminal", {
+              x: bodyX + bodyWidth + 6,
+              y: bodyY + (bodyHeight - terminalHeight) / 2,
+              width: terminalWidth,
+              height: terminalHeight,
+              rx: 6,
+              fill: config.theme.surfaceAlt,
+              stroke: config.theme.border,
+              "stroke-width": 1
+            }),
+            ...Array.from({ length: segmentCount }, (_, index) => {
+              const x = bodyX + fillInset + index * (segmentWidth + segmentGap);
+              const segmentRatioStart = index / segmentCount;
+              const segmentRatioEnd = (index + 1) / segmentCount;
+              const fillRatioWithinSegment = Math.max(0, Math.min(payload.ratio, segmentRatioEnd) - segmentRatioStart) / (segmentRatioEnd - segmentRatioStart);
+              const filled = fillRatioWithinSegment > 0;
+              const segmentMidValue = payload.min + (segmentRatioStart + (segmentRatioEnd - segmentRatioStart) / 2) * (payload.max - payload.min);
+              const fillColor = getSegmentColorAtValue(payload, segmentMidValue);
+              return rectNode(`battery-segment-${index}`, {
+                x,
+                y: bodyY + fillInset,
+                width: segmentWidth,
+                height: bodyHeight - fillInset * 2,
+                rx: 8,
+                fill: filled ? fillColor : config.theme.surfaceAlt,
+                opacity: filled ? 0.3 + fillRatioWithinSegment * 0.7 : 0.72
+              });
+            }),
+            rectNode("battery-fill-overlay", {
+              x: bodyX + fillInset,
+              y: bodyY + fillInset,
+              width: fillWidth,
+              height: bodyHeight - fillInset * 2,
+              rx: 10,
+              fill: payload.color,
+              opacity: 0.18,
+              ...createInteractionAttrs({
+                targetId: "battery-fill-overlay",
+                chartType: "battery",
+                kind: "gauge",
+                label: payload.label,
+                value: payload.formattedValue,
+                detail: activeSegment == null ? void 0 : activeSegment.label,
+                color: payload.color
+              })
+            }, interactiveNodeStyle),
+            config.showNumber ? textNode("battery-value", payload.formattedValue, {
+              x: frame.plot.x + frame.plot.width * 0.76,
+              y: bodyY + 26,
+              fill: config.theme.title,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize + 16,
+              "font-weight": 700,
+              "text-anchor": "middle"
+            }) : groupNode("battery-value-empty"),
+            textNode("battery-label", payload.label, {
+              x: frame.plot.x + frame.plot.width * 0.76,
+              y: bodyY + 54,
+              fill: config.theme.text,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize + 1,
+              "text-anchor": "middle"
+            }),
+            activeSegment ? textNode("battery-status", activeSegment.label, {
+              x: frame.plot.x + frame.plot.width * 0.76,
+              y: bodyY + 78,
+              fill: activeSegment.color,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize,
+              "text-anchor": "middle"
+            }) : groupNode("battery-status-empty")
+          ]),
+          ...buildLegendNodes("battery", config, frame, config.theme, payload.segments.map((segment) => ({
+            id: segment.id,
+            label: segment.label,
+            color: segment.color
+          })))
+        ];
+      }
+    });
+    gaugeChart = createArcGaugeDefinition("gauge", {
+      centerYRatio: 0.74,
+      outerRadiusX: 0.34,
+      outerRadiusY: 0.62,
+      innerRatio: 0.72,
+      progressInnerRatio: 0.8,
+      progressOuterRatio: 0.95,
+      needle: true,
+      showMinMax: true,
+      showHub: true,
+      valueYOffset: -20,
+      labelYOffset: 18,
+      statusYOffset: 34,
+      needleStartRadius: 10,
+      needleEndOffset: 4,
+      hubOuterRadius: 7,
+      hubInnerRadius: 3
+    });
+    semicircleGaugeChart = createArcGaugeDefinition("gauge-semicircle", {
+      centerYRatio: 0.78,
+      outerRadiusX: 0.46,
+      outerRadiusY: 0.72,
+      innerRatio: 0.74,
+      progressInnerRatio: 0.82,
+      progressOuterRatio: 0.96,
+      needle: true,
+      showMinMax: true,
+      showHub: true,
+      startAngle: Math.PI * 3 / 2,
+      endAngle: Math.PI * 5 / 2,
+      compactLabels: true,
+      valueYOffset: -8,
+      labelYOffset: 20,
+      statusYOffset: 36,
+      valueSizeBoost: 10,
+      needleStartRadius: 8,
+      needleEndOffset: 3,
+      hubOuterRadius: 6,
+      hubInnerRadius: 2.5
+    });
+    radialProgressChart = createArcGaugeDefinition("radial-progress", {
+      centerYRatio: 0.5,
+      outerRadiusX: 0.3,
+      outerRadiusY: 0.33,
+      innerRatio: 0.7,
+      progressInnerRatio: 0.72,
+      progressOuterRatio: 0.98,
+      needle: false,
+      showMinMax: false,
+      showHub: false,
+      startAngle: 1e-3,
+      endAngle: Math.PI * 2 - 1e-3,
+      valueYOffset: -2,
+      labelYOffset: 18,
+      statusYOffset: 36,
+      valueSizeBoost: 10,
+      labelSizeBoost: 0,
+      statusSizeBoost: 0
+    });
+    thermometerChart = createThermometerDefinition("thermometer", false);
+    thermometerHorizontalChart = createThermometerDefinition("thermometer-horizontal", true);
+    batteryChart = createBatteryDefinition();
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/donut/donut-chart.js
+var donut_chart_exports = {};
+__export(donut_chart_exports, {
+  donutChart: () => donutChart,
+  pieChart: () => pieChart
+});
+var createRadialDefinition, donutChart, pieChart;
+var init_donut_chart = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/donut/donut-chart.js"() {
+    init_chrome();
+    init_interaction();
+    init_palette();
+    init_radial_path();
+    init_value_labels();
+    init_scene();
+    init_math();
+    createRadialDefinition = (mode) => ({
+      id: mode,
+      family: "radial",
+      render: ({ config, payload, frame, size }) => {
+        var _a;
+        if (payload.kind !== "radial") {
+          return [];
+        }
+        const centerX = frame.plot.x + frame.plot.width / 2;
+        const centerY = frame.plot.y + frame.plot.height / 2 - (config.legend.show ? 4 : 0);
+        const outerRadius = Math.max(44, Math.min(frame.plot.width / 2 - 28, frame.plot.height / 2 - 10));
+        const innerRadius = mode === "pie" ? 0 : outerRadius * 0.58;
+        const total = payload.total || 1;
+        const gap = 0.012;
+        let currentAngle = 0;
+        const slices = payload.slices.flatMap((slice, index) => {
+          const rawSweep = slice.value / total * Math.PI * 2;
+          const startAngle = currentAngle + gap;
+          const endAngle = currentAngle + rawSweep - gap;
+          currentAngle += rawSweep;
+          const fill = resolveSeriesColor(config, index, slice.color);
+          const share = total > 0 ? (slice.value / total * 100).toFixed(1) : "0.0";
+          const midAngle = startAngle + (endAngle - startAngle) / 2;
+          const insideRadius = mode === "pie" ? outerRadius * 0.58 : innerRadius + (outerRadius - innerRadius) * 0.72;
+          const insidePoint = polarToCartesian(centerX, centerY, insideRadius, midAngle);
+          const edgePoint = polarToCartesian(centerX, centerY, outerRadius + 2, midAngle);
+          const elbowPoint = polarToCartesian(centerX, centerY, outerRadius + 18, midAngle);
+          const useOutsideLabel = config.showNumber;
+          const anchor = elbowPoint.x >= centerX ? "start" : "end";
+          const labelX = elbowPoint.x + (anchor === "start" ? 10 : -10);
+          const labelY = elbowPoint.y + 4;
+          return [
+            pathNode(`${mode}-slice-${slice.id}`, {
+              d: describeArc(centerX, centerY, innerRadius, outerRadius, startAngle, endAngle),
+              fill,
+              stroke: config.theme.pointStroke,
+              "stroke-width": mode === "pie" ? 2 : 3,
+              opacity: 0.96,
+              ...createInteractionAttrs({
+                targetId: `${mode}-slice-${slice.id}`,
+                chartType: mode,
+                kind: "slice",
+                label: slice.label,
+                value: slice.value,
+                detail: `${share}% of total`,
+                color: fill,
+                index
+              })
+            }, interactiveNodeStyle),
+            config.showNumber && useOutsideLabel ? lineNode(`${mode}-slice-guide-${slice.id}`, {
+              x1: edgePoint.x,
+              y1: edgePoint.y,
+              x2: elbowPoint.x,
+              y2: elbowPoint.y,
+              stroke: fill,
+              "stroke-width": 1.5,
+              opacity: 0.88
+            }) : groupNode(`${mode}-slice-guide-empty-${slice.id}`),
+            config.showNumber ? buildValueLabelNode(`${mode}-slice-value-${slice.id}`, config, slice.value, useOutsideLabel ? labelX : insidePoint.x, useOutsideLabel ? labelY : insidePoint.y + 4, {
+              anchor: useOutsideLabel ? anchor : "middle",
+              fill: useOutsideLabel ? config.theme.title : "#ffffff",
+              fontSize: config.theme.fontSize
+            }) : groupNode(`${mode}-slice-value-empty-${slice.id}`)
+          ];
+        });
+        return [
+          rectNode(`${mode}-surface`, {
+            x: 0,
+            y: 0,
+            width: size.width,
+            height: size.height,
+            rx: config.layout.cornerRadius,
+            fill: (_a = config.layout.background) != null ? _a : config.theme.surface,
+            stroke: config.theme.border,
+            "stroke-width": 1
+          }),
+          ...buildTitleNodes(mode, config, frame, config.theme),
+          groupNode(`${mode}-plot`, [
+            rectNode(`${mode}-plot-bg`, {
+              x: frame.plot.x,
+              y: frame.plot.y,
+              width: frame.plot.width,
+              height: frame.plot.height,
+              rx: 14,
+              fill: config.theme.plotBackground,
+              stroke: config.theme.plotBorder,
+              "stroke-width": 1
+            }),
+            ...slices,
+            mode === "donut" && config.showNumber ? textNode(`${mode}-center-total`, String(payload.total), {
+              x: centerX,
+              y: centerY + 4,
+              fill: config.theme.title,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize + 8,
+              "font-weight": 700,
+              "text-anchor": "middle"
+            }) : groupNode(`${mode}-center-total-empty`),
+            mode === "donut" && config.showNumber ? textNode(`${mode}-center-label`, "total", {
+              x: centerX,
+              y: centerY + 22,
+              fill: config.theme.mutedText,
+              "font-family": config.theme.fontFamily,
+              "font-size": config.theme.fontSize,
+              "text-anchor": "middle"
+            }) : groupNode(`${mode}-center-label-empty`)
+          ]),
+          ...buildLegendNodes(mode, config, frame, config.theme, payload.slices.map((slice, index) => ({
+            id: slice.id,
+            label: config.showNumber ? `${slice.label} (${slice.value})` : slice.label,
+            color: resolveSeriesColor(config, index, slice.color)
+          })))
+        ];
+      }
+    });
+    donutChart = createRadialDefinition("donut");
+    pieChart = createRadialDefinition("pie");
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/charts/index.js
+var charts_exports = {};
+__export(charts_exports, {
+  coreChartsPack: () => coreChartsPack
+});
+var coreChartsPack;
+var init_charts = __esm({
+  "node_modules/@revivejs/infinity-charts/dist/charts/index.js"() {
+    init_area_chart();
+    init_bar_3d_chart();
+    init_bar_chart();
+    init_combo_chart();
+    init_donut_chart();
+    init_gauge_chart();
+    init_line_chart();
+    init_scatter_chart();
+    init_sparkline_chart();
+    init_stacked_area_chart();
+    coreChartsPack = {
+      id: "core",
+      charts: [
+        lineChart,
+        areaChart,
+        stackedAreaChart,
+        barChart,
+        bar3DChart,
+        comboChart,
+        sparklineChart,
+        scatterChart,
+        gaugeChart,
+        semicircleGaugeChart,
+        radialProgressChart,
+        thermometerChart,
+        thermometerHorizontalChart,
+        batteryChart,
+        pieChart,
+        donutChart
+      ],
+      plugins: []
+    };
+  }
+});
+
+// node_modules/@revivejs/infinity-charts/dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  ChartRegistry: () => ChartRegistry,
+  builtInChartTypes: () => builtInChartTypes,
+  create: () => create,
+  createChart: () => createChart,
+  loadAllCharts: () => loadAllCharts,
+  loadChart: () => loadChart,
+  mount: () => mount,
+  preloadCharts: () => preloadCharts,
+  registerChart: () => registerChart,
+  registerChartLoader: () => registerChartLoader,
+  registerPack: () => registerPack,
+  registerPlugin: () => registerPlugin,
+  usePack: () => usePack
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/@revivejs/infinity-charts/dist/charts/loaders.js
+var builtInChartLoaders = {
+  line: async () => (await Promise.resolve().then(() => (init_line_chart(), line_chart_exports))).lineChart,
+  area: async () => (await Promise.resolve().then(() => (init_area_chart(), area_chart_exports))).areaChart,
+  "stacked-area": async () => (await Promise.resolve().then(() => (init_stacked_area_chart(), stacked_area_chart_exports))).stackedAreaChart,
+  bar: async () => (await Promise.resolve().then(() => (init_bar_chart(), bar_chart_exports))).barChart,
+  "bar-3d": async () => (await Promise.resolve().then(() => (init_bar_3d_chart(), bar_3d_chart_exports))).bar3DChart,
+  combo: async () => (await Promise.resolve().then(() => (init_combo_chart(), combo_chart_exports))).comboChart,
+  sparkline: async () => (await Promise.resolve().then(() => (init_sparkline_chart(), sparkline_chart_exports))).sparklineChart,
+  scatter: async () => (await Promise.resolve().then(() => (init_scatter_chart(), scatter_chart_exports))).scatterChart,
+  gauge: async () => (await Promise.resolve().then(() => (init_gauge_chart(), gauge_chart_exports))).gaugeChart,
+  "gauge-semicircle": async () => (await Promise.resolve().then(() => (init_gauge_chart(), gauge_chart_exports))).semicircleGaugeChart,
+  "radial-progress": async () => (await Promise.resolve().then(() => (init_gauge_chart(), gauge_chart_exports))).radialProgressChart,
+  thermometer: async () => (await Promise.resolve().then(() => (init_gauge_chart(), gauge_chart_exports))).thermometerChart,
+  "thermometer-horizontal": async () => (await Promise.resolve().then(() => (init_gauge_chart(), gauge_chart_exports))).thermometerHorizontalChart,
+  battery: async () => (await Promise.resolve().then(() => (init_gauge_chart(), gauge_chart_exports))).batteryChart,
+  pie: async () => (await Promise.resolve().then(() => (init_donut_chart(), donut_chart_exports))).pieChart,
+  donut: async () => (await Promise.resolve().then(() => (init_donut_chart(), donut_chart_exports))).donutChart
+};
+var builtInChartTypes = Object.keys(builtInChartLoaders);
+
+// node_modules/@revivejs/infinity-charts/dist/charts/common/data-normalizer.js
+init_math();
+var gaugeLikeTypes = /* @__PURE__ */ new Set([
+  "gauge",
+  "gauge-semicircle",
+  "radial-progress",
+  "thermometer",
+  "thermometer-horizontal",
+  "battery"
+]);
+var resolveDefaultCartesianSeriesType = (type) => {
+  if (type === "bar") {
+    return "bar";
+  }
+  if (type === "bar-3d") {
+    return "bar";
+  }
+  if (type === "area" || type === "stacked-area") {
+    return "area";
+  }
+  if (type === "scatter") {
+    return "scatter";
+  }
+  return "line";
+};
+var isNumberArray = (input) => Array.isArray(input) && (input.length === 0 || input.every((value) => typeof value === "number"));
+var isRecordData = (input) => typeof input === "object" && input !== null && !Array.isArray(input) && Object.values(input).every((value) => typeof value === "number");
+var isCartesianSeriesArray = (input) => Array.isArray(input) && (input.length === 0 || input.every((item) => typeof item === "object" && item !== null && "data" in item && Array.isArray(item.data)));
+var isSliceArray = (input) => Array.isArray(input) && (input.length === 0 || input.every((item) => typeof item === "object" && item !== null && "value" in item && "label" in item && !("data" in item)));
+var isLabeledValueArray = (input) => Array.isArray(input) && (input.length === 0 || input.every((item) => typeof item === "object" && item !== null && "value" in item && "label" in item && !("data" in item)));
+var normalizeSingleCartesianData = (input) => {
+  var _a;
+  const labels = [...(_a = input.labels) != null ? _a : []];
+  if (isNumberArray(input.data)) {
+    const resolvedLabels = labels.length > 0 ? labels : input.data.map((_, index) => `Point ${index + 1}`);
+    return {
+      kind: "cartesian",
+      labels: resolvedLabels,
+      series: [
+        {
+          kind: "cartesian",
+          id: "series-0",
+          name: "Series 1",
+          type: resolveDefaultCartesianSeriesType(input.type),
+          data: input.data.map((value, index) => {
+            var _a2, _b;
+            return {
+              index,
+              x: (_a2 = resolvedLabels[index]) != null ? _a2 : `Point ${index + 1}`,
+              label: (_b = resolvedLabels[index]) != null ? _b : `Point ${index + 1}`,
+              y: value
+            };
+          })
+        }
+      ]
+    };
+  }
+  if (isRecordData(input.data)) {
+    const resolvedLabels = Object.keys(input.data);
+    const values = Object.values(input.data);
+    return {
+      kind: "cartesian",
+      labels: resolvedLabels,
+      series: [
+        {
+          kind: "cartesian",
+          id: "series-0",
+          name: "Series 1",
+          type: resolveDefaultCartesianSeriesType(input.type),
+          data: values.map((value, index) => {
+            var _a2, _b;
+            return {
+              index,
+              x: (_a2 = resolvedLabels[index]) != null ? _a2 : `Point ${index + 1}`,
+              label: (_b = resolvedLabels[index]) != null ? _b : `Point ${index + 1}`,
+              y: value
+            };
+          })
+        }
+      ]
+    };
+  }
+  if (Array.isArray(input.data)) {
+    const entries = input.data;
+    const resolvedLabels = labels.length > 0 ? labels : entries.map((entry, index) => {
+      var _a2, _b, _c;
+      if (typeof entry === "number") {
+        return `Point ${index + 1}`;
+      }
+      if ("y" in entry) {
+        return (_b = entry.label) != null ? _b : String((_a2 = entry.x) != null ? _a2 : `Point ${index + 1}`);
+      }
+      return (_c = entry.label) != null ? _c : `Point ${index + 1}`;
+    });
+    return {
+      kind: "cartesian",
+      labels: resolvedLabels,
+      series: [
+        {
+          kind: "cartesian",
+          id: "series-0",
+          name: "Series 1",
+          type: resolveDefaultCartesianSeriesType(input.type),
+          data: entries.map((entry, index) => {
+            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+            if (typeof entry === "number") {
+              return {
+                index,
+                x: (_a2 = resolvedLabels[index]) != null ? _a2 : `Point ${index + 1}`,
+                label: (_b = resolvedLabels[index]) != null ? _b : `Point ${index + 1}`,
+                y: entry
+              };
+            }
+            if ("y" in entry) {
+              return {
+                index,
+                x: (_d = (_c = entry.x) != null ? _c : resolvedLabels[index]) != null ? _d : `Point ${index + 1}`,
+                label: (_f = (_e = entry.label) != null ? _e : resolvedLabels[index]) != null ? _f : `Point ${index + 1}`,
+                y: entry.y
+              };
+            }
+            return {
+              index,
+              x: (_h = (_g = entry.label) != null ? _g : resolvedLabels[index]) != null ? _h : `Point ${index + 1}`,
+              label: (_j = (_i = entry.label) != null ? _i : resolvedLabels[index]) != null ? _j : `Point ${index + 1}`,
+              y: entry.value
+            };
+          })
+        }
+      ]
+    };
+  }
+  return {
+    kind: "cartesian",
+    labels: [],
+    series: [
+      {
+        kind: "cartesian",
+        id: "series-0",
+        name: "Series 1",
+        type: resolveDefaultCartesianSeriesType(input.type),
+        data: []
+      }
+    ]
+  };
+};
+var normalizeCartesianSeries = (input) => {
+  var _a, _b, _c, _d, _e;
+  if (!isCartesianSeriesArray(input.series)) {
+    return normalizeSingleCartesianData(input);
+  }
+  const baseLabels = ((_a = input.labels) == null ? void 0 : _a.length) ? [...input.labels] : (_c = (_b = input.series[0]) == null ? void 0 : _b.data.map((datum, index) => {
+    var _a2, _b2;
+    if (typeof datum === "number") {
+      return `Point ${index + 1}`;
+    }
+    return (_b2 = datum.label) != null ? _b2 : String((_a2 = datum.x) != null ? _a2 : `Point ${index + 1}`);
+  })) != null ? _c : [];
+  const series = input.series.map((entry, seriesIndex) => {
+    var _a2, _b2, _c2;
+    return {
+      kind: "cartesian",
+      id: (_a2 = entry.id) != null ? _a2 : `series-${seriesIndex}`,
+      name: (_b2 = entry.name) != null ? _b2 : `Series ${seriesIndex + 1}`,
+      color: entry.color,
+      type: (_c2 = entry.type) != null ? _c2 : resolveDefaultCartesianSeriesType(input.type),
+      data: entry.data.map((datum, index) => {
+        var _a3, _b3, _c3, _d2, _e2, _f;
+        if (typeof datum === "number") {
+          return {
+            index,
+            x: (_a3 = baseLabels[index]) != null ? _a3 : `Point ${index + 1}`,
+            label: (_b3 = baseLabels[index]) != null ? _b3 : `Point ${index + 1}`,
+            y: datum
+          };
+        }
+        return {
+          index,
+          x: (_d2 = (_c3 = datum.x) != null ? _c3 : baseLabels[index]) != null ? _d2 : `Point ${index + 1}`,
+          label: (_f = (_e2 = datum.label) != null ? _e2 : baseLabels[index]) != null ? _f : `Point ${index + 1}`,
+          y: datum.y
+        };
+      })
+    };
+  });
+  const labels = baseLabels.length > 0 ? baseLabels : (_e = (_d = series[0]) == null ? void 0 : _d.data.map((datum) => datum.label)) != null ? _e : [];
+  return {
+    kind: "cartesian",
+    labels,
+    series
+  };
+};
+var normalizeRadialPayload = (input) => {
+  const slices = isSliceArray(input.series) ? input.series : isSliceArray(input.data) ? input.data : isRecordData(input.data) ? Object.entries(input.data).map(([label, value]) => ({ label, value })) : isLabeledValueArray(input.data) ? input.data : isNumberArray(input.data) ? input.data.map((value, index) => ({
+    label: `Slice ${index + 1}`,
+    value
+  })) : [];
+  const normalizedSlices = slices.map((slice, index) => {
+    const explicitId = typeof slice.id === "string" ? slice.id : void 0;
+    const explicitColor = typeof slice.color === "string" ? slice.color : void 0;
+    return {
+      id: explicitId != null ? explicitId : `slice-${index}`,
+      label: slice.label,
+      value: slice.value,
+      color: explicitColor
+    };
+  });
+  return {
+    kind: "radial",
+    mode: input.type === "pie" ? "pie" : "donut",
+    slices: normalizedSlices,
+    total: sum(normalizedSlices.map((slice) => slice.value))
+  };
+};
+var resolveGaugeSource = (input) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (isCartesianSeriesArray(input.series)) {
+    const firstSeries = input.series[0];
+    const firstDatum = firstSeries == null ? void 0 : firstSeries.data[0];
+    if (firstSeries && firstDatum !== void 0) {
+      if (typeof firstDatum === "number") {
+        return {
+          value: firstDatum,
+          label: (_a = firstSeries.name) != null ? _a : "Value",
+          color: firstSeries.color
+        };
+      }
+      return {
+        value: firstDatum.y,
+        label: (_c = (_b = firstDatum.label) != null ? _b : firstSeries.name) != null ? _c : "Value",
+        color: firstSeries.color
+      };
+    }
+  }
+  if (isLabeledValueArray(input.data)) {
+    const first = input.data[0];
+    if (first) {
+      return {
+        value: first.value,
+        label: first.label,
+        color: first.color
+      };
+    }
+  }
+  if (isNumberArray(input.data)) {
+    return {
+      value: (_d = input.data[0]) != null ? _d : 0,
+      label: (_f = (_e = input.labels) == null ? void 0 : _e[0]) != null ? _f : "Value"
+    };
+  }
+  if (isRecordData(input.data)) {
+    const [label, value] = (_g = Object.entries(input.data)[0]) != null ? _g : ["Value", 0];
+    return { value, label };
+  }
+  return {
+    value: 0,
+    label: (_i = (_h = input.labels) == null ? void 0 : _h[0]) != null ? _i : "Value"
+  };
+};
+var normalizeGaugePayload = (input) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const gauge = input.gauge;
+  const min = (_a = gauge == null ? void 0 : gauge.min) != null ? _a : 0;
+  const max = (_b = gauge == null ? void 0 : gauge.max) != null ? _b : 100;
+  const span = max - min || 1;
+  const source = resolveGaugeSource(input);
+  const value = clamp(source.value, min, max);
+  const ratio = clamp((value - min) / span, 0, 1);
+  const segments = ((_c = gauge == null ? void 0 : gauge.bands) == null ? void 0 : _c.length) ? gauge.bands.map((band, index) => {
+    var _a2, _b2;
+    return {
+      id: `band-${index}`,
+      from: clamp(band.from, min, max),
+      to: clamp(band.to, min, max),
+      color: (_a2 = band.color) != null ? _a2 : "#2563eb",
+      label: (_b2 = band.label) != null ? _b2 : `Band ${index + 1}`
+    };
+  }) : [
+    {
+      id: "band-0",
+      from: min,
+      to: max,
+      color: "#2563eb",
+      label: "Value"
+    }
+  ];
+  const activeColor = (_h = (_g = (_e = source.color) != null ? _e : (_d = segments.find((segment) => value >= segment.from && value <= segment.to)) == null ? void 0 : _d.color) != null ? _g : (_f = segments[segments.length - 1]) == null ? void 0 : _f.color) != null ? _h : "#2563eb";
+  const formattedValue = (gauge == null ? void 0 : gauge.valueFormatter) ? gauge.valueFormatter(value) : `${Number.isInteger(value) ? value : value.toFixed(1)}${(_i = gauge == null ? void 0 : gauge.unit) != null ? _i : ""}`;
+  return {
+    kind: "gauge",
+    value,
+    min,
+    max,
+    ratio,
+    label: (gauge == null ? void 0 : gauge.label) || source.label,
+    unit: (_j = gauge == null ? void 0 : gauge.unit) != null ? _j : "",
+    formattedValue,
+    startAngle: (_k = gauge == null ? void 0 : gauge.startAngle) != null ? _k : Math.PI * 5 / 4,
+    endAngle: (_l = gauge == null ? void 0 : gauge.endAngle) != null ? _l : Math.PI * 11 / 4,
+    needle: (_m = gauge == null ? void 0 : gauge.needle) != null ? _m : true,
+    trackColor: gauge == null ? void 0 : gauge.trackColor,
+    color: activeColor,
+    segments
+  };
+};
+var normalizeChartPayload = (input) => input.type === "donut" || input.type === "pie" ? normalizeRadialPayload(input) : gaugeLikeTypes.has(input.type) ? normalizeGaugePayload(input) : normalizeCartesianSeries(input);
+var coerceCartesianSeriesInput = (input) => {
+  const payload = normalizeCartesianSeries(input);
+  return payload.series.map((series) => ({
+    id: series.id,
+    name: series.name,
+    color: series.color,
+    type: series.type,
+    data: series.data.map((datum) => ({
+      x: datum.x,
+      y: datum.y,
+      label: datum.label
+    }))
+  }));
+};
+var coerceRadialSliceInput = (input) => {
+  const payload = normalizeRadialPayload(input);
+  return payload.slices.map((slice) => ({
+    id: slice.id,
+    label: slice.label,
+    value: slice.value,
+    color: slice.color
+  }));
+};
+var appendDataPoint = (config, point) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  if (gaugeLikeTypes.has(config.type)) {
+    const nextValue = typeof point === "number" ? point : (_b = (_a = point.value) != null ? _a : point.y) != null ? _b : 0;
+    const nextLabel2 = typeof point === "object" ? (_e = (_d = point.label) != null ? _d : (_c = config.gauge) == null ? void 0 : _c.label) != null ? _e : "Value" : (_g = (_f = config.gauge) == null ? void 0 : _f.label) != null ? _g : "Value";
+    const nextColor = typeof point === "object" ? point.color : void 0;
+    config.data = [
+      {
+        label: nextLabel2,
+        value: nextValue,
+        ...nextColor ? { color: nextColor } : {}
+      }
+    ];
+    config.series = void 0;
+    config.labels = [nextLabel2];
+    return;
+  }
+  if (config.type === "pie" || config.type === "donut") {
+    const slices = coerceRadialSliceInput(config);
+    const nextValue = typeof point === "number" ? point : (_i = (_h = point.value) != null ? _h : point.y) != null ? _i : 0;
+    slices.push({
+      id: `slice-${slices.length}`,
+      label: typeof point === "number" ? `Slice ${slices.length + 1}` : (_j = point.label) != null ? _j : `Slice ${slices.length + 1}`,
+      value: nextValue,
+      color: typeof point === "object" ? point.color : void 0
+    });
+    config.data = slices;
+    config.series = void 0;
+    return;
+  }
+  const series = coerceCartesianSeriesInput(config);
+  if (series.length === 0) {
+    series.push({
+      id: "series-0",
+      name: "Series 1",
+      type: config.type === "bar" ? "bar" : config.type === "area" ? "area" : config.type === "scatter" ? "scatter" : "line",
+      data: []
+    });
+  }
+  const primarySeries = series[0];
+  const nextLabel = typeof point === "number" ? `Point ${primarySeries.data.length + 1}` : (_k = point.label) != null ? _k : `Point ${primarySeries.data.length + 1}`;
+  if (typeof point === "number") {
+    primarySeries.data.push({ label: nextLabel, y: point });
+  } else if (Array.isArray(point.values)) {
+    series.forEach((entry, index) => {
+      var _a2, _b2;
+      entry.data.push({
+        label: nextLabel,
+        y: (_b2 = (_a2 = point.values) == null ? void 0 : _a2[index]) != null ? _b2 : 0
+      });
+    });
+  } else if (point.seriesId && series.length > 1) {
+    series.forEach((entry) => {
+      var _a2, _b2;
+      entry.data.push({
+        label: nextLabel,
+        y: entry.id === point.seriesId ? (_b2 = (_a2 = point.value) != null ? _a2 : point.y) != null ? _b2 : 0 : 0
+      });
+    });
+  } else {
+    primarySeries.data.push({
+      label: nextLabel,
+      y: (_m = (_l = point.value) != null ? _l : point.y) != null ? _m : 0
+    });
+  }
+  const maxPoints = (_o = (_n = config.realtime) == null ? void 0 : _n.maxPoints) != null ? _o : 0;
+  if (maxPoints > 0) {
+    series.forEach((entry) => {
+      if (entry.data.length > maxPoints) {
+        entry.data = entry.data.slice(-maxPoints);
+      }
+    });
+  }
+  config.series = series;
+  config.data = void 0;
+  config.labels = primarySeries.data.map((datum) => {
+    var _a2;
+    return typeof datum === "number" ? "" : (_a2 = datum.label) != null ? _a2 : "";
+  });
+};
+
+// node_modules/@revivejs/infinity-charts/dist/events/event-emitter.js
+var EventEmitter = class {
+  constructor() {
+    __publicField(this, "handlers", /* @__PURE__ */ new Map());
+  }
+  on(event, handler) {
+    var _a;
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    (_a = this.handlers.get(event)) == null ? void 0 : _a.add(handler);
+    return () => {
+      var _a2;
+      (_a2 = this.handlers.get(event)) == null ? void 0 : _a2.delete(handler);
+    };
+  }
+  emit(event, payload) {
+    var _a;
+    (_a = this.handlers.get(event)) == null ? void 0 : _a.forEach((handler) => {
+      handler(payload);
+    });
+  }
+  clear() {
+    this.handlers.clear();
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/interaction/interaction-layer.js
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var clamp2 = (value, min, max) => Math.min(Math.max(value, min), max);
+var InteractionLayer = class {
+  constructor(container, events) {
+    __publicField(this, "container");
+    __publicField(this, "events");
+    __publicField(this, "tooltip", document.createElement("div"));
+    __publicField(this, "config");
+    __publicField(this, "activeTarget");
+    __publicField(this, "setRelativePosition", false);
+    __publicField(this, "handlePointerMove", (event) => {
+      var _a;
+      if (!((_a = this.config) == null ? void 0 : _a.interaction.enabled)) {
+        return;
+      }
+      const target = this.resolveInteractiveElement(event.target);
+      if (!target) {
+        this.clearActiveTarget();
+        return;
+      }
+      const payload = this.readPayload(target);
+      if (!payload) {
+        this.clearActiveTarget();
+        return;
+      }
+      this.activateTarget(target, payload);
+      if (this.config.interaction.tooltip) {
+        this.showTooltip(payload, event.clientX, event.clientY);
+      }
+    });
+    __publicField(this, "handlePointerLeave", () => {
+      this.clearActiveTarget();
+    });
+    __publicField(this, "handleClick", (event) => {
+      var _a;
+      if (!((_a = this.config) == null ? void 0 : _a.interaction.enabled) || !this.config.interaction.click) {
+        return;
+      }
+      const target = this.resolveInteractiveElement(event.target);
+      if (!target) {
+        return;
+      }
+      const payload = this.readPayload(target);
+      if (!payload) {
+        return;
+      }
+      this.events.emit("interaction:click", payload);
+      if (payload.kind === "datum") {
+        this.events.emit("point:click", payload);
+      }
+      if (payload.kind === "slice") {
+        this.events.emit("slice:click", payload);
+      }
+      if (payload.kind === "gauge") {
+        this.events.emit("gauge:click", payload);
+      }
+    });
+    this.container = container;
+    this.events = events;
+    this.tooltip.dataset.infinityChartsTooltip = "true";
+    this.tooltip.className = "infinity-chart-tooltip";
+    this.tooltip.setAttribute("aria-hidden", "true");
+    this.tooltip.style.position = "absolute";
+    this.tooltip.style.pointerEvents = "none";
+    this.tooltip.style.zIndex = "12";
+    this.tooltip.style.minWidth = "160px";
+    this.tooltip.style.maxWidth = "280px";
+    this.tooltip.style.padding = "12px 14px";
+    this.tooltip.style.borderRadius = "14px";
+    this.tooltip.style.border = "1px solid transparent";
+    this.tooltip.style.boxSizing = "border-box";
+    this.tooltip.style.backdropFilter = "blur(16px)";
+    this.tooltip.style.opacity = "0";
+    this.tooltip.style.transform = "translateY(8px)";
+    this.tooltip.style.transition = "opacity 160ms ease, transform 160ms ease";
+    this.tooltip.style.whiteSpace = "normal";
+    this.ensureContainerPositioning();
+    this.installListeners();
+    this.container.append(this.tooltip);
+  }
+  update(config) {
+    this.config = config;
+    this.tooltip.style.background = config.theme.tooltipBackground;
+    this.tooltip.style.color = config.theme.tooltipText;
+    this.tooltip.style.borderColor = config.theme.border;
+    this.tooltip.style.boxShadow = config.theme.shadow;
+    this.tooltip.style.fontFamily = config.theme.fontFamily;
+    this.tooltip.style.fontSize = `${config.theme.fontSize}px`;
+    if (!config.interaction.enabled) {
+      this.clearActiveTarget(false);
+    }
+  }
+  destroy() {
+    this.container.removeEventListener("mousemove", this.handlePointerMove);
+    this.container.removeEventListener("mouseleave", this.handlePointerLeave);
+    this.container.removeEventListener("click", this.handleClick);
+    this.clearActiveTarget(false);
+    this.tooltip.remove();
+    if (this.setRelativePosition) {
+      this.container.style.removeProperty("position");
+    }
+  }
+  ensureContainerPositioning() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (window.getComputedStyle(this.container).position === "static") {
+      this.container.style.position = "relative";
+      this.setRelativePosition = true;
+    }
+  }
+  installListeners() {
+    this.container.addEventListener("mousemove", this.handlePointerMove);
+    this.container.addEventListener("mouseleave", this.handlePointerLeave);
+    this.container.addEventListener("click", this.handleClick);
+  }
+  activateTarget(target, payload) {
+    var _a, _b, _c, _d;
+    if (((_a = this.activeTarget) == null ? void 0 : _a.element) === target) {
+      return;
+    }
+    this.clearActiveTarget(false);
+    const filter = target instanceof HTMLElement || target instanceof SVGElement ? target.style.getPropertyValue("filter") : "";
+    const opacity = target instanceof HTMLElement || target instanceof SVGElement ? target.style.getPropertyValue("opacity") : "";
+    if (((_b = this.config) == null ? void 0 : _b.interaction.hover) !== false && (target instanceof HTMLElement || target instanceof SVGElement)) {
+      const glow = (_d = (_c = this.config) == null ? void 0 : _c.theme.interactiveGlow) != null ? _d : "rgba(37, 99, 235, 0.22)";
+      target.style.setProperty("filter", `brightness(1.08) saturate(1.08) drop-shadow(0 12px 24px ${glow})`);
+      if (!opacity) {
+        target.style.setProperty("opacity", "1");
+      }
+    }
+    this.activeTarget = {
+      element: target,
+      payload,
+      filter,
+      opacity
+    };
+    this.events.emit("interaction:hover", payload);
+    if (payload.kind === "datum") {
+      this.events.emit("point:hover", payload);
+    }
+  }
+  clearActiveTarget(emitLeave = true) {
+    if (this.activeTarget && (this.activeTarget.element instanceof HTMLElement || this.activeTarget.element instanceof SVGElement)) {
+      this.activeTarget.element.style.setProperty("filter", this.activeTarget.filter);
+      if (this.activeTarget.opacity) {
+        this.activeTarget.element.style.setProperty("opacity", this.activeTarget.opacity);
+      } else {
+        this.activeTarget.element.style.removeProperty("opacity");
+      }
+    }
+    if (emitLeave && this.activeTarget) {
+      this.events.emit("interaction:leave", this.activeTarget.payload);
+    }
+    this.activeTarget = void 0;
+    this.hideTooltip();
+  }
+  showTooltip(payload, clientX, clientY) {
+    var _a, _b;
+    const rows = [
+      payload.seriesName && payload.label !== payload.seriesName ? ["Series", payload.seriesName] : void 0,
+      payload.value !== void 0 ? ["Value", String(payload.value)] : void 0,
+      payload.secondaryValue !== void 0 ? ["Compare", String(payload.secondaryValue)] : void 0,
+      payload.detail ? ["Context", payload.detail] : void 0
+    ].filter((entry) => Boolean(entry));
+    const title = (_b = (_a = payload.label) != null ? _a : payload.seriesName) != null ? _b : payload.chartType;
+    const swatch = payload.color ? `<span style="display:inline-block;width:10px;height:10px;border-radius:999px;background:${escapeHtml(payload.color)};"></span>` : "";
+    this.tooltip.innerHTML = `
+      <div style="display:flex;align-items:center;gap:8px;font-weight:700;font-size:1em;margin-bottom:${rows.length > 0 ? "8px" : "0"};">
+        ${swatch}
+        <span>${escapeHtml(title)}</span>
+      </div>
+      ${rows.map(([label, value]) => {
+      var _a2, _b2;
+      return `
+            <div style="display:flex;justify-content:space-between;gap:12px;margin-top:6px;">
+              <span style="color:${escapeHtml((_b2 = (_a2 = this.config) == null ? void 0 : _a2.theme.mutedText) != null ? _b2 : "#64748b")};">${escapeHtml(label)}</span>
+              <strong style="font-weight:600;">${escapeHtml(value)}</strong>
+            </div>
+          `;
+    }).join("")}
+    `;
+    const bounds = this.container.getBoundingClientRect();
+    const padding = 16;
+    const offset = 16;
+    const tooltipWidth = this.tooltip.offsetWidth || 220;
+    const tooltipHeight = this.tooltip.offsetHeight || 96;
+    const left = clamp2(clientX - bounds.left + offset, padding, Math.max(padding, bounds.width - tooltipWidth - padding));
+    const top = clamp2(clientY - bounds.top + offset, padding, Math.max(padding, bounds.height - tooltipHeight - padding));
+    this.tooltip.style.left = `${left}px`;
+    this.tooltip.style.top = `${top}px`;
+    this.tooltip.style.opacity = "1";
+    this.tooltip.style.transform = "translateY(0)";
+  }
+  hideTooltip() {
+    this.tooltip.style.opacity = "0";
+    this.tooltip.style.transform = "translateY(8px)";
+  }
+  resolveInteractiveElement(target) {
+    if (!(target instanceof Element)) {
+      return null;
+    }
+    return target.closest("[data-ic-interactive='true']");
+  }
+  readPayload(target) {
+    const raw = target.getAttribute("data-ic-payload");
+    if (!raw) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(raw);
+    } catch (e) {
+      return void 0;
+    }
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/layout/chart-layout.js
+var createRect = (x, y, width, height) => ({
+  x,
+  y,
+  width: Math.max(0, width),
+  height: Math.max(0, height)
+});
+var createChartFrame = (config, size, payload) => {
+  const { padding, plotPadding } = config.layout;
+  const outer = createRect(0, 0, size.width, size.height);
+  const radialLike = payload.kind === "radial" || payload.kind === "gauge";
+  const headerHeight = config.title.text || config.title.subtitle ? config.title.subtitle ? 58 : 40 : 0;
+  const innerX = padding.left;
+  const innerY = padding.top;
+  const innerWidth = size.width - padding.left - padding.right;
+  const innerHeight = size.height - padding.top - padding.bottom;
+  let bodyX = innerX;
+  let bodyY = innerY + headerHeight;
+  let bodyWidth = innerWidth;
+  let bodyHeight = innerHeight - headerHeight;
+  let legend;
+  const shouldReserveLegend = config.legend.show && (payload.kind === "cartesian" && payload.series.length > 0 || payload.kind === "radial" && payload.slices.length > 0 || payload.kind === "gauge" && payload.segments.length > 0);
+  if (shouldReserveLegend) {
+    if (config.legend.position === "right") {
+      legend = createRect(size.width - padding.right - 164, bodyY + 8, 156, Math.max(0, bodyHeight - 16));
+      bodyWidth -= legend.width + 12;
+    } else if (config.legend.position === "left") {
+      legend = createRect(padding.left + 8, bodyY + 8, 156, Math.max(0, bodyHeight - 16));
+      bodyX += legend.width + 12;
+      bodyWidth -= legend.width + 12;
+    } else {
+      const legendHeight = radialLike ? 30 : 36;
+      const legendOffset = radialLike ? 36 : 44;
+      legend = createRect(bodyX + 8, size.height - padding.bottom - legendOffset, Math.max(0, bodyWidth - 16), legendHeight);
+      bodyHeight -= legendOffset;
+    }
+  }
+  const compactCartesian = config.type === "sparkline";
+  const radialPlotPadding = radialLike ? {
+    top: Math.min(plotPadding.top, 4),
+    right: Math.min(plotPadding.right, 4),
+    bottom: Math.min(plotPadding.bottom, 4),
+    left: Math.min(plotPadding.left, 4)
+  } : plotPadding;
+  const axisLeft = payload.kind === "cartesian" && config.yAxis.show && !compactCartesian ? 56 : radialLike ? 0 : 8;
+  const axisBottom = payload.kind === "cartesian" && config.xAxis.show && !compactCartesian ? 42 : radialLike ? 0 : 8;
+  const trailingInset = radialLike ? 8 : 12;
+  const plot = createRect(bodyX + axisLeft + radialPlotPadding.left, bodyY + radialPlotPadding.top, bodyWidth - axisLeft - trailingInset - radialPlotPadding.left - radialPlotPadding.right, bodyHeight - axisBottom - radialPlotPadding.top - radialPlotPadding.bottom);
+  return {
+    outer,
+    header: createRect(innerX, innerY, innerWidth, headerHeight),
+    body: createRect(bodyX, bodyY, bodyWidth, bodyHeight),
+    plot,
+    legend
+  };
+};
+
+// node_modules/@revivejs/infinity-charts/dist/plugins/plugin-manager.js
+var PluginManager = class {
+  constructor(initialPlugins = []) {
+    __publicField(this, "plugins", /* @__PURE__ */ new Map());
+    initialPlugins.forEach((plugin) => this.register(plugin));
+  }
+  register(plugin) {
+    this.plugins.set(plugin.id, plugin);
+  }
+  invoke(hook, context) {
+    this.plugins.forEach((plugin) => {
+      var _a, _b;
+      (_b = (_a = plugin.hooks) == null ? void 0 : _a[hook]) == null ? void 0 : _b.call(_a, context);
+    });
+  }
+  list() {
+    return [...this.plugins.values()];
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/realtime/render-scheduler.js
+var RenderScheduler = class {
+  constructor() {
+    __publicField(this, "frameId", 0);
+    __publicField(this, "queued", /* @__PURE__ */ new Set());
+  }
+  schedule(reason, callback) {
+    this.queued.add(reason);
+    if (this.frameId !== 0) {
+      return;
+    }
+    this.frameId = window.requestAnimationFrame(() => {
+      const reasons = [...this.queued.values()];
+      this.queued.clear();
+      this.frameId = 0;
+      callback(reasons);
+    });
+  }
+  flush(callback) {
+    if (this.queued.size === 0) {
+      return;
+    }
+    const reasons = [...this.queued.values()];
+    this.queued.clear();
+    if (this.frameId !== 0) {
+      window.cancelAnimationFrame(this.frameId);
+      this.frameId = 0;
+    }
+    callback(reasons);
+  }
+  destroy() {
+    if (this.frameId !== 0) {
+      window.cancelAnimationFrame(this.frameId);
+    }
+    this.frameId = 0;
+    this.queued.clear();
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/core/chart-engine.js
+init_scene();
+
+// node_modules/@revivejs/infinity-charts/dist/renderers/svg/svg-renderer.js
+var SVG_NS = "http://www.w3.org/2000/svg";
+var tagNameByKind = {
+  group: "g",
+  rect: "rect",
+  path: "path",
+  text: "text",
+  line: "line",
+  circle: "circle"
+};
+var SvgRenderer = class {
+  constructor() {
+    __publicField(this, "svg");
+    __publicField(this, "container");
+    __publicField(this, "attrCache", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "styleCache", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "previousChartTypeClass");
+    __publicField(this, "previousThemeClass");
+    this.svg = document.createElementNS(SVG_NS, "svg");
+    this.svg.setAttribute("xmlns", SVG_NS);
+    this.svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    this.svg.style.display = "block";
+    this.svg.style.width = "100%";
+    this.svg.style.height = "100%";
+  }
+  mount(container) {
+    this.container = container;
+    container.innerHTML = "";
+    container.classList.add("infinity-chart-host");
+    container.append(this.svg);
+  }
+  resize(width, height) {
+    this.svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+    this.svg.setAttribute("width", String(width));
+    this.svg.setAttribute("height", String(height));
+  }
+  render(scene, options) {
+    var _a, _b;
+    this.applyRootClasses(options.chartType, options.themeMode);
+    this.svg.style.background = (_a = options.background) != null ? _a : "transparent";
+    this.svg.setAttribute("role", "img");
+    this.svg.setAttribute("aria-label", (_b = options.ariaLabel) != null ? _b : "Infinity chart");
+    this.syncChildren(this.svg, scene, options.animation);
+  }
+  destroy() {
+    this.svg.remove();
+  }
+  applyRootClasses(chartType = "chart", themeMode = "light") {
+    const normalizedType = chartType.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
+    const nextTypeClass = `infinity-chart-host--${normalizedType}`;
+    const nextThemeClass = `infinity-chart-theme--${themeMode}`;
+    if (this.container) {
+      if (this.previousChartTypeClass) {
+        this.container.classList.remove(this.previousChartTypeClass);
+      }
+      if (this.previousThemeClass) {
+        this.container.classList.remove(this.previousThemeClass);
+      }
+      this.container.classList.add(nextTypeClass, nextThemeClass);
+      this.container.dataset.infinityChartType = chartType;
+      this.container.dataset.infinityChartTheme = themeMode;
+    }
+    this.svg.setAttribute("class", `infinity-chart-svg infinity-chart-svg--${normalizedType} infinity-chart-theme--${themeMode}`);
+    this.svg.dataset.infinityChartType = chartType;
+    this.svg.dataset.infinityChartTheme = themeMode;
+    this.previousChartTypeClass = nextTypeClass;
+    this.previousThemeClass = nextThemeClass;
+  }
+  syncChildren(parent, nodes, animation) {
+    const existing = /* @__PURE__ */ new Map();
+    Array.from(parent.children).forEach((child) => {
+      const element = child;
+      const id = element.dataset.sceneId;
+      if (id) {
+        existing.set(id, element);
+      }
+    });
+    let anchor = parent.firstChild;
+    const used = /* @__PURE__ */ new Set();
+    nodes.forEach((node) => {
+      const tagName = tagNameByKind[node.kind];
+      let element = existing.get(node.id);
+      const isNewElement = !element || element.tagName.toLowerCase() !== tagName;
+      if (isNewElement) {
+        element == null ? void 0 : element.remove();
+        element = document.createElementNS(SVG_NS, tagName);
+        element.dataset.sceneId = node.id;
+      }
+      if (!element) {
+        return;
+      }
+      this.applyNode(element, node, animation, isNewElement);
+      if (anchor !== element) {
+        parent.insertBefore(element, anchor);
+      }
+      used.add(node.id);
+      if (node.kind === "text") {
+      } else if (node.children && node.children.length > 0) {
+        this.syncChildren(element, node.children, animation);
+      } else {
+        while (element.firstChild) {
+          element.removeChild(element.firstChild);
+        }
+      }
+      anchor = element.nextSibling;
+    });
+    existing.forEach((element, id) => {
+      if (!used.has(id)) {
+        element.remove();
+      }
+    });
+  }
+  applyNode(element, node, animation, isNewElement) {
+    var _a, _b, _c;
+    this.applyAttributes(element, (_a = node.attrs) != null ? _a : {});
+    this.applyStyles(element, {
+      ...animation.enabled && node.kind !== "group" ? {
+        transition: `opacity ${animation.duration}ms ${animation.easing}, fill ${animation.duration}ms ${animation.easing}, stroke ${animation.duration}ms ${animation.easing}, transform ${animation.duration}ms ${animation.easing}, filter 160ms ease`
+      } : {},
+      ...(_b = node.style) != null ? _b : {}
+    });
+    if (node.kind === "text") {
+      element.textContent = (_c = node.textContent) != null ? _c : "";
+    }
+    if (isNewElement) {
+      this.animateNodeEntry(element, node, animation);
+    }
+  }
+  applyAttributes(element, attrs) {
+    var _a;
+    const previous = (_a = this.attrCache.get(element)) != null ? _a : /* @__PURE__ */ new Set();
+    const next = /* @__PURE__ */ new Set();
+    Object.entries(attrs).forEach(([key, value]) => {
+      if (value === void 0 || value === null || value === false) {
+        return;
+      }
+      element.setAttribute(key, String(value));
+      next.add(key);
+    });
+    previous.forEach((key) => {
+      if (!next.has(key)) {
+        element.removeAttribute(key);
+      }
+    });
+    this.attrCache.set(element, next);
+  }
+  applyStyles(element, styles) {
+    var _a;
+    const previous = (_a = this.styleCache.get(element)) != null ? _a : /* @__PURE__ */ new Set();
+    const next = /* @__PURE__ */ new Set();
+    Object.entries(styles).forEach(([key, value]) => {
+      if (value === void 0) {
+        return;
+      }
+      element.style.setProperty(key, String(value));
+      next.add(key);
+    });
+    previous.forEach((key) => {
+      if (!next.has(key)) {
+        element.style.removeProperty(key);
+      }
+    });
+    this.styleCache.set(element, next);
+  }
+  animateNodeEntry(element, node, animation) {
+    if (!animation.enabled || typeof element.animate !== "function" || node.kind === "group") {
+      return;
+    }
+    const delay = Math.max(0, animation.stagger);
+    if (node.kind === "path" && element.getAttribute("fill") === "none") {
+      const path = element;
+      if (typeof path.getTotalLength === "function") {
+        try {
+          const length = Math.max(1, path.getTotalLength());
+          const previousDasharray = element.style.getPropertyValue("stroke-dasharray");
+          const previousDashoffset = element.style.getPropertyValue("stroke-dashoffset");
+          element.style.setProperty("stroke-dasharray", String(length));
+          element.style.setProperty("stroke-dashoffset", String(length));
+          const animationHandle = element.animate([
+            { opacity: 0.18, strokeDashoffset: String(length) },
+            { opacity: 1, strokeDashoffset: "0" }
+          ], {
+            duration: animation.duration + 120,
+            delay,
+            easing: animation.easing,
+            fill: "forwards"
+          });
+          void animationHandle.finished.finally(() => {
+            if (previousDasharray) {
+              element.style.setProperty("stroke-dasharray", previousDasharray);
+            } else {
+              element.style.removeProperty("stroke-dasharray");
+            }
+            if (previousDashoffset) {
+              element.style.setProperty("stroke-dashoffset", previousDashoffset);
+            } else {
+              element.style.removeProperty("stroke-dashoffset");
+            }
+          });
+          return;
+        } catch (e) {
+        }
+      }
+    }
+    element.animate([
+      {
+        opacity: 0,
+        transform: "translateY(10px) scale(0.985)",
+        transformOrigin: "center center"
+      },
+      {
+        opacity: 1,
+        transform: "translateY(0) scale(1)",
+        transformOrigin: "center center"
+      }
+    ], {
+      duration: animation.duration,
+      delay,
+      easing: animation.easing,
+      fill: "both"
+    });
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/core/chart-registry.js
+var ChartRegistry = class {
+  constructor() {
+    __publicField(this, "charts", /* @__PURE__ */ new Map());
+    __publicField(this, "loaders", /* @__PURE__ */ new Map());
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+  }
+  register(definition) {
+    this.charts.set(definition.id, definition);
+  }
+  registerLoader(type, loader) {
+    this.loaders.set(type, loader);
+  }
+  has(type) {
+    return this.charts.has(type);
+  }
+  hasLoader(type) {
+    return this.loaders.has(type);
+  }
+  get(type) {
+    const chart = this.charts.get(type);
+    if (!chart) {
+      throw new Error(`Infinity Charts has no chart registered for "${type}".`);
+    }
+    return chart;
+  }
+  async ensure(type) {
+    if (this.charts.has(type)) {
+      return this.get(type);
+    }
+    const inFlight = this.pending.get(type);
+    if (inFlight) {
+      return inFlight;
+    }
+    const loader = this.loaders.get(type);
+    if (!loader) {
+      throw new Error(`Infinity Charts has no chart registered or loader configured for "${type}".`);
+    }
+    const pending = loader().then((definition) => {
+      this.register(definition);
+      this.pending.delete(type);
+      return this.get(type);
+    }).catch((error) => {
+      this.pending.delete(type);
+      throw error;
+    });
+    this.pending.set(type, pending);
+    return pending;
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/animation/animation-engine.js
+var resolveAnimationOptions = (options) => {
+  var _a, _b, _c, _d, _e;
+  const reducedMotion = typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  const enabled = (_a = options == null ? void 0 : options.enabled) != null ? _a : !reducedMotion;
+  const mode = enabled === false ? "none" : (_b = options == null ? void 0 : options.mode) != null ? _b : "subtle";
+  return {
+    enabled,
+    duration: enabled ? (_c = options == null ? void 0 : options.duration) != null ? _c : 320 : 0,
+    easing: (_d = options == null ? void 0 : options.easing) != null ? _d : "cubic-bezier(0.22, 1, 0.36, 1)",
+    stagger: (_e = options == null ? void 0 : options.stagger) != null ? _e : 18,
+    mode,
+    reducedMotion
+  };
+};
+
+// node_modules/@revivejs/infinity-charts/dist/utils/deep-merge.js
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var deepMerge = (base, patch) => {
+  if (patch === void 0) {
+    return structuredClone(base);
+  }
+  if (!isPlainObject(base) || !isPlainObject(patch)) {
+    return structuredClone(patch != null ? patch : base);
+  }
+  const result = { ...base };
+  Object.entries(patch).forEach(([key, value]) => {
+    if (value === void 0) {
+      return;
+    }
+    const current = result[key];
+    if (isPlainObject(current) && isPlainObject(value)) {
+      result[key] = deepMerge(current, value);
+      return;
+    }
+    result[key] = Array.isArray(value) ? [...value] : value;
+  });
+  return result;
+};
+
+// node_modules/@revivejs/infinity-charts/dist/theme/themes.js
+var lightTheme = {
+  name: "Infinity Light",
+  mode: "light",
+  background: "#faf8f4",
+  surface: "#ffffff",
+  surfaceAlt: "#f5f1eb",
+  plotBackground: "#fffdfa",
+  plotBorder: "#e7ded4",
+  border: "#e4dbd1",
+  grid: "#e8dfd6",
+  axis: "#91867b",
+  text: "#27303b",
+  mutedText: "#736b63",
+  title: "#171d26",
+  legendText: "#27303b",
+  shadow: "0 18px 54px rgba(15, 23, 42, 0.14)",
+  palette: [
+    "#2563eb",
+    "#0ea5e9",
+    "#14b8a6",
+    "#f59e0b",
+    "#ef4444",
+    "#8b5cf6",
+    "#ec4899",
+    "#84cc16"
+  ],
+  semantic: {
+    success: "#16a34a",
+    warning: "#d97706",
+    danger: "#dc2626",
+    info: "#0284c7"
+  },
+  fontFamily: '"IBM Plex Sans", system-ui, sans-serif',
+  fontSize: 13,
+  tooltipBackground: "#102038",
+  tooltipText: "#f8fafc",
+  pointStroke: "#ffffff",
+  threshold: "#d97706",
+  gaugeTrack: "#ece2d7",
+  gaugeNeedle: "#102038",
+  interactiveGlow: "rgba(37, 99, 235, 0.22)"
+};
+var darkTheme = {
+  name: "Infinity Dark",
+  mode: "dark",
+  background: "#07101d",
+  surface: "#0f172a",
+  surfaceAlt: "#132038",
+  plotBackground: "#0d1628",
+  plotBorder: "#1b2940",
+  border: "#223048",
+  grid: "#22324b",
+  axis: "#7f93ad",
+  text: "#d7e2f1",
+  mutedText: "#8fa4bc",
+  title: "#f8fbff",
+  legendText: "#d7e2f1",
+  shadow: "0 22px 64px rgba(2, 6, 23, 0.55)",
+  palette: [
+    "#60a5fa",
+    "#38bdf8",
+    "#2dd4bf",
+    "#fbbf24",
+    "#fb7185",
+    "#a78bfa",
+    "#f472b6",
+    "#a3e635"
+  ],
+  semantic: {
+    success: "#4ade80",
+    warning: "#fbbf24",
+    danger: "#f87171",
+    info: "#38bdf8"
+  },
+  fontFamily: '"IBM Plex Sans", system-ui, sans-serif',
+  fontSize: 13,
+  tooltipBackground: "#e5eefb",
+  tooltipText: "#081221",
+  pointStroke: "#0f172a",
+  threshold: "#fbbf24",
+  gaugeTrack: "#16243b",
+  gaugeNeedle: "#f8fbff",
+  interactiveGlow: "rgba(96, 165, 250, 0.26)"
+};
+
+// node_modules/@revivejs/infinity-charts/dist/theme/theme-engine.js
+var withCssVarFallback = (name, fallback) => `var(${name}, ${fallback})`;
+var wrapThemeWithCssVariables = (theme) => ({
+  ...theme,
+  background: withCssVarFallback("--ic-background", theme.background),
+  surface: withCssVarFallback("--ic-surface", theme.surface),
+  surfaceAlt: withCssVarFallback("--ic-surface-alt", theme.surfaceAlt),
+  plotBackground: withCssVarFallback("--ic-plot-background", theme.plotBackground),
+  plotBorder: withCssVarFallback("--ic-plot-border", theme.plotBorder),
+  border: withCssVarFallback("--ic-border", theme.border),
+  grid: withCssVarFallback("--ic-grid", theme.grid),
+  axis: withCssVarFallback("--ic-axis", theme.axis),
+  text: withCssVarFallback("--ic-text", theme.text),
+  mutedText: withCssVarFallback("--ic-muted-text", theme.mutedText),
+  title: withCssVarFallback("--ic-title", theme.title),
+  legendText: withCssVarFallback("--ic-legend-text", theme.legendText),
+  shadow: withCssVarFallback("--ic-shadow", theme.shadow),
+  palette: theme.palette.map((color, index) => withCssVarFallback(`--ic-series-${index + 1}`, color)),
+  semantic: {
+    success: withCssVarFallback("--ic-success", theme.semantic.success),
+    warning: withCssVarFallback("--ic-warning", theme.semantic.warning),
+    danger: withCssVarFallback("--ic-danger", theme.semantic.danger),
+    info: withCssVarFallback("--ic-info", theme.semantic.info)
+  },
+  fontFamily: withCssVarFallback("--ic-font-family", theme.fontFamily),
+  tooltipBackground: withCssVarFallback("--ic-tooltip-background", theme.tooltipBackground),
+  tooltipText: withCssVarFallback("--ic-tooltip-text", theme.tooltipText),
+  pointStroke: withCssVarFallback("--ic-point-stroke", theme.pointStroke),
+  threshold: withCssVarFallback("--ic-threshold", theme.threshold),
+  gaugeTrack: withCssVarFallback("--ic-gauge-track", theme.gaugeTrack),
+  gaugeNeedle: withCssVarFallback("--ic-gauge-needle", theme.gaugeNeedle),
+  interactiveGlow: withCssVarFallback("--ic-interactive-glow", theme.interactiveGlow)
+});
+var resolveTheme = (theme, paletteOverride = [], colors) => {
+  const base = theme === "dark" ? darkTheme : typeof theme === "object" && (theme == null ? void 0 : theme.mode) === "dark" ? darkTheme : lightTheme;
+  const merged = typeof theme === "object" ? deepMerge(base, theme) : deepMerge(base);
+  if (paletteOverride.length > 0) {
+    merged.palette = [...paletteOverride];
+  }
+  if (colors) {
+    Object.entries(colors).forEach(([key, value]) => {
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    });
+  }
+  return wrapThemeWithCssVariables(merged);
+};
+
+// node_modules/@revivejs/infinity-charts/dist/core/defaults.js
+var DEFAULT_PADDING = {
+  top: 20,
+  right: 20,
+  bottom: 20,
+  left: 20
+};
+var DEFAULT_PLOT_PADDING = {
+  top: 8,
+  right: 8,
+  bottom: 8,
+  left: 8
+};
+var measureWidgetTypes = /* @__PURE__ */ new Set([
+  "gauge",
+  "gauge-semicircle",
+  "radial-progress",
+  "thermometer",
+  "thermometer-horizontal",
+  "battery"
+]);
+var radialChartTypes = /* @__PURE__ */ new Set(["pie", "donut"]);
+var resolveMargin = (input, fallback) => {
+  var _a, _b, _c, _d;
+  return {
+    top: (_a = input == null ? void 0 : input.top) != null ? _a : fallback.top,
+    right: (_b = input == null ? void 0 : input.right) != null ? _b : fallback.right,
+    bottom: (_c = input == null ? void 0 : input.bottom) != null ? _c : fallback.bottom,
+    left: (_d = input == null ? void 0 : input.left) != null ? _d : fallback.left
+  };
+};
+var resolveTitle = (title) => {
+  var _a, _b, _c;
+  if (typeof title === "string") {
+    return {
+      text: title,
+      subtitle: "",
+      align: "start"
+    };
+  }
+  return {
+    text: (_a = title == null ? void 0 : title.text) != null ? _a : "",
+    subtitle: (_b = title == null ? void 0 : title.subtitle) != null ? _b : "",
+    align: (_c = title == null ? void 0 : title.align) != null ? _c : "start"
+  };
+};
+var resolveLayout = (config) => {
+  var _a, _b, _c, _d, _e;
+  return {
+    padding: resolveMargin((_a = config.layout) == null ? void 0 : _a.padding, DEFAULT_PADDING),
+    plotPadding: resolveMargin((_b = config.layout) == null ? void 0 : _b.plotPadding, DEFAULT_PLOT_PADDING),
+    cornerRadius: (_d = (_c = config.layout) == null ? void 0 : _c.cornerRadius) != null ? _d : 20,
+    background: (_e = config.layout) == null ? void 0 : _e.background
+  };
+};
+var resolveInteraction = (config) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const enabled = (_b = (_a = config.interaction) == null ? void 0 : _a.enabled) != null ? _b : true;
+  const showTooltip = (_e = (_d = config.showTooltip) != null ? _d : (_c = config.interaction) == null ? void 0 : _c.tooltip) != null ? _e : true;
+  return {
+    enabled,
+    tooltip: enabled && showTooltip,
+    hover: enabled && ((_g = (_f = config.interaction) == null ? void 0 : _f.hover) != null ? _g : true),
+    click: enabled && ((_i = (_h = config.interaction) == null ? void 0 : _h.click) != null ? _i : true)
+  };
+};
+var resolveBar3D = (config, theme) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  return {
+    depthX: (_b = (_a = config.bar3d) == null ? void 0 : _a.depthX) != null ? _b : 24,
+    depthY: (_d = (_c = config.bar3d) == null ? void 0 : _c.depthY) != null ? _d : 16,
+    topLightness: (_f = (_e = config.bar3d) == null ? void 0 : _e.topLightness) != null ? _f : 0.14,
+    sideLightness: (_h = (_g = config.bar3d) == null ? void 0 : _g.sideLightness) != null ? _h : -0.18,
+    floorColor: (_j = (_i = config.bar3d) == null ? void 0 : _i.floorColor) != null ? _j : theme.surfaceAlt,
+    floorLineColor: (_l = (_k = config.bar3d) == null ? void 0 : _k.floorLineColor) != null ? _l : theme.plotBorder,
+    shadowColor: (_n = (_m = config.bar3d) == null ? void 0 : _m.shadowColor) != null ? _n : theme.mode === "dark" ? "rgba(2, 6, 23, 0.42)" : "rgba(15, 23, 42, 0.14)"
+  };
+};
+var createGaugeBandsFromThresholds = (min, max, thresholds, theme) => {
+  const sorted = [...thresholds != null ? thresholds : []].filter((threshold) => {
+    var _a;
+    return ((_a = threshold.axis) != null ? _a : "y") === "y";
+  }).map((threshold) => threshold.value).filter((value) => value > min && value < max).sort((left, right) => left - right);
+  if (sorted.length === 0) {
+    return [];
+  }
+  const points = [min, ...sorted, max];
+  const fallbackColors = [
+    theme.semantic.success,
+    theme.semantic.warning,
+    theme.semantic.danger
+  ];
+  return points.slice(0, -1).map((from, index) => {
+    var _a;
+    return {
+      from,
+      to: (_a = points[index + 1]) != null ? _a : max,
+      color: fallbackColors[Math.min(index, fallbackColors.length - 1)],
+      label: index === 0 ? "Optimal" : index === points.length - 2 ? "Critical" : "Attention"
+    };
+  });
+};
+var resolveGauge = (config, theme) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+  const min = (_d = (_c = (_a = config.gauge) == null ? void 0 : _a.min) != null ? _c : (_b = config.yAxis) == null ? void 0 : _b.min) != null ? _d : 0;
+  const configuredMax = (_h = (_g = (_e = config.gauge) == null ? void 0 : _e.max) != null ? _g : (_f = config.yAxis) == null ? void 0 : _f.max) != null ? _h : 100;
+  const max = configuredMax > min ? configuredMax : min + 1;
+  const thresholdBands = createGaugeBandsFromThresholds(min, max, config.thresholds, theme);
+  const defaultBands = [
+    {
+      from: min,
+      to: min + (max - min) * 0.6,
+      color: theme.semantic.success,
+      label: "Healthy"
+    },
+    {
+      from: min + (max - min) * 0.6,
+      to: min + (max - min) * 0.85,
+      color: theme.semantic.warning,
+      label: "Attention"
+    },
+    {
+      from: min + (max - min) * 0.85,
+      to: max,
+      color: theme.semantic.danger,
+      label: "Critical"
+    }
+  ];
+  const bands = ((_j = (_i = config.gauge) == null ? void 0 : _i.bands) == null ? void 0 : _j.length) ? config.gauge.bands.map((band, index) => {
+    var _a2;
+    return {
+      from: Math.max(min, Math.min(max, band.from)),
+      to: Math.max(min, Math.min(max, band.to)),
+      color: band.color,
+      label: (_a2 = band.label) != null ? _a2 : `Band ${index + 1}`
+    };
+  }) : thresholdBands.length ? thresholdBands : defaultBands;
+  return {
+    min,
+    max,
+    unit: (_l = (_k = config.gauge) == null ? void 0 : _k.unit) != null ? _l : "",
+    label: (_n = (_m = config.gauge) == null ? void 0 : _m.label) != null ? _n : "",
+    startAngle: (_p = (_o = config.gauge) == null ? void 0 : _o.startAngle) != null ? _p : Math.PI * 5 / 4,
+    endAngle: (_r = (_q = config.gauge) == null ? void 0 : _q.endAngle) != null ? _r : Math.PI * 11 / 4,
+    needle: (_t = (_s = config.gauge) == null ? void 0 : _s.needle) != null ? _t : true,
+    trackColor: (_v = (_u = config.gauge) == null ? void 0 : _u.trackColor) != null ? _v : theme.gaugeTrack,
+    bands,
+    valueFormatter: (_w = config.gauge) == null ? void 0 : _w.valueFormatter
+  };
+};
+var resolveChartConfig = (config, container) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia, _ja, _ka, _la, _ma, _na, _oa, _pa, _qa, _ra, _sa;
+  const theme = resolveTheme(config.theme, (_a = config.palette) != null ? _a : [], config.colors);
+  const compactSparkline = config.type === "sparkline";
+  const compactMeasureWidget = measureWidgetTypes.has(config.type);
+  const radialChart = radialChartTypes.has(config.type);
+  const compactWidget = compactSparkline || compactMeasureWidget;
+  return {
+    ...config,
+    container,
+    showNumber: (_b = config.showNumber) != null ? _b : true,
+    showLegend: (_e = (_d = config.showLegend) != null ? _d : (_c = config.legend) == null ? void 0 : _c.show) != null ? _e : !compactWidget,
+    showTooltip: (_h = (_g = config.showTooltip) != null ? _g : (_f = config.interaction) == null ? void 0 : _f.tooltip) != null ? _h : true,
+    title: resolveTitle(config.title),
+    theme,
+    colors: { ...(_i = config.colors) != null ? _i : {} },
+    renderer: (_j = config.renderer) != null ? _j : "svg",
+    palette: ((_k = config.palette) == null ? void 0 : _k.length) ? [...config.palette] : [...theme.palette],
+    animation: resolveAnimationOptions(config.animation),
+    bar3d: resolveBar3D(config, theme),
+    responsive: {
+      enabled: (_m = (_l = config.responsive) == null ? void 0 : _l.enabled) != null ? _m : true,
+      debounceMs: (_o = (_n = config.responsive) == null ? void 0 : _n.debounceMs) != null ? _o : 48,
+      minHeight: (_q = (_p = config.responsive) == null ? void 0 : _p.minHeight) != null ? _q : compactSparkline ? 120 : compactMeasureWidget ? 240 : radialChart ? 340 : 280
+    },
+    interaction: resolveInteraction(config),
+    realtime: {
+      enabled: (_s = (_r = config.realtime) == null ? void 0 : _r.enabled) != null ? _s : false,
+      maxPoints: (_u = (_t = config.realtime) == null ? void 0 : _t.maxPoints) != null ? _u : 0,
+      batchWindowMs: (_w = (_v = config.realtime) == null ? void 0 : _v.batchWindowMs) != null ? _w : 0,
+      preserveDomain: (_y = (_x = config.realtime) == null ? void 0 : _x.preserveDomain) != null ? _y : false
+    },
+    layout: resolveLayout(config),
+    xAxis: {
+      show: (_A = (_z = config.xAxis) == null ? void 0 : _z.show) != null ? _A : !compactWidget,
+      title: (_C = (_B = config.xAxis) == null ? void 0 : _B.title) != null ? _C : "",
+      tickCount: (_E = (_D = config.xAxis) == null ? void 0 : _D.tickCount) != null ? _E : 5,
+      min: (_F = config.xAxis) == null ? void 0 : _F.min,
+      max: (_G = config.xAxis) == null ? void 0 : _G.max,
+      nice: (_I = (_H = config.xAxis) == null ? void 0 : _H.nice) != null ? _I : false,
+      format: (_J = config.xAxis) == null ? void 0 : _J.format
+    },
+    yAxis: {
+      show: (_L = (_K = config.yAxis) == null ? void 0 : _K.show) != null ? _L : !compactWidget,
+      title: (_N = (_M = config.yAxis) == null ? void 0 : _M.title) != null ? _N : "",
+      tickCount: (_P = (_O = config.yAxis) == null ? void 0 : _O.tickCount) != null ? _P : 5,
+      min: (_Q = config.yAxis) == null ? void 0 : _Q.min,
+      max: (_R = config.yAxis) == null ? void 0 : _R.max,
+      nice: (_T = (_S = config.yAxis) == null ? void 0 : _S.nice) != null ? _T : true,
+      format: (_U = config.yAxis) == null ? void 0 : _U.format
+    },
+    grid: {
+      show: (_W = (_V = config.grid) == null ? void 0 : _V.show) != null ? _W : !compactWidget,
+      x: (_Y = (_X = config.grid) == null ? void 0 : _X.x) != null ? _Y : false,
+      y: (__ = (_Z = config.grid) == null ? void 0 : _Z.y) != null ? __ : true,
+      color: (_aa = (_$ = config.grid) == null ? void 0 : _$.color) != null ? _aa : theme.grid,
+      opacity: (_ca = (_ba = config.grid) == null ? void 0 : _ba.opacity) != null ? _ca : 1
+    },
+    legend: {
+      show: (_fa = (_ea = config.showLegend) != null ? _ea : (_da = config.legend) == null ? void 0 : _da.show) != null ? _fa : !compactWidget,
+      position: (_ha = (_ga = config.legend) == null ? void 0 : _ga.position) != null ? _ha : "bottom",
+      align: (_ja = (_ia = config.legend) == null ? void 0 : _ia.align) != null ? _ja : "start"
+    },
+    gauge: {
+      ...resolveGauge(config, theme),
+      startAngle: (_la = (_ka = config.gauge) == null ? void 0 : _ka.startAngle) != null ? _la : config.type === "gauge-semicircle" ? Math.PI * 3 / 2 : config.type === "radial-progress" ? 1e-3 : Math.PI * 5 / 4,
+      endAngle: (_na = (_ma = config.gauge) == null ? void 0 : _ma.endAngle) != null ? _na : config.type === "gauge-semicircle" ? Math.PI * 5 / 2 : config.type === "radial-progress" ? Math.PI * 2 - 1e-3 : Math.PI * 11 / 4,
+      needle: (_pa = (_oa = config.gauge) == null ? void 0 : _oa.needle) != null ? _pa : config.type === "radial-progress" ? false : true
+    },
+    thresholds: [...(_qa = config.thresholds) != null ? _qa : []],
+    plugins: [...(_ra = config.plugins) != null ? _ra : []],
+    states: { ...(_sa = config.states) != null ? _sa : {} }
+  };
+};
+
+// node_modules/@revivejs/infinity-charts/dist/utils/dom.js
+var resolveContainer = (input) => {
+  if (typeof input !== "string") {
+    return input;
+  }
+  const element = document.querySelector(input);
+  if (!element) {
+    throw new Error(`Infinity Charts could not find container: ${input}`);
+  }
+  return element;
+};
+var measureContainer = (element, width, height, minHeight = 280) => {
+  var _a, _b;
+  const measuredWidth = (_a = width != null ? width : element.clientWidth) != null ? _a : 720;
+  const measuredHeight = (_b = height != null ? height : element.clientHeight) != null ? _b : minHeight;
+  return {
+    width: Math.max(240, measuredWidth),
+    height: Math.max(minHeight, measuredHeight)
+  };
+};
+var debounce = (callback, waitMs) => {
+  let timeoutId = 0;
+  return ((...args) => {
+    window.clearTimeout(timeoutId);
+    timeoutId = window.setTimeout(() => {
+      callback(...args);
+    }, waitMs);
+  });
+};
+
+// node_modules/@revivejs/infinity-charts/dist/core/chart-engine.js
+var buildStatusScene = (size, config, options) => {
+  var _a, _b;
+  return [
+    rectNode("status-surface", {
+      x: 0,
+      y: 0,
+      width: size.width,
+      height: size.height,
+      rx: config.layout.cornerRadius,
+      fill: (_a = config.layout.background) != null ? _a : config.theme.surface,
+      stroke: config.theme.border,
+      "stroke-width": 1
+    }),
+    rectNode("status-card", {
+      x: Math.max(24, size.width * 0.08),
+      y: Math.max(32, size.height * 0.22),
+      width: Math.max(220, size.width * 0.84),
+      height: Math.max(120, size.height * 0.38),
+      rx: 20,
+      fill: config.theme.plotBackground,
+      stroke: config.theme.border,
+      "stroke-width": 1
+    }),
+    rectNode("status-accent", {
+      x: Math.max(44, size.width * 0.12),
+      y: Math.max(54, size.height * 0.3),
+      width: 68,
+      height: 8,
+      rx: 999,
+      fill: (_b = options.accent) != null ? _b : config.theme.palette[0],
+      opacity: 0.88
+    }),
+    textNode("status-title", options.title, {
+      x: Math.max(44, size.width * 0.12),
+      y: Math.max(102, size.height * 0.38),
+      fill: config.theme.title,
+      "font-family": config.theme.fontFamily,
+      "font-size": config.theme.fontSize + 14,
+      "font-weight": 700
+    }),
+    textNode("status-subtitle", options.subtitle, {
+      x: Math.max(44, size.width * 0.12),
+      y: Math.max(132, size.height * 0.38),
+      fill: config.theme.mutedText,
+      "font-family": config.theme.fontFamily,
+      "font-size": config.theme.fontSize + 1
+    })
+  ];
+};
+var ChartEngine = class {
+  constructor(config, options) {
+    __publicField(this, "registry");
+    __publicField(this, "renderer", new SvgRenderer());
+    __publicField(this, "scheduler", new RenderScheduler());
+    __publicField(this, "events", new EventEmitter());
+    __publicField(this, "pluginManager");
+    __publicField(this, "container");
+    __publicField(this, "resizeHandler");
+    __publicField(this, "interaction");
+    __publicField(this, "resizeObserver");
+    __publicField(this, "destroyed", false);
+    __publicField(this, "inputConfig");
+    __publicField(this, "resolvedConfig");
+    __publicField(this, "renderId", 0);
+    __publicField(this, "renderPromise", Promise.resolve());
+    var _a;
+    this.registry = options.registry;
+    this.container = resolveContainer(config.container);
+    this.inputConfig = { ...config, container: this.container };
+    this.resolvedConfig = resolveChartConfig(this.inputConfig, this.container);
+    this.pluginManager = new PluginManager([
+      ...(_a = options.globalPlugins) != null ? _a : [],
+      ...this.resolvedConfig.plugins
+    ]);
+    this.renderer.mount(this.container);
+    this.interaction = new InteractionLayer(this.container, this.events);
+    this.interaction.update(this.resolvedConfig);
+    this.pluginManager.invoke("beforeInit", this.createPluginContext("init"));
+    this.render(["init"]);
+    void this.ready().then(() => {
+      if (!this.destroyed) {
+        this.pluginManager.invoke("afterInit", this.createPluginContext("init"));
+      }
+    }).catch(() => {
+    });
+    this.resizeHandler = debounce(() => {
+      this.resize();
+    }, this.resolvedConfig.responsive.debounceMs);
+    this.installResponsiveHandling();
+  }
+  ready() {
+    return this.renderPromise;
+  }
+  update(config) {
+    this.inputConfig = {
+      ...this.inputConfig,
+      ...config,
+      container: this.container
+    };
+    this.refreshResolvedConfig();
+    this.scheduleRender("config");
+  }
+  updateSeries(series) {
+    this.inputConfig.series = series;
+    this.inputConfig.data = void 0;
+    this.refreshResolvedConfig();
+    this.scheduleRender("series");
+  }
+  appendData(point) {
+    appendDataPoint(this.inputConfig, point);
+    this.refreshResolvedConfig();
+    this.scheduleRender("realtime");
+  }
+  appendBatch(points) {
+    points.forEach((point) => appendDataPoint(this.inputConfig, point));
+    this.refreshResolvedConfig();
+    this.scheduleRender("realtime");
+  }
+  replaceData(data) {
+    this.inputConfig.data = data;
+    this.inputConfig.series = void 0;
+    this.refreshResolvedConfig();
+    this.scheduleRender("data");
+  }
+  resize(width, height) {
+    if (width !== void 0) {
+      this.inputConfig.width = width;
+    }
+    if (height !== void 0) {
+      this.inputConfig.height = height;
+    }
+    this.refreshResolvedConfig();
+    this.scheduleRender("resize");
+  }
+  setTheme(theme) {
+    this.inputConfig.theme = theme;
+    this.refreshResolvedConfig();
+    this.scheduleRender("theme");
+  }
+  registerPlugin(plugin) {
+    this.pluginManager.register(plugin);
+    this.scheduleRender("plugin");
+  }
+  registerPack(pack) {
+    var _a;
+    pack.charts.forEach((chart) => this.registry.register(chart));
+    (_a = pack.plugins) == null ? void 0 : _a.forEach((plugin) => this.pluginManager.register(plugin));
+    this.scheduleRender("plugin");
+  }
+  on(event, handler) {
+    return this.events.on(event, handler);
+  }
+  destroy() {
+    var _a;
+    if (this.destroyed) {
+      return;
+    }
+    this.destroyed = true;
+    this.pluginManager.invoke("beforeDestroy", this.createPluginContext("config"));
+    (_a = this.resizeObserver) == null ? void 0 : _a.disconnect();
+    globalThis.removeEventListener("resize", this.resizeHandler);
+    this.scheduler.destroy();
+    this.events.emit("destroy");
+    this.events.clear();
+    this.interaction.destroy();
+    this.renderer.destroy();
+    this.pluginManager.invoke("afterDestroy", this.createPluginContext("config"));
+  }
+  installResponsiveHandling() {
+    if (!this.resolvedConfig.responsive.enabled) {
+      return;
+    }
+    if (typeof ResizeObserver !== "undefined") {
+      this.resizeObserver = new ResizeObserver(() => {
+        this.resizeHandler();
+      });
+      this.resizeObserver.observe(this.container);
+      return;
+    }
+    globalThis.addEventListener("resize", this.resizeHandler);
+  }
+  scheduleRender(reason) {
+    this.pluginManager.invoke("onUpdate", this.createPluginContext(reason));
+    this.scheduler.schedule(reason, (reasons) => {
+      this.render(reasons);
+    });
+  }
+  render(reasons) {
+    const nextRenderId = ++this.renderId;
+    const promise = this.renderInternal(reasons, nextRenderId);
+    this.renderPromise = promise;
+    void promise.catch(() => {
+    });
+  }
+  async renderInternal(reasons, renderId) {
+    var _a;
+    if (this.destroyed) {
+      return;
+    }
+    const payload = normalizeChartPayload(this.resolvedConfig);
+    const size = measureContainer(this.container, this.resolvedConfig.width, this.resolvedConfig.height, this.resolvedConfig.responsive.minHeight);
+    const frame = createChartFrame(this.resolvedConfig, size, payload);
+    const chartType = this.resolvedConfig.type;
+    const reason = (_a = reasons[0]) != null ? _a : "config";
+    const shouldLazyLoad = !this.registry.has(chartType) && this.registry.hasLoader(chartType);
+    this.renderer.resize(size.width, size.height);
+    if (shouldLazyLoad) {
+      this.renderer.render(buildStatusScene(size, this.resolvedConfig, {
+        title: `Loading ${chartType}`,
+        subtitle: "Infinity Charts is fetching this chart module on demand.",
+        accent: this.resolvedConfig.theme.palette[0]
+      }), {
+        background: this.resolvedConfig.theme.background,
+        animation: this.resolvedConfig.animation,
+        ariaLabel: `${chartType} chart loading`,
+        chartType,
+        themeMode: this.resolvedConfig.theme.mode
+      });
+      this.events.emit("load:start", { type: chartType, reasons });
+    }
+    let definition;
+    try {
+      definition = await this.registry.ensure(chartType);
+    } catch (error) {
+      if (this.destroyed || renderId !== this.renderId) {
+        return;
+      }
+      this.renderer.render(buildStatusScene(size, this.resolvedConfig, {
+        title: `Unable to load ${chartType}`,
+        subtitle: error instanceof Error ? error.message : "Unexpected chart loading error.",
+        accent: this.resolvedConfig.theme.semantic.danger
+      }), {
+        background: this.resolvedConfig.theme.background,
+        animation: this.resolvedConfig.animation,
+        ariaLabel: `${chartType} chart load error`,
+        chartType,
+        themeMode: this.resolvedConfig.theme.mode
+      });
+      this.events.emit("load:error", { type: chartType, error });
+      throw error;
+    }
+    if (this.destroyed || renderId !== this.renderId) {
+      return;
+    }
+    this.pluginManager.invoke("beforeRender", this.createPluginContext(reason));
+    this.renderer.render(definition.render({
+      config: this.resolvedConfig,
+      payload,
+      size,
+      frame,
+      reasons
+    }), {
+      background: this.resolvedConfig.theme.background,
+      animation: this.resolvedConfig.animation,
+      ariaLabel: this.resolvedConfig.title.text || `${chartType} chart`,
+      chartType,
+      themeMode: this.resolvedConfig.theme.mode
+    });
+    this.pluginManager.invoke("afterRender", this.createPluginContext(reason));
+    if (shouldLazyLoad) {
+      this.events.emit("load:end", { type: chartType, reasons });
+    }
+    this.events.emit("render", { reasons, size, type: chartType });
+  }
+  refreshResolvedConfig() {
+    this.resolvedConfig = resolveChartConfig({
+      ...this.inputConfig,
+      container: this.container
+    }, this.container);
+    this.interaction.update(this.resolvedConfig);
+  }
+  createPluginContext(reason) {
+    return {
+      chart: this,
+      config: this.resolvedConfig,
+      reason
+    };
+  }
+};
+
+// node_modules/@revivejs/infinity-charts/dist/index.js
+var globalRegistry = new ChartRegistry();
+var globalPlugins = [];
+builtInChartTypes.forEach((type) => {
+  globalRegistry.registerLoader(type, builtInChartLoaders[type]);
+});
+var registerChart = (chart) => {
+  globalRegistry.register(chart);
+};
+var registerChartLoader = (type, loader) => {
+  globalRegistry.registerLoader(type, loader);
+};
+var registerPlugin = (plugin) => {
+  globalPlugins.push(plugin);
+};
+var registerPack = (pack) => {
+  var _a;
+  pack.charts.forEach((chart) => globalRegistry.register(chart));
+  (_a = pack.plugins) == null ? void 0 : _a.forEach((plugin) => globalPlugins.push(plugin));
+};
+var loadChart = async (type) => {
+  await globalRegistry.ensure(type);
+};
+var preloadCharts = async (types) => {
+  await Promise.all(types.map((type) => globalRegistry.ensure(type)));
+};
+var loadAllCharts = async () => {
+  const { coreChartsPack: coreChartsPack2 } = await Promise.resolve().then(() => (init_charts(), charts_exports));
+  registerPack(coreChartsPack2);
+};
+var createChart = (config) => new ChartEngine(config, {
+  registry: globalRegistry,
+  globalPlugins
+});
+var create = createChart;
+var mount = createChart;
+var usePack = registerPack;