@synnaxlabs/pluto 0.45.1 → 0.46.1

package/dist/provider-B-VPfAGa.js

@@ -0,0 +1,4673 @@
+import { B as on, D as kr, E as Ms, F as Ps, H as Ls, I as As, J as Os, K as Ns, M as _s, N as Is, Q as Ys, T as Us, U as Zs, V as Bs, W as Fs, X as $s, Y as qs, Z as Hs, m as js, $ as zs, a0 as Ws, a1 as Xs, a2 as qt, a3 as Vs, a4 as Gs, a5 as Ks, a6 as Qs, a7 as Js, a8 as ei, a9 as ti, aa as ni, ab as ri, ac as si, ad as ii, ae as Et, af as ai, ag as ln, ah as oi, ai as li, aj as ci, ak as ui, al as hi, am as di, an as Rt, ao as fi, ap as gi, aq as pi, ar as mi, as as Dr, at as yi, au as bi, av as xi, aw as Si, ax as vi, ay as Ti, az as wi, aA as Ci, aB as Ei, aC as Ri, aD as ki, aE as kt, aF as cn, aG as Ge, aH as Mr, aI as Pr, aJ as Lr, aK as un, aL as hn, aM as Ar, aN as Or, aO as Di, aP as Mi, aQ as Pi, aR as Li, aS as Ai, aT as Oi, aU as ct, aV as Ni, aW as _i, aX as Ii, aY as Yi, aZ as Ui, a_ as Zi, a$ as Bi, b0 as Fi, b1 as $i, b2 as qi, b3 as Hi, b4 as dn, b5 as ji, b6 as zi, b7 as Wi, b8 as fn, b9 as Xi, ba as Vi, bb as Nr, bc as Gi, bd as Ke, be as H, bf as Ki, bg as Qi, bh as Z, bi as _r, bj as Dt, bk as Mt, G as Ji, bl as fe, h as j, bm as he, bn as ea, bo as An, bp as ta, bq as na, u as re, br as ra, d as On, bs as $e, bt as Pt, l as gn, bu as V, bv as pn, bw as mn, bx as sa, by as Ir, bz as yn, bA as ia, bB as aa, c as Nt, bC as oa, bD as la } from "./provider-qIzR8Puy.js";
+import pe, { z as p } from "zod";
+import { k as y, d as C, H as A, Q as d, f as Qe, N as Yr, R as Ur, S as ca, j as g, e as ua, b as G, a as Zr, c as Br, F as ha, r as $, m as qe, K, _ as Nn, p as te, O as da, A as Lt, V as Fr, i as _n, z as $r } from "./css-qKD7ZG81.js";
+import { f as Fe } from "./fontString-CpT1noV1.js";
+import "react";
+const bn = "pluto-vis-renderer", xn = (t, e) => {
+  t.set(bn, e, !1);
+}, Sn = (t) => t.get(bn), qr = (t) => t.getOptional(bn), de = (t, e) => Sn(t)(e), Pu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AbstractSink: on,
+  AbstractSource: kr,
+  Base: Ms,
+  BaseProvider: Ps,
+  BooleanStatus: Ls,
+  CONTEXT_KEY: As,
+  ChannelData: Os,
+  ColorGradient: Ns,
+  CompoundTelemFactory: _s,
+  Context: Is,
+  FixedColorSource: Ys,
+  FixedNumber: Us,
+  FixedString: Zs,
+  IterativeSeries: Bs,
+  Mean: Fs,
+  MultiSourceTransformer: $s,
+  NoopFactory: qs,
+  PipelineFactory: Hs,
+  REGISTRY: js,
+  RemoteFactory: zs,
+  RollingAverage: Ws,
+  ScaleNumber: Xs,
+  SeriesDownsampler: qt,
+  SetPoint: Vs,
+  SinkPipeline: Gs,
+  SourcePipeline: Ks,
+  StaticFactory: Qs,
+  StreamChannelData: Js,
+  StreamChannelValue: ei,
+  StringifyNumber: ti,
+  TransformerFactory: ni,
+  UnarySinkTransformer: ri,
+  UnarySourceTransformer: si,
+  WithinBounds: ii,
+  booleanSinkSpecZ: Et,
+  booleanSinkTransformerSpecZ: ai,
+  booleanSourceSpecZ: ln,
+  booleanSourceTransformerSpecZ: oi,
+  booleanStatus: li,
+  booleanStatusProps: ci,
+  channelData: ui,
+  colorGradient: hi,
+  colorGradientProps: di,
+  colorSourceSpecZ: Rt,
+  connectionZ: fi,
+  createFactory: gi,
+  downsampleMode: pi,
+  downsampleModeProps: mi,
+  downsampleModeZ: Dr,
+  fixedArray: yi,
+  fixedColor: bi,
+  fixedColorSourcePropsZ: xi,
+  fixedNumber: Si,
+  fixedNumberPropsZ: vi,
+  fixedSeriesPropsZ: Ti,
+  fixedString: wi,
+  fixedStringPropsZ: Ci,
+  iterativeArray: Ei,
+  iterativeSeriesPropsZ: Ri,
+  mean: ki,
+  noopBooleanSinkSpec: kt,
+  noopBooleanSourceSpec: cn,
+  noopColorSourceSpec: Ge,
+  noopNumericSinkSpec: Mr,
+  noopNumericSourceSpec: Pr,
+  noopSeriesSourceSpec: Lr,
+  noopStatusSourceSpec: un,
+  noopStringSourceSpec: hn,
+  numberSinkSpecZ: Ar,
+  numberSourceSpecZ: Or,
+  providerStateZ: Di,
+  rollingAverage: Mi,
+  rollingAverageProps: Pi,
+  scaleNumber: Li,
+  scaleNumberProps: Ai,
+  seriesDownsampler: Oi,
+  seriesSourceSpecZ: ct,
+  setContext: Ni,
+  setpoint: _i,
+  sinkPipeline: Ii,
+  sinkPipelinePropsZ: Yi,
+  sinkSpecZ: Ui,
+  sinkTransformerSpecZ: Zi,
+  sourcePipeline: Bi,
+  sourcePipelinePropsZ: Fi,
+  sourceSpecZ: $i,
+  sourceTransformerSpecZ: qi,
+  specZ: Hi,
+  statusSourceSpecZ: dn,
+  streamChannelData: ji,
+  streamChannelValue: zi,
+  streamChannelValuePropsZ: Wi,
+  stringSourceSpecZ: fn,
+  stringifyNumber: Xi,
+  stringifyNumberProps: Vi,
+  useChildContext: Nr,
+  useContext: Gi,
+  useSink: Ke,
+  useSource: H,
+  withinBounds: Ki,
+  withinBoundsProps: Qi
+}, Symbol.toStringTag, { value: "Module" }));
+function vn(t, e, n) {
+  t.prototype = e.prototype = n, n.constructor = t;
+}
+function Hr(t, e) {
+  var n = Object.create(t.prototype);
+  for (var r in e) n[r] = e[r];
+  return n;
+}
+function Je() {
+}
+var He = 0.7, ut = 1 / He, Me = "\\s*([+-]?\\d+)\\s*", je = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*", ne = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*", fa = /^#([0-9a-f]{3,8})$/, ga = new RegExp(`^rgb\\(${Me},${Me},${Me}\\)$`), pa = new RegExp(`^rgb\\(${ne},${ne},${ne}\\)$`), ma = new RegExp(`^rgba\\(${Me},${Me},${Me},${je}\\)$`), ya = new RegExp(`^rgba\\(${ne},${ne},${ne},${je}\\)$`), ba = new RegExp(`^hsl\\(${je},${ne},${ne}\\)$`), xa = new RegExp(`^hsla\\(${je},${ne},${ne},${je}\\)$`), In = {
+  aliceblue: 15792383,
+  antiquewhite: 16444375,
+  aqua: 65535,
+  aquamarine: 8388564,
+  azure: 15794175,
+  beige: 16119260,
+  bisque: 16770244,
+  black: 0,
+  blanchedalmond: 16772045,
+  blue: 255,
+  blueviolet: 9055202,
+  brown: 10824234,
+  burlywood: 14596231,
+  cadetblue: 6266528,
+  chartreuse: 8388352,
+  chocolate: 13789470,
+  coral: 16744272,
+  cornflowerblue: 6591981,
+  cornsilk: 16775388,
+  crimson: 14423100,
+  cyan: 65535,
+  darkblue: 139,
+  darkcyan: 35723,
+  darkgoldenrod: 12092939,
+  darkgray: 11119017,
+  darkgreen: 25600,
+  darkgrey: 11119017,
+  darkkhaki: 12433259,
+  darkmagenta: 9109643,
+  darkolivegreen: 5597999,
+  darkorange: 16747520,
+  darkorchid: 10040012,
+  darkred: 9109504,
+  darksalmon: 15308410,
+  darkseagreen: 9419919,
+  darkslateblue: 4734347,
+  darkslategray: 3100495,
+  darkslategrey: 3100495,
+  darkturquoise: 52945,
+  darkviolet: 9699539,
+  deeppink: 16716947,
+  deepskyblue: 49151,
+  dimgray: 6908265,
+  dimgrey: 6908265,
+  dodgerblue: 2003199,
+  firebrick: 11674146,
+  floralwhite: 16775920,
+  forestgreen: 2263842,
+  fuchsia: 16711935,
+  gainsboro: 14474460,
+  ghostwhite: 16316671,
+  gold: 16766720,
+  goldenrod: 14329120,
+  gray: 8421504,
+  green: 32768,
+  greenyellow: 11403055,
+  grey: 8421504,
+  honeydew: 15794160,
+  hotpink: 16738740,
+  indianred: 13458524,
+  indigo: 4915330,
+  ivory: 16777200,
+  khaki: 15787660,
+  lavender: 15132410,
+  lavenderblush: 16773365,
+  lawngreen: 8190976,
+  lemonchiffon: 16775885,
+  lightblue: 11393254,
+  lightcoral: 15761536,
+  lightcyan: 14745599,
+  lightgoldenrodyellow: 16448210,
+  lightgray: 13882323,
+  lightgreen: 9498256,
+  lightgrey: 13882323,
+  lightpink: 16758465,
+  lightsalmon: 16752762,
+  lightseagreen: 2142890,
+  lightskyblue: 8900346,
+  lightslategray: 7833753,
+  lightslategrey: 7833753,
+  lightsteelblue: 11584734,
+  lightyellow: 16777184,
+  lime: 65280,
+  limegreen: 3329330,
+  linen: 16445670,
+  magenta: 16711935,
+  maroon: 8388608,
+  mediumaquamarine: 6737322,
+  mediumblue: 205,
+  mediumorchid: 12211667,
+  mediumpurple: 9662683,
+  mediumseagreen: 3978097,
+  mediumslateblue: 8087790,
+  mediumspringgreen: 64154,
+  mediumturquoise: 4772300,
+  mediumvioletred: 13047173,
+  midnightblue: 1644912,
+  mintcream: 16121850,
+  mistyrose: 16770273,
+  moccasin: 16770229,
+  navajowhite: 16768685,
+  navy: 128,
+  oldlace: 16643558,
+  olive: 8421376,
+  olivedrab: 7048739,
+  orange: 16753920,
+  orangered: 16729344,
+  orchid: 14315734,
+  palegoldenrod: 15657130,
+  palegreen: 10025880,
+  paleturquoise: 11529966,
+  palevioletred: 14381203,
+  papayawhip: 16773077,
+  peachpuff: 16767673,
+  peru: 13468991,
+  pink: 16761035,
+  plum: 14524637,
+  powderblue: 11591910,
+  purple: 8388736,
+  rebeccapurple: 6697881,
+  red: 16711680,
+  rosybrown: 12357519,
+  royalblue: 4286945,
+  saddlebrown: 9127187,
+  salmon: 16416882,
+  sandybrown: 16032864,
+  seagreen: 3050327,
+  seashell: 16774638,
+  sienna: 10506797,
+  silver: 12632256,
+  skyblue: 8900331,
+  slateblue: 6970061,
+  slategray: 7372944,
+  slategrey: 7372944,
+  snow: 16775930,
+  springgreen: 65407,
+  steelblue: 4620980,
+  tan: 13808780,
+  teal: 32896,
+  thistle: 14204888,
+  tomato: 16737095,
+  turquoise: 4251856,
+  violet: 15631086,
+  wheat: 16113331,
+  white: 16777215,
+  whitesmoke: 16119285,
+  yellow: 16776960,
+  yellowgreen: 10145074
+};
+vn(Je, ze, {
+  copy(t) {
+    return Object.assign(new this.constructor(), this, t);
+  },
+  displayable() {
+    return this.rgb().displayable();
+  },
+  hex: Yn,
+  // Deprecated! Use color.formatHex.
+  formatHex: Yn,
+  formatHex8: Sa,
+  formatHsl: va,
+  formatRgb: Un,
+  toString: Un
+});
+function Yn() {
+  return this.rgb().formatHex();
+}
+function Sa() {
+  return this.rgb().formatHex8();
+}
+function va() {
+  return jr(this).formatHsl();
+}
+function Un() {
+  return this.rgb().formatRgb();
+}
+function ze(t) {
+  var e, n;
+  return t = (t + "").trim().toLowerCase(), (e = fa.exec(t)) ? (n = e[1].length, e = parseInt(e[1], 16), n === 6 ? Zn(e) : n === 3 ? new q(e >> 8 & 15 | e >> 4 & 240, e >> 4 & 15 | e & 240, (e & 15) << 4 | e & 15, 1) : n === 8 ? st(e >> 24 & 255, e >> 16 & 255, e >> 8 & 255, (e & 255) / 255) : n === 4 ? st(e >> 12 & 15 | e >> 8 & 240, e >> 8 & 15 | e >> 4 & 240, e >> 4 & 15 | e & 240, ((e & 15) << 4 | e & 15) / 255) : null) : (e = ga.exec(t)) ? new q(e[1], e[2], e[3], 1) : (e = pa.exec(t)) ? new q(e[1] * 255 / 100, e[2] * 255 / 100, e[3] * 255 / 100, 1) : (e = ma.exec(t)) ? st(e[1], e[2], e[3], e[4]) : (e = ya.exec(t)) ? st(e[1] * 255 / 100, e[2] * 255 / 100, e[3] * 255 / 100, e[4]) : (e = ba.exec(t)) ? $n(e[1], e[2] / 100, e[3] / 100, 1) : (e = xa.exec(t)) ? $n(e[1], e[2] / 100, e[3] / 100, e[4]) : In.hasOwnProperty(t) ? Zn(In[t]) : t === "transparent" ? new q(NaN, NaN, NaN, 0) : null;
+}
+function Zn(t) {
+  return new q(t >> 16 & 255, t >> 8 & 255, t & 255, 1);
+}
+function st(t, e, n, r) {
+  return r <= 0 && (t = e = n = NaN), new q(t, e, n, r);
+}
+function Ta(t) {
+  return t instanceof Je || (t = ze(t)), t ? (t = t.rgb(), new q(t.r, t.g, t.b, t.opacity)) : new q();
+}
+function Ht(t, e, n, r) {
+  return arguments.length === 1 ? Ta(t) : new q(t, e, n, r ?? 1);
+}
+function q(t, e, n, r) {
+  this.r = +t, this.g = +e, this.b = +n, this.opacity = +r;
+}
+vn(q, Ht, Hr(Je, {
+  brighter(t) {
+    return t = t == null ? ut : Math.pow(ut, t), new q(this.r * t, this.g * t, this.b * t, this.opacity);
+  },
+  darker(t) {
+    return t = t == null ? He : Math.pow(He, t), new q(this.r * t, this.g * t, this.b * t, this.opacity);
+  },
+  rgb() {
+    return this;
+  },
+  clamp() {
+    return new q(ye(this.r), ye(this.g), ye(this.b), ht(this.opacity));
+  },
+  displayable() {
+    return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+  },
+  hex: Bn,
+  // Deprecated! Use color.formatHex.
+  formatHex: Bn,
+  formatHex8: wa,
+  formatRgb: Fn,
+  toString: Fn
+}));
+function Bn() {
+  return `#${me(this.r)}${me(this.g)}${me(this.b)}`;
+}
+function wa() {
+  return `#${me(this.r)}${me(this.g)}${me(this.b)}${me((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
+}
+function Fn() {
+  const t = ht(this.opacity);
+  return `${t === 1 ? "rgb(" : "rgba("}${ye(this.r)}, ${ye(this.g)}, ${ye(this.b)}${t === 1 ? ")" : `, ${t})`}`;
+}
+function ht(t) {
+  return isNaN(t) ? 1 : Math.max(0, Math.min(1, t));
+}
+function ye(t) {
+  return Math.max(0, Math.min(255, Math.round(t) || 0));
+}
+function me(t) {
+  return t = ye(t), (t < 16 ? "0" : "") + t.toString(16);
+}
+function $n(t, e, n, r) {
+  return r <= 0 ? t = e = n = NaN : n <= 0 || n >= 1 ? t = e = NaN : e <= 0 && (t = NaN), new ee(t, e, n, r);
+}
+function jr(t) {
+  if (t instanceof ee) return new ee(t.h, t.s, t.l, t.opacity);
+  if (t instanceof Je || (t = ze(t)), !t) return new ee();
+  if (t instanceof ee) return t;
+  t = t.rgb();
+  var e = t.r / 255, n = t.g / 255, r = t.b / 255, s = Math.min(e, n, r), a = Math.max(e, n, r), i = NaN, o = a - s, c = (a + s) / 2;
+  return o ? (e === a ? i = (n - r) / o + (n < r) * 6 : n === a ? i = (r - e) / o + 2 : i = (e - n) / o + 4, o /= c < 0.5 ? a + s : 2 - a - s, i *= 60) : o = c > 0 && c < 1 ? 0 : i, new ee(i, o, c, t.opacity);
+}
+function Ca(t, e, n, r) {
+  return arguments.length === 1 ? jr(t) : new ee(t, e, n, r ?? 1);
+}
+function ee(t, e, n, r) {
+  this.h = +t, this.s = +e, this.l = +n, this.opacity = +r;
+}
+vn(ee, Ca, Hr(Je, {
+  brighter(t) {
+    return t = t == null ? ut : Math.pow(ut, t), new ee(this.h, this.s, this.l * t, this.opacity);
+  },
+  darker(t) {
+    return t = t == null ? He : Math.pow(He, t), new ee(this.h, this.s, this.l * t, this.opacity);
+  },
+  rgb() {
+    var t = this.h % 360 + (this.h < 0) * 360, e = isNaN(t) || isNaN(this.s) ? 0 : this.s, n = this.l, r = n + (n < 0.5 ? n : 1 - n) * e, s = 2 * n - r;
+    return new q(
+      _t(t >= 240 ? t - 240 : t + 120, s, r),
+      _t(t, s, r),
+      _t(t < 120 ? t + 240 : t - 120, s, r),
+      this.opacity
+    );
+  },
+  clamp() {
+    return new ee(qn(this.h), it(this.s), it(this.l), ht(this.opacity));
+  },
+  displayable() {
+    return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+  },
+  formatHsl() {
+    const t = ht(this.opacity);
+    return `${t === 1 ? "hsl(" : "hsla("}${qn(this.h)}, ${it(this.s) * 100}%, ${it(this.l) * 100}%${t === 1 ? ")" : `, ${t})`}`;
+  }
+}));
+function qn(t) {
+  return t = (t || 0) % 360, t < 0 ? t + 360 : t;
+}
+function it(t) {
+  return Math.max(0, Math.min(1, t || 0));
+}
+function _t(t, e, n) {
+  return (t < 60 ? e + (n - e) * t / 60 : t < 180 ? n : t < 240 ? e + (n - e) * (240 - t) / 60 : e) * 255;
+}
+const Tn = (t) => () => t;
+function Ea(t, e) {
+  return function(n) {
+    return t + n * e;
+  };
+}
+function Ra(t, e, n) {
+  return t = Math.pow(t, n), e = Math.pow(e, n) - t, n = 1 / n, function(r) {
+    return Math.pow(t + r * e, n);
+  };
+}
+function ka(t) {
+  return (t = +t) == 1 ? zr : function(e, n) {
+    return n - e ? Ra(e, n, t) : Tn(isNaN(e) ? n : e);
+  };
+}
+function zr(t, e) {
+  var n = e - t;
+  return n ? Ea(t, n) : Tn(isNaN(t) ? e : t);
+}
+const Hn = (function t(e) {
+  var n = ka(e);
+  function r(s, a) {
+    var i = n((s = Ht(s)).r, (a = Ht(a)).r), o = n(s.g, a.g), c = n(s.b, a.b), l = zr(s.opacity, a.opacity);
+    return function(u) {
+      return s.r = i(u), s.g = o(u), s.b = c(u), s.opacity = l(u), s + "";
+    };
+  }
+  return r.gamma = t, r;
+})(1);
+function Da(t, e) {
+  e || (e = []);
+  var n = t ? Math.min(e.length, t.length) : 0, r = e.slice(), s;
+  return function(a) {
+    for (s = 0; s < n; ++s) r[s] = t[s] * (1 - a) + e[s] * a;
+    return r;
+  };
+}
+function Ma(t) {
+  return ArrayBuffer.isView(t) && !(t instanceof DataView);
+}
+function Pa(t, e) {
+  var n = e ? e.length : 0, r = t ? Math.min(n, t.length) : 0, s = new Array(r), a = new Array(n), i;
+  for (i = 0; i < r; ++i) s[i] = wn(t[i], e[i]);
+  for (; i < n; ++i) a[i] = e[i];
+  return function(o) {
+    for (i = 0; i < r; ++i) a[i] = s[i](o);
+    return a;
+  };
+}
+function La(t, e) {
+  var n = /* @__PURE__ */ new Date();
+  return t = +t, e = +e, function(r) {
+    return n.setTime(t * (1 - r) + e * r), n;
+  };
+}
+function dt(t, e) {
+  return t = +t, e = +e, function(n) {
+    return t * (1 - n) + e * n;
+  };
+}
+function Aa(t, e) {
+  var n = {}, r = {}, s;
+  (t === null || typeof t != "object") && (t = {}), (e === null || typeof e != "object") && (e = {});
+  for (s in e)
+    s in t ? n[s] = wn(t[s], e[s]) : r[s] = e[s];
+  return function(a) {
+    for (s in n) r[s] = n[s](a);
+    return r;
+  };
+}
+var jt = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, It = new RegExp(jt.source, "g");
+function Oa(t) {
+  return function() {
+    return t;
+  };
+}
+function Na(t) {
+  return function(e) {
+    return t(e) + "";
+  };
+}
+function _a(t, e) {
+  var n = jt.lastIndex = It.lastIndex = 0, r, s, a, i = -1, o = [], c = [];
+  for (t = t + "", e = e + ""; (r = jt.exec(t)) && (s = It.exec(e)); )
+    (a = s.index) > n && (a = e.slice(n, a), o[i] ? o[i] += a : o[++i] = a), (r = r[0]) === (s = s[0]) ? o[i] ? o[i] += s : o[++i] = s : (o[++i] = null, c.push({ i, x: dt(r, s) })), n = It.lastIndex;
+  return n < e.length && (a = e.slice(n), o[i] ? o[i] += a : o[++i] = a), o.length < 2 ? c[0] ? Na(c[0].x) : Oa(e) : (e = c.length, function(l) {
+    for (var u = 0, h; u < e; ++u) o[(h = c[u]).i] = h.x(l);
+    return o.join("");
+  });
+}
+function wn(t, e) {
+  var n = typeof e, r;
+  return e == null || n === "boolean" ? Tn(e) : (n === "number" ? dt : n === "string" ? (r = ze(e)) ? (e = r, Hn) : _a : e instanceof ze ? Hn : e instanceof Date ? La : Ma(e) ? Da : Array.isArray(e) ? Pa : typeof e.valueOf != "function" && typeof e.toString != "function" || isNaN(e) ? Aa : dt)(t, e);
+}
+function Ia(t, e) {
+  return t = +t, e = +e, function(n) {
+    return Math.round(t * (1 - n) + e * n);
+  };
+}
+const jn = `#version 300 es
+precision lowp float;
+
+uniform lowp vec4 u_color;
+out vec4 fragColor;
+
+void main(void) {
+  fragColor = u_color;
+}
+`, Ya = `#version 300 es
+
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+in mediump float a_x;
+in mediump float a_y;
+in mediump vec2 a_translate;
+
+uniform mediump vec2 u_scale_aggregate;
+uniform mediump vec2 u_offset_aggregate;
+
+void main(void) {
+  gl_Position = vec4((u_scale_aggregate * vec2(a_x, a_y) + u_offset_aggregate) + a_translate, 0.0, 1.0);
+}
+`, Ua = `#version 300 es
+
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+in mediump float a_x;
+in mediump uint a_y;
+in mediump vec2 a_translate;
+
+uniform mediump vec2 u_scale_aggregate;
+uniform mediump vec2 u_offset_aggregate;
+
+void main(void) {
+  gl_Position = vec4((u_scale_aggregate * vec2(a_x, float(a_y)) + u_offset_aggregate) + a_translate, 0.0, 1.0);
+}
+`, Za = p.object({
+  x: ct,
+  y: ct,
+  label: p.string().optional(),
+  color: y.colorZ,
+  strokeWidth: p.number().default(1),
+  downsample: p.number().min(1).max(50).default(1),
+  downsampleMode: Dr.default("decimate"),
+  visible: p.boolean().optional().default(!0)
+}), Ba = (t, e, n) => t === -1 || e === -1 || t >= n.series.length ? NaN : Number(n.series[t].at(e)), Fa = C.milliseconds(2);
+d.NAN, d.NAN, y.ZERO, A.ZERO;
+const $a = (t, e) => e.equals(Qe.UINT8) ? t.UNSIGNED_BYTE : t.FLOAT;
+class zn extends Ji {
+  translationBufferCache = /* @__PURE__ */ new Map();
+  constructor(e, n, r) {
+    super(e, n, r), this.translationBufferCache = /* @__PURE__ */ new Map();
+  }
+  bindState({ strokeWidth: e, color: n }) {
+    return this.uniformColor("u_color", n), this.attrStrokeWidth(e);
+  }
+  bindScale(e, n) {
+    const r = d.scale(e.scale, n.scale), s = d.translate(
+      d.scale(n.scale, e.offset),
+      n.offset
+    );
+    this.uniformXY("u_scale_aggregate", r), this.uniformXY("u_offset_aggregate", s);
+  }
+  draw({ x: e, y: n, count: r, downsample: s, xOffset: a, yOffset: i }, o, c, l) {
+    const { gl: u } = this.renderCtx;
+    this.bindAttrBuffer("x", e.glBuffer, s, a, c), this.bindAttrBuffer("y", n.glBuffer, s, i, l), u.drawArraysInstanced(u.LINE_STRIP, 0, r / s, o);
+  }
+  bindAttrBuffer(e, n, r, s = 0, a) {
+    const { gl: i } = this.renderCtx;
+    i.bindBuffer(i.ARRAY_BUFFER, n);
+    const o = i.getAttribLocation(this.prog, `a_${e}`), c = $a(i, a), l = a.density.valueOf();
+    a.equals(Qe.UINT8) ? i.vertexAttribIPointer(
+      o,
+      1,
+      c,
+      // e.g., gl.UNSIGNED_BYTE
+      l * r,
+      l * s
+    ) : i.vertexAttribPointer(
+      o,
+      1,
+      c,
+      !1,
+      l * r,
+      l * s
+    ), i.enableVertexAttribArray(o);
+  }
+  getAndBindTranslationBuffer(e) {
+    const { gl: n } = this.renderCtx, r = `${this.renderCtx.aspect}:${e}`, s = this.translationBufferCache.get(r);
+    if (s != null)
+      return n.bindBuffer(n.ARRAY_BUFFER, s.glBuffer), s;
+    const a = n.createBuffer();
+    if (a == null)
+      throw new Mt("Failed to create buffer from WebGL context");
+    const i = Ha(this.renderCtx.aspect, e);
+    n.bindBuffer(n.ARRAY_BUFFER, a), n.bufferData(n.ARRAY_BUFFER, i, n.DYNAMIC_DRAW);
+    const o = { glBuffer: a, jsBuffer: i };
+    return this.translationBufferCache.set(r, o), o;
+  }
+  /**
+   * We apply stroke width by drawing the line multiple times, each time with a slight
+   * transformation. This is done as simply as possible. We draw the "centered" line
+   * and then four more lines: one to the left, one to the right, one above, and one
+   * below. We can repeat this process an arbitrary number of times to make the line
+   * thicker. As we increase the stroke width, we also increase the cost of drawing the
+   * line.
+   */
+  attrStrokeWidth(e) {
+    const { gl: n } = this.renderCtx, { jsBuffer: r } = this.getAndBindTranslationBuffer(e), s = n.getAttribLocation(this.prog, "a_translate");
+    return n.vertexAttribPointer(s, 2, n.FLOAT, !1, 0, 0), n.enableVertexAttribArray(s), n.vertexAttribDivisor(s, 1), r.length / 2;
+  }
+}
+class Pe {
+  static CONTEXT_KEY = "pluto-line-gl-program";
+  // Uint8 hybrid program is used for high performance rendering of uint8 data along
+  // with float32 timestamp data. It's used as a hot path optimization for common
+  // channel such as actuator states.
+  uint8HybridProgram;
+  // Float32 program is used for rendering float32 data. It's used for all other
+  // channel types.
+  float32Program;
+  constructor(e) {
+    this.uint8HybridProgram = new zn(e, Ua, jn), this.float32Program = new zn(e, Ya, jn);
+  }
+  get gl() {
+    return this.uint8HybridProgram.renderCtx.gl;
+  }
+  getProgram(e) {
+    return e.equals(Qe.UINT8) ? this.uint8HybridProgram : this.float32Program;
+  }
+  static create(e, n) {
+    const r = new Pe(n);
+    return e.set(Pe.CONTEXT_KEY, r), r;
+  }
+  static use(e) {
+    const n = e.get(Pe.CONTEXT_KEY);
+    if (n == null) throw new Mt("GLProgram not found");
+    return n;
+  }
+}
+class zt extends Z {
+  static TYPE = "line";
+  schema = Za;
+  afterUpdate(e) {
+    const { internal: n } = this, r = {
+      onStatusChange: _r(e)
+    };
+    n.xTelem = H(e, this.state.x, n.xTelem, r), n.yTelem = H(e, this.state.y, n.yTelem, r), n.instrumentation = Dt(e, "line"), n.lineCtx = Pe.use(e), n.requestRender = Sn(e), n.stopListeningXTelem?.(), n.stopListeningYTelem?.(), n.stopListeningXTelem = n.xTelem.onChange(() => n.requestRender("data")), n.stopListeningYTelem = n.yTelem.onChange(() => n.requestRender("data")), n.requestRender("layout"), (n.xDownsampler?.props.mode !== this.state.downsampleMode || n.xDownsampler?.props.windowSize !== this.state.downsample) && (n.xDownsampler = new qt({
+      mode: this.state.downsampleMode,
+      windowSize: this.state.downsample
+    }), n.yDownsampler = new qt({
+      mode: this.state.downsampleMode,
+      windowSize: this.state.downsample
+    }));
+  }
+  afterDelete() {
+    const { internal: e } = this;
+    e.xTelem.cleanup?.(), e.yTelem.cleanup?.(), e.requestRender("layout");
+  }
+  xBounds() {
+    return this.internal.xTelem.value()[0];
+  }
+  yBounds() {
+    return this.internal.yTelem.value()[0];
+  }
+  findByXValue(e, n) {
+    const { xTelem: r, yTelem: s } = this.internal;
+    let [, a] = r.value();
+    a = this.internal.xDownsampler.transform(a);
+    let [i, o] = [-1, -1];
+    a.series.find((T, k) => {
+      const L = T.binarySearch(n), D = L >= 0 && L < T.length;
+      return D && ([i, o] = [L, k]), D;
+    });
+    const { key: c } = this, { color: l, label: u } = this.state, h = {
+      key: c,
+      color: l,
+      label: u,
+      position: { x: 0, y: 0 },
+      value: { x: NaN, y: NaN },
+      bounds: { lower: 0, upper: 0 }
+    };
+    if (i === -1 || o === -1 || !this.state.visible) return h;
+    const f = a.series[o];
+    h.value.x = Ba(o, i, a);
+    let [, b] = s.value();
+    b = this.internal.yDownsampler.transform(b);
+    const v = b.series.find(
+      (T) => A.contains(T.alignmentBounds, f.alignment + BigInt(i))
+    );
+    if (v == null) return h;
+    const S = Number(v.alignment - f.alignment);
+    return h.value.y = Number(v.at(i - S)), h.bounds = { ...v.bounds }, h.position = {
+      x: e.dataToDecimalScale.x.pos(h.value.x),
+      y: e.dataToDecimalScale.y.pos(h.value.y)
+    }, h;
+  }
+  render(e) {
+    if (this.deleted || !this.state.visible) return;
+    const { downsample: n } = this.state, { xTelem: r, yTelem: s, lineCtx: a, xDownsampler: i, yDownsampler: o } = this.internal, { dataToDecimalScale: c, exposure: l } = e;
+    let [[, u], [, h]] = [r.value(), s.value()];
+    if (u = i.transform(u), h = o.transform(h), u.updateGLBuffer(a.gl), h.updateGLBuffer(a.gl), u.length === 0 || h.length === 0) return;
+    const f = a.getProgram(h.dataType), b = Va(
+      u,
+      h,
+      l,
+      n,
+      this.state.downsampleMode,
+      Fa
+    );
+    this.internal.instrumentation.L.debug("render", () => ({
+      key: this.key,
+      downsample: n,
+      scale: c.transform,
+      props: e.region,
+      ops: Ga(b)
+    }));
+    const v = f.setAsActive(), S = f.bindState(this.state), T = f.renderCtx.scaleRegion(e.region).transform;
+    b.forEach((k) => {
+      const L = Xa(c, k).transform;
+      f.bindScale(L, T), f.draw(k, S, u.dataType, h.dataType);
+    }), v();
+  }
+}
+const qa = 5e3, Ha = (t, e) => Wa(za(t), e).map(
+  (n, r) => Math.floor(r / ja) * (1 / (qa * t)) * n
+), ja = 5, za = (t) => (
+  // prettier-ignore
+  new Float32Array([
+    0,
+    0,
+    // center
+    0,
+    t,
+    // top
+    0,
+    -t,
+    // bottom
+    1,
+    0,
+    // right
+    -1,
+    0
+    // left
+  ])
+), Wa = (t, e) => {
+  const n = new Float32Array(t.length * e);
+  for (let r = 0; r < e; r++) n.set(t, r * t.length);
+  return n;
+}, Xa = (t, e) => t.translate(
+  t.x.dim(Number(e.x.sampleOffset)),
+  t.y.dim(Number(e.y.sampleOffset))
+), Lu = { [zt.TYPE]: zt }, Va = (t, e, n, r, s, a) => {
+  if (t.series.length === 0 || e.series.length === 0) return [];
+  const i = [];
+  return t.series.forEach(
+    (o) => e.series.forEach((c) => {
+      if (!Ka(o, c, a)) return;
+      let l = 0n, u = 0n;
+      o.alignment < c.alignment ? l = c.alignment - o.alignment : c.alignment < o.alignment && (u = o.alignment - c.alignment);
+      const h = Yr.min(
+        A.span(o.alignmentBounds) - l,
+        A.span(c.alignmentBounds) - u
+      );
+      if (h === 0n) return;
+      let f = Ur(
+        Math.round(n * 4 * Number(h)),
+        r,
+        51
+      );
+      s !== "decimate" && (f = 1);
+      const b = Number(h / o.alignmentMultiple), v = Number(l / o.alignmentMultiple), S = Number(u / c.alignmentMultiple);
+      i.push({ x: o, y: c, xOffset: v, yOffset: S, count: b, downsample: f });
+    })
+  ), i;
+}, Ga = (t) => t.map((e) => ({ ...e, x: e.x.digest, y: e.y.digest })), Ka = (t, e, n) => {
+  if (t.alignmentMultiple !== e.alignmentMultiple)
+    return console.warn(
+      "encountered two series with different alignment multiples in draw operations",
+      { x: t.digest, y: e.digest }
+    ), !1;
+  const r = t.timeRange.overlapsWith(e.timeRange, n), s = A.overlapsWith(t.alignmentBounds, e.alignmentBounds);
+  return r && s;
+}, Wr = p.object({
+  dpr: p.number(),
+  region: g.box,
+  bootstrap: p.boolean().optional().default(!1),
+  bootstrapped: p.boolean().optional().default(!1),
+  // We set all of these to ay because nodejs can't identify OffscreenCanvas
+  // and polyfilling causes more problems than it solves
+  glCanvas: p.any().optional(),
+  upper2dCanvas: p.any().optional(),
+  lower2dCanvas: p.any().optional(),
+  os: ca.osZ
+});
+class Wt extends fe {
+  static TYPE = "Canvas";
+  schema = Wr;
+  renderCtx = null;
+  afterUpdate(e) {
+    if (this.renderCtx == null) {
+      if (!this.state.bootstrap) return;
+      const { glCanvas: n, lower2dCanvas: r, upper2dCanvas: s, os: a } = this.state;
+      if (n == null || r == null || s == null)
+        throw new Mt(
+          "[vis.worker.Canvas] - expected render context bootstrap to include all canvases"
+        );
+      this.renderCtx = j.create(
+        e,
+        n,
+        r,
+        s,
+        a
+      ), Pe.create(e, this.renderCtx), this.setState((i) => ({
+        ...i,
+        bootstrap: !1,
+        bootstrapped: !0,
+        glCanvas: void 0,
+        lower2dCanvas: void 0,
+        upper2dCanvas: void 0
+      }));
+    } else this.renderCtx.update(e);
+    this.renderCtx.resize(this.state.region, this.state.dpr);
+  }
+}
+const Qa = {
+  [Wt.TYPE]: Wt
+}, Au = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Canvas: Wt,
+  REGISTRY: Qa,
+  canvasStateZ: Wr
+}, Symbol.toStringTag, { value: "Module" })), Xr = p.object({
+  position: d.xy,
+  zoom: p.number(),
+  region: g.box,
+  clearOverScan: d.crudeZ.optional().default(10),
+  visible: p.boolean().optional().default(!0),
+  autoRenderInterval: p.number().optional()
+}), at = ["upper2d", "lower2d"];
+class Le extends fe {
+  static TYPE = "Diagram";
+  static stateZ = Xr;
+  schema = Le.stateZ;
+  afterUpdate(e) {
+    this.internal.renderCtx = j.use(e), this.internal.handleError = he(e), ua.isNonZero(this.state.autoRenderInterval) && (this.internal.autoRenderInterval ??= setInterval(() => {
+      this.state.visible && this.requestRender("low");
+    }, this.state.autoRenderInterval)), xn(e, () => {
+      this.state.visible && this.requestRender("low");
+    }), !(!this.state.visible && !this.prevState.visible) && (this.internal.viewportScale = G.XY.magnify(d.construct(this.state.zoom)).translate(g.topLeft(this.state.region)).translate(this.state.position), this.requestRender("high"));
+  }
+  afterDelete() {
+    this.internal.autoRenderInterval != null && clearInterval(this.internal.autoRenderInterval), this.requestRender("high");
+  }
+  render() {
+    if (this.deleted) return;
+    const { renderCtx: e, handleError: n, viewportScale: r } = this.internal, s = g.construct(this.state.region);
+    if (!this.state.visible)
+      return () => e.erase(s, this.state.clearOverScan, ...at);
+    const a = e.scissor(s, d.ZERO, at);
+    try {
+      this.children.forEach((o) => o.render?.({ viewportScale: r }));
+    } catch (o) {
+      n(o, "failed to render diagram");
+    } finally {
+      a();
+    }
+    const i = g.copy(this.state.region);
+    return () => {
+      e.lower2d.fillStyle = y.hex(y.BLACK), e.lower2d.fillRect(
+        ...d.couple(g.topLeft(i)),
+        g.width(i),
+        g.height(i)
+      ), e.erase(i, this.state.clearOverScan, ...at);
+    };
+  }
+  requestRender(e) {
+    const { renderCtx: n } = this.internal;
+    n.loop.set({
+      key: `${Le.TYPE}-${this.key}`,
+      render: this.render.bind(this),
+      priority: e,
+      canvases: at
+    });
+  }
+}
+const Ja = {
+  [Le.TYPE]: Le
+}, Ou = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Diagram: Le,
+  REGISTRY: Ja,
+  diagramStateZ: Xr
+}, Symbol.toStringTag, { value: "Module" }));
+class eo {
+  entries = /* @__PURE__ */ new Map();
+  setListeners = /* @__PURE__ */ new Map();
+  deleteListeners = /* @__PURE__ */ new Map();
+  handleError;
+  equal;
+  constructor(e, n = () => !1) {
+    this.handleError = e, this.equal = n;
+  }
+  setOne(e, n, r, s) {
+    const a = this.entries.get(n), i = ea(r, a);
+    if (!(i == null || a != null && this.equal(i, a, n)))
+      return this.entries.set(n, i), this.notifySet(e, n, i, s), () => {
+        a === void 0 ? (this.entries.delete(n), this.notifyDelete(e, n)) : (this.entries.set(n, a), this.notifySet(e, n, a, s));
+      };
+  }
+  /**
+   * Sets a value for the given key in the store.
+   *
+   * @param key - The key to set
+   * @param value - The value to set, or a function to compute the value from the previous state
+   * @param opts - Options for the set operation
+   * @returns A rollback function that undoes the set operation
+   */
+  set(e, n, r, s) {
+    const a = [];
+    if (Array.isArray(n))
+      n.forEach((i) => {
+        const o = this.setOne(e, i.key, i, r);
+        o != null && a.push(o);
+      });
+    else if (typeof n == "object" && "key" in n) {
+      const i = n, o = this.setOne(e, i.key, i, r);
+      o != null && a.push(o);
+    } else {
+      const i = this.setOne(
+        e,
+        n,
+        r,
+        s
+      );
+      i != null && a.push(i);
+    }
+    return () => a.reverse().forEach((i) => i());
+  }
+  get(e) {
+    return typeof e == "function" ? Array.from(this.entries.values()).filter(e) : Array.isArray(e) ? e.map((n) => this.entries.get(n)).filter((n) => n != null) : this.entries.get(e);
+  }
+  list() {
+    return Array.from(this.entries.values());
+  }
+  has(e) {
+    return Array.isArray(e) ? e.every((n) => this.entries.has(n)) : this.entries.has(e);
+  }
+  /**
+   * Deletes entries from the store and notifies delete listeners.
+   * @param key - The key(s) to delete or a filter function
+   * @param variant - Optional variant data for set operations during rollback
+   * @returns A rollback function that restores the deleted entries
+   */
+  delete(e, n, r) {
+    const s = [];
+    return typeof n == "function" ? this.entries.forEach((a, i) => {
+      n(a, i) && s.push({ key: i, value: a });
+    }) : Zr.toArray(n).forEach((a) => {
+      const i = this.entries.get(a);
+      s.push({ key: a, value: i });
+    }), s.forEach(({ key: a }) => {
+      this.entries.delete(a), this.notifyDelete(e, a);
+    }), () => s.forEach(({ key: a, value: i }) => {
+      i != null && (this.entries.set(a, i), this.notifySet(e, a, i, r));
+    });
+  }
+  clear() {
+    this.entries.clear();
+  }
+  /**
+   * Registers a listener for set operations.
+   *
+   * @param callback - Function to call when a value is set
+   * @param key - Optional key to filter notifications (if provided, only changes to this
+   * key trigger the callback)
+   * @returns A destructor function to remove the listener
+   */
+  onSet(e, n, r) {
+    return this.setListeners.set(n, { scope: e, key: r }), () => this.setListeners.delete(n);
+  }
+  /**
+   * Registers a listener for delete operations.
+   *
+   * @param callback - Function to call when a value is deleted
+   * @param key - Optional key to filter notifications (if provided, only deletion
+   * of this key triggers the callback)
+   * @returns A destructor function to remove the listener
+   */
+  onDelete(e, n, r) {
+    return this.deleteListeners.set(n, { scope: e, key: r }), () => this.deleteListeners.delete(n);
+  }
+  notifySet(e, n, r, s) {
+    this.setListeners.forEach((a, i) => {
+      const o = a.key == null || a.key === n, c = a.scope !== e;
+      o && c && this.handleError(
+        async () => await i(r, s),
+        "Failed to notify set listener"
+      );
+    });
+  }
+  notifyDelete(e, n) {
+    this.deleteListeners.forEach((r, s) => {
+      const a = r.key == null || r.key === n, i = r.scope !== e;
+      a && i && this.handleError(
+        async () => await s(n),
+        "Failed to notify delete listener"
+      );
+    });
+  }
+  scope(e) {
+    return {
+      set: (n, r, s) => this.set(e, n, r, s),
+      get: ((n) => this.get(n)),
+      list: () => this.list(),
+      has: (n) => this.has(n),
+      delete: (n, r) => this.delete(e, n, r),
+      onSet: (n, r) => this.onSet(e, n, r),
+      onDelete: (n, r) => this.onDelete(e, n, r)
+    };
+  }
+}
+const to = (t, e) => Object.fromEntries(
+  Object.entries(t).map(([n, { equal: r }]) => [
+    n,
+    new eo(e, r)
+  ])
+), Wn = (t, e) => Object.fromEntries(
+  Object.entries(t).map(([n]) => [
+    n,
+    t[n].scope(e)
+  ])
+), Nu = (t, e, n) => t.set(e, (r) => r == null ? void 0 : { ...r, ...n }), no = (t, e) => {
+  const n = t.includes("delete"), r = e.includes("delete");
+  return n && !r ? -1 : !n && r ? 1 : 0;
+}, ro = async ({
+  openStreamer: t,
+  storeConfig: e,
+  handleError: n,
+  client: r,
+  store: s
+}) => {
+  const a = Object.values(e), i = Br.unique(
+    a.flatMap(({ listeners: h }) => h.map(({ channel: f }) => f))
+  ), o = {};
+  a.forEach(
+    ({ listeners: h }) => h.forEach((f) => {
+      const { channel: b } = f;
+      o[b] = [...o[b] || [], f];
+    })
+  );
+  const c = await An.HardenedStreamer.open(t, i), l = new An.ObservableStreamer(c), u = (h) => {
+    const f = [...h.uniqueNames];
+    f.sort(no), n(
+      async () => {
+        for (const b of f) {
+          const v = h.get(b), S = o[b];
+          if (S != null)
+            for (const { onChange: T, schema: k } of S)
+              await n(async () => {
+                let L;
+                v.dataType.equals(Qe.JSON) ? L = v.parseJSON(k) : L = Array.from(v).map((D) => k.parse(D));
+                for (const D of L)
+                  await n(
+                    () => T({ changed: D, client: r, store: s }),
+                    `Failed to handle streamer change for ${b}`,
+                    ta
+                  );
+              }, `Failed to parse streamer change for ${b}`);
+        }
+      },
+      `Failed to handle streamer change for ${ha.naturalLanguageJoin(f)}`
+    );
+  };
+  return l.onChange(u), l.close.bind(l);
+};
+class so {
+  store;
+  streamCloser = null;
+  client;
+  constructor({
+    client: e,
+    openStreamer: n,
+    storeConfig: r,
+    handleError: s,
+    handleAsyncError: a
+  }) {
+    this.store = to(r, s), this.client = e, e != null && (n ??= e?.openStreamer.bind(e), this.streamCloser = ro({
+      client: e,
+      storeConfig: r,
+      handleError: a,
+      store: Wn(this.store, ""),
+      openStreamer: n
+    }));
+  }
+  async awaitInitialized() {
+    this.streamCloser != null && await this.streamCloser;
+  }
+  scopedStore(e) {
+    return Wn(this.store, e);
+  }
+  async close() {
+    if (this.streamCloser == null) return;
+    await (await this.streamCloser)();
+  }
+}
+const io = pe.object({
+  request: pe.string(),
+  bounds: pe.record(pe.string(), A.bounds)
+}), ao = pe.object({
+  request: pe.string(),
+  response: io
+});
+class Xt extends Z {
+  static TYPE = "Bounds";
+  schema = ao;
+  afterUpdate(e) {
+    this.state.request !== this.prevState.request && this.setState((n) => ({
+      ...n,
+      response: {
+        request: n.request,
+        bounds: this.internal.getBounds()
+      }
+    }));
+  }
+  render(e) {
+    this.internal.getBounds = e.getBounds;
+  }
+}
+function lt(t, e) {
+  return t == null || e == null ? NaN : t < e ? -1 : t > e ? 1 : t >= e ? 0 : NaN;
+}
+function oo(t, e) {
+  return t == null || e == null ? NaN : e < t ? -1 : e > t ? 1 : e >= t ? 0 : NaN;
+}
+function Cn(t) {
+  let e, n, r;
+  t.length !== 2 ? (e = lt, n = (o, c) => lt(t(o), c), r = (o, c) => t(o) - c) : (e = t === lt || t === oo ? t : lo, n = t, r = t);
+  function s(o, c, l = 0, u = o.length) {
+    if (l < u) {
+      if (e(c, c) !== 0) return u;
+      do {
+        const h = l + u >>> 1;
+        n(o[h], c) < 0 ? l = h + 1 : u = h;
+      } while (l < u);
+    }
+    return l;
+  }
+  function a(o, c, l = 0, u = o.length) {
+    if (l < u) {
+      if (e(c, c) !== 0) return u;
+      do {
+        const h = l + u >>> 1;
+        n(o[h], c) <= 0 ? l = h + 1 : u = h;
+      } while (l < u);
+    }
+    return l;
+  }
+  function i(o, c, l = 0, u = o.length) {
+    const h = s(o, c, l, u - 1);
+    return h > l && r(o[h - 1], c) > -r(o[h], c) ? h - 1 : h;
+  }
+  return { left: s, center: i, right: a };
+}
+function lo() {
+  return 0;
+}
+function co(t) {
+  return t === null ? NaN : +t;
+}
+const uo = Cn(lt), ho = uo.right;
+Cn(co).center;
+const fo = Math.sqrt(50), go = Math.sqrt(10), po = Math.sqrt(2);
+function ft(t, e, n) {
+  const r = (e - t) / Math.max(0, n), s = Math.floor(Math.log10(r)), a = r / Math.pow(10, s), i = a >= fo ? 10 : a >= go ? 5 : a >= po ? 2 : 1;
+  let o, c, l;
+  return s < 0 ? (l = Math.pow(10, -s) / i, o = Math.round(t * l), c = Math.round(e * l), o / l < t && ++o, c / l > e && --c, l = -l) : (l = Math.pow(10, s) * i, o = Math.round(t / l), c = Math.round(e / l), o * l < t && ++o, c * l > e && --c), c < o && 0.5 <= n && n < 2 ? ft(t, e, n * 2) : [o, c, l];
+}
+function mo(t, e, n) {
+  if (e = +e, t = +t, n = +n, !(n > 0)) return [];
+  if (t === e) return [t];
+  const r = e < t, [s, a, i] = r ? ft(e, t, n) : ft(t, e, n);
+  if (!(a >= s)) return [];
+  const o = a - s + 1, c = new Array(o);
+  if (r)
+    if (i < 0) for (let l = 0; l < o; ++l) c[l] = (a - l) / -i;
+    else for (let l = 0; l < o; ++l) c[l] = (a - l) * i;
+  else if (i < 0) for (let l = 0; l < o; ++l) c[l] = (s + l) / -i;
+  else for (let l = 0; l < o; ++l) c[l] = (s + l) * i;
+  return c;
+}
+function Vt(t, e, n) {
+  return e = +e, t = +t, n = +n, ft(t, e, n)[2];
+}
+function Gt(t, e, n) {
+  e = +e, t = +t, n = +n;
+  const r = e < t, s = r ? Vt(e, t, n) : Vt(t, e, n);
+  return (r ? -1 : 1) * (s < 0 ? 1 / -s : s);
+}
+function Vr(t, e) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      this.range(t);
+      break;
+    default:
+      this.range(e).domain(t);
+      break;
+  }
+  return this;
+}
+function yo(t) {
+  return function() {
+    return t;
+  };
+}
+function bo(t) {
+  return +t;
+}
+var Xn = [0, 1];
+function Re(t) {
+  return t;
+}
+function Kt(t, e) {
+  return (e -= t = +t) ? function(n) {
+    return (n - t) / e;
+  } : yo(isNaN(e) ? NaN : 0.5);
+}
+function xo(t, e) {
+  var n;
+  return t > e && (n = t, t = e, e = n), function(r) {
+    return Math.max(t, Math.min(e, r));
+  };
+}
+function So(t, e, n) {
+  var r = t[0], s = t[1], a = e[0], i = e[1];
+  return s < r ? (r = Kt(s, r), a = n(i, a)) : (r = Kt(r, s), a = n(a, i)), function(o) {
+    return a(r(o));
+  };
+}
+function vo(t, e, n) {
+  var r = Math.min(t.length, e.length) - 1, s = new Array(r), a = new Array(r), i = -1;
+  for (t[r] < t[0] && (t = t.slice().reverse(), e = e.slice().reverse()); ++i < r; )
+    s[i] = Kt(t[i], t[i + 1]), a[i] = n(e[i], e[i + 1]);
+  return function(o) {
+    var c = ho(t, o, 1, r) - 1;
+    return a[c](s[c](o));
+  };
+}
+function Gr(t, e) {
+  return e.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown());
+}
+function To() {
+  var t = Xn, e = Xn, n = wn, r, s, a, i = Re, o, c, l;
+  function u() {
+    var f = Math.min(t.length, e.length);
+    return i !== Re && (i = xo(t[0], t[f - 1])), o = f > 2 ? vo : So, c = l = null, h;
+  }
+  function h(f) {
+    return f == null || isNaN(f = +f) ? a : (c || (c = o(t.map(r), e, n)))(r(i(f)));
+  }
+  return h.invert = function(f) {
+    return i(s((l || (l = o(e, t.map(r), dt)))(f)));
+  }, h.domain = function(f) {
+    return arguments.length ? (t = Array.from(f, bo), u()) : t.slice();
+  }, h.range = function(f) {
+    return arguments.length ? (e = Array.from(f), u()) : e.slice();
+  }, h.rangeRound = function(f) {
+    return e = Array.from(f), n = Ia, u();
+  }, h.clamp = function(f) {
+    return arguments.length ? (i = f ? !0 : Re, u()) : i !== Re;
+  }, h.interpolate = function(f) {
+    return arguments.length ? (n = f, u()) : n;
+  }, h.unknown = function(f) {
+    return arguments.length ? (a = f, h) : a;
+  }, function(f, b) {
+    return r = f, s = b, u();
+  };
+}
+function Kr() {
+  return To()(Re, Re);
+}
+function wo(t) {
+  return Math.abs(t = Math.round(t)) >= 1e21 ? t.toLocaleString("en").replace(/,/g, "") : t.toString(10);
+}
+function gt(t, e) {
+  if ((n = (t = e ? t.toExponential(e - 1) : t.toExponential()).indexOf("e")) < 0) return null;
+  var n, r = t.slice(0, n);
+  return [
+    r.length > 1 ? r[0] + r.slice(2) : r,
+    +t.slice(n + 1)
+  ];
+}
+function Ae(t) {
+  return t = gt(Math.abs(t)), t ? t[1] : NaN;
+}
+function Co(t, e) {
+  return function(n, r) {
+    for (var s = n.length, a = [], i = 0, o = t[0], c = 0; s > 0 && o > 0 && (c + o + 1 > r && (o = Math.max(1, r - c)), a.push(n.substring(s -= o, s + o)), !((c += o + 1) > r)); )
+      o = t[i = (i + 1) % t.length];
+    return a.reverse().join(e);
+  };
+}
+function Eo(t) {
+  return function(e) {
+    return e.replace(/[0-9]/g, function(n) {
+      return t[+n];
+    });
+  };
+}
+var Ro = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+function pt(t) {
+  if (!(e = Ro.exec(t))) throw new Error("invalid format: " + t);
+  var e;
+  return new En({
+    fill: e[1],
+    align: e[2],
+    sign: e[3],
+    symbol: e[4],
+    zero: e[5],
+    width: e[6],
+    comma: e[7],
+    precision: e[8] && e[8].slice(1),
+    trim: e[9],
+    type: e[10]
+  });
+}
+pt.prototype = En.prototype;
+function En(t) {
+  this.fill = t.fill === void 0 ? " " : t.fill + "", this.align = t.align === void 0 ? ">" : t.align + "", this.sign = t.sign === void 0 ? "-" : t.sign + "", this.symbol = t.symbol === void 0 ? "" : t.symbol + "", this.zero = !!t.zero, this.width = t.width === void 0 ? void 0 : +t.width, this.comma = !!t.comma, this.precision = t.precision === void 0 ? void 0 : +t.precision, this.trim = !!t.trim, this.type = t.type === void 0 ? "" : t.type + "";
+}
+En.prototype.toString = function() {
+  return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+};
+function ko(t) {
+  e: for (var e = t.length, n = 1, r = -1, s; n < e; ++n)
+    switch (t[n]) {
+      case ".":
+        r = s = n;
+        break;
+      case "0":
+        r === 0 && (r = n), s = n;
+        break;
+      default:
+        if (!+t[n]) break e;
+        r > 0 && (r = 0);
+        break;
+    }
+  return r > 0 ? t.slice(0, r) + t.slice(s + 1) : t;
+}
+var Qr;
+function Do(t, e) {
+  var n = gt(t, e);
+  if (!n) return t + "";
+  var r = n[0], s = n[1], a = s - (Qr = Math.max(-8, Math.min(8, Math.floor(s / 3))) * 3) + 1, i = r.length;
+  return a === i ? r : a > i ? r + new Array(a - i + 1).join("0") : a > 0 ? r.slice(0, a) + "." + r.slice(a) : "0." + new Array(1 - a).join("0") + gt(t, Math.max(0, e + a - 1))[0];
+}
+function Vn(t, e) {
+  var n = gt(t, e);
+  if (!n) return t + "";
+  var r = n[0], s = n[1];
+  return s < 0 ? "0." + new Array(-s).join("0") + r : r.length > s + 1 ? r.slice(0, s + 1) + "." + r.slice(s + 1) : r + new Array(s - r.length + 2).join("0");
+}
+const Gn = {
+  "%": (t, e) => (t * 100).toFixed(e),
+  b: (t) => Math.round(t).toString(2),
+  c: (t) => t + "",
+  d: wo,
+  e: (t, e) => t.toExponential(e),
+  f: (t, e) => t.toFixed(e),
+  g: (t, e) => t.toPrecision(e),
+  o: (t) => Math.round(t).toString(8),
+  p: (t, e) => Vn(t * 100, e),
+  r: Vn,
+  s: Do,
+  X: (t) => Math.round(t).toString(16).toUpperCase(),
+  x: (t) => Math.round(t).toString(16)
+};
+function Kn(t) {
+  return t;
+}
+var Qn = Array.prototype.map, Jn = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+function Mo(t) {
+  var e = t.grouping === void 0 || t.thousands === void 0 ? Kn : Co(Qn.call(t.grouping, Number), t.thousands + ""), n = t.currency === void 0 ? "" : t.currency[0] + "", r = t.currency === void 0 ? "" : t.currency[1] + "", s = t.decimal === void 0 ? "." : t.decimal + "", a = t.numerals === void 0 ? Kn : Eo(Qn.call(t.numerals, String)), i = t.percent === void 0 ? "%" : t.percent + "", o = t.minus === void 0 ? "−" : t.minus + "", c = t.nan === void 0 ? "NaN" : t.nan + "";
+  function l(h) {
+    h = pt(h);
+    var f = h.fill, b = h.align, v = h.sign, S = h.symbol, T = h.zero, k = h.width, L = h.comma, D = h.precision, N = h.trim, _ = h.type;
+    _ === "n" ? (L = !0, _ = "g") : Gn[_] || (D === void 0 && (D = 12), N = !0, _ = "g"), (T || f === "0" && b === "=") && (T = !0, f = "0", b = "=");
+    var w = S === "$" ? n : S === "#" && /[boxX]/.test(_) ? "0" + _.toLowerCase() : "", I = S === "$" ? r : /[%p]/.test(_) ? i : "", ce = Gn[_], Ie = /[defgprs%]/.test(_);
+    D = D === void 0 ? 6 : /[gprs]/.test(_) ? Math.max(1, Math.min(21, D)) : Math.max(0, Math.min(20, D));
+    function nt(R) {
+      var se = w, B = I, ue, rt, Te;
+      if (_ === "c")
+        B = ce(R) + B, R = "";
+      else {
+        R = +R;
+        var we = R < 0 || 1 / R < 0;
+        if (R = isNaN(R) ? c : ce(Math.abs(R), D), N && (R = ko(R)), we && +R == 0 && v !== "+" && (we = !1), se = (we ? v === "(" ? v : o : v === "-" || v === "(" ? "" : v) + se, B = (_ === "s" ? Jn[8 + Qr / 3] : "") + B + (we && v === "(" ? ")" : ""), Ie) {
+          for (ue = -1, rt = R.length; ++ue < rt; )
+            if (Te = R.charCodeAt(ue), 48 > Te || Te > 57) {
+              B = (Te === 46 ? s + R.slice(ue + 1) : R.slice(ue)) + B, R = R.slice(0, ue);
+              break;
+            }
+        }
+      }
+      L && !T && (R = e(R, 1 / 0));
+      var Ce = se.length + R.length + B.length, J = Ce < k ? new Array(k - Ce + 1).join(f) : "";
+      switch (L && T && (R = e(J + R, J.length ? k - B.length : 1 / 0), J = ""), b) {
+        case "<":
+          R = se + R + B + J;
+          break;
+        case "=":
+          R = se + J + R + B;
+          break;
+        case "^":
+          R = J.slice(0, Ce = J.length >> 1) + se + R + B + J.slice(Ce);
+          break;
+        default:
+          R = J + se + R + B;
+          break;
+      }
+      return a(R);
+    }
+    return nt.toString = function() {
+      return h + "";
+    }, nt;
+  }
+  function u(h, f) {
+    var b = l((h = pt(h), h.type = "f", h)), v = Math.max(-8, Math.min(8, Math.floor(Ae(f) / 3))) * 3, S = Math.pow(10, -v), T = Jn[8 + v / 3];
+    return function(k) {
+      return b(S * k) + T;
+    };
+  }
+  return {
+    format: l,
+    formatPrefix: u
+  };
+}
+var ot, Jr, es;
+Po({
+  thousands: ",",
+  grouping: [3],
+  currency: ["$", ""]
+});
+function Po(t) {
+  return ot = Mo(t), Jr = ot.format, es = ot.formatPrefix, ot;
+}
+function Lo(t) {
+  return Math.max(0, -Ae(Math.abs(t)));
+}
+function Ao(t, e) {
+  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(Ae(e) / 3))) * 3 - Ae(Math.abs(t)));
+}
+function Oo(t, e) {
+  return t = Math.abs(t), e = Math.abs(e) - t, Math.max(0, Ae(e) - Ae(t)) + 1;
+}
+function No(t, e, n, r) {
+  var s = Gt(t, e, n), a;
+  switch (r = pt(r ?? ",f"), r.type) {
+    case "s": {
+      var i = Math.max(Math.abs(t), Math.abs(e));
+      return r.precision == null && !isNaN(a = Ao(s, i)) && (r.precision = a), es(r, i);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      r.precision == null && !isNaN(a = Oo(s, Math.max(Math.abs(t), Math.abs(e)))) && (r.precision = a - (r.type === "e"));
+      break;
+    }
+    case "f":
+    case "%": {
+      r.precision == null && !isNaN(a = Lo(s)) && (r.precision = a - (r.type === "%") * 2);
+      break;
+    }
+  }
+  return Jr(r);
+}
+function _o(t) {
+  var e = t.domain;
+  return t.ticks = function(n) {
+    var r = e();
+    return mo(r[0], r[r.length - 1], n ?? 10);
+  }, t.tickFormat = function(n, r) {
+    var s = e();
+    return No(s[0], s[s.length - 1], n ?? 10, r);
+  }, t.nice = function(n) {
+    n == null && (n = 10);
+    var r = e(), s = 0, a = r.length - 1, i = r[s], o = r[a], c, l, u = 10;
+    for (o < i && (l = i, i = o, o = l, l = s, s = a, a = l); u-- > 0; ) {
+      if (l = Vt(i, o, n), l === c)
+        return r[s] = i, r[a] = o, e(r);
+      if (l > 0)
+        i = Math.floor(i / l) * l, o = Math.ceil(o / l) * l;
+      else if (l < 0)
+        i = Math.ceil(i * l) / l, o = Math.floor(o * l) / l;
+      else
+        break;
+      c = l;
+    }
+    return t;
+  }, t;
+}
+function ts() {
+  var t = Kr();
+  return t.copy = function() {
+    return Gr(t, ts());
+  }, Vr.apply(t, arguments), _o(t);
+}
+function Io(t, e) {
+  t = t.slice();
+  var n = 0, r = t.length - 1, s = t[n], a = t[r], i;
+  return a < s && (i = n, n = r, r = i, i = s, s = a, a = i), t[n] = e.floor(s), t[r] = e.ceil(a), t;
+}
+const Yt = /* @__PURE__ */ new Date(), Ut = /* @__PURE__ */ new Date();
+function Y(t, e, n, r) {
+  function s(a) {
+    return t(a = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+a)), a;
+  }
+  return s.floor = (a) => (t(a = /* @__PURE__ */ new Date(+a)), a), s.ceil = (a) => (t(a = new Date(a - 1)), e(a, 1), t(a), a), s.round = (a) => {
+    const i = s(a), o = s.ceil(a);
+    return a - i < o - a ? i : o;
+  }, s.offset = (a, i) => (e(a = /* @__PURE__ */ new Date(+a), i == null ? 1 : Math.floor(i)), a), s.range = (a, i, o) => {
+    const c = [];
+    if (a = s.ceil(a), o = o == null ? 1 : Math.floor(o), !(a < i) || !(o > 0)) return c;
+    let l;
+    do
+      c.push(l = /* @__PURE__ */ new Date(+a)), e(a, o), t(a);
+    while (l < a && a < i);
+    return c;
+  }, s.filter = (a) => Y((i) => {
+    if (i >= i) for (; t(i), !a(i); ) i.setTime(i - 1);
+  }, (i, o) => {
+    if (i >= i)
+      if (o < 0) for (; ++o <= 0; )
+        for (; e(i, -1), !a(i); )
+          ;
+      else for (; --o >= 0; )
+        for (; e(i, 1), !a(i); )
+          ;
+  }), n && (s.count = (a, i) => (Yt.setTime(+a), Ut.setTime(+i), t(Yt), t(Ut), Math.floor(n(Yt, Ut))), s.every = (a) => (a = Math.floor(a), !isFinite(a) || !(a > 0) ? null : a > 1 ? s.filter(r ? (i) => r(i) % a === 0 : (i) => s.count(0, i) % a === 0) : s)), s;
+}
+const mt = Y(() => {
+}, (t, e) => {
+  t.setTime(+t + e);
+}, (t, e) => e - t);
+mt.every = (t) => (t = Math.floor(t), !isFinite(t) || !(t > 0) ? null : t > 1 ? Y((e) => {
+  e.setTime(Math.floor(e / t) * t);
+}, (e, n) => {
+  e.setTime(+e + n * t);
+}, (e, n) => (n - e) / t) : mt);
+mt.range;
+const ie = 1e3, X = ie * 60, ae = X * 60, oe = ae * 24, Rn = oe * 7, er = oe * 30, Zt = oe * 365, ke = Y((t) => {
+  t.setTime(t - t.getMilliseconds());
+}, (t, e) => {
+  t.setTime(+t + e * ie);
+}, (t, e) => (e - t) / ie, (t) => t.getUTCSeconds());
+ke.range;
+const kn = Y((t) => {
+  t.setTime(t - t.getMilliseconds() - t.getSeconds() * ie);
+}, (t, e) => {
+  t.setTime(+t + e * X);
+}, (t, e) => (e - t) / X, (t) => t.getMinutes());
+kn.range;
+const Yo = Y((t) => {
+  t.setUTCSeconds(0, 0);
+}, (t, e) => {
+  t.setTime(+t + e * X);
+}, (t, e) => (e - t) / X, (t) => t.getUTCMinutes());
+Yo.range;
+const Dn = Y((t) => {
+  t.setTime(t - t.getMilliseconds() - t.getSeconds() * ie - t.getMinutes() * X);
+}, (t, e) => {
+  t.setTime(+t + e * ae);
+}, (t, e) => (e - t) / ae, (t) => t.getHours());
+Dn.range;
+const Uo = Y((t) => {
+  t.setUTCMinutes(0, 0, 0);
+}, (t, e) => {
+  t.setTime(+t + e * ae);
+}, (t, e) => (e - t) / ae, (t) => t.getUTCHours());
+Uo.range;
+const et = Y(
+  (t) => t.setHours(0, 0, 0, 0),
+  (t, e) => t.setDate(t.getDate() + e),
+  (t, e) => (e - t - (e.getTimezoneOffset() - t.getTimezoneOffset()) * X) / oe,
+  (t) => t.getDate() - 1
+);
+et.range;
+const Mn = Y((t) => {
+  t.setUTCHours(0, 0, 0, 0);
+}, (t, e) => {
+  t.setUTCDate(t.getUTCDate() + e);
+}, (t, e) => (e - t) / oe, (t) => t.getUTCDate() - 1);
+Mn.range;
+const Zo = Y((t) => {
+  t.setUTCHours(0, 0, 0, 0);
+}, (t, e) => {
+  t.setUTCDate(t.getUTCDate() + e);
+}, (t, e) => (e - t) / oe, (t) => Math.floor(t / oe));
+Zo.range;
+function xe(t) {
+  return Y((e) => {
+    e.setDate(e.getDate() - (e.getDay() + 7 - t) % 7), e.setHours(0, 0, 0, 0);
+  }, (e, n) => {
+    e.setDate(e.getDate() + n * 7);
+  }, (e, n) => (n - e - (n.getTimezoneOffset() - e.getTimezoneOffset()) * X) / Rn);
+}
+const At = xe(0), yt = xe(1), Bo = xe(2), Fo = xe(3), Oe = xe(4), $o = xe(5), qo = xe(6);
+At.range;
+yt.range;
+Bo.range;
+Fo.range;
+Oe.range;
+$o.range;
+qo.range;
+function Se(t) {
+  return Y((e) => {
+    e.setUTCDate(e.getUTCDate() - (e.getUTCDay() + 7 - t) % 7), e.setUTCHours(0, 0, 0, 0);
+  }, (e, n) => {
+    e.setUTCDate(e.getUTCDate() + n * 7);
+  }, (e, n) => (n - e) / Rn);
+}
+const ns = Se(0), bt = Se(1), Ho = Se(2), jo = Se(3), Ne = Se(4), zo = Se(5), Wo = Se(6);
+ns.range;
+bt.range;
+Ho.range;
+jo.range;
+Ne.range;
+zo.range;
+Wo.range;
+const Pn = Y((t) => {
+  t.setDate(1), t.setHours(0, 0, 0, 0);
+}, (t, e) => {
+  t.setMonth(t.getMonth() + e);
+}, (t, e) => e.getMonth() - t.getMonth() + (e.getFullYear() - t.getFullYear()) * 12, (t) => t.getMonth());
+Pn.range;
+const Xo = Y((t) => {
+  t.setUTCDate(1), t.setUTCHours(0, 0, 0, 0);
+}, (t, e) => {
+  t.setUTCMonth(t.getUTCMonth() + e);
+}, (t, e) => e.getUTCMonth() - t.getUTCMonth() + (e.getUTCFullYear() - t.getUTCFullYear()) * 12, (t) => t.getUTCMonth());
+Xo.range;
+const le = Y((t) => {
+  t.setMonth(0, 1), t.setHours(0, 0, 0, 0);
+}, (t, e) => {
+  t.setFullYear(t.getFullYear() + e);
+}, (t, e) => e.getFullYear() - t.getFullYear(), (t) => t.getFullYear());
+le.every = (t) => !isFinite(t = Math.floor(t)) || !(t > 0) ? null : Y((e) => {
+  e.setFullYear(Math.floor(e.getFullYear() / t) * t), e.setMonth(0, 1), e.setHours(0, 0, 0, 0);
+}, (e, n) => {
+  e.setFullYear(e.getFullYear() + n * t);
+});
+le.range;
+const be = Y((t) => {
+  t.setUTCMonth(0, 1), t.setUTCHours(0, 0, 0, 0);
+}, (t, e) => {
+  t.setUTCFullYear(t.getUTCFullYear() + e);
+}, (t, e) => e.getUTCFullYear() - t.getUTCFullYear(), (t) => t.getUTCFullYear());
+be.every = (t) => !isFinite(t = Math.floor(t)) || !(t > 0) ? null : Y((e) => {
+  e.setUTCFullYear(Math.floor(e.getUTCFullYear() / t) * t), e.setUTCMonth(0, 1), e.setUTCHours(0, 0, 0, 0);
+}, (e, n) => {
+  e.setUTCFullYear(e.getUTCFullYear() + n * t);
+});
+be.range;
+function Vo(t, e, n, r, s, a) {
+  const i = [
+    [ke, 1, ie],
+    [ke, 5, 5 * ie],
+    [ke, 15, 15 * ie],
+    [ke, 30, 30 * ie],
+    [a, 1, X],
+    [a, 5, 5 * X],
+    [a, 15, 15 * X],
+    [a, 30, 30 * X],
+    [s, 1, ae],
+    [s, 3, 3 * ae],
+    [s, 6, 6 * ae],
+    [s, 12, 12 * ae],
+    [r, 1, oe],
+    [r, 2, 2 * oe],
+    [n, 1, Rn],
+    [e, 1, er],
+    [e, 3, 3 * er],
+    [t, 1, Zt]
+  ];
+  function o(l, u, h) {
+    const f = u < l;
+    f && ([l, u] = [u, l]);
+    const b = h && typeof h.range == "function" ? h : c(l, u, h), v = b ? b.range(l, +u + 1) : [];
+    return f ? v.reverse() : v;
+  }
+  function c(l, u, h) {
+    const f = Math.abs(u - l) / h, b = Cn(([, , T]) => T).right(i, f);
+    if (b === i.length) return t.every(Gt(l / Zt, u / Zt, h));
+    if (b === 0) return mt.every(Math.max(Gt(l, u, h), 1));
+    const [v, S] = i[f / i[b - 1][2] < i[b][2] / f ? b - 1 : b];
+    return v.every(S);
+  }
+  return [o, c];
+}
+const [Go, Ko] = Vo(le, Pn, At, et, Dn, kn);
+function Bt(t) {
+  if (0 <= t.y && t.y < 100) {
+    var e = new Date(-1, t.m, t.d, t.H, t.M, t.S, t.L);
+    return e.setFullYear(t.y), e;
+  }
+  return new Date(t.y, t.m, t.d, t.H, t.M, t.S, t.L);
+}
+function Ft(t) {
+  if (0 <= t.y && t.y < 100) {
+    var e = new Date(Date.UTC(-1, t.m, t.d, t.H, t.M, t.S, t.L));
+    return e.setUTCFullYear(t.y), e;
+  }
+  return new Date(Date.UTC(t.y, t.m, t.d, t.H, t.M, t.S, t.L));
+}
+function Ye(t, e, n) {
+  return { y: t, m: e, d: n, H: 0, M: 0, S: 0, L: 0 };
+}
+function Qo(t) {
+  var e = t.dateTime, n = t.date, r = t.time, s = t.periods, a = t.days, i = t.shortDays, o = t.months, c = t.shortMonths, l = Ue(s), u = Ze(s), h = Ue(a), f = Ze(a), b = Ue(i), v = Ze(i), S = Ue(o), T = Ze(o), k = Ue(c), L = Ze(c), D = {
+    a: we,
+    A: Ce,
+    b: J,
+    B: Ss,
+    c: null,
+    d: ar,
+    e: ar,
+    f: vl,
+    g: Ll,
+    G: Ol,
+    H: bl,
+    I: xl,
+    j: Sl,
+    L: rs,
+    m: Tl,
+    M: wl,
+    p: vs,
+    q: Ts,
+    Q: cr,
+    s: ur,
+    S: Cl,
+    u: El,
+    U: Rl,
+    V: kl,
+    w: Dl,
+    W: Ml,
+    x: null,
+    X: null,
+    y: Pl,
+    Y: Al,
+    Z: Nl,
+    "%": lr
+  }, N = {
+    a: ws,
+    A: Cs,
+    b: Es,
+    B: Rs,
+    c: null,
+    d: or,
+    e: or,
+    f: Ul,
+    g: Xl,
+    G: Gl,
+    H: _l,
+    I: Il,
+    j: Yl,
+    L: is,
+    m: Zl,
+    M: Bl,
+    p: ks,
+    q: Ds,
+    Q: cr,
+    s: ur,
+    S: Fl,
+    u: $l,
+    U: ql,
+    V: Hl,
+    w: jl,
+    W: zl,
+    x: null,
+    X: null,
+    y: Wl,
+    Y: Vl,
+    Z: Kl,
+    "%": lr
+  }, _ = {
+    a: nt,
+    A: R,
+    b: se,
+    B,
+    c: ue,
+    d: sr,
+    e: sr,
+    f: gl,
+    g: rr,
+    G: nr,
+    H: ir,
+    I: ir,
+    j: ul,
+    L: fl,
+    m: cl,
+    M: hl,
+    p: Ie,
+    q: ll,
+    Q: ml,
+    s: yl,
+    S: dl,
+    u: rl,
+    U: sl,
+    V: il,
+    w: nl,
+    W: al,
+    x: rt,
+    X: Te,
+    y: rr,
+    Y: nr,
+    Z: ol,
+    "%": pl
+  };
+  D.x = w(n, D), D.X = w(r, D), D.c = w(e, D), N.x = w(n, N), N.X = w(r, N), N.c = w(e, N);
+  function w(x, E) {
+    return function(M) {
+      var m = [], F = -1, O = 0, z = x.length, W, ge, Ln;
+      for (M instanceof Date || (M = /* @__PURE__ */ new Date(+M)); ++F < z; )
+        x.charCodeAt(F) === 37 && (m.push(x.slice(O, F)), (ge = tr[W = x.charAt(++F)]) != null ? W = x.charAt(++F) : ge = W === "e" ? " " : "0", (Ln = E[W]) && (W = Ln(M, ge)), m.push(W), O = F + 1);
+      return m.push(x.slice(O, F)), m.join("");
+    };
+  }
+  function I(x, E) {
+    return function(M) {
+      var m = Ye(1900, void 0, 1), F = ce(m, x, M += "", 0), O, z;
+      if (F != M.length) return null;
+      if ("Q" in m) return new Date(m.Q);
+      if ("s" in m) return new Date(m.s * 1e3 + ("L" in m ? m.L : 0));
+      if (E && !("Z" in m) && (m.Z = 0), "p" in m && (m.H = m.H % 12 + m.p * 12), m.m === void 0 && (m.m = "q" in m ? m.q : 0), "V" in m) {
+        if (m.V < 1 || m.V > 53) return null;
+        "w" in m || (m.w = 1), "Z" in m ? (O = Ft(Ye(m.y, 0, 1)), z = O.getUTCDay(), O = z > 4 || z === 0 ? bt.ceil(O) : bt(O), O = Mn.offset(O, (m.V - 1) * 7), m.y = O.getUTCFullYear(), m.m = O.getUTCMonth(), m.d = O.getUTCDate() + (m.w + 6) % 7) : (O = Bt(Ye(m.y, 0, 1)), z = O.getDay(), O = z > 4 || z === 0 ? yt.ceil(O) : yt(O), O = et.offset(O, (m.V - 1) * 7), m.y = O.getFullYear(), m.m = O.getMonth(), m.d = O.getDate() + (m.w + 6) % 7);
+      } else ("W" in m || "U" in m) && ("w" in m || (m.w = "u" in m ? m.u % 7 : "W" in m ? 1 : 0), z = "Z" in m ? Ft(Ye(m.y, 0, 1)).getUTCDay() : Bt(Ye(m.y, 0, 1)).getDay(), m.m = 0, m.d = "W" in m ? (m.w + 6) % 7 + m.W * 7 - (z + 5) % 7 : m.w + m.U * 7 - (z + 6) % 7);
+      return "Z" in m ? (m.H += m.Z / 100 | 0, m.M += m.Z % 100, Ft(m)) : Bt(m);
+    };
+  }
+  function ce(x, E, M, m) {
+    for (var F = 0, O = E.length, z = M.length, W, ge; F < O; ) {
+      if (m >= z) return -1;
+      if (W = E.charCodeAt(F++), W === 37) {
+        if (W = E.charAt(F++), ge = _[W in tr ? E.charAt(F++) : W], !ge || (m = ge(x, M, m)) < 0) return -1;
+      } else if (W != M.charCodeAt(m++))
+        return -1;
+    }
+    return m;
+  }
+  function Ie(x, E, M) {
+    var m = l.exec(E.slice(M));
+    return m ? (x.p = u.get(m[0].toLowerCase()), M + m[0].length) : -1;
+  }
+  function nt(x, E, M) {
+    var m = b.exec(E.slice(M));
+    return m ? (x.w = v.get(m[0].toLowerCase()), M + m[0].length) : -1;
+  }
+  function R(x, E, M) {
+    var m = h.exec(E.slice(M));
+    return m ? (x.w = f.get(m[0].toLowerCase()), M + m[0].length) : -1;
+  }
+  function se(x, E, M) {
+    var m = k.exec(E.slice(M));
+    return m ? (x.m = L.get(m[0].toLowerCase()), M + m[0].length) : -1;
+  }
+  function B(x, E, M) {
+    var m = S.exec(E.slice(M));
+    return m ? (x.m = T.get(m[0].toLowerCase()), M + m[0].length) : -1;
+  }
+  function ue(x, E, M) {
+    return ce(x, e, E, M);
+  }
+  function rt(x, E, M) {
+    return ce(x, n, E, M);
+  }
+  function Te(x, E, M) {
+    return ce(x, r, E, M);
+  }
+  function we(x) {
+    return i[x.getDay()];
+  }
+  function Ce(x) {
+    return a[x.getDay()];
+  }
+  function J(x) {
+    return c[x.getMonth()];
+  }
+  function Ss(x) {
+    return o[x.getMonth()];
+  }
+  function vs(x) {
+    return s[+(x.getHours() >= 12)];
+  }
+  function Ts(x) {
+    return 1 + ~~(x.getMonth() / 3);
+  }
+  function ws(x) {
+    return i[x.getUTCDay()];
+  }
+  function Cs(x) {
+    return a[x.getUTCDay()];
+  }
+  function Es(x) {
+    return c[x.getUTCMonth()];
+  }
+  function Rs(x) {
+    return o[x.getUTCMonth()];
+  }
+  function ks(x) {
+    return s[+(x.getUTCHours() >= 12)];
+  }
+  function Ds(x) {
+    return 1 + ~~(x.getUTCMonth() / 3);
+  }
+  return {
+    format: function(x) {
+      var E = w(x += "", D);
+      return E.toString = function() {
+        return x;
+      }, E;
+    },
+    parse: function(x) {
+      var E = I(x += "", !1);
+      return E.toString = function() {
+        return x;
+      }, E;
+    },
+    utcFormat: function(x) {
+      var E = w(x += "", N);
+      return E.toString = function() {
+        return x;
+      }, E;
+    },
+    utcParse: function(x) {
+      var E = I(x += "", !0);
+      return E.toString = function() {
+        return x;
+      }, E;
+    }
+  };
+}
+var tr = { "-": "", _: " ", 0: "0" }, U = /^\s*\d+/, Jo = /^%/, el = /[\\^$*+?|[\]().{}]/g;
+function P(t, e, n) {
+  var r = t < 0 ? "-" : "", s = (r ? -t : t) + "", a = s.length;
+  return r + (a < n ? new Array(n - a + 1).join(e) + s : s);
+}
+function tl(t) {
+  return t.replace(el, "\\$&");
+}
+function Ue(t) {
+  return new RegExp("^(?:" + t.map(tl).join("|") + ")", "i");
+}
+function Ze(t) {
+  return new Map(t.map((e, n) => [e.toLowerCase(), n]));
+}
+function nl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 1));
+  return r ? (t.w = +r[0], n + r[0].length) : -1;
+}
+function rl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 1));
+  return r ? (t.u = +r[0], n + r[0].length) : -1;
+}
+function sl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.U = +r[0], n + r[0].length) : -1;
+}
+function il(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.V = +r[0], n + r[0].length) : -1;
+}
+function al(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.W = +r[0], n + r[0].length) : -1;
+}
+function nr(t, e, n) {
+  var r = U.exec(e.slice(n, n + 4));
+  return r ? (t.y = +r[0], n + r[0].length) : -1;
+}
+function rr(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.y = +r[0] + (+r[0] > 68 ? 1900 : 2e3), n + r[0].length) : -1;
+}
+function ol(t, e, n) {
+  var r = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(e.slice(n, n + 6));
+  return r ? (t.Z = r[1] ? 0 : -(r[2] + (r[3] || "00")), n + r[0].length) : -1;
+}
+function ll(t, e, n) {
+  var r = U.exec(e.slice(n, n + 1));
+  return r ? (t.q = r[0] * 3 - 3, n + r[0].length) : -1;
+}
+function cl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.m = r[0] - 1, n + r[0].length) : -1;
+}
+function sr(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.d = +r[0], n + r[0].length) : -1;
+}
+function ul(t, e, n) {
+  var r = U.exec(e.slice(n, n + 3));
+  return r ? (t.m = 0, t.d = +r[0], n + r[0].length) : -1;
+}
+function ir(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.H = +r[0], n + r[0].length) : -1;
+}
+function hl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.M = +r[0], n + r[0].length) : -1;
+}
+function dl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 2));
+  return r ? (t.S = +r[0], n + r[0].length) : -1;
+}
+function fl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 3));
+  return r ? (t.L = +r[0], n + r[0].length) : -1;
+}
+function gl(t, e, n) {
+  var r = U.exec(e.slice(n, n + 6));
+  return r ? (t.L = Math.floor(r[0] / 1e3), n + r[0].length) : -1;
+}
+function pl(t, e, n) {
+  var r = Jo.exec(e.slice(n, n + 1));
+  return r ? n + r[0].length : -1;
+}
+function ml(t, e, n) {
+  var r = U.exec(e.slice(n));
+  return r ? (t.Q = +r[0], n + r[0].length) : -1;
+}
+function yl(t, e, n) {
+  var r = U.exec(e.slice(n));
+  return r ? (t.s = +r[0], n + r[0].length) : -1;
+}
+function ar(t, e) {
+  return P(t.getDate(), e, 2);
+}
+function bl(t, e) {
+  return P(t.getHours(), e, 2);
+}
+function xl(t, e) {
+  return P(t.getHours() % 12 || 12, e, 2);
+}
+function Sl(t, e) {
+  return P(1 + et.count(le(t), t), e, 3);
+}
+function rs(t, e) {
+  return P(t.getMilliseconds(), e, 3);
+}
+function vl(t, e) {
+  return rs(t, e) + "000";
+}
+function Tl(t, e) {
+  return P(t.getMonth() + 1, e, 2);
+}
+function wl(t, e) {
+  return P(t.getMinutes(), e, 2);
+}
+function Cl(t, e) {
+  return P(t.getSeconds(), e, 2);
+}
+function El(t) {
+  var e = t.getDay();
+  return e === 0 ? 7 : e;
+}
+function Rl(t, e) {
+  return P(At.count(le(t) - 1, t), e, 2);
+}
+function ss(t) {
+  var e = t.getDay();
+  return e >= 4 || e === 0 ? Oe(t) : Oe.ceil(t);
+}
+function kl(t, e) {
+  return t = ss(t), P(Oe.count(le(t), t) + (le(t).getDay() === 4), e, 2);
+}
+function Dl(t) {
+  return t.getDay();
+}
+function Ml(t, e) {
+  return P(yt.count(le(t) - 1, t), e, 2);
+}
+function Pl(t, e) {
+  return P(t.getFullYear() % 100, e, 2);
+}
+function Ll(t, e) {
+  return t = ss(t), P(t.getFullYear() % 100, e, 2);
+}
+function Al(t, e) {
+  return P(t.getFullYear() % 1e4, e, 4);
+}
+function Ol(t, e) {
+  var n = t.getDay();
+  return t = n >= 4 || n === 0 ? Oe(t) : Oe.ceil(t), P(t.getFullYear() % 1e4, e, 4);
+}
+function Nl(t) {
+  var e = t.getTimezoneOffset();
+  return (e > 0 ? "-" : (e *= -1, "+")) + P(e / 60 | 0, "0", 2) + P(e % 60, "0", 2);
+}
+function or(t, e) {
+  return P(t.getUTCDate(), e, 2);
+}
+function _l(t, e) {
+  return P(t.getUTCHours(), e, 2);
+}
+function Il(t, e) {
+  return P(t.getUTCHours() % 12 || 12, e, 2);
+}
+function Yl(t, e) {
+  return P(1 + Mn.count(be(t), t), e, 3);
+}
+function is(t, e) {
+  return P(t.getUTCMilliseconds(), e, 3);
+}
+function Ul(t, e) {
+  return is(t, e) + "000";
+}
+function Zl(t, e) {
+  return P(t.getUTCMonth() + 1, e, 2);
+}
+function Bl(t, e) {
+  return P(t.getUTCMinutes(), e, 2);
+}
+function Fl(t, e) {
+  return P(t.getUTCSeconds(), e, 2);
+}
+function $l(t) {
+  var e = t.getUTCDay();
+  return e === 0 ? 7 : e;
+}
+function ql(t, e) {
+  return P(ns.count(be(t) - 1, t), e, 2);
+}
+function as(t) {
+  var e = t.getUTCDay();
+  return e >= 4 || e === 0 ? Ne(t) : Ne.ceil(t);
+}
+function Hl(t, e) {
+  return t = as(t), P(Ne.count(be(t), t) + (be(t).getUTCDay() === 4), e, 2);
+}
+function jl(t) {
+  return t.getUTCDay();
+}
+function zl(t, e) {
+  return P(bt.count(be(t) - 1, t), e, 2);
+}
+function Wl(t, e) {
+  return P(t.getUTCFullYear() % 100, e, 2);
+}
+function Xl(t, e) {
+  return t = as(t), P(t.getUTCFullYear() % 100, e, 2);
+}
+function Vl(t, e) {
+  return P(t.getUTCFullYear() % 1e4, e, 4);
+}
+function Gl(t, e) {
+  var n = t.getUTCDay();
+  return t = n >= 4 || n === 0 ? Ne(t) : Ne.ceil(t), P(t.getUTCFullYear() % 1e4, e, 4);
+}
+function Kl() {
+  return "+0000";
+}
+function lr() {
+  return "%";
+}
+function cr(t) {
+  return +t;
+}
+function ur(t) {
+  return Math.floor(+t / 1e3);
+}
+var Ee, os;
+Ql({
+  dateTime: "%x, %X",
+  date: "%-m/%-d/%Y",
+  time: "%-I:%M:%S %p",
+  periods: ["AM", "PM"],
+  days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+  shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+  shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+});
+function Ql(t) {
+  return Ee = Qo(t), os = Ee.format, Ee.parse, Ee.utcFormat, Ee.utcParse, Ee;
+}
+function Jl(t) {
+  return new Date(t);
+}
+function ec(t) {
+  return t instanceof Date ? +t : +/* @__PURE__ */ new Date(+t);
+}
+function ls(t, e, n, r, s, a, i, o, c, l) {
+  var u = Kr(), h = u.invert, f = u.domain, b = l(".%L"), v = l(":%S"), S = l("%I:%M"), T = l("%I %p"), k = l("%a %d"), L = l("%b %d"), D = l("%B"), N = l("%Y");
+  function _(w) {
+    return (c(w) < w ? b : o(w) < w ? v : i(w) < w ? S : a(w) < w ? T : r(w) < w ? s(w) < w ? k : L : n(w) < w ? D : N)(w);
+  }
+  return u.invert = function(w) {
+    return new Date(h(w));
+  }, u.domain = function(w) {
+    return arguments.length ? f(Array.from(w, ec)) : f().map(Jl);
+  }, u.ticks = function(w) {
+    var I = f();
+    return t(I[0], I[I.length - 1], w ?? 10);
+  }, u.tickFormat = function(w, I) {
+    return I == null ? _ : l(I);
+  }, u.nice = function(w) {
+    var I = f();
+    return (!w || typeof w.range != "function") && (w = e(I[0], I[I.length - 1], w ?? 10)), w ? f(Io(I, w)) : u;
+  }, u.copy = function() {
+    return Gr(u, ls(t, e, n, r, s, a, i, o, c, l));
+  }, u;
+}
+function tc() {
+  return Vr.apply(ls(Go, Ko, le, Pn, At, et, Dn, kn, ke, os).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
+}
+const hr = [
+  C.NANOSECOND,
+  // 1ns
+  C.nanoseconds(2),
+  // 2ns
+  C.nanoseconds(5),
+  // 5ns
+  C.nanoseconds(10),
+  // 10ns
+  C.nanoseconds(20),
+  // 20ns
+  C.nanoseconds(50),
+  // 50ns
+  C.nanoseconds(100),
+  // 100ns
+  C.nanoseconds(200),
+  // 200ns
+  C.nanoseconds(500),
+  // 500ns
+  C.MICROSECOND,
+  // 1µs
+  C.microseconds(2),
+  // 2µs
+  C.microseconds(5),
+  // 5µs
+  C.microseconds(10),
+  // 10µs
+  C.microseconds(20),
+  // 20µs
+  C.microseconds(50),
+  // 50µs
+  C.microseconds(100),
+  // 100µs
+  C.microseconds(200),
+  // 200µs
+  C.microseconds(500),
+  // 500µs
+  C.MILLISECOND,
+  // 1ms
+  C.milliseconds(2),
+  // 2ms
+  C.milliseconds(5),
+  // 5ms
+  C.milliseconds(10),
+  // 10ms
+  C.milliseconds(20),
+  // 20ms
+  C.milliseconds(50),
+  // 50ms
+  C.milliseconds(100),
+  // 100ms
+  C.milliseconds(200),
+  // 200ms
+  C.milliseconds(500),
+  // 500ms
+  C.SECOND
+  // 1s
+];
+class nc {
+  _domain;
+  _range;
+  _span;
+  /**
+   * Creates a new PreciseTimeScale instance with default domain [0, 1] and range [0, 1].
+   */
+  constructor() {
+    this._domain = [new $(0n), new $(1n)], this._range = [0, 1], this._span = this._domain[1].span(this._domain[0]);
+  }
+  domain(e) {
+    return e === void 0 ? this._domain : (this._domain = [new $(e[0]), new $(e[1])], this._span = this._domain[1].span(this._domain[0]), this);
+  }
+  range(e) {
+    return e === void 0 ? this._range : (this._range = e, this);
+  }
+  /**
+   * Scales a timestamp to its corresponding position in the range.
+   *
+   * @param value - The timestamp to scale
+   * @returns The scaled numeric value within the range
+   */
+  scale(e) {
+    const r = new $(e).valueOf(), s = this._domain[0].valueOf(), a = this._domain[1].valueOf() - s, i = this._range[1] - this._range[0];
+    return Number(r - s) / Number(a) * i + this._range[0];
+  }
+  /**
+   * Generates an array of evenly spaced tick marks within the domain.
+   * The ticks are automatically adjusted to use human-friendly time intervals.
+   *
+   * @param count - Desired number of ticks (actual count may differ to maintain nice intervals)
+   * @returns Array of timestamps representing tick positions
+   */
+  ticks(e) {
+    const n = this.calculateOptimalStep(e).valueOf(), r = this._domain[0].valueOf(), s = this._domain[1].valueOf(), a = (r + n - 1n) / n * n, i = Number((s - a) / n);
+    return Array.from({ length: i + 1 }, (o, c) => {
+      const l = a + BigInt(c) * n;
+      return new $(l);
+    }).filter((o) => o.afterEq(this._domain[0]) && o.beforeEq(this._domain[1]));
+  }
+  /**
+   * Calculates the optimal step size for tick generation based on the desired tick count.
+   * Uses predefined steps from TIME_SCALE_STEPS to ensure human-readable intervals.
+   *
+   * @param targetCount - Desired number of ticks
+   * @returns The optimal TimeSpan step size
+   */
+  calculateOptimalStep(e) {
+    const n = this._span.valueOf() / BigInt(Math.ceil(e));
+    let r = hr[0];
+    for (const s of hr) {
+      if (s.valueOf() > n) break;
+      r = s;
+    }
+    return r;
+  }
+  /**
+   * Formats a timestamp for display on tick marks.
+   * Automatically adjusts the format based on the current time scale:
+   * - For spans < 50µs: displays microseconds
+   * - For spans >= 50µs: displays milliseconds
+   *
+   * @param value - The timestamp to format
+   * @returns Formatted string representation of the timestamp
+   */
+  formatTick(e) {
+    return this._span.lessThan(C.microseconds(50)) ? `${e.remainder(C.MILLISECOND).microseconds.toString()}µs` : `${e.remainder(C.SECOND).milliseconds.toString()}ms`;
+  }
+}
+const rc = () => new nc(), cs = p.enum(["linear", "time"]), us = p.object({
+  tickSpacing: p.number().default(75),
+  type: cs.optional().default("linear")
+}), dr = (t) => {
+  const e = us.parse(t);
+  return ac[e.type](e);
+};
+class sc {
+  props;
+  prevScaleSize;
+  prevDomain;
+  currTicks;
+  normalScale;
+  preciseScale;
+  constructor(e) {
+    this.props = e, this.normalScale = tc(), this.preciseScale = rc(), this.prevScaleSize = 0, this.prevDomain = new qe(new $(0), new $(0)), this.currTicks = [];
+  }
+  create({ decimalToDataScale: e, size: n }) {
+    const r = new qe(
+      new $(e.pos(0)),
+      new $(e.pos(1))
+    );
+    if (this.prevDomain.equals(r) && this.prevScaleSize === n)
+      return this.currTicks;
+    if (this.prevDomain = r, this.prevScaleSize !== n) {
+      const s = [0, n];
+      this.preciseScale.range(s), this.normalScale.range(s), this.prevScaleSize = n;
+    }
+    if (r.span.milliseconds < 5) {
+      this.preciseScale.domain([r.start, r.end]);
+      const s = Qt(n, this.props.tickSpacing) / 2, a = this.preciseScale.ticks(s);
+      this.currTicks = a.map((i) => ({
+        label: this.preciseScale.formatTick(i),
+        position: this.preciseScale.scale(i)
+      }));
+    } else {
+      this.normalScale.domain([r.start.date(), r.end.date()]);
+      const s = this.normalScale.ticks(Qt(n, this.props.tickSpacing));
+      this.currTicks = s.map((a) => ({
+        label: this.normalTickLabel(a),
+        position: this.normalScale(a)
+      }));
+    }
+    return this.currTicks;
+  }
+  normalTickLabel(e) {
+    let n = `:${e.getSeconds()}`;
+    const r = e.getMilliseconds();
+    if (r !== 0) {
+      const s = Math.round(e.getMilliseconds()).toString().padStart(3, "0").replace(/0+$/, "");
+      n += `.${s}`;
+    }
+    return e.getSeconds() === 0 && r === 0 && (n = `${e.getHours()}:${e.getMinutes().toString().padStart(2, "0")}`), n;
+  }
+}
+class ic {
+  props;
+  prevDomain;
+  prevScaleSize;
+  currTicks;
+  d3Scale;
+  constructor(e) {
+    this.props = e, this.prevDomain = A.construct(0, 0), this.prevScaleSize = 0, this.currTicks = [], this.d3Scale = ts();
+  }
+  create({ decimalToDataScale: e, size: n }) {
+    const r = { lower: e.pos(0), upper: e.pos(1) };
+    if (A.equals(this.prevDomain, r) && this.prevScaleSize === n)
+      return this.currTicks;
+    A.equals(this.prevDomain, r) || (this.d3Scale = this.d3Scale.domain([r.lower, r.upper])), this.prevScaleSize !== n && (this.d3Scale = this.d3Scale.range([0, n])), this.prevDomain = r, this.prevScaleSize = n;
+    const s = Qt(n, this.props.tickSpacing), a = this.d3Scale.ticks(s);
+    return this.currTicks = a.map((i) => ({
+      label: this.tickLabel(i),
+      position: this.d3Scale(i)
+    })), this.currTicks;
+  }
+  tickLabel(e) {
+    return e.toString();
+  }
+}
+const Qt = (t, e) => {
+  const n = Math.floor(t / e);
+  return n > 0 ? n : 1;
+}, ac = {
+  linear: (t) => new ic(t),
+  time: (t) => new sc(t)
+}, hs = us.extend({
+  color: y.colorZ,
+  type: cs.optional().default("linear"),
+  font: p.string(),
+  showGrid: p.boolean().optional().default(!0),
+  location: K.outer,
+  gridColor: y.colorZ
+}), Q = 5, We = 6, tt = { useAtlas: !0 }, oc = {
+  bottom: (t, e) => new cc(t, e),
+  top: (t, e) => new uc(t, e),
+  left: (t, e) => new hc(t, e),
+  right: (t, e) => new dc(t, e)
+}, lc = (t, e, n) => oc[t](e, n);
+class _e {
+  renderCtx;
+  state;
+  tickFactory;
+  constructor(e, n) {
+    this.renderCtx = e, this.state = n, this.tickFactory = dr(this.state);
+  }
+  setState(e) {
+    this.state = na(hs, e), this.tickFactory = dr(e);
+  }
+  drawLine(e, n) {
+    const { lower2d: r } = this.renderCtx;
+    r.moveTo(...d.couple(e)), r.lineTo(...d.couple(n));
+  }
+  drawTicks(e, n) {
+    let r = Nn.ZERO;
+    return e.forEach((s) => {
+      const a = this.renderCtx.lower2d.textDimensions(s.label, tt);
+      r = Nn.max([r, a]), n(a, s);
+    }), r;
+  }
+  static START_BOUND = A.construct(-1, 1);
+  maybeDrawGrid(e, n, r) {
+    const { showGrid: s, gridColor: a } = this.state;
+    if (s) {
+      const i = _e.START_BOUND, o = A.construct(e - 1, e + 1), { lower2d: c } = this.renderCtx;
+      c.beginPath(), c.strokeStyle = y.hex(a), n.forEach((l) => {
+        A.contains(i, l.position) || A.contains(o, l.position) || this.drawLine(...r(l));
+      }), c.stroke();
+    }
+  }
+  setColor(e) {
+    const n = y.hex(e);
+    this.renderCtx.lower2d.strokeStyle = n, this.renderCtx.lower2d.fillStyle = n, this.renderCtx.lower2d.font = this.state.font;
+  }
+}
+class cc extends _e {
+  render(e) {
+    const { lower2d: n } = this.renderCtx, { plot: r, position: s } = e, { width: a, height: i } = g.dims(r), o = this.tickFactory.create({ ...e, size: a });
+    n.beginPath(), this.setColor(this.state.color), this.drawLine(s, d.translate(s, "x", a));
+    const c = this.drawTicks(o, (l, u) => {
+      this.drawLine(
+        d.translateX(s, u.position),
+        d.translate(s, { x: u.position, y: Q })
+      ), n.fillText(
+        u.label,
+        s.x + u.position - l.width / 2,
+        s.y + Q + l.height + We,
+        void 0,
+        tt
+      );
+    });
+    return n.stroke(), this.maybeDrawGrid(a, o, (l) => [
+      d.translate(s, "x", l.position),
+      d.translate(s, { x: l.position, y: -i })
+    ]), { size: c.height + Q + We };
+  }
+}
+class uc extends _e {
+  render(e) {
+    const { lower2d: n } = this.renderCtx, { plot: r } = e, { width: s, height: a } = g.dims(r), i = d.translate(e.position, "y", e.size), o = this.tickFactory.create({ ...e, size: s });
+    n.beginPath(), this.setColor(this.state.color), this.drawLine(i, d.translate(i, "x", s));
+    const c = this.drawTicks(o, (l, u) => {
+      this.drawLine(
+        d.translateX(i, u.position),
+        d.translate(i, { x: u.position, y: -Q })
+      ), n.fillText(
+        u.label,
+        i.x + u.position - l.width / 2,
+        i.y - Q - l.height - We,
+        void 0,
+        tt
+      );
+    });
+    return n.stroke(), this.maybeDrawGrid(s, o, (l) => [
+      d.translate(i, "x", l.position),
+      d.translate(i, { x: l.position, y: a })
+    ]), { size: c.height + Q };
+  }
+}
+class hc extends _e {
+  render(e) {
+    const { lower2d: n } = this.renderCtx, { plot: r, position: s } = e, { height: a, width: i } = g.dims(r), o = d.translate(s, "x", e.size), c = this.tickFactory.create({ ...e, size: a });
+    n.beginPath(), this.setColor(this.state.color), this.drawLine(o, d.translate(o, "y", a));
+    const l = this.drawTicks(c, (u, h) => {
+      this.drawLine(
+        d.translateY(o, h.position),
+        d.translate(o, { x: -Q, y: h.position })
+      ), n.fillText(
+        h.label,
+        o.x - u.width - Q * 2,
+        o.y + h.position + u.height / 2,
+        void 0,
+        tt
+      );
+    });
+    return n.stroke(), this.maybeDrawGrid(a, c, (u) => [
+      d.translate(o, "y", u.position),
+      d.translate(o, { x: i, y: u.position })
+    ]), { size: l.width + Q * 2 };
+  }
+}
+class dc extends _e {
+  render(e) {
+    const { lower2d: n } = this.renderCtx, { plot: r, position: s } = e, { height: a, width: i } = g.dims(r), o = this.tickFactory.create({ ...e, size: a });
+    n.beginPath(), this.setColor(this.state.color), this.drawLine(s, d.translateY(s, a));
+    const c = this.drawTicks(o, (l, u) => {
+      this.drawLine(
+        d.translateY(s, u.position),
+        d.translate(s, { x: Q, y: u.position })
+      ), n.fillText(
+        u.label,
+        s.x + Q + We,
+        s.y + u.position + l.height / 2,
+        void 0,
+        tt
+      );
+    });
+    return n.stroke(), this.maybeDrawGrid(a, o, (l) => [
+      d.translateY(s, l.position),
+      d.translate(s, { x: -i, y: l.position })
+    ]), { size: c.width + Q + We };
+  }
+}
+const ds = p.object({
+  key: p.string(),
+  size: p.number(),
+  order: p.number(),
+  loc: K.outer
+});
+p.record(p.string(), ds);
+const De = (t, e) => Object.values(e).filter(({ loc: n }) => n === t).sort((n, r) => r.order - n.order), fc = (t, e, n) => {
+  const r = e[t];
+  if (r == null) return d.ZERO;
+  const s = K.construct(r.loc), a = De(s, e), i = K.construct(te.swap(K.direction(s))), o = De(i, e), c = a.findIndex(({ key: h }) => h === t), l = a.slice(0, c).reduce((h, { size: f }) => h + f, 0), u = o.reduce((h, { size: f }) => h + f, 0);
+  switch (s) {
+    case "left":
+      return d.translate(g.topLeft(n), [l, u]);
+    case "right":
+      return d.translate(g.topRight(n), [l - r.size, u]);
+    case "top":
+      return d.translate(g.topLeft(n), [u, l]);
+    default:
+      return d.translate(g.bottomLeft(n), [
+        u,
+        -l - r.size
+      ]);
+  }
+}, gc = (t, e) => {
+  const n = De("left", t), r = De("right", t), s = De("top", t), a = De("bottom", t), i = n.reduce((u, { size: h }) => u + h, 0), o = r.reduce((u, { size: h }) => u + h, 0), c = s.reduce((u, { size: h }) => u + h, 0), l = a.reduce((u, { size: h }) => u + h, 0);
+  return g.construct(
+    d.translate(g.topLeft(e), { x: i, y: c }),
+    g.width(e) - i - o,
+    g.height(e) - c - l
+  );
+}, Ot = hs.extend({
+  axisKey: p.string().optional(),
+  bounds: A.bounds.optional(),
+  autoBounds: p.object({
+    lower: p.boolean().optional().default(!0),
+    upper: p.boolean().optional().default(!0)
+  }).or(p.boolean().optional().default(!0)),
+  autoBoundPadding: p.number().optional(),
+  autoBoundUpdateInterval: C.z.optional().default(C.seconds(10)),
+  size: p.number().optional().default(0),
+  label: p.string().optional().default(""),
+  labelSize: p.number().optional().default(0)
+}).partial({ color: !0, font: !0, gridColor: !0 }), pc = 2, mc = 7, yc = (t, e) => A.contains(
+  {
+    lower: t - mc,
+    upper: t + pc
+  },
+  e
+), bc = A.DECIMAL, fr = $.now(), xc = {
+  lower: Number(fr.valueOf()),
+  upper: Number(fr.add(C.HOUR).valueOf())
+}, fs = (t) => t === "linear" ? bc : xc, Sc = (t, e = 0.1, n) => {
+  const r = A.max(t.filter(A.isFinite));
+  if (!A.isFinite(r)) return fs(n);
+  const { lower: s, upper: a } = r;
+  if (a === s) return { lower: s - 1, upper: a + 1 };
+  const i = (a - s) * e;
+  return { lower: s - i, upper: a + i };
+}, vc = 0.01, Tc = 0.1;
+class gs extends fe {
+  afterUpdate(e) {
+    const { internal: n } = this, { location: r, autoBoundUpdateInterval: s } = this.state;
+    n.render = j.use(e);
+    const a = re(e), i = te.construct(r);
+    this.state.autoBoundPadding ??= i === "x" ? Tc : vc, n.core = lc(r, n.render, {
+      color: a.colors.gray.l10,
+      font: Fe(a, { level: "small", code: !0 }),
+      gridColor: a.colors.gray.l1,
+      ...this.state
+    }), de(e, "layout"), n.updateBounds ??= ra(
+      (o) => this.setState((c) => ({ ...c, bounds: o })),
+      s.milliseconds
+    );
+  }
+  afterDelete(e) {
+    de(e, "layout");
+  }
+  renderAxis(e, n) {
+    if (!e.canvases.includes("lower2d")) return;
+    const { core: r } = this.internal, { grid: s, container: a } = e, i = fc(`${this.type}-${this.key}`, s, a), o = {
+      ...e,
+      position: i,
+      decimalToDataScale: n,
+      size: this.state.size + this.state.labelSize
+    }, { size: c } = r.render(o);
+    yc(this.state.size, c) || this.setState((l) => ({ ...l, size: c }));
+  }
+  iBounds(e, n) {
+    if (e && this.internal.boundSnapshot != null)
+      return [this.internal.boundSnapshot, null];
+    const { lower: r, upper: s } = wc(this.state.autoBounds);
+    if (!r && !s && this.state.bounds != null)
+      return this.internal.boundSnapshot = this.state.bounds, [this.state.bounds, null];
+    const a = (l) => ({
+      upper: s || this.state.bounds == null ? l.upper : this.state.bounds.upper,
+      lower: r || this.state.bounds == null ? l.lower : this.state.bounds.lower
+    });
+    let i, o = null;
+    try {
+      const l = n();
+      i = Sc(l, this.state.autoBoundPadding, this.state.type);
+    } catch (l) {
+      i = fs(this.state.type), o = l;
+    }
+    const c = a(i);
+    return this.internal.boundSnapshot = c, (this.state.bounds == null || r && this.state.bounds.lower !== c.lower || s && this.state.bounds.upper !== c.upper) && this.internal.updateBounds?.(c), [c, o];
+  }
+  dataToDecimalScale(e, n, r) {
+    const [s, a] = this.iBounds(e, n), i = te.swap(te.construct(this.state.location));
+    return [
+      G.Scale.scale(s).scale(1).translate(-g.root(r)[i]).magnify(1 / g.dim(r, i)),
+      a
+    ];
+  }
+}
+const wc = (t) => typeof t == "boolean" ? { lower: t, upper: t } : { lower: t?.lower ?? !0, upper: t?.upper ?? !0 };
+class ve {
+  canvas;
+  theme;
+  constructor(e, n) {
+    this.canvas = e, this.theme = n;
+  }
+  rule({ direction: e, region: n, position: r, ...s }) {
+    return e === "x" ? this.line({
+      start: d.construct(g.left(n), r),
+      end: d.construct(g.right(n), r),
+      ...s
+    }) : this.line({
+      start: d.construct(r, g.top(n)),
+      end: d.construct(r, g.bottom(n)),
+      ...s
+    });
+  }
+  line({ stroke: e, lineWidth: n, lineDash: r, start: s, end: a }) {
+    const i = this.canvas;
+    i.strokeStyle = y.hex(e), i.lineWidth = n, i.setLineDash([r]), i.beginPath(), i.moveTo(...d.couple(s)), i.lineTo(...d.couple(a)), i.stroke();
+  }
+  circle({
+    fill: e,
+    stroke: n,
+    strokeWidth: r,
+    radius: s,
+    position: a,
+    angle: i,
+    lineCap: o
+  }) {
+    const c = this.canvas;
+    c.beginPath();
+    const l = i?.lower ?? 0, u = i?.upper ?? 2 * Math.PI;
+    if (n != null && typeof s == "object") {
+      const { inner: h, outer: f } = s, b = (h + f) / 2, v = f - h;
+      c.arc(...d.couple(a), b, l, u, !1), c.strokeStyle = y.hex(n), c.lineWidth = r ?? v, o && (c.lineCap = o), c.stroke();
+    } else if (e != null)
+      if (c.fillStyle = y.hex(e), typeof s == "number")
+        c.arc(...d.couple(a), s, l, u), c.fill();
+      else {
+        const { inner: h, outer: f } = s;
+        c.arc(...d.couple(a), f, l, u, !1);
+        const b = a.x + h * Math.cos(u), v = a.y + h * Math.sin(u);
+        c.lineTo(b, v), c.arc(...d.couple(a), h, u, l, !0), c.closePath(), c.fill();
+      }
+  }
+  resolveColor(e, n) {
+    return e == null ? n == null ? this.theme.colors.text : this.resolveColor(n) : typeof e == "function" ? e(this.theme) : y.construct(e);
+  }
+  border({
+    region: e,
+    color: n,
+    width: r,
+    radius: s,
+    location: a
+  }) {
+    const i = this.canvas;
+    i.strokeStyle = y.hex(this.resolveColor(n, this.theme.colors.border)), i.lineWidth = r ?? this.theme.sizes.border.width, s ??= this.theme.sizes.border.radius, a == null || a === !0 ? s > 0 ? (i.roundRect(
+      ...d.couple(g.topLeft(e)),
+      ...d.couple(g.dims(e)),
+      s
+    ), i.stroke()) : (i.rect(...d.couple(g.topLeft(e)), ...d.couple(g.dims(e))), i.stroke()) : Zr.toArray(a).forEach((o) => {
+      const [c, l] = g.edgePoints(e, o);
+      i.beginPath(), i.moveTo(...d.couple(c)), i.lineTo(...d.couple(l)), i.stroke();
+    });
+  }
+  container({
+    region: e,
+    bordered: n = !0,
+    rounded: r = !0,
+    borderColor: s,
+    borderRadius: a,
+    borderWidth: i,
+    backgroundColor: o
+  }) {
+    a ??= this.theme.sizes.border.radius, i ??= 1;
+    const c = this.canvas;
+    c.fillStyle = y.hex(
+      this.resolveColor(o, this.theme.colors.gray.l1)
+    ), c.strokeStyle = y.hex(
+      this.resolveColor(s, this.theme.colors.border)
+    ), c.setLineDash([]), c.lineWidth = 1, c.beginPath(), r ? c.roundRect(
+      ...d.couple(g.topLeft(e)),
+      ...d.couple(g.dims(e)),
+      a
+    ) : c.rect(...d.couple(g.topLeft(e)), ...d.couple(g.dims(e))), c.fill(), n && this.border({
+      region: e,
+      color: s,
+      radius: a,
+      width: i,
+      location: n
+    });
+  }
+  textContainer(e) {
+    const [n, r] = this.spacedTextDrawF(e);
+    n.width += 12, n.height += 12;
+    const { root: s = K.TOP_LEFT, offset: a = d.ZERO } = e, i = { ...e.position };
+    s.x === "right" ? i.x -= n.width + a.x : i.x += a.x, s.y === "bottom" ? i.y -= n.height + a.y : i.y += a.y, this.container({
+      region: g.construct(i, n.width, n.height),
+      ...e
+    }), this.canvas.filter = "none", r(d.translate(i, [6, 6]));
+  }
+  spacedTextDrawF({
+    text: e,
+    direction: n,
+    spacing: r = 1,
+    level: s = "p"
+  }) {
+    const a = Fe(this.theme, { level: s }), i = e.map((l) => On(l, a, this.canvas)), o = this.theme.sizes.base * r, c = Math.max(...i.map((l) => l[te.dimension(n)])) + o;
+    return [
+      {
+        [te.dimension(te.swap(n))]: Math.max(
+          ...i.map((l) => l[te.dimension(te.swap(n))])
+        ),
+        [te.dimension(n)]: c * e.length - o
+      },
+      (l) => {
+        const u = Fe(this.theme, { level: s });
+        this.canvas.font = u, this.canvas.fillStyle = y.hex(this.theme.colors.text), this.canvas.textBaseline = "top", e.forEach((h, f) => {
+          this.canvas.fillText(h, l.x, l.y + c * f);
+        });
+      }
+    ];
+  }
+  list({
+    length: e,
+    itemHeight: n,
+    width: r,
+    spacing: s = 0,
+    position: a,
+    draw: i,
+    root: o = K.TOP_LEFT,
+    offset: c = d.ZERO,
+    padding: l = d.ZERO
+  }) {
+    const u = e * n + l.y * 2 + s * (e - 1), h = r + l.x * 2, f = { ...a };
+    o.x === "right" ? f.x -= r + c.x * 2 : f.x += c.x, o.y === "top" ? f.y -= u + c.y * 2 : f.y += c.y, this.container({
+      region: g.construct(f, { width: h, height: u }),
+      backgroundColor: (b) => b.colors.gray.l1
+    });
+    for (let b = 0; b < e; b++) {
+      const v = g.construct(
+        d.construct(
+          f.x + l.x,
+          f.y + b * n + l.y + s * b
+        ),
+        r,
+        n
+      );
+      i(b, v);
+    }
+  }
+  drawTextInCenter({ box: e, text: n, level: r }) {
+    const s = On(n, this.canvas.font, this.canvas), a = g.positionInCenter(g.construct(d.ZERO, s), e);
+    return this.text({ text: n, position: g.topLeft(a), level: r });
+  }
+  text({
+    text: e,
+    position: n,
+    level: r = "p",
+    weight: s,
+    shade: a,
+    maxWidth: i,
+    code: o,
+    justify: c = "left",
+    align: l = "top",
+    useAtlas: u,
+    color: h
+  }) {
+    this.canvas.font = Fe(this.theme, { level: r, weight: s, code: o }), h != null ? this.canvas.fillStyle = y.hex(this.resolveColor(h)) : a == null ? this.canvas.fillStyle = y.hex(this.theme.colors.text) : this.canvas.fillStyle = y.hex(this.theme.colors.gray[`l${a}`]), this.canvas.textAlign = c, this.canvas.textBaseline = l;
+    let f;
+    i != null && (f = this.canvas.scissor(g.construct(n, i, 1e3))), this.canvas.fillText(e, n.x, n.y, void 0, { useAtlas: u }), f?.();
+  }
+}
+const ps = p.object({
+  position: p.number().optional(),
+  pixelPosition: p.number().optional(),
+  dragging: p.boolean(),
+  lineWidth: p.number().optional().default(1),
+  lineDash: p.number().optional().default(20),
+  color: y.colorZ
+}), Cc = 3;
+class xt extends Z {
+  static TYPE = "Rule";
+  schema = ps;
+  lastUpdateRef = null;
+  afterUpdate(e) {
+    this.internal.renderCtx = j.use(e);
+    const n = re(e);
+    this.internal.draw = new ve(this.internal.renderCtx.upper2d, n), de(e, "tool");
+  }
+  afterDelete(e) {
+    de(e, "tool");
+  }
+  updatePositions({ decimalToDataScale: e, plot: n }) {
+    const r = this.state.dragging, s = this.prevState.dragging && !r;
+    if ((r || s) && this.state.pixelPosition != null) {
+      if (this.lastUpdateRef ??= this.state.pixelPosition, Math.abs(this.state.pixelPosition - this.lastUpdateRef) < Cc && !s)
+        return this.state.pixelPosition;
+      this.lastUpdateRef = this.state.pixelPosition;
+      const o = e.pos(this.state.pixelPosition / g.height(n));
+      return this.setState((c) => ({ ...c, position: o })), this.state.pixelPosition;
+    }
+    if (this.state.position == null) {
+      const i = e.pos(0.5);
+      this.setState((o) => ({ ...o, position: i }));
+    }
+    const a = e.reverse().pos(this.state.position) * g.height(n);
+    if (!isNaN(a)) {
+      if (this.state.pixelPosition != null && Math.abs(a - this.state.pixelPosition) < 1)
+        return this.state.pixelPosition;
+      this.setState((i) => ({ ...i, pixelPosition: a }));
+    }
+    return a;
+  }
+  render(e) {
+    if (this.deleted) return;
+    const { renderCtx: n } = this.internal, { location: r, plot: s } = e, a = K.direction(r), { upper2d: i } = n, o = this.internal.draw, c = this.updatePositions(e) + g.top(e.plot);
+    o.rule({
+      stroke: this.state.color,
+      lineWidth: this.state.lineWidth,
+      lineDash: this.state.lineDash,
+      direction: a,
+      region: s,
+      position: c
+    }), i.fillStyle = y.hex(this.state.color), i.lineJoin = "round", i.lineWidth = 3.5, i.lineCap = "round", i.beginPath();
+    const l = 4;
+    if (r === "left") {
+      const u = g.left(s) - 1;
+      i.moveTo(u, c), i.lineTo(u - l, c - l), i.lineTo(u - l, c + l);
+    } else r === "right" && (i.moveTo(g.right(s), c), i.lineTo(g.right(s) + l, c - l), i.lineTo(g.right(s) + l, c + l));
+    i.closePath(), i.stroke();
+  }
+}
+const Ec = {
+  [xt.TYPE]: xt
+}, _u = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  REGISTRY: Ec,
+  Rule: xt,
+  ruleStateZ: ps
+}, Symbol.toStringTag, { value: "Module" })), Iu = Ot.extend({
+  location: K.x.optional().default("left")
+}), gr = 2, Rc = (t) => g.signedWidth(t) < gr || g.signedHeight(t) < gr;
+class Jt extends gs {
+  static TYPE = "YAxis";
+  schema = Ot;
+  xBounds() {
+    return A.max(
+      this.lines.map((e) => e.xBounds()).filter((e) => A.isFinite(e))
+    );
+  }
+  bounds(e) {
+    const [n, r] = this.iBounds(e, this.dataBounds.bind(this));
+    if (r != null) throw r;
+    return n;
+  }
+  render(e) {
+    if (this.deleted) return;
+    const [n, r] = this.dataToDecimalScale(
+      e.hold,
+      this.dataBounds.bind(this),
+      e.viewport
+    ), s = n.invert().reverse();
+    if (this.renderAxis(e, s), this.renderLines(e, n), this.renderRules(e, s), r != null) throw r;
+  }
+  renderLines({ xDataToDecimalScale: e, plot: n, canvases: r, exposure: s }, a) {
+    if (!r.includes("gl") || Rc(n)) return;
+    const i = {
+      region: n,
+      dataToDecimalScale: new G.XY(e, a),
+      exposure: s
+    };
+    this.lines.forEach((o) => o.render(i));
+  }
+  renderRules({ container: e, plot: n, canvases: r }, s) {
+    if (!r.includes("upper2d")) return;
+    const { location: a } = this.state, { render: i } = this.internal, o = g.construct(
+      g.left(e),
+      g.top(n),
+      g.width(e),
+      g.height(n)
+    ), c = i.scissor(o, d.ZERO, ["upper2d"]), l = { container: e, plot: n, decimalToDataScale: s, location: a };
+    this.rules.map((u) => u.render(l)), c();
+  }
+  findByXValue({
+    xDataToDecimalScale: e,
+    plot: n,
+    viewport: r,
+    hold: s,
+    exposure: a
+  }, i) {
+    const [o, c] = this.dataToDecimalScale(
+      s,
+      this.dataBounds.bind(this),
+      r
+    );
+    if (c != null) throw c;
+    const l = new G.XY(e, o), u = { region: n, dataToDecimalScale: l, exposure: a };
+    return this.lines.map((h) => ({
+      ...h.findByXValue(u, i),
+      units: this.state.label
+    }));
+  }
+  dataBounds() {
+    return this.lines.map((e) => e.yBounds());
+  }
+  get lines() {
+    return this.childrenOfType(zt.TYPE);
+  }
+  get rules() {
+    return this.childrenOfType(xt.TYPE);
+  }
+}
+const kc = p.object({ start: $.z, end: $.z });
+class pr extends Z {
+  static TYPE = "range-annotation";
+  schema = kc;
+  afterUpdate(e) {
+    this.internal.render = j.use(e), this.internal.draw = new ve(this.internal.render.upper2d, re(e));
+  }
+}
+const Dc = $e.payloadZ.extend({
+  viewport: A.bounds
+}), Mc = p.object({
+  cursor: d.xy.or(p.null()),
+  hovered: Dc.or(p.null()),
+  count: p.number()
+});
+class en extends Z {
+  static TYPE = "range-provider";
+  schema = Mc;
+  fetchedInitial = qe.ZERO;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.render = j.use(e), n.draw = new ve(n.render.upper2d, re(e)), n.requestRender = Sn(e), n.runAsync = he(e), n.ranges ??= /* @__PURE__ */ new Map();
+    const r = Pt(e);
+    if (n.requestRender("tool"), r == null) return;
+    n.client = r;
+    const s = wu(e, this.key);
+    n.removeListener?.();
+    const a = s.ranges.onSet((o) => {
+      n.client != null && (y.isCrude(o.color) && n.ranges.set(o.key, n.client.ranges.sugarOne(o)), this.setState((c) => ({ ...c, count: n.ranges.size })), n.requestRender("tool"));
+    }), i = s.ranges.onDelete(async (o) => {
+      n.ranges.delete(o), this.setState((c) => ({ ...c, count: n.ranges.size })), n.requestRender("tool");
+    });
+    n.removeListener = () => {
+      a(), i();
+    };
+  }
+  fetchInitial(e) {
+    const { internal: n } = this, { client: r, runAsync: s } = n;
+    r == null || this.fetchedInitial.equals(e, C.minutes(1)) || (this.fetchedInitial = e, s(async () => {
+      (await r.ranges.retrieve(e)).forEach((i) => {
+        y.isCrude(i.color) && n.ranges.set(i.key, i);
+      }), this.setState((i) => ({ ...i, count: n.ranges.size }));
+    }, "failed to fetch initial ranges"));
+  }
+  render(e) {
+    const { dataToDecimalScale: n, region: r, viewport: s, timeRange: a } = e;
+    this.fetchInitial(a);
+    const { draw: i, ranges: o } = this.internal, c = n.scale(g.xBounds(r)), l = this.state.cursor == null ? null : this.state.cursor.x;
+    let u = null;
+    const h = i.canvas.scissor(
+      g.construct(
+        { x: g.left(r), y: g.top(r) - 35 },
+        { x: g.right(r), y: g.bottom(r) }
+      )
+    );
+    o.forEach((f) => {
+      const b = y.colorZ.safeParse(f.color);
+      if (!b.success) return;
+      const v = b.data;
+      let S = c.pos(Number(f.timeRange.start.valueOf()));
+      const T = c.pos(Number(f.timeRange.end.valueOf()));
+      if (T < g.left(r) || S > g.right(r)) return;
+      S = Ur(S, g.left(r) - 2, g.right(r) - 1);
+      let k = !1;
+      l != null && (k = A.contains({ lower: S, upper: T }, l)), k && (u = {
+        key: f.key,
+        parent: f.parent,
+        name: f.name,
+        color: f.color,
+        labels: f.labels,
+        timeRange: f.timeRange,
+        viewport: {
+          lower: n.scale(g.xBounds(s)).pos(Number(f.timeRange.start.valueOf())),
+          upper: n.scale(g.xBounds(s)).pos(Number(f.timeRange.end.valueOf()))
+        }
+      }), i.container({
+        region: g.construct(
+          { x: S, y: g.top(r) - 1 },
+          { x: T, y: g.bottom(r) - 1 }
+        ),
+        backgroundColor: y.setAlpha(v, 0.2),
+        bordered: !1
+      });
+      const L = g.construct(
+        { x: S + 1, y: g.top(r) - 34 },
+        { x: T - 1, y: g.top(r) - 12 }
+      );
+      i.container({
+        region: L,
+        backgroundColor: g.width(L) < 20 ? y.setAlpha(v, 0.4) : (D) => k ? D.colors.gray.l2 : D.colors.gray.l0,
+        bordered: !0,
+        borderWidth: 1,
+        borderRadius: 2,
+        borderColor: y.setAlpha(v, 0.8)
+      }), i.text({
+        text: f.name,
+        position: { x: S + 8, y: g.top(r) - 30 },
+        level: "small",
+        shade: 10,
+        weight: 500,
+        maxWidth: T - S - 16
+      });
+    }), h(), u != null ? this.setState((f) => ({ ...f, hovered: u })) : this.state.hovered && this.setState((f) => ({ ...f, hovered: null }));
+  }
+}
+const Yu = {
+  [pr.TYPE]: pr,
+  [en.TYPE]: en
+}, Uu = Ot;
+class tn extends gs {
+  static TYPE = "XAxis";
+  schema = Ot;
+  render(e) {
+    if (this.deleted) return;
+    const [n, r] = this.dataToDecimalScale(
+      e.hold,
+      this.dataBounds.bind(this),
+      e.viewport
+    );
+    if (this.renderAxis(e, n.reverse()), this.renderYAxes(e, n), this.renderRanges(e, n), r != null) throw r;
+  }
+  findByXDecimal(e, n) {
+    const [r, s] = this.dataToDecimalScale(
+      e.hold,
+      this.dataBounds.bind(this),
+      e.viewport
+    );
+    if (s != null) throw s;
+    return this.findByXValue(e, r.reverse().pos(n));
+  }
+  findByXValue(e, n) {
+    const [r, s] = this.dataToDecimalScale(
+      e.hold,
+      this.dataBounds.bind(this),
+      e.viewport
+    );
+    if (s != null) throw s;
+    const a = { ...e, xDataToDecimalScale: r };
+    return this.yAxes.map((i) => i.findByXValue(a, n)).flat();
+  }
+  renderYAxes(e, n) {
+    const r = { ...e, xDataToDecimalScale: n };
+    this.yAxes.forEach((s) => s.render(r));
+  }
+  get yAxes() {
+    return this.childrenOfType(Jt.TYPE);
+  }
+  get ranges() {
+    return this.childrenOfType(en.TYPE);
+  }
+  bounds(e) {
+    const [n, r] = this.iBounds(e, this.dataBounds.bind(this));
+    if (r != null) throw r;
+    return n;
+  }
+  renderRanges(e, n) {
+    const r = this.bounds(e.hold), s = A.min([r, qe.MAX.numericBounds]), a = new qe(s.lower, s.upper);
+    this.ranges.forEach(
+      (i) => i.render({
+        dataToDecimalScale: n,
+        region: e.plot,
+        viewport: e.viewport,
+        timeRange: a
+      })
+    );
+  }
+  dataBounds() {
+    return this.yAxes.map((e) => e.xBounds());
+  }
+}
+const Pc = d.construct(12), Lc = 3, Ac = 14, Oc = d.construct(6), ms = p.object({
+  position: d.xy.or(p.null()),
+  textColor: y.colorZ.optional().default(y.ZERO),
+  backgroundColor: y.colorZ.optional().default(y.ZERO),
+  borderColor: y.colorZ.optional().default(y.ZERO),
+  ruleColor: y.colorZ.optional().default(y.ZERO),
+  ruleStrokeWidth: p.number().optional().default(1),
+  ruleStrokeDash: p.number().default(0)
+});
+class St extends Z {
+  static TYPE = "tooltip";
+  schema = ms;
+  afterUpdate(e) {
+    const n = re(e);
+    y.isZero(this.state.textColor) && (this.state.textColor = n.colors.text), y.isZero(this.state.backgroundColor) && (this.state.backgroundColor = n.colors.gray.l1), y.isZero(this.state.borderColor) && (this.state.borderColor = n.colors.border), y.isZero(this.state.ruleColor) && (this.state.ruleColor = n.colors.gray.l7), this.internal.dotColor = n.colors.text, this.internal.dotColorContrast = n.colors.textInverted, this.internal.render = j.use(e), this.internal.draw = new ve(this.internal.render.upper2d, n), de(e, "tool");
+  }
+  afterDelete(e) {
+    de(e, "tool");
+  }
+  render(e) {
+    if (this.deleted || this.state.position == null) return;
+    const { region: n } = e, r = G.XY.scale(g.DECIMAL).scale(n), s = G.XY.scale(n).scale(g.DECIMAL), a = e.findByXDecimal(s.x.pos(this.state.position.x)), i = a.filter((S) => d.isFinite(S.value)), { draw: o } = this.internal, c = i.reduce((S, T) => S + T.position.x, 0) / i.length, l = new $(
+      i.reduce((S, T) => S + T.value.x, 0) / i.length
+    ), u = r.x.pos(c);
+    if (!A.contains(g.xBounds(n), u)) return;
+    o.rule({
+      stroke: this.state.ruleColor,
+      lineWidth: this.state.ruleStrokeWidth,
+      lineDash: this.state.ruleStrokeDash,
+      direction: "y",
+      region: n,
+      position: u
+    }), i.forEach((S) => {
+      const T = r.pos(S.position);
+      o.circle({ fill: y.setAlpha(S.color, 0.5), radius: 8, position: T }), o.circle({ fill: y.setAlpha(S.color, 0.8), radius: 5, position: T }), o.circle({
+        fill: y.pickByContrast(
+          S.color,
+          this.internal.dotColor,
+          this.internal.dotColorContrast
+        ),
+        radius: 2,
+        position: T
+      });
+    });
+    const h = s.pos(this.state.position), f = { ...K.TOP_LEFT };
+    h.x > 0.6 && (f.x = "right"), h.y > 0.6 && (f.y = "bottom");
+    let b = a.reduce((S, T) => Math.max(S, T.label?.length ?? 0), 0);
+    const v = l.toString("preciseDate", "local").length;
+    v > b && (b = v), o.list({
+      root: f,
+      offset: Pc,
+      length: i.length + 1,
+      padding: Oc,
+      itemHeight: Ac,
+      spacing: Lc,
+      width: b * 7 + 48,
+      position: this.state.position,
+      draw: (S, T) => {
+        let k = "", L = "", D = this.state.textColor;
+        if (S === 0)
+          k = "Time", L = l.toString("preciseDate", "local");
+        else {
+          const N = i[S - 1];
+          k = N.label ?? "", L = Yr.roundBySpan(N.value.y, N.bounds).toString(), D = N.color;
+        }
+        o.text({
+          position: g.topLeft(T),
+          text: k,
+          level: "small",
+          weight: 500,
+          color: D
+        }), o.text({
+          position: d.translateY(g.topRight(T), -1),
+          text: L,
+          level: "small",
+          justify: "right",
+          code: !0,
+          shade: 10
+        });
+      }
+    });
+  }
+}
+const Nc = {
+  [St.TYPE]: St
+}, Zu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  REGISTRY: Nc,
+  Tooltip: St,
+  tooltipStateZ: ms
+}, Symbol.toStringTag, { value: "Module" })), ys = p.object({
+  one: d.xy.nullable(),
+  two: d.xy.nullable(),
+  hover: d.xy.nullable(),
+  color: p.union([
+    y.colorZ,
+    p.object({
+      verticalLine: y.colorZ.optional().default(y.ZERO),
+      horizontalLine: y.colorZ.optional().default(y.ZERO),
+      obliqueLine: y.colorZ.optional().default(y.ZERO)
+    })
+  ]).optional().default(y.ZERO),
+  strokeWidth: p.number().optional().default(1),
+  strokeDash: p.number().optional().default(2)
+});
+class vt extends Z {
+  static TYPE = "measure";
+  schema = ys;
+  afterUpdate(e) {
+    const n = j.use(e);
+    this.internal.theme = re(e), this.internal.renderCtx = n, this.internal.draw = new ve(n.upper2d, this.internal.theme), de(e, "tool");
+  }
+  afterDelete(e) {
+    de(e, "layout");
+  }
+  get verticalLineColor() {
+    return y.isColor(this.state.color) ? y.isZero(this.state.color) ? this.internal.theme.colors.gray.l8 : this.state.color : y.isZero(this.state.color.verticalLine) ? this.internal.theme.colors.gray.l8 : this.state.color.verticalLine;
+  }
+  get horizontalLineColor() {
+    return y.isColor(this.state.color) ? y.isZero(this.state.color) ? this.internal.theme.colors.gray.l8 : this.state.color : y.isZero(this.state.color.horizontalLine) ? this.internal.theme.colors.gray.l8 : this.state.color.horizontalLine;
+  }
+  get obliqueLineColor() {
+    return y.isColor(this.state.color) ? y.isZero(this.state.color) ? this.internal.theme.colors.gray.l8 : this.state.color : y.isZero(this.state.color.obliqueLine) ? this.internal.theme.colors.gray.l8 : this.state.color.obliqueLine;
+  }
+  find(e) {
+    const { one: n, two: r } = this.state;
+    if (n == null || r == null) return null;
+    const { one: s, two: a } = this.prevState, { dataOne: i, dataTwo: o } = this.internal;
+    if (s != null && d.equals(n, s) && a != null && d.equals(r, a) && i != null && o != null) {
+      const [S, T] = [e.findByXValue(i.x), e.findByXValue(o.x)];
+      return S.length === 0 || T.length === 0 ? null : [
+        S.sort(
+          (k, L) => d.distance(i, k.value) - d.distance(i, L.value)
+        )[0],
+        T.sort(
+          (k, L) => d.distance(o, k.value) - d.distance(o, L.value)
+        )[0]
+      ];
+    }
+    const c = G.XY.scale(e.region).scale(g.DECIMAL), [l, u] = [c.pos(n), c.pos(r)], [h, f] = [
+      e.findByXDecimal(l.x),
+      e.findByXDecimal(u.x)
+    ];
+    if (h.length === 0 || f.length === 0) return null;
+    const [b, v] = [
+      h.sort(
+        (S, T) => d.distance(l, S.position) - d.distance(l, T.position)
+      )[0],
+      f.sort(
+        (S, T) => d.distance(u, S.position) - d.distance(u, T.position)
+      )[0]
+    ];
+    return this.internal.dataOne = b.value, this.internal.dataTwo = v.value, [b, v];
+  }
+  renderHover(e) {
+    if (this.state.hover == null) return;
+    const n = this.state.hover, r = G.XY.scale(e.region).scale(g.DECIMAL), s = r.pos(n), a = e.findByXDecimal(r.pos(n).x);
+    if (a.length === 0) return;
+    const i = a.sort(
+      (c, l) => d.distance(s, c.position) - d.distance(s, l.position)
+    )[0], { draw: o } = this.internal;
+    o.circle({
+      fill: y.setAlpha(i.color, 0.5),
+      radius: 9,
+      position: r.reverse().pos(i.position)
+    });
+  }
+  render(e) {
+    if (this.deleted) return;
+    this.renderHover(e);
+    const n = this.find(e);
+    if (n == null) return;
+    const [r, s] = n, { draw: a } = this.internal, { strokeDash: i, strokeWidth: o } = this.state, c = G.XY.scale(g.DECIMAL).scale(e.region), l = c.pos(r.position), u = c.pos(s.position), h = new C(Math.abs(r.value.x - s.value.x)), f = Math.abs(r.value.y - s.value.y), b = f / h.seconds;
+    a.line({
+      start: d.construct(l.x, l.y),
+      end: d.construct(l.x, u.y),
+      stroke: this.verticalLineColor,
+      lineDash: i,
+      lineWidth: o
+    }), a.textContainer({
+      text: [`${f.toFixed(2)} ${r.units ?? ""}`],
+      direction: "x",
+      position: d.construct(l.x, (l.y + u.y) / 2),
+      level: "small"
+    }), a.line({
+      start: d.construct(l.x, u.y),
+      end: d.construct(u.x, u.y),
+      stroke: this.horizontalLineColor,
+      lineDash: i,
+      lineWidth: o
+    }), a.textContainer({
+      text: [h.truncate(C.MILLISECOND).toString()],
+      direction: "x",
+      position: d.construct((l.x + u.x) / 2, u.y),
+      level: "small"
+    }), a.line({
+      start: d.construct(l.x, l.y),
+      end: d.construct(u.x, u.y),
+      stroke: this.obliqueLineColor,
+      lineDash: i,
+      lineWidth: o
+    }), a.textContainer({
+      text: [`${b.toFixed(2)} ${r.units ?? ""} / S`],
+      direction: "x",
+      position: d.construct((l.x + u.x) / 2, (l.y + u.y) / 2),
+      level: "small"
+    }), a.circle({
+      fill: y.setAlpha(r.color, 0.5),
+      radius: 8,
+      position: l
+    }), a.circle({
+      fill: y.setAlpha(r.color, 0.8),
+      radius: 5,
+      position: l
+    }), a.circle({ fill: y.WHITE, radius: 2, position: l }), a.circle({
+      fill: y.setAlpha(s.color, 0.5),
+      radius: 8,
+      position: u
+    }), a.circle({
+      fill: y.setAlpha(s.color, 0.8),
+      radius: 5,
+      position: u
+    }), a.circle({ fill: y.WHITE, radius: 2, position: u });
+  }
+}
+const _c = {
+  [vt.TYPE]: vt
+}, Bu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Measure: vt,
+  REGISTRY: _c,
+  measureStateZ: ys
+}, Symbol.toStringTag, { value: "Module" })), Ic = p.object({
+  container: g.box,
+  viewport: g.box,
+  hold: p.boolean().optional().default(!1),
+  grid: p.record(p.string(), ds),
+  visible: p.boolean().optional().default(!0),
+  clearOverScan: d.crudeZ.optional().default(d.ZERO)
+}), Yc = (t, e) => {
+  const n = g.width(t) * Math.sqrt(g.height(t)), r = g.width(e) * Math.sqrt(g.height(e));
+  return n / r;
+}, Uc = ["upper2d", "lower2d", "gl"], Zc = ["upper2d"];
+class mr extends fe {
+  static TYPE = "LinePlot";
+  schema = Ic;
+  afterUpdate(e) {
+    this.internal.instrumentation = Dt(e, "lineplot"), this.internal.handleError = he(e), this.internal.renderCtx = j.use(e), xn(e, (n) => {
+      this.state.visible && this.requestRender("low", n);
+    }), !(!this.state.visible && !this.prevState.visible) && this.requestRender("high", "layout");
+  }
+  afterDelete(e) {
+    this.internal.renderCtx = j.use(e), this.requestRender("high", "layout");
+  }
+  findByXDecimal(e) {
+    const n = {
+      ...this.state,
+      plot: this.calculatePlot(),
+      exposure: this.exposure
+    };
+    return this.axes.flatMap((r) => r.findByXDecimal(n, e)).flat();
+  }
+  findByXValue(e) {
+    const n = {
+      ...this.state,
+      plot: this.calculatePlot(),
+      exposure: this.exposure
+    };
+    return this.axes.flatMap((r) => r.findByXValue(n, e)).flat();
+  }
+  get axes() {
+    return this.childrenOfType(tn.TYPE);
+  }
+  get tooltips() {
+    return this.childrenOfType(St.TYPE);
+  }
+  get measures() {
+    return this.childrenOfType(vt.TYPE);
+  }
+  get bounds() {
+    return this.childrenOfType(Xt.TYPE);
+  }
+  get exposure() {
+    return Yc(this.state.viewport, this.state.container);
+  }
+  renderAxes(e, n) {
+    const r = { ...this.state, plot: e, canvases: n, exposure: this.exposure };
+    this.axes.forEach((s) => s.render(r));
+  }
+  renderTooltips(e, n) {
+    const r = { findByXDecimal: this.findByXDecimal.bind(this), region: e, canvases: n };
+    this.tooltips.forEach((s) => s.render(r));
+  }
+  renderBounds() {
+    this.bounds.forEach(
+      (e) => e.render({
+        getBounds: () => {
+          const n = {};
+          return this.axes.forEach((r) => {
+            const s = r.state.axisKey ?? r.key;
+            n[s] = r.bounds(this.state.hold), r.yAxes.forEach((a) => {
+              const i = a.state.axisKey ?? a.key;
+              n[i] = a.bounds(this.state.hold);
+            });
+          }), n;
+        }
+      })
+    );
+  }
+  renderMeasures(e) {
+    const n = {
+      findByXDecimal: this.findByXDecimal.bind(this),
+      findByXValue: this.findByXValue.bind(this),
+      region: e
+    };
+    this.measures.forEach((r) => r.render(n));
+  }
+  calculatePlot() {
+    return gc(this.state.grid, this.state.container);
+  }
+  render(e) {
+    const { instrumentation: n, renderCtx: r, handleError: s } = this.internal;
+    if (this.deleted) {
+      n.L.debug("deleted, skipping render", { key: this.key });
+      return;
+    }
+    if (!this.state.visible)
+      return n.L.debug("not visible, skipping render", { key: this.key }), ({ canvases: u }) => r.erase(this.state.container, this.state.clearOverScan, ...u);
+    const a = this.calculatePlot();
+    n.L.debug("rendering", {
+      key: this.key,
+      viewport: this.state.viewport,
+      container: this.state.container,
+      grid: this.state.grid,
+      plot: a,
+      canvases: e
+    });
+    const i = d.construct(this.state.clearOverScan), o = r.scissor(
+      this.state.container,
+      i,
+      e.filter((u) => u !== "gl")
+    ), c = r.scissor(
+      a,
+      d.ZERO,
+      e.filter((u) => u === "gl")
+    );
+    try {
+      this.renderAxes(a, e), this.renderTooltips(a, e), this.renderMeasures(a), this.renderBounds();
+    } catch (u) {
+      s(u, "failed to render line plot");
+    } finally {
+      o(), c();
+    }
+    n.L.debug("rendered", { key: this.key });
+    const l = g.copy(this.state.container);
+    return ({ canvases: u }) => r.erase(l, this.state.clearOverScan, ...u);
+  }
+  requestRender(e, n) {
+    const { renderCtx: r } = this.internal;
+    let s = Uc;
+    n === "tool" && (s = Zc), r.loop.set({
+      key: `${this.type}-${this.key}`,
+      render: () => this.render(s),
+      priority: e,
+      canvases: s
+    });
+  }
+}
+const Fu = {
+  [mr.TYPE]: mr,
+  [tn.TYPE]: tn,
+  [Jt.TYPE]: Jt,
+  [Xt.TYPE]: Xt
+}, Bc = p.object({
+  region: g.box,
+  wheelPos: p.number(),
+  scrolling: p.boolean(),
+  empty: p.boolean(),
+  visible: p.boolean(),
+  telem: ct.optional().default(Lr),
+  font: gn.optional().default("p"),
+  color: y.colorZ.optional().default(y.ZERO),
+  overshoot: d.xy.optional().default({ x: 0, y: 0 })
+}), Fc = 0.98, Be = "lower2d", $c = {
+  offset: 0n,
+  offsetRef: 0n,
+  scrollRef: 0
+};
+class Tt extends Z {
+  static TYPE = "log";
+  static z = Bc;
+  schema = Tt.z;
+  values = new da([]);
+  scrollState = $c;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.render = j.use(e), n.theme = re(e), y.isZero(this.state.color) ? this.internal.textColor = n.theme.colors.gray.l11 : n.textColor = this.state.color, n.telem = H(e, this.state.telem, n.telem);
+    const { scrolling: r, wheelPos: s } = this.state;
+    if (this.state.scrolling && !this.prevState.scrolling) {
+      const c = this.values.alignmentBounds.upper - 1n;
+      this.scrollState = {
+        offset: c,
+        offsetRef: c,
+        scrollRef: this.state.wheelPos
+      };
+    } else if (r) {
+      const { scrollState: c, values: l } = this, u = Math.ceil((s - this.scrollState.scrollRef) / this.lineHeight);
+      c.offset = this.values.traverseAlignment(
+        c.offsetRef,
+        -BigInt(u)
+      ), c.offset < l.alignmentBounds.lower + BigInt(this.visibleLineCount) && (c.offset = l.alignmentBounds.lower, this.setState((h) => ({ ...h, wheelPos: this.prevState.wheelPos }))), c.offset >= l.alignmentBounds.upper && this.setState((h) => ({ ...h, scrolling: !1 }));
+    }
+    const [i, o] = this.internal.telem.value();
+    this.values = o, this.checkEmpty(), n.stopListeningTelem?.(), n.stopListeningTelem = n.telem.onChange(() => {
+      const [c, l] = this.internal.telem.value();
+      this.checkEmpty(), this.values = l, this.requestRender();
+    }), !(!this.state.visible && !this.prevState.visible) && this.requestRender();
+  }
+  checkEmpty() {
+    const e = this.values.length === 0;
+    e !== this.state.empty && this.setState((n) => ({ ...n, empty: e }));
+  }
+  afterDelete() {
+    const { telem: e, render: n } = this.internal;
+    e.cleanup?.(), n.erase(g.construct(this.state.region), d.ZERO, Be);
+  }
+  requestRender() {
+    const { render: e } = this.internal;
+    e.loop.set({
+      key: `${this.type}-${this.key}`,
+      render: () => this.render(),
+      priority: "high",
+      canvases: [Be]
+    });
+  }
+  get lineHeight() {
+    return this.internal.theme.typography[this.state.font].size * this.internal.theme.sizes.base;
+  }
+  get totalHeight() {
+    return Math.ceil(this.values.length * this.lineHeight);
+  }
+  get visibleLineCount() {
+    return Math.min(
+      Math.floor((g.height(this.state.region) - 12) / this.lineHeight),
+      this.values.length
+    );
+  }
+  render() {
+    const { render: e } = this.internal, n = this.state.region;
+    if (g.areaIsZero(n)) return;
+    if (!this.state.visible) return () => e.erase(n, d.ZERO, Be);
+    let r;
+    if (!this.state.scrolling)
+      r = this.values.subIterator(
+        this.values.length - this.visibleLineCount,
+        this.values.length
+      );
+    else {
+      const l = this.values.traverseAlignment(
+        this.scrollState.offset,
+        -BigInt(this.visibleLineCount)
+      );
+      r = this.values.subAlignmentSpanIterator(l, this.visibleLineCount);
+    }
+    const s = this.state.region, a = e[Be], i = new ve(a, this.internal.theme), o = e.scissor(s, d.ZERO, [Be]);
+    this.renderElements(i, r), this.renderScrollbar(i), o();
+    const c = g.copy(this.state.region);
+    return ({ canvases: l }) => e.erase(c, this.state.overshoot, ...l);
+  }
+  renderScrollbar(e) {
+    const n = this.state.region, r = g.height(n) / this.totalHeight * g.height(n);
+    if (r >= g.height(n) * Fc) return;
+    let s = g.bottom(n) - r;
+    this.state.scrolling && (s -= Number(
+      this.values.distance(
+        this.values.alignmentBounds.upper,
+        this.scrollState.offset
+      )
+    ) / this.values.length * g.height(n)), s < 0 && (s = g.top(n)), e.container({
+      region: g.construct(
+        { x: g.right(n) - 6, y: s },
+        { width: 6, height: r }
+      ),
+      bordered: !1,
+      backgroundColor: (a) => a.colors.gray.l6
+    });
+  }
+  renderElements(e, n) {
+    const r = this.state.region;
+    let s = 0;
+    for (const a of n) {
+      const i = this.values.dataType.equals(Qe.JSON) ? JSON.stringify(a) : a.toString();
+      e.text({
+        text: i,
+        level: this.state.font,
+        shade: 11,
+        position: d.translate(g.topLeft(r), { x: 6, y: s * this.lineHeight + 6 }),
+        code: !0
+      }), s++;
+    }
+  }
+}
+const $u = { [Tt.TYPE]: Tt }, qu = "relationships", Hu = "resources", qc = {
+  channel: V.RELATIONSHIP_SET_CHANNEL_NAME,
+  schema: V.relationshipZ,
+  onChange: ({ store: t, changed: e }) => t.relationships.set(V.relationshipToString(e), e)
+}, Hc = {
+  channel: V.RELATIONSHIP_DELETE_CHANNEL_NAME,
+  schema: V.relationshipZ,
+  onChange: ({ store: t, changed: e }) => {
+    t.relationships.delete(V.relationshipToString(e));
+  }
+}, ju = {
+  equal: (t, e) => V.idsEqual(t.from, e.from) && V.idsEqual(t.to, e.to) && t.type === e.type,
+  listeners: [qc, Hc]
+}, jc = {
+  channel: V.RESOURCE_SET_CHANNEL_NAME,
+  schema: V.resourceZ,
+  onChange: async ({ store: t, changed: e }) => {
+    t.resources.set(
+      e.key,
+      (n) => n == null ? e : { ...n, ...e }
+    );
+  }
+}, zc = {
+  channel: V.RESOURCE_DELETE_CHANNEL_NAME,
+  schema: V.idZ,
+  onChange: ({ store: t, changed: e }) => t.resources.delete(e.key)
+}, zu = {
+  equal: (t, e) => pn.equal(t, e),
+  listeners: [jc, zc]
+}, Wu = "ranges", Wc = {
+  channel: $e.SET_CHANNEL_NAME,
+  schema: $e.payloadZ,
+  onChange: async ({ store: t, changed: e, client: n }) => {
+    const r = n.ranges.sugarOne(e), s = t.ranges.get(e.key);
+    let a;
+    s?.labels == null && (a = await r.retrieveLabels());
+    let i = null;
+    s?.parent == null && (i = await r.retrieveParent()), t.ranges.set(
+      e.key,
+      (o) => n.ranges.sugarOne({
+        ...r.payload,
+        labels: o?.labels ?? a,
+        parent: o?.parent ?? i
+      })
+    );
+  }
+}, Xc = {
+  channel: $e.DELETE_CHANNEL_NAME,
+  schema: $e.keyZ,
+  onChange: ({ store: t, changed: e }) => t.ranges.delete(e)
+}, Xu = {
+  equal: (t, e) => pn.equal(t.payload, e.payload),
+  listeners: [Wc, Xc]
+}, Vc = p.object({
+  region: g.box,
+  clearOverScan: d.crudeZ.optional().default(0),
+  visible: p.boolean().optional().default(!0),
+  autoRenderInterval: p.number().optional().default(1e3)
+}), yr = ["upper2d", "lower2d"];
+class Xe extends fe {
+  static TYPE = "Table";
+  static stateZ = Vc;
+  schema = Xe.stateZ;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.renderCtx = j.use(e), n.handleError = he(e), n.autoRenderInterval ??= setInterval(
+      () => this.state.visible && this.requestRender("low"),
+      this.state.autoRenderInterval
+    ), xn(e, () => {
+      this.state.visible && this.requestRender("low");
+    }), !(!this.state.visible && !this.prevState.visible) && this.requestRender("high");
+  }
+  afterDelete() {
+    this.internal.autoRenderInterval != null && clearInterval(this.internal.autoRenderInterval), this.requestRender("high");
+  }
+  render() {
+    if (this.deleted) return;
+    const e = g.copy(this.state.region);
+    if (!this.state.visible)
+      return () => this.internal.renderCtx.erase(e, this.state.clearOverScan);
+    const { renderCtx: n, handleError: r } = this.internal, s = G.XY.translate(g.topLeft(this.state.region)), a = n.scissor(
+      this.state.region,
+      d.construct(this.state.clearOverScan),
+      yr
+    );
+    try {
+      for (const i of this.children) i.render({ viewportScale: s });
+    } catch (i) {
+      r(i, "Failed to render table");
+    } finally {
+      a();
+    }
+    return () => this.internal.renderCtx.erase(e, this.state.clearOverScan);
+  }
+  requestRender(e) {
+    const { renderCtx: n } = this.internal;
+    n.loop.set({
+      key: `${Xe.TYPE}-${this.key}`,
+      render: this.render.bind(this),
+      priority: e,
+      canvases: yr
+    });
+  }
+}
+const Vu = {
+  [Xe.TYPE]: Xe
+}, Gc = p.object({
+  authority: Lt.authorityZ.optional(),
+  valid: p.boolean().optional()
+}).default({ authority: void 0, valid: !1 }), Kc = p.object({
+  triggered: p.boolean(),
+  status: Fr.statusZ(Gc),
+  sink: Et.optional().default(kt),
+  source: dn.optional().default(un)
+});
+class br extends Z {
+  static TYPE = "Chip";
+  schema = Kc;
+  afterUpdate(e) {
+    const { internal: n } = this, { sink: r, source: s } = this.state;
+    n.source = H(
+      e,
+      s,
+      n.source
+    ), n.sink = Ke(e, r, n.sink), this.state.triggered && !this.prevState.triggered && n.sink.set(this.state.status.details?.authority !== Lt.ABSOLUTE_AUTHORITY), this.updateEnabledState(), n.stopListening?.(), n.stopListening = n.source.onChange(() => this.updateEnabledState());
+  }
+  updateEnabledState() {
+    const e = this.internal.source.value();
+    pn.equal(e, this.state.status) || this.setState((n) => ({ ...n, status: e, triggered: !1 }));
+  }
+  afterDelete() {
+    this.internal.stopListening(), this.internal.source.cleanup?.(), this.internal.sink.cleanup?.();
+  }
+  render() {
+  }
+}
+const Qc = p.object({}), xr = "control-state-provider", Jc = mn.stateZ.extend({
+  subjectColor: y.colorZ
+});
+class wt extends fe {
+  static TYPE = "StateProvider";
+  schema = Qc;
+  /** Tracks the colors we assign to a particular control subject. */
+  colors = /* @__PURE__ */ new Map();
+  /** Tracks the current control state for each channel and allows us to access it */
+  tracker;
+  /** Stop listening for changes to the tracker */
+  disconnectTrackerChange;
+  /** An observer that lets external subscribers know when the control state changes */
+  obs = new sa.Observer();
+  /**
+   * Grabs the state provider from the current aether context.
+   *
+   * @param ctx - The component's current aether context.
+   * @throws {Error} if the state provider is not in the context.
+   */
+  static use(e) {
+    return e.get(xr);
+  }
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.instrumentation = Dt(e, "control-state");
+    const r = re(e);
+    n.palette = r.colors.visualization.palettes.default, n.defaultColor = r.colors.gray.l8;
+    const s = Pt(e);
+    if (n.client != null && s === n.client) return;
+    n.client = s, e.set(xr, this), he(e)(async () => {
+      await this.maybeCloseTracker(), n.client != null && (this.internal.instrumentation.L.debug("starting state tracker"), await this.openTracker(n.client));
+    }, "failed to open control state tracker");
+  }
+  async maybeCloseTracker() {
+    this.tracker != null && (this.internal.instrumentation.L.debug("stopping state tracker"), this.disconnectTrackerChange?.(), await this.tracker.close(), this.tracker = void 0);
+  }
+  afterDelete(e) {
+    he(e)(async () => {
+      await this.maybeCloseTracker();
+    }, "failed to close control state tracker");
+  }
+  onChange(e) {
+    return this.obs.onChange(e);
+  }
+  get(e) {
+    return Array.isArray(e) ? Br.unique(e).map((n) => this.getOne(n)).filter((n) => n != null) : this.getOne(e);
+  }
+  getOne(e) {
+    if (this.tracker == null) return;
+    const n = this.tracker.states.get(e);
+    if (n != null)
+      return {
+        ...n,
+        subjectColor: this.colors.get(n.subject.key) ?? this.internal.defaultColor
+      };
+  }
+  async openTracker(e) {
+    const { internal: n } = this, { instrumentation: r } = n;
+    try {
+      this.tracker = await e.control.openStateTracker();
+    } catch {
+      r.L.error("failed to open state tracker");
+      return;
+    }
+    this.disconnectTrackerChange?.(), this.disconnectTrackerChange = this.tracker.onChange((s) => {
+      if (r.L.debug("transfer", { transfers: s.map((a) => mn.transferString(a)) }), this.tracker == null)
+        throw new Mt("tracker is null inside it's own onChange callback!");
+      this.updateColors(this.tracker), this.obs.notify(s);
+    });
+  }
+  updateColors(e) {
+    const n = e.subjects(), r = n.map((i) => i.key), s = Array.from(this.colors.values());
+    this.colors.forEach((i, o) => !r.includes(o) && this.colors.delete(o));
+    const { palette: a } = this.internal;
+    n.forEach((i) => {
+      if (this.colors.has(i.key)) return;
+      const o = a.find((c) => !s.includes(c)) ?? a[0];
+      this.colors.set(i.key, o), s.push(o);
+    });
+  }
+}
+const eu = ["acquired", "released", "overridden", "failed"], tu = p.enum(eu), nu = p.object({
+  name: p.string(),
+  authority: p.number().default(0),
+  acquireTrigger: p.number(),
+  status: tu.optional(),
+  needsControlOf: Ir.keyZ.array().optional().default([])
+});
+class Sr extends fe {
+  static TYPE = "Controller";
+  schema = nu;
+  registry = /* @__PURE__ */ new Map();
+  writer;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.instrumentation = Dt(e), n.addStatus = _r(e), n.runAsync = he(e), (n.prevTrigger == null || Math.abs(this.state.acquireTrigger - n.prevTrigger) > 1) && (n.prevTrigger = this.state.acquireTrigger);
+    const r = Pt(e), s = wt.use(e);
+    n.stateProv = s, n.telemCtx = Nr(e, this, n.telemCtx), n.client = r, n.runAsync(async () => {
+      n.client == null && await this.release(), this.state.acquireTrigger > n.prevTrigger ? await this.acquire() : this.state.acquireTrigger < n.prevTrigger && await this.release();
+    }, "failed to acquire control");
+  }
+  afterDelete() {
+    const { internal: e } = this;
+    e.runAsync(async () => await this.release(), "failed to release control");
+  }
+  async updateNeedsControlOf() {
+    const { client: e } = this.internal;
+    if (e == null) return;
+    const n = /* @__PURE__ */ new Set([]);
+    for (const s of this.registry.keys())
+      (await s.needsControlOf(e)).forEach((i) => i !== 0 && n.add(i));
+    const r = Array.from(n);
+    _n.unorderedPrimitiveArrays(this.state.needsControlOf, r) !== _n.EQUAL && this.setState((s) => ({ ...s, needsControlOf: r }));
+  }
+  async acquire() {
+    this.internal.prevTrigger = this.state.acquireTrigger;
+    const { client: e, addStatus: n } = this.internal;
+    if (e == null)
+      return n({
+        message: `Cannot acquire control on ${this.state.name} because no cluster has been connected.`,
+        variant: "warning"
+      });
+    try {
+      await this.updateNeedsControlOf();
+      const r = this.state.needsControlOf;
+      if (r.length === 0)
+        return n({
+          message: `Cannot acquire control on ${this.state.name} because there are no channels to control.`,
+          variant: "warning"
+        });
+      const s = yn.now().sub(C.milliseconds(1));
+      this.writer = await e.openWriter({
+        start: s,
+        channels: r,
+        controlSubject: { key: this.key, name: this.state.name },
+        authorities: this.state.authority,
+        enableAutoCommit: !0
+      }), this.setState((a) => ({ ...a, status: "acquired" }));
+    } catch (r) {
+      if (this.setState((s) => ({ ...s, status: "failed" })), !(r instanceof Error)) throw r;
+      n({
+        variant: "error",
+        message: `${this.state.name} failed to acquire control`,
+        description: r.message
+      });
+    }
+  }
+  async release() {
+    this.internal.prevTrigger = this.state.acquireTrigger;
+    try {
+      await this.writer?.close();
+    } catch (e) {
+      this.internal.addStatus({
+        message: `${this.state.name} failed to release control: ${e.message}`,
+        variant: "error"
+      });
+    } finally {
+      this.setState((e) => ({ ...e, status: "released" })), this.writer = void 0;
+    }
+  }
+  async set(e) {
+    this.writer == null && await this.acquire(), await this.writer?.write(e);
+  }
+  async setAuthority(e, n) {
+    this.writer == null && await this.acquire(), await this.writer?.setAuthority(
+      Object.fromEntries(e.map((r) => [r, n]))
+    );
+  }
+  async releaseAuthority(e) {
+    this.writer == null && await this.acquire(), await this.writer?.setAuthority(
+      Object.fromEntries(e.map((n) => [n, this.state.authority]))
+    );
+  }
+  deleteTelem(e) {
+    this.registry.delete(e), this.updateNeedsControlOf();
+  }
+  /** @implements telem.Factory to create telemetry that is bound to this controller. */
+  create(e) {
+    const { internal: n } = this, s = (() => {
+      switch (e.type) {
+        case nn.TYPE: {
+          const a = new nn(this, n.runAsync, e.props);
+          return this.registry.set(a, null), a;
+        }
+        case sn.TYPE: {
+          const a = new sn(this, this.internal.stateProv, e.props);
+          return this.registry.set(a, null), a;
+        }
+        case rn.TYPE:
+          return new rn(this, n.runAsync, e.props);
+        default:
+          return null;
+      }
+    })();
+    return s != null && this.updateNeedsControlOf(), s;
+  }
+}
+const ru = p.object({
+  channel: p.number()
+});
+class nn extends on {
+  static TYPE = "controlled-numeric-telem-sink";
+  controller;
+  runAsync;
+  schema = ru;
+  constructor(e, n, r) {
+    super(r), this.controller = e, this.runAsync = n;
+  }
+  invalidate() {
+  }
+  cleanup() {
+    this.controller.deleteTelem(this);
+  }
+  async needsControlOf(e) {
+    if (this.props.channel === 0) return [];
+    const n = await e.channels.retrieve(this.props.channel), r = [n.key];
+    return n.index !== 0 && r.push(n.index), r;
+  }
+  set(...e) {
+    this.runAsync(async () => {
+      const { client: n } = this.controller.internal;
+      if (n == null) throw new ia("No cluster connected");
+      if (this.props.channel === 0)
+        throw new aa("No command channel specified for actuator");
+      const r = await n.channels.retrieve(this.props.channel), s = { [r.key]: e };
+      if (r.index !== 0) {
+        const a = await n.channels.retrieve(r.index), i = yn.now();
+        s[a.key] = Array.from(
+          { length: e.length },
+          (o, c) => i.add(C.nanoseconds(c))
+        );
+      }
+      await this.controller.set(s);
+    }, "Failed to command channel");
+  }
+}
+const Gu = (t) => ({
+  type: nn.TYPE,
+  props: t,
+  variant: "sink",
+  valueType: "number"
+}), su = p.object({
+  authority: p.number().default(mn.ABSOLUTE_AUTHORITY),
+  channel: p.number()
+});
+class rn extends on {
+  static TYPE = "acquire-channel-control";
+  controller;
+  runAsync;
+  schema = su;
+  constructor(e, n, r) {
+    super(r), this.controller = e, this.runAsync = n;
+  }
+  cleanup() {
+    this.controller.deleteTelem(this);
+  }
+  async needsControlOf(e) {
+    const n = await e.channels.retrieve(this.props.channel), r = [n.key];
+    return n.index !== 0 && r.push(n.index), r;
+  }
+  set(e) {
+    this.runAsync(async () => {
+      const { controller: n } = this, { client: r } = n.internal;
+      if (r == null) return;
+      const s = await r.channels.retrieve(this.props.channel), a = [s.key];
+      s.index !== 0 && a.push(s.index), e ? await this.controller.setAuthority(a, this.props.authority) : await this.controller.releaseAuthority(a);
+    }, "failed to set channel authority");
+  }
+}
+const Ku = (t) => ({
+  type: rn.TYPE,
+  props: t,
+  variant: "sink",
+  valueType: "boolean"
+}), iu = p.object({
+  channel: p.number()
+}), Qu = p.object({
+  valid: p.boolean(),
+  color: y.colorZ.optional(),
+  authority: p.number()
+});
+class sn extends kr {
+  static TYPE = "controlled-status-source";
+  prov;
+  valid = !1;
+  stopListening;
+  controller;
+  schema = iu;
+  constructor(e, n, r) {
+    super(r), this.prov = n, this.controller = e;
+  }
+  async needsControlOf() {
+    return [];
+  }
+  maybeRevalidate() {
+    if (this.valid) return;
+    const { channel: e } = this.props;
+    this.stopListening?.();
+    const n = Lt.filterTransfersByChannelKey(e);
+    this.stopListening = this.prov.onChange((r) => {
+      n(r).length !== 0 && this.notify?.();
+    }), this.valid = !0;
+  }
+  value() {
+    this.maybeRevalidate();
+    const e = yn.now();
+    if (this.props.channel === 0)
+      return {
+        name: this.controller.key,
+        key: this.controller.key,
+        variant: "disabled",
+        message: "No Channel",
+        time: e,
+        details: { valid: !1, authority: 0 }
+      };
+    const n = this.prov.get(this.props.channel);
+    return n == null ? {
+      name: this.controller.key,
+      key: this.controller.key,
+      variant: "disabled",
+      message: "Uncontrolled",
+      time: e,
+      details: { valid: !0, color: void 0, authority: 0 }
+    } : {
+      name: this.controller.key,
+      key: n.subject.key,
+      variant: n.subject.key === this.controller.key ? "success" : "error",
+      message: `Controlled by ${n.subject.name}`,
+      time: e,
+      details: { valid: !0, color: n.subjectColor, authority: n.authority }
+    };
+  }
+  cleanup() {
+    this.controller.deleteTelem(this), this.stopListening?.();
+  }
+}
+const Ju = (t) => ({
+  type: sn.TYPE,
+  props: t,
+  variant: "source",
+  valueType: "status"
+}), au = p.object({ color: y.colorZ.optional() }).default({ color: void 0 }), ou = p.object({
+  statusSource: dn.optional().default(un),
+  colorSource: Rt.optional().default(Ge),
+  status: Fr.statusZ(au),
+  color: y.colorZ.optional()
+});
+class vr extends Z {
+  static TYPE = "Indicator";
+  schema = ou;
+  stopListeningStatus;
+  stopListeningColor;
+  afterUpdate(e) {
+    const { internal: n } = this, { statusSource: r, colorSource: s } = this.state;
+    n.statusSource = H(e, r, n.statusSource), n.colorSource = H(e, s, n.colorSource), this.updateState(), this.stopListeningStatus?.(), this.stopListeningColor?.(), this.stopListeningStatus = n.statusSource.onChange(this.updateState.bind(this)), this.stopListeningColor = n.colorSource.onChange(this.updateState.bind(this));
+  }
+  afterDelete() {
+    this.internal.statusSource.cleanup?.(), this.internal.colorSource.cleanup?.();
+  }
+  render() {
+  }
+  updateState() {
+    const e = this.internal.colorSource.value(), n = this.internal.statusSource.value();
+    y.equals(e, this.state.color) && n.message === this.state.status.message || this.setState((r) => ({ ...r, color: e, status: n }));
+  }
+}
+const lu = p.object({
+  needsControlOf: Ir.keyZ.array(),
+  states: Jc.array()
+});
+class Tr extends Z {
+  static TYPE = "Legend";
+  schema = lu;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.stateProv = wt.use(e);
+    const r = this.state.needsControlOf;
+    n.disconnectStateProv?.();
+    const s = Lt.filterTransfersByChannelKey(...r), a = n.stateProv.get(r);
+    this.setState((i) => ({ ...i, states: a })), n.disconnectStateProv = n.stateProv.onChange((i) => {
+      if (s(i).length === 0) return;
+      const o = n.stateProv.get(r);
+      this.setState((c) => ({ ...c, states: o }));
+    });
+  }
+  afterDelete() {
+    const { internal: e } = this;
+    e.disconnectStateProv?.();
+  }
+  render() {
+  }
+}
+const eh = {
+  [Sr.TYPE]: Sr,
+  [wt.TYPE]: wt,
+  [vr.TYPE]: vr,
+  [br.TYPE]: br,
+  [Tr.TYPE]: Tr
+}, cu = ["fire", "momentary", "pulse"], uu = p.enum(cu), hu = p.object({
+  trigger: p.number(),
+  sink: Et.optional().default(kt),
+  mode: uu.optional().default("fire")
+}), du = 2, fu = 1;
+class wr extends Z {
+  static TYPE = "Button";
+  schema = hu;
+  afterUpdate(e) {
+    const { sink: n, mode: r, trigger: s } = this.state, { internal: a } = this;
+    a.prevTrigger ??= s, a.sink = Ke(e, n, a.sink);
+    const i = a.prevTrigger;
+    a.prevTrigger = s;
+    const o = s === i + du;
+    s === i + fu ? r == "fire" ? this.internal.sink.set(!0) : r == "momentary" && this.internal.sink.set(!1) : o && (r == "momentary" ? this.internal.sink.set(!0) : r == "pulse" && this.internal.sink.set(!0, !1));
+  }
+  afterDelete() {
+    this.internal.sink.cleanup?.();
+  }
+}
+const th = { [wr.TYPE]: wr };
+p.enum(["small", "medium", "large", "huge"]);
+const gu = p.object({
+  box: g.box,
+  telem: fn.optional().default(hn),
+  backgroundTelem: Rt.optional().default(Ge),
+  level: gn.optional().default("p"),
+  color: y.colorZ.optional().default(y.ZERO),
+  precision: p.number().optional().default(2),
+  minWidth: p.number().optional().default(60),
+  width: p.number().optional(),
+  notation: $r.notationZ.optional().default("standard"),
+  location: K.xy.optional().default({ x: "left", y: "center" }),
+  units: p.string().optional().default("RPM"),
+  bounds: A.bounds.optional().default(A.construct(0, 100)),
+  // New gauge configuration properties
+  barWidth: p.number().optional().default(12)
+  // Width of the gauge bar in pixels
+}), pu = ["upper2d", "lower2d"];
+class Ct extends Z {
+  static TYPE = "gauge";
+  static z = gu;
+  schema = Ct.z;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.render = j.use(e), n.theme = re(e), y.isZero(this.state.color) ? n.textColor = n.theme.colors.gray.l8 : n.textColor = this.state.color, n.telem = H(e, this.state.telem, n.telem), n.stopListening?.(), n.stopListening = n.telem.onChange(() => this.requestRender()), n.backgroundTelem = H(
+      e,
+      this.state.backgroundTelem,
+      n.backgroundTelem
+    ), n.stopListeningBackground?.(), n.stopListeningBackground = n.backgroundTelem.onChange(() => this.requestRender()), n.requestRender = qr(e), n.strokeColor = y.isZero(this.state.color) ? n.theme.colors.visualization.palettes.default[0] : this.state.color;
+    const r = this.state.box, s = g.width(r) / 2, { barWidth: a } = this.state;
+    n.outerRadius = s - 8, n.innerRadius = n.outerRadius - a;
+    const i = Math.PI / 2;
+    n.gaugeStartAngle = 3 * Math.PI / 4, n.gaugeAngleRange = 2 * Math.PI - i, n.gaugeEndAngle = n.gaugeStartAngle + n.gaugeAngleRange, n.labelRadius = n.outerRadius + 12, n.labelInwardShift = 12, n.centerPos = g.center(r);
+    const o = n.centerPos.y + n.labelRadius * Math.sin(n.gaugeStartAngle) + 6;
+    n.minLabelPos = d.construct(
+      n.centerPos.x + n.labelRadius * Math.cos(n.gaugeStartAngle) + n.labelInwardShift,
+      o
+    ), n.maxLabelPos = d.construct(
+      n.centerPos.x + n.labelRadius * Math.cos(n.gaugeEndAngle) - n.labelInwardShift,
+      o
+    ), n.valueTextPos = d.translateY(n.centerPos, -6), n.unitsTextPos = d.translateY(n.centerPos, g.height(r) / 9), n.textLevel = this.state.level, n.labelLevel = Nt(Nt(n.textLevel)), this.requestRender();
+  }
+  afterDelete() {
+    const { internal: e } = this;
+    e.stopListening?.(), e.stopListeningBackground?.(), e.telem.cleanup?.(), e.backgroundTelem.cleanup?.(), e.requestRender == null ? e.render.erase(g.construct(this.state.box), d.ZERO, ...pu) : e.requestRender("layout");
+  }
+  requestRender() {
+    const { requestRender: e } = this.internal;
+    e != null ? e("layout") : this.render({});
+  }
+  render({ viewportScale: e = G.XY.IDENTITY }) {
+    const { internal: n } = this, r = n.render.upper2d.applyScale(e), s = new ve(r, n.theme), a = n.telem.value(), { lower: i, upper: o } = this.state.bounds, c = Number(a), l = A.clamp(this.state.bounds, c), u = o - i, h = u === 0 ? 0 : (l - i) / u, f = n.gaugeStartAngle + h * n.gaugeAngleRange;
+    s.text({
+      text: a,
+      position: n.valueTextPos,
+      shade: 10,
+      level: n.textLevel,
+      align: "middle",
+      justify: "center",
+      weight: 450,
+      code: !0,
+      useAtlas: !0
+    }), s.text({
+      text: this.state.units,
+      position: n.unitsTextPos,
+      shade: 8,
+      level: Nt(n.textLevel),
+      align: "middle",
+      justify: "center",
+      code: !0,
+      useAtlas: !0
+    }), s.text({
+      text: i.toString(),
+      position: n.minLabelPos,
+      shade: 7,
+      level: n.labelLevel,
+      align: "middle",
+      justify: "center",
+      code: !0,
+      useAtlas: !0
+    }), s.text({
+      text: o.toString(),
+      position: n.maxLabelPos,
+      shade: 7,
+      level: n.labelLevel,
+      align: "middle",
+      justify: "center",
+      code: !0,
+      useAtlas: !0
+    }), s.circle({
+      stroke: n.theme.colors.gray.l5,
+      radius: { inner: n.innerRadius, outer: n.outerRadius },
+      position: n.centerPos,
+      angle: { lower: n.gaugeStartAngle, upper: n.gaugeEndAngle },
+      lineCap: "round"
+    }), s.circle({
+      stroke: n.strokeColor,
+      radius: { inner: n.innerRadius, outer: n.outerRadius },
+      position: n.centerPos,
+      angle: {
+        lower: n.gaugeStartAngle,
+        upper: f
+      },
+      lineCap: "round"
+    });
+  }
+}
+const nh = { [Ct.TYPE]: Ct }, mu = p.object({
+  enabled: p.boolean(),
+  source: ln.optional().default(cn)
+});
+class Cr extends Z {
+  static TYPE = "Light";
+  schema = mu;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    this.internal.source = H(e, this.state.source, n.source), this.updateEnabledState(), n.stopListening?.(), n.stopListening = n.source.onChange(() => this.updateEnabledState());
+  }
+  updateEnabledState() {
+    const e = this.internal.source.value();
+    e !== this.state.enabled && this.setState((n) => ({ ...n, enabled: e }));
+  }
+  afterDelete() {
+    this.internal.stopListening?.(), this.internal.source.cleanup?.();
+  }
+}
+const rh = { [Cr.TYPE]: Cr }, yu = p.object({
+  trigger: p.number(),
+  command: p.number().optional(),
+  value: p.number(),
+  sink: Ar.optional().default(Mr),
+  source: Or.optional().default(Pr)
+});
+class Er extends Z {
+  static TYPE = "Setpoint";
+  schema = yu;
+  afterUpdate(e) {
+    const { sink: n, source: r, trigger: s, command: a } = this.state, { internal: i } = this;
+    i.prevTrigger ??= s, this.internal.source = H(e, r, this.internal.source), i.sink = Ke(e, n, i.sink);
+    const o = i.prevTrigger;
+    i.prevTrigger = s, s > o && a != null && this.internal.sink.set(a), this.updateValue(), i.stopListening?.(), i.stopListening = i.source.onChange(() => this.updateValue());
+  }
+  updateValue() {
+    const e = this.internal.source.value();
+    e === this.state.value || isNaN(e) || this.setState((n) => ({ ...n, value: e, triggered: !1 }));
+  }
+  afterDelete() {
+    const { internal: e } = this;
+    e.stopListening?.(), e.source.cleanup?.(), e.sink.cleanup?.();
+  }
+}
+const sh = { [Er.TYPE]: Er }, bu = p.object({
+  triggered: p.boolean(),
+  enabled: p.boolean(),
+  sink: Et.optional().default(kt),
+  source: ln.optional().default(cn)
+});
+class Rr extends Z {
+  static TYPE = "Toggle";
+  schema = bu;
+  afterUpdate(e) {
+    this.internal.addStatus = oa(e);
+    const { sink: n, source: r, triggered: s, enabled: a } = this.state, { triggered: i } = this.prevState, { internal: o } = this;
+    o.source = H(e, r, o.source), o.sink = Ke(e, n, o.sink), s && !i && o.sink.set(!a), this.updateEnabledState(), o.stopListening?.(), o.stopListening = o.source.onChange(() => this.updateEnabledState());
+  }
+  updateEnabledState() {
+    const e = this.internal.source.value();
+    e !== this.state.enabled && this.setState((n) => ({ ...n, enabled: e, triggered: !1 }));
+  }
+  afterDelete() {
+    this.internal.stopListening?.(), this.internal.source.cleanup?.(), this.internal.sink.cleanup?.();
+  }
+}
+const ih = { [Rr.TYPE]: Rr }, $t = { useAtlas: !0 }, xu = p.object({
+  box: g.box,
+  telem: fn.optional().default(hn),
+  backgroundTelem: Rt.optional().default(Ge),
+  level: gn.optional().default("p"),
+  color: y.colorZ.optional().default(y.ZERO),
+  precision: p.number().optional().default(2),
+  stalenessTimeout: p.number().optional().default(5),
+  stalenessColor: y.colorZ.optional().default(y.ZERO),
+  minWidth: p.number().optional().default(60),
+  width: p.number().optional(),
+  notation: $r.notationZ.optional().default("standard"),
+  location: K.xy.optional().default({ x: "left", y: "center" }),
+  useWidthForBackground: p.boolean().optional().default(!1),
+  valueBackgroundShift: d.xy.optional().default(d.ZERO),
+  valueBackgroundOverScan: d.xy.optional().default(d.ZERO)
+}), Su = ["upper2d", "lower2d"];
+class Ve extends Z {
+  static TYPE = "value";
+  static z = xu;
+  schema = Ve.z;
+  afterUpdate(e) {
+    const { internal: n } = this;
+    n.renderCtx = j.use(e), n.theme = re(e), n.telem = H(e, this.state.telem, n.telem), n.stopListening?.(), n.stopListening = n.telem.onChange(() => {
+      n.lastReceived = performance.now(), this.requestRender();
+    }), n.fontString = Fe(n.theme, { level: this.state.level, code: !0 }), n.backgroundTelem = H(
+      e,
+      this.state.backgroundTelem,
+      n.backgroundTelem
+    ), n.stopListeningBackground?.(), n.stopListeningBackground = n.backgroundTelem.onChange(() => this.requestRender()), n.requestRender = qr(e), this.requestRender();
+  }
+  afterDelete() {
+    const { internal: e } = this;
+    e.stopListening?.(), e.stopListeningBackground?.(), e.telem.cleanup?.(), e.backgroundTelem.cleanup?.(), e.requestRender == null ? e.renderCtx.erase(g.construct(this.state.box), d.ZERO, ...Su) : e.requestRender("layout");
+  }
+  requestRender() {
+    const { requestRender: e } = this.internal;
+    e != null ? e("layout") : this.render({});
+  }
+  get fontHeight() {
+    const { theme: e } = this.internal;
+    return e.typography[this.state.level].size * e.sizes.base;
+  }
+  maybeUpdateWidth(e) {
+    const { theme: n } = this.internal, r = e + n.sizes.base + this.fontHeight;
+    this.state.width == null || this.state.width + this.fontHeight * 0.5 < r || this.state.minWidth > r && this.state.width !== this.state.minWidth ? this.setState((s) => ({ ...s, width: Math.max(r, s.minWidth) })) : this.state.width - this.fontHeight > r && this.setState((s) => ({ ...s, width: Math.max(r, s.minWidth) }));
+  }
+  getTextColor() {
+    const { theme: e } = this.internal;
+    return performance.now() - this.internal.lastReceived > this.state.stalenessTimeout * 1e3 ? y.isZero(this.state.stalenessColor) ? e.colors.warning.m1 : this.state.stalenessColor : y.isZero(this.state.color) ? y.pickByContrast(
+      e.colors.border,
+      e.colors.gray.l11,
+      e.colors.gray.l0
+    ) : y.pickByContrast(
+      e.colors.border,
+      e.colors.gray.l11,
+      this.state.color
+    );
+  }
+  render({ viewportScale: e = G.XY.IDENTITY }) {
+    const { renderCtx: n, telem: r, backgroundTelem: s, fontString: a, requestRender: i } = this.internal, { location: o, box: c } = this.state;
+    if (g.areaIsZero(c)) return;
+    const l = g.topLeft(c), u = g.width(c), h = g.height(c), f = n.lower2d.applyScale(e);
+    let b = r.value();
+    f.font = a;
+    const v = this.fontHeight, S = b[0] == "-";
+    S && (b = b.slice(1));
+    const { theme: T } = this.internal, k = f.textDimensions(b, $t), L = k.width + T.sizes.base, D = k.height;
+    i == null && n.erase(g.construct(this.prevState.box)), this.maybeUpdateWidth(L);
+    const N = { ...d.ZERO };
+    o.x === "left" ? N.x = 6 + v * 0.75 : o.x === "center" && (N.x = u / 2 - L / 2), o.y === "center" && (N.y = h / 2 + D / 2);
+    const _ = d.translate(l, N);
+    if (this.state.backgroundTelem.type != Ge.type) {
+      const I = s.value();
+      if (!y.isZero(I)) {
+        f.fillStyle = y.hex(I);
+        const Ie = this.state.useWidthForBackground ? this.state.width ?? this.state.minWidth : g.width(c);
+        f.fillRect(
+          ...d.couple(d.translate(l, this.state.valueBackgroundShift)),
+          Ie + this.state.valueBackgroundOverScan.x,
+          h + this.state.valueBackgroundOverScan.y
+        );
+      }
+    }
+    const w = this.getTextColor();
+    f.fillStyle = y.hex(w), S && f.fillText(
+      "-",
+      ...d.couple(d.translateX(_, -v * 0.6)),
+      void 0,
+      $t
+    ), f.fillText(b, ...d.couple(_), void 0, $t);
+  }
+}
+const vu = {
+  [Ve.TYPE]: Ve
+}, ah = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  REGISTRY: vu,
+  Value: Ve
+}, Symbol.toStringTag, { value: "Module" })), Tu = pe.object({}), an = "flux-context", bs = "flux.Provider", wu = (t, e) => t.get(an).scopedStore(e), Cu = (t) => {
+  const e = (n, r) => {
+    if ("client" in t) return t.client;
+    const s = Pt(n);
+    return r != null && r?.client?.key === s?.key ? r : new so({
+      client: s,
+      storeConfig: t.storeConfig,
+      handleError: he(n),
+      handleAsyncError: la(n)
+    });
+  };
+  return class xs extends fe {
+    static TYPE = bs;
+    static stateZ = Tu;
+    schema = xs.stateZ;
+    afterUpdate(r) {
+      const { internal: s } = this;
+      s.store = e(r, s.store), r.wasSetPreviously(an) || r.set(an, s.store);
+    }
+  };
+}, oh = (t) => ({ [bs]: Cu(t) });
+export {
+  cc as $,
+  ju as A,
+  Xt as B,
+  Hu as C,
+  qu as D,
+  Wu as E,
+  Xu as F,
+  Zu as G,
+  Pu as H,
+  Au as I,
+  Ou as J,
+  Bu as K,
+  mr as L,
+  _u as M,
+  ah as N,
+  dt as O,
+  Hn as P,
+  _a as Q,
+  Fu as R,
+  ze as S,
+  wn as T,
+  Wr as U,
+  Wt as V,
+  Xr as W,
+  tn as X,
+  Jt as Y,
+  Le as Z,
+  _e as _,
+  Sn as a,
+  Cr as a$,
+  dc as a0,
+  uc as a1,
+  hs as a2,
+  lc as a3,
+  dr as a4,
+  us as a5,
+  cs as a6,
+  rn as a7,
+  sn as a8,
+  br as a9,
+  to as aA,
+  Nu as aB,
+  Wn as aC,
+  De as aD,
+  wc as aE,
+  yc as aF,
+  Ot as aG,
+  Za as aH,
+  zt as aI,
+  ms as aJ,
+  St as aK,
+  Mc as aL,
+  en as aM,
+  ys as aN,
+  vt as aO,
+  ps as aP,
+  xt as aQ,
+  Bc as aR,
+  Tt as aS,
+  wr as aT,
+  hu as aU,
+  fu as aV,
+  du as aW,
+  cu as aX,
+  Ve as aY,
+  Ct as aZ,
+  mu as a_,
+  Sr as aa,
+  vr as ab,
+  Tr as ac,
+  eu as ad,
+  nn as ae,
+  wt as af,
+  Ku as ag,
+  su as ah,
+  Ju as ai,
+  Qu as aj,
+  iu as ak,
+  Kc as al,
+  Gc as am,
+  nu as an,
+  ou as ao,
+  au as ap,
+  lu as aq,
+  Gu as ar,
+  ru as as,
+  Qc as at,
+  tu as au,
+  Jc as av,
+  bs as aw,
+  Tu as ax,
+  so as ay,
+  eo as az,
+  ao as b,
+  yu as b0,
+  Er as b1,
+  bu as b2,
+  Rr as b3,
+  Xe as b4,
+  xn as c,
+  nh as d,
+  Vu as e,
+  $u as f,
+  vu as g,
+  Nc as h,
+  ih as i,
+  sh as j,
+  Ec as k,
+  Ic as l,
+  Yu as m,
+  _c as n,
+  Lu as o,
+  rh as p,
+  Ja as q,
+  de as r,
+  eh as s,
+  Qa as t,
+  qr as u,
+  th as v,
+  oh as w,
+  Uu as x,
+  Iu as y,
+  zu as z
+};