@umriss-ui/charts 0.3.0-rc.0

package/dist/charts.js

@@ -0,0 +1,2820 @@
+var fe = Object.defineProperty;
+var me = (n, t, e) => t in n ? fe(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var g = (n, t, e) => me(n, typeof t != "symbol" ? t + "" : t, e);
+import { jsx as I, jsxs as B, Fragment as Nt } from "react/jsx-runtime";
+import { useRef as Z, useEffect as D, createContext as pe, useContext as ye, useSyncExternalStore as Et, useCallback as ge, useState as be, useMemo as E } from "react";
+function xe() {
+  var t;
+  const n = import.meta;
+  return typeof ((t = n.env) == null ? void 0 : t.DEV) == "boolean" ? n.env.DEV : typeof process < "u" && (process != null && process.env) ? process.env.NODE_ENV !== "production" : !1;
+}
+const st = xe();
+function ut(n, t) {
+  if (st && !n)
+    throw new Error(`@umriss-ui/charts: ${t}`);
+}
+const Ot = /* @__PURE__ */ new Set();
+function q(n, t) {
+  !st || Ot.has(n) || (Ot.add(n), console.warn(`@umriss-ui/charts: ${t}`));
+}
+const W = {
+  colorAxis: "rgba(23, 23, 23, 0.17)",
+  colorGrid: "rgba(23, 23, 23, 0.06)",
+  colorText: "#71717a",
+  colorBg: "#ffffff",
+  colorWarning: "#8a5c00",
+  colorAlarm: "#b13636",
+  colorOk: "#217a4b",
+  font: "system-ui, sans-serif",
+  fontMono: "ui-monospace, monospace",
+  series: ["#2563eb", "#db2777", "#059669", "#d97706", "#7c3aed", "#0891b2"]
+}, Ht = /* @__PURE__ */ new WeakMap();
+let wt = 0;
+const It = /* @__PURE__ */ new Set();
+let bt = null;
+function _(n, t, e) {
+  const i = n.getPropertyValue(t).trim();
+  return i === "" ? e : i;
+}
+function ve(n) {
+  const t = getComputedStyle(n), e = [];
+  for (let i = 1; i <= 6; i++)
+    e.push(_(t, `--uc-series-${i}`, W.series[i - 1] ?? "#2563eb"));
+  return {
+    colorAxis: _(t, "--uc-color-axis", W.colorAxis),
+    colorGrid: _(t, "--uc-color-grid", W.colorGrid),
+    colorText: _(t, "--uc-color-text", W.colorText),
+    colorBg: _(t, "--uc-color-bg", W.colorBg),
+    colorWarning: _(t, "--uc-color-warning", W.colorWarning),
+    colorAlarm: _(t, "--uc-color-alarm", W.colorAlarm),
+    colorOk: _(t, "--uc-color-ok", W.colorOk),
+    font: _(t, "--uc-font", W.font),
+    fontMono: _(t, "--uc-font-mono", W.fontMono),
+    series: e
+  };
+}
+function ke() {
+  bt === null && (typeof MutationObserver > "u" || typeof document > "u" || (bt = new MutationObserver(() => we()), bt.observe(document.documentElement, { attributes: !0 })));
+}
+function Ne(n) {
+  ke();
+  const t = Ht.get(n);
+  if (t !== void 0 && t.generation === wt) return t.theme;
+  const e = ve(n);
+  return Ht.set(n, { generation: wt, theme: e }), e;
+}
+function we() {
+  wt++;
+  for (const n of It) n();
+}
+function Ie(n) {
+  return It.add(n), () => {
+    It.delete(n);
+  };
+}
+const Se = { width: 0, height: 0 };
+class Me {
+  constructor(t) {
+    g(this, "span", null);
+    g(this, "root");
+    g(this, "cache", /* @__PURE__ */ new Map());
+    this.root = t;
+  }
+  ensure() {
+    if (this.span !== null) return this.span;
+    if (typeof document > "u") return null;
+    const t = document.createElement("span");
+    return t.className = "kc-measure", t.setAttribute("aria-hidden", "true"), this.root.appendChild(t), this.span = t, t;
+  }
+  /** Width and height of a text in the presentation of the given class. */
+  measure(t, e) {
+    const i = `${e}|${t}`, s = this.cache.get(i);
+    if (s !== void 0) return s;
+    const r = this.ensure();
+    if (r === null) return Se;
+    r.className = `kc-measure ${e}`, r.textContent = t;
+    const o = r.getBoundingClientRect(), a = { width: o.width, height: o.height };
+    return this.cache.set(i, a), a;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  remove() {
+    var t;
+    (t = this.span) == null || t.remove(), this.span = null, this.cache.clear();
+  }
+}
+function St(n) {
+  return Object.is(n, -0) ? 0 : n;
+}
+function pt(n, t) {
+  if (!Number.isFinite(n) || n <= 0) return 1;
+  const e = Math.max(1, Math.floor(t)), i = n / e, s = Math.pow(10, Math.floor(Math.log10(i))), r = i / s, o = 1e-9;
+  return (r <= 1 + o ? 1 : r <= 2 + o ? 2 : r <= 5 + o ? 5 : 10) * s;
+}
+function Dt(n) {
+  const t = Math.abs(n);
+  if (!Number.isFinite(t) || t === 0) return 0;
+  const e = Math.floor(Math.log10(t));
+  let i = e < 0 ? -e : 0;
+  const s = t * 1e-9;
+  for (; i < 12 && Math.abs(Number(t.toFixed(i)) - t) > s; )
+    i++;
+  return i;
+}
+function Mt(n, t) {
+  return t <= 0 || !Number.isFinite(n) || Math.abs(n) >= 1e21 ? St(n) : St(Number(n.toFixed(Math.min(20, t))));
+}
+function Te(n, t, e) {
+  if (!Number.isFinite(n) || !Number.isFinite(t)) return [0, 1];
+  if (n === t) return [n - 1, t + 1];
+  const i = pt(t - n, e), s = Dt(i);
+  return [
+    Mt(Math.floor(n / i) * i, s),
+    Mt(Math.ceil(t / i) * i, s)
+  ];
+}
+function Rt(n, t) {
+  return !Number.isFinite(n) || !Number.isFinite(t) ? [0, 1] : n === t ? [n - 1, t + 1] : [n, t];
+}
+function ee(n, t, e) {
+  if (!Number.isFinite(n) || !Number.isFinite(t)) return [];
+  if (n === t) return [St(n)];
+  const [i, s] = n < t ? [n, t] : [t, n], r = pt(s - i, e), o = Dt(r), a = r * 1e-9, l = Math.ceil((i - a) / r), c = Math.floor((s + a) / r);
+  if (!Number.isFinite(l) || !Number.isFinite(c)) return [];
+  const u = [];
+  for (let h = l; h <= c; h++)
+    u.push(Mt(h * r, o));
+  return u;
+}
+class Vt {
+  constructor(t, e) {
+    g(this, "domain");
+    g(this, "range");
+    /** Pre-computed line equation px = v·m + b - the draw loop uses it directly. */
+    g(this, "m");
+    g(this, "b");
+    this.domain = t, this.range = e;
+    const i = t[1] - t[0];
+    i === 0 || !Number.isFinite(i) ? (this.m = 0, this.b = (e[0] + e[1]) / 2) : (this.m = (e[1] - e[0]) / i, this.b = e[0] - t[0] * this.m);
+  }
+  toPx(t) {
+    return t * this.m + this.b;
+  }
+  fromPx(t) {
+    return this.m === 0 ? this.domain[0] : (t - this.b) / this.m;
+  }
+  ticks(t) {
+    return ee(this.domain[0], this.domain[1], t);
+  }
+}
+let at = null;
+function ne() {
+  if (at !== null) return at;
+  const n = typeof navigator > "u" ? void 0 : navigator.language;
+  return at = typeof n == "string" && n !== "" ? n : "en-US", at;
+}
+const dt = /* @__PURE__ */ new Map();
+function Ae(n) {
+  const t = ne(), e = `${t}|${n}`;
+  let i = dt.get(e);
+  return i === void 0 && (i = new Intl.NumberFormat(t, {
+    minimumFractionDigits: n,
+    maximumFractionDigits: n,
+    useGrouping: !0
+  }), dt.set(e, i)), i;
+}
+function Le(n, t) {
+  return Ae(Math.min(6, Dt(t))).format(n);
+}
+function _t(n) {
+  if (!Number.isFinite(n)) return "–";
+  const t = ne(), e = `${t}|value`;
+  let i = dt.get(e);
+  return i === void 0 && (i = new Intl.NumberFormat(t, { maximumFractionDigits: 3, useGrouping: !0 }), dt.set(e, i)), i.format(n);
+}
+const K = 1e3, U = 60 * K, Q = 60 * U, X = 24 * Q;
+function Fe(n) {
+  const t = n.filter((r) => Number.isFinite(r.from) && Number.isFinite(r.to) && r.to > r.from).sort((r, o) => r.from - o.from), e = [];
+  for (const r of t) {
+    const o = e[e.length - 1];
+    o !== void 0 && r.from <= o.to ? r.to > o.to && (e[e.length - 1] = { from: o.from, to: r.to }) : e.push({ from: r.from, to: r.to });
+  }
+  const i = [];
+  let s = 0;
+  for (const r of e)
+    i.push(s), s += r.to - r.from;
+  return { intervals: e, offsets: i, total: s };
+}
+const Bt = /* @__PURE__ */ new WeakMap();
+function G(n) {
+  if (!Array.isArray(n)) return n;
+  const t = n, e = Bt.get(t);
+  if (e !== void 0) return e;
+  const i = Fe(t);
+  return Bt.set(t, i), i;
+}
+function Pe(n, t) {
+  const e = n.intervals;
+  let i = 0, s = e.length - 1, r = -1;
+  for (; i <= s; ) {
+    const o = i + s >> 1;
+    e[o].from <= t ? (r = o, i = o + 1) : s = o - 1;
+  }
+  return r < 0 ? -1 : t <= e[r].to ? r : -1;
+}
+function yt(n, t) {
+  const e = G(t);
+  if (e.intervals.length === 0) return n;
+  const i = Pe(e, n);
+  return i < 0 ? Number.NaN : e.offsets[i] + (n - e.intervals[i].from);
+}
+function ft(n, t) {
+  const e = G(t), i = e.intervals;
+  if (i.length === 0) return n;
+  if (!(n >= 0) || n > e.total) return Number.NaN;
+  if (n === e.total)
+    return i[i.length - 1].to;
+  let s = 0, r = i.length - 1, o = 0;
+  for (; s <= r; ) {
+    const a = s + r >> 1;
+    e.offsets[a] <= n ? (o = a, s = a + 1) : r = a - 1;
+  }
+  return i[o].from + (n - e.offsets[o]);
+}
+function Un(n, t, e, i) {
+  const s = G(n);
+  for (let r = 0; r < e; r++)
+    i[r] = yt(t[r], s);
+}
+function Ee(n, t) {
+  const e = G(t);
+  if (e.intervals.length === 0) return n;
+  const i = yt(n, e);
+  if (!Number.isNaN(i)) return i;
+  if (!Number.isFinite(n)) return Number.NaN;
+  for (let s = 0; s < e.intervals.length; s++) {
+    const r = e.intervals[s];
+    if (n < r.from) return e.offsets[s];
+  }
+  return e.total;
+}
+function De(n, t) {
+  const e = G(t);
+  return e.intervals.length === 0 ? !1 : Number.isNaN(yt(n, e));
+}
+function $e(n) {
+  const t = G(n), e = [];
+  for (let i = 1; i < t.intervals.length; i++)
+    e.push({
+      from: t.intervals[i - 1].to,
+      to: t.intervals[i].from,
+      operatingTime: t.offsets[i]
+    });
+  return e;
+}
+function Ce(n, t, e) {
+  return $e(n).map((i) => i.operatingTime).filter((i) => i >= t && i <= e);
+}
+const Yt = [
+  K,
+  2 * K,
+  5 * K,
+  10 * K,
+  15 * K,
+  30 * K,
+  U,
+  2 * U,
+  5 * U,
+  10 * U,
+  15 * U,
+  30 * U,
+  Q,
+  2 * Q,
+  3 * Q,
+  6 * Q,
+  12 * Q,
+  X,
+  2 * X,
+  7 * X,
+  14 * X,
+  28 * X
+];
+function We(n, t) {
+  const e = Yt[0];
+  if (!Number.isFinite(n) || n <= 0) return e;
+  const i = n / Math.max(1, Math.floor(t));
+  for (const s of Yt) if (s >= i) return s;
+  return X * pt(i / X, 1);
+}
+function Oe(n, t, e, i, s = 0) {
+  const r = G(n), o = [];
+  if (!Number.isFinite(t) || !Number.isFinite(e) || !(i > 0)) return o;
+  const a = Math.ceil((t - s) / i), l = Math.floor((e - s) / i);
+  if (!Number.isFinite(a) || !Number.isFinite(l)) return o;
+  let c = Number.NaN;
+  for (let u = a; u <= l; u++) {
+    const h = s + u * i, p = yt(h, r);
+    Number.isNaN(p) || p === c || (o.push({ wallClock: h, operatingTime: p }), c = p);
+  }
+  return o;
+}
+function He(n, t, e, i, s = 0) {
+  const r = G(n);
+  if (r.intervals.length === 0 || !(e > t)) return [];
+  const o = Math.max(0, Math.min(r.total, t)), a = Math.max(0, Math.min(r.total, e)), l = We(e - t, i);
+  return Oe(
+    r,
+    ft(o, r),
+    ft(a, r),
+    l,
+    s
+  ).map((u) => u.operatingTime).filter((u) => u >= t && u <= e);
+}
+const Tt = 5, At = 4, xt = 8, zt = 4, Re = 8, ht = "kc-tick-label", lt = "kc-axis-title", ie = {
+  width: 0,
+  height: 0,
+  plot: { x: 0, y: 0, width: 0, height: 0 },
+  axes: []
+};
+function Gt(n, t, e) {
+  const i = Math.ceil(t), s = e.get(n);
+  return s === void 0 || i > s || s - i >= Re ? (e.set(n, i), i) : s;
+}
+function qt(n, t) {
+  const e = n.domainMode;
+  if (Array.isArray(e)) {
+    const r = e;
+    return r[0] === r[1] ? [r[0] - 1, r[1] + 1] : r;
+  }
+  const [i, s] = n.extent;
+  return n.calendar !== void 0 && n.calendar.length > 0 || e === "data" ? Rt(i, s) : Te(i, s, t);
+}
+function Ve(n) {
+  if (!Number.isFinite(n)) return "";
+  const t = new Date(n), e = (i) => String(i).padStart(2, "0");
+  return `${e(t.getDate())}.${e(t.getMonth() + 1)}. ${e(t.getHours())}:${e(t.getMinutes())}`;
+}
+function Kt(n, t, e) {
+  if (n.tickValues !== void 0)
+    return n.tickValues.filter((s) => s >= t[0] && s <= t[1]);
+  const i = n.calendar;
+  return i !== void 0 && i.length > 0 ? He(i, t[0], t[1], e) : ee(t[0], t[1], e);
+}
+function Ut(n, t, e) {
+  const i = n.calendar;
+  if (i !== void 0 && i.length > 0) {
+    const r = n.tickFormat;
+    return r === void 0 ? (o) => Ve(ft(o, i)) : (o) => r(ft(o, i));
+  }
+  if (n.tickFormat !== void 0) return n.tickFormat;
+  const s = pt(Math.abs(t[1] - t[0]), e);
+  return (r) => Le(r, s);
+}
+function _e(n) {
+  const { width: t, height: e, padding: i, axes: s, measure: r, hysteresis: o } = n, a = s.filter((v) => v.position === "left"), l = s.filter((v) => v.position === "right"), c = s.filter((v) => v.position === "top"), u = s.filter((v) => v.position === "bottom"), h = Math.ceil(r("0", ht).height) || 14, p = /* @__PURE__ */ new Map();
+  for (const v of [...c, ...u]) {
+    const M = v.label === void 0 || v.label === "" ? 0 : Math.ceil(r(v.label, lt).height) + zt;
+    p.set(v.key, Gt(v.key, Tt + At + h + M, o));
+  }
+  const d = (v, M) => {
+    let x = 0;
+    for (let A = 0; A < v.length; A++) {
+      const $ = v[A];
+      $ !== void 0 && (x += M.get($.key) ?? 0, A > 0 && (x += xt));
+    }
+    return x;
+  }, m = i.top + d(c, p), y = e - i.bottom - d(u, p), f = Math.max(0, y - m), b = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map();
+  for (const v of [...a, ...l]) {
+    const M = v.tickCount ?? Math.max(2, Math.round(f / 50)), x = qt(v, M), A = Kt(v, x, M), $ = Ut(v, x, M), T = A.map($), O = T.map((V) => r(V, ht).width);
+    let C = 0;
+    for (const V of O) V > C && (C = V);
+    const et = v.label === void 0 || v.label === "" ? 0 : Math.ceil(r(v.label, lt).height) + zt;
+    b.set(v.key, { axis: v, domain: x, values: A, labels: T, widths: O, format: $ }), k.set(
+      v.key,
+      Gt(v.key, Tt + At + C + et, o)
+    );
+  }
+  const N = i.left + d(a, k), w = t - i.right - d(l, k), L = Math.max(0, w - N), F = { x: N, y: m, width: L, height: f }, P = (v, M, x, A) => {
+    switch (v.position) {
+      case "left":
+        return { x: N - x - A, y: m, width: A, height: f };
+      case "right":
+        return { x: w + x, y: m, width: A, height: f };
+      case "top":
+        return { x: N, y: m - x - A, width: L, height: A };
+      default:
+        return { x: N, y: y + x, width: L, height: A };
+    }
+  }, S = [], H = (v) => {
+    let M = 0;
+    v.forEach((x, A) => {
+      const $ = k.get(x.key) ?? 0, T = b.get(x.key), O = P(x, A, M, $);
+      M += $ + xt;
+      const C = (T == null ? void 0 : T.domain) ?? [0, 1], et = (T == null ? void 0 : T.format) ?? ((j) => String(j)), V = new Vt(C, [m + f, m]), nt = ((T == null ? void 0 : T.values) ?? []).map((j, Y) => ({
+        value: j,
+        label: (T == null ? void 0 : T.labels[Y]) ?? "",
+        px: V.toPx(j),
+        labelLeft: 0,
+        labelWidth: (T == null ? void 0 : T.widths[Y]) ?? 0
+      }));
+      S.push({
+        key: x.key,
+        id: x.id,
+        orientation: "y",
+        position: x.position,
+        label: x.label,
+        grid: x.grid,
+        band: O,
+        size: $,
+        stack: A,
+        domain: C,
+        scale: V,
+        ticks: nt,
+        format: et,
+        titleSize: x.label === void 0 || x.label === "" ? 0 : Math.ceil(r(x.label, lt).height),
+        breaks: []
+      });
+    });
+  };
+  H(a), H(l);
+  const R = (v) => {
+    let M = 0;
+    v.forEach((x, A) => {
+      const $ = p.get(x.key) ?? 0, T = P(x, A, M, $);
+      M += $ + xt;
+      const O = x.tickCount ?? Math.max(2, Math.round(L / 80)), C = qt(x, O), et = Kt(x, C, O), V = Ut(x, C, O), nt = new Vt(C, [N, N + L]), j = et.map((Y) => {
+        const Ct = V(Y), gt = r(Ct, ht).width, Wt = nt.toPx(Y), he = Wt - gt / 2, de = Math.min(Math.max(he, 0), Math.max(0, t - gt));
+        return { value: Y, label: Ct, px: Wt, labelLeft: de, labelWidth: gt };
+      });
+      S.push({
+        key: x.key,
+        id: x.id,
+        orientation: "x",
+        position: x.position,
+        label: x.label,
+        grid: x.grid,
+        band: T,
+        size: $,
+        stack: A,
+        domain: C,
+        scale: nt,
+        ticks: j,
+        format: V,
+        titleSize: x.label === void 0 || x.label === "" ? 0 : Math.ceil(r(x.label, lt).height),
+        breaks: x.calendar === void 0 || x.calendar.length === 0 ? [] : Ce(x.calendar, C[0], C[1]).map((Y) => nt.toPx(Y))
+      });
+    });
+  };
+  return R(c), R(u), { width: t, height: e, plot: F, axes: S };
+}
+function Be(n, t, e) {
+  if (t <= 0 || !(e >= n[0])) return -1;
+  let i = 0, s = t - 1;
+  if (n[s] <= e) return s;
+  for (; s - i > 1; ) {
+    const r = i + s >> 1;
+    n[r] <= e ? i = r : s = r;
+  }
+  return i;
+}
+function se(n, t, e, i) {
+  return e + 1 < t ? n[e + 1] : i;
+}
+function rt(n, t) {
+  return Number.isFinite(n) ? n : t;
+}
+function re(n) {
+  return !Number.isFinite(n);
+}
+function Xt(n, t) {
+  return n < t;
+}
+function Ye(n, t, e, i) {
+  const s = new Int32Array(e);
+  for (let r = 0; r < e; r++) {
+    const o = n[r], a = rt(t[r], i);
+    if (!Xt(o, a)) continue;
+    let l = 0;
+    for (let c = 0; c < r; c++) {
+      const u = n[c], h = rt(t[c], i);
+      Xt(u, h) && o < h && u < a && l++;
+    }
+    s[r] = l;
+  }
+  return s;
+}
+function ze(n, t, e, i, s, r, o, a) {
+  const l = o / 2;
+  for (let c = i - 1; c >= 0; c--) {
+    const u = e[c];
+    if (!(Math.abs(u - r) <= l)) continue;
+    const h = n[c], p = rt(t[c], a);
+    if (s >= h && s < p) return c;
+  }
+  return -1;
+}
+function ot(n) {
+  return Math.round(n) + 0.5;
+}
+function Ge(n, t) {
+  const { plot: e, axes: i, theme: s } = t, r = e.x, o = e.x + e.width, a = e.y, l = e.y + e.height;
+  n.lineWidth = 1;
+  for (const c of i)
+    if (c.grid)
+      for (const u of [0, 1]) {
+        const h = u === 1;
+        n.beginPath();
+        let p = !1;
+        for (const d of c.ticks)
+          if ((c.orientation === "y" && d.value === 0) === h)
+            if (p = !0, c.orientation === "y") {
+              const y = ot(d.px);
+              n.moveTo(r, y), n.lineTo(o, y);
+            } else {
+              const y = ot(d.px);
+              n.moveTo(y, a), n.lineTo(y, l);
+            }
+        p && (n.strokeStyle = h ? s.colorAxis : s.colorGrid, n.stroke());
+      }
+}
+function qe(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.yScale.m, o = t.yScale.b, a = t.x, l = t.y, c = new Path2D();
+  let u = !1;
+  for (let h = 0; h < e; h++) {
+    const p = l[h];
+    if (Number.isNaN(p)) {
+      u = !1;
+      continue;
+    }
+    const d = a[h] * i + s, m = p * r + o;
+    u ? c.lineTo(d, m) : (c.moveTo(d, m), u = !0);
+  }
+  if (n.strokeStyle = t.color, n.lineWidth = t.strokeWidth, t.dash !== void 0 && t.dash.length > 0 ? n.setLineDash(t.dash) : n.setLineDash([]), n.stroke(c), n.setLineDash([]), t.marker) {
+    const h = t.strokeWidth + 1.5, p = new Path2D();
+    for (let d = 0; d < e; d++) {
+      const m = l[d];
+      if (Number.isNaN(m)) continue;
+      const y = a[d] * i + s, f = m * r + o;
+      p.moveTo(y + h, f), p.arc(y, f, h, 0, Math.PI * 2);
+    }
+    n.fillStyle = t.color, n.fill(p);
+  }
+}
+function Ke(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.yScale.m, o = t.yScale.b, a = t.x, l = t.y, c = t.y0, u = t.baseline * r + o, h = new Path2D(), p = new Path2D();
+  let d = 0;
+  for (; d < e; ) {
+    for (; d < e && (Number.isNaN(l[d]) || c !== null && Number.isNaN(c[d])); )
+      d++;
+    if (d >= e) break;
+    const m = d;
+    for (; d < e && !Number.isNaN(l[d]) && (c === null || !Number.isNaN(c[d])); )
+      d++;
+    const y = d - 1;
+    for (let f = m; f <= y; f++) {
+      const b = a[f] * i + s, k = l[f] * r + o;
+      f === m ? (h.moveTo(b, k), p.moveTo(b, k)) : (h.lineTo(b, k), p.lineTo(b, k));
+    }
+    if (c === null)
+      h.lineTo(a[y] * i + s, u), h.lineTo(a[m] * i + s, u);
+    else
+      for (let f = y; f >= m; f--)
+        h.lineTo(a[f] * i + s, c[f] * r + o);
+    h.closePath();
+  }
+  n.globalAlpha = t.alpha * t.fillOpacity, n.fillStyle = t.color, n.fill(h), t.strokeWidth > 0 && (n.globalAlpha = t.alpha, n.strokeStyle = t.color, n.lineWidth = t.strokeWidth, n.setLineDash([]), n.stroke(p));
+}
+function Ue(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.yScale.m, o = t.yScale.b, a = t.x, l = t.y, c = t.baseline * r + o, u = t.offset * i, h = t.width * i, p = new Path2D();
+  for (let d = 0; d < e; d++) {
+    const m = l[d];
+    if (Number.isNaN(m)) continue;
+    const y = a[d] * i + s + u, f = m * r + o;
+    p.rect(y, f, h, c - f);
+  }
+  n.fillStyle = t.color, n.fill(p);
+}
+function Xe(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.yScale.m, o = t.yScale.b, a = t.x, l = t.y, c = t.radius, u = new Path2D();
+  for (let h = 0; h < e; h++) {
+    const p = l[h];
+    if (Number.isNaN(p)) continue;
+    const d = a[h] * i + s, m = p * r + o;
+    u.moveTo(d + c, m), u.arc(d, m, c, 0, Math.PI * 2);
+  }
+  n.fillStyle = t.color, n.fill(u);
+}
+function Ze(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.x, o = t.y, a = t.laneTop, l = t.laneBottom - t.laneTop, c = t.colors.length;
+  if (c === 0 || l <= 0) return;
+  const u = [];
+  for (let p = 0; p < c; p++) u.push(new Path2D());
+  let h = !1;
+  for (let p = 0; p < e; p++) {
+    const d = o[p];
+    if (Number.isNaN(d)) continue;
+    const m = d | 0, y = u[m];
+    if (y === void 0) continue;
+    const f = r[p], b = se(r, e, p, t.domainEnd);
+    b > f && (y.rect(f * i + s, a, (b - f) * i, l), h = !0);
+  }
+  if (h)
+    for (let p = 0; p < c; p++)
+      n.fillStyle = t.colors[p], n.fill(u[p]);
+}
+function Je(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.yScale.m, o = t.yScale.b, a = t.x, l = t.y, c = t.buckets, u = t.colors.length;
+  if (u === 0) return;
+  const h = t.width * i, p = Math.abs(t.height * r), d = [];
+  for (let m = 0; m < u; m++) d.push(new Path2D());
+  for (let m = 0; m < e; m++) {
+    const y = c[m];
+    if (y < 0) continue;
+    const f = d[y];
+    if (f === void 0) continue;
+    const b = a[m] * i + s - h / 2, k = l[m] * r + o - p / 2;
+    f.rect(b, k, h, p);
+  }
+  for (let m = 0; m < u; m++)
+    n.fillStyle = t.colors[m], n.fill(d[m]);
+}
+function je(n, t) {
+  const e = t.length, i = t.xScale.m, s = t.xScale.b, r = t.yScale.m, o = t.yScale.b, a = t.x, l = t.y, c = t.x1, u = t.depth, h = Math.abs(t.height * r), p = h * 0.28, d = new Path2D(), m = new Path2D();
+  for (let y = 0; y < e; y++) {
+    const f = l[y];
+    if (Number.isNaN(f)) continue;
+    const b = a[y];
+    if (Number.isNaN(b)) continue;
+    const k = c[y], N = rt(k, t.domainEnd);
+    if (!(N >= b)) continue;
+    const w = b * i + s, L = Math.max(1, (N - b) * i), F = f * r + o + u[y] * p;
+    (re(k) ? m : d).rect(w, F - h / 2, L, h);
+  }
+  n.fillStyle = t.color, n.fill(d), n.save(), n.globalAlpha = n.globalAlpha * 0.45, n.fill(m), n.restore(), n.strokeStyle = t.color, n.lineWidth = 1, n.setLineDash([3, 2]), n.stroke(m), n.setLineDash([]);
+}
+function Zt(n, t, e) {
+  for (const i of e) {
+    if (i.band) {
+      const s = Math.min(i.fromPx, i.toPx), r = Math.max(i.fromPx, i.toPx);
+      n.fillStyle = i.color, n.save(), n.globalAlpha = 0.12, i.orientation === "y" ? n.fillRect(t.x, s, t.width, r - s) : n.fillRect(s, t.y, r - s, t.height), n.restore();
+      continue;
+    }
+    if (n.beginPath(), i.orientation === "y") {
+      const s = ot(i.fromPx);
+      n.moveTo(t.x, s), n.lineTo(t.x + t.width, s);
+    } else {
+      const s = ot(i.fromPx);
+      n.moveTo(s, t.y), n.lineTo(s, t.y + t.height);
+    }
+    n.strokeStyle = i.color, n.lineWidth = 1, n.setLineDash(i.dash), n.stroke(), n.setLineDash([]);
+  }
+}
+function Qe(n, t) {
+  const { width: e, height: i, plot: s, series: r } = t;
+  if (n.clearRect(0, 0, e, i), !(s.width <= 0 || s.height <= 0)) {
+    Ge(n, t), n.save(), n.beginPath(), n.rect(s.x, s.y, s.width, s.height), n.clip(), n.lineJoin = "round", n.lineCap = "round", n.globalAlpha = 1, Zt(n, s, t.limitBands);
+    for (const o of r)
+      if (o.length !== 0)
+        switch (n.globalAlpha = o.alpha, o.kind) {
+          case "line":
+            qe(n, o);
+            break;
+          case "area":
+            Ke(n, o);
+            break;
+          case "bar":
+            Ue(n, o);
+            break;
+          case "scatter":
+            Xe(n, o);
+            break;
+          case "state":
+            Ze(n, o);
+            break;
+          case "matrix":
+            Je(n, o);
+            break;
+          case "span":
+            je(n, o);
+            break;
+        }
+    n.globalAlpha = 1, Zt(n, s, t.limitLines), n.restore();
+  }
+}
+function tn(n, t) {
+  const { width: e, height: i, plot: s, theme: r, hover: o } = t;
+  if (n.clearRect(0, 0, e, i), o === null || s.width <= 0 || s.height <= 0) return;
+  const a = ot(o.hit.xPx);
+  a >= s.x && a <= s.x + s.width && (n.beginPath(), n.moveTo(a, s.y), n.lineTo(a, s.y + s.height), n.lineWidth = 1, n.strokeStyle = r.colorAxis, n.setLineDash([]), n.stroke());
+  for (const l of o.marker)
+    n.beginPath(), n.arc(l.x, l.y, 5.5, 0, Math.PI * 2), n.fillStyle = r.colorBg, n.fill(), n.beginPath(), n.arc(l.x, l.y, 3.5, 0, Math.PI * 2), n.fillStyle = l.color, n.fill();
+}
+function en(n, t, e) {
+  if (t <= 0) return -1;
+  if (t === 1) return 0;
+  let i = 0, s = t - 1;
+  if (e <= n[i]) return i;
+  if (e >= n[s]) return s;
+  for (; s - i > 1; ) {
+    const a = i + s >> 1;
+    n[a] <= e ? i = a : s = a;
+  }
+  const r = e - n[i];
+  return n[s] - e < r ? s : i;
+}
+function Jt(n, t) {
+  if (t < 2) return 0;
+  const e = n.slice(0, t).sort();
+  let i = Number.POSITIVE_INFINITY;
+  for (let s = 1; s < t; s++) {
+    const r = e[s] - e[s - 1];
+    r > 0 && r < i && (i = r);
+  }
+  return Number.isFinite(i) ? i : 0;
+}
+function ct(n, t) {
+  return n > 0 ? n : t;
+}
+function nn(n, t, e, i, s, r, o) {
+  const a = r / 2, l = o / 2;
+  for (let c = 0; c < e; c++) {
+    const u = i - n[c];
+    if (!(u >= -a && u < a)) continue;
+    const h = s - t[c];
+    if (h >= -l && h < l)
+      return c;
+  }
+  return -1;
+}
+const sn = {
+  ok: 0,
+  unknown: 1,
+  warning: 2,
+  alarm: 3
+};
+function Xn(n) {
+  return sn[n];
+}
+const jt = { warning: 2, alarm: 3 };
+function rn(n, t = {}) {
+  if (n == null || !Number.isFinite(n))
+    return { verdict: "unknown" };
+  const e = t.target, i = e !== void 0 && Number.isFinite(e) ? n - e : void 0;
+  let s, r = 0;
+  for (const a of t.limits ?? []) {
+    const l = a.side === "upper" ? n - a.value : a.value - n;
+    l > 0 && (s === void 0 || jt[a.severity] > jt[s.severity] || a.severity === s.severity && l > r) && (s = a, r = l);
+  }
+  if (s === void 0)
+    return i === void 0 ? { verdict: "ok" } : { verdict: "ok", deviation: i };
+  const o = {
+    verdict: s.severity,
+    limit: s,
+    excess: r
+  };
+  return i === void 0 ? o : { ...o, deviation: i };
+}
+function on(n, t, e, i, s) {
+  const r = n.length, o = new Float64Array(r), a = new Float64Array(r), l = typeof i == "function" ? i : null, c = l === null ? null : new Float64Array(r), u = (s == null ? void 0 : s.value) ?? null, h = u === null ? null : new Float64Array(r), p = (s == null ? void 0 : s.xEnd) ?? null, d = p === null ? null : new Float64Array(r), m = (s == null ? void 0 : s.xMap) ?? null, y = (s == null ? void 0 : s.xGap) ?? null;
+  let f = Number.POSITIVE_INFINITY, b = Number.NEGATIVE_INFINITY, k = Number.POSITIVE_INFINITY, N = Number.NEGATIVE_INFINITY;
+  typeof i == "number" && r > 0 && (k = i, N = i);
+  for (let w = 0; w < r; w++) {
+    const L = n[w], F = t(L, w), P = m === null ? F : m(F);
+    o[w] = P;
+    const S = y !== null && y(F);
+    if (S || (P < f && (f = P), P > b && (b = P)), p !== null) {
+      const v = p(L, w), M = v ?? Number.NaN, x = !Number.isFinite(M) || m === null ? M : m(M);
+      d[w] = x, Number.isFinite(x) && (x < f && (f = x), x > b && (b = x));
+    }
+    const H = S ? null : e(L, w), R = H ?? Number.NaN;
+    if (a[w] = R, R < k && (k = R), R > N && (N = R), u !== null) {
+      const v = S ? null : u(L, w);
+      h[w] = v ?? Number.NaN;
+    }
+    if (l !== null) {
+      const v = S ? null : l(L, w), M = v ?? Number.NaN;
+      c[w] = M, M < k && (k = M), M > N && (N = M);
+    }
+  }
+  return { series: { x: o, y: a, y0: c, w: h, x1: d, length: r }, extent: { xMin: f, xMax: b, yMin: k, yMax: N } };
+}
+function an(n, t) {
+  for (let e = 1; e < t; e++)
+    if (n[e] < n[e - 1]) return e;
+  return -1;
+}
+function ln(n, t, e, i) {
+  let s = Number.POSITIVE_INFINITY, r = Number.NEGATIVE_INFINITY;
+  for (const o of e) {
+    const a = o.extent;
+    if (a === null || !(n === "x" ? o.xAxisId === t : o.yAxisId === t)) continue;
+    const c = n === "x" ? a.xMin : a.yMin, u = n === "x" ? a.xMax : a.yMax;
+    c < s && (s = c), u > r && (r = u);
+  }
+  if (i !== void 0)
+    for (const o of i)
+      Number.isFinite(o) && (o < s && (s = o), o > r && (r = o));
+  return !Number.isFinite(s) || !Number.isFinite(r) ? [0, 1] : [s, r];
+}
+function cn(n, t) {
+  let e = Number.POSITIVE_INFINITY;
+  for (let i = 1; i < t; i++) {
+    const s = n[i] - n[i - 1];
+    s > 0 && s < e && (e = s);
+  }
+  return Number.isFinite(e) ? e : 0;
+}
+function un(n, t) {
+  return n > 0 ? n : t;
+}
+function hn(n, t, e, i) {
+  const s = n * t, r = s / i;
+  return { offset: -s / 2 + e * r, width: r };
+}
+function dn(n) {
+  const t = /* @__PURE__ */ new Map();
+  for (const i of n) {
+    if (i.kind !== "bar") continue;
+    const s = t.get(i.xAxisId);
+    s === void 0 ? t.set(i.xAxisId, [i]) : s.push(i);
+  }
+  const e = /* @__PURE__ */ new Map();
+  for (const i of t.values()) {
+    let s = Number.POSITIVE_INFINITY;
+    for (const a of i)
+      a.step > 0 && a.step < s && (s = a.step);
+    const r = Number.isFinite(s) ? s : 0, o = i[0].fraction;
+    i.forEach((a, l) => {
+      e.set(a.order, {
+        index: l,
+        size: i.length,
+        step: r,
+        fraction: o
+      });
+    });
+  }
+  return e;
+}
+const Qt = {
+  version: 0,
+  layout: ie,
+  legend: null,
+  series: [],
+  limits: []
+}, te = {
+  version: 0,
+  hover: null,
+  tooltip: null,
+  xLabel: ""
+}, fn = 4, mn = 60;
+let vt = 0;
+const pn = new Float64Array(0), yn = new Int32Array(0);
+function z(n, t) {
+  return n === t ? !0 : typeof n != "function" || typeof t != "function" ? !1 : String(n) === String(t);
+}
+function mt(n, t) {
+  if (n === t) return !0;
+  if (n === void 0 || t === void 0 || n.length !== t.length) return !1;
+  for (let e = 0; e < n.length; e++) if (n[e] !== t[e]) return !1;
+  return !0;
+}
+function gn(n, t) {
+  return n.kind === t.kind && z(n.accessor, t.accessor) && n.data === t.data && z(Pt(n), Pt(t)) && z(Lt(n), Lt(t)) && z(Ft(n), Ft(t));
+}
+function Lt(n) {
+  return n.kind === "matrix" ? n.value : void 0;
+}
+function Ft(n) {
+  return n.kind === "span" ? n.to : void 0;
+}
+function Pt(n) {
+  switch (n.kind) {
+    case "line":
+    case "scatter":
+      return;
+    case "area":
+      return n.baseline ?? 0;
+    case "bar":
+      return 0;
+    case "state":
+    case "matrix":
+    case "span":
+      return;
+  }
+}
+function bn(n, t) {
+  if (n.kind !== t.kind) return !1;
+  switch (t.kind) {
+    case "line": {
+      const e = n;
+      return e.strokeWidth === t.strokeWidth && e.markers === t.markers && mt(e.dash, t.dash);
+    }
+    case "area": {
+      const e = n;
+      return z(e.baseline, t.baseline) && e.fillOpacity === t.fillOpacity && e.strokeWidth === t.strokeWidth;
+    }
+    case "bar":
+      return n.barWidth === t.barWidth;
+    case "scatter":
+      return n.radius === t.radius;
+    case "state": {
+      const e = n;
+      return e.laneFrom === t.laneFrom && e.laneTo === t.laneTo && xn(e.states, t.states);
+    }
+    case "matrix":
+      return vn(n.coloring, t.coloring);
+    case "span":
+      return n.height === t.height;
+  }
+}
+function xn(n, t) {
+  var e, i, s, r;
+  if (n === t) return !0;
+  if (n.length !== t.length) return !1;
+  for (let o = 0; o < n.length; o++)
+    if (((e = n[o]) == null ? void 0 : e.label) !== ((i = t[o]) == null ? void 0 : i.label) || ((s = n[o]) == null ? void 0 : s.color) !== ((r = t[o]) == null ? void 0 : r.color)) return !1;
+  return !0;
+}
+function vn(n, t) {
+  return n === t ? !0 : n.kind !== t.kind ? !1 : n.kind === "assessment" && t.kind === "assessment" ? n.limits === t.limits : n.kind === "gradient" && t.kind === "gradient" ? mt(n.stops, t.stops) && mt(n.range, t.range) : !1;
+}
+function kn(n, t) {
+  return n.kind === "assessment" ? [t.colorOk, t.colorWarning, t.colorAlarm] : n.stops;
+}
+function Nn(n, t, e) {
+  var c, u;
+  const i = n.length, s = new Int32Array(i), r = n.w;
+  if (r === null || e === 0)
+    return s.fill(-1), s;
+  if (t.kind === "assessment") {
+    for (let h = 0; h < i; h++) {
+      const p = rn(r[h], t.limits);
+      s[h] = p.verdict === "alarm" ? 2 : p.verdict === "warning" ? 1 : p.verdict === "ok" ? 0 : -1;
+    }
+    return s;
+  }
+  let o = (c = t.range) == null ? void 0 : c[0], a = (u = t.range) == null ? void 0 : u[1];
+  if (o === void 0 || a === void 0) {
+    o = Number.POSITIVE_INFINITY, a = Number.NEGATIVE_INFINITY;
+    for (let h = 0; h < i; h++) {
+      const p = r[h];
+      Number.isFinite(p) && (p < o && (o = p), p > a && (a = p));
+    }
+  }
+  const l = a - o;
+  for (let h = 0; h < i; h++) {
+    const p = r[h];
+    if (!Number.isFinite(p)) {
+      s[h] = -1;
+      continue;
+    }
+    const d = l > 0 ? (p - o) / l : 0.5, m = Math.floor(d * e);
+    s[h] = m < 0 ? 0 : m >= e ? e - 1 : m;
+  }
+  return s;
+}
+function wn(n, t) {
+  return n === t ? !0 : Array.isArray(n) && Array.isArray(t) ? n[0] === t[0] && n[1] === t[1] : !1;
+}
+class oe {
+  constructor() {
+    /* ---------- Registration ---------- */
+    g(this, "series", /* @__PURE__ */ new Map());
+    g(this, "axes", /* @__PURE__ */ new Map());
+    g(this, "legend", null);
+    g(this, "tooltip", null);
+    g(this, "limits", /* @__PURE__ */ new Map());
+    /* ---------- Data and layout inputs ---------- */
+    g(this, "data", []);
+    g(this, "padding", { top: 8, right: 8, bottom: 8, left: 8 });
+    /* ---------- DOM binding ---------- */
+    g(this, "container", null);
+    g(this, "seriesCanvas", null);
+    g(this, "overlayCanvas", null);
+    g(this, "seriesCtx", null);
+    g(this, "overlayCtx", null);
+    g(this, "tooltipEl", null);
+    g(this, "measurer", null);
+    /* ---------- Size and DPR ---------- */
+    g(this, "cssWidth", 0);
+    g(this, "cssHeight", 0);
+    g(this, "pendingWidth", null);
+    g(this, "pendingHeight", null);
+    g(this, "dpr", 1);
+    g(this, "dprMedia", null);
+    g(this, "onDprChange", () => {
+      this.rebindDprWatch(), this.pendingWidth = this.cssWidth, this.pendingHeight = this.cssHeight, this.markLayoutDirty();
+    });
+    /* ---------- Scheduling ---------- */
+    g(this, "seriesDirty", !1);
+    g(this, "overlayDirty", !1);
+    g(this, "layoutDirty", !0);
+    g(this, "materialsDirty", !1);
+    g(this, "frameHandle", null);
+    /* ---------- Theme ---------- */
+    g(this, "theme", null);
+    g(this, "unsubscribeTheme", null);
+    /* ---------- Layout and interaction ---------- */
+    g(this, "layout", ie);
+    g(this, "hysteresis", /* @__PURE__ */ new Map());
+    g(this, "hover", null);
+    g(this, "hoverKey", "");
+    g(this, "hoverXLabel", "");
+    g(this, "highlight", null);
+    /* ---------- Snapshots for the HTML layer ---------- */
+    g(this, "layoutSnapshot", Qt);
+    g(this, "hoverSnapshot", te);
+    g(this, "layoutSubscribers", /* @__PURE__ */ new Set());
+    g(this, "hoverSubscribers", /* @__PURE__ */ new Set());
+    /* ---------- Instrumentation (R-5.1) ---------- */
+    g(this, "perf", { materializeMs: 0, seriesDrawMs: 0, points: 0 });
+    /* The palette follows the name (library-audit 05). The table only grows: a name
+       that goes away keeps its place, so that it finds it again on its return and
+       no other name gets it in the meantime. */
+    g(this, "slotsByName", /* @__PURE__ */ new Map());
+    g(this, "nextSlot", 0);
+    g(this, "onPerf", null);
+    /* ================= Materialisation (R-2.6, R-2.7) ================= */
+    g(this, "sortednessChecked", !1);
+    g(this, "themeRoot", null);
+    g(this, "subscribeLayout", (t) => (this.layoutSubscribers.add(t), () => {
+      this.layoutSubscribers.delete(t);
+    }));
+    g(this, "getLayoutSnapshot", () => this.layoutSnapshot);
+    g(this, "getLayoutServerSnapshot", () => Qt);
+    g(this, "subscribeHover", (t) => (this.hoverSubscribers.add(t), () => {
+      this.hoverSubscribers.delete(t);
+    }));
+    g(this, "getHoverSnapshot", () => this.hoverSnapshot);
+    g(this, "getHoverServerSnapshot", () => te);
+  }
+  setOnPerf(t) {
+    this.onPerf = t;
+  }
+  /* ================= Registration model (R-2.1, R-2.2) ================= */
+  /** The palette place for a new registration. On the first mount, in JSX order,
+      it is the same number as the index in the registration - every registration
+      counts on, named or not. */
+  slotFor(t) {
+    if (t === void 0) return this.nextSlot++;
+    const e = this.slotsByName.get(t);
+    if (e !== void 0 && !this.slotTaken(e)) return e;
+    const i = this.nextSlot++;
+    return e === void 0 && this.slotsByName.set(t, i), i;
+  }
+  /** Is a named series currently standing on this palette place? A taken place is
+      not assigned a second time: two series of the same name standing at once
+      share no colour, and a name that a rename has left behind does not get the
+      colour of the renamed series. */
+  slotTaken(t, e) {
+    for (const i of this.series.values())
+      if (i !== e && i.config.name !== void 0 && i.slot === t) return !0;
+    return !1;
+  }
+  registerSeries(t) {
+    const e = vt++;
+    return this.series.set(e, {
+      order: e,
+      config: t,
+      slot: this.slotFor(t.name),
+      lastSlot: null,
+      materialized: null,
+      extent: null,
+      step: null,
+      cellHeight: null,
+      depth: null
+    }), this.materialsDirty = !0, this.markLayoutDirty(), e;
+  }
+  updateSeries(t, e) {
+    const i = this.series.get(t);
+    if (i === void 0) return;
+    const s = i.config, r = gn(s, e), o = r && s.xAxisId === e.xAxisId && s.yAxisId === e.yAxisId && s.name === e.name && s.color === e.color && s.tone === e.tone && bn(s, e);
+    if (s.name !== e.name && e.name !== void 0) {
+      const a = this.slotsByName.get(e.name);
+      a === void 0 ? this.slotsByName.set(e.name, i.slot) : this.slotTaken(a, i) || (i.slot = a);
+    }
+    i.config = e, !o && (r || (i.materialized = null, i.extent = null, i.step = null, i.cellHeight = null, i.depth = null, this.materialsDirty = !0), this.markLayoutDirty());
+  }
+  unregisterSeries(t) {
+    this.series.delete(t) && (this.materialsDirty = !0, this.markLayoutDirty());
+  }
+  registerAxis(t) {
+    const e = vt++;
+    return this.axes.set(e, { order: e, config: t }), this.materialsDirty = !0, this.markLayoutDirty(), e;
+  }
+  updateAxis(t, e) {
+    const i = this.axes.get(t);
+    if (i === void 0) return;
+    const s = i.config, r = z(s.accessor, e.accessor) && s.calendar === e.calendar, o = r && s.id === e.id && s.orientation === e.orientation && s.position === e.position && s.label === e.label && s.tickCount === e.tickCount && s.grid === e.grid && mt(s.ticks, e.ticks) && wn(s.domain, e.domain) && z(s.tickFormat, e.tickFormat);
+    if (i.config = e, !o) {
+      if (!r || s.id !== e.id) {
+        for (const a of this.series.values())
+          a.materialized = null, a.extent = null, a.step = null, a.cellHeight = null, a.depth = null;
+        this.materialsDirty = !0;
+      }
+      this.markLayoutDirty();
+    }
+  }
+  unregisterAxis(t) {
+    this.axes.delete(t) && (this.materialsDirty = !0, this.markLayoutDirty());
+  }
+  /* Limits register themselves like series - that is the only way a child says
+     anything in this library. They are therefore not series: no accessor, no
+     data, no legend entry, no hit. */
+  registerLimit(t) {
+    const e = vt++;
+    return this.limits.set(e, { order: e, config: t }), this.markLayoutDirty(), e;
+  }
+  updateLimit(t, e) {
+    const i = this.limits.get(t);
+    if (i === void 0) return;
+    const s = i.config;
+    i.config = e, !(s.kind === e.kind && s.axisId === e.axisId && s.orientation === e.orientation && s.severity === e.severity && s.role === e.role && s.label === e.label && s.color === e.color && s.inExtent === e.inExtent && (s.kind === "line" && e.kind === "line" ? s.value === e.value : s.kind === "band" && e.kind === "band" && s.from === e.from && s.to === e.to)) && this.markLayoutDirty();
+  }
+  unregisterLimit(t) {
+    this.limits.delete(t) && this.markLayoutDirty();
+  }
+  limitsInOrder() {
+    return [...this.limits.values()].sort((t, e) => t.order - e.order);
+  }
+  registerLegend(t) {
+    this.legend = t, this.markLayoutDirty();
+  }
+  updateLegend(t) {
+    this.legend !== null && this.legend.placement === t.placement || (this.legend = t, this.markLayoutDirty());
+  }
+  unregisterLegend() {
+    this.legend = null, this.markLayoutDirty();
+  }
+  registerTooltip(t) {
+    this.tooltip = t, this.pushHoverSnapshot();
+  }
+  updateTooltip(t) {
+    const e = this.tooltip;
+    if (e !== null && e.mode === t.mode && z(e.render, t.render)) {
+      this.tooltip = t;
+      return;
+    }
+    this.tooltip = t, this.pushHoverSnapshot();
+  }
+  unregisterTooltip() {
+    this.tooltip = null, this.hover = null, this.hoverKey = "", this.markOverlayDirty(), this.pushHoverSnapshot();
+  }
+  /** Series in registration order - the drawing order. The palette follows it
+      only on the first mount; after that it follows the name. */
+  seriesInOrder() {
+    return [...this.series.values()].sort((t, e) => t.order - e.order);
+  }
+  axesInOrder() {
+    return [...this.axes.values()].sort((t, e) => t.order - e.order);
+  }
+  /* ================= Data and container configuration ================= */
+  setData(t) {
+    if (t !== this.data) {
+      this.data = t, this.materialsDirty = !0, this.sortednessChecked = !1;
+      for (const e of this.series.values())
+        e.materialized = null, e.extent = null, e.step = null, e.cellHeight = null, e.depth = null;
+      this.markLayoutDirty();
+    }
+  }
+  setPadding(t) {
+    const e = this.padding;
+    e.top === t.top && e.right === t.right && e.bottom === t.bottom && e.left === t.left || (this.padding = t, this.markLayoutDirty());
+  }
+  /* ================= Checks (R-4.12, R-4.13) ================= */
+  /** Called from the Chart after the child effects; DEV only. */
+  validate() {
+    if (!st) return;
+    const t = /* @__PURE__ */ new Set();
+    for (const { config: r } of this.axesInOrder()) {
+      const o = `${r.orientation}:${r.id}`, a = r.orientation === "x" ? "XAxis" : "YAxis";
+      ut(
+        !t.has(o),
+        `Two <${a}> with the same id "${r.id}". A second ${a} needs an own id (R-4.12).`
+      ), t.add(o);
+    }
+    const e = /* @__PURE__ */ new Set();
+    for (const { config: r } of this.series.values())
+      ut(
+        t.has(`x:${r.xAxisId}`),
+        `Series "${r.name ?? "?"}" refers to the unknown x axis "${r.xAxisId}" (R-4.12).`
+      ), ut(
+        t.has(`y:${r.yAxisId}`),
+        `Series "${r.name ?? "?"}" refers to the unknown y axis "${r.yAxisId}" (R-4.12).`
+      ), e.add(`x:${r.xAxisId}`), e.add(`y:${r.yAxisId}`);
+    for (const r of t)
+      !e.has(r) && this.series.size > 0 && q(
+        `axis-without-series-${r}`,
+        `Axis "${r}" has no bound series; it is drawn with the domain [0, 1] (R-4.13).`
+      );
+    const i = /* @__PURE__ */ new Map();
+    for (const { config: r } of this.seriesInOrder()) {
+      if (r.kind !== "bar") continue;
+      const o = i.get(r.xAxisId);
+      o === void 0 ? i.set(r.xAxisId, r.barWidth) : o !== r.barWidth && q(
+        `bar-width-${r.xAxisId}`,
+        `Bars on the x axis "${r.xAxisId}" give different barWidth. A group shares one width fraction; that of the first (${o}) applies (ADR-0002).`
+      );
+    }
+    let s = 0;
+    for (const r of this.axesInOrder()) r.config.grid === !0 && s++;
+    s > 1 && q(
+      "multiple-grids",
+      "More than one axis draws grid. Unaligned grids compete visually; there is no tick alignment between axes in V0 (R-4.15)."
+    );
+  }
+  findXAxis(t) {
+    for (const { config: e } of this.axes.values())
+      if (e.orientation === "x" && e.id === t) return e;
+    return null;
+  }
+  materialize() {
+    const t = typeof performance > "u" ? 0 : performance.now();
+    let e = 0;
+    for (const i of this.series.values()) {
+      if (i.materialized !== null) {
+        e += i.materialized.length;
+        continue;
+      }
+      const s = i.config, r = s.data ?? this.data, o = this.findXAxis(s.xAxisId);
+      if (o === null) continue;
+      const a = on(
+        r,
+        o.accessor,
+        s.accessor,
+        Pt(s),
+        {
+          value: Lt(s),
+          xEnd: Ft(s),
+          xMap: this.mapFor(o),
+          xGap: this.gapFor(o)
+        }
+      );
+      if (i.materialized = a.series, e += a.series.length, s.kind === "bar") {
+        const l = cn(a.series.x, a.series.length);
+        i.step = l;
+        const c = l / 2;
+        i.extent = {
+          ...a.extent,
+          xMin: a.extent.xMin - c,
+          xMax: a.extent.xMax + c
+        };
+      } else if (s.kind === "matrix") {
+        const l = Jt(a.series.x, a.series.length), c = Jt(a.series.y, a.series.length);
+        i.step = l, i.cellHeight = c, i.extent = {
+          xMin: a.extent.xMin - l / 2,
+          xMax: a.extent.xMax + l / 2,
+          yMin: a.extent.yMin - c / 2,
+          yMax: a.extent.yMax + c / 2
+        };
+      } else if (s.kind === "state")
+        i.step = null, i.extent = {
+          ...a.extent,
+          yMin: Number.POSITIVE_INFINITY,
+          yMax: Number.NEGATIVE_INFINITY
+        };
+      else if (s.kind === "span") {
+        i.depth = Ye(
+          a.series.x,
+          a.series.x1 ?? new Float64Array(a.series.length),
+          a.series.length,
+          // The end of the domain is not yet fixed at materialisation time. The
+          // covering of an open span reaches to the end of everything there is -
+          // and that is exactly the value it gets here.
+          a.extent.xMax
+        );
+        const l = (s.height ?? 0.6) / 2;
+        i.step = null, i.extent = {
+          ...a.extent,
+          yMin: a.extent.yMin - l,
+          yMax: a.extent.yMax + l
+        };
+      } else
+        i.step = null, i.extent = a.extent;
+      if (!this.sortednessChecked && st) {
+        this.sortednessChecked = !0;
+        const l = an(a.series.x, a.series.length);
+        l >= 0 && q(
+          "x-unsorted",
+          `X values are not sorted ascending (index ${l}). Binary search and path building assume sortedness; there is no automatic sorting (R-2.6).`
+        );
+      }
+    }
+    this.materialsDirty = !1, this.perf.materializeMs = (typeof performance > "u" ? 0 : performance.now()) - t, this.perf.points = e;
+  }
+  /* ================= DOM binding, DPR, resize ================= */
+  bind(t, e, i, s) {
+    this.container = t, this.themeRoot = s, this.seriesCanvas = e, this.overlayCanvas = i, this.seriesCtx = e.getContext("2d"), this.overlayCtx = i.getContext("2d"), this.measurer = new Me(s), this.dpr = typeof devicePixelRatio == "number" ? devicePixelRatio : 1, this.rebindDprWatch(), this.unsubscribeTheme = Ie(() => {
+      var r;
+      this.theme = null, (r = this.measurer) == null || r.clear(), this.markLayoutDirty();
+    }), this.theme = null, this.markLayoutDirty();
+  }
+  bindTooltip(t) {
+    this.tooltipEl = t;
+  }
+  unbind() {
+    var t, e, i;
+    this.frameHandle !== null && typeof cancelAnimationFrame == "function" && (cancelAnimationFrame(this.frameHandle), this.frameHandle = null), (t = this.dprMedia) == null || t.removeEventListener("change", this.onDprChange), this.dprMedia = null, (e = this.unsubscribeTheme) == null || e.call(this), this.unsubscribeTheme = null, (i = this.measurer) == null || i.remove(), this.measurer = null, this.container = null, this.themeRoot = null, this.seriesCanvas = null, this.overlayCanvas = null, this.seriesCtx = null, this.overlayCtx = null, this.tooltipEl = null;
+  }
+  /** Detect a change of DPR (a change of monitor): rebind matchMedia (R-2.9). */
+  rebindDprWatch() {
+    var t;
+    typeof matchMedia == "function" && ((t = this.dprMedia) == null || t.removeEventListener("change", this.onDprChange), this.dpr = typeof devicePixelRatio == "number" ? devicePixelRatio : 1, this.dprMedia = matchMedia(`(resolution: ${this.dpr}dppx)`), this.dprMedia.addEventListener("change", this.onDprChange));
+  }
+  /** Called by the ResizeObserver; coalesced onto one rAF (R-2.10). */
+  requestResize(t, e) {
+    t === this.cssWidth && e === this.cssHeight || (this.pendingWidth = t, this.pendingHeight = e, this.markLayoutDirty());
+  }
+  applyPendingSize() {
+    if (this.pendingWidth === null || this.pendingHeight === null) return;
+    this.cssWidth = this.pendingWidth, this.cssHeight = this.pendingHeight, this.pendingWidth = null, this.pendingHeight = null;
+    const { seriesCanvas: t, overlayCanvas: e, seriesCtx: i, overlayCtx: s, dpr: r } = this;
+    if (!t || !e || !i || !s) return;
+    const o = Math.max(0, Math.round(this.cssWidth * r)), a = Math.max(0, Math.round(this.cssHeight * r));
+    for (const l of [t, e])
+      l.width = o, l.height = a, l.style.width = `${this.cssWidth}px`, l.style.height = `${this.cssHeight}px`;
+    i.setTransform(r, 0, 0, r, 0, 0), s.setTransform(r, 0, 0, r, 0, 0);
+  }
+  /* ================= Scheduling (R-2.11) ================= */
+  markSeriesDirty() {
+    this.seriesDirty = !0, this.requestFrame();
+  }
+  markOverlayDirty() {
+    this.overlayDirty = !0, this.requestFrame();
+  }
+  /** A layout-relevant change: it pulls the series and the overlay layer with
+      it. */
+  markLayoutDirty() {
+    this.layoutDirty = !0, this.seriesDirty = !0, this.overlayDirty = !0, this.requestFrame();
+  }
+  requestFrame() {
+    this.frameHandle === null && this.container !== null && typeof requestAnimationFrame == "function" && (this.frameHandle = requestAnimationFrame(() => {
+      this.frameHandle = null, this.frame();
+    }));
+  }
+  frame() {
+    if (this.applyPendingSize(), this.theme === null && this.themeRoot !== null && (this.theme = Ne(this.themeRoot)), this.cssWidth <= 0 || this.cssHeight <= 0) {
+      this.layoutDirty && this.pushLayoutSnapshot();
+      return;
+    }
+    this.materialsDirty && this.materialize(), this.layoutDirty && (this.updateLayout(), this.layoutDirty = !1, this.pushLayoutSnapshot()), this.seriesDirty && (this.drawSeriesLayer(), this.seriesDirty = !1), this.overlayDirty && (this.drawOverlayLayer(), this.overlayDirty = !1);
+  }
+  /* ================= Layout ================= */
+  /** The effective grid default: only the first registered axis per orientation
+      (R-4.15). */
+  gridDefault() {
+    const t = /* @__PURE__ */ new Map();
+    let e = !0, i = !0;
+    for (const [s, r] of [...this.axes.entries()].sort((o, a) => o[1].order - a[1].order)) {
+      const o = r.config.orientation === "x" ? e : i;
+      t.set(s, r.config.grid ?? o), r.config.orientation === "x" ? e = !1 : i = !1;
+    }
+    return t;
+  }
+  /** Extent of an axis out of the series bound to it (R-4.13).
+  
+        Materialises on demand and manages without the DOM - that is the seam at
+        which extents across series kinds can be tested without asking a canvas.
+        The layout path calls extentFor directly. */
+  axisExtent(t, e) {
+    this.materialsDirty && this.materialize();
+    const i = [...this.series.values()].map((s) => ({
+      xAxisId: s.config.xAxisId,
+      yAxisId: s.config.yAxisId,
+      extent: s.extent
+    }));
+    return ln(t, e, i, this.limitValues(t, e));
+  }
+  /** The values of the limits that are to pull this axis along. */
+  limitValues(t, e) {
+    const i = [];
+    for (const { config: s } of this.limits.values())
+      s.inExtent && (s.orientation !== t || s.axisId !== e || (s.kind === "line" ? i.push(s.value) : i.push(s.from, s.to)));
+    return i;
+  }
+  /** Pre-mapping of the x values of an axis with an operating calendar. The scale
+      stays affine; the mapping happens beforehand, once per point, in
+      materialisation - exactly the route ADR-0001 prescribes for a non-affine
+      axis. */
+  mapFor(t) {
+    const e = t.calendar;
+    if (!(e === void 0 || e.length === 0))
+      return (i) => Ee(i, e);
+  }
+  gapFor(t) {
+    const e = t.calendar;
+    if (!(e === void 0 || e.length === 0))
+      return (i) => De(i, e);
+  }
+  extentFor(t) {
+    return this.axisExtent(t.orientation, t.id);
+  }
+  updateLayout() {
+    const t = this.measurer, e = this.gridDefault(), i = [];
+    for (const [s, r] of [...this.axes.entries()].sort((o, a) => o[1].order - a[1].order)) {
+      const o = r.config;
+      i.push({
+        key: `${o.orientation}:${o.id}`,
+        id: o.id,
+        orientation: o.orientation,
+        position: o.position,
+        label: o.label,
+        grid: e.get(s) ?? !1,
+        extent: this.extentFor(o),
+        domainMode: o.domain,
+        tickCount: o.tickCount,
+        tickFormat: o.tickFormat,
+        tickValues: o.ticks,
+        calendar: o.calendar
+      });
+    }
+    this.layout = _e({
+      width: this.cssWidth,
+      height: this.cssHeight,
+      padding: this.padding,
+      axes: i,
+      measure: (s, r) => t === null ? { width: 0, height: 0 } : t.measure(s, r),
+      hysteresis: this.hysteresis
+    });
+  }
+  findAxis(t, e) {
+    for (const i of this.layout.axes)
+      if (i.orientation === t && i.id === e) return i;
+    return null;
+  }
+  /* ================= Series colours and legend entries ================= */
+  colorFor(t, e) {
+    var r;
+    if (t.config.color !== void 0) return t.config.color;
+    const i = t.config.tone;
+    if (i !== void 0) {
+      const o = this.theme ?? W;
+      return i === "alarm" ? o.colorAlarm : i === "warning" ? o.colorWarning : o.colorOk;
+    }
+    const s = ((r = this.theme) == null ? void 0 : r.series) ?? W.series;
+    return s[this.paletteSlot(t, e) % Math.max(1, s.length)] ?? W.series[0] ?? "#2563eb";
+  }
+  /** Named: the place of the name. Nameless: the index in the registration, as
+      before - and a warning as soon as that shifts underneath it. */
+  paletteSlot(t, e) {
+    return t.config.name !== void 0 ? t.slot : (t.lastSlot !== null && t.lastSlot !== e && q(
+      "series-without-name-colour",
+      "a series without a name has changed its colour, because a series before it went away - with `name` it keeps it."
+    ), t.lastSlot = e, e);
+  }
+  nameFor(t, e) {
+    return t.config.name !== void 0 ? t.config.name : (q(
+      "series-without-name",
+      `a series without a name is called "Series ${e + 1}" in the legend and the tooltip - the name belongs in \`name\`.`
+    ), `Series ${e + 1}`);
+  }
+  legendItems() {
+    const t = [], e = /* @__PURE__ */ new Set();
+    return this.seriesInOrder().forEach((i, s) => {
+      const r = i.config;
+      if (r.kind === "state") {
+        r.states.forEach((o, a) => {
+          const l = `${o.label}\0${o.color}`;
+          e.has(l) || (e.add(l), t.push({
+            id: `${i.order}:${a}`,
+            name: o.label,
+            color: o.color,
+            seriesId: i.order
+          }));
+        });
+        return;
+      }
+      t.push({
+        id: String(i.order),
+        name: this.nameFor(i, s),
+        color: this.colorFor(i, s),
+        seriesId: i.order
+      });
+    }), t;
+  }
+  /* ---------- Limits, ready in pixels ---------- */
+  limitColor(t, e) {
+    return t.color !== void 0 ? t.color : t.role === "control" ? e.colorAxis : t.role === "zone" ? e.colorGrid : t.severity === "alarm" ? e.colorAlarm : e.colorWarning;
+  }
+  /** Dash pattern per role. The reader has to be able to see at a glance whether
+      the problem is the process or the tolerance. */
+  limitDash(t) {
+    switch (t.role) {
+      case "control":
+        return [];
+      case "zone":
+        return [2, 3];
+      default:
+        return [4, 3];
+    }
+  }
+  limitItems(t) {
+    const e = this.theme ?? W, i = [];
+    for (const { config: s } of this.limitsInOrder()) {
+      if (s.kind === "band" !== t) continue;
+      const r = this.findAxis(s.orientation, s.axisId);
+      if (r === null) continue;
+      const o = this.limitColor(s, e), a = this.limitDash(s);
+      if (s.kind === "band")
+        i.push({
+          orientation: s.orientation,
+          fromPx: r.scale.toPx(s.from),
+          toPx: r.scale.toPx(s.to),
+          color: o,
+          band: !0,
+          dash: a
+        });
+      else {
+        const l = r.scale.toPx(s.value);
+        i.push({
+          orientation: s.orientation,
+          fromPx: l,
+          toPx: l,
+          color: o,
+          band: !1,
+          dash: a
+        });
+      }
+    }
+    return i;
+  }
+  /** Labelled limits for the HTML layer: position and colour, ready. */
+  limitLabels() {
+    const t = [];
+    for (const { order: e, config: i } of this.limitsInOrder()) {
+      if (i.label === void 0 || i.label === "") continue;
+      const s = this.findAxis(i.orientation, i.axisId);
+      if (s === null) continue;
+      const r = i.kind === "line" ? i.value : (i.from + i.to) / 2;
+      t.push({
+        id: e,
+        axisKey: s.key,
+        px: s.scale.toPx(r),
+        label: i.label,
+        severity: i.severity,
+        role: i.role
+      });
+    }
+    return t;
+  }
+  /* ================= Drawing ================= */
+  drawItems() {
+    const t = [], e = this.seriesInOrder(), i = dn(
+      e.map((s) => ({
+        order: s.order,
+        kind: s.config.kind,
+        xAxisId: s.config.xAxisId,
+        step: s.step ?? 0,
+        fraction: s.config.kind === "bar" ? s.config.barWidth : 0
+      }))
+    );
+    return e.forEach((s, r) => {
+      const o = s.materialized;
+      if (o === null) return;
+      const a = this.findAxis("x", s.config.xAxisId), l = this.findAxis("y", s.config.yAxisId);
+      if (a === null || l === null) return;
+      const c = this.highlight !== null && this.highlight !== s.order, u = {
+        x: o.x,
+        y: o.y,
+        length: o.length,
+        xScale: a.scale,
+        yScale: l.scale,
+        color: this.colorFor(s, r),
+        alpha: c ? 0.25 : 1
+      }, h = s.config;
+      switch (h.kind) {
+        case "line":
+          t.push({
+            ...u,
+            kind: "line",
+            strokeWidth: h.strokeWidth,
+            dash: h.dash,
+            marker: h.markers === "always" || h.markers === "auto" && o.length <= mn
+          });
+          break;
+        case "area":
+          t.push({
+            ...u,
+            kind: "area",
+            y0: o.y0,
+            baseline: 0,
+            fillOpacity: h.fillOpacity,
+            strokeWidth: h.strokeWidth
+          });
+          break;
+        case "bar": {
+          const p = i.get(s.order) ?? {
+            index: 0,
+            size: 1,
+            step: s.step ?? 0,
+            fraction: h.barWidth
+          }, d = a.scale.domain, m = hn(
+            un(p.step, d[1] - d[0]),
+            p.fraction,
+            p.index,
+            p.size
+          );
+          t.push({
+            ...u,
+            kind: "bar",
+            baseline: 0,
+            offset: m.offset,
+            width: m.width
+          });
+          break;
+        }
+        case "scatter":
+          t.push({ ...u, kind: "scatter", radius: h.radius });
+          break;
+        case "state": {
+          const p = this.lanePx(h, l);
+          t.push({
+            ...u,
+            kind: "state",
+            colors: h.states.map((d) => d.color),
+            laneTop: p.top,
+            laneBottom: p.bottom,
+            domainEnd: a.scale.domain[1]
+          });
+          break;
+        }
+        case "matrix": {
+          const p = kn(h.coloring, this.theme ?? W);
+          t.push({
+            ...u,
+            kind: "matrix",
+            buckets: Nn(o, h.coloring, p.length),
+            colors: p,
+            width: ct(
+              s.step ?? 0,
+              a.scale.domain[1] - a.scale.domain[0]
+            ),
+            height: ct(
+              s.cellHeight ?? 0,
+              l.scale.domain[1] - l.scale.domain[0]
+            )
+          });
+          break;
+        }
+        case "span": {
+          t.push({
+            ...u,
+            kind: "span",
+            x1: o.x1 ?? pn,
+            // Computed once per materialisation, not per frame: the calculation
+            // is quadratic, and a schedule with five hundred spans is pushed and
+            // pulled like any other chart.
+            depth: s.depth ?? yn,
+            height: h.height ?? 0.6,
+            domainEnd: a.scale.domain[1]
+          });
+          break;
+        }
+      }
+    }), t;
+  }
+  /** Lane of a state series in pixels. Without a value the whole domain of its y
+      axis: a single series fills its band, a stack gets a domain with one unit per
+      machine from the caller. */
+  lanePx(t, e) {
+    const i = e.scale.domain, s = e.scale.toPx(t.laneFrom ?? i[0]), r = e.scale.toPx(t.laneTo ?? i[1]);
+    return { top: Math.min(s, r), bottom: Math.max(s, r) };
+  }
+  drawSeriesLayer() {
+    var s;
+    const t = this.seriesCtx, e = this.theme;
+    if (!t || !e) return;
+    const i = typeof performance > "u" ? 0 : performance.now();
+    Qe(t, {
+      width: this.cssWidth,
+      height: this.cssHeight,
+      plot: this.layout.plot,
+      axes: this.layout.axes,
+      theme: e,
+      series: this.drawItems(),
+      limitBands: this.limitItems(!0),
+      limitLines: this.limitItems(!1)
+    }), this.perf.seriesDrawMs = (typeof performance > "u" ? 0 : performance.now()) - i, (s = this.onPerf) == null || s.call(this, { ...this.perf });
+  }
+  drawOverlayLayer() {
+    const t = this.overlayCtx, e = this.theme;
+    !t || !e || (tn(t, {
+      width: this.cssWidth,
+      height: this.cssHeight,
+      plot: this.layout.plot,
+      theme: e,
+      hover: this.hover
+    }), this.positionTooltip());
+  }
+  /* ================= Interaction (4.4) ================= */
+  setHighlight(t) {
+    this.highlight !== t && (this.highlight = t, this.markSeriesDirty());
+  }
+  inPlot(t, e) {
+    const i = this.layout.plot;
+    return t >= i.x && t <= i.x + i.width && e >= i.y && e <= i.y + i.height;
+  }
+  pointerMove(t, e) {
+    if (this.tooltip === null) return;
+    if (!this.inPlot(t, e)) {
+      this.pointerLeave();
+      return;
+    }
+    const i = this.hitTest(t, e);
+    if (i === null) {
+      this.pointerLeave();
+      return;
+    }
+    const s = i.key;
+    this.hover = i.state, this.hover.mouseX = t, this.hover.mouseY = e, this.markOverlayDirty(), s !== this.hoverKey && (this.hoverKey = s, this.hoverXLabel = i.xLabel, this.pushHoverSnapshot());
+  }
+  pointerLeave() {
+    this.hover === null && this.hoverKey === "" || (this.hover = null, this.hoverKey = "", this.markOverlayDirty(), this.pushHoverSnapshot());
+  }
+  hitTest(t, e) {
+    var y;
+    const i = ((y = this.tooltip) == null ? void 0 : y.mode) ?? "x", s = [];
+    if (this.seriesInOrder().forEach((f, b) => {
+      const k = f.materialized;
+      if (k === null || k.length === 0) return;
+      const N = f.config, w = this.findAxis("x", N.xAxisId), L = this.findAxis("y", N.yAxisId);
+      if (w === null || L === null) return;
+      const F = w.scale.fromPx(t), P = L.scale.fromPx(e), S = this.hitIn(f, k, w, L, e, F, P);
+      S !== null && s.push({
+        entry: f,
+        index: S.index,
+        color: S.color ?? this.colorFor(f, b),
+        name: this.nameFor(f, b),
+        px: S.px,
+        py: S.py,
+        xValue: S.xValue,
+        yValue: S.yValue,
+        marked: S.marked,
+        areal: S.areal,
+        value: S.value,
+        segment: S.segment
+      });
+    }), s.length === 0) return null;
+    const r = s.filter((f) => !f.areal), o = r.length > 0 ? r : s;
+    let a = o[0];
+    if (i === "nearest") {
+      let f = Number.POSITIVE_INFINITY;
+      for (const b of s) {
+        const k = b.areal ? 0 : b.px - t, N = b.areal ? 0 : b.py - e, w = k * k + N * N;
+        w < f && (f = w, a = b);
+      }
+    } else {
+      let f = Number.POSITIVE_INFINITY;
+      for (const b of o) {
+        const k = Math.abs(b.px - t);
+        k < f && (f = k, a = b);
+      }
+    }
+    const l = i === "nearest" ? [a] : s.filter(
+      // An area is always included: it covers the pointer, otherwise it
+      // would not have reported a hit at all. Only points have to share the
+      // x position.
+      (f) => f.areal || Math.abs(f.px - a.px) <= fn
+    ), c = l.map((f) => ({
+      seriesName: f.name,
+      color: f.color,
+      yValue: f.yValue,
+      datum: (f.entry.config.data ?? this.data)[f.index],
+      index: f.index,
+      value: f.value,
+      segment: f.segment
+    })), h = {
+      hit: {
+        xValue: a.xValue,
+        points: c,
+        xPx: a.px,
+        yPx: a.py
+      },
+      marker: l.filter((f) => f.marked).map((f) => ({ x: f.px, y: f.py, color: f.color })),
+      mouseX: t,
+      mouseY: e
+    }, p = l.map((f) => `${f.entry.order}:${f.index}`).join("|"), d = this.findAxis("x", a.entry.config.xAxisId), m = d === null ? String(a.xValue) : d.format(a.xValue);
+    return { key: p, state: h, xLabel: m };
+  }
+  /** The hit of one series - one different question per kind.
+  
+        Every mark that is a point asks "which point lies nearest". A band, a cell
+        and a span ask "what lies under the pointer", and that is not the same
+        question: for the right half of every segment the nearest point gives the
+        wrong answer. */
+  hitIn(t, e, i, s, r, o, a) {
+    const l = t.config, c = e.length;
+    if (l.kind === "state") {
+      const d = this.lanePx(l, s);
+      if (r < d.top || r > d.bottom) return null;
+      const m = Be(e.x, c, o);
+      if (m < 0) return null;
+      const y = e.y[m];
+      if (Number.isNaN(y)) return null;
+      const f = e.x[m], b = se(e.x, c, m, i.scale.domain[1]), k = l.states[y | 0];
+      return {
+        index: m,
+        px: i.scale.toPx(f),
+        py: (d.top + d.bottom) / 2,
+        xValue: f,
+        yValue: y,
+        marked: !1,
+        areal: !0,
+        color: k == null ? void 0 : k.color,
+        segment: { from: f, to: b, label: (k == null ? void 0 : k.label) ?? "", open: !1 }
+      };
+    }
+    if (l.kind === "span") {
+      const d = e.x1;
+      if (d === null) return null;
+      const m = i.scale.domain[1], y = l.height ?? 0.6, f = ze(
+        e.x,
+        d,
+        e.y,
+        c,
+        o,
+        a,
+        y,
+        m
+      );
+      if (f < 0) return null;
+      const b = e.x[f], k = e.y[f], N = d[f];
+      return {
+        index: f,
+        px: i.scale.toPx(b),
+        py: s.scale.toPx(k),
+        xValue: b,
+        yValue: k,
+        marked: !1,
+        areal: !0,
+        segment: {
+          from: b,
+          to: rt(N, m),
+          label: "",
+          open: re(N)
+        }
+      };
+    }
+    if (l.kind === "matrix") {
+      const d = nn(
+        e.x,
+        e.y,
+        c,
+        o,
+        a,
+        ct(t.step ?? 0, i.scale.domain[1] - i.scale.domain[0]),
+        ct(t.cellHeight ?? 0, s.scale.domain[1] - s.scale.domain[0])
+      );
+      if (d < 0) return null;
+      const m = e.w, y = m === null ? Number.NaN : m[d];
+      if (!Number.isFinite(y)) return null;
+      const f = e.x[d], b = e.y[d];
+      return {
+        index: d,
+        px: i.scale.toPx(f),
+        py: s.scale.toPx(b),
+        xValue: f,
+        // yValue stays the position on the y axis; the value that carries the
+        // colour stands in a field of its own. Colour alone can transport no
+        // number - which is why the tooltip has to carry it.
+        yValue: b,
+        value: y,
+        marked: !1,
+        areal: !0
+      };
+    }
+    const u = en(e.x, c, o);
+    if (u < 0) return null;
+    const h = e.y[u];
+    if (Number.isNaN(h)) return null;
+    const p = e.x[u];
+    return {
+      index: u,
+      px: i.scale.toPx(p),
+      py: s.scale.toPx(h),
+      xValue: p,
+      yValue: h,
+      marked: !0,
+      areal: !1
+    };
+  }
+  /** R-4.9: 12 px to the right of the crosshair, flipping at the right edge,
+      clamped vertically. */
+  positionTooltip() {
+    const t = this.tooltipEl;
+    if (t === null) return;
+    const e = this.hover;
+    if (e === null) {
+      t.style.opacity = "0";
+      return;
+    }
+    const i = t.offsetWidth, s = t.offsetHeight;
+    let r = e.hit.xPx + 12;
+    r + i > this.cssWidth && (r = e.hit.xPx - 12 - i), r < 0 && (r = 0);
+    let o = e.mouseY - s / 2;
+    o = Math.min(Math.max(o, 0), Math.max(0, this.cssHeight - s)), t.style.transform = `translate3d(${Math.round(r)}px, ${Math.round(o)}px, 0)`, t.style.opacity = "1";
+  }
+  /* ================= Snapshots for the HTML layer ================= */
+  pushLayoutSnapshot() {
+    this.layoutSnapshot = {
+      version: this.layoutSnapshot.version + 1,
+      layout: this.layout,
+      legend: this.legend,
+      series: this.legendItems(),
+      limits: this.limitLabels()
+    };
+    for (const t of this.layoutSubscribers) t();
+  }
+  pushHoverSnapshot() {
+    this.hoverSnapshot = {
+      version: this.hoverSnapshot.version + 1,
+      hover: this.hover,
+      tooltip: this.tooltip,
+      xLabel: this.hoverXLabel
+    };
+    for (const t of this.hoverSubscribers) t();
+  }
+}
+/** Class name of the measuring span for tick labels - keeps the CSS and the
+    layout in step. */
+g(oe, "classTick", ht);
+const ae = pe(null);
+function tt(n) {
+  const t = ye(ae);
+  if (t === null && st)
+    throw new Error(
+      `@umriss-ui/charts: <${n}> must be used inside a <Chart>.`
+    );
+  return t;
+}
+function J(n, t) {
+  const e = tt(n), i = Z(null);
+  D(() => {
+    if (e !== null)
+      return i.current = e.registerSeries(t), () => {
+        i.current !== null && e.unregisterSeries(i.current), i.current = null;
+      };
+  }, [e]), D(() => {
+    e !== null && i.current !== null && e.updateSeries(i.current, t);
+  });
+}
+function le(n, t) {
+  const e = tt(n), i = Z(null);
+  D(() => {
+    if (e !== null)
+      return i.current = e.registerAxis(t), () => {
+        i.current !== null && e.unregisterAxis(i.current), i.current = null;
+      };
+  }, [e]), D(() => {
+    e !== null && i.current !== null && e.updateAxis(i.current, t);
+  });
+}
+function ce(n, t) {
+  const e = tt(n), i = Z(null);
+  D(() => {
+    if (e !== null)
+      return i.current = e.registerLimit(t), () => {
+        i.current !== null && e.unregisterLimit(i.current), i.current = null;
+      };
+  }, [e]), D(() => {
+    e !== null && i.current !== null && e.updateLimit(i.current, t);
+  });
+}
+function In(n, t) {
+  const e = tt(n);
+  D(() => {
+    if (e !== null)
+      return e.registerLegend(t), () => e.unregisterLegend();
+  }, [e]), D(() => {
+    e == null || e.updateLegend(t);
+  });
+}
+function Sn(n, t) {
+  const e = tt(n);
+  D(() => {
+    if (e !== null)
+      return e.registerTooltip(t), () => e.unregisterTooltip();
+  }, [e]), D(() => {
+    e == null || e.updateTooltip(t);
+  });
+}
+function Mn(n, t) {
+  const { band: e, position: i, orientation: s } = n, r = {
+    left: `${e.x}px`,
+    top: `${e.y}px`,
+    width: `${e.width}px`,
+    height: `${e.height}px`
+  }, o = Tt + At;
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      className: `kc-axis kc-axis-${s} kc-axis-${i}`,
+      style: r,
+      "data-axis": n.id,
+      children: [
+        /* @__PURE__ */ I("span", { className: "kc-axis-line" }),
+        n.ticks.map((a) => {
+          if (s === "y") {
+            const c = Math.round(a.px - e.y);
+            return /* @__PURE__ */ B("span", { className: "kc-tick", style: { top: `${c}px` }, children: [
+              /* @__PURE__ */ I("span", { className: "kc-tick-mark" }),
+              /* @__PURE__ */ I(
+                "span",
+                {
+                  className: "kc-tick-label",
+                  style: { [i === "left" ? "right" : "left"]: `${o}px` },
+                  children: a.label
+                }
+              )
+            ] }, a.value);
+          }
+          const l = Math.round(a.px - e.x);
+          return /* @__PURE__ */ B("span", { className: "kc-tick", style: { left: `${l}px` }, children: [
+            /* @__PURE__ */ I("span", { className: "kc-tick-mark" }),
+            /* @__PURE__ */ I(
+              "span",
+              {
+                className: "kc-tick-label",
+                style: {
+                  left: `${Math.round(a.labelLeft - e.x) - l}px`,
+                  [i === "top" ? "bottom" : "top"]: `${o}px`
+                },
+                children: a.label
+              }
+            )
+          ] }, a.value);
+        }),
+        n.breaks.map((a, l) => /* @__PURE__ */ I(
+          "span",
+          {
+            className: "kc-break",
+            style: { left: `${Math.round(a - e.x)}px` },
+            "aria-hidden": "true"
+          },
+          `break-${l}`
+        )),
+        t.map(
+          (a) => s === "y" ? /* @__PURE__ */ I(
+            "span",
+            {
+              className: "kc-limit-label",
+              "data-severity": a.severity,
+              "data-role": a.role,
+              style: { top: `${Math.round(a.px - e.y)}px` },
+              children: a.label
+            },
+            `limit-${a.id}`
+          ) : /* @__PURE__ */ I(
+            "span",
+            {
+              className: "kc-limit-label",
+              "data-severity": a.severity,
+              "data-role": a.role,
+              style: {
+                left: `${Math.round(a.px - e.x)}px`,
+                [i === "top" ? "bottom" : "top"]: `${o}px`
+              },
+              children: a.label
+            },
+            `limit-${a.id}`
+          )
+        ),
+        n.label !== void 0 && n.label !== "" && /* @__PURE__ */ I("span", { className: "kc-axis-title", children: n.label })
+      ]
+    },
+    n.key
+  );
+}
+function Tn({ scene: n }) {
+  const t = Et(
+    n.subscribeLayout,
+    n.getLayoutSnapshot,
+    n.getLayoutServerSnapshot
+  ), { layout: e } = t;
+  return e.plot.width <= 0 || e.plot.height <= 0 ? null : /* @__PURE__ */ I("div", { className: "kc-axes", children: e.axes.map(
+    (i) => Mn(
+      i,
+      t.limits.filter((s) => s.axisKey === i.key)
+    )
+  ) });
+}
+function An(n) {
+  var e;
+  const t = (e = n.segment) == null ? void 0 : e.label;
+  return t !== void 0 && t !== "" ? t : n.value !== void 0 ? _t(n.value) : _t(n.yValue);
+}
+function Ln({ scene: n }) {
+  const t = Et(
+    n.subscribeHover,
+    n.getHoverSnapshot,
+    n.getHoverServerSnapshot
+  ), e = ge(
+    (s) => {
+      n.bindTooltip(s);
+    },
+    [n]
+  );
+  if (D(() => {
+    n.markOverlayDirty();
+  }, [n, t.version]), t.tooltip === null) return null;
+  const i = t.hover;
+  return /* @__PURE__ */ I("div", { className: "kc-tooltip", ref: e, role: "presentation", children: i === null ? null : t.tooltip.render !== void 0 ? t.tooltip.render(i.hit) : /* @__PURE__ */ B(Nt, { children: [
+    /* @__PURE__ */ I("div", { className: "kc-tooltip-head", children: t.xLabel }),
+    /* @__PURE__ */ I("div", { className: "kc-tooltip-list", children: i.hit.points.map((s) => /* @__PURE__ */ B("div", { className: "kc-tooltip-row", children: [
+      /* @__PURE__ */ I("span", { className: "kc-tooltip-chip", style: { background: s.color } }),
+      /* @__PURE__ */ I("span", { className: "kc-tooltip-name", children: s.seriesName }),
+      /* @__PURE__ */ I("span", { className: "kc-tooltip-value", children: An(s) })
+    ] }, `${s.seriesName}-${s.index}`)) })
+  ] }) });
+}
+function Zn(n) {
+  const {
+    data: t,
+    width: e = "100%",
+    height: i = 300,
+    padding: s = 8,
+    ariaLabel: r,
+    className: o,
+    style: a,
+    onPerf: l,
+    children: c
+  } = n, [u] = be(() => new oe()), h = Z(null), p = Z(null), d = Z(null), m = Z(null), y = typeof s == "number" ? void 0 : s, f = typeof s == "number" ? s : void 0, b = f ?? (y == null ? void 0 : y.top), k = f ?? (y == null ? void 0 : y.right), N = f ?? (y == null ? void 0 : y.bottom), w = f ?? (y == null ? void 0 : y.left), L = E(
+    () => ({
+      top: b ?? 8,
+      right: k ?? 8,
+      bottom: N ?? 8,
+      left: w ?? 8
+    }),
+    [b, k, N, w]
+  );
+  r === void 0 && q(
+    "chart-arialabel",
+    "Chart without ariaLabel - please set a meaningful description (R-7.6)."
+  ), D(() => {
+    const S = h.current, H = p.current, R = d.current, v = m.current;
+    if (!S || !H || !R || !v) return;
+    u.bind(H, R, v, S);
+    const M = H.getBoundingClientRect();
+    u.requestResize(M.width, M.height);
+    const x = new ResizeObserver(($) => {
+      var C;
+      const T = $[$.length - 1];
+      if (T === void 0) return;
+      const O = (C = T.contentBoxSize) == null ? void 0 : C[0];
+      O !== void 0 ? u.requestResize(O.inlineSize, O.blockSize) : u.requestResize(T.contentRect.width, T.contentRect.height);
+    });
+    x.observe(H);
+    const A = () => u.pointerLeave();
+    return window.addEventListener("blur", A), () => {
+      window.removeEventListener("blur", A), x.disconnect(), u.unbind();
+    };
+  }, [u]), D(() => {
+    u.setData(t);
+  }, [u, t]), D(() => {
+    u.setPadding(L);
+  }, [u, L]), D(() => {
+    u.setOnPerf(l ?? null);
+  }, [u, l]), D(() => {
+    u.validate();
+  });
+  const F = {
+    width: e === "100%" ? "100%" : `${e}px`,
+    height: `${i}px`,
+    ...a
+  }, P = (S) => {
+    u.pointerMove(S.nativeEvent.offsetX, S.nativeEvent.offsetY);
+  };
+  return /* @__PURE__ */ I(ae.Provider, { value: u, children: /* @__PURE__ */ B(
+    "div",
+    {
+      ref: h,
+      className: o ? `kc-root ${o}` : "kc-root",
+      style: F,
+      children: [
+        /* @__PURE__ */ B(
+          "div",
+          {
+            ref: p,
+            className: "kc-plot",
+            role: "img",
+            "aria-label": r,
+            onPointerMove: P,
+            onPointerLeave: () => u.pointerLeave(),
+            children: [
+              /* @__PURE__ */ I("canvas", { ref: d, className: "kc-layer-series", "aria-hidden": "true" }),
+              /* @__PURE__ */ I("canvas", { ref: m, className: "kc-layer-overlay", "aria-hidden": "true" }),
+              /* @__PURE__ */ I(Tn, { scene: u }),
+              /* @__PURE__ */ I(Ln, { scene: u })
+            ]
+          }
+        ),
+        c
+      ]
+    }
+  ) });
+}
+function Jn(n) {
+  const {
+    accessor: t,
+    baseline: e,
+    xAxisId: i = "x",
+    yAxisId: s = "y",
+    data: r,
+    name: o,
+    color: a,
+    fillOpacity: l = 0.18,
+    strokeWidth: c = 1.5
+  } = n, u = E(
+    () => ({
+      kind: "area",
+      accessor: t,
+      baseline: e,
+      xAxisId: i,
+      yAxisId: s,
+      data: r,
+      name: o,
+      color: a,
+      fillOpacity: l,
+      strokeWidth: c
+    }),
+    [t, e, i, s, r, o, a, l, c]
+  );
+  return J("Area", u), null;
+}
+function jn(n) {
+  const {
+    accessor: t,
+    xAxisId: e = "x",
+    yAxisId: i = "y",
+    data: s,
+    name: r,
+    color: o,
+    barWidth: a = 0.8
+  } = n, l = E(
+    () => ({
+      kind: "bar",
+      accessor: t,
+      xAxisId: e,
+      yAxisId: i,
+      data: s,
+      name: r,
+      color: o,
+      barWidth: a
+    }),
+    [t, e, i, s, r, o, a]
+  );
+  return J("Bar", l), null;
+}
+function Fn(n) {
+  const {
+    accessor: t,
+    xAxisId: e = "x",
+    yAxisId: i = "y",
+    data: s,
+    name: r,
+    color: o,
+    tone: a,
+    strokeWidth: l = 1.5,
+    dash: c,
+    markers: u = "auto"
+  } = n, h = E(
+    () => ({
+      kind: "line",
+      accessor: t,
+      xAxisId: e,
+      yAxisId: i,
+      data: s,
+      name: r,
+      color: o,
+      tone: a,
+      strokeWidth: l,
+      dash: c,
+      markers: u
+    }),
+    [t, e, i, s, r, o, a, l, c, u]
+  );
+  return J("Line", h), null;
+}
+function Pn(n) {
+  const {
+    accessor: t,
+    xAxisId: e = "x",
+    yAxisId: i = "y",
+    data: s,
+    name: r,
+    color: o,
+    tone: a,
+    radius: l = 3
+  } = n, c = E(
+    () => ({
+      kind: "scatter",
+      accessor: t,
+      xAxisId: e,
+      yAxisId: i,
+      data: s,
+      name: r,
+      color: o,
+      tone: a,
+      radius: l
+    }),
+    [t, e, i, s, r, o, a, l]
+  );
+  return J("Scatter", c), null;
+}
+function Qn(n) {
+  const {
+    accessor: t,
+    states: e,
+    xAxisId: i = "x",
+    yAxisId: s = "y",
+    data: r,
+    name: o,
+    laneFrom: a,
+    laneTo: l
+  } = n, c = E(
+    () => ({
+      kind: "state",
+      accessor: t,
+      states: e,
+      xAxisId: i,
+      yAxisId: s,
+      data: r,
+      name: o,
+      laneFrom: a,
+      laneTo: l
+    }),
+    [t, e, i, s, r, o, a, l]
+  );
+  return J("StateBand", c), null;
+}
+const En = [
+  "#eef2ff",
+  "#c7d2fe",
+  "#a5b4fc",
+  "#818cf8",
+  "#6366f1",
+  "#4f46e5",
+  "#4338ca"
+];
+function ti(n) {
+  const {
+    accessor: t,
+    value: e,
+    coloring: i,
+    xAxisId: s = "x",
+    yAxisId: r = "y",
+    data: o,
+    name: a
+  } = n, l = E(
+    () => i ?? { kind: "gradient", stops: En },
+    [i]
+  ), c = E(
+    () => ({
+      kind: "matrix",
+      accessor: t,
+      value: e,
+      coloring: l,
+      xAxisId: s,
+      yAxisId: r,
+      data: o,
+      name: a
+    }),
+    [t, e, l, s, r, o, a]
+  );
+  return J("Matrix", c), null;
+}
+function ei(n) {
+  const {
+    accessor: t,
+    to: e,
+    xAxisId: i = "x",
+    yAxisId: s = "y",
+    data: r,
+    name: o,
+    color: a,
+    height: l = 0.6
+  } = n, c = E(
+    () => ({
+      kind: "span",
+      accessor: t,
+      to: e,
+      xAxisId: i,
+      yAxisId: s,
+      data: r,
+      name: o,
+      color: a,
+      height: l
+    }),
+    [t, e, i, s, r, o, a, l]
+  );
+  return J("Span", c), null;
+}
+function it(n) {
+  const {
+    value: t,
+    axisId: e = "y",
+    orientation: i = "y",
+    severity: s = "alarm",
+    label: r,
+    color: o,
+    inExtent: a = !0,
+    role: l = "specification"
+  } = n, c = E(
+    () => ({
+      kind: "line",
+      value: t,
+      axisId: e,
+      orientation: i,
+      severity: s,
+      role: l,
+      label: r,
+      color: o,
+      inExtent: a
+    }),
+    [t, e, i, s, l, r, o, a]
+  );
+  return ce("LimitLine", c), null;
+}
+function ni(n) {
+  const {
+    from: t,
+    to: e,
+    axisId: i = "y",
+    orientation: s = "y",
+    severity: r = "warning",
+    label: o,
+    color: a,
+    inExtent: l = !0,
+    role: c = "specification"
+  } = n, u = E(
+    () => ({
+      kind: "band",
+      from: t,
+      to: e,
+      axisId: i,
+      orientation: s,
+      severity: r,
+      role: c,
+      label: o,
+      color: a,
+      inExtent: l
+    }),
+    [t, e, i, s, r, c, o, a, l]
+  );
+  return ce("LimitBand", u), null;
+}
+const Dn = 1.128;
+function kt(n, t) {
+  return {
+    center: n,
+    sigma: t,
+    upper: n + 3 * t,
+    lower: n - 3 * t
+  };
+}
+function ii(n, t) {
+  return (t - n) / 3;
+}
+function $n(n, t) {
+  if (t.kind === "given")
+    return kt(t.center, t.sigma);
+  const e = Math.max(0, Math.trunc(t.from)), i = Math.min(n.length, Math.trunc(t.to));
+  let s = 0, r = 0, o = 0, a = 0, l = Number.NaN;
+  for (let u = e; u < i; u++) {
+    const h = n[u];
+    if (!Number.isFinite(h)) {
+      l = Number.NaN;
+      continue;
+    }
+    s += h, r++, Number.isFinite(l) && (o += Math.abs(h - l), a++), l = h;
+  }
+  if (r === 0) return kt(Number.NaN, Number.NaN);
+  const c = a === 0 ? 0 : o / a / Dn;
+  return kt(s / r, c);
+}
+function Cn(n, t = [1, 2]) {
+  return t.map((e) => ({
+    k: e,
+    upper: n.center + e * n.sigma,
+    lower: n.center - e * n.sigma
+  }));
+}
+function Wn(n, t) {
+  return Number.isFinite(n) ? n > t ? 1 : n < t ? -1 : 0 : 0;
+}
+function ue(n, t) {
+  const e = [];
+  if (t < 1) return e;
+  let i = 0;
+  for (let s = 1; s <= n.length; s++) {
+    const r = s < n.length ? n[s] : Number.NaN, o = n[i];
+    if (r !== o) {
+      if (o !== 0 && s - i >= t)
+        for (let a = i; a < s; a++) e.push(a);
+      i = s;
+    }
+  }
+  return e;
+}
+const $t = {
+  outlier: !0,
+  run: !0,
+  trend: !0,
+  twoOfThree: !0,
+  runLength: 9,
+  trendLength: 6
+};
+function On(n, t) {
+  const e = [];
+  for (let i = 0; i < n.length; i++) {
+    const s = n[i];
+    (s > t.upper || s < t.lower) && e.push(i);
+  }
+  return e;
+}
+function Hn(n, t, e = $t.runLength) {
+  return ue(
+    n.map((i) => Wn(i, t.center)),
+    e
+  );
+}
+function Rn(n, t = $t.trendLength) {
+  const e = [];
+  for (let s = 1; s < n.length; s++) {
+    const r = n[s - 1], o = n[s];
+    e.push(Number.isFinite(r) && Number.isFinite(o) ? Math.sign(o - r) : 0);
+  }
+  const i = [];
+  for (const s of ue(e, Math.max(1, t - 1)))
+    i[i.length - 1] !== s && i.push(s), i.push(s + 1);
+  return i;
+}
+function Vn(n, t) {
+  const e = t.center + 2 * t.sigma, i = t.center - 2 * t.sigma, s = /* @__PURE__ */ new Set();
+  for (let r = 0; r + 2 < n.length; r++)
+    for (const o of [
+      [r, r + 1, r + 2].filter((a) => n[a] > e),
+      [r, r + 1, r + 2].filter((a) => n[a] < i)
+    ])
+      if (o.length >= 2) for (const a of o) s.add(a);
+  return [...s].sort((r, o) => r - o);
+}
+function _n(n, t, e = {}) {
+  const i = { ...$t, ...e }, s = [], r = (o, a) => {
+    a.length > 0 && s.push({ rule: o, indices: a });
+  };
+  return i.outlier && r("outlier", On(n, t)), i.run && r("run", Hn(n, t, i.runLength)), i.trend && r("trend", Rn(n, i.trendLength)), i.twoOfThree && r("twoOfThree", Vn(n, t)), s;
+}
+function Bn(n) {
+  const t = /* @__PURE__ */ new Set();
+  for (const e of n) for (const i of e.indices) t.add(i);
+  return [...t].sort((e, i) => e - i);
+}
+function si(n) {
+  const {
+    accessor: t,
+    data: e,
+    origin: i,
+    xAxisId: s = "x",
+    yAxisId: r = "y",
+    name: o,
+    color: a,
+    rules: l,
+    zoneLines: c = !0,
+    labelUpper: u,
+    labelLower: h,
+    violationName: p,
+    onViolations: d
+  } = n, m = E(() => {
+    const F = [];
+    for (let P = 0; P < e.length; P++) {
+      const S = t(e[P], P);
+      F.push(S ?? Number.NaN);
+    }
+    return F;
+  }, [e, t]), y = E(() => $n(m, i), [m, i]), f = E(
+    () => _n(m, y, l ?? {}),
+    [m, y, l]
+  ), b = E(() => new Set(Bn(f)), [f]);
+  D(() => {
+    d == null || d(f);
+  }, [f, d]);
+  const k = E(
+    () => (F, P) => b.has(P) ? t(F, P) : null,
+    [b, t]
+  ), N = E(
+    () => b.size === 0 ? e : e.slice(),
+    [e, b]
+  ), w = E(
+    () => c ? Cn(y, [1, 2]) : [],
+    [c, y]
+  ), L = Number.isFinite(y.center);
+  return /* @__PURE__ */ B(Nt, { children: [
+    /* @__PURE__ */ I(Fn, { accessor: t, data: e, xAxisId: s, yAxisId: r, name: o, color: a }),
+    L && /* @__PURE__ */ B(Nt, { children: [
+      w.map((F) => /* @__PURE__ */ I(
+        it,
+        {
+          value: F.upper,
+          axisId: r,
+          role: "zone",
+          inExtent: !1
+        },
+        `zone-${F.k}-upper`
+      )),
+      w.map((F) => /* @__PURE__ */ I(
+        it,
+        {
+          value: F.lower,
+          axisId: r,
+          role: "zone",
+          inExtent: !1
+        },
+        `zone-${F.k}-lower`
+      )),
+      /* @__PURE__ */ I(it, { value: y.center, axisId: r, role: "control" }),
+      /* @__PURE__ */ I(it, { value: y.upper, axisId: r, role: "control", label: u }),
+      /* @__PURE__ */ I(it, { value: y.lower, axisId: r, role: "control", label: h })
+    ] }),
+    /* @__PURE__ */ I(
+      Pn,
+      {
+        accessor: k,
+        data: N,
+        xAxisId: s,
+        yAxisId: r,
+        name: p,
+        tone: "alarm",
+        radius: 4
+      }
+    )
+  ] });
+}
+function ri(n) {
+  const {
+    id: t = "x",
+    position: e = "bottom",
+    accessor: i,
+    label: s,
+    tickCount: r,
+    tickFormat: o,
+    domain: a = "nice",
+    grid: l,
+    ticks: c,
+    calendar: u
+  } = n, h = E(
+    () => ({
+      id: t,
+      orientation: "x",
+      position: e,
+      accessor: i,
+      label: s,
+      tickCount: r,
+      tickFormat: o,
+      domain: a,
+      grid: l,
+      ticks: c,
+      calendar: u
+    }),
+    [t, e, i, s, r, o, a, l, c, u]
+  );
+  return le("XAxis", h), null;
+}
+function oi(n) {
+  const {
+    id: t = "y",
+    position: e = "left",
+    accessor: i,
+    label: s,
+    tickCount: r,
+    tickFormat: o,
+    domain: a = "nice",
+    grid: l,
+    ticks: c
+  } = n, u = E(
+    () => ({
+      id: t,
+      orientation: "y",
+      position: e,
+      accessor: i,
+      label: s,
+      tickCount: r,
+      tickFormat: o,
+      domain: a,
+      grid: l,
+      ticks: c
+    }),
+    [t, e, i, s, r, o, a, l, c]
+  );
+  return le("YAxis", u), null;
+}
+function Yn({
+  scene: n,
+  placement: t
+}) {
+  In("Legend", { placement: t });
+  const e = Et(
+    n.subscribeLayout,
+    n.getLayoutSnapshot,
+    n.getLayoutServerSnapshot
+  );
+  return e.series.length === 0 ? null : /* @__PURE__ */ I("div", { className: `kc-legend kc-legend-${t}`, children: e.series.map((i) => /* @__PURE__ */ B(
+    "span",
+    {
+      className: "kc-legend-item",
+      onPointerEnter: () => n.setHighlight(i.seriesId),
+      onPointerLeave: () => n.setHighlight(null),
+      children: [
+        /* @__PURE__ */ I("span", { className: "kc-legend-chip", style: { background: i.color } }),
+        i.name
+      ]
+    },
+    i.id
+  )) });
+}
+function ai({ placement: n = "top" }) {
+  const t = tt("Legend");
+  return t === null ? null : /* @__PURE__ */ I(Yn, { scene: t, placement: n });
+}
+function li(n) {
+  const { mode: t = "x", render: e } = n, i = E(
+    () => ({ mode: t, render: e }),
+    [t, e]
+  );
+  return Sn("Tooltip", i), null;
+}
+const zn = {
+  cutoff: 0.8,
+  collectRank: Number.POSITIVE_INFINITY
+};
+function ci(n, t = {}) {
+  const e = { ...zn, ...t };
+  ut(
+    !Number.isFinite(e.collectRank) || e.remainderName !== void 0,
+    "pareto: a collect rank needs `remainderName` - the package brings no name for the remainder."
+  );
+  const i = n.map((d, m) => ({ item: d, inputIndex: m })).sort((d, m) => m.item.value - d.item.value || d.inputIndex - m.inputIndex).map(({ item: d }) => d), s = Math.max(0, Math.min(i.length, Math.floor(e.collectRank))), r = i.slice(0, s), o = i.slice(s), a = o.length === 0 ? r : [...r, { name: e.remainderName ?? "", value: o.reduce((d, m) => d + m.value, 0) }], l = a.reduce((d, m) => d + m.value, 0), c = [];
+  let u = 0;
+  for (let d = 0; d < a.length; d++) {
+    const m = a[d];
+    u += m.value, c.push({
+      name: m.name,
+      value: m.value,
+      index: d,
+      share: l === 0 ? 0 : m.value / l,
+      cumulative: l === 0 ? 0 : u / l,
+      remainder: o.length > 0 && d === a.length - 1
+    });
+  }
+  const h = Math.abs(e.cutoff) * 1e-12, p = c.findIndex((d) => d.cumulative >= e.cutoff - h);
+  return { entries: c, total: l, cutoffIndex: p };
+}
+export {
+  Jn as Area,
+  jn as Bar,
+  Zn as Chart,
+  si as ControlChart,
+  X as DAY,
+  En as DEFAULT_GRADIENT,
+  Q as HOUR,
+  ai as Legend,
+  ni as LimitBand,
+  it as LimitLine,
+  Fn as Line,
+  Vt as LinearScale,
+  U as MINUTE,
+  ti as Matrix,
+  K as SECOND,
+  Pn as Scatter,
+  ei as Span,
+  Qn as StateBand,
+  li as Tooltip,
+  ri as XAxis,
+  oi as YAxis,
+  rn as assess,
+  Ce as breaks,
+  G as calendarFrom,
+  $n as controlLimits,
+  $t as defaultRules,
+  we as invalidateTheme,
+  Un as mapSeries,
+  Fe as operatingCalendar,
+  He as operatingTicks,
+  Oe as operatingTimeTicks,
+  ci as pareto,
+  zn as paretoDefaults,
+  $e as removedIntervals,
+  On as ruleOutlier,
+  Hn as ruleRun,
+  Rn as ruleTrend,
+  Vn as ruleTwoOfThree,
+  ii as sigmaFromLimit,
+  We as timeStep,
+  yt as toOperatingTime,
+  ft as toWallClock,
+  Xn as verdictWeight,
+  Bn as violatedIndices,
+  _n as violations,
+  Cn as zones
+};