@nice2dev/ui 1.0.6 → 1.0.8

package/dist/charts-Bx_kNBsE.js

@@ -0,0 +1,4280 @@
+import { jsxs as _, jsx as e, Fragment as Be } from "react/jsx-runtime";
+import Re, { useContext as Ee, createContext as ke, useRef as ye, useState as oe, useMemo as he, useCallback as ee, forwardRef as be, useEffect as we, useImperativeHandle as Ne } from "react";
+import { u as Ye, a as je, b as Se } from "./core-BpghV7Ls.js";
+const Fe = (t, o) => o, He = ke(Fe);
+function Ve() {
+  return { t: Ee(He) };
+}
+ke({
+  dir: "ltr",
+  isRTL: !1,
+  flip: (t) => t,
+  value: (t) => t.ltr
+});
+ke(null);
+ke(null);
+const Me = [
+  "#3b82f6",
+  "#ef4444",
+  "#22c55e",
+  "#f59e0b",
+  "#8b5cf6",
+  "#ec4899",
+  "#06b6d4",
+  "#84cc16"
+], ze = ({
+  series: t,
+  categories: o,
+  width: l = 600,
+  height: i = 400,
+  title: c,
+  showLegend: b = !0,
+  showGrid: f = !0,
+  yAxisLabel: w,
+  xAxisLabel: B,
+  stacked: p,
+  zoomable: S,
+  crosshair: N,
+  annotations: z,
+  legendInteractive: M,
+  onDataPointClick: v,
+  exportable: u,
+  className: h,
+  style: m
+}) => {
+  const L = ye(null), [x, y] = oe(/* @__PURE__ */ new Set()), [s, T] = oe(null), [g, C] = oe(null), [d, $] = oe(!1), A = ye(null), O = he(
+    () => t.filter((P) => !x.has(P.name)),
+    [t, x]
+  ), X = ee(
+    (P) => {
+      M && y((K) => {
+        const ne = new Set(K);
+        return ne.has(P) ? ne.delete(P) : ne.add(P), ne;
+      });
+    },
+    [M]
+  ), R = {
+    top: c ? 40 : 20,
+    right: 20,
+    bottom: B ? 60 : 40,
+    left: w ? 60 : 50
+  }, Y = l - R.left - R.right, q = i - R.top - R.bottom, J = O[0]?.data.length ?? t[0]?.data.length ?? 0, V = g?.start ?? 0, Q = g?.end ?? J, r = Q - V, F = he(
+    () => O.map((P) => ({ ...P, data: P.data.slice(V, Q) })),
+    [O, V, Q]
+  ), H = he(
+    () => o?.slice(V, Q),
+    [o, V, Q]
+  ), { minY: k, maxY: n, yTicks: E } = he(() => {
+    let P;
+    if (p) {
+      P = [];
+      for (let D = 0; D < r; D++)
+        P.push(F.reduce((re, ue) => re + (ue.data[D] || 0), 0));
+    } else
+      P = F.flatMap((D) => D.data);
+    P.length === 0 && (P = [0]);
+    const K = Math.min(0, ...P), ne = Math.max(0, ...P), se = ne - K || 1, de = Math.pow(10, Math.floor(Math.log10(se))) || 1, a = Math.floor(K / de) * de, W = Math.ceil(ne / de) * de, U = [];
+    for (let D = a; D <= W; D += de)
+      U.push(Math.round(D * 1e6) / 1e6);
+    return U.length < 2 && U.push(W), { minY: a, maxY: W, yTicks: U };
+  }, [F, r, p]), I = (P) => q - (P - k) / (n - k || 1) * q, Z = (P) => (P + 0.5) / r * Y, ae = r > 0 ? Y / r / (p ? 1.5 : Math.max(O.length, 1) * 1.5) : 20, le = ee(
+    (P) => {
+      if (!S)
+        return;
+      P.preventDefault();
+      const K = g ?? { start: 0, end: J }, ne = K.end - K.start, se = (K.start + K.end) / 2, de = P.deltaY > 0 ? 1.2 : 0.8, a = Math.max(2, Math.min(J, Math.round(ne * de))), W = Math.max(0, Math.round(se - a / 2)), U = Math.min(J, W + a);
+      C({ start: W, end: U });
+    },
+    [S, g, J]
+  ), te = ee(
+    (P) => {
+      S && ($(!0), A.current = { x: P.clientX, range: g ?? { start: 0, end: J } });
+    },
+    [S, g, J]
+  ), j = ee(
+    (P) => {
+      const K = L.current?.getBoundingClientRect();
+      if (K && T({ x: P.clientX - K.left - R.left, y: P.clientY - K.top - R.top }), d && A.current && S) {
+        const ne = P.clientX - A.current.x, se = Y / r, de = -Math.round(ne / se), a = A.current.range, W = a.end - a.start;
+        let U = a.start + de;
+        U < 0 && (U = 0), U + W > J && (U = J - W), C({ start: U, end: U + W });
+      }
+    },
+    [d, S, Y, r, J, R.left, R.top]
+  ), G = ee(() => {
+    $(!1), A.current = null;
+  }, []), ce = ee(() => {
+    T(null), $(!1), A.current = null;
+  }, []), ge = ee(() => {
+    const P = L.current;
+    if (!P)
+      return;
+    const K = new XMLSerializer().serializeToString(P), ne = document.createElement("canvas");
+    ne.width = l, ne.height = i + (b ? 30 : 0);
+    const se = ne.getContext("2d");
+    if (!se)
+      return;
+    const de = new Image();
+    de.onload = () => {
+      se.fillStyle = "#fff", se.fillRect(0, 0, ne.width, ne.height), se.drawImage(de, 0, 0);
+      const a = document.createElement("a");
+      a.download = "chart.png", a.href = ne.toDataURL("image/png"), a.click();
+    }, de.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(K);
+  }, [l, i, b]);
+  return /* @__PURE__ */ _("div", { className: `nice-chart ${h || ""}`, style: m, children: [
+    u && /* @__PURE__ */ e(
+      "button",
+      {
+        type: "button",
+        className: "nice-chart__export-btn",
+        onClick: ge,
+        title: "Export PNG",
+        children: "📷"
+      }
+    ),
+    /* @__PURE__ */ _(
+      "svg",
+      {
+        ref: L,
+        width: l,
+        height: i + (b ? 30 : 0),
+        className: "nice-chart__svg",
+        onWheel: le,
+        onMouseDown: te,
+        onMouseMove: j,
+        onMouseUp: G,
+        onMouseLeave: ce,
+        children: [
+          /* @__PURE__ */ _("g", { transform: `translate(${R.left},${R.top})`, children: [
+            c && /* @__PURE__ */ e("text", { x: Y / 2, y: -10, textAnchor: "middle", className: "nice-chart__title", children: c }),
+            f && E.map((P) => /* @__PURE__ */ _("g", { children: [
+              /* @__PURE__ */ e(
+                "line",
+                {
+                  x1: 0,
+                  y1: I(P),
+                  x2: Y,
+                  y2: I(P),
+                  className: "nice-chart__grid-line"
+                }
+              ),
+              /* @__PURE__ */ e("text", { x: -8, y: I(P) + 4, textAnchor: "end", className: "nice-chart__axis-label", children: P })
+            ] }, P)),
+            H && H.map((P, K) => /* @__PURE__ */ e(
+              "text",
+              {
+                x: Z(K),
+                y: q + 20,
+                textAnchor: "middle",
+                className: "nice-chart__axis-label",
+                children: P
+              },
+              K
+            )),
+            w && /* @__PURE__ */ e(
+              "text",
+              {
+                x: -R.left + 14,
+                y: q / 2,
+                textAnchor: "middle",
+                transform: `rotate(-90, -${R.left - 14}, ${q / 2})`,
+                className: "nice-chart__axis-title",
+                children: w
+              }
+            ),
+            B && /* @__PURE__ */ e("text", { x: Y / 2, y: q + 45, textAnchor: "middle", className: "nice-chart__axis-title", children: B }),
+            /* @__PURE__ */ e("line", { x1: 0, y1: 0, x2: 0, y2: q, className: "nice-chart__axis" }),
+            /* @__PURE__ */ e("line", { x1: 0, y1: q, x2: Y, y2: q, className: "nice-chart__axis" }),
+            z?.map((P, K) => {
+              if (P.type === "line") {
+                const ne = I(P.value);
+                return /* @__PURE__ */ _("g", { children: [
+                  /* @__PURE__ */ e(
+                    "line",
+                    {
+                      x1: 0,
+                      y1: ne,
+                      x2: Y,
+                      y2: ne,
+                      stroke: P.color || "#ef4444",
+                      strokeWidth: 1.5,
+                      strokeDasharray: P.dash || "6,3"
+                    }
+                  ),
+                  P.label && /* @__PURE__ */ e(
+                    "text",
+                    {
+                      x: Y + 4,
+                      y: ne + 4,
+                      className: "nice-chart__annotation-label",
+                      fill: P.color || "#ef4444",
+                      children: P.label
+                    }
+                  )
+                ] }, K);
+              }
+              return /* @__PURE__ */ e(
+                "text",
+                {
+                  x: Z(P.value),
+                  y: -4,
+                  textAnchor: "middle",
+                  className: "nice-chart__annotation-label",
+                  fill: P.color || "#6b7280",
+                  children: P.label
+                },
+                K
+              );
+            }),
+            N && s && s.x >= 0 && s.x <= Y && s.y >= 0 && s.y <= q && /* @__PURE__ */ _(Be, { children: [
+              /* @__PURE__ */ e(
+                "line",
+                {
+                  x1: s.x,
+                  y1: 0,
+                  x2: s.x,
+                  y2: q,
+                  stroke: "#9ca3af",
+                  strokeWidth: 1,
+                  strokeDasharray: "4,2"
+                }
+              ),
+              /* @__PURE__ */ e(
+                "line",
+                {
+                  x1: 0,
+                  y1: s.y,
+                  x2: Y,
+                  y2: s.y,
+                  stroke: "#9ca3af",
+                  strokeWidth: 1,
+                  strokeDasharray: "4,2"
+                }
+              )
+            ] }),
+            F.map((P, K) => {
+              const ne = P.color || Me[K % Me.length], se = P.type || "bar";
+              if (se === "bar")
+                return /* @__PURE__ */ e("g", { children: P.data.map((a, W) => {
+                  let U, D;
+                  if (p) {
+                    const ue = F.slice(0, K).reduce((xe, fe) => xe + (fe.data[W] || 0), 0);
+                    U = I(ue + a), D = I(ue) - U;
+                  } else
+                    U = I(Math.max(0, a)), D = Math.abs(I(a) - I(0));
+                  const re = p ? Z(W) - ae / 2 : Z(W) - F.length * ae / 2 + K * ae;
+                  return /* @__PURE__ */ e(
+                    "rect",
+                    {
+                      x: re,
+                      y: U,
+                      width: ae * 0.9,
+                      height: Math.max(0, D),
+                      fill: ne,
+                      rx: 2,
+                      style: v ? { cursor: "pointer" } : void 0,
+                      onClick: v ? () => v(P.name, V + W, a) : void 0,
+                      children: /* @__PURE__ */ e("title", { children: `${P.name}: ${a}` })
+                    },
+                    W
+                  );
+                }) }, P.name);
+              const de = P.data.map((a, W) => `${Z(W)},${I(a)}`);
+              return /* @__PURE__ */ _("g", { children: [
+                se === "area" && /* @__PURE__ */ e(
+                  "polygon",
+                  {
+                    points: `${Z(0)},${I(0)} ${de.join(" ")} ${Z(r - 1)},${I(0)}`,
+                    fill: ne,
+                    opacity: 0.15
+                  }
+                ),
+                /* @__PURE__ */ e("polyline", { points: de.join(" "), fill: "none", stroke: ne, strokeWidth: 2 }),
+                P.data.map((a, W) => /* @__PURE__ */ e(
+                  "circle",
+                  {
+                    cx: Z(W),
+                    cy: I(a),
+                    r: 3,
+                    fill: ne,
+                    style: v ? { cursor: "pointer" } : void 0,
+                    onClick: v ? () => v(P.name, V + W, a) : void 0,
+                    children: /* @__PURE__ */ e("title", { children: `${P.name}: ${a}` })
+                  },
+                  W
+                ))
+              ] }, P.name);
+            })
+          ] }),
+          b && /* @__PURE__ */ e("g", { transform: `translate(${R.left}, ${i})`, children: t.map((P, K) => {
+            const ne = K * 120, se = x.has(P.name);
+            return /* @__PURE__ */ _(
+              "g",
+              {
+                transform: `translate(${ne}, 10)`,
+                style: M ? { cursor: "pointer" } : void 0,
+                onClick: () => X(P.name),
+                opacity: se ? 0.35 : 1,
+                children: [
+                  /* @__PURE__ */ e("rect", { width: 12, height: 12, rx: 2, fill: P.color || Me[K % Me.length] }),
+                  /* @__PURE__ */ e(
+                    "text",
+                    {
+                      x: 16,
+                      y: 10,
+                      className: "nice-chart__legend-text",
+                      style: se ? { textDecoration: "line-through" } : void 0,
+                      children: P.name
+                    }
+                  )
+                ]
+              },
+              P.name
+            );
+          }) })
+        ]
+      }
+    )
+  ] });
+}, dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NiceChart: ze
+}, Symbol.toStringTag, { value: "Module" }));
+function Xe(t) {
+  if (!t.length)
+    return { categories: [], numericFields: [], sampleValues: {} };
+  const o = t[0], l = [], i = {};
+  let c = null;
+  for (const [f, w] of Object.entries(o))
+    typeof w == "number" ? (l.push(f), i[f] = t.map((B) => Number(B[f]) || 0)) : !c && (typeof w == "string" || w instanceof Date) && (c = f);
+  return { categories: c ? t.map((f) => String(f[c] || "")) : t.map((f, w) => `Item ${w + 1}`), numericFields: l, sampleValues: i };
+}
+function Ze(t, o) {
+  const { categories: l, numericFields: i, sampleValues: c } = Xe(t);
+  return { series: i.map((f, w) => ({
+    name: f.replace(/([A-Z])/g, " $1").replace(/^./, (B) => B.toUpperCase()).trim(),
+    data: c[f],
+    type: o === "area" ? "area" : o === "line" ? "line" : "bar"
+  })), categories: l };
+}
+const ht = be(
+  function(o, l) {
+    const {
+      rawData: i,
+      enableAI: c = !0,
+      aiModel: b,
+      enableAutoType: f = !0,
+      enableInsights: w = !0,
+      dataDescription: B,
+      onChartSuggestion: p,
+      onInsights: S,
+      showAIToolbar: N = !0,
+      showInsightsOnLoad: z = !1,
+      series: M,
+      categories: v,
+      ...u
+    } = o, [h, m] = oe("bar"), [L, x] = oe(null), [y, s] = oe([]), [T, g] = oe(z), [C, d] = oe(null), { t: $ } = Ve(), A = Ye(), {
+      suggestChartType: O,
+      generateInsights: X,
+      isLoading: R
+    } = je(), Y = c && A.isConfigured, { series: q, categories: J } = i ? Ze(i, C || h) : { series: M || [], categories: v }, V = ee(async () => {
+      if (!Y || !f)
+        return { type: "bar", reason: "Default", config: {} };
+      const k = i || (M?.length ? M.flatMap((n) => n.data.map((E, I) => ({ [n.name]: E, index: I }))) : []);
+      try {
+        const n = await O(k, B), E = {
+          type: n.type,
+          reason: n.reason,
+          config: n.config
+        };
+        return x(E), m(E.type), p?.(E), E;
+      } catch {
+        return { type: "bar", reason: "Default fallback", config: {} };
+      }
+    }, [
+      Y,
+      f,
+      i,
+      M,
+      B,
+      O,
+      p
+    ]), Q = ee(async () => {
+      if (!Y || !w)
+        return [];
+      const k = i || (M?.length ? M.flatMap(
+        (n) => n.data.map((E, I) => ({ [n.name]: E, category: v?.[I] || I }))
+      ) : []);
+      try {
+        const n = await X(k, C || h);
+        return s(n), S?.(n), n;
+      } catch {
+        return [];
+      }
+    }, [
+      Y,
+      w,
+      i,
+      M,
+      v,
+      h,
+      C,
+      X,
+      S
+    ]), r = ee(
+      () => C || h,
+      [C, h]
+    );
+    we(() => {
+      Y && f && (i?.length || M?.length) && V();
+    }, [Y, f, i, M]), Ne(l, () => ({
+      getSuggestion: V,
+      generateInsights: Q,
+      getCurrentType: r
+    }));
+    const F = [
+      { type: "bar", icon: "📊", label: "Bar" },
+      { type: "line", icon: "📈", label: "Line" },
+      { type: "area", icon: "🏔️", label: "Area" },
+      { type: "pie", icon: "🥧", label: "Pie" },
+      { type: "donut", icon: "🍩", label: "Donut" },
+      { type: "scatter", icon: "⭐", label: "Scatter" }
+    ], H = C || h;
+    return /* @__PURE__ */ _("div", { className: "nice-chart-ai", "data-testid": o["data-testid"], children: [
+      N && Y && /* @__PURE__ */ _("div", { className: "nice-chart-ai__toolbar", children: [
+        /* @__PURE__ */ _("div", { className: "nice-chart-ai__toolbar-left", children: [
+          /* @__PURE__ */ e("span", { className: "nice-chart-ai__badge", children: "AI" }),
+          L && /* @__PURE__ */ _("div", { className: "nice-chart-ai__suggestion", children: [
+            /* @__PURE__ */ e("span", { className: "nice-chart-ai__suggestion-icon", children: "💡" }),
+            /* @__PURE__ */ _("span", { className: "nice-chart-ai__suggestion-text", children: [
+              $("chartAI.suggestedType", "Suggested:"),
+              " ",
+              L.type
+            ] }),
+            /* @__PURE__ */ _("span", { className: "nice-chart-ai__suggestion-reason", title: L.reason, children: [
+              "(",
+              L.reason,
+              ")"
+            ] })
+          ] }),
+          R && /* @__PURE__ */ e("span", { className: "nice-chart-ai__loading", children: $("chartAI.analyzing", "Analyzing...") })
+        ] }),
+        /* @__PURE__ */ e("div", { className: "nice-chart-ai__toolbar-center", children: /* @__PURE__ */ e("div", { className: "nice-chart-ai__type-selector", children: F.filter((k) => ["bar", "line", "area"].includes(k.type)).map(({ type: k, icon: n, label: E }) => /* @__PURE__ */ e(
+          "button",
+          {
+            type: "button",
+            className: `nice-chart-ai__type-btn ${H === k ? "nice-chart-ai__type-btn--active" : ""}`,
+            onClick: () => d(k),
+            title: E,
+            children: n
+          },
+          k
+        )) }) }),
+        /* @__PURE__ */ _("div", { className: "nice-chart-ai__toolbar-right", children: [
+          /* @__PURE__ */ _(
+            "button",
+            {
+              type: "button",
+              className: "nice-chart-ai__auto-btn",
+              onClick: () => V(),
+              disabled: R,
+              title: $("chartAI.autoDetect", "Auto-detect best chart type"),
+              children: [
+                "🔮 ",
+                $("chartAI.auto", "Auto")
+              ]
+            }
+          ),
+          w && /* @__PURE__ */ _(
+            "button",
+            {
+              type: "button",
+              className: "nice-chart-ai__insights-btn",
+              onClick: () => {
+                y.length || Q(), g(!T);
+              },
+              disabled: R,
+              title: $("chartAI.showInsights", "Show data insights"),
+              children: [
+                "💡 ",
+                $("chartAI.insights", "Insights")
+              ]
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ e("div", { className: "nice-chart-ai__chart-wrapper", children: /* @__PURE__ */ e(ze, { series: q, categories: J, ...u }) }),
+      T && y.length > 0 && /* @__PURE__ */ _("div", { className: "nice-chart-ai__insights", children: [
+        /* @__PURE__ */ _("div", { className: "nice-chart-ai__insights-header", children: [
+          /* @__PURE__ */ _("h4", { children: [
+            "💡 ",
+            $("chartAI.dataInsights", "Data Insights")
+          ] }),
+          /* @__PURE__ */ e(
+            "button",
+            {
+              type: "button",
+              className: "nice-chart-ai__insights-close",
+              onClick: () => g(!1),
+              children: "✕"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ e("ul", { className: "nice-chart-ai__insights-list", children: y.map((k, n) => /* @__PURE__ */ _("li", { className: "nice-chart-ai__insight", children: [
+          /* @__PURE__ */ e("span", { className: "nice-chart-ai__insight-icon", children: "•" }),
+          k
+        ] }, n)) }),
+        /* @__PURE__ */ e("div", { className: "nice-chart-ai__insights-footer", children: /* @__PURE__ */ _(
+          "button",
+          {
+            type: "button",
+            className: "nice-chart-ai__refresh",
+            onClick: () => Q(),
+            disabled: R,
+            children: [
+              "🔄 ",
+              $("chartAI.refresh", "Refresh")
+            ]
+          }
+        ) })
+      ] }),
+      T && R && /* @__PURE__ */ e("div", { className: "nice-chart-ai__insights nice-chart-ai__insights--loading", children: /* @__PURE__ */ _("div", { className: "nice-chart-ai__loading-content", children: [
+        /* @__PURE__ */ e("span", { className: "nice-chart-ai__spinner" }),
+        $("chartAI.generatingInsights", "Generating insights...")
+      ] }) })
+    ] });
+  }
+);
+function Ue(t, o) {
+  const l = t ? typeof t == "number" ? new Date(t) : new Date(t) : /* @__PURE__ */ new Date(), i = (B) => B.toString().padStart(2, "0"), c = i(l.getHours()), b = i(l.getMinutes()), f = i(l.getSeconds()), w = l.getMilliseconds().toString().padStart(3, "0");
+  switch (o) {
+    case "HH:mm:ss":
+      return `${c}:${b}:${f}`;
+    case "HH:mm":
+      return `${c}:${b}`;
+    case "mm:ss":
+      return `${b}:${f}`;
+    case "ss.SSS":
+      return `${f}.${w}`;
+    case "ISO":
+      return l.toISOString();
+    default:
+      return `${c}:${b}:${f}`;
+  }
+}
+function De(t) {
+  if (t.length === 0)
+    return null;
+  const o = Math.min(...t), l = Math.max(...t), i = t.reduce((b, f) => b + f, 0) / t.length, c = t[t.length - 1];
+  return { min: o, max: l, avg: i, current: c, count: t.length };
+}
+const Ge = be(
+  ({
+    series: t,
+    maxPoints: o = 100,
+    slidingWindow: l = !0,
+    refreshRate: i = 16,
+    dataSource: c,
+    width: b = 600,
+    height: f = 400,
+    title: w,
+    showLegend: B = !0,
+    showGrid: p = !0,
+    yAxisLabel: S,
+    xAxisLabel: N,
+    stacked: z,
+    zoomable: M,
+    crosshair: v,
+    annotations: u = [],
+    legendInteractive: h,
+    onDataPointClick: m,
+    exportable: L,
+    showControls: x = !0,
+    showStatus: y = !0,
+    initialPaused: s = !1,
+    onDataReceived: T,
+    onDataDropped: g,
+    timeFormat: C = "HH:mm:ss",
+    showStats: d,
+    thresholds: $ = [],
+    className: A,
+    style: O
+  }, X) => {
+    const [R, Y] = oe(() => {
+      const j = /* @__PURE__ */ new Map();
+      for (const G of t)
+        j.set(G.name, G.initialData?.slice() ?? []);
+      return j;
+    }), [q, J] = oe([]), [V, Q] = oe(s), [r, F] = oe(!1), H = ye([]), k = ye(Date.now()), n = ye(null), E = ee(() => {
+      const j = H.current;
+      j.length !== 0 && (H.current = [], Y((G) => {
+        const ce = new Map(G);
+        for (const ge of j) {
+          const P = ce.get(ge.series);
+          if (!P)
+            continue;
+          const K = [...P, ge.value];
+          if (l && K.length > o) {
+            const ne = K.length - o;
+            g?.(ne, ge.series), K.splice(0, ne);
+          }
+          ce.set(ge.series, K);
+        }
+        return ce;
+      }), j.length > 0 && J((G) => {
+        const ce = [...G];
+        for (const ge of j) {
+          const P = ge.category ?? Ue(ge.timestamp, C);
+          ce.push(P);
+        }
+        return l && ce.length > o && ce.splice(0, ce.length - o), ce;
+      }));
+    }, [l, o, C, g]), I = ee(() => {
+      const j = Date.now();
+      j - k.current >= i && (E(), k.current = j), n.current = requestAnimationFrame(I);
+    }, [i, E]);
+    we(() => (V || (n.current = requestAnimationFrame(I)), () => {
+      n.current !== null && (cancelAnimationFrame(n.current), n.current = null);
+    }), [V, I]);
+    const Z = ee(
+      (j) => {
+        if (V)
+          return;
+        const G = "points" in j ? j.points : [j];
+        for (const ce of G)
+          R.has(ce.series) && (H.current.push(ce), T?.(ce));
+      },
+      [V, R, T]
+    );
+    we(() => {
+      if (!c)
+        return;
+      const j = c.subscribe(Z);
+      let G;
+      return c.onStatusChange ? G = c.onStatusChange(F) : F(!0), c.fetchHistory && c.fetchHistory(o).then((ce) => {
+        for (const ge of ce)
+          H.current.push(ge);
+        E();
+      }), () => {
+        j(), G?.();
+      };
+    }, [c, Z, o, E]);
+    const ae = he(() => t.map((j) => ({
+      name: j.name,
+      color: j.color,
+      type: j.type,
+      data: R.get(j.name) ?? []
+    })), [t, R]), le = he(() => {
+      const j = [...u];
+      for (const G of $)
+        j.push({
+          type: "line",
+          value: G.value,
+          color: G.color,
+          label: G.label,
+          dash: G.style === "dashed" ? "5,5" : G.style === "dotted" ? "2,2" : void 0
+        });
+      return j;
+    }, [u, $]);
+    Ne(
+      X,
+      () => ({
+        pause() {
+          Q(!0);
+        },
+        resume() {
+          Q(!1);
+        },
+        isPaused() {
+          return V;
+        },
+        clear() {
+          Y((j) => {
+            const G = new Map(j);
+            for (const ce of G.keys())
+              G.set(ce, []);
+            return G;
+          }), J([]), H.current = [];
+        },
+        addPoint(j) {
+          Z(j);
+        },
+        addPoints(j) {
+          Z({ points: j });
+        },
+        getData(j) {
+          return R.get(j) ?? [];
+        },
+        getCategories() {
+          return q;
+        },
+        exportData() {
+          return { series: ae, categories: q };
+        },
+        getStats(j) {
+          const G = R.get(j);
+          return G ? De(G) : null;
+        }
+      }),
+      [V, R, q, ae, Z]
+    );
+    const te = he(() => {
+      if (!d)
+        return null;
+      const j = {};
+      for (const [G, ce] of R)
+        j[G] = De(ce);
+      return j;
+    }, [d, R]);
+    return /* @__PURE__ */ _("div", { className: A, style: { position: "relative", ...O }, children: [
+      y && /* @__PURE__ */ _(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            top: 8,
+            right: 8,
+            display: "flex",
+            alignItems: "center",
+            gap: 4,
+            fontSize: 12,
+            color: r ? "#22c55e" : "#ef4444",
+            zIndex: 10
+          },
+          children: [
+            /* @__PURE__ */ e(
+              "span",
+              {
+                style: {
+                  width: 8,
+                  height: 8,
+                  borderRadius: "50%",
+                  backgroundColor: r ? "#22c55e" : "#ef4444"
+                }
+              }
+            ),
+            r ? "Live" : "Disconnected"
+          ]
+        }
+      ),
+      x && /* @__PURE__ */ e(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            top: 8,
+            left: 8,
+            display: "flex",
+            gap: 4,
+            zIndex: 10
+          },
+          children: /* @__PURE__ */ e(
+            "button",
+            {
+              onClick: () => Q((j) => !j),
+              style: {
+                padding: "4px 8px",
+                fontSize: 12,
+                border: "1px solid #ddd",
+                borderRadius: 4,
+                background: V ? "#fef3c7" : "#fff",
+                cursor: "pointer"
+              },
+              title: V ? "Resume" : "Pause",
+              children: V ? "▶" : "⏸"
+            }
+          )
+        }
+      ),
+      d && te && /* @__PURE__ */ e(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            bottom: 50,
+            right: 8,
+            background: "rgba(255,255,255,0.9)",
+            border: "1px solid #ddd",
+            borderRadius: 4,
+            padding: 8,
+            fontSize: 11,
+            zIndex: 10
+          },
+          children: Object.entries(te).map(
+            ([j, G]) => G ? /* @__PURE__ */ _("div", { style: { marginBottom: 4 }, children: [
+              /* @__PURE__ */ e("strong", { children: j }),
+              /* @__PURE__ */ _("div", { children: [
+                "Min: ",
+                G.min.toFixed(2),
+                " | Max: ",
+                G.max.toFixed(2)
+              ] }),
+              /* @__PURE__ */ _("div", { children: [
+                "Avg: ",
+                G.avg.toFixed(2),
+                " | Now: ",
+                G.current.toFixed(2)
+              ] })
+            ] }, j) : null
+          )
+        }
+      ),
+      /* @__PURE__ */ e(
+        ze,
+        {
+          series: ae,
+          categories: q,
+          width: b,
+          height: f,
+          title: w,
+          showLegend: B,
+          showGrid: p,
+          yAxisLabel: S,
+          xAxisLabel: N,
+          stacked: z,
+          zoomable: M,
+          crosshair: v,
+          annotations: le,
+          legendInteractive: h,
+          onDataPointClick: m,
+          exportable: L
+        }
+      )
+    ] });
+  }
+);
+Ge.displayName = "NiceLiveChart";
+function ut(t) {
+  const {
+    hubConnection: o,
+    eventName: l = "DataPoint",
+    subscribeMethod: i = "SubscribeToMetrics",
+    historyMethod: c = "GetMetricHistory",
+    metricName: b
+  } = t;
+  return {
+    subscribe(f) {
+      const w = (B) => {
+        f(B);
+      };
+      return o.on(l, w), o.state === "Connected" && o.invoke(i, b).catch(() => {
+      }), () => {
+        o.off(l, w);
+      };
+    },
+    async fetchHistory(f) {
+      try {
+        return await o.invoke(c, b, f);
+      } catch {
+        return [];
+      }
+    },
+    onStatusChange(f) {
+      const w = () => f(o.state === "Connected");
+      return o.onclose(() => f(!1)), o.onreconnected(() => f(!0)), w(), () => {
+      };
+    }
+  };
+}
+function ft(t) {
+  const {
+    url: o,
+    autoReconnect: l = !0,
+    reconnectDelay: i = 3e3,
+    parseMessage: c = (S) => JSON.parse(S)
+  } = t;
+  let b = null, f = null, w = null, B = null;
+  const p = () => {
+    b = new WebSocket(o), b.onopen = () => {
+      f?.(!0);
+    }, b.onclose = () => {
+      f?.(!1), l && (B = setTimeout(p, i));
+    }, b.onerror = () => {
+      b?.close();
+    }, b.onmessage = (S) => {
+      try {
+        const N = c(S.data);
+        N && w && w(N);
+      } catch {
+      }
+    };
+  };
+  return {
+    subscribe(S) {
+      return w = S, p(), () => {
+        w = null, B && clearTimeout(B), b?.close(), b = null;
+      };
+    },
+    onStatusChange(S) {
+      return f = S, () => {
+        f = null;
+      };
+    }
+  };
+}
+function pt(t) {
+  const { seriesNames: o, interval: l = 1e3, generateValue: i = () => Math.random() * 100 } = t;
+  let c = null, b = 0;
+  return {
+    subscribe(f) {
+      return c = setInterval(() => {
+        for (const w of o)
+          f({
+            series: w,
+            value: i(w, b),
+            timestamp: Date.now()
+          });
+        b++;
+      }, l), () => {
+        c && clearInterval(c);
+      };
+    },
+    onStatusChange(f) {
+      return f(!0), () => {
+      };
+    }
+  };
+}
+const me = ["#3b82f6", "#ef4444", "#22c55e", "#f59e0b", "#8b5cf6", "#ec4899", "#06b6d4", "#84cc16"], mt = ({
+  data: t,
+  width: o = 400,
+  height: l = 400,
+  innerRadius: i = 0,
+  title: c,
+  showLegend: b = !0,
+  showLabels: f = !0,
+  className: w,
+  style: B
+}) => {
+  const p = o / 2, S = (l - (b ? 30 : 0)) / 2 + (c ? 10 : 0), N = Math.min(p, S) - 40, z = t.reduce((u, h) => u + h.value, 0);
+  let M = -Math.PI / 2;
+  const v = t.map((u, h) => {
+    const m = u.value / (z || 1) * Math.PI * 2, L = M;
+    M += m;
+    const x = M, y = (L + x) / 2, s = p + N * Math.cos(L), T = S + N * Math.sin(L), g = p + N * Math.cos(x), C = S + N * Math.sin(x), d = m > Math.PI ? 1 : 0, $ = u.color || me[h % me.length];
+    let A;
+    if (i > 0) {
+      const Y = p + i * Math.cos(L), q = S + i * Math.sin(L), J = p + i * Math.cos(x), V = S + i * Math.sin(x);
+      A = `M${s},${T} A${N},${N} 0 ${d},1 ${g},${C} L${J},${V} A${i},${i} 0 ${d},0 ${Y},${q} Z`;
+    } else
+      A = `M${p},${S} L${s},${T} A${N},${N} 0 ${d},1 ${g},${C} Z`;
+    const O = p + N * 0.7 * Math.cos(y), X = S + N * 0.7 * Math.sin(y), R = z > 0 ? Math.round(u.value / z * 100) : 0;
+    return { ...u, path: A, labelX: O, labelY: X, pct: R, color: $ };
+  });
+  return /* @__PURE__ */ e("div", { className: `nice-piechart ${w || ""}`, style: B, children: /* @__PURE__ */ _("svg", { width: o, height: l, className: "nice-piechart__svg", children: [
+    c && /* @__PURE__ */ e("text", { x: p, y: 20, textAnchor: "middle", className: "nice-chart__title", children: c }),
+    v.map((u, h) => /* @__PURE__ */ _("g", { children: [
+      /* @__PURE__ */ e("path", { d: u.path, fill: u.color, stroke: "var(--bg-primary, #fff)", strokeWidth: 2, children: /* @__PURE__ */ e("title", { children: `${u.label}: ${u.value} (${u.pct}%)` }) }),
+      f && u.pct >= 5 && /* @__PURE__ */ _(
+        "text",
+        {
+          x: u.labelX,
+          y: u.labelY,
+          textAnchor: "middle",
+          dominantBaseline: "middle",
+          className: "nice-piechart__label",
+          children: [
+            u.pct,
+            "%"
+          ]
+        }
+      )
+    ] }, h)),
+    b && /* @__PURE__ */ e("g", { transform: `translate(10, ${l - 25})`, children: t.map((u, h) => /* @__PURE__ */ _("g", { transform: `translate(${h * 100}, 0)`, children: [
+      /* @__PURE__ */ e("rect", { width: 10, height: 10, rx: 2, fill: u.color || me[h % me.length] }),
+      /* @__PURE__ */ e("text", { x: 14, y: 9, className: "nice-chart__legend-text", children: u.label })
+    ] }, h)) })
+  ] }) });
+}, gt = ({
+  series: t,
+  categories: o,
+  width: l = 400,
+  height: i = 400,
+  maxValue: c,
+  title: b,
+  showLegend: f = !0,
+  className: w,
+  style: B
+}) => {
+  const p = l / 2, S = (i - (f ? 30 : 0)) / 2 + (b ? 10 : 0), N = Math.min(p, S) - 40, z = o.length, M = c ?? Math.max(...t.flatMap((m) => m.data), 1), v = Math.PI * 2 / z, u = 5, h = (m, L) => {
+    const x = m * v - Math.PI / 2, y = L / M * N;
+    return { x: p + y * Math.cos(x), y: S + y * Math.sin(x) };
+  };
+  return /* @__PURE__ */ e("div", { className: `nice-polarchart ${w || ""}`, style: B, children: /* @__PURE__ */ _("svg", { width: l, height: i, className: "nice-polarchart__svg", children: [
+    b && /* @__PURE__ */ e("text", { x: p, y: 20, textAnchor: "middle", className: "nice-chart__title", children: b }),
+    Array.from({ length: u }, (m, L) => {
+      const x = N * ((L + 1) / u);
+      return /* @__PURE__ */ e(
+        "circle",
+        {
+          cx: p,
+          cy: S,
+          r: x,
+          fill: "none",
+          stroke: "var(--border-color, #ddd)",
+          strokeWidth: 0.5
+        },
+        L
+      );
+    }),
+    o.map((m, L) => {
+      const x = h(L, M), y = h(L, M * 1.12);
+      return /* @__PURE__ */ _("g", { children: [
+        /* @__PURE__ */ e(
+          "line",
+          {
+            x1: p,
+            y1: S,
+            x2: x.x,
+            y2: x.y,
+            stroke: "var(--border-color, #ddd)",
+            strokeWidth: 0.5
+          }
+        ),
+        /* @__PURE__ */ e(
+          "text",
+          {
+            x: y.x,
+            y: y.y,
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            className: "nice-chart__axis-label",
+            children: m
+          }
+        )
+      ] }, L);
+    }),
+    t.map((m, L) => {
+      const x = m.color || me[L % me.length], y = m.data.map((s, T) => {
+        const g = h(T, s);
+        return `${g.x},${g.y}`;
+      }).join(" ");
+      return /* @__PURE__ */ _("g", { children: [
+        /* @__PURE__ */ e(
+          "polygon",
+          {
+            points: y,
+            fill: m.fill !== !1 ? x : "none",
+            fillOpacity: 0.15,
+            stroke: x,
+            strokeWidth: 2
+          }
+        ),
+        m.data.map((s, T) => {
+          const g = h(T, s);
+          return /* @__PURE__ */ e("circle", { cx: g.x, cy: g.y, r: 3, fill: x, children: /* @__PURE__ */ e("title", { children: `${m.name} - ${o[T]}: ${s}` }) }, T);
+        })
+      ] }, m.name);
+    }),
+    f && /* @__PURE__ */ e("g", { transform: `translate(10, ${i - 25})`, children: t.map((m, L) => /* @__PURE__ */ _("g", { transform: `translate(${L * 100}, 0)`, children: [
+      /* @__PURE__ */ e("rect", { width: 10, height: 10, rx: 2, fill: m.color || me[L % me.length] }),
+      /* @__PURE__ */ e("text", { x: 14, y: 9, className: "nice-chart__legend-text", children: m.name })
+    ] }, L)) })
+  ] }) });
+}, xt = ({
+  value: t,
+  min: o = 0,
+  max: l = 100,
+  width: i = 200,
+  height: c = 200,
+  startAngle: b = 225,
+  endAngle: f = -45,
+  color: w = "#3b82f6",
+  trackColor: B,
+  label: p,
+  formatValue: S,
+  ranges: N,
+  className: z,
+  style: M
+}) => {
+  const v = i / 2, u = c / 2, h = Math.min(v, u) - 20, m = Math.max(0, Math.min(1, (t - o) / (l - o || 1))), L = (d) => d * Math.PI / 180, x = (b - f + 360) % 360 || 360, y = (d) => ({
+    x: v + h * Math.cos(L(d)),
+    y: u - h * Math.sin(L(d))
+  }), s = (d, $) => {
+    const A = y(d), O = y($), R = (d - $ + 360) % 360 > 180 ? 1 : 0;
+    return `M${A.x},${A.y} A${h},${h} 0 ${R},1 ${O.x},${O.y}`;
+  }, T = b - m * x, g = y(T);
+  let C = w;
+  if (N) {
+    for (const d of N)
+      if (t >= d.start && t <= d.end) {
+        C = d.color;
+        break;
+      }
+  }
+  return /* @__PURE__ */ e("div", { className: `nice-gauge nice-gauge--circular ${z || ""}`, style: M, children: /* @__PURE__ */ _("svg", { width: i, height: c, children: [
+    /* @__PURE__ */ e(
+      "path",
+      {
+        d: s(b, f),
+        fill: "none",
+        stroke: B || "var(--border-color, #e2e8f0)",
+        strokeWidth: 12,
+        strokeLinecap: "round"
+      }
+    ),
+    m > 0 && /* @__PURE__ */ e(
+      "path",
+      {
+        d: s(b, T),
+        fill: "none",
+        stroke: C,
+        strokeWidth: 12,
+        strokeLinecap: "round"
+      }
+    ),
+    /* @__PURE__ */ e(
+      "line",
+      {
+        x1: v,
+        y1: u,
+        x2: g.x,
+        y2: g.y,
+        stroke: "var(--text-primary, #333)",
+        strokeWidth: 2,
+        strokeLinecap: "round"
+      }
+    ),
+    /* @__PURE__ */ e("circle", { cx: v, cy: u, r: 4, fill: "var(--text-primary, #333)" }),
+    /* @__PURE__ */ e("text", { x: v, y: u + h * 0.35, textAnchor: "middle", className: "nice-gauge__value", children: S ? S(t) : t }),
+    p && /* @__PURE__ */ e("text", { x: v, y: u + h * 0.55, textAnchor: "middle", className: "nice-gauge__label", children: p })
+  ] }) });
+}, yt = ({
+  value: t,
+  min: o = 0,
+  max: l = 100,
+  width: i = 300,
+  height: c = 60,
+  orientation: b = "horizontal",
+  color: f = "#3b82f6",
+  label: w,
+  formatValue: B,
+  ranges: p,
+  showTicks: S = !0,
+  tickCount: N = 5,
+  className: z,
+  style: M
+}) => {
+  const v = b === "horizontal", u = v ? i - 40 : c - 40, h = Math.max(0, Math.min(1, (t - o) / (l - o || 1))), m = 10;
+  let L = f;
+  if (p) {
+    for (const y of p)
+      if (t >= y.start && t <= y.end) {
+        L = y.color;
+        break;
+      }
+  }
+  const x = Array.from(
+    { length: N },
+    (y, s) => o + (l - o) * (s / (N - 1))
+  );
+  return v ? /* @__PURE__ */ e("div", { className: `nice-gauge nice-gauge--linear ${z || ""}`, style: M, children: /* @__PURE__ */ _("svg", { width: i, height: c, children: [
+    w && /* @__PURE__ */ e("text", { x: i / 2, y: 14, textAnchor: "middle", className: "nice-gauge__label", children: w }),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: 20,
+        y: c / 2 - m / 2,
+        width: u,
+        height: m,
+        rx: 5,
+        fill: "var(--border-color, #e2e8f0)"
+      }
+    ),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: 20,
+        y: c / 2 - m / 2,
+        width: u * h,
+        height: m,
+        rx: 5,
+        fill: L
+      }
+    ),
+    /* @__PURE__ */ e(
+      "polygon",
+      {
+        points: `${20 + u * h},${c / 2 - m / 2 - 2} ${20 + u * h - 5},${c / 2 - m / 2 - 10} ${20 + u * h + 5},${c / 2 - m / 2 - 10}`,
+        fill: "var(--text-primary, #333)"
+      }
+    ),
+    /* @__PURE__ */ e(
+      "text",
+      {
+        x: 20 + u * h,
+        y: c / 2 - m / 2 - 12,
+        textAnchor: "middle",
+        className: "nice-gauge__value",
+        style: { fontSize: 11 },
+        children: B ? B(t) : t
+      }
+    ),
+    S && x.map((y, s) => {
+      const T = 20 + (y - o) / (l - o) * u;
+      return /* @__PURE__ */ e(
+        "text",
+        {
+          x: T,
+          y: c / 2 + m / 2 + 14,
+          textAnchor: "middle",
+          className: "nice-gauge__tick",
+          children: y
+        },
+        s
+      );
+    })
+  ] }) }) : /* @__PURE__ */ e(
+    "div",
+    {
+      className: `nice-gauge nice-gauge--linear nice-gauge--vertical ${z || ""}`,
+      style: M,
+      children: /* @__PURE__ */ _("svg", { width: i, height: c, children: [
+        /* @__PURE__ */ e(
+          "rect",
+          {
+            x: i / 2 - m / 2,
+            y: 20,
+            width: m,
+            height: u,
+            rx: 5,
+            fill: "var(--border-color, #e2e8f0)"
+          }
+        ),
+        /* @__PURE__ */ e(
+          "rect",
+          {
+            x: i / 2 - m / 2,
+            y: 20 + u * (1 - h),
+            width: m,
+            height: u * h,
+            rx: 5,
+            fill: L
+          }
+        ),
+        /* @__PURE__ */ e("text", { x: i / 2, y: 14, textAnchor: "middle", className: "nice-gauge__value", children: B ? B(t) : t }),
+        w && /* @__PURE__ */ e("text", { x: i / 2, y: c - 4, textAnchor: "middle", className: "nice-gauge__label", children: w })
+      ] })
+    }
+  );
+}, bt = ({
+  items: t,
+  min: o = 0,
+  max: l = 100,
+  width: i = 300,
+  height: c = 300,
+  startAngle: b = 225,
+  endAngle: f = -45,
+  formatValue: w,
+  title: B,
+  className: p,
+  style: S
+}) => {
+  const N = i / 2, z = c / 2, M = Math.min(N, z) - 30, v = Math.min(20, M / (t.length + 1)), u = 4, h = (x) => x * Math.PI / 180, m = (b - f + 360) % 360 || 360, L = (x, y, s) => {
+    const T = N + x * Math.cos(h(y)), g = z - x * Math.sin(h(y)), C = N + x * Math.cos(h(s)), d = z - x * Math.sin(h(s)), $ = (y - s + 360) % 360;
+    return `M${T},${g} A${x},${x} 0 ${$ > 180 ? 1 : 0},1 ${C},${d}`;
+  };
+  return /* @__PURE__ */ e("div", { className: `nice-bargauge ${p || ""}`, style: S, children: /* @__PURE__ */ _("svg", { width: i, height: c, children: [
+    B && /* @__PURE__ */ e("text", { x: N, y: 20, textAnchor: "middle", className: "nice-chart__title", children: B }),
+    t.map((x, y) => {
+      const s = M - y * (v + u), T = Math.max(0, Math.min(1, (x.value - o) / (l - o || 1))), g = b - T * m, C = x.color || me[y % me.length];
+      return /* @__PURE__ */ _("g", { children: [
+        /* @__PURE__ */ e(
+          "path",
+          {
+            d: L(s, b, f),
+            fill: "none",
+            stroke: "var(--border-color, #e2e8f0)",
+            strokeWidth: v,
+            strokeLinecap: "round"
+          }
+        ),
+        T > 0 && /* @__PURE__ */ e(
+          "path",
+          {
+            d: L(s, b, g),
+            fill: "none",
+            stroke: C,
+            strokeWidth: v,
+            strokeLinecap: "round"
+          }
+        )
+      ] }, y);
+    }),
+    /* @__PURE__ */ e("g", { children: t.map((x, y) => /* @__PURE__ */ _(
+      "text",
+      {
+        x: N,
+        y: z - ((t.length - 1) / 2 - y) * 16,
+        textAnchor: "middle",
+        dominantBaseline: "middle",
+        className: "nice-gauge__value",
+        style: { fontSize: 12 },
+        children: [
+          x.label ? `${x.label}: ` : "",
+          w ? w(x.value) : x.value
+        ]
+      },
+      y
+    )) })
+  ] }) });
+}, vt = ({
+  data: t,
+  width: o = 120,
+  height: l = 30,
+  type: i = "line",
+  color: c = "#3b82f6",
+  showMinMax: b,
+  showLastPoint: f = !0,
+  className: w,
+  style: B
+}) => {
+  if (t.length === 0)
+    return null;
+  const p = 2, S = Math.min(...t), N = Math.max(...t), z = N - S || 1, M = o - p * 2, v = l - p * 2, u = (s) => p + s / (t.length - 1 || 1) * M, h = (s) => p + v - (s - S) / z * v;
+  if (i === "bar") {
+    const s = Math.max(1, M / t.length - 1);
+    return /* @__PURE__ */ e(
+      "svg",
+      {
+        width: o,
+        height: l,
+        className: `nice-sparkline ${w || ""}`,
+        style: B,
+        children: t.map((T, g) => /* @__PURE__ */ e(
+          "rect",
+          {
+            x: p + g / t.length * M,
+            y: h(T),
+            width: s,
+            height: v - (h(T) - p),
+            fill: c,
+            rx: 1
+          },
+          g
+        ))
+      }
+    );
+  }
+  const m = t.map((s, T) => `${u(T)},${h(s)}`).join(" "), L = t.indexOf(S), x = t.indexOf(N), y = t.length - 1;
+  return /* @__PURE__ */ _(
+    "svg",
+    {
+      width: o,
+      height: l,
+      className: `nice-sparkline ${w || ""}`,
+      style: B,
+      children: [
+        i === "area" && /* @__PURE__ */ e(
+          "polygon",
+          {
+            points: `${u(0)},${p + v} ${m} ${u(y)},${p + v}`,
+            fill: c,
+            opacity: 0.15
+          }
+        ),
+        /* @__PURE__ */ e("polyline", { points: m, fill: "none", stroke: c, strokeWidth: 1.5 }),
+        b && /* @__PURE__ */ e("circle", { cx: u(L), cy: h(S), r: 2, fill: "#ef4444" }),
+        b && /* @__PURE__ */ e("circle", { cx: u(x), cy: h(N), r: 2, fill: "#22c55e" }),
+        f && /* @__PURE__ */ e("circle", { cx: u(y), cy: h(t[y]), r: 2, fill: c })
+      ]
+    }
+  );
+}, _t = ({
+  value: t,
+  target: o,
+  min: l = 0,
+  max: i = 100,
+  width: c = 200,
+  height: b = 30,
+  color: f = "#3b82f6",
+  targetColor: w = "#ef4444",
+  className: B,
+  style: p
+}) => {
+  const N = c - 8, z = b - 8, M = Math.max(0, Math.min(1, (t - l) / (i - l || 1))), v = o != null ? Math.max(0, Math.min(1, (o - l) / (i - l || 1))) : null;
+  return /* @__PURE__ */ _("svg", { width: c, height: b, className: `nice-bullet ${B || ""}`, style: p, children: [
+    /* @__PURE__ */ e("rect", { x: 4, y: 4, width: N, height: z, rx: 3, fill: "var(--border-color, #e2e8f0)" }),
+    /* @__PURE__ */ e("rect", { x: 4, y: 4 + z * 0.2, width: N * M, height: z * 0.6, rx: 2, fill: f }),
+    v != null && /* @__PURE__ */ e(
+      "line",
+      {
+        x1: 4 + N * v,
+        y1: 6,
+        x2: 4 + N * v,
+        y2: 4 + z - 2,
+        stroke: w,
+        strokeWidth: 2
+      }
+    )
+  ] });
+}, wt = ({
+  data: t,
+  width: o = 400,
+  height: l = 300,
+  inverted: i,
+  showLabels: c = !0,
+  showValues: b = !0,
+  title: f,
+  className: w,
+  style: B
+}) => {
+  const p = { top: f ? 30 : 10, bottom: 10, x: 40 }, S = o - p.x * 2, N = l - p.top - p.bottom, z = i ? [...t].reverse() : t, M = Math.max(...z.map((u) => u.value), 1), v = N / z.length;
+  return /* @__PURE__ */ e("div", { className: `nice-funnel ${w || ""}`, style: B, children: /* @__PURE__ */ _("svg", { width: o, height: l, children: [
+    f && /* @__PURE__ */ e("text", { x: o / 2, y: 20, textAnchor: "middle", className: "nice-chart__title", children: f }),
+    z.map((u, h) => {
+      const m = u.value / M * S, L = h < z.length - 1 ? z[h + 1].value / M * S : m * 0.3, x = p.top + h * v, y = x + v, s = o / 2, T = `${s - m / 2},${x} ${s + m / 2},${x} ${s + L / 2},${y} ${s - L / 2},${y}`, g = u.color || me[h % me.length];
+      return /* @__PURE__ */ _("g", { children: [
+        /* @__PURE__ */ e(
+          "polygon",
+          {
+            points: T,
+            fill: g,
+            stroke: "var(--bg-primary, #fff)",
+            strokeWidth: 1,
+            children: /* @__PURE__ */ e("title", { children: `${u.label}: ${u.value}` })
+          }
+        ),
+        c && /* @__PURE__ */ e(
+          "text",
+          {
+            x: s,
+            y: x + v / 2 - (b ? 4 : 0),
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            className: "nice-funnel__label",
+            children: u.label
+          }
+        ),
+        b && /* @__PURE__ */ e(
+          "text",
+          {
+            x: s,
+            y: x + v / 2 + 10,
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            className: "nice-funnel__value",
+            children: u.value
+          }
+        )
+      ] }, h);
+    })
+  ] }) });
+}, qe = ({
+  nodes: t,
+  links: o,
+  width: l = 600,
+  height: i = 400,
+  nodeWidth: c = 20,
+  nodePadding: b = 10,
+  title: f,
+  className: w,
+  style: B
+}) => {
+  const p = { top: f ? 40 : 20, bottom: 20, left: 20, right: 20 }, S = l - p.left - p.right, N = i - p.top - p.bottom, z = new Set(o.map((d) => d.source)), M = new Set(o.map((d) => d.target)), v = t.filter((d) => z.has(d.id) && !M.has(d.id)), u = t.filter((d) => M.has(d.id)), h = t.filter((d) => z.has(d.id) && M.has(d.id)), m = [v, ...h.length ? [h] : [], u].filter(
+    (d) => d.length > 0
+  ), L = m.length, x = /* @__PURE__ */ new Map();
+  t.forEach((d) => {
+    const $ = o.filter((O) => O.source === d.id).reduce((O, X) => O + X.value, 0), A = o.filter((O) => O.target === d.id).reduce((O, X) => O + X.value, 0);
+    x.set(d.id, Math.max($, A));
+  });
+  const y = m.map(
+    (d) => d.reduce(($, A) => $ + (x.get(A.id) || 0), 0) + (d.length - 1) * b
+  ), s = Math.max(...y, 1), T = /* @__PURE__ */ new Map();
+  m.forEach((d, $) => {
+    const A = p.left + $ / (L - 1 || 1) * (S - c);
+    let O = 0;
+    d.forEach((X) => {
+      const R = (x.get(X.id) || 0) / s * N;
+      T.set(X.id, { x: A, y: p.top + O, h: R }), O += R + b;
+    });
+  });
+  const g = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map();
+  return t.forEach((d) => {
+    g.set(d.id, 0), C.set(d.id, 0);
+  }), /* @__PURE__ */ e("div", { className: `nice-sankey ${w || ""}`, style: B, children: /* @__PURE__ */ _("svg", { width: l, height: i, children: [
+    f && /* @__PURE__ */ e("text", { x: l / 2, y: 20, textAnchor: "middle", className: "nice-chart__title", children: f }),
+    o.map((d, $) => {
+      const A = T.get(d.source), O = T.get(d.target);
+      if (!A || !O)
+        return null;
+      const X = g.get(d.source) || 0, R = C.get(d.target) || 0, Y = d.value / s * N;
+      g.set(d.source, X + Y), C.set(d.target, R + Y);
+      const q = A.x + c, J = A.y + X, V = O.x, Q = O.y + R, r = (q + V) / 2, H = t.find((k) => k.id === d.source)?.color || me[$ % me.length];
+      return /* @__PURE__ */ e(
+        "path",
+        {
+          d: `M${q},${J} C${r},${J} ${r},${Q} ${V},${Q} L${V},${Q + Y} C${r},${Q + Y} ${r},${J + Y} ${q},${J + Y} Z`,
+          fill: H,
+          fillOpacity: 0.3,
+          stroke: H,
+          strokeOpacity: 0.5,
+          strokeWidth: 0.5,
+          children: /* @__PURE__ */ e("title", { children: `${d.source} → ${d.target}: ${d.value}` })
+        },
+        $
+      );
+    }),
+    t.map((d, $) => {
+      const A = T.get(d.id);
+      if (!A)
+        return null;
+      const O = d.color || me[$ % me.length];
+      return /* @__PURE__ */ _("g", { children: [
+        /* @__PURE__ */ e(
+          "rect",
+          {
+            x: A.x,
+            y: A.y,
+            width: c,
+            height: Math.max(A.h, 2),
+            fill: O,
+            rx: 2
+          }
+        ),
+        /* @__PURE__ */ e(
+          "text",
+          {
+            x: A.x < S / 2 ? A.x + c + 4 : A.x - 4,
+            y: A.y + A.h / 2,
+            textAnchor: A.x < S / 2 ? "start" : "end",
+            dominantBaseline: "middle",
+            className: "nice-chart__legend-text",
+            children: d.label
+          }
+        )
+      ] }, d.id);
+    })
+  ] }) });
+}, Nt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NiceSankey: qe
+}, Symbol.toStringTag, { value: "Module" })), Mt = ({
+  data: t,
+  min: o,
+  max: l,
+  start: i,
+  end: c,
+  onChange: b,
+  width: f = 500,
+  height: w = 100,
+  step: B = 1,
+  formatValue: p,
+  chartColor: S = "#3b82f6",
+  className: N,
+  style: z
+}) => {
+  const M = { top: 10, bottom: 30, left: 10, right: 10 }, v = f - M.left - M.right, u = w - M.top - M.bottom, h = (T) => M.left + (T - o) / (l - o || 1) * v, m = (T) => {
+    const g = Math.max(0, Math.min(1, (T - M.left) / v)), C = o + g * (l - o);
+    return Math.round(C / B) * B;
+  }, L = (T, g) => {
+    g.preventDefault();
+    const C = g.target.closest("svg");
+    if (!C)
+      return;
+    const d = (A) => {
+      const O = C.getBoundingClientRect(), X = m(A.clientX - O.left);
+      T === "start" ? b(Math.min(X, c), c) : b(i, Math.max(X, i));
+    }, $ = () => {
+      document.removeEventListener("pointermove", d), document.removeEventListener("pointerup", $);
+    };
+    document.addEventListener("pointermove", d), document.addEventListener("pointerup", $);
+  }, x = t ? Math.min(...t) : 0, s = (t ? Math.max(...t) : 1) - x || 1;
+  return /* @__PURE__ */ e("div", { className: `nice-rangeselector ${N || ""}`, style: z, children: /* @__PURE__ */ _("svg", { width: f, height: w, children: [
+    t && t.length > 1 && /* @__PURE__ */ e(
+      "polygon",
+      {
+        points: `${M.left},${M.top + u} ${t.map((T, g) => `${M.left + g / (t.length - 1) * v},${M.top + u - (T - x) / s * u}`).join(" ")} ${M.left + v},${M.top + u}`,
+        fill: S,
+        opacity: 0.15
+      }
+    ),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: h(i),
+        y: M.top,
+        width: h(c) - h(i),
+        height: u,
+        fill: S,
+        opacity: 0.1
+      }
+    ),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: M.left,
+        y: M.top,
+        width: h(i) - M.left,
+        height: u,
+        fill: "var(--bg-secondary, #f5f5f5)",
+        opacity: 0.6
+      }
+    ),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: h(c),
+        y: M.top,
+        width: M.left + v - h(c),
+        height: u,
+        fill: "var(--bg-secondary, #f5f5f5)",
+        opacity: 0.6
+      }
+    ),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: h(i) - 4,
+        y: M.top,
+        width: 8,
+        height: u,
+        fill: S,
+        rx: 2,
+        cursor: "ew-resize",
+        onPointerDown: (T) => L("start", T)
+      }
+    ),
+    /* @__PURE__ */ e(
+      "rect",
+      {
+        x: h(c) - 4,
+        y: M.top,
+        width: 8,
+        height: u,
+        fill: S,
+        rx: 2,
+        cursor: "ew-resize",
+        onPointerDown: (T) => L("end", T)
+      }
+    ),
+    /* @__PURE__ */ e(
+      "text",
+      {
+        x: h(i),
+        y: M.top + u + 18,
+        textAnchor: "middle",
+        className: "nice-chart__axis-label",
+        children: p ? p(i) : i
+      }
+    ),
+    /* @__PURE__ */ e(
+      "text",
+      {
+        x: h(c),
+        y: M.top + u + 18,
+        textAnchor: "middle",
+        className: "nice-chart__axis-label",
+        children: p ? p(c) : c
+      }
+    )
+  ] }) });
+}, Je = ({
+  regions: t,
+  width: o = 600,
+  height: l = 400,
+  viewBox: i = "0 0 1000 600",
+  colorRange: c = ["#dbeafe", "#1d4ed8"],
+  maxValue: b,
+  onRegionClick: f,
+  selectedRegionId: w,
+  title: B,
+  showTooltip: p = !0,
+  className: S,
+  style: N
+}) => {
+  const z = b ?? Math.max(...t.map((v) => v.value ?? 0), 1), M = (v) => {
+    const u = (d) => [
+      parseInt(d.slice(1, 3), 16),
+      parseInt(d.slice(3, 5), 16),
+      parseInt(d.slice(5, 7), 16)
+    ], [h, m, L] = u(c[0]), [x, y, s] = u(c[1]), T = Math.round(h + (x - h) * v), g = Math.round(m + (y - m) * v), C = Math.round(L + (s - L) * v);
+    return `rgb(${T},${g},${C})`;
+  };
+  return /* @__PURE__ */ _("div", { className: `nice-vectormap ${S || ""}`, style: N, children: [
+    B && /* @__PURE__ */ e("div", { className: "nice-vectormap__title", children: B }),
+    /* @__PURE__ */ e("svg", { width: o, height: l, viewBox: i, children: t.map((v) => {
+      const u = v.value != null ? Math.max(0, Math.min(1, v.value / z)) : 0, h = v.value != null ? M(u) : "var(--bg-tertiary, #e5e7eb)", m = v.id === w;
+      return /* @__PURE__ */ e(
+        "path",
+        {
+          d: v.path,
+          fill: h,
+          stroke: m ? "var(--color-primary, #3b82f6)" : "var(--border-color, #d1d5db)",
+          strokeWidth: m ? 2 : 0.5,
+          cursor: f ? "pointer" : void 0,
+          onClick: () => f?.(v),
+          children: p && /* @__PURE__ */ e("title", { children: `${v.name}${v.value != null ? `: ${v.value}` : ""}` })
+        },
+        v.id
+      );
+    }) })
+  ] });
+}, $t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NiceVectorMap: Je
+}, Symbol.toStringTag, { value: "Module" })), Qe = `
+.nice-forecast-chart {
+  display: flex;
+  flex-direction: column;
+  background: var(--nice-bg-primary, #ffffff);
+  border: 1px solid var(--nice-border-color, #e5e7eb);
+  border-radius: 0.5rem;
+  overflow: hidden;
+}
+
+.nice-forecast-chart__header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0.75rem 1rem;
+  border-bottom: 1px solid var(--nice-border-color, #e5e7eb);
+}
+
+.nice-forecast-chart__title {
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--nice-text-primary);
+  margin: 0;
+}
+
+.nice-forecast-chart__actions {
+  display: flex;
+  gap: 0.5rem;
+}
+
+.nice-forecast-chart__btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2rem;
+  height: 2rem;
+  font-size: 1rem;
+  border-radius: 0.375rem;
+  cursor: pointer;
+  transition: all 0.15s ease;
+  border: 1px solid var(--nice-border-color, #d1d5db);
+  background: var(--nice-bg-primary, #ffffff);
+  color: var(--nice-text-secondary);
+}
+
+.nice-forecast-chart__btn:hover {
+  background: var(--nice-bg-hover, #f3f4f6);
+  color: var(--nice-text-primary);
+}
+
+.nice-forecast-chart__btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.nice-forecast-chart__container {
+  position: relative;
+  width: 100%;
+  padding: 1rem;
+}
+
+.nice-forecast-chart__svg {
+  width: 100%;
+  overflow: visible;
+}
+
+.nice-forecast-chart__grid-line {
+  stroke: var(--nice-border-divider, #f3f4f6);
+  stroke-width: 1;
+}
+
+.nice-forecast-chart__axis-line {
+  stroke: var(--nice-border-color, #e5e7eb);
+  stroke-width: 1;
+}
+
+.nice-forecast-chart__axis-label {
+  font-size: 0.6875rem;
+  fill: var(--nice-text-secondary);
+}
+
+.nice-forecast-chart__axis-title {
+  font-size: 0.75rem;
+  font-weight: 500;
+  fill: var(--nice-text-primary);
+}
+
+.nice-forecast-chart__historical-line {
+  fill: none;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+.nice-forecast-chart__forecast-line {
+  fill: none;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+  stroke-dasharray: 6, 4;
+}
+
+.nice-forecast-chart__confidence-band {
+  opacity: 0.2;
+}
+
+.nice-forecast-chart__forecast-region {
+  fill: var(--nice-bg-secondary, #f9fafb);
+  opacity: 0.5;
+}
+
+.nice-forecast-chart__point {
+  cursor: pointer;
+  transition: r 0.15s ease;
+}
+
+.nice-forecast-chart__point:hover {
+  r: 6;
+}
+
+.nice-forecast-chart__annotation-line {
+  stroke-dasharray: 4, 2;
+  stroke-width: 1;
+}
+
+.nice-forecast-chart__annotation-marker {
+  cursor: pointer;
+  transition: transform 0.15s ease;
+}
+
+.nice-forecast-chart__annotation-marker:hover {
+  transform: scale(1.2);
+}
+
+.nice-forecast-chart__reference-line {
+  stroke-width: 1;
+}
+
+.nice-forecast-chart__reference-label {
+  font-size: 0.625rem;
+  fill: var(--nice-text-secondary);
+}
+
+.nice-forecast-chart__cash-runway {
+  pointer-events: none;
+}
+
+.nice-forecast-chart__cash-runway-line {
+  stroke: #ef4444;
+  stroke-width: 2;
+  stroke-dasharray: 8, 4;
+}
+
+.nice-forecast-chart__cash-runway-label-bg {
+  fill: #ef4444;
+  rx: 4;
+}
+
+.nice-forecast-chart__cash-runway-label {
+  font-size: 0.6875rem;
+  font-weight: 600;
+  fill: #ffffff;
+}
+
+.nice-forecast-chart__cash-runway-date {
+  font-size: 0.625rem;
+  fill: #ef4444;
+  font-weight: 500;
+}
+
+.nice-forecast-chart__tooltip {
+  position: absolute;
+  pointer-events: none;
+  z-index: 100;
+  padding: 0.75rem;
+  background: var(--nice-bg-primary, #ffffff);
+  border: 1px solid var(--nice-border-color, #e5e7eb);
+  border-radius: 0.5rem;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+  font-size: 0.8125rem;
+  max-width: 250px;
+}
+
+.nice-forecast-chart__tooltip-date {
+  font-weight: 600;
+  color: var(--nice-text-primary);
+  margin-bottom: 0.5rem;
+  padding-bottom: 0.5rem;
+  border-bottom: 1px solid var(--nice-border-divider, #f3f4f6);
+}
+
+.nice-forecast-chart__tooltip-item {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin-bottom: 0.25rem;
+}
+
+.nice-forecast-chart__tooltip-color {
+  width: 10px;
+  height: 10px;
+  border-radius: 2px;
+  flex-shrink: 0;
+}
+
+.nice-forecast-chart__tooltip-label {
+  color: var(--nice-text-secondary);
+  flex: 1;
+}
+
+.nice-forecast-chart__tooltip-value {
+  font-weight: 600;
+  color: var(--nice-text-primary);
+  font-variant-numeric: tabular-nums;
+}
+
+.nice-forecast-chart__tooltip-confidence {
+  font-size: 0.75rem;
+  color: var(--nice-text-tertiary);
+}
+
+.nice-forecast-chart__legend {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 1rem;
+  padding: 0.75rem 1rem;
+  border-top: 1px solid var(--nice-border-color, #e5e7eb);
+}
+
+.nice-forecast-chart__legend-item {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  font-size: 0.8125rem;
+  color: var(--nice-text-secondary);
+  cursor: pointer;
+  user-select: none;
+  transition: opacity 0.15s ease;
+}
+
+.nice-forecast-chart__legend-item:hover {
+  color: var(--nice-text-primary);
+}
+
+.nice-forecast-chart__legend-item--hidden {
+  opacity: 0.4;
+}
+
+.nice-forecast-chart__legend-color {
+  width: 16px;
+  height: 3px;
+  border-radius: 1px;
+}
+
+.nice-forecast-chart__legend-color--dashed {
+  background: repeating-linear-gradient(
+    90deg,
+    currentColor,
+    currentColor 4px,
+    transparent 4px,
+    transparent 6px
+  );
+}
+
+.nice-forecast-chart__empty {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 300px;
+  color: var(--nice-text-secondary);
+}
+
+/* Dark mode */
+.dark .nice-forecast-chart {
+  background: var(--nice-bg-primary-dark, #111827);
+  border-color: var(--nice-border-color-dark, #374151);
+}
+
+.dark .nice-forecast-chart__tooltip {
+  background: var(--nice-bg-secondary-dark, #1f2937);
+  border-color: var(--nice-border-color-dark, #374151);
+}
+
+.dark .nice-forecast-chart__forecast-region {
+  fill: var(--nice-bg-secondary-dark, #1f2937);
+}
+`, Te = [
+  "#3b82f6",
+  // blue
+  "#10b981",
+  // green
+  "#f59e0b",
+  // amber
+  "#ef4444",
+  // red
+  "#8b5cf6",
+  // purple
+  "#ec4899",
+  // pink
+  "#06b6d4",
+  // cyan
+  "#f97316"
+  // orange
+];
+function pe(t) {
+  return t instanceof Date ? t : new Date(t);
+}
+function Le(t, o = "pl-PL") {
+  return t.toLocaleDateString(o, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function $e(t, o = "pl-PL") {
+  return new Intl.NumberFormat(o, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 2
+  }).format(t);
+}
+const kt = be(
+  function(o, l) {
+    const {
+      scenarios: i,
+      annotations: c = [],
+      referenceLines: b = [],
+      forecastStartDate: f,
+      cashRunway: w,
+      xAxis: B,
+      yAxis: p,
+      confidenceBands: S = [{ level: 95, color: "#3b82f6", opacity: 0.15 }],
+      tooltip: N,
+      legend: z = { enabled: !0, position: "bottom", interactive: !0 },
+      height: M = 350,
+      showForecastRegion: v = !0,
+      lineWidth: u = 2,
+      showPoints: h = !1,
+      pointRadius: m = 4,
+      enableZoom: L = !1,
+      animationDuration: x = 300,
+      responsive: y = !0,
+      onPointClick: s,
+      onAnnotationClick: T,
+      onScenarioToggle: g,
+      onViewportChange: C,
+      size: d = "medium",
+      disabled: $ = !1,
+      labels: A = {},
+      locale: O = "pl-PL",
+      className: X,
+      style: R
+    } = o, [Y, q] = oe(
+      () => i.map((a, W) => ({
+        ...a,
+        color: a.color ?? Te[W % Te.length],
+        visible: a.visible !== !1
+      }))
+    ), [J, V] = oe(null), [Q, r] = oe({ x: 0, y: 0 }), F = ye(null), H = ye(null), k = { top: 20, right: 30, bottom: 40, left: 60 }, [n, E] = oe({
+      width: 600,
+      height: typeof M == "number" ? M : 350
+    });
+    we(() => {
+      if (!y || !F.current)
+        return;
+      const a = new ResizeObserver((W) => {
+        for (const U of W)
+          E((D) => ({
+            width: U.contentRect.width,
+            height: D.height
+          }));
+      });
+      return a.observe(F.current), () => a.disconnect();
+    }, [y]), we(() => {
+      const a = "nice-forecast-chart-styles";
+      if (!document.getElementById(a)) {
+        const W = document.createElement("style");
+        W.id = a, W.textContent = Qe, document.head.appendChild(W);
+      }
+    }, []);
+    const { xScale: I, yScale: Z, allDates: ae, minY: le, maxY: te } = he(() => {
+      const W = Y.filter((ie) => ie.visible !== !1).flatMap((ie) => ie.data);
+      if (W.length === 0)
+        return { xScale: () => 0, yScale: () => 0, allDates: [], minY: 0, maxY: 100 };
+      const U = W.map((ie) => pe(ie.date).getTime()), D = Math.min(...U), re = Math.max(...U), ue = W.flatMap((ie) => [ie.value, ie.forecast, ie.lowerBound, ie.upperBound]).filter((ie) => ie != null), xe = p?.min ?? Math.min(...ue) * 0.95, fe = p?.max ?? Math.max(...ue) * 1.05, ve = n.width - k.left - k.right, _e = n.height - k.top - k.bottom, Ce = (ie) => {
+        const Ie = typeof ie == "number" ? ie : ie.getTime();
+        return k.left + (Ie - D) / (re - D) * ve;
+      }, Ae = (ie) => k.top + _e - (ie - xe) / (fe - xe) * _e, Oe = [...new Set(U)].sort((ie, Ie) => ie - Ie).map((ie) => new Date(ie));
+      return {
+        xScale: Ce,
+        yScale: Ae,
+        allDates: Oe,
+        minY: xe,
+        maxY: fe
+      };
+    }, [Y, n, k, p]), j = f ? pe(f) : null, G = he(() => {
+      if (!w?.enabled)
+        return null;
+      const a = w.threshold ?? 0, W = w.scenarioId ? Y.find((D) => D.id === w.scenarioId && D.visible !== !1) : Y.find((D) => D.visible !== !1);
+      if (!W)
+        return null;
+      const U = W.data.sort(
+        (D, re) => pe(D.date).getTime() - pe(re.date).getTime()
+      );
+      for (let D = 1; D < U.length; D++) {
+        const re = U[D - 1], ue = U[D], xe = re.forecast ?? re.value, fe = ue.forecast ?? ue.value;
+        if (xe != null && fe != null && xe > a && fe <= a) {
+          const ve = (xe - a) / (xe - fe), _e = pe(re.date).getTime(), Ce = pe(ue.date).getTime(), Ae = _e + ve * (Ce - _e);
+          return new Date(Ae);
+        }
+      }
+      return null;
+    }, [w, Y]), ce = ee(
+      (a, W) => {
+        const U = a.filter((D) => D[W] != null).map((D) => ({ x: I(pe(D.date)), y: Z(D[W]) }));
+        return U.length === 0 ? "" : `M ${U.map((D) => `${D.x},${D.y}`).join(" L ")}`;
+      },
+      [I, Z]
+    ), ge = ee(
+      (a) => {
+        const W = a.filter((re) => re.lowerBound != null && re.upperBound != null);
+        if (W.length === 0)
+          return "";
+        const U = W.map((re) => ({
+          x: I(pe(re.date)),
+          y: Z(re.upperBound)
+        })), D = W.map((re) => ({ x: I(pe(re.date)), y: Z(re.lowerBound) })).reverse();
+        return `M ${U.map((re) => `${re.x},${re.y}`).join(" L ")} L ${D.map((re) => `${re.x},${re.y}`).join(" L ")} Z`;
+      },
+      [I, Z]
+    ), P = ee(
+      (a) => {
+        if (!H.current || N?.enabled === !1)
+          return;
+        const W = H.current.getBoundingClientRect(), U = a.clientX - W.left;
+        a.clientY - W.top;
+        let D = null, re = 1 / 0;
+        for (const ue of ae) {
+          const xe = I(ue), fe = Math.abs(xe - U);
+          fe < re && (re = fe, D = ue);
+        }
+        if (D && re < 50) {
+          const ue = Y.filter((fe) => fe.visible !== !1).map((fe) => {
+            const ve = fe.data.find((_e) => pe(_e.date).getTime() === D.getTime());
+            return {
+              scenario: fe,
+              value: ve?.value,
+              forecast: ve?.forecast,
+              lowerBound: ve?.lowerBound,
+              upperBound: ve?.upperBound
+            };
+          }), xe = c.filter(
+            (fe) => Math.abs(pe(fe.date).getTime() - D.getTime()) < 864e5
+          );
+          V({ date: D, values: ue, annotations: xe }), r({ x: a.clientX - W.left + 10, y: a.clientY - W.top - 10 });
+        } else
+          V(null);
+      },
+      [I, ae, Y, c, N]
+    ), K = ee(
+      (a) => {
+        if (!z.interactive)
+          return;
+        q((U) => U.map((D) => D.id === a ? { ...D, visible: !D.visible } : D));
+        const W = Y.find((U) => U.id === a);
+        W && g?.(a, !W.visible);
+      },
+      [z.interactive, Y, g]
+    );
+    Ne(
+      l,
+      () => ({
+        getScenarios: () => Y,
+        updateScenario: (a, W) => {
+          q((U) => U.map((D) => D.id === a ? { ...D, data: W } : D));
+        },
+        toggleScenario: K,
+        setZoomRange: () => {
+        },
+        // Would need pan/zoom implementation
+        resetZoom: () => {
+        },
+        exportImage: (a) => {
+          if (!H.current)
+            return null;
+          const W = H.current, D = new XMLSerializer().serializeToString(W);
+          return `data:image/svg+xml;base64,${btoa(D)}`;
+        },
+        getDataAtDate: (a) => {
+          const W = Y.filter((U) => U.visible !== !1).map((U) => {
+            const D = U.data.find((re) => pe(re.date).getTime() === a.getTime());
+            return {
+              scenario: U,
+              value: D?.value,
+              forecast: D?.forecast,
+              lowerBound: D?.lowerBound,
+              upperBound: D?.upperBound
+            };
+          });
+          return {
+            date: a,
+            values: W,
+            annotations: c.filter((U) => pe(U.date).getTime() === a.getTime())
+          };
+        }
+      }),
+      [Y, c, K]
+    ), n.width - k.left - k.right;
+    const ne = n.height - k.top - k.bottom, se = he(() => {
+      const a = p?.tickCount ?? 5, W = [], U = (te - le) / (a - 1);
+      for (let D = 0; D < a; D++)
+        W.push(le + U * D);
+      return W;
+    }, [le, te, p?.tickCount]), de = he(() => {
+      const a = B?.tickCount ?? 6;
+      if (ae.length === 0)
+        return [];
+      const W = Math.max(1, Math.floor(ae.length / (a - 1)));
+      return ae.filter((U, D) => D % W === 0 || D === ae.length - 1);
+    }, [ae, B?.tickCount]);
+    return Y.length === 0 || Y.every((a) => a.data.length === 0) ? /* @__PURE__ */ e("div", { className: `nice-forecast-chart ${X ?? ""}`, style: R, children: /* @__PURE__ */ e("div", { className: "nice-forecast-chart__empty", children: A.noData ?? "No data available" }) }) : /* @__PURE__ */ _("div", { className: `nice-forecast-chart ${X ?? ""}`, style: { ...R, height: M }, children: [
+      /* @__PURE__ */ _("div", { ref: F, className: "nice-forecast-chart__container", children: [
+        /* @__PURE__ */ _(
+          "svg",
+          {
+            ref: H,
+            className: "nice-forecast-chart__svg",
+            width: n.width,
+            height: n.height,
+            onMouseMove: P,
+            onMouseLeave: () => V(null),
+            children: [
+              p?.showGrid !== !1 && se.map((a) => /* @__PURE__ */ e(
+                "line",
+                {
+                  className: "nice-forecast-chart__grid-line",
+                  x1: k.left,
+                  x2: n.width - k.right,
+                  y1: Z(a),
+                  y2: Z(a)
+                },
+                a
+              )),
+              v && j && /* @__PURE__ */ e(
+                "rect",
+                {
+                  className: "nice-forecast-chart__forecast-region",
+                  x: I(j),
+                  y: k.top,
+                  width: n.width - k.right - I(j),
+                  height: ne
+                }
+              ),
+              b.map((a) => /* @__PURE__ */ _("g", { children: [
+                /* @__PURE__ */ e(
+                  "line",
+                  {
+                    className: "nice-forecast-chart__reference-line",
+                    x1: k.left,
+                    x2: n.width - k.right,
+                    y1: Z(a.value),
+                    y2: Z(a.value),
+                    stroke: a.color ?? "#9ca3af",
+                    strokeDasharray: a.dashArray ?? "4,2"
+                  }
+                ),
+                a.label && /* @__PURE__ */ e(
+                  "text",
+                  {
+                    className: "nice-forecast-chart__reference-label",
+                    x: n.width - k.right - 4,
+                    y: Z(a.value) - 4,
+                    textAnchor: "end",
+                    children: a.label
+                  }
+                )
+              ] }, a.id)),
+              G && w?.enabled && /* @__PURE__ */ _("g", { className: "nice-forecast-chart__cash-runway", children: [
+                /* @__PURE__ */ e(
+                  "line",
+                  {
+                    className: "nice-forecast-chart__cash-runway-line",
+                    x1: I(G),
+                    x2: I(G),
+                    y1: k.top,
+                    y2: n.height - k.bottom,
+                    stroke: w.color ?? "#ef4444"
+                  }
+                ),
+                w.showLabel !== !1 && /* @__PURE__ */ _(Be, { children: [
+                  /* @__PURE__ */ e(
+                    "rect",
+                    {
+                      className: "nice-forecast-chart__cash-runway-label-bg",
+                      x: I(G) - 60,
+                      y: k.top - 2,
+                      width: 120,
+                      height: w.showDate !== !1 ? 32 : 20,
+                      fill: w.color ?? "#ef4444",
+                      rx: 4
+                    }
+                  ),
+                  /* @__PURE__ */ e(
+                    "text",
+                    {
+                      className: "nice-forecast-chart__cash-runway-label",
+                      x: I(G),
+                      y: k.top + 12,
+                      textAnchor: "middle",
+                      fill: "#ffffff",
+                      children: w.label ?? A.cashRunsOut ?? "💰 Cash runs out"
+                    }
+                  ),
+                  w.showDate !== !1 && /* @__PURE__ */ e(
+                    "text",
+                    {
+                      className: "nice-forecast-chart__cash-runway-label",
+                      x: I(G),
+                      y: k.top + 26,
+                      textAnchor: "middle",
+                      fill: "#ffffff",
+                      style: { fontSize: "0.625rem", opacity: 0.9 },
+                      children: Le(G, O)
+                    }
+                  )
+                ] })
+              ] }),
+              Y.filter((a) => a.visible !== !1 && a.showConfidenceBand).map((a) => /* @__PURE__ */ e(
+                "path",
+                {
+                  className: "nice-forecast-chart__confidence-band",
+                  d: ge(a.data),
+                  fill: a.color
+                },
+                `band-${a.id}`
+              )),
+              Y.filter((a) => a.visible !== !1).map((a) => {
+                const W = j ? a.data.filter((D) => pe(D.date) < j) : a.data.filter((D) => D.value != null), U = j ? a.data.filter((D) => pe(D.date) >= j) : a.data.filter((D) => D.forecast != null);
+                return /* @__PURE__ */ _("g", { children: [
+                  /* @__PURE__ */ e(
+                    "path",
+                    {
+                      className: "nice-forecast-chart__historical-line",
+                      d: ce(W, "value"),
+                      stroke: a.color,
+                      strokeWidth: u
+                    }
+                  ),
+                  /* @__PURE__ */ e(
+                    "path",
+                    {
+                      className: "nice-forecast-chart__forecast-line",
+                      d: ce(U, j ? "value" : "forecast"),
+                      stroke: a.color,
+                      strokeWidth: u
+                    }
+                  ),
+                  U.length > 0 && a.data.some((D) => D.forecast != null) && /* @__PURE__ */ e(
+                    "path",
+                    {
+                      className: "nice-forecast-chart__forecast-line",
+                      d: ce(a.data, "forecast"),
+                      stroke: a.color,
+                      strokeWidth: u
+                    }
+                  ),
+                  h && a.data.map((D, re) => {
+                    const ue = D.value ?? D.forecast;
+                    return ue == null ? null : /* @__PURE__ */ e(
+                      "circle",
+                      {
+                        className: "nice-forecast-chart__point",
+                        cx: I(pe(D.date)),
+                        cy: Z(ue),
+                        r: m,
+                        fill: a.color,
+                        onClick: () => s?.(D, a)
+                      },
+                      re
+                    );
+                  })
+                ] }, a.id);
+              }),
+              c.map((a) => {
+                const W = I(pe(a.date));
+                return /* @__PURE__ */ _(
+                  "g",
+                  {
+                    className: "nice-forecast-chart__annotation-marker",
+                    onClick: () => T?.(a),
+                    children: [
+                      a.showLine !== !1 && /* @__PURE__ */ e(
+                        "line",
+                        {
+                          className: "nice-forecast-chart__annotation-line",
+                          x1: W,
+                          x2: W,
+                          y1: k.top,
+                          y2: n.height - k.bottom,
+                          stroke: a.color ?? "#9ca3af"
+                        }
+                      ),
+                      /* @__PURE__ */ e("circle", { cx: W, cy: k.top + 10, r: 8, fill: a.color ?? "#9ca3af" }),
+                      /* @__PURE__ */ e("text", { x: W, y: k.top + 14, textAnchor: "middle", fill: "white", fontSize: "10", children: a.icon ?? "!" })
+                    ]
+                  },
+                  a.id
+                );
+              }),
+              /* @__PURE__ */ e(
+                "line",
+                {
+                  className: "nice-forecast-chart__axis-line",
+                  x1: k.left,
+                  x2: k.left,
+                  y1: k.top,
+                  y2: n.height - k.bottom
+                }
+              ),
+              /* @__PURE__ */ e(
+                "line",
+                {
+                  className: "nice-forecast-chart__axis-line",
+                  x1: k.left,
+                  x2: n.width - k.right,
+                  y1: n.height - k.bottom,
+                  y2: n.height - k.bottom
+                }
+              ),
+              se.map((a) => /* @__PURE__ */ e(
+                "text",
+                {
+                  className: "nice-forecast-chart__axis-label",
+                  x: k.left - 8,
+                  y: Z(a) + 4,
+                  textAnchor: "end",
+                  children: p?.format ? p.format(a) : $e(a, O)
+                },
+                a
+              )),
+              de.map((a) => /* @__PURE__ */ e(
+                "text",
+                {
+                  className: "nice-forecast-chart__axis-label",
+                  x: I(a),
+                  y: n.height - k.bottom + 16,
+                  textAnchor: "middle",
+                  children: B?.format ? B.format(a) : Le(a, O)
+                },
+                a.getTime()
+              )),
+              p?.title && /* @__PURE__ */ e(
+                "text",
+                {
+                  className: "nice-forecast-chart__axis-title",
+                  x: 15,
+                  y: n.height / 2,
+                  textAnchor: "middle",
+                  transform: `rotate(-90, 15, ${n.height / 2})`,
+                  children: p.title
+                }
+              )
+            ]
+          }
+        ),
+        J && /* @__PURE__ */ _(
+          "div",
+          {
+            className: "nice-forecast-chart__tooltip",
+            style: { left: Q.x, top: Q.y },
+            children: [
+              /* @__PURE__ */ e("div", { className: "nice-forecast-chart__tooltip-date", children: Le(J.date, O) }),
+              J.values.map((a) => {
+                const W = a.value ?? a.forecast;
+                return W == null ? null : /* @__PURE__ */ _("div", { className: "nice-forecast-chart__tooltip-item", children: [
+                  /* @__PURE__ */ e(
+                    "span",
+                    {
+                      className: "nice-forecast-chart__tooltip-color",
+                      style: { background: a.scenario.color }
+                    }
+                  ),
+                  /* @__PURE__ */ e("span", { className: "nice-forecast-chart__tooltip-label", children: a.scenario.name }),
+                  /* @__PURE__ */ e("span", { className: "nice-forecast-chart__tooltip-value", children: $e(W, O) })
+                ] }, a.scenario.id);
+              }),
+              J.values.some((a) => a.lowerBound != null) && /* @__PURE__ */ _("div", { className: "nice-forecast-chart__tooltip-confidence", children: [
+                A.confidence ?? "CI",
+                ":",
+                " ",
+                $e(J.values[0]?.lowerBound ?? 0, O),
+                " –",
+                " ",
+                $e(J.values[0]?.upperBound ?? 0, O)
+              ] })
+            ]
+          }
+        )
+      ] }),
+      z.enabled && /* @__PURE__ */ e("div", { className: "nice-forecast-chart__legend", children: Y.map((a) => /* @__PURE__ */ _(
+        "div",
+        {
+          className: `nice-forecast-chart__legend-item ${a.visible === !1 ? "nice-forecast-chart__legend-item--hidden" : ""}`,
+          onClick: () => K(a.id),
+          children: [
+            /* @__PURE__ */ e(
+              "span",
+              {
+                className: `nice-forecast-chart__legend-color ${a.isBase ? "" : "nice-forecast-chart__legend-color--dashed"}`,
+                style: { background: a.color }
+              }
+            ),
+            a.name
+          ]
+        },
+        a.id
+      )) })
+    ] });
+  }
+), Pe = [
+  "#3b82f6",
+  "#ef4444",
+  "#22c55e",
+  "#f59e0b",
+  "#8b5cf6",
+  "#ec4899",
+  "#06b6d4",
+  "#84cc16",
+  "#f97316",
+  "#6366f1"
+], Ke = be(
+  (t, o) => {
+    const {
+      levels: l,
+      initialLevelId: i,
+      chartType: c = "bar",
+      width: b = 600,
+      height: f = 400,
+      showBreadcrumbs: w = !0,
+      showBackButton: B = !0,
+      animationDuration: p = 300,
+      onLevelChange: S,
+      onItemClick: N,
+      colors: z = Pe,
+      showValues: M = !0,
+      showLegend: v = !0,
+      className: u,
+      style: h,
+      ...m
+    } = t, [L, x] = oe(i || l[0]?.id), [y, s] = oe([i || l[0]?.id]), [T, g] = oe(!1), [C, d] = oe("in"), $ = he(
+      () => l.find((r) => r.id === L),
+      [l, L]
+    ), A = ee(
+      (r) => {
+        l.find((H) => H.id === r) && (d("in"), g(!0), setTimeout(() => {
+          x(r), s((H) => [...H, r]), S?.(r, [...y, r]), g(!1);
+        }, p / 2));
+      },
+      [l, y, p, S]
+    ), O = ee(() => {
+      if (y.length <= 1)
+        return;
+      d("out"), g(!0);
+      const r = y.slice(0, -1), F = r[r.length - 1];
+      setTimeout(() => {
+        x(F), s(r), S?.(F, r), g(!1);
+      }, p / 2);
+    }, [y, p, S]), X = ee(() => {
+      const r = l[0]?.id;
+      r && (d("out"), g(!0), setTimeout(() => {
+        x(r), s([r]), S?.(r, [r]), g(!1);
+      }, p / 2));
+    }, [l, p, S]);
+    Ne(
+      o,
+      () => ({
+        drillDown: A,
+        drillUp: O,
+        resetToRoot: X,
+        getCurrentLevel: () => L,
+        getPath: () => y
+      }),
+      [A, O, X, L, y]
+    );
+    const R = ee(
+      (r, F) => {
+        N?.(r, L);
+        const H = l.find(
+          (k) => k.parentId === L && k.id === r.metadata?.childLevelId
+        );
+        H && A(H.id);
+      },
+      [L, l, A, N]
+    ), Y = he(
+      () => $?.data.reduce((r, F) => r + F.value, 0) || 0,
+      [$]
+    ), q = he(
+      () => y.map((r) => l.find((F) => F.id === r)?.label || r),
+      [y, l]
+    ), J = () => {
+      if (!$)
+        return null;
+      const r = $.data, F = Math.max(...r.map((k) => k.value)), H = Math.min(40, (f - 100) / r.length - 8);
+      return /* @__PURE__ */ e("div", { className: "nice-drilldown-bars", children: r.map((k, n) => {
+        const E = k.value / F * 100;
+        return /* @__PURE__ */ _(
+          "div",
+          {
+            className: "nice-drilldown-bar-row",
+            onClick: () => R(k, n),
+            children: [
+              /* @__PURE__ */ e("span", { className: "nice-drilldown-bar-label", children: k.label || `Item ${n + 1}` }),
+              /* @__PURE__ */ e("div", { className: "nice-drilldown-bar-track", children: /* @__PURE__ */ e(
+                "div",
+                {
+                  className: "nice-drilldown-bar-fill",
+                  style: {
+                    width: `${E}%`,
+                    backgroundColor: k.color || z[n % z.length],
+                    height: H
+                  }
+                }
+              ) }),
+              M && /* @__PURE__ */ e("span", { className: "nice-drilldown-bar-value", children: k.value.toLocaleString() })
+            ]
+          },
+          n
+        );
+      }) });
+    }, V = () => {
+      if (!$)
+        return null;
+      const r = $.data, F = b / 2, H = (f - 60) / 2 + 30, k = Math.min(F, H) - 40;
+      let n = -90;
+      const E = r.map((I, Z) => {
+        const ae = I.value / Y * 360, le = n + ae, te = ae > 180 ? 1 : 0, j = n * Math.PI / 180, G = le * Math.PI / 180, ce = F + k * Math.cos(j), ge = H + k * Math.sin(j), P = F + k * Math.cos(G), K = H + k * Math.sin(G), ne = (n + ae / 2) * Math.PI / 180, se = F + k * 0.7 * Math.cos(ne), de = H + k * 0.7 * Math.sin(ne), a = `M ${F} ${H} L ${ce} ${ge} A ${k} ${k} 0 ${te} 1 ${P} ${K} Z`;
+        return n = le, {
+          path: a,
+          color: I.color || z[Z % z.length],
+          label: I.label || `Item ${Z + 1}`,
+          value: I.value,
+          percentage: (I.value / Y * 100).toFixed(1),
+          labelX: se,
+          labelY: de,
+          item: I,
+          index: Z
+        };
+      });
+      return /* @__PURE__ */ e("svg", { width: b, height: f - 40, className: "nice-drilldown-pie", children: /* @__PURE__ */ e("g", { children: E.map((I, Z) => /* @__PURE__ */ _("g", { onClick: () => R(I.item, I.index), children: [
+        /* @__PURE__ */ e(
+          "path",
+          {
+            d: I.path,
+            fill: I.color,
+            stroke: "white",
+            strokeWidth: 2,
+            className: "nice-drilldown-pie-slice"
+          }
+        ),
+        M && parseFloat(I.percentage) > 5 && /* @__PURE__ */ _(
+          "text",
+          {
+            x: I.labelX,
+            y: I.labelY,
+            textAnchor: "middle",
+            dominantBaseline: "middle",
+            fill: "white",
+            fontSize: "12",
+            fontWeight: "600",
+            children: [
+              I.percentage,
+              "%"
+            ]
+          }
+        )
+      ] }, Z)) }) });
+    }, Q = () => {
+      if (!$)
+        return null;
+      const r = $.data, F = Math.max(...r.map((n) => n.value)), H = Math.min(60, (b - 100) / r.length - 8), k = f - 100;
+      return /* @__PURE__ */ e("svg", { width: b, height: f - 40, className: "nice-drilldown-columns", children: /* @__PURE__ */ _("g", { transform: "translate(50, 20)", children: [
+        [0, 0.25, 0.5, 0.75, 1].map((n, E) => /* @__PURE__ */ _("g", { children: [
+          /* @__PURE__ */ e(
+            "line",
+            {
+              x1: 0,
+              y1: k * (1 - n),
+              x2: b - 80,
+              y2: k * (1 - n),
+              stroke: "#e5e7eb",
+              strokeDasharray: n === 0 ? void 0 : "4"
+            }
+          ),
+          /* @__PURE__ */ e(
+            "text",
+            {
+              x: -8,
+              y: k * (1 - n),
+              textAnchor: "end",
+              dominantBaseline: "middle",
+              fontSize: "11",
+              fill: "#6b7280",
+              children: Math.round(F * n).toLocaleString()
+            }
+          )
+        ] }, E)),
+        r.map((n, E) => {
+          const I = n.value / F * k, Z = E * ((b - 100) / r.length) + ((b - 100) / r.length - H) / 2;
+          return /* @__PURE__ */ _("g", { onClick: () => R(n, E), children: [
+            /* @__PURE__ */ e(
+              "rect",
+              {
+                x: Z,
+                y: k - I,
+                width: H,
+                height: I,
+                fill: n.color || z[E % z.length],
+                rx: 4,
+                className: "nice-drilldown-column-bar"
+              }
+            ),
+            /* @__PURE__ */ e(
+              "text",
+              {
+                x: Z + H / 2,
+                y: k + 16,
+                textAnchor: "middle",
+                fontSize: "11",
+                fill: "#374151",
+                children: (n.label || `${E + 1}`).slice(0, 10)
+              }
+            ),
+            M && /* @__PURE__ */ e(
+              "text",
+              {
+                x: Z + H / 2,
+                y: k - I - 8,
+                textAnchor: "middle",
+                fontSize: "11",
+                fill: "#374151",
+                fontWeight: "500",
+                children: n.value.toLocaleString()
+              }
+            )
+          ] }, E);
+        })
+      ] }) });
+    };
+    return /* @__PURE__ */ _(
+      "div",
+      {
+        className: `nice-drilldown-chart ${T ? `animating ${C}` : ""} ${u || ""}`,
+        style: { width: b, ...h },
+        ...m,
+        children: [
+          /* @__PURE__ */ _("div", { className: "nice-drilldown-header", children: [
+            B && y.length > 1 && /* @__PURE__ */ e("button", { className: "nice-drilldown-back", onClick: O, children: "← Wstecz" }),
+            w && /* @__PURE__ */ e("div", { className: "nice-drilldown-breadcrumbs", children: q.map((r, F) => /* @__PURE__ */ _(Re.Fragment, { children: [
+              F > 0 && /* @__PURE__ */ e("span", { className: "nice-drilldown-separator", children: "/" }),
+              /* @__PURE__ */ e(
+                "span",
+                {
+                  className: `nice-drilldown-crumb ${F === q.length - 1 ? "active" : ""}`,
+                  onClick: () => {
+                    if (F < q.length - 1) {
+                      const H = y.slice(0, F + 1);
+                      s(H), x(H[H.length - 1]);
+                    }
+                  },
+                  children: r
+                }
+              )
+            ] }, F)) })
+          ] }),
+          /* @__PURE__ */ _("div", { className: "nice-drilldown-content", style: { height: f - 40 }, children: [
+            c === "bar" && J(),
+            c === "pie" && V(),
+            c === "column" && Q()
+          ] }),
+          v && $ && /* @__PURE__ */ e("div", { className: "nice-drilldown-legend", children: $.data.map((r, F) => /* @__PURE__ */ _("div", { className: "nice-drilldown-legend-item", children: [
+            /* @__PURE__ */ e(
+              "span",
+              {
+                className: "nice-drilldown-legend-color",
+                style: { backgroundColor: r.color || z[F % z.length] }
+              }
+            ),
+            /* @__PURE__ */ e("span", { className: "nice-drilldown-legend-label", children: r.label || `Item ${F + 1}` })
+          ] }, F)) }),
+          /* @__PURE__ */ e("style", { children: `
+        .nice-drilldown-chart {
+          font-family: system-ui, -apple-system, sans-serif;
+          background: white;
+          border-radius: 8px;
+          overflow: hidden;
+        }
+
+        .nice-drilldown-header {
+          display: flex;
+          align-items: center;
+          gap: 12px;
+          padding: 12px 16px;
+          border-bottom: 1px solid #e5e7eb;
+          min-height: 40px;
+        }
+
+        .nice-drilldown-back {
+          background: #f3f4f6;
+          border: none;
+          padding: 6px 12px;
+          border-radius: 6px;
+          cursor: pointer;
+          font-size: 13px;
+          color: #374151;
+          transition: background 0.2s;
+        }
+
+        .nice-drilldown-back:hover {
+          background: #e5e7eb;
+        }
+
+        .nice-drilldown-breadcrumbs {
+          display: flex;
+          align-items: center;
+          gap: 4px;
+          font-size: 13px;
+        }
+
+        .nice-drilldown-separator {
+          color: #9ca3af;
+        }
+
+        .nice-drilldown-crumb {
+          color: #6b7280;
+          cursor: pointer;
+        }
+
+        .nice-drilldown-crumb:hover:not(.active) {
+          color: #3b82f6;
+        }
+
+        .nice-drilldown-crumb.active {
+          color: #111827;
+          font-weight: 500;
+          cursor: default;
+        }
+
+        .nice-drilldown-content {
+          padding: 16px;
+          transition: opacity 0.15s, transform 0.15s;
+        }
+
+        .nice-drilldown-chart.animating .nice-drilldown-content {
+          opacity: 0;
+        }
+
+        .nice-drilldown-chart.animating.in .nice-drilldown-content {
+          transform: translateX(20px);
+        }
+
+        .nice-drilldown-chart.animating.out .nice-drilldown-content {
+          transform: translateX(-20px);
+        }
+
+        .nice-drilldown-bars {
+          display: flex;
+          flex-direction: column;
+          gap: 8px;
+        }
+
+        .nice-drilldown-bar-row {
+          display: flex;
+          align-items: center;
+          gap: 12px;
+          cursor: pointer;
+          padding: 4px 8px;
+          margin: -4px -8px;
+          border-radius: 6px;
+          transition: background 0.2s;
+        }
+
+        .nice-drilldown-bar-row:hover {
+          background: #f9fafb;
+        }
+
+        .nice-drilldown-bar-label {
+          width: 120px;
+          font-size: 13px;
+          color: #374151;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+        }
+
+        .nice-drilldown-bar-track {
+          flex: 1;
+          background: #f3f4f6;
+          border-radius: 6px;
+          overflow: hidden;
+        }
+
+        .nice-drilldown-bar-fill {
+          transition: width 0.3s ease;
+          border-radius: 6px;
+        }
+
+        .nice-drilldown-bar-value {
+          width: 80px;
+          text-align: right;
+          font-size: 13px;
+          font-weight: 500;
+          color: #111827;
+        }
+
+        .nice-drilldown-pie-slice {
+          cursor: pointer;
+          transition: transform 0.2s, opacity 0.2s;
+          transform-origin: center;
+        }
+
+        .nice-drilldown-pie-slice:hover {
+          opacity: 0.85;
+          transform: scale(1.02);
+        }
+
+        .nice-drilldown-column-bar {
+          cursor: pointer;
+          transition: opacity 0.2s;
+        }
+
+        .nice-drilldown-column-bar:hover {
+          opacity: 0.8;
+        }
+
+        .nice-drilldown-legend {
+          display: flex;
+          flex-wrap: wrap;
+          gap: 16px;
+          padding: 12px 16px;
+          border-top: 1px solid #e5e7eb;
+        }
+
+        .nice-drilldown-legend-item {
+          display: flex;
+          align-items: center;
+          gap: 6px;
+        }
+
+        .nice-drilldown-legend-color {
+          width: 12px;
+          height: 12px;
+          border-radius: 3px;
+        }
+
+        .nice-drilldown-legend-label {
+          font-size: 12px;
+          color: #6b7280;
+        }
+      ` })
+        ]
+      }
+    );
+  }
+);
+Ke.displayName = "NiceDrillDownChart";
+const St = ({
+  type: t = "choropleth",
+  regions: o = [],
+  bubbles: l = [],
+  width: i = 800,
+  height: c = 500,
+  viewBox: b = "0 0 800 500",
+  colorScale: f = ["#dbeafe", "#93c5fd", "#3b82f6", "#1d4ed8", "#1e3a8a"],
+  minValue: w,
+  maxValue: B,
+  showTooltip: p = !0,
+  showLegend: S = !0,
+  onRegionClick: N,
+  onBubbleClick: z,
+  onRegionHover: M,
+  title: v,
+  mapSvg: u,
+  zoomable: h = !1,
+  className: m,
+  style: L,
+  ...x
+}) => {
+  const [y, s] = oe(null), [T, g] = oe(1), [C, d] = oe({ x: 0, y: 0 }), $ = ye(null), A = ye(!1), O = ye({ x: 0, y: 0 }), X = w ?? Math.min(...o.map((n) => n.value), ...l.map((n) => n.value)), R = B ?? Math.max(...o.map((n) => n.value), ...l.map((n) => n.value)), Y = ee(
+    (n) => {
+      const E = (n - X) / (R - X), I = Math.min(Math.floor(E * f.length), f.length - 1);
+      return f[Math.max(0, I)];
+    },
+    [X, R, f]
+  ), q = ee(
+    (n) => {
+      if (!p || !y)
+        return;
+      const E = $.current?.getBoundingClientRect();
+      E && s(
+        (I) => I ? { ...I, x: n.clientX - E.left, y: n.clientY - E.top } : null
+      );
+    },
+    [p, y]
+  ), J = ee(
+    (n, E) => {
+      const I = $.current?.getBoundingClientRect();
+      I && p && s({
+        x: E.clientX - I.left,
+        y: E.clientY - I.top,
+        content: `${n.name}: ${n.value.toLocaleString()}`
+      }), M?.(n);
+    },
+    [p, M]
+  ), V = ee(() => {
+    s(null), M?.(null);
+  }, [M]), Q = ee(
+    (n) => {
+      if (!h)
+        return;
+      n.preventDefault();
+      const E = n.deltaY > 0 ? 0.9 : 1.1;
+      g((I) => Math.min(Math.max(I * E, 0.5), 4));
+    },
+    [h]
+  ), r = ee(
+    (n) => {
+      h && (A.current = !0, O.current = { x: n.clientX - C.x, y: n.clientY - C.y });
+    },
+    [h, C]
+  ), F = ee(() => {
+    A.current = !1;
+  }, []), H = ee((n) => {
+    A.current && d({
+      x: n.clientX - O.current.x,
+      y: n.clientY - O.current.y
+    });
+  }, []), k = he(() => o.length > 0 ? o : [
+    {
+      id: "mazowieckie",
+      name: "Mazowieckie",
+      value: 100,
+      path: "M400,200 L450,200 L460,250 L420,280 L380,250 Z"
+    },
+    { id: "slaskie", name: "Śląskie", value: 80, path: "M350,280 L400,280 L390,330 L340,320 Z" },
+    {
+      id: "wielkopolskie",
+      name: "Wielkopolskie",
+      value: 70,
+      path: "M300,200 L350,200 L360,260 L310,270 L280,230 Z"
+    }
+  ], [o]);
+  return /* @__PURE__ */ _("div", { className: `nice-map-chart ${m || ""}`, style: { width: i, ...L }, ...x, children: [
+    v && /* @__PURE__ */ e("div", { className: "nice-map-title", children: v }),
+    /* @__PURE__ */ e(
+      "svg",
+      {
+        ref: $,
+        width: i,
+        height: c,
+        viewBox: b,
+        className: "nice-map-svg",
+        onWheel: Q,
+        onMouseDown: r,
+        onMouseUp: F,
+        onMouseLeave: F,
+        onMouseMove: (n) => {
+          q(n), H(n);
+        },
+        children: /* @__PURE__ */ _("g", { transform: `translate(${C.x}, ${C.y}) scale(${T})`, children: [
+          u && /* @__PURE__ */ e("g", { dangerouslySetInnerHTML: { __html: u } }),
+          t === "choropleth" && k.map((n) => /* @__PURE__ */ e(
+            "path",
+            {
+              d: n.path,
+              fill: n.color || Y(n.value),
+              stroke: "#fff",
+              strokeWidth: 1,
+              className: "nice-map-region",
+              onClick: () => N?.(n),
+              onMouseEnter: (E) => J(n, E),
+              onMouseLeave: V
+            },
+            n.id
+          )),
+          (t === "bubble" || l.length > 0) && l.map((n) => {
+            const E = Math.sqrt((n.value - X) / (R - X)) * 30 + 5;
+            return /* @__PURE__ */ e(
+              "circle",
+              {
+                cx: n.lng,
+                cy: n.lat,
+                r: E,
+                fill: n.color || "#3b82f6",
+                fillOpacity: 0.7,
+                stroke: "#fff",
+                strokeWidth: 1,
+                className: "nice-map-bubble",
+                onClick: () => z?.(n),
+                onMouseEnter: (I) => {
+                  const Z = $.current?.getBoundingClientRect();
+                  Z && p && s({
+                    x: I.clientX - Z.left,
+                    y: I.clientY - Z.top,
+                    content: `${n.label || n.id}: ${n.value.toLocaleString()}`
+                  });
+                },
+                onMouseLeave: V,
+                children: n.label && /* @__PURE__ */ _("title", { children: [
+                  n.label,
+                  ": ",
+                  n.value
+                ] })
+              },
+              n.id
+            );
+          })
+        ] })
+      }
+    ),
+    y && /* @__PURE__ */ e("div", { className: "nice-map-tooltip", style: { left: y.x + 10, top: y.y - 30 }, children: y.content }),
+    S && /* @__PURE__ */ _("div", { className: "nice-map-legend", children: [
+      /* @__PURE__ */ e("span", { className: "nice-map-legend-title", children: "Wartość" }),
+      /* @__PURE__ */ e("div", { className: "nice-map-legend-scale", children: f.map((n, E) => /* @__PURE__ */ e("div", { className: "nice-map-legend-item", style: { backgroundColor: n } }, E)) }),
+      /* @__PURE__ */ _("div", { className: "nice-map-legend-labels", children: [
+        /* @__PURE__ */ e("span", { children: X.toLocaleString() }),
+        /* @__PURE__ */ e("span", { children: R.toLocaleString() })
+      ] })
+    ] }),
+    /* @__PURE__ */ e("style", { children: `
+        .nice-map-chart {
+          font-family: system-ui, -apple-system, sans-serif;
+          background: white;
+          border-radius: 8px;
+          overflow: hidden;
+          position: relative;
+        }
+
+        .nice-map-title {
+          padding: 12px 16px;
+          font-size: 16px;
+          font-weight: 600;
+          color: #111827;
+          border-bottom: 1px solid #e5e7eb;
+        }
+
+        .nice-map-svg {
+          display: block;
+          cursor: grab;
+        }
+
+        .nice-map-svg:active {
+          cursor: grabbing;
+        }
+
+        .nice-map-region {
+          cursor: pointer;
+          transition: opacity 0.2s, stroke-width 0.2s;
+        }
+
+        .nice-map-region:hover {
+          opacity: 0.8;
+          stroke-width: 2;
+        }
+
+        .nice-map-bubble {
+          cursor: pointer;
+          transition: transform 0.2s, opacity 0.2s;
+        }
+
+        .nice-map-bubble:hover {
+          opacity: 1;
+          transform: scale(1.1);
+        }
+
+        .nice-map-tooltip {
+          position: absolute;
+          background: #1f2937;
+          color: white;
+          padding: 6px 10px;
+          border-radius: 4px;
+          font-size: 12px;
+          pointer-events: none;
+          z-index: 10;
+          white-space: nowrap;
+        }
+
+        .nice-map-legend {
+          position: absolute;
+          right: 16px;
+          bottom: 16px;
+          background: white;
+          padding: 12px;
+          border-radius: 6px;
+          box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+
+        .nice-map-legend-title {
+          display: block;
+          font-size: 11px;
+          color: #6b7280;
+          margin-bottom: 6px;
+        }
+
+        .nice-map-legend-scale {
+          display: flex;
+          height: 12px;
+          border-radius: 2px;
+          overflow: hidden;
+        }
+
+        .nice-map-legend-item {
+          flex: 1;
+          min-width: 24px;
+        }
+
+        .nice-map-legend-labels {
+          display: flex;
+          justify-content: space-between;
+          font-size: 10px;
+          color: #6b7280;
+          margin-top: 4px;
+        }
+      ` })
+  ] });
+}, Ct = ({
+  nodes: t,
+  links: o,
+  width: l = 800,
+  height: i = 500,
+  nodeWidth: c = 20,
+  nodePadding: b = 10,
+  showValues: f = !0,
+  showTooltip: w = !0,
+  onNodeClick: B,
+  onLinkClick: p,
+  title: S,
+  className: N,
+  style: z,
+  ...M
+}) => {
+  const [v, u] = oe(null), h = ye(null), m = he(() => {
+    const x = /* @__PURE__ */ new Map();
+    t.forEach((r) => x.set(r.id, r));
+    const y = new Set(o.map((r) => r.target)), s = new Set(o.map((r) => r.source)), T = [], g = /* @__PURE__ */ new Map(), C = t.filter((r) => s.has(r.id) && !y.has(r.id));
+    C.length > 0 && (T.push(C.map((r) => r.id)), C.forEach((r) => g.set(r.id, 0)));
+    const d = t.filter((r) => s.has(r.id) && y.has(r.id));
+    d.length > 0 && (T.push(d.map((r) => r.id)), d.forEach((r) => g.set(r.id, 1)));
+    const $ = t.filter((r) => !s.has(r.id) && y.has(r.id));
+    $.length > 0 && (T.push($.map((r) => r.id)), $.forEach((r) => g.set(r.id, 2))), T.length === 0 && (T.push(t.map((r) => r.id)), t.forEach((r) => g.set(r.id, 0)));
+    const A = /* @__PURE__ */ new Map();
+    o.forEach((r) => {
+      A.set(r.source, (A.get(r.source) || 0) + r.value), A.set(r.target, (A.get(r.target) || 0) + r.value);
+    });
+    const O = 40, X = l - O * 2, R = i - O * 2, Y = T.length > 1 ? X / (T.length - 1) : X, q = /* @__PURE__ */ new Map();
+    Math.max(...Array.from(A.values())), T.forEach((r, F) => {
+      const H = r.reduce((E, I) => E + (A.get(I) || 0), 0), k = (R - (r.length - 1) * b) / H;
+      let n = O;
+      r.forEach((E) => {
+        const Z = (A.get(E) || 0) * k, ae = O + F * Y;
+        q.set(E, { x: ae, y: n, height: Z }), n += Z + b;
+      });
+    });
+    const J = [], V = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map();
+    return o.forEach((r) => {
+      const F = q.get(r.source), H = q.get(r.target);
+      if (!F || !H)
+        return;
+      const k = A.get(r.source) || 1;
+      A.get(r.target);
+      const n = r.value / k * F.height, E = F.y + (V.get(r.source) || 0), I = H.y + (Q.get(r.target) || 0);
+      V.set(r.source, (V.get(r.source) || 0) + n), Q.set(r.target, (Q.get(r.target) || 0) + n);
+      const Z = F.x + c, ae = H.x, le = (ae - Z) * 0.5, te = `
+        M ${Z} ${E}
+        C ${Z + le} ${E},
+          ${ae - le} ${I},
+          ${ae} ${I}
+        L ${ae} ${I + n}
+        C ${ae - le} ${I + n},
+          ${Z + le} ${E + n},
+          ${Z} ${E + n}
+        Z
+      `;
+      J.push({
+        path: te,
+        link: r,
+        sourcePos: F,
+        targetPos: H
+      });
+    }), { nodePositions: q, linkPaths: J, nodeMap: x, nodeValues: A };
+  }, [t, o, l, i, c, b]), L = ee(
+    (x, y) => {
+      const s = h.current?.getBoundingClientRect();
+      s && w && u({
+        x: y.clientX - s.left,
+        y: y.clientY - s.top,
+        content: x
+      });
+    },
+    [w]
+  );
+  return /* @__PURE__ */ _("div", { className: `nice-sankey-chart ${N || ""}`, style: { width: l, ...z }, ...M, children: [
+    S && /* @__PURE__ */ e("div", { className: "nice-sankey-title", children: S }),
+    /* @__PURE__ */ _("svg", { ref: h, width: l, height: i, className: "nice-sankey-svg", children: [
+      /* @__PURE__ */ e("defs", { children: m.linkPaths.map((x, y) => /* @__PURE__ */ _("linearGradient", { id: `sankey-gradient-${y}`, x1: "0%", y1: "0%", x2: "100%", y2: "0%", children: [
+        /* @__PURE__ */ e(
+          "stop",
+          {
+            offset: "0%",
+            stopColor: m.nodeMap.get(x.link.source)?.color || "#3b82f6"
+          }
+        ),
+        /* @__PURE__ */ e(
+          "stop",
+          {
+            offset: "100%",
+            stopColor: m.nodeMap.get(x.link.target)?.color || "#ef4444"
+          }
+        )
+      ] }, y)) }),
+      /* @__PURE__ */ e("g", { className: "nice-sankey-links", children: m.linkPaths.map((x, y) => /* @__PURE__ */ e(
+        "path",
+        {
+          d: x.path,
+          fill: x.link.color || `url(#sankey-gradient-${y})`,
+          fillOpacity: 0.4,
+          className: "nice-sankey-link",
+          onClick: () => p?.(x.link),
+          onMouseEnter: (s) => L(
+            `${m.nodeMap.get(x.link.source)?.name} → ${m.nodeMap.get(x.link.target)?.name}: ${x.link.value.toLocaleString()}`,
+            s
+          ),
+          onMouseLeave: () => u(null)
+        },
+        y
+      )) }),
+      /* @__PURE__ */ e("g", { className: "nice-sankey-nodes", children: Array.from(m.nodePositions.entries()).map(([x, y]) => {
+        const s = m.nodeMap.get(x);
+        return s ? /* @__PURE__ */ _("g", { children: [
+          /* @__PURE__ */ e(
+            "rect",
+            {
+              x: y.x,
+              y: y.y,
+              width: c,
+              height: y.height,
+              fill: s.color || "#3b82f6",
+              rx: 2,
+              className: "nice-sankey-node",
+              onClick: () => B?.(s),
+              onMouseEnter: (T) => L(
+                `${s.name}: ${m.nodeValues.get(x)?.toLocaleString() || 0}`,
+                T
+              ),
+              onMouseLeave: () => u(null)
+            }
+          ),
+          /* @__PURE__ */ _(
+            "text",
+            {
+              x: y.x + c + 6,
+              y: y.y + y.height / 2,
+              dominantBaseline: "middle",
+              fontSize: "12",
+              fill: "#374151",
+              children: [
+                s.name,
+                f && ` (${m.nodeValues.get(x)?.toLocaleString() || 0})`
+              ]
+            }
+          )
+        ] }, x) : null;
+      }) })
+    ] }),
+    v && /* @__PURE__ */ e("div", { className: "nice-sankey-tooltip", style: { left: v.x + 10, top: v.y - 30 }, children: v.content }),
+    /* @__PURE__ */ e("style", { children: `
+        .nice-sankey-chart {
+          font-family: system-ui, -apple-system, sans-serif;
+          background: white;
+          border-radius: 8px;
+          position: relative;
+        }
+
+        .nice-sankey-title {
+          padding: 12px 16px;
+          font-size: 16px;
+          font-weight: 600;
+          color: #111827;
+          border-bottom: 1px solid #e5e7eb;
+        }
+
+        .nice-sankey-link {
+          cursor: pointer;
+          transition: fill-opacity 0.2s;
+        }
+
+        .nice-sankey-link:hover {
+          fill-opacity: 0.7;
+        }
+
+        .nice-sankey-node {
+          cursor: pointer;
+          transition: opacity 0.2s;
+        }
+
+        .nice-sankey-node:hover {
+          opacity: 0.8;
+        }
+
+        .nice-sankey-tooltip {
+          position: absolute;
+          background: #1f2937;
+          color: white;
+          padding: 6px 10px;
+          border-radius: 4px;
+          font-size: 12px;
+          pointer-events: none;
+          z-index: 10;
+          white-space: nowrap;
+        }
+      ` })
+  ] });
+}, et = be(
+  (t, o) => {
+    const {
+      initialData: l = [],
+      maxPoints: i = 60,
+      updateInterval: c = 1e3,
+      fetchData: b,
+      width: f = 600,
+      height: w = 200,
+      chartType: B = "line",
+      color: p = "#3b82f6",
+      showGrid: S = !0,
+      showTimeAxis: N = !0,
+      showCurrentValue: z = !0,
+      title: M,
+      valueFormatter: v = (te) => te.toFixed(2),
+      timeFormatter: u = (te) => new Date(te).toLocaleTimeString(),
+      onDataUpdate: h,
+      paused: m,
+      className: L,
+      style: x,
+      ...y
+    } = t, [s, T] = oe(l), [g, C] = oe(m || !1), d = ye();
+    we(() => {
+      m !== void 0 && C(m);
+    }, [m]), we(() => {
+      if (g || !b)
+        return;
+      const te = async () => {
+        try {
+          const j = await b();
+          T((G) => {
+            const ce = [...G, j].slice(-i);
+            return h?.(ce), ce;
+          });
+        } catch (j) {
+          console.error("Failed to fetch realtime data:", j);
+        }
+      };
+      return d.current = setInterval(te, c), () => {
+        d.current && clearInterval(d.current);
+      };
+    }, [g, b, c, i, h]);
+    const $ = ee(
+      (te) => {
+        T((j) => {
+          const G = [...j, te].slice(-i);
+          return h?.(G), G;
+        });
+      },
+      [i, h]
+    ), A = ee(() => {
+      T([]), h?.([]);
+    }, [h]), O = ee(() => C(!0), []), X = ee(() => C(!1), []);
+    Ne(
+      o,
+      () => ({
+        addDataPoint: $,
+        clearData: A,
+        pause: O,
+        resume: X,
+        getData: () => s
+      }),
+      [$, A, s]
+    );
+    const R = { top: 20, right: 60, bottom: N ? 40 : 20, left: 50 }, Y = f - R.left - R.right, q = w - R.top - R.bottom, J = s.map((te) => te.value), V = J.length ? Math.min(...J) : 0, Q = J.length ? Math.max(...J) : 100, F = (Q - V || 1) * 0.1, H = V - F, n = Q + F - H, E = (te) => R.left + te / (i - 1) * Y, I = (te) => R.top + q - (te - H) / n * q, Z = s.map((te, j) => `${E(j)},${I(te.value)}`).join(" "), ae = s.length > 0 ? `M ${E(0)},${R.top + q} L ${Z} L ${E(s.length - 1)},${R.top + q} Z` : "", le = s.length > 0 ? s[s.length - 1].value : null;
+    return /* @__PURE__ */ _(
+      "div",
+      {
+        className: `nice-realtime-chart ${L || ""}`,
+        style: { width: f, ...x },
+        ...y,
+        children: [
+          M && /* @__PURE__ */ _("div", { className: "nice-realtime-header", children: [
+            /* @__PURE__ */ e("span", { className: "nice-realtime-title", children: M }),
+            /* @__PURE__ */ _("div", { className: "nice-realtime-controls", children: [
+              /* @__PURE__ */ e(
+                "button",
+                {
+                  className: `nice-realtime-btn ${g ? "paused" : ""}`,
+                  onClick: () => C(!g),
+                  children: g ? "▶️" : "⏸️"
+                }
+              ),
+              z && le !== null && /* @__PURE__ */ e("span", { className: "nice-realtime-value", children: v(le) })
+            ] })
+          ] }),
+          /* @__PURE__ */ _("svg", { width: f, height: w, className: "nice-realtime-svg", children: [
+            S && /* @__PURE__ */ e("g", { className: "nice-realtime-grid", children: [0, 0.25, 0.5, 0.75, 1].map((te, j) => {
+              const G = R.top + q * (1 - te), ce = H + n * te;
+              return /* @__PURE__ */ _("g", { children: [
+                /* @__PURE__ */ e(
+                  "line",
+                  {
+                    x1: R.left,
+                    y1: G,
+                    x2: f - R.right,
+                    y2: G,
+                    stroke: "#e5e7eb",
+                    strokeDasharray: te === 0 ? void 0 : "3"
+                  }
+                ),
+                /* @__PURE__ */ e(
+                  "text",
+                  {
+                    x: R.left - 8,
+                    y: G,
+                    textAnchor: "end",
+                    dominantBaseline: "middle",
+                    fontSize: "10",
+                    fill: "#6b7280",
+                    children: v(ce)
+                  }
+                )
+              ] }, j);
+            }) }),
+            B === "area" && s.length > 0 && /* @__PURE__ */ e("path", { d: ae, fill: p, fillOpacity: 0.2 }),
+            s.length > 1 && /* @__PURE__ */ e(
+              "polyline",
+              {
+                points: Z,
+                fill: "none",
+                stroke: p,
+                strokeWidth: 2,
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            ),
+            s.length > 0 && /* @__PURE__ */ e(
+              "circle",
+              {
+                cx: E(s.length - 1),
+                cy: I(s[s.length - 1].value),
+                r: 4,
+                fill: p,
+                className: "nice-realtime-point"
+              }
+            ),
+            N && s.length > 0 && /* @__PURE__ */ e("g", { className: "nice-realtime-time-axis", children: [0, Math.floor(s.length / 2), s.length - 1].filter((te) => s[te]).map((te) => /* @__PURE__ */ e(
+              "text",
+              {
+                x: E(te),
+                y: w - 8,
+                textAnchor: "middle",
+                fontSize: "10",
+                fill: "#6b7280",
+                children: u(s[te].timestamp)
+              },
+              te
+            )) })
+          ] }),
+          /* @__PURE__ */ _("div", { className: `nice-realtime-status ${g ? "paused" : "live"}`, children: [
+            /* @__PURE__ */ e("span", { className: "nice-realtime-status-dot" }),
+            /* @__PURE__ */ e("span", { children: g ? "Wstrzymano" : "Na żywo" })
+          ] }),
+          /* @__PURE__ */ e("style", { children: `
+        .nice-realtime-chart {
+          font-family: system-ui, -apple-system, sans-serif;
+          background: white;
+          border-radius: 8px;
+          position: relative;
+        }
+
+        .nice-realtime-header {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          padding: 12px 16px;
+          border-bottom: 1px solid #e5e7eb;
+        }
+
+        .nice-realtime-title {
+          font-size: 14px;
+          font-weight: 600;
+          color: #111827;
+        }
+
+        .nice-realtime-controls {
+          display: flex;
+          align-items: center;
+          gap: 12px;
+        }
+
+        .nice-realtime-btn {
+          background: none;
+          border: none;
+          cursor: pointer;
+          font-size: 16px;
+          padding: 4px;
+        }
+
+        .nice-realtime-value {
+          font-size: 18px;
+          font-weight: 600;
+          color: ${p};
+          font-variant-numeric: tabular-nums;
+        }
+
+        .nice-realtime-point {
+          animation: realtime-pulse 1s ease-out infinite;
+        }
+
+        @keyframes realtime-pulse {
+          0% { opacity: 1; transform: scale(1); }
+          50% { opacity: 0.5; transform: scale(1.5); }
+          100% { opacity: 1; transform: scale(1); }
+        }
+
+        .nice-realtime-status {
+          position: absolute;
+          bottom: 8px;
+          right: 8px;
+          display: flex;
+          align-items: center;
+          gap: 6px;
+          font-size: 11px;
+          color: #6b7280;
+        }
+
+        .nice-realtime-status-dot {
+          width: 8px;
+          height: 8px;
+          border-radius: 50%;
+          background: #22c55e;
+        }
+
+        .nice-realtime-status.paused .nice-realtime-status-dot {
+          background: #f59e0b;
+        }
+
+        .nice-realtime-status.live .nice-realtime-status-dot {
+          animation: live-pulse 2s ease-in-out infinite;
+        }
+
+        @keyframes live-pulse {
+          0%, 100% { opacity: 1; }
+          50% { opacity: 0.4; }
+        }
+      ` })
+        ]
+      }
+    );
+  }
+);
+et.displayName = "NiceRealtimeChart";
+const At = ({
+  data: t,
+  width: o = 600,
+  height: l = 400,
+  showLabels: i = !0,
+  showValues: c = !0,
+  onNodeClick: b,
+  drilldownEnabled: f = !0,
+  colors: w = Pe,
+  tilePadding: B = 2,
+  className: p,
+  style: S,
+  ...N
+}) => {
+  const [z, M] = oe(t), [v, u] = oe([t.name]), [h, m] = oe(null), L = ye(null), x = he(() => {
+    const d = z.children || [];
+    if (d.length === 0)
+      return [];
+    const $ = d.reduce((V, Q) => V + Q.value, 0), A = d.map((V) => ({
+      node: V,
+      area: V.value / $ * o * l
+    }));
+    A.sort((V, Q) => Q.area - V.area);
+    const O = [];
+    let X = 0, R = 0, Y = o, q = l, J = 0;
+    for (; J < A.length; ) {
+      const V = Y < q;
+      let Q = 0, r = [];
+      const F = V ? q : Y;
+      for (let n = J; n < A.length; n++) {
+        const E = [...r, A[n]], I = E.reduce((ae, le) => ae + le.area, 0), Z = y(E, I, F);
+        if (r.length === 0)
+          r = E, Q = I;
+        else {
+          const ae = y(r, Q, F);
+          if (Z <= ae)
+            r = E, Q = I;
+          else
+            break;
+        }
+      }
+      const H = Q / F;
+      let k = 0;
+      r.forEach((n, E) => {
+        const I = n.area / H;
+        O.push({
+          node: n.node,
+          x: V ? X : X + k,
+          y: V ? R + k : R,
+          w: V ? H : I,
+          h: V ? I : H,
+          color: n.node.color || w[(J + E) % w.length]
+        }), k += I;
+      }), V ? (X += H, Y -= H) : (R += H, q -= H), J += r.length;
+    }
+    return O;
+  }, [z, o, l, w]);
+  function y(C, d, $) {
+    const A = d / $;
+    let O = 0;
+    for (const X of C) {
+      const R = X.area / A, Y = Math.max(A / R, R / A);
+      O = Math.max(O, Y);
+    }
+    return O;
+  }
+  const s = (C) => {
+    b?.(C, [...v, C.name]), f && C.children && C.children.length > 0 && (M(C), u((d) => [...d, C.name]));
+  }, T = () => {
+    if (v.length <= 1)
+      return;
+    let C = t;
+    const d = v.slice(0, -1);
+    for (let $ = 1; $ < d.length; $++) {
+      const A = C.children?.find((O) => O.name === d[$]);
+      A && (C = A);
+    }
+    M(C), u(d);
+  }, g = (C, d) => {
+    const $ = L.current?.getBoundingClientRect();
+    $ && m({
+      x: d.clientX - $.left,
+      y: d.clientY - $.top,
+      content: C
+    });
+  };
+  return /* @__PURE__ */ _("div", { className: `nice-treemap-chart ${p || ""}`, style: { width: o, ...S }, ...N, children: [
+    /* @__PURE__ */ _("div", { className: "nice-treemap-nav", children: [
+      v.length > 1 && /* @__PURE__ */ e("button", { className: "nice-treemap-back", onClick: T, children: "← Wstecz" }),
+      /* @__PURE__ */ e("div", { className: "nice-treemap-breadcrumbs", children: v.map((C, d) => /* @__PURE__ */ _(Re.Fragment, { children: [
+        d > 0 && /* @__PURE__ */ e("span", { className: "nice-treemap-sep", children: "/" }),
+        /* @__PURE__ */ e("span", { className: d === v.length - 1 ? "current" : "", children: C })
+      ] }, d)) })
+    ] }),
+    /* @__PURE__ */ e("svg", { ref: L, width: o, height: l, className: "nice-treemap-svg", children: x.map((C, d) => {
+      const { node: $, x: A, y: O, w: X, h: R, color: Y } = C, q = Math.min(14, Math.max(10, Math.min(X, R) / 6)), J = X > 40 && R > 30;
+      return /* @__PURE__ */ _(
+        "g",
+        {
+          onClick: () => s($),
+          onMouseEnter: (V) => g(`${$.name}: ${$.value.toLocaleString()}`, V),
+          onMouseLeave: () => m(null),
+          children: [
+            /* @__PURE__ */ e(
+              "rect",
+              {
+                x: A + B / 2,
+                y: O + B / 2,
+                width: Math.max(0, X - B),
+                height: Math.max(0, R - B),
+                fill: Y,
+                rx: 4,
+                className: "nice-treemap-tile"
+              }
+            ),
+            i && J && /* @__PURE__ */ e(
+              "text",
+              {
+                x: A + X / 2,
+                y: O + R / 2 - (c ? 6 : 0),
+                textAnchor: "middle",
+                dominantBaseline: "middle",
+                fontSize: q,
+                fill: "white",
+                fontWeight: "500",
+                style: { pointerEvents: "none" },
+                children: $.name.length > X / q + 2 ? $.name.slice(0, Math.floor(X / q)) + "..." : $.name
+              }
+            ),
+            c && J && /* @__PURE__ */ e(
+              "text",
+              {
+                x: A + X / 2,
+                y: O + R / 2 + 10,
+                textAnchor: "middle",
+                dominantBaseline: "middle",
+                fontSize: q - 2,
+                fill: "rgba(255,255,255,0.8)",
+                style: { pointerEvents: "none" },
+                children: $.value.toLocaleString()
+              }
+            )
+          ]
+        },
+        d
+      );
+    }) }),
+    h && /* @__PURE__ */ e("div", { className: "nice-treemap-tooltip", style: { left: h.x + 10, top: h.y - 30 }, children: h.content }),
+    /* @__PURE__ */ e("style", { children: `
+        .nice-treemap-chart {
+          font-family: system-ui, -apple-system, sans-serif;
+          background: white;
+          border-radius: 8px;
+          position: relative;
+        }
+
+        .nice-treemap-nav {
+          display: flex;
+          align-items: center;
+          gap: 12px;
+          padding: 12px 16px;
+          border-bottom: 1px solid #e5e7eb;
+        }
+
+        .nice-treemap-back {
+          background: #f3f4f6;
+          border: none;
+          padding: 6px 12px;
+          border-radius: 6px;
+          cursor: pointer;
+          font-size: 13px;
+        }
+
+        .nice-treemap-back:hover {
+          background: #e5e7eb;
+        }
+
+        .nice-treemap-breadcrumbs {
+          display: flex;
+          align-items: center;
+          gap: 4px;
+          font-size: 13px;
+          color: #6b7280;
+        }
+
+        .nice-treemap-breadcrumbs .current {
+          color: #111827;
+          font-weight: 500;
+        }
+
+        .nice-treemap-sep {
+          color: #9ca3af;
+        }
+
+        .nice-treemap-tile {
+          cursor: pointer;
+          transition: opacity 0.2s, transform 0.1s;
+        }
+
+        .nice-treemap-tile:hover {
+          opacity: 0.85;
+        }
+
+        .nice-treemap-tooltip {
+          position: absolute;
+          background: #1f2937;
+          color: white;
+          padding: 6px 10px;
+          border-radius: 4px;
+          font-size: 12px;
+          pointer-events: none;
+          z-index: 10;
+          white-space: nowrap;
+        }
+      ` })
+  ] });
+}, tt = be(
+  ({
+    data: t,
+    renderNode: o,
+    selectable: l,
+    selectedKey: i,
+    onSelect: c,
+    direction: b = "top-down",
+    collapsible: f = !0,
+    className: w,
+    style: B,
+    id: p
+  }, S) => {
+    const N = Se(p), [z, M] = oe(/* @__PURE__ */ new Set()), v = ee((m) => {
+      M((L) => {
+        const x = new Set(L);
+        return x.has(m) ? x.delete(m) : x.add(m), x;
+      });
+    }, []), u = ee(
+      (m) => {
+        l && c?.(m);
+      },
+      [l, c]
+    ), h = ee(
+      (m) => {
+        const L = z.has(m.key), x = m.children && m.children.length > 0;
+        return /* @__PURE__ */ _("li", { className: "nice-org-chart__item", children: [
+          /* @__PURE__ */ _(
+            "div",
+            {
+              className: `nice-org-chart__node${i === m.key ? " nice-org-chart__node--selected" : ""}`,
+              onClick: () => u(m.key),
+              role: l ? "button" : void 0,
+              children: [
+                o ? o(m) : /* @__PURE__ */ e("span", { children: m.label }),
+                f && x && /* @__PURE__ */ e(
+                  "button",
+                  {
+                    type: "button",
+                    className: "nice-org-chart__toggle",
+                    onClick: (y) => {
+                      y.stopPropagation(), v(m.key);
+                    },
+                    "aria-label": L ? "Expand" : "Collapse",
+                    children: L ? "+" : "−"
+                  }
+                )
+              ]
+            }
+          ),
+          x && !L && /* @__PURE__ */ e("ul", { className: "nice-org-chart__children", children: m.children.map((y) => h(y)) })
+        ] }, m.key);
+      },
+      [z, i, o, l, f, u, v]
+    );
+    return /* @__PURE__ */ e(
+      "div",
+      {
+        ref: S,
+        id: N,
+        className: `nice-org-chart nice-org-chart--${b} ${w || ""}`,
+        style: B,
+        children: /* @__PURE__ */ e("ul", { className: "nice-org-chart__root", children: h(t) })
+      }
+    );
+  }
+);
+tt.displayName = "NiceOrganizationChart";
+function nt(t, o, l) {
+  const i = (M) => {
+    const v = M.replace("#", "");
+    return [
+      parseInt(v.slice(0, 2), 16),
+      parseInt(v.slice(2, 4), 16),
+      parseInt(v.slice(4, 6), 16)
+    ];
+  }, [c, b, f] = i(t), [w, B, p] = i(o), S = Math.round(c + (w - c) * l), N = Math.round(b + (B - b) * l), z = Math.round(f + (p - f) * l);
+  return `rgb(${S},${N},${z})`;
+}
+const at = be(
+  ({
+    data: t,
+    xLabels: o,
+    yLabels: l,
+    colors: i = ["#e0f2fe", "#1d4ed8"],
+    onCellClick: c,
+    cellSize: b = 40,
+    showValues: f = !0,
+    className: w,
+    style: B,
+    id: p
+  }, S) => {
+    const N = Se(p), { minVal: z, maxVal: M } = he(() => {
+      let u = 1 / 0, h = -1 / 0;
+      for (const m of t)
+        for (const L of m)
+          L < u && (u = L), L > h && (h = L);
+      return { minVal: u, maxVal: h };
+    }, [t]), v = ee(
+      (u) => M === z ? 0.5 : (u - z) / (M - z),
+      [z, M]
+    );
+    return /* @__PURE__ */ e("div", { ref: S, id: N, className: `nice-heatmap ${w || ""}`, style: B, children: /* @__PURE__ */ _("table", { className: "nice-heatmap__table", children: [
+      o && /* @__PURE__ */ e("thead", { children: /* @__PURE__ */ _("tr", { children: [
+        l && /* @__PURE__ */ e("th", {}),
+        o.map((u, h) => /* @__PURE__ */ e("th", { className: "nice-heatmap__header", children: u }, h))
+      ] }) }),
+      /* @__PURE__ */ e("tbody", { children: t.map((u, h) => /* @__PURE__ */ _("tr", { children: [
+        l && /* @__PURE__ */ e("th", { className: "nice-heatmap__row-label", children: l[h] }),
+        u.map((m, L) => /* @__PURE__ */ e(
+          "td",
+          {
+            className: "nice-heatmap__cell",
+            style: {
+              background: nt(i[0], i[1], v(m)),
+              width: b,
+              height: b,
+              textAlign: "center",
+              color: v(m) > 0.6 ? "#fff" : "#333",
+              cursor: c ? "pointer" : void 0
+            },
+            onClick: () => c?.(h, L, m),
+            title: String(m),
+            children: f ? m : ""
+          },
+          L
+        ))
+      ] }, h)) })
+    ] }) });
+  }
+);
+at.displayName = "NiceHeatMap";
+function rt(t, o) {
+  const l = t.reduce((p, S) => p + S.value, 0);
+  if (l === 0 || t.length === 0)
+    return [];
+  const i = [];
+  let { x: c, y: b, w: f, h: w } = o;
+  const B = [...t].sort((p, S) => S.value - p.value);
+  for (const p of B) {
+    const S = p.value / l;
+    if (f >= w) {
+      const N = f * S;
+      i.push({ x: c, y: b, w: N, h: w, node: p }), c += N, f -= N;
+    } else {
+      const N = w * S;
+      i.push({ x: c, y: b, w: f, h: N, node: p }), b += N, w -= N;
+    }
+  }
+  return i;
+}
+const ct = [
+  "#3b82f6",
+  "#10b981",
+  "#f59e0b",
+  "#ef4444",
+  "#8b5cf6",
+  "#06b6d4",
+  "#ec4899",
+  "#84cc16"
+], We = be(
+  ({ data: t, width: o = 600, height: l = 400, onNodeClick: i, colors: c = ct, className: b, style: f, id: w }, B) => {
+    const p = Se(w), S = he(() => {
+      const N = t.children ?? [t];
+      return rt(N, { x: 0, y: 0, w: o, h: l });
+    }, [t, o, l]);
+    return /* @__PURE__ */ e("div", { ref: B, id: p, className: `nice-treemap ${b || ""}`, style: f, children: /* @__PURE__ */ e("svg", { width: o, height: l, className: "nice-treemap__svg", children: S.map((N, z) => /* @__PURE__ */ _(
+      "g",
+      {
+        onClick: () => i?.(N.node),
+        style: { cursor: i ? "pointer" : void 0 },
+        children: [
+          /* @__PURE__ */ e(
+            "rect",
+            {
+              x: N.x,
+              y: N.y,
+              width: Math.max(N.w - 1, 0),
+              height: Math.max(N.h - 1, 0),
+              fill: N.node.color ?? c[z % c.length],
+              rx: 2
+            }
+          ),
+          N.w > 40 && N.h > 20 && /* @__PURE__ */ e(
+            "text",
+            {
+              x: N.x + N.w / 2,
+              y: N.y + N.h / 2,
+              textAnchor: "middle",
+              dominantBaseline: "central",
+              fill: "#fff",
+              fontSize: Math.min(12, N.w / 6),
+              className: "nice-treemap__label",
+              children: N.node.label
+            }
+          )
+        ]
+      },
+      N.node.key
+    )) }) });
+  }
+);
+We.displayName = "NiceTreeMap";
+const It = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NiceTreeMap: We
+}, Symbol.toStringTag, { value: "Module" })), ot = be(
+  ({
+    data: t,
+    type: o = "candlestick",
+    showVolume: l = !0,
+    width: i = 800,
+    height: c = 400,
+    bullColor: b = "#22c55e",
+    bearColor: f = "#ef4444",
+    className: w,
+    style: B,
+    id: p
+  }, S) => {
+    const N = Se(p), z = { top: 20, right: 20, bottom: l ? 80 : 30, left: 60 }, M = i - z.left - z.right, v = l ? 50 : 0, u = c - z.top - z.bottom - v, { minP: h, maxP: m, maxVol: L } = he(() => {
+      let g = 1 / 0, C = -1 / 0, d = 0;
+      for (const $ of t)
+        $.low < g && (g = $.low), $.high > C && (C = $.high), $.volume && $.volume > d && (d = $.volume);
+      return { minP: g, maxP: C, maxVol: d };
+    }, [t]), x = Math.max(1, M / t.length * 0.7), y = (g) => z.left + (g + 0.5) * (M / t.length), s = (g) => z.top + u - (g - h) / (m - h || 1) * u, T = (g) => c - z.bottom - v + v * (1 - g / (L || 1));
+    return /* @__PURE__ */ e("div", { ref: S, id: N, className: `nice-stock-chart ${w || ""}`, style: B, children: /* @__PURE__ */ _("svg", { width: i, height: c, className: "nice-stock-chart__svg", children: [
+      [0, 0.25, 0.5, 0.75, 1].map((g) => {
+        const C = h + g * (m - h);
+        return /* @__PURE__ */ _("g", { children: [
+          /* @__PURE__ */ e(
+            "line",
+            {
+              x1: z.left,
+              x2: i - z.right,
+              y1: s(C),
+              y2: s(C),
+              stroke: "#e5e7eb",
+              strokeDasharray: "2,2"
+            }
+          ),
+          /* @__PURE__ */ e("text", { x: z.left - 4, y: s(C) + 4, textAnchor: "end", fontSize: 10, fill: "#888", children: C.toFixed(2) })
+        ] }, g);
+      }),
+      o === "line" ? /* @__PURE__ */ e(
+        "polyline",
+        {
+          points: t.map((g, C) => `${y(C)},${s(g.close)}`).join(" "),
+          fill: "none",
+          stroke: b,
+          strokeWidth: 1.5
+        }
+      ) : t.map((g, C) => {
+        const d = g.close >= g.open, $ = d ? b : f, A = y(C);
+        if (o === "ohlc")
+          return /* @__PURE__ */ _("g", { children: [
+            /* @__PURE__ */ e(
+              "line",
+              {
+                x1: A,
+                x2: A,
+                y1: s(g.high),
+                y2: s(g.low),
+                stroke: $,
+                strokeWidth: 1
+              }
+            ),
+            /* @__PURE__ */ e(
+              "line",
+              {
+                x1: A - x / 2,
+                x2: A,
+                y1: s(g.open),
+                y2: s(g.open),
+                stroke: $,
+                strokeWidth: 1.5
+              }
+            ),
+            /* @__PURE__ */ e(
+              "line",
+              {
+                x1: A,
+                x2: A + x / 2,
+                y1: s(g.close),
+                y2: s(g.close),
+                stroke: $,
+                strokeWidth: 1.5
+              }
+            )
+          ] }, C);
+        const O = s(Math.max(g.open, g.close)), X = s(Math.min(g.open, g.close));
+        return /* @__PURE__ */ _("g", { children: [
+          /* @__PURE__ */ e(
+            "line",
+            {
+              x1: A,
+              x2: A,
+              y1: s(g.high),
+              y2: s(g.low),
+              stroke: $,
+              strokeWidth: 1
+            }
+          ),
+          /* @__PURE__ */ e(
+            "rect",
+            {
+              x: A - x / 2,
+              y: O,
+              width: x,
+              height: Math.max(X - O, 1),
+              fill: d ? "transparent" : $,
+              stroke: $,
+              strokeWidth: 1
+            }
+          )
+        ] }, C);
+      }),
+      l && t.map((g, C) => {
+        if (!g.volume)
+          return null;
+        const d = g.close >= g.open;
+        return /* @__PURE__ */ e(
+          "rect",
+          {
+            x: y(C) - x / 2,
+            y: T(g.volume),
+            width: x,
+            height: c - z.bottom - T(g.volume),
+            fill: d ? b : f,
+            opacity: 0.3
+          },
+          `v${C}`
+        );
+      }),
+      t.map((g, C) => C % Math.max(1, Math.floor(t.length / 8)) !== 0 ? null : /* @__PURE__ */ e(
+        "text",
+        {
+          x: y(C),
+          y: c - z.bottom + v + 14,
+          textAnchor: "middle",
+          fontSize: 9,
+          fill: "#888",
+          children: g.date
+        },
+        `l${C}`
+      ))
+    ] }) });
+  }
+);
+ot.displayName = "NiceStockChart";
+export {
+  dt as A,
+  Nt as B,
+  me as C,
+  $t as D,
+  It as E,
+  Je as N,
+  Ve as R,
+  Mt as a,
+  tt as b,
+  ot as c,
+  We as d,
+  at as e,
+  qe as f,
+  wt as g,
+  _t as h,
+  vt as i,
+  bt as j,
+  yt as k,
+  xt as l,
+  gt as m,
+  mt as n,
+  ze as o,
+  ht as p,
+  Ke as q,
+  kt as r,
+  Ge as s,
+  St as t,
+  et as u,
+  Ct as v,
+  At as w,
+  pt as x,
+  ut as y,
+  ft as z
+};