@synnaxlabs/pluto 0.40.1 → 0.42.0

package/dist/css-B7c7_G5h.js

@@ -0,0 +1,4746 @@
+var Fn = Object.defineProperty;
+var _n = (r, e, t) => e in r ? Fn(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var je = (r, e, t) => _n(r, typeof e != "symbol" ? e + "" : e, t);
+import se, { z as a } from "zod";
+const Xe = a.tuple([a.number(), a.number()]);
+a.tuple([a.bigint(), a.bigint()]);
+const Lt = a.object({ width: a.number(), height: a.number() }), qn = a.object({
+  signedWidth: a.number(),
+  signedHeight: a.number()
+}), Wn = ["width", "height"];
+a.enum(Wn);
+const Vn = ["start", "center", "end"], Yn = ["signedWidth", "signedHeight"];
+a.enum(Yn);
+const Ne = a.object({ x: a.number(), y: a.number() }), Ir = a.object({ clientX: a.number(), clientY: a.number() }), Rt = ["x", "y"], jt = a.enum(Rt), Nr = ["top", "right", "bottom", "left"], Zn = a.enum(Nr), Qe = ["left", "right"], kt = a.enum(Qe), et = ["top", "bottom"], Dt = a.enum(et), Pt = ["center"], dt = a.enum(Pt), Hn = [...Nr, ...Pt], zt = a.enum(Hn);
+a.enum(Vn);
+const Gn = ["first", "last"];
+a.enum(Gn);
+const Ur = a.object({ lower: a.number(), upper: a.number() }), Kn = a.object({ lower: a.bigint(), upper: a.bigint() });
+a.union([Ur, Xe]);
+a.union([Kn, Xe]);
+const Jn = a.enum([...jt.options, ...zt.options]), Xn = a.union([jt, zt, a.instanceof(String)]), K = (r) => typeof r == "bigint" || r instanceof BigInt, $e = (r, e) => K(r) ? r.valueOf() - BigInt(e.valueOf().valueOf()) : r.valueOf() - Number(e.valueOf()), Br = (r, e) => K(r) ? r.valueOf() + BigInt(e.valueOf().valueOf()) : r + Number(e.valueOf()), Qn = (r, e, t = 1e-4) => Math.abs(r - e) < t, gt = (r, e) => K(r) ? r === BigInt(e.valueOf().valueOf()) : r === Number(e.valueOf()), es = (r) => {
+  const e = 10 ** Math.floor(Math.log10(r));
+  return Math.round(r / e) * e;
+}, Er = (r, e) => K(r) ? r.valueOf() < BigInt(e.valueOf()) ? r : BigInt(e.valueOf()) : r.valueOf() < Number(e.valueOf()) ? r : Number(e.valueOf()), ts = (r, e) => K(r) ? r.valueOf() > BigInt(e.valueOf()) ? r : BigInt(e.valueOf()) : r.valueOf() > Number(e.valueOf()) ? r : Number(e.valueOf()), Ar = (r) => K(r) || r instanceof BigInt ? r.valueOf() < 0n ? -r : r : r.valueOf() < 0 ? -r : r, X = (r, e) => K(r) ? r.valueOf() * BigInt(e.valueOf()) : r.valueOf() * Number(e.valueOf()), rs = (r, e) => K(r) ? r.valueOf() / BigInt(e.valueOf()) : r.valueOf() / Number(e.valueOf()), m = (r, e) => {
+  const t = {};
+  if (typeof r == "number" || typeof r == "bigint")
+    e != null ? (t.lower = r, t.upper = e) : (t.lower = typeof r == "bigint" ? 0n : 0, t.upper = r);
+  else if (Array.isArray(r)) {
+    if (r.length !== 2) throw new Error("bounds: expected array of length 2");
+    [t.lower, t.upper] = r;
+  } else return pt(r);
+  return pt(t);
+}, ns = Object.freeze({ lower: 0, upper: 0 }), ss = Object.freeze({ lower: -1 / 0, upper: 1 / 0 }), is = Object.freeze({ lower: 0, upper: 1 }), os = Object.freeze({ lower: -1, upper: 1 }), as = (r, e) => {
+  if (r == null && e == null) return !0;
+  if (r == null || e == null) return !1;
+  const t = m(r), n = m(e);
+  return (t == null ? void 0 : t.lower) === (n == null ? void 0 : n.lower) && (t == null ? void 0 : t.upper) === (n == null ? void 0 : n.upper);
+}, pt = (r) => r.lower > r.upper ? { lower: r.upper, upper: r.lower } : r, yt = (r, e) => {
+  const t = m(r);
+  return e < t.lower ? t.lower : e >= t.upper ? t.upper - (typeof t.upper == "number" ? 1 : 1n) : e;
+}, C = (r, e) => {
+  const t = m(r);
+  if (typeof e == "number" || typeof e == "bigint")
+    return e >= t.lower && e < t.upper;
+  const n = m(e);
+  return n.lower >= t.lower && n.upper <= t.upper;
+}, us = (r, e) => {
+  const t = m(r), n = m(e);
+  return t.lower === n.lower ? !0 : n.upper === t.lower || n.lower === t.upper ? !1 : C(t, n.upper) || C(t, n.lower) || C(n, t.upper) || C(n, t.lower);
+}, Me = (r) => {
+  const e = m(r);
+  return e.upper - e.lower;
+}, ls = (r) => {
+  const e = m(r);
+  return typeof e.lower == "bigint" ? e.lower === 0n && e.upper === 0n : e.lower === 0 && e.upper === 0;
+}, hs = (r) => {
+  const e = Me(r);
+  return typeof e == "number" ? e === 0 : e === 0n;
+}, cs = (r) => {
+  const e = m(r);
+  return typeof e.lower == "bigint" ? !0 : Number.isFinite(e.lower) && Number.isFinite(e.upper);
+}, fs = (r) => {
+  const e = m(r);
+  return (e.upper + e.lower) / 2;
+}, Mr = (r) => ({
+  lower: Math.min(...r.map((e) => m(e).lower)),
+  upper: Math.max(...r.map((e) => m(e).upper))
+}), ds = (r) => ({
+  lower: Math.max(...r.map((e) => m(e).lower)),
+  upper: Math.min(...r.map((e) => m(e).upper))
+}), gs = (r) => {
+  const e = m(r), t = typeof e.lower == "bigint";
+  return Array.from({ length: Number(Me(r)) }, (n, s) => t ? e.lower + BigInt(s) : e.lower + s);
+}, mt = (r, e) => {
+  const t = r.map((i) => m(i)), n = t.findIndex((i) => C(i, e) || e < i.lower);
+  if (n === -1) return { index: r.length, position: 0 };
+  const s = t[n];
+  return C(s, e) ? { index: n, position: Number(e - s.lower) } : { index: n, position: 0 };
+}, at = {
+  removeBefore: 0,
+  removeAfter: 0,
+  insertInto: 0,
+  deleteInBetween: 0
+}, ps = (r, e) => {
+  const t = r.map((f) => m(f)), n = m(e);
+  if (t.length === 0) return at;
+  const s = mt(t, n.lower), i = mt(t, n.upper);
+  if (s.index === r.length) return { ...at, insertInto: r.length };
+  if (i.index === 0) return { ...at, removeAfter: i.position };
+  if (s.index === i.index)
+    return s.position !== 0 && i.position !== 0 ? null : {
+      removeAfter: i.position,
+      removeBefore: s.position,
+      insertInto: s.index,
+      deleteInBetween: 0
+    };
+  let o = i.index - s.index, u = s.index, h = $e(Number(Me(t[s.index])), s.position);
+  return s.position !== 0 ? (o -= 1, u += 1) : h = 0, {
+    removeBefore: h,
+    removeAfter: i.position,
+    insertInto: u,
+    deleteInBetween: o
+  };
+}, Cr = (r, e, t) => {
+  const n = r.map((u) => m(u)), s = t > 0 ? 1 : t < 0 ? -1 : 0;
+  if (s === 0) return e;
+  let i = t, o = e;
+  for (; gt(i, 0) === !1; ) {
+    const u = n.findIndex((h) => s > 0 ? o >= h.lower && o < h.upper : o > h.lower && o <= h.upper);
+    if (u !== -1) {
+      const h = n[u];
+      let f;
+      if (s > 0 ? f = $e(h.upper, o) : f = $e(o, h.lower), f > 0) {
+        const g = Er(Ar(i), f);
+        if (o = Br(
+          o,
+          s > 0 ? g : -g
+        ), i = $e(i, s > 0 ? g : -g), gt(i, 0)) return o;
+        continue;
+      }
+    }
+    if (s > 0) {
+      const h = n.filter((f) => f.lower > o);
+      if (h.length > 0) o = h[0].lower;
+      else return o;
+    } else {
+      const h = n.filter((f) => f.upper < o);
+      if (h.length > 0)
+        o = h[h.length - 1].upper;
+      else return o;
+    }
+  }
+  return o;
+}, Lr = (r, e, t) => {
+  const n = r.map((o) => m(o));
+  if (e === t) return typeof e == "bigint" ? 0n : 0;
+  const s = e < t ? m([e, t]) : m([t, e]);
+  let i = typeof e == "bigint" ? 0n : 0;
+  for (const o of n) {
+    const u = o.lower > s.lower ? o.lower : s.lower, h = o.upper < s.upper ? o.upper : s.upper;
+    if (u < h) {
+      const f = h - u;
+      i = i + f;
+    }
+  }
+  return i;
+}, zu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  CLIP: os,
+  DECIMAL: is,
+  INFINITE: ss,
+  ZERO: ns,
+  bounds: Ur,
+  buildInsertionPlan: ps,
+  clamp: yt,
+  construct: m,
+  contains: C,
+  distance: Lr,
+  equals: as,
+  findInsertPosition: mt,
+  isFinite: cs,
+  isZero: ls,
+  linspace: gs,
+  makeValid: pt,
+  max: Mr,
+  mean: fs,
+  min: ds,
+  overlapsWith: us,
+  span: Me,
+  spanIsZero: hs,
+  traverse: Cr
+}, Symbol.toStringTag, { value: "Module" })), Rr = Jn, J = (r) => Rt.includes(r) ? r : et.includes(r) ? "y" : "x", ys = (r) => J(r) === "x" ? "y" : "x", ms = (r) => J(r) === "x" ? "width" : "height", ws = (r) => J(r) === "x" ? "left" : "top", bs = (r) => Rr.safeParse(r).success, vs = (r) => J(r) === "x" ? "signedWidth" : "signedHeight", $s = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  construct: J,
+  crude: Rr,
+  dimension: ms,
+  direction: jt,
+  isDirection: bs,
+  location: ws,
+  signedDimension: vs,
+  swap: ys
+}, Symbol.toStringTag, { value: "Module" })), xs = (r) => {
+  const e = r.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
+  return e.length > 1 && e[0] === e[0].toUpperCase() && e[1] === e[1].toUpperCase() || e.length === 0 ? e : e[0].toLowerCase() + e.slice(1);
+}, Ft = (r) => {
+  const e = (t, n = wt) => {
+    if (typeof t == "string") return r(t);
+    if (Array.isArray(t)) return t.map((o) => e(o, n));
+    if (!ut(t)) return t;
+    n = Ts(n);
+    const s = {}, i = t;
+    return Object.keys(i).forEach((o) => {
+      let u = i[o];
+      const h = r(o);
+      n.recursive && (ut(u) ? lr(u, n.keepTypesOnRecursion) || (u = e(u, n)) : n.recursiveInArray && ur(u) && (u = [...u].map((f) => {
+        let g = f;
+        return ut(f) ? lr(g, n.keepTypesOnRecursion) || (g = e(f, n)) : ur(f) && (g = e({ key: f }, n).key), g;
+      }))), s[h] = u;
+    }), s;
+  };
+  return e;
+}, tt = Ft(xs), Os = (r) => (
+  // Don't convert the first character and don't convert a character that is after a
+  // non-alphanumeric character
+  r.replace(
+    /([a-z0-9])([A-Z])/g,
+    (e, t, n) => `${t}_${n.toLowerCase()}`
+  )
+), _t = Ft(Os), jr = (r) => r.length === 0 ? r : r[0].toUpperCase() + r.slice(1), wt = {
+  recursive: !0,
+  recursiveInArray: !0,
+  keepTypesOnRecursion: [Number, String, Uint8Array]
+}, Ts = (r = wt) => (r.recursive == null ? r = wt : r.recursiveInArray ?? (r.recursiveInArray = !1), r), ur = (r) => r != null && Array.isArray(r), ut = (r) => r != null && typeof r == "object" && !Array.isArray(r), lr = (r, e) => (e || []).some((t) => r instanceof t), Ss = (r) => r.replace(/\s+/g, "-").replace(
+  /([a-z0-9])([A-Z])/g,
+  (e, t, n) => `${t}-${n.toLowerCase()}`
+).toLowerCase(), Is = Ft(Ss), Fu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  camelToSnake: _t,
+  capitalize: jr,
+  snakeToCamel: tt,
+  toKebab: Is
+}, Symbol.toStringTag, { value: "Module" })), Ns = kt, Us = Dt, Bs = dt, Es = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right",
+  center: "center"
+}, As = {
+  top: "left",
+  right: "top",
+  bottom: "right",
+  left: "bottom",
+  center: "center"
+}, Ms = Xn, Z = (r) => r instanceof String || !Rt.includes(r) ? r : r === "x" ? "left" : "top", Cs = (r) => Es[Z(r)], Ls = (r) => As[Z(r)], Ue = (r) => {
+  const e = Z(r);
+  return e === "top" || e === "bottom" ? "y" : "x";
+}, Rs = a.object({
+  x: kt.or(dt),
+  y: Dt.or(dt)
+}), kr = a.object({ x: kt, y: Dt }), Ce = Object.freeze({ x: "left", y: "top" }), qt = Object.freeze({ x: "right", y: "top" }), rt = Object.freeze({ x: "left", y: "bottom" }), Wt = Object.freeze({ x: "right", y: "bottom" }), Vt = Object.freeze({ x: "center", y: "center" }), Yt = Object.freeze({ x: "center", y: "top" }), Zt = Object.freeze({ x: "center", y: "bottom" }), Ht = Object.freeze({ x: "right", y: "center" }), Gt = Object.freeze({ x: "left", y: "center" }), js = Object.freeze([
+  Gt,
+  Ht,
+  Yt,
+  Zt,
+  Ce,
+  qt,
+  rt,
+  Wt,
+  Vt
+]), Kt = (r, e) => r.x === e.x && r.y === e.y, ks = (r, e) => {
+  if (typeof e == "object") {
+    let t = !0;
+    return "x" in e && (r.x === e.x || (t = !1)), "y" in e && (r.y === e.y || (t = !1)), t;
+  }
+  return r.x === e || r.y === e;
+}, Dr = (r) => [r.x, r.y], _e = (r) => Ue(Z(r)) === "x", Ds = (r) => Ue(Z(r)) === "y", Ps = (r) => `${r.x}${jr(r.y)}`, zs = (r, e) => {
+  let t, n;
+  if (typeof r == "object" && "x" in r ? (t = r.x, n = r.y) : (t = Z(r), n = Z(e ?? r)), Ue(t) === Ue(n) && t !== "center" && n !== "center")
+    throw new Error(
+      `[XYLocation] - encountered two locations with the same direction: ${t.toString()} - ${n.toString()}`
+    );
+  const s = { ...Vt };
+  return t === "center" ? _e(n) ? [s.x, s.y] = [n, t] : [s.x, s.y] = [t, n] : n === "center" ? _e(t) ? [s.x, s.y] = [t, n] : [s.x, s.y] = [n, t] : _e(t) ? [s.x, s.y] = [t, n] : [s.x, s.y] = [n, t], s;
+}, Fs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BOTTOM_CENTER: Zt,
+  BOTTOM_LEFT: rt,
+  BOTTOM_RIGHT: Wt,
+  CENTER: Vt,
+  CENTER_LEFT: Gt,
+  CENTER_LOCATIONS: Pt,
+  CENTER_RIGHT: Ht,
+  TOP_CENTER: Yt,
+  TOP_LEFT: Ce,
+  TOP_RIGHT: qt,
+  XY_LOCATIONS: js,
+  X_LOCATIONS: Qe,
+  Y_LOCATIONS: et,
+  center: Bs,
+  construct: Z,
+  constructXY: zs,
+  corner: kr,
+  crude: Ms,
+  direction: Ue,
+  isX: _e,
+  isY: Ds,
+  location: zt,
+  outer: Zn,
+  rotate90: Ls,
+  swap: Cs,
+  x: Ns,
+  xy: Rs,
+  xyCouple: Dr,
+  xyEquals: Kt,
+  xyMatches: ks,
+  xyToString: Ps,
+  y: Us
+}, Symbol.toStringTag, { value: "Module" })), bt = a.union([
+  a.number(),
+  Ne,
+  Xe,
+  Lt,
+  qn,
+  Ir
+]), T = (r, e) => {
+  if (typeof r == "string") {
+    if (e === void 0) throw new Error("The y coordinate must be given.");
+    return r === "x" ? { x: e, y: 0 } : { x: 0, y: e };
+  }
+  return typeof r == "number" ? { x: r, y: e ?? r } : Array.isArray(r) ? { x: r[0], y: r[1] } : "signedWidth" in r ? { x: r.signedWidth, y: r.signedHeight } : "clientX" in r ? { x: r.clientX, y: r.clientY } : "width" in r ? { x: r.width, y: r.height } : { x: r.x, y: r.y };
+}, D = Object.freeze({ x: 0, y: 0 }), Pr = Object.freeze({ x: 1, y: 1 }), _s = Object.freeze({ x: 1 / 0, y: 1 / 0 }), qs = Object.freeze({ x: NaN, y: NaN }), Ge = (r, e, t = 0) => {
+  const n = T(r), s = T(e);
+  return t === 0 ? n.x === s.x && n.y === s.y : Math.abs(n.x - s.x) <= t && Math.abs(n.y - s.y) <= t;
+}, Ws = (r) => Ge(r, D), Jt = (r, e, t) => {
+  const n = T(r), s = T(e, t);
+  return { x: n.x * s.x, y: n.y * s.y };
+}, zr = (r, e) => {
+  const t = T(r);
+  return { x: t.x + e, y: t.y };
+}, Fr = (r, e) => {
+  const t = T(r);
+  return { x: t.x, y: t.y + e };
+}, Be = (r, e, t, ...n) => typeof e == "string" && typeof t == "number" ? e === "x" ? zr(r, t) : Fr(r, t) : [r, e, t ?? D, ...n].reduce((s, i) => {
+  const o = T(i);
+  return { x: s.x + o.x, y: s.y + o.y };
+}, D), Vs = (r, e, t) => {
+  const n = T(r);
+  return e === "x" ? { x: t, y: n.y } : { x: n.x, y: t };
+}, Ys = (r, e) => {
+  const t = T(r), n = T(e);
+  return Math.sqrt((t.x - n.x) ** 2 + (t.y - n.y) ** 2);
+}, Zs = (r, e) => {
+  const t = T(r), n = T(e);
+  return { x: n.x - t.x, y: n.y - t.y };
+}, Hs = (r) => {
+  const e = T(r);
+  return Number.isNaN(e.x) || Number.isNaN(e.y);
+}, Gs = (r) => {
+  const e = T(r);
+  return Number.isFinite(e.x) && Number.isFinite(e.y);
+}, Ks = (r) => {
+  const e = T(r);
+  return [e.x, e.y];
+}, Js = (r) => {
+  const e = T(r);
+  return { left: e.x, top: e.y };
+}, vt = (r, e = 0) => {
+  const t = T(r);
+  return { x: Number(t.x.toFixed(e)), y: Number(t.y.toFixed(e)) };
+}, fe = (r, e) => {
+  const t = T(r), n = T(e);
+  return { x: t.x - n.x, y: t.y - n.y };
+}, de = (r) => {
+  const e = T(r), t = Math.hypot(e.x, e.y);
+  return t === 0 ? { x: 0, y: 0 } : { x: -e.y / t, y: e.x / t };
+}, _r = (r) => {
+  const e = T(r), t = Math.hypot(e.x, e.y);
+  return t === 0 ? { x: 0, y: 0 } : { x: e.x / t, y: e.y / t };
+}, qr = (...r) => {
+  const e = r.reduce((t, n) => Be(t, n), D);
+  return Jt(e, 1 / r.length);
+}, Xs = (r, e) => {
+  const t = [];
+  for (let n = 0; n < r.length; n++) {
+    const s = r[n];
+    let i, o, u, h;
+    if (n === 0) {
+      const f = r[n + 1], g = fe(f, s);
+      o = de(g), u = o, h = e;
+    } else if (n === r.length - 1) {
+      const f = r[n - 1], g = fe(s, f);
+      i = de(g), u = i, h = e;
+    } else {
+      const f = r[n - 1], g = r[n + 1], d = fe(s, f), B = fe(g, s);
+      i = de(d), o = de(B);
+      const M = Math.acos(
+        (d.x * B.x + d.y * B.y) / (Math.hypot(d.x, d.y) * Math.hypot(B.x, B.y))
+      ), ue = Math.sin(M / 2);
+      ue === 0 ? h = e : h = e / ue, u = _r(qr(i, o));
+    }
+    t.push(Jt(u, h));
+  }
+  return t;
+}, Qs = (r) => {
+  const e = T(r);
+  return { x: e.y, y: e.x };
+}, _u = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  INFINITY: _s,
+  NAN: qs,
+  ONE: Pr,
+  ZERO: D,
+  average: qr,
+  calculateMiters: Xs,
+  clientXY: Ir,
+  construct: T,
+  couple: Ks,
+  crudeZ: bt,
+  css: Js,
+  distance: Ys,
+  equals: Ge,
+  isFinite: Gs,
+  isNan: Hs,
+  isZero: Ws,
+  normal: de,
+  normalize: _r,
+  scale: Jt,
+  set: Vs,
+  sub: fe,
+  swap: Qs,
+  translate: Be,
+  translateX: zr,
+  translateY: Fr,
+  translation: Zs,
+  truncate: vt,
+  xy: Ne
+}, Symbol.toStringTag, { value: "Module" })), ke = a.union([a.number(), a.string()]), ei = a.object({
+  top: ke,
+  left: ke,
+  width: ke,
+  height: ke
+}), ti = a.object({
+  left: a.number(),
+  top: a.number(),
+  right: a.number(),
+  bottom: a.number()
+}), ri = a.object({
+  one: Ne,
+  two: Ne,
+  root: kr
+}), Wr = { one: D, two: D, root: Ce }, ni = { one: D, two: Pr, root: rt }, Vr = (r, e) => ({
+  one: r.one,
+  two: r.two,
+  root: e ?? r.root
+}), S = (r, e, t = 0, n = 0, s) => {
+  const i = {
+    one: { ...D },
+    two: { ...D },
+    root: s ?? Ce
+  };
+  if (typeof r == "number") {
+    if (typeof e != "number")
+      throw new Error("Box constructor called with invalid arguments");
+    return i.one = { x: r, y: e }, i.two = { x: i.one.x + t, y: i.one.y + n }, i;
+  }
+  return "one" in r && "two" in r && "root" in r ? { ...r, root: s ?? r.root } : ("getBoundingClientRect" in r && (r = r.getBoundingClientRect()), "left" in r ? (i.one = { x: r.left, y: r.top }, i.two = { x: r.right, y: r.bottom }, i) : (i.one = r, e == null ? i.two = { x: i.one.x + t, y: i.one.y + n } : typeof e == "number" ? i.two = { x: i.one.x + e, y: i.one.y + t } : "width" in e ? i.two = {
+    x: i.one.x + e.width,
+    y: i.one.y + e.height
+  } : "signedWidth" in e ? i.two = {
+    x: i.one.x + e.signedWidth,
+    y: i.one.y + e.signedHeight
+  } : i.two = e, i));
+}, si = (r, e, t) => {
+  const n = S(r);
+  if (typeof e == "string") {
+    if (t == null) throw new Error("Invalid arguments for resize");
+    const s = J(e);
+    return S(
+      n.one,
+      void 0,
+      s === "x" ? t : H(n),
+      s === "y" ? t : G(n),
+      n.root
+    );
+  }
+  return S(n.one, e, void 0, void 0, n.root);
+}, ii = (r, e, t = !0) => {
+  const n = S(r);
+  let s = (i, o) => i < o;
+  return t && (s = (i, o) => i <= o), "one" in e ? s(V(n), V(e)) && s(ee(e), ee(n)) && s(Y(n), Y(e)) && s(te(e), te(n)) : s(V(n), e.x) && s(e.x, ee(n)) && s(Y(n), e.y) && s(e.y, te(n));
+}, oi = (r, e) => Ge(r.one, e.one) && Ge(r.two, e.two) && Kt(r.root, e.root), Yr = (r) => ({
+  width: H(r),
+  height: G(r)
+}), ai = (r) => ({
+  signedWidth: nt(r),
+  signedHeight: st(r)
+}), ui = (r) => ({
+  top: Y(r),
+  left: V(r),
+  width: H(r),
+  height: G(r)
+}), Xt = (r, e, t = !1) => {
+  const n = J(e) === "y" ? st(r) : nt(r);
+  return t ? n : Math.abs(n);
+}, F = (r, e) => {
+  const t = S(r);
+  return {
+    x: e.x === "center" ? $t(t).x : ne(t, e.x),
+    y: e.y === "center" ? $t(t).y : ne(t, e.y)
+  };
+}, ne = (r, e) => {
+  const t = S(r), n = Dr(t.root).includes(e) ? Math.min : Math.max;
+  return Qe.includes(e) ? n(t.one.x, t.two.x) : n(t.one.y, t.two.y);
+}, li = (r) => r.one.x === r.two.x && r.one.y === r.two.y, H = (r) => Xt(r, "x"), G = (r) => Xt(r, "y"), nt = (r) => {
+  const e = S(r);
+  return e.two.x - e.one.x;
+}, st = (r) => {
+  const e = S(r);
+  return e.two.y - e.one.y;
+}, Zr = (r) => F(r, Ce), hi = (r) => F(r, Yt), ci = (r) => F(r, qt), fi = (r) => F(r, rt), di = (r) => F(r, Zt), gi = (r) => F(r, Wt), pi = (r) => F(r, Gt), yi = (r) => F(r, Ht), ee = (r) => ne(r, "right"), te = (r) => ne(r, "bottom"), V = (r) => ne(r, "left"), Y = (r) => ne(r, "top"), $t = (r) => Be(Zr(r), {
+  x: nt(r) / 2,
+  y: st(r) / 2
+}), Qt = (r) => {
+  const e = S(r);
+  return e.root.x === "left" ? V(e) : ee(e);
+}, er = (r) => {
+  const e = S(r);
+  return e.root.y === "top" ? Y(e) : te(e);
+}, mi = (r) => ({ x: Qt(r), y: er(r) }), qe = (r) => {
+  const e = S(r);
+  return { lower: e.one.x, upper: e.two.x };
+}, We = (r) => {
+  const e = S(r);
+  return { lower: e.one.y, upper: e.two.y };
+}, wi = (r, e) => Vr(r, e), bi = (r, e) => {
+  const t = S(r), n = Qe.includes(e) ? "x" : et.includes(e) ? "y" : null;
+  if (n === null) throw new Error(`Invalid location: ${e}`);
+  const s = e === "top" || e === "left" ? Math.min : Math.max, i = { ...t.one }, o = { ...t.two };
+  return i[n] = s(t.one[n], t.two[n]), o[n] = s(t.one[n], t.two[n]), [i, o];
+}, vi = (r, e) => {
+  const t = S(r), n = S(e), s = Qt(n) + (H(n) - H(t)) / 2, i = er(n) + (G(n) - G(t)) / 2;
+  return S({ x: s, y: i }, Yr(t));
+}, Hr = (r) => typeof r != "object" || r == null ? !1 : "one" in r && "two" in r && "root" in r, $i = (r) => H(r) / G(r), xi = (r, e, t) => {
+  if (typeof e == "string") {
+    if (t == null) throw new Error("Undefined amount passed into box.translate");
+    const s = J(e);
+    e = T(s, t);
+  }
+  const n = S(r);
+  return S(
+    Be(n.one, e),
+    Be(n.two, e),
+    void 0,
+    void 0,
+    n.root
+  );
+}, Oi = (r, e) => {
+  const t = Math.max(V(r), V(e)), n = Math.max(Y(r), Y(e)), s = Math.min(ee(r), ee(e)), i = Math.min(te(r), te(e));
+  return t > s || n > i ? Wr : S({ x: t, y: n }, { x: s, y: i }, void 0, void 0, r.root);
+}, Ti = (r) => H(r) * G(r), Si = (r, e) => {
+  const t = S(r);
+  return S(
+    vt(t.one, e),
+    vt(t.two, e),
+    void 0,
+    void 0,
+    t.root
+  );
+}, Ii = (r, e, t, n, s, i) => {
+  const o = { x: r, y: e }, u = { x: r + t, y: e + n };
+  return s.x !== i.x && (s.x === "center" ? (o.x -= t / 2, u.x -= t / 2) : (o.x -= t, u.x -= t)), s.y !== i.y && (s.y === "center" ? (o.y -= n / 2, u.y -= n / 2) : (o.y -= n, u.y -= n)), S(o, u, void 0, void 0, i);
+}, qu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DECIMAL: ni,
+  ZERO: Wr,
+  area: Ti,
+  areaIsZero: li,
+  aspect: $i,
+  bottom: te,
+  bottomCenter: di,
+  bottomLeft: fi,
+  bottomRight: gi,
+  box: ri,
+  center: $t,
+  centerLeft: pi,
+  centerRight: yi,
+  construct: S,
+  constructWithAlternateRoot: Ii,
+  contains: ii,
+  copy: Vr,
+  css: ui,
+  cssBox: ei,
+  dim: Xt,
+  dims: Yr,
+  domRect: ti,
+  edgePoints: bi,
+  equals: oi,
+  height: G,
+  intersection: Oi,
+  isBox: Hr,
+  left: V,
+  loc: ne,
+  positionInCenter: vi,
+  reRoot: wi,
+  resize: si,
+  right: ee,
+  root: mi,
+  signedDims: ai,
+  signedHeight: st,
+  signedWidth: nt,
+  top: Y,
+  topCenter: hi,
+  topLeft: Zr,
+  topRight: ci,
+  translate: xi,
+  truncate: Si,
+  width: H,
+  x: Qt,
+  xBounds: qe,
+  xyLoc: F,
+  y: er,
+  yBounds: We
+}, Symbol.toStringTag, { value: "Module" })), Gr = a.object({ signedWidth: a.number(), signedHeight: a.number() }), Ni = a.union([Lt, Gr, Ne, Xe]), Ui = { width: 0, height: 0 }, Bi = { width: 1, height: 1 }, L = (r, e) => typeof r == "number" ? { width: r, height: e ?? r } : Array.isArray(r) ? { width: r[0], height: r[1] } : "x" in r ? { width: r.x, height: r.y } : "signedWidth" in r ? { width: r.signedWidth, height: r.signedHeight } : { ...r }, Ei = (r, e) => {
+  if (e == null) return !1;
+  const t = L(r), n = L(e);
+  return t.width === n.width && t.height === n.height;
+}, Ai = (r) => {
+  const e = L(r);
+  return { width: e.height, height: e.width };
+}, Mi = (r) => {
+  const e = L(r);
+  return `0 0 ${e.width} ${e.height}`;
+}, Ci = (r) => {
+  const e = L(r);
+  return [e.width, e.height];
+}, Li = (r) => ({
+  width: Math.max(...r.map((e) => L(e).width)),
+  height: Math.max(...r.map((e) => L(e).height))
+}), Ri = (r) => ({
+  width: Math.min(...r.map((e) => L(e).width)),
+  height: Math.min(...r.map((e) => L(e).height))
+}), ji = (r, e) => {
+  const t = L(r);
+  return { width: t.width * e, height: t.height * e };
+}, Wu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DECIMAL: Bi,
+  ZERO: Ui,
+  construct: L,
+  couple: Ci,
+  crude: Ni,
+  dimensions: Lt,
+  equals: Ei,
+  max: Li,
+  min: Ri,
+  scale: ji,
+  signed: Gr,
+  svgViewBox: Mi,
+  swap: Ai
+}, Symbol.toStringTag, { value: "Module" }));
+var ki = Object.defineProperty, Di = (r, e, t) => e in r ? ki(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, z = (r, e, t) => Di(r, typeof e != "symbol" ? e + "" : e, t);
+const Pi = (r, e, t) => e !== void 0 && r < e ? e : t !== void 0 && r > t ? t : r, zi = a.object({ offset: bt, scale: bt }), Fi = a.object({ offset: a.number(), scale: a.number() }), _i = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
+  e,
+  s ? n - r : n + r
+], qi = (r) => (e, t, n, s) => [
+  e,
+  s ? n / r : n * r
+], Wi = (r) => (e, t, n) => {
+  if (e === null) return [r, n];
+  const { lower: s, upper: i } = e, { lower: o, upper: u } = r, h = i - s, f = u - o;
+  if (t === "dimension") return [r, n * (f / h)];
+  const g = (n - s) * (f / h) + o;
+  return [r, g];
+}, Vi = (r) => (e, t, n) => [r, n], Yi = () => (r, e, t) => {
+  if (r === null) throw new Error("cannot invert without bounds");
+  if (e === "dimension") return [r, t];
+  const { lower: n, upper: s } = r;
+  return [r, s - (t - n)];
+}, Zi = (r) => (e, t, n) => {
+  const { lower: s, upper: i } = r;
+  return n = Pi(n, s, i), [e, n];
+}, xt = class ge {
+  constructor() {
+    z(this, "ops", []), z(this, "currBounds", null), z(this, "currType", null), z(this, "reversed", !1), this.ops = [];
+  }
+  /**
+   * @returns a new scale with a translation as its first operation. Any number provided
+   * to the {@link pos} operation on the scale will be translated by the specified value.
+   * @param value - The amount to translate by.
+   */
+  static translate(e) {
+    return new ge().translate(e);
+  }
+  /**
+   * @returns a new scale with a magnification as its first operation. Any number provided
+   * to the {@link pos} or {@link dim} operation will be multiplied by the specified value.
+   * @param value - The amount to translate by.
+   */
+  static magnify(e) {
+    return new ge().magnify(e);
+  }
+  static scale(e, t) {
+    return new ge().scale(e, t);
+  }
+  /**
+   * @returns a copy of the scale with a translation as its next operation. Any
+   * number provided to the {@link pos} method on the scale will be translated by the
+   * specified value.
+   * @param value - The amount to translate by.
+   */
+  translate(e) {
+    const t = this.new(), n = _i(e);
+    return n.type = "translate", t.ops.push(n), t;
+  }
+  /**
+   * @returns a copy of the scale with a translation as its next operation. Any number
+   * provided to the {@link pos} or {@link dim} method on the scale will be multiplied
+   * by the specified value.
+   * @param value - The amount to magnify by.
+   */
+  magnify(e) {
+    const t = this.new(), n = qi(e);
+    return n.type = "magnify", t.ops.push(n), t;
+  }
+  scale(e, t) {
+    const n = m(e, t), s = this.new(), i = Wi(n);
+    return i.type = "scale", s.ops.push(i), s;
+  }
+  clamp(e, t) {
+    const n = m(e, t), s = this.new(), i = Zi(n);
+    return i.type = "clamp", s.ops.push(i), s;
+  }
+  reBound(e, t) {
+    const n = m(e, t), s = this.new(), i = Vi(n);
+    return i.type = "re-bound", s.ops.push(i), s;
+  }
+  invert() {
+    const e = Yi();
+    e.type = "invert";
+    const t = this.new();
+    return t.ops.push(e), t;
+  }
+  pos(e) {
+    return this.exec("position", e);
+  }
+  dim(e) {
+    return this.exec("dimension", e);
+  }
+  new() {
+    const e = new ge();
+    return e.ops = this.ops.slice(), e.reversed = this.reversed, e;
+  }
+  exec(e, t) {
+    return this.currBounds = null, this.ops.reduce(
+      ([n, s], i) => i(n, e, s, this.reversed),
+      [null, t]
+    )[1];
+  }
+  reverse() {
+    const e = this.new();
+    e.ops.reverse();
+    const t = [];
+    return e.ops.forEach((n, s) => {
+      if (n.type === "scale" || t.some(([o, u]) => s >= o && s <= u))
+        return;
+      const i = e.ops.findIndex((o, u) => o.type === "scale" && u > s);
+      i !== -1 && t.push([s, i]);
+    }), t.forEach(([n, s]) => {
+      const i = e.ops.slice(n, s);
+      i.unshift(e.ops[s]), e.ops.splice(n, s - n + 1, ...i);
+    }), e.reversed = !e.reversed, e;
+  }
+  get transform() {
+    return { scale: this.dim(1), offset: this.pos(0) };
+  }
+};
+z(xt, "IDENTITY", new xt());
+let Ot = xt;
+const Tt = class P {
+  constructor(e = new Ot(), t = new Ot(), n = null) {
+    z(this, "x"), z(this, "y"), z(this, "currRoot"), this.x = e, this.y = t, this.currRoot = n;
+  }
+  static translate(e, t) {
+    return new P().translate(e, t);
+  }
+  static translateX(e) {
+    return new P().translateX(e);
+  }
+  static translateY(e) {
+    return new P().translateY(e);
+  }
+  static clamp(e) {
+    return new P().clamp(e);
+  }
+  static magnify(e) {
+    return new P().magnify(e);
+  }
+  static scale(e) {
+    return new P().scale(e);
+  }
+  static reBound(e) {
+    return new P().reBound(e);
+  }
+  translate(e, t) {
+    const n = T(e, t), s = this.copy();
+    return s.x = this.x.translate(n.x), s.y = this.y.translate(n.y), s;
+  }
+  translateX(e) {
+    const t = this.copy();
+    return t.x = this.x.translate(e), t;
+  }
+  translateY(e) {
+    const t = this.copy();
+    return t.y = this.y.translate(e), t;
+  }
+  magnify(e) {
+    const t = this.copy();
+    return t.x = this.x.magnify(e.x), t.y = this.y.magnify(e.y), t;
+  }
+  scale(e) {
+    const t = this.copy();
+    if (Hr(e)) {
+      const n = this.currRoot;
+      return t.currRoot = e.root, n != null && !Kt(n, e.root) && (n.x !== e.root.x && (t.x = t.x.invert()), n.y !== e.root.y && (t.y = t.y.invert())), t.x = t.x.scale(qe(e)), t.y = t.y.scale(We(e)), t;
+    }
+    return t.x = t.x.scale(e.width), t.y = t.y.scale(e.height), t;
+  }
+  reBound(e) {
+    const t = this.copy();
+    return t.x = this.x.reBound(qe(e)), t.y = this.y.reBound(We(e)), t;
+  }
+  clamp(e) {
+    const t = this.copy();
+    return t.x = this.x.clamp(qe(e)), t.y = this.y.clamp(We(e)), t;
+  }
+  copy() {
+    const e = new P();
+    return e.currRoot = this.currRoot, e.x = this.x, e.y = this.y, e;
+  }
+  reverse() {
+    const e = this.copy();
+    return e.x = this.x.reverse(), e.y = this.y.reverse(), e;
+  }
+  pos(e) {
+    return { x: this.x.pos(e.x), y: this.y.pos(e.y) };
+  }
+  dim(e) {
+    return { x: this.x.dim(e.x), y: this.y.dim(e.y) };
+  }
+  box(e) {
+    return S(
+      this.pos(e.one),
+      this.pos(e.two),
+      0,
+      0,
+      this.currRoot ?? e.root
+    );
+  }
+  get transform() {
+    return {
+      scale: this.dim({ x: 1, y: 1 }),
+      offset: this.pos({ x: 0, y: 0 })
+    };
+  }
+};
+z(Tt, "IDENTITY", new Tt());
+let Hi = Tt;
+const Vu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Scale: Ot,
+  XY: Hi,
+  crudeXYTransform: zi,
+  transform: Fi
+}, Symbol.toStringTag, { value: "Module" }));
+function Kr(r) {
+  var e, t, n = "";
+  if (typeof r == "string" || typeof r == "number") n += r;
+  else if (typeof r == "object") if (Array.isArray(r)) {
+    var s = r.length;
+    for (e = 0; e < s; e++) r[e] && (t = Kr(r[e])) && (n && (n += " "), n += t);
+  } else for (t in r) r[t] && (n && (n += " "), n += t);
+  return n;
+}
+function Gi() {
+  for (var r, e, t = 0, n = "", s = arguments.length; t < s; t++) (r = arguments[t]) && (e = Kr(r)) && (n && (n += " "), n += e);
+  return n;
+}
+const Ki = Gi, hr = "-", cr = "__", De = "--", Jr = (r) => {
+  const e = (...t) => Ki(...t);
+  return e.B = (t) => r + hr + t, e.E = (t) => r + cr + t, e.M = (t) => r + De + t, e.BM = (t, n) => e.B(t) + De + n, e.BE = (t, n) => e.B(t) + cr + n, e.BEM = (t, n, s) => e.BE(t, n) + De + s, e.extend = (t) => Jr(e.B(t)), e.var = (t) => De + r + hr + t, e;
+}, tr = (r) => r != null && typeof r == "object" && !Array.isArray(r);
+var Ji = Object.defineProperty, Xi = (r, e, t) => e in r ? Ji(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, ie = (r, e, t) => Xi(r, typeof e != "symbol" ? e + "" : e, t);
+function Qi(r) {
+  const e = r.length;
+  let t = 0, n = 0;
+  for (; n < e; ) {
+    let s = r.charCodeAt(n++);
+    if ((s & 4294967168) === 0) {
+      t++;
+      continue;
+    } else if ((s & 4294965248) === 0)
+      t += 2;
+    else {
+      if (s >= 55296 && s <= 56319 && n < e) {
+        const i = r.charCodeAt(n);
+        (i & 64512) === 56320 && (++n, s = ((s & 1023) << 10) + (i & 1023) + 65536);
+      }
+      (s & 4294901760) === 0 ? t += 3 : t += 4;
+    }
+  }
+  return t;
+}
+function eo(r, e, t) {
+  const n = r.length;
+  let s = t, i = 0;
+  for (; i < n; ) {
+    let o = r.charCodeAt(i++);
+    if ((o & 4294967168) === 0) {
+      e[s++] = o;
+      continue;
+    } else if ((o & 4294965248) === 0)
+      e[s++] = o >> 6 & 31 | 192;
+    else {
+      if (o >= 55296 && o <= 56319 && i < n) {
+        const u = r.charCodeAt(i);
+        (u & 64512) === 56320 && (++i, o = ((o & 1023) << 10) + (u & 1023) + 65536);
+      }
+      (o & 4294901760) === 0 ? (e[s++] = o >> 12 & 15 | 224, e[s++] = o >> 6 & 63 | 128) : (e[s++] = o >> 18 & 7 | 240, e[s++] = o >> 12 & 63 | 128, e[s++] = o >> 6 & 63 | 128);
+    }
+    e[s++] = o & 63 | 128;
+  }
+}
+const to = new TextEncoder(), ro = 50;
+function no(r, e, t) {
+  to.encodeInto(r, e.subarray(t));
+}
+function so(r, e, t) {
+  r.length > ro ? no(r, e, t) : eo(r, e, t);
+}
+const io = 4096;
+function Xr(r, e, t) {
+  let n = e;
+  const s = n + t, i = [];
+  let o = "";
+  for (; n < s; ) {
+    const u = r[n++];
+    if ((u & 128) === 0)
+      i.push(u);
+    else if ((u & 224) === 192) {
+      const h = r[n++] & 63;
+      i.push((u & 31) << 6 | h);
+    } else if ((u & 240) === 224) {
+      const h = r[n++] & 63, f = r[n++] & 63;
+      i.push((u & 31) << 12 | h << 6 | f);
+    } else if ((u & 248) === 240) {
+      const h = r[n++] & 63, f = r[n++] & 63, g = r[n++] & 63;
+      let d = (u & 7) << 18 | h << 12 | f << 6 | g;
+      d > 65535 && (d -= 65536, i.push(d >>> 10 & 1023 | 55296), d = 56320 | d & 1023), i.push(d);
+    } else
+      i.push(u);
+    i.length >= io && (o += String.fromCharCode(...i), i.length = 0);
+  }
+  return i.length > 0 && (o += String.fromCharCode(...i)), o;
+}
+const oo = new TextDecoder(), ao = 200;
+function uo(r, e, t) {
+  const n = r.subarray(e, e + t);
+  return oo.decode(n);
+}
+function lo(r, e, t) {
+  return t > ao ? uo(r, e, t) : Xr(r, e, t);
+}
+let Pe = class {
+  constructor(e, t) {
+    this.type = e, this.data = t;
+  }
+}, k = class St extends Error {
+  constructor(e) {
+    super(e);
+    const t = Object.create(St.prototype);
+    Object.setPrototypeOf(this, t), Object.defineProperty(this, "name", {
+      configurable: !0,
+      enumerable: !1,
+      value: St.name
+    });
+  }
+};
+const le = 4294967295;
+function ho(r, e, t) {
+  const n = t / 4294967296, s = t;
+  r.setUint32(e, n), r.setUint32(e + 4, s);
+}
+function Qr(r, e, t) {
+  const n = Math.floor(t / 4294967296), s = t;
+  r.setUint32(e, n), r.setUint32(e + 4, s);
+}
+function en(r, e) {
+  const t = r.getInt32(e), n = r.getUint32(e + 4);
+  return t * 4294967296 + n;
+}
+function co(r, e) {
+  const t = r.getUint32(e), n = r.getUint32(e + 4);
+  return t * 4294967296 + n;
+}
+const fo = -1, go = 4294967296 - 1, po = 17179869184 - 1;
+function yo({ sec: r, nsec: e }) {
+  if (r >= 0 && e >= 0 && r <= po)
+    if (e === 0 && r <= go) {
+      const t = new Uint8Array(4);
+      return new DataView(t.buffer).setUint32(0, r), t;
+    } else {
+      const t = r / 4294967296, n = r & 4294967295, s = new Uint8Array(8), i = new DataView(s.buffer);
+      return i.setUint32(0, e << 2 | t & 3), i.setUint32(4, n), s;
+    }
+  else {
+    const t = new Uint8Array(12), n = new DataView(t.buffer);
+    return n.setUint32(0, e), Qr(n, 4, r), t;
+  }
+}
+function mo(r) {
+  const e = r.getTime(), t = Math.floor(e / 1e3), n = (e - t * 1e3) * 1e6, s = Math.floor(n / 1e9);
+  return {
+    sec: t + s,
+    nsec: n - s * 1e9
+  };
+}
+function wo(r) {
+  if (r instanceof Date) {
+    const e = mo(r);
+    return yo(e);
+  } else
+    return null;
+}
+function bo(r) {
+  const e = new DataView(r.buffer, r.byteOffset, r.byteLength);
+  switch (r.byteLength) {
+    case 4:
+      return { sec: e.getUint32(0), nsec: 0 };
+    case 8: {
+      const t = e.getUint32(0), n = e.getUint32(4), s = (t & 3) * 4294967296 + n, i = t >>> 2;
+      return { sec: s, nsec: i };
+    }
+    case 12: {
+      const t = en(e, 4), n = e.getUint32(0);
+      return { sec: t, nsec: n };
+    }
+    default:
+      throw new k(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${r.length}`);
+  }
+}
+function vo(r) {
+  const e = bo(r);
+  return new Date(e.sec * 1e3 + e.nsec / 1e6);
+}
+const $o = {
+  type: fo,
+  encode: wo,
+  decode: vo
+};
+let Ee = class {
+  constructor() {
+    this.builtInEncoders = [], this.builtInDecoders = [], this.encoders = [], this.decoders = [], this.register($o);
+  }
+  register({ type: e, encode: t, decode: n }) {
+    if (e >= 0)
+      this.encoders[e] = t, this.decoders[e] = n;
+    else {
+      const s = -1 - e;
+      this.builtInEncoders[s] = t, this.builtInDecoders[s] = n;
+    }
+  }
+  tryToEncode(e, t) {
+    for (let n = 0; n < this.builtInEncoders.length; n++) {
+      const s = this.builtInEncoders[n];
+      if (s != null) {
+        const i = s(e, t);
+        if (i != null) {
+          const o = -1 - n;
+          return new Pe(o, i);
+        }
+      }
+    }
+    for (let n = 0; n < this.encoders.length; n++) {
+      const s = this.encoders[n];
+      if (s != null) {
+        const i = s(e, t);
+        if (i != null) {
+          const o = n;
+          return new Pe(o, i);
+        }
+      }
+    }
+    return e instanceof Pe ? e : null;
+  }
+  decode(e, t, n) {
+    const s = t < 0 ? this.builtInDecoders[-1 - t] : this.decoders[t];
+    return s ? s(e, t, n) : new Pe(t, e);
+  }
+};
+Ee.defaultCodec = new Ee();
+function xo(r) {
+  return r instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && r instanceof SharedArrayBuffer;
+}
+function It(r) {
+  return r instanceof Uint8Array ? r : ArrayBuffer.isView(r) ? new Uint8Array(r.buffer, r.byteOffset, r.byteLength) : xo(r) ? new Uint8Array(r) : Uint8Array.from(r);
+}
+const Oo = 100, To = 2048;
+let So = class tn {
+  constructor(e) {
+    this.entered = !1, this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? Ee.defaultCodec, this.context = e == null ? void 0 : e.context, this.useBigInt64 = (e == null ? void 0 : e.useBigInt64) ?? !1, this.maxDepth = (e == null ? void 0 : e.maxDepth) ?? Oo, this.initialBufferSize = (e == null ? void 0 : e.initialBufferSize) ?? To, this.sortKeys = (e == null ? void 0 : e.sortKeys) ?? !1, this.forceFloat32 = (e == null ? void 0 : e.forceFloat32) ?? !1, this.ignoreUndefined = (e == null ? void 0 : e.ignoreUndefined) ?? !1, this.forceIntegerToFloat = (e == null ? void 0 : e.forceIntegerToFloat) ?? !1, this.pos = 0, this.view = new DataView(new ArrayBuffer(this.initialBufferSize)), this.bytes = new Uint8Array(this.view.buffer);
+  }
+  clone() {
+    return new tn({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      maxDepth: this.maxDepth,
+      initialBufferSize: this.initialBufferSize,
+      sortKeys: this.sortKeys,
+      forceFloat32: this.forceFloat32,
+      ignoreUndefined: this.ignoreUndefined,
+      forceIntegerToFloat: this.forceIntegerToFloat
+    });
+  }
+  reinitializeState() {
+    this.pos = 0;
+  }
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  encodeSharedRef(e) {
+    if (this.entered)
+      return this.clone().encodeSharedRef(e);
+    try {
+      return this.entered = !0, this.reinitializeState(), this.doEncode(e, 1), this.bytes.subarray(0, this.pos);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
+  encode(e) {
+    if (this.entered)
+      return this.clone().encode(e);
+    try {
+      return this.entered = !0, this.reinitializeState(), this.doEncode(e, 1), this.bytes.slice(0, this.pos);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  doEncode(e, t) {
+    if (t > this.maxDepth)
+      throw new Error(`Too deep objects in depth ${t}`);
+    e == null ? this.encodeNil() : typeof e == "boolean" ? this.encodeBoolean(e) : typeof e == "number" ? this.forceIntegerToFloat ? this.encodeNumberAsFloat(e) : this.encodeNumber(e) : typeof e == "string" ? this.encodeString(e) : this.useBigInt64 && typeof e == "bigint" ? this.encodeBigInt64(e) : this.encodeObject(e, t);
+  }
+  ensureBufferSizeToWrite(e) {
+    const t = this.pos + e;
+    this.view.byteLength < t && this.resizeBuffer(t * 2);
+  }
+  resizeBuffer(e) {
+    const t = new ArrayBuffer(e), n = new Uint8Array(t), s = new DataView(t);
+    n.set(this.bytes), this.view = s, this.bytes = n;
+  }
+  encodeNil() {
+    this.writeU8(192);
+  }
+  encodeBoolean(e) {
+    e === !1 ? this.writeU8(194) : this.writeU8(195);
+  }
+  encodeNumber(e) {
+    !this.forceIntegerToFloat && Number.isSafeInteger(e) ? e >= 0 ? e < 128 ? this.writeU8(e) : e < 256 ? (this.writeU8(204), this.writeU8(e)) : e < 65536 ? (this.writeU8(205), this.writeU16(e)) : e < 4294967296 ? (this.writeU8(206), this.writeU32(e)) : this.useBigInt64 ? this.encodeNumberAsFloat(e) : (this.writeU8(207), this.writeU64(e)) : e >= -32 ? this.writeU8(224 | e + 32) : e >= -128 ? (this.writeU8(208), this.writeI8(e)) : e >= -32768 ? (this.writeU8(209), this.writeI16(e)) : e >= -2147483648 ? (this.writeU8(210), this.writeI32(e)) : this.useBigInt64 ? this.encodeNumberAsFloat(e) : (this.writeU8(211), this.writeI64(e)) : this.encodeNumberAsFloat(e);
+  }
+  encodeNumberAsFloat(e) {
+    this.forceFloat32 ? (this.writeU8(202), this.writeF32(e)) : (this.writeU8(203), this.writeF64(e));
+  }
+  encodeBigInt64(e) {
+    e >= BigInt(0) ? (this.writeU8(207), this.writeBigUint64(e)) : (this.writeU8(211), this.writeBigInt64(e));
+  }
+  writeStringHeader(e) {
+    if (e < 32)
+      this.writeU8(160 + e);
+    else if (e < 256)
+      this.writeU8(217), this.writeU8(e);
+    else if (e < 65536)
+      this.writeU8(218), this.writeU16(e);
+    else if (e < 4294967296)
+      this.writeU8(219), this.writeU32(e);
+    else
+      throw new Error(`Too long string: ${e} bytes in UTF-8`);
+  }
+  encodeString(e) {
+    const t = Qi(e);
+    this.ensureBufferSizeToWrite(5 + t), this.writeStringHeader(t), so(e, this.bytes, this.pos), this.pos += t;
+  }
+  encodeObject(e, t) {
+    const n = this.extensionCodec.tryToEncode(e, this.context);
+    if (n != null)
+      this.encodeExtension(n);
+    else if (Array.isArray(e))
+      this.encodeArray(e, t);
+    else if (ArrayBuffer.isView(e))
+      this.encodeBinary(e);
+    else if (typeof e == "object")
+      this.encodeMap(e, t);
+    else
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(e)}`);
+  }
+  encodeBinary(e) {
+    const t = e.byteLength;
+    if (t < 256)
+      this.writeU8(196), this.writeU8(t);
+    else if (t < 65536)
+      this.writeU8(197), this.writeU16(t);
+    else if (t < 4294967296)
+      this.writeU8(198), this.writeU32(t);
+    else
+      throw new Error(`Too large binary: ${t}`);
+    const n = It(e);
+    this.writeU8a(n);
+  }
+  encodeArray(e, t) {
+    const n = e.length;
+    if (n < 16)
+      this.writeU8(144 + n);
+    else if (n < 65536)
+      this.writeU8(220), this.writeU16(n);
+    else if (n < 4294967296)
+      this.writeU8(221), this.writeU32(n);
+    else
+      throw new Error(`Too large array: ${n}`);
+    for (const s of e)
+      this.doEncode(s, t + 1);
+  }
+  countWithoutUndefined(e, t) {
+    let n = 0;
+    for (const s of t)
+      e[s] !== void 0 && n++;
+    return n;
+  }
+  encodeMap(e, t) {
+    const n = Object.keys(e);
+    this.sortKeys && n.sort();
+    const s = this.ignoreUndefined ? this.countWithoutUndefined(e, n) : n.length;
+    if (s < 16)
+      this.writeU8(128 + s);
+    else if (s < 65536)
+      this.writeU8(222), this.writeU16(s);
+    else if (s < 4294967296)
+      this.writeU8(223), this.writeU32(s);
+    else
+      throw new Error(`Too large map object: ${s}`);
+    for (const i of n) {
+      const o = e[i];
+      this.ignoreUndefined && o === void 0 || (this.encodeString(i), this.doEncode(o, t + 1));
+    }
+  }
+  encodeExtension(e) {
+    if (typeof e.data == "function") {
+      const n = e.data(this.pos + 6), s = n.length;
+      if (s >= 4294967296)
+        throw new Error(`Too large extension object: ${s}`);
+      this.writeU8(201), this.writeU32(s), this.writeI8(e.type), this.writeU8a(n);
+      return;
+    }
+    const t = e.data.length;
+    if (t === 1)
+      this.writeU8(212);
+    else if (t === 2)
+      this.writeU8(213);
+    else if (t === 4)
+      this.writeU8(214);
+    else if (t === 8)
+      this.writeU8(215);
+    else if (t === 16)
+      this.writeU8(216);
+    else if (t < 256)
+      this.writeU8(199), this.writeU8(t);
+    else if (t < 65536)
+      this.writeU8(200), this.writeU16(t);
+    else if (t < 4294967296)
+      this.writeU8(201), this.writeU32(t);
+    else
+      throw new Error(`Too large extension object: ${t}`);
+    this.writeI8(e.type), this.writeU8a(e.data);
+  }
+  writeU8(e) {
+    this.ensureBufferSizeToWrite(1), this.view.setUint8(this.pos, e), this.pos++;
+  }
+  writeU8a(e) {
+    const t = e.length;
+    this.ensureBufferSizeToWrite(t), this.bytes.set(e, this.pos), this.pos += t;
+  }
+  writeI8(e) {
+    this.ensureBufferSizeToWrite(1), this.view.setInt8(this.pos, e), this.pos++;
+  }
+  writeU16(e) {
+    this.ensureBufferSizeToWrite(2), this.view.setUint16(this.pos, e), this.pos += 2;
+  }
+  writeI16(e) {
+    this.ensureBufferSizeToWrite(2), this.view.setInt16(this.pos, e), this.pos += 2;
+  }
+  writeU32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setUint32(this.pos, e), this.pos += 4;
+  }
+  writeI32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setInt32(this.pos, e), this.pos += 4;
+  }
+  writeF32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setFloat32(this.pos, e), this.pos += 4;
+  }
+  writeF64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setFloat64(this.pos, e), this.pos += 8;
+  }
+  writeU64(e) {
+    this.ensureBufferSizeToWrite(8), ho(this.view, this.pos, e), this.pos += 8;
+  }
+  writeI64(e) {
+    this.ensureBufferSizeToWrite(8), Qr(this.view, this.pos, e), this.pos += 8;
+  }
+  writeBigUint64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setBigUint64(this.pos, e), this.pos += 8;
+  }
+  writeBigInt64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setBigInt64(this.pos, e), this.pos += 8;
+  }
+};
+function pe(r, e) {
+  return new So(e).encodeSharedRef(r);
+}
+function lt(r) {
+  return `${r < 0 ? "-" : ""}0x${Math.abs(r).toString(16).padStart(2, "0")}`;
+}
+const Io = 16, No = 16;
+class Uo {
+  constructor(e = Io, t = No) {
+    this.hit = 0, this.miss = 0, this.maxKeyLength = e, this.maxLengthPerKey = t, this.caches = [];
+    for (let n = 0; n < this.maxKeyLength; n++)
+      this.caches.push([]);
+  }
+  canBeCached(e) {
+    return e > 0 && e <= this.maxKeyLength;
+  }
+  find(e, t, n) {
+    const s = this.caches[n - 1];
+    e: for (const i of s) {
+      const o = i.bytes;
+      for (let u = 0; u < n; u++)
+        if (o[u] !== e[t + u])
+          continue e;
+      return i.str;
+    }
+    return null;
+  }
+  store(e, t) {
+    const n = this.caches[e.length - 1], s = { bytes: e, str: t };
+    n.length >= this.maxLengthPerKey ? n[Math.random() * n.length | 0] = s : n.push(s);
+  }
+  decode(e, t, n) {
+    const s = this.find(e, t, n);
+    if (s != null)
+      return this.hit++, s;
+    this.miss++;
+    const i = Xr(e, t, n), o = Uint8Array.prototype.slice.call(e, t, t + n);
+    return this.store(o, i), i;
+  }
+}
+const Nt = "array", xe = "map_key", rn = "map_value", Bo = (r) => {
+  if (typeof r == "string" || typeof r == "number")
+    return r;
+  throw new k("The type of key must be string or number but " + typeof r);
+};
+class Eo {
+  constructor() {
+    this.stack = [], this.stackHeadPosition = -1;
+  }
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = Nt, t.position = 0, t.size = e, t.array = new Array(e);
+  }
+  pushMapState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = xe, t.readCount = 0, t.size = e, t.map = {};
+  }
+  getUninitializedStateFromPool() {
+    if (this.stackHeadPosition++, this.stackHeadPosition === this.stack.length) {
+      const e = {
+        type: void 0,
+        size: 0,
+        array: void 0,
+        position: 0,
+        readCount: 0,
+        map: void 0,
+        key: null
+      };
+      this.stack.push(e);
+    }
+    return this.stack[this.stackHeadPosition];
+  }
+  release(e) {
+    if (this.stack[this.stackHeadPosition] !== e)
+      throw new Error("Invalid stack state. Released state is not on top of the stack.");
+    if (e.type === Nt) {
+      const t = e;
+      t.size = 0, t.array = void 0, t.position = 0, t.type = void 0;
+    }
+    if (e.type === xe || e.type === rn) {
+      const t = e;
+      t.size = 0, t.map = void 0, t.readCount = 0, t.type = void 0;
+    }
+    this.stackHeadPosition--;
+  }
+  reset() {
+    this.stack.length = 0, this.stackHeadPosition = -1;
+  }
+}
+const he = -1, rr = new DataView(new ArrayBuffer(0)), Ao = new Uint8Array(rr.buffer);
+try {
+  rr.getInt8(0);
+} catch (r) {
+  if (!(r instanceof RangeError))
+    throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+}
+const fr = new RangeError("Insufficient data"), Mo = new Uo();
+let Co = class nn {
+  constructor(e) {
+    this.totalPos = 0, this.pos = 0, this.view = rr, this.bytes = Ao, this.headByte = he, this.stack = new Eo(), this.entered = !1, this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? Ee.defaultCodec, this.context = e == null ? void 0 : e.context, this.useBigInt64 = (e == null ? void 0 : e.useBigInt64) ?? !1, this.rawStrings = (e == null ? void 0 : e.rawStrings) ?? !1, this.maxStrLength = (e == null ? void 0 : e.maxStrLength) ?? le, this.maxBinLength = (e == null ? void 0 : e.maxBinLength) ?? le, this.maxArrayLength = (e == null ? void 0 : e.maxArrayLength) ?? le, this.maxMapLength = (e == null ? void 0 : e.maxMapLength) ?? le, this.maxExtLength = (e == null ? void 0 : e.maxExtLength) ?? le, this.keyDecoder = (e == null ? void 0 : e.keyDecoder) !== void 0 ? e.keyDecoder : Mo, this.mapKeyConverter = (e == null ? void 0 : e.mapKeyConverter) ?? Bo;
+  }
+  clone() {
+    return new nn({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      rawStrings: this.rawStrings,
+      maxStrLength: this.maxStrLength,
+      maxBinLength: this.maxBinLength,
+      maxArrayLength: this.maxArrayLength,
+      maxMapLength: this.maxMapLength,
+      maxExtLength: this.maxExtLength,
+      keyDecoder: this.keyDecoder
+    });
+  }
+  reinitializeState() {
+    this.totalPos = 0, this.headByte = he, this.stack.reset();
+  }
+  setBuffer(e) {
+    const t = It(e);
+    this.bytes = t, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength), this.pos = 0;
+  }
+  appendBuffer(e) {
+    if (this.headByte === he && !this.hasRemaining(1))
+      this.setBuffer(e);
+    else {
+      const t = this.bytes.subarray(this.pos), n = It(e), s = new Uint8Array(t.length + n.length);
+      s.set(t), s.set(n, t.length), this.setBuffer(s);
+    }
+  }
+  hasRemaining(e) {
+    return this.view.byteLength - this.pos >= e;
+  }
+  createExtraByteError(e) {
+    const { view: t, pos: n } = this;
+    return new RangeError(`Extra ${t.byteLength - n} of ${t.byteLength} byte(s) found at buffer[${e}]`);
+  }
+  /**
+   * @throws {@link DecodeError}
+   * @throws {@link RangeError}
+   */
+  decode(e) {
+    if (this.entered)
+      return this.clone().decode(e);
+    try {
+      this.entered = !0, this.reinitializeState(), this.setBuffer(e);
+      const t = this.doDecodeSync();
+      if (this.hasRemaining(1))
+        throw this.createExtraByteError(this.pos);
+      return t;
+    } finally {
+      this.entered = !1;
+    }
+  }
+  *decodeMulti(e) {
+    if (this.entered) {
+      yield* this.clone().decodeMulti(e);
+      return;
+    }
+    try {
+      for (this.entered = !0, this.reinitializeState(), this.setBuffer(e); this.hasRemaining(1); )
+        yield this.doDecodeSync();
+    } finally {
+      this.entered = !1;
+    }
+  }
+  async decodeAsync(e) {
+    if (this.entered)
+      return this.clone().decodeAsync(e);
+    try {
+      this.entered = !0;
+      let t = !1, n;
+      for await (const u of e) {
+        if (t)
+          throw this.entered = !1, this.createExtraByteError(this.totalPos);
+        this.appendBuffer(u);
+        try {
+          n = this.doDecodeSync(), t = !0;
+        } catch (h) {
+          if (!(h instanceof RangeError))
+            throw h;
+        }
+        this.totalPos += this.pos;
+      }
+      if (t) {
+        if (this.hasRemaining(1))
+          throw this.createExtraByteError(this.totalPos);
+        return n;
+      }
+      const { headByte: s, pos: i, totalPos: o } = this;
+      throw new RangeError(`Insufficient data in parsing ${lt(s)} at ${o} (${i} in the current buffer)`);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  decodeArrayStream(e) {
+    return this.decodeMultiAsync(e, !0);
+  }
+  decodeStream(e) {
+    return this.decodeMultiAsync(e, !1);
+  }
+  async *decodeMultiAsync(e, t) {
+    if (this.entered) {
+      yield* this.clone().decodeMultiAsync(e, t);
+      return;
+    }
+    try {
+      this.entered = !0;
+      let n = t, s = -1;
+      for await (const i of e) {
+        if (t && s === 0)
+          throw this.createExtraByteError(this.totalPos);
+        this.appendBuffer(i), n && (s = this.readArraySize(), n = !1, this.complete());
+        try {
+          for (; yield this.doDecodeSync(), --s !== 0; )
+            ;
+        } catch (o) {
+          if (!(o instanceof RangeError))
+            throw o;
+        }
+        this.totalPos += this.pos;
+      }
+    } finally {
+      this.entered = !1;
+    }
+  }
+  doDecodeSync() {
+    e: for (; ; ) {
+      const e = this.readHeadByte();
+      let t;
+      if (e >= 224)
+        t = e - 256;
+      else if (e < 192)
+        if (e < 128)
+          t = e;
+        else if (e < 144) {
+          const s = e - 128;
+          if (s !== 0) {
+            this.pushMapState(s), this.complete();
+            continue e;
+          } else
+            t = {};
+        } else if (e < 160) {
+          const s = e - 144;
+          if (s !== 0) {
+            this.pushArrayState(s), this.complete();
+            continue e;
+          } else
+            t = [];
+        } else {
+          const s = e - 160;
+          t = this.decodeString(s, 0);
+        }
+      else if (e === 192)
+        t = null;
+      else if (e === 194)
+        t = !1;
+      else if (e === 195)
+        t = !0;
+      else if (e === 202)
+        t = this.readF32();
+      else if (e === 203)
+        t = this.readF64();
+      else if (e === 204)
+        t = this.readU8();
+      else if (e === 205)
+        t = this.readU16();
+      else if (e === 206)
+        t = this.readU32();
+      else if (e === 207)
+        this.useBigInt64 ? t = this.readU64AsBigInt() : t = this.readU64();
+      else if (e === 208)
+        t = this.readI8();
+      else if (e === 209)
+        t = this.readI16();
+      else if (e === 210)
+        t = this.readI32();
+      else if (e === 211)
+        this.useBigInt64 ? t = this.readI64AsBigInt() : t = this.readI64();
+      else if (e === 217) {
+        const s = this.lookU8();
+        t = this.decodeString(s, 1);
+      } else if (e === 218) {
+        const s = this.lookU16();
+        t = this.decodeString(s, 2);
+      } else if (e === 219) {
+        const s = this.lookU32();
+        t = this.decodeString(s, 4);
+      } else if (e === 220) {
+        const s = this.readU16();
+        if (s !== 0) {
+          this.pushArrayState(s), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 221) {
+        const s = this.readU32();
+        if (s !== 0) {
+          this.pushArrayState(s), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 222) {
+        const s = this.readU16();
+        if (s !== 0) {
+          this.pushMapState(s), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 223) {
+        const s = this.readU32();
+        if (s !== 0) {
+          this.pushMapState(s), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 196) {
+        const s = this.lookU8();
+        t = this.decodeBinary(s, 1);
+      } else if (e === 197) {
+        const s = this.lookU16();
+        t = this.decodeBinary(s, 2);
+      } else if (e === 198) {
+        const s = this.lookU32();
+        t = this.decodeBinary(s, 4);
+      } else if (e === 212)
+        t = this.decodeExtension(1, 0);
+      else if (e === 213)
+        t = this.decodeExtension(2, 0);
+      else if (e === 214)
+        t = this.decodeExtension(4, 0);
+      else if (e === 215)
+        t = this.decodeExtension(8, 0);
+      else if (e === 216)
+        t = this.decodeExtension(16, 0);
+      else if (e === 199) {
+        const s = this.lookU8();
+        t = this.decodeExtension(s, 1);
+      } else if (e === 200) {
+        const s = this.lookU16();
+        t = this.decodeExtension(s, 2);
+      } else if (e === 201) {
+        const s = this.lookU32();
+        t = this.decodeExtension(s, 4);
+      } else
+        throw new k(`Unrecognized type byte: ${lt(e)}`);
+      this.complete();
+      const n = this.stack;
+      for (; n.length > 0; ) {
+        const s = n.top();
+        if (s.type === Nt)
+          if (s.array[s.position] = t, s.position++, s.position === s.size)
+            t = s.array, n.release(s);
+          else
+            continue e;
+        else if (s.type === xe) {
+          if (t === "__proto__")
+            throw new k("The key __proto__ is not allowed");
+          s.key = this.mapKeyConverter(t), s.type = rn;
+          continue e;
+        } else if (s.map[s.key] = t, s.readCount++, s.readCount === s.size)
+          t = s.map, n.release(s);
+        else {
+          s.key = null, s.type = xe;
+          continue e;
+        }
+      }
+      return t;
+    }
+  }
+  readHeadByte() {
+    return this.headByte === he && (this.headByte = this.readU8()), this.headByte;
+  }
+  complete() {
+    this.headByte = he;
+  }
+  readArraySize() {
+    const e = this.readHeadByte();
+    switch (e) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (e < 160)
+          return e - 144;
+        throw new k(`Unrecognized array type byte: ${lt(e)}`);
+      }
+    }
+  }
+  pushMapState(e) {
+    if (e > this.maxMapLength)
+      throw new k(`Max length exceeded: map length (${e}) > maxMapLengthLength (${this.maxMapLength})`);
+    this.stack.pushMapState(e);
+  }
+  pushArrayState(e) {
+    if (e > this.maxArrayLength)
+      throw new k(`Max length exceeded: array length (${e}) > maxArrayLength (${this.maxArrayLength})`);
+    this.stack.pushArrayState(e);
+  }
+  decodeString(e, t) {
+    return !this.rawStrings || this.stateIsMapKey() ? this.decodeUtf8String(e, t) : this.decodeBinary(e, t);
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeUtf8String(e, t) {
+    var n;
+    if (e > this.maxStrLength)
+      throw new k(`Max length exceeded: UTF-8 byte length (${e}) > maxStrLength (${this.maxStrLength})`);
+    if (this.bytes.byteLength < this.pos + t + e)
+      throw fr;
+    const s = this.pos + t;
+    let i;
+    return this.stateIsMapKey() && (n = this.keyDecoder) != null && n.canBeCached(e) ? i = this.keyDecoder.decode(this.bytes, s, e) : i = lo(this.bytes, s, e), this.pos += t + e, i;
+  }
+  stateIsMapKey() {
+    return this.stack.length > 0 ? this.stack.top().type === xe : !1;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(e, t) {
+    if (e > this.maxBinLength)
+      throw new k(`Max length exceeded: bin length (${e}) > maxBinLength (${this.maxBinLength})`);
+    if (!this.hasRemaining(e + t))
+      throw fr;
+    const n = this.pos + t, s = this.bytes.subarray(n, n + e);
+    return this.pos += t + e, s;
+  }
+  decodeExtension(e, t) {
+    if (e > this.maxExtLength)
+      throw new k(`Max length exceeded: ext length (${e}) > maxExtLength (${this.maxExtLength})`);
+    const n = this.view.getInt8(this.pos + t), s = this.decodeBinary(
+      e,
+      t + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(s, n, this.context);
+  }
+  lookU8() {
+    return this.view.getUint8(this.pos);
+  }
+  lookU16() {
+    return this.view.getUint16(this.pos);
+  }
+  lookU32() {
+    return this.view.getUint32(this.pos);
+  }
+  readU8() {
+    const e = this.view.getUint8(this.pos);
+    return this.pos++, e;
+  }
+  readI8() {
+    const e = this.view.getInt8(this.pos);
+    return this.pos++, e;
+  }
+  readU16() {
+    const e = this.view.getUint16(this.pos);
+    return this.pos += 2, e;
+  }
+  readI16() {
+    const e = this.view.getInt16(this.pos);
+    return this.pos += 2, e;
+  }
+  readU32() {
+    const e = this.view.getUint32(this.pos);
+    return this.pos += 4, e;
+  }
+  readI32() {
+    const e = this.view.getInt32(this.pos);
+    return this.pos += 4, e;
+  }
+  readU64() {
+    const e = co(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readI64() {
+    const e = en(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readU64AsBigInt() {
+    const e = this.view.getBigUint64(this.pos);
+    return this.pos += 8, e;
+  }
+  readI64AsBigInt() {
+    const e = this.view.getBigInt64(this.pos);
+    return this.pos += 8, e;
+  }
+  readF32() {
+    const e = this.view.getFloat32(this.pos);
+    return this.pos += 4, e;
+  }
+  readF64() {
+    const e = this.view.getFloat64(this.pos);
+    return this.pos += 8, e;
+  }
+};
+function sn(r, e) {
+  return new Co(e).decode(r);
+}
+let Lo = class {
+  constructor() {
+    ie(this, "contentType", "application/json"), ie(this, "decoder"), ie(this, "encoder"), this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
+  }
+  encode(e) {
+    return this.encoder.encode(this.encodeString(e));
+  }
+  decode(e, t) {
+    return this.decodeString(this.decoder.decode(e), t);
+  }
+  decodeString(e, t) {
+    const n = JSON.parse(e), s = tt(n);
+    return t != null ? t.parse(s) : s;
+  }
+  encodeString(e) {
+    const t = _t(e);
+    return JSON.stringify(t, (n, s) => ArrayBuffer.isView(s) ? Array.from(s) : tr(s) && "encode_value" in s ? typeof s.value == "bigint" ? s.value.toString() : s.value : typeof s == "bigint" ? s.toString() : s);
+  }
+  static registerCustomType() {
+  }
+}, Ro = class {
+  constructor() {
+    ie(this, "contentType", "text/csv");
+  }
+  encode(e) {
+    const t = this.encodeString(e);
+    return new TextEncoder().encode(t);
+  }
+  decode(e, t) {
+    const n = new TextDecoder().decode(e);
+    return this.decodeString(n, t);
+  }
+  encodeString(e) {
+    if (!Array.isArray(e) || e.length === 0 || !tr(e[0]))
+      throw new Error("Payload must be an array of objects");
+    const t = Object.keys(e[0]), n = [t.join(",")];
+    return e.forEach((s) => {
+      const i = t.map((o) => JSON.stringify(s[o] ?? ""));
+      n.push(i.join(","));
+    }), n.join(`
+`);
+  }
+  decodeString(e, t) {
+    const [n, ...s] = e.trim().split(`
+`).map((u) => u.trim());
+    if (n.length === 0)
+      return t != null ? t.parse({}) : {};
+    const i = n.split(",").map((u) => u.trim()), o = {};
+    return i.forEach((u) => {
+      o[u] = [];
+    }), s.forEach((u) => {
+      const h = u.split(",").map((f) => f.trim());
+      i.forEach((f, g) => {
+        const d = this.parseValue(h[g]);
+        d != null && o[f].push(d);
+      });
+    }), t != null ? t.parse(o) : o;
+  }
+  parseValue(e) {
+    if (e == null || e.length === 0) return null;
+    const t = Number(e);
+    return isNaN(t) ? e.startsWith('"') && e.endsWith('"') ? e.slice(1, -1) : e : t;
+  }
+  static registerCustomType() {
+  }
+}, jo = class {
+  constructor() {
+    ie(this, "contentType", "text/plain");
+  }
+  encode(e) {
+    return new TextEncoder().encode(e);
+  }
+  decode(e, t) {
+    const n = new TextDecoder().decode(e);
+    return t != null ? t.parse(n) : n;
+  }
+};
+const W = new Ee();
+W.register({
+  type: 0,
+  encode: (r) => {
+    if (ArrayBuffer.isView(r)) {
+      const e = Array.from(r);
+      return pe(e, { extensionCodec: W });
+    }
+    return tr(r) && "encode_value" in r ? typeof r.value == "bigint" ? pe(r.value.toString(), { extensionCodec: W }) : pe(r.value, { extensionCodec: W }) : typeof r == "bigint" ? pe(r.toString(), { extensionCodec: W }) : null;
+  },
+  decode: (r) => sn(r, { extensionCodec: W })
+});
+let ko = class {
+  constructor() {
+    ie(this, "contentType", "application/msgpack");
+  }
+  encode(e) {
+    const t = _t(e);
+    return pe(t, { extensionCodec: W }).slice();
+  }
+  decode(e, t) {
+    const n = sn(e, { extensionCodec: W }), s = tt(n);
+    return t != null ? t.parse(s) : s;
+  }
+  static registerCustomType() {
+  }
+};
+const Ve = new Lo();
+new Ro();
+new jo();
+new ko();
+const Ut = (r) => [...new Set(r)], Do = (r, e, t = !0) => {
+  const n = /* @__PURE__ */ new Map();
+  return r.forEach((s) => {
+    const i = e(s);
+    if (n.has(i)) {
+      if (t) return;
+      n.delete(i);
+    }
+    n.set(i, s);
+  }), Array.from(n.values());
+}, Xu = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  by: Do,
+  unique: Ut
+}, Symbol.toStringTag, { value: "Module" })), on = (r) => r != null && typeof r == "object" && "toString" in r, Qu = (r) => {
+  if (on(r)) return (r == null ? void 0 : r.toString().length) === 0;
+  switch (typeof r) {
+    case "string":
+      return r.length === 0;
+    case "number":
+      return r === 0;
+    case "bigint":
+      return r === 0n;
+    case "boolean":
+      return !r;
+    case "undefined":
+      return !0;
+    case "object":
+      return !0;
+  }
+}, it = (r, e = !1) => {
+  const t = on(r) ? "stringer" : typeof r;
+  let n;
+  switch (t) {
+    case "string":
+      n = (s, i) => s.localeCompare(i);
+      break;
+    case "stringer":
+      n = (s, i) => s.toString().localeCompare(i.toString());
+      break;
+    case "number":
+      n = (s, i) => Number(s) - Number(i);
+      break;
+    case "bigint":
+      n = (s, i) => BigInt(s) - BigInt(i) > 0n ? 1 : -1;
+      break;
+    case "boolean":
+      n = (s, i) => Number(s) - Number(i);
+      break;
+    case "undefined":
+      n = () => 0;
+      break;
+    default:
+      return console.warn(`sortFunc: unknown type ${t}`), () => -1;
+  }
+  return e ? un(n) : n;
+}, Po = (r, e, t) => {
+  const n = it(e[r], t);
+  return (s, i) => n(s[r], i[r]);
+}, zo = (r, e) => r.length !== e.length ? r.length - e.length : r.every((t, n) => t === e[n]) ? 0 : -1, an = (r, e) => {
+  if (r.length !== e.length) return r.length - e.length;
+  if (r.length === 0) return 0;
+  const t = it(r[0]), n = [...r].sort(t), s = [...e].sort(t);
+  return n.every((i, o) => i === s[o]) ? 0 : -1;
+}, Fo = (r, e) => {
+  const t = Ut(r), n = Ut(e);
+  return an(t, n);
+}, _o = (r, e) => r === e ? 0 : r === "first" && e === "last" ? 1 : -1, un = (r) => (e, t) => r(t, e), ae = 0, Ye = -1, Ze = 1, ln = (r) => r < ae, hn = (r) => r > ae, qo = (r) => r >= ae, cn = (r) => r === ae, Wo = (r, e) => {
+  const t = /([a-zA-Z]+)|(\d+)/g, n = r.replace(/[\s_.-]+/g, "").match(t), s = e.replace(/[\s_.-]+/g, "").match(t);
+  if (!n || !s) return 0;
+  for (let i = 0; i < Math.min(n.length, s.length); i++) {
+    const o = n[i], u = s[i];
+    if (isNaN(Number(o)) && isNaN(Number(u))) {
+      const h = o.localeCompare(u);
+      if (h !== 0) return h;
+    } else if (!isNaN(Number(o)) && !isNaN(Number(u))) {
+      const h = Number(o) - Number(u);
+      if (h !== 0) return h;
+    } else return isNaN(Number(o)) ? -1 : 1;
+  }
+  return n.length - s.length;
+}, el = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EQUAL: ae,
+  GREATER_THAN: Ze,
+  LESS_THAN: Ye,
+  isEqualTo: cn,
+  isGreaterThan: hn,
+  isGreaterThanEqual: qo,
+  isLessThan: ln,
+  newF: it,
+  newFieldF: Po,
+  order: _o,
+  primitiveArrays: zo,
+  reverseF: un,
+  stringsWithNumbers: Wo,
+  uniqueUnorderedPrimitiveArrays: Fo,
+  unorderedPrimitiveArrays: an
+}, Symbol.toStringTag, { value: "Module" }));
+var Vo = Object.defineProperty, Yo = (r, e, t) => e in r ? Vo(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, l = (r, e, t) => Yo(r, typeof e != "symbol" ? e + "" : e, t);
+let Zo = (r, e = 21) => (t = e) => {
+  let n = "", s = t | 0;
+  for (; s--; )
+    n += r[Math.random() * r.length | 0];
+  return n;
+};
+const Ho = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Go = Zo(Ho, 11), fn = () => Go(), tl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  create: fn
+}, Symbol.toStringTag, { value: "Module" })), Ko = a.enum(["static", "dynamic"]), dn = (r, e) => {
+  const t = new x(e);
+  if (![
+    O.DAY,
+    O.HOUR,
+    O.MINUTE,
+    O.SECOND,
+    O.MILLISECOND,
+    O.MICROSECOND,
+    O.NANOSECOND
+  ].some((s) => s.equals(t)))
+    throw new Error(
+      "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
+    );
+  const n = r.valueOf() % t.valueOf();
+  return r instanceof x ? new x(n) : new O(n);
+}, b = class p {
+  constructor(e, t = "UTC") {
+    if (l(this, "value"), l(this, "encodeValue", !0), e == null) this.value = p.now().valueOf();
+    else if (e instanceof Date)
+      this.value = BigInt(e.getTime()) * p.MILLISECOND.valueOf();
+    else if (typeof e == "string")
+      this.value = p.parseDateTimeString(e, t).valueOf();
+    else if (Array.isArray(e)) this.value = p.parseDate(e);
+    else {
+      let n = BigInt(0);
+      e instanceof Number && (e = e.valueOf()), t === "local" && (n = p.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = p.MAX : e = p.MIN)), this.value = BigInt(e.valueOf()) + n;
+    }
+  }
+  static parseDate([e = 1970, t = 1, n = 1]) {
+    const s = new Date(e, t - 1, n, 0, 0, 0, 0);
+    return new p(BigInt(s.getTime()) * p.MILLISECOND.valueOf()).truncate(p.DAY).valueOf();
+  }
+  valueOf() {
+    return this.value;
+  }
+  static parseTimeString(e, t = "UTC") {
+    const [n, s, i] = e.split(":");
+    let o = "00", u = "00";
+    i != null && ([o, u] = i.split("."));
+    let h = p.hours(parseInt(n ?? "00")).add(p.minutes(parseInt(s ?? "00"))).add(p.seconds(parseInt(o ?? "00"))).add(p.milliseconds(parseInt(u ?? "00")));
+    return t === "local" && (h = h.add(p.utcOffset)), h.valueOf();
+  }
+  static parseDateTimeString(e, t = "UTC") {
+    if (!e.includes("/") && !e.includes("-"))
+      return p.parseTimeString(e, t);
+    const n = new Date(e);
+    return e.includes(":") || n.setUTCHours(0, 0, 0, 0), new p(
+      BigInt(n.getTime()) * p.MILLISECOND.valueOf(),
+      t
+    ).valueOf();
+  }
+  fString(e = "ISO", t = "UTC") {
+    switch (e) {
+      case "ISODate":
+        return this.toISOString(t).slice(0, 10);
+      case "ISOTime":
+        return this.toISOString(t).slice(11, 23);
+      case "time":
+        return this.timeString(!1, t);
+      case "preciseTime":
+        return this.timeString(!0, t);
+      case "date":
+        return this.dateString();
+      case "preciseDate":
+        return `${this.dateString()} ${this.timeString(!0, t)}`;
+      case "dateTime":
+        return `${this.dateString()} ${this.timeString(!1, t)}`;
+      default:
+        return this.toISOString(t);
+    }
+  }
+  toISOString(e = "UTC") {
+    return e === "UTC" ? this.date().toISOString() : this.sub(p.utcOffset).date().toISOString();
+  }
+  timeString(e = !1, t = "UTC") {
+    const n = this.toISOString(t);
+    return e ? n.slice(11, 23) : n.slice(11, 19);
+  }
+  dateString() {
+    const e = this.date(), t = e.toLocaleString("default", { month: "short" }), n = e.toLocaleString("default", { day: "numeric" });
+    return `${t} ${n}`;
+  }
+  static get utcOffset() {
+    return new O(
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * p.MINUTE.valueOf()
+    );
+  }
+  /**
+   * @returns a TimeSpan representing the amount time elapsed since
+   * the other timestamp.
+   * @param other - The other timestamp.
+   */
+  static since(e) {
+    return new p().span(e);
+  }
+  /** @returns A JavaScript Date object representing the TimeStamp. */
+  date() {
+    return new Date(this.milliseconds);
+  }
+  /**
+   * Checks if the TimeStamp is equal to another TimeStamp.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns True if the TimeStamps are equal, false otherwise.
+   */
+  equals(e) {
+    return this.valueOf() === new p(e).valueOf();
+  }
+  /**
+   * Creates a TimeSpan representing the duration between the two timestamps.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns A TimeSpan representing the duration between the two timestamps.
+   *   The span is guaranteed to be positive.
+   */
+  span(e) {
+    return this.range(e).span;
+  }
+  /**
+   * Creates a TimeRange spanning the given TimeStamp.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns A TimeRange spanning the given TimeStamp that is guaranteed to be
+   *   valid, regardless of the TimeStamp order.
+   */
+  range(e) {
+    return new re(this, e).makeValid();
+  }
+  /**
+   * Creates a TimeRange starting at the TimeStamp and spanning the given
+   * TimeSpan.
+   *
+   * @param other - The TimeSpan to span.
+   * @returns A TimeRange starting at the TimeStamp and spanning the given
+   *   TimeSpan. The TimeRange is guaranteed to be valid.
+   */
+  spanRange(e) {
+    return this.range(this.add(e)).makeValid();
+  }
+  /**
+   * Checks if the TimeStamp represents the unix epoch.
+   *
+   * @returns True if the TimeStamp represents the unix epoch, false otherwise.
+   */
+  get isZero() {
+    return this.valueOf() === BigInt(0);
+  }
+  /**
+   * Checks if the TimeStamp is after the given TimeStamp.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns True if the TimeStamp is after the given TimeStamp, false
+   *   otherwise.
+   */
+  after(e) {
+    return this.valueOf() > new p(e).valueOf();
+  }
+  /**
+   * Checks if the TimeStamp is after or equal to the given TimeStamp.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns True if the TimeStamp is after or equal to the given TimeStamp,
+   *   false otherwise.
+   */
+  afterEq(e) {
+    return this.valueOf() >= new p(e).valueOf();
+  }
+  /**
+   * Checks if the TimeStamp is before the given TimeStamp.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns True if the TimeStamp is before the given TimeStamp, false
+   *   otherwise.
+   */
+  before(e) {
+    return this.valueOf() < new p(e).valueOf();
+  }
+  /**
+   * Checks if TimeStamp is before or equal to the current timestamp.
+   *
+   * @param other - The other TimeStamp to compare to.
+   * @returns True if TimeStamp is before or equal to the current timestamp,
+   *   false otherwise.
+   */
+  beforeEq(e) {
+    return this.valueOf() <= new p(e).valueOf();
+  }
+  /**
+   * Adds a TimeSpan to the TimeStamp.
+   *
+   * @param span - The TimeSpan to add.
+   * @returns A new TimeStamp representing the sum of the TimeStamp and
+   *   TimeSpan.
+   */
+  add(e) {
+    return new p(this.valueOf() + BigInt(e.valueOf()));
+  }
+  /**
+   * Subtracts a TimeSpan from the TimeStamp.
+   *
+   * @param span - The TimeSpan to subtract.
+   * @returns A new TimeStamp representing the difference of the TimeStamp and
+   *   TimeSpan.
+   */
+  sub(e) {
+    return new p(this.valueOf() - BigInt(e.valueOf()));
+  }
+  /**
+   * @returns the floating point number of hours since the unix epoch to the timestamp
+   * value.
+   */
+  get hours() {
+    return Number(this.valueOf()) / Number(O.HOUR.valueOf());
+  }
+  /**
+   * @returns the floating point number of minutes since the unix epoch to the timestamp
+   * value.
+   */
+  get minutes() {
+    return Number(this.valueOf()) / Number(O.MINUTE.valueOf());
+  }
+  /**
+   * @returns the floating point number of days since the unix epoch to the timestamp
+   * value.
+   */
+  get days() {
+    return Number(this.valueOf()) / Number(O.DAY.valueOf());
+  }
+  /**
+   * @returns the floating point number of seconds since the unix epoch to the timestamp
+   * value.
+   */
+  get seconds() {
+    return Number(this.valueOf()) / Number(O.SECOND.valueOf());
+  }
+  /** @returns the floating point number of milliseconds since the unix epoch. */
+  get milliseconds() {
+    return Number(this.valueOf()) / Number(p.MILLISECOND.valueOf());
+  }
+  /** @returns the floating point number of microseconds since the unix epoch */
+  get microseconds() {
+    return Number(this.valueOf()) / Number(p.MICROSECOND.valueOf());
+  }
+  /**
+   * @returns the floating point number of nanoseconds since the unix epoch.
+   * Note that since we're converting to float64, this reduces the resolution
+   * to a quarter of a microsecond.
+   */
+  get nanoseconds() {
+    return Number(this.valueOf());
+  }
+  /** @returns the integer year that the timestamp corresponds to. */
+  get year() {
+    return this.date().getFullYear();
+  }
+  /**
+   * @returns a copy of the timestamp with the year changed.
+   * @param year the value to set the year to.
+   */
+  setYear(e) {
+    const t = this.date();
+    return t.setFullYear(e), new p(t);
+  }
+  /** @returns the integer month that the timestamp corresponds to with its year. */
+  get month() {
+    return this.date().getUTCMonth();
+  }
+  /**
+   * @returns a copy of the timestamp with the month changed.
+   * @param month the value to set the month to.
+   */
+  setMonth(e) {
+    const t = this.date();
+    return t.setUTCMonth(e), new p(t);
+  }
+  /** @returns the integer day that the timestamp corresponds to within its month. */
+  get day() {
+    return this.date().getUTCDate();
+  }
+  /**
+   * @returns a copy of the timestamp with the day changed.
+   * @param day the value the set the day to.
+   */
+  setDay(e) {
+    const t = this.date();
+    return t.setUTCDate(e), new p(t);
+  }
+  /**
+   * @returns the integer hour that the timestamp corresponds to within its day.
+   */
+  get hour() {
+    return this.date().getUTCHours();
+  }
+  /**
+   * @returns a copy of the timestamp with the hour changed.
+   * @param hour the value to set the hour to.
+   */
+  setHour(e) {
+    const t = this.date();
+    return t.setUTCHours(e), new p(t, "UTC");
+  }
+  /** @returns the integer minute that the timestamp corresponds to within its hour. */
+  get minute() {
+    return this.date().getMinutes();
+  }
+  /**
+   * @returns a copy of the timestamp with the minute changed.
+   * @param minute the value to set the minute to.
+   */
+  setMinute(e) {
+    const t = this.date();
+    return t.setUTCMinutes(e), new p(t);
+  }
+  /**
+   * @returns the integer second that the timestamp corresponds to within its
+   * minute.
+   */
+  get second() {
+    return this.date().getSeconds();
+  }
+  /**
+   * @returns a copy of the timestamp with the second changed.
+   * @param second the value to set the second to.
+   */
+  setSecond(e) {
+    const t = this.date();
+    return t.setUTCSeconds(e), new p(t);
+  }
+  /**
+   * @reutrns the integer millisecond that the timestamp corresponds to within
+   * its second.
+   */
+  get millisecond() {
+    return this.date().getMilliseconds();
+  }
+  /**
+   * @returns a copy of the timestamp with the milliseconds changed.
+   * @param millisecond the value to set the millisecond to.
+   */
+  setMillisecond(e) {
+    const t = this.date();
+    return t.setMilliseconds(e), new p(t);
+  }
+  /** @returns the time stamp formatted as an ISO string. */
+  toString() {
+    return this.date().toISOString();
+  }
+  /**
+   * @returns A new TimeStamp that is the remainder of the TimeStamp divided by the
+   * given span. This is useful in cases where you want only part of a TimeStamp's value
+   * i.e., the hours, minutes, seconds, milliseconds, microseconds, and nanoseconds but
+   * not the days, years, etc.
+   *
+   * @param divisor - The TimeSpan to divide by. Must be an even TimeSpan or TimeStamp. Even
+   * means it must be a day, hour, minute, second, millisecond, or microsecond, etc.
+   *
+   * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
+   */
+  remainder(e) {
+    return dn(this, e);
+  }
+  /** @returns true if the day portion TimeStamp is today, false otherwise. */
+  get isToday() {
+    return this.truncate(O.DAY).equals(p.now().truncate(O.DAY));
+  }
+  truncate(e) {
+    return this.sub(this.remainder(e));
+  }
+  /**
+   * @returns A new TimeStamp representing the current time in UTC. It's important to
+   * note that this TimeStamp is only accurate to the millisecond level (that's the best
+   * JavaScript can do).
+   */
+  static now() {
+    return new p(/* @__PURE__ */ new Date());
+  }
+  /** @returns the maximum value of all the timestamps. */
+  static max(...e) {
+    let t = p.MIN;
+    for (const n of e) {
+      const s = new p(n);
+      s.after(t) && (t = s);
+    }
+    return t;
+  }
+  /** @returns the minimum value of all the timestamps. */
+  static min(...e) {
+    let t = p.MAX;
+    for (const n of e) {
+      const s = new p(n);
+      s.before(t) && (t = s);
+    }
+    return t;
+  }
+  /** @returns a new TimeStamp n nanoseconds after the unix epoch */
+  static nanoseconds(e, t = "UTC") {
+    return new p(e, t);
+  }
+  /** @returns a new TimeStamp n microseconds after the unix epoch */
+  static microseconds(e, t = "UTC") {
+    return p.nanoseconds(e * 1e3, t);
+  }
+  /** @returns a new TimeStamp n milliseconds after the unix epoch */
+  static milliseconds(e, t = "UTC") {
+    return p.microseconds(e * 1e3, t);
+  }
+  /** @returns a new TimeStamp n seconds after the unix epoch */
+  static seconds(e, t = "UTC") {
+    return p.milliseconds(e * 1e3, t);
+  }
+  /** @returns a new TimeStamp n minutes after the unix epoch */
+  static minutes(e, t = "UTC") {
+    return p.seconds(e * 60, t);
+  }
+  /** @returns a new TimeStamp n hours after the unix epoch */
+  static hours(e, t = "UTC") {
+    return p.minutes(e * 60, t);
+  }
+  /** @returns a new TimeStamp n days after the unix epoch */
+  static days(e, t = "UTC") {
+    return p.hours(e * 24, t);
+  }
+};
+l(b, "NANOSECOND", b.nanoseconds(1)), /** One microsecond after the unix epoch */
+l(b, "MICROSECOND", b.microseconds(1)), /** One millisecond after the unix epoch */
+l(b, "MILLISECOND", b.milliseconds(1)), /** One second after the unix epoch */
+l(b, "SECOND", b.seconds(1)), /** One minute after the unix epoch */
+l(b, "MINUTE", b.minutes(1)), /** One hour after the unix epoch */
+l(b, "HOUR", b.hours(1)), /** One day after the unix epoch */
+l(b, "DAY", b.days(1)), /** The maximum possible value for a timestamp */
+l(b, "MAX", new b((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
+l(b, "MIN", new b(0)), /** The unix epoch */
+l(b, "ZERO", new b(0)), /** A zod schema for validating timestamps */
+l(b, "z", a.union([
+  a.object({ value: a.bigint() }).transform((r) => new b(r.value)),
+  a.string().transform((r) => new b(BigInt(r))),
+  a.instanceof(Number).transform((r) => new b(r)),
+  a.number().transform((r) => new b(r)),
+  a.instanceof(b)
+]));
+let x = b;
+const v = class y {
+  constructor(e) {
+    l(this, "value"), l(this, "encodeValue", !0), typeof e == "number" && (e = Math.trunc(e.valueOf())), this.value = BigInt(e.valueOf());
+  }
+  static fromSeconds(e) {
+    return e instanceof y ? e : e instanceof dr ? e.period : e instanceof x ? new y(e) : ["number", "bigint"].includes(typeof e) ? y.seconds(e) : new y(e);
+  }
+  static fromMilliseconds(e) {
+    return e instanceof y ? e : e instanceof dr ? e.period : e instanceof x ? new y(e) : ["number", "bigint"].includes(typeof e) ? y.milliseconds(e) : new y(e);
+  }
+  encode() {
+    return this.value.toString();
+  }
+  valueOf() {
+    return this.value;
+  }
+  lessThan(e) {
+    return this.valueOf() < new y(e).valueOf();
+  }
+  greaterThan(e) {
+    return this.valueOf() > new y(e).valueOf();
+  }
+  lessThanOrEqual(e) {
+    return this.valueOf() <= new y(e).valueOf();
+  }
+  greaterThanOrEqual(e) {
+    return this.valueOf() >= new y(e).valueOf();
+  }
+  remainder(e) {
+    return dn(this, e);
+  }
+  truncate(e) {
+    return new y(
+      BigInt(Math.trunc(Number(this.valueOf() / e.valueOf()))) * e.valueOf()
+    );
+  }
+  toString() {
+    const e = this.truncate(y.DAY), t = this.truncate(y.HOUR), n = this.truncate(y.MINUTE), s = this.truncate(y.SECOND), i = this.truncate(y.MILLISECOND), o = this.truncate(y.MICROSECOND), u = this.truncate(y.NANOSECOND), h = e, f = t.sub(e), g = n.sub(t), d = s.sub(n), B = i.sub(s), M = o.sub(i), ue = u.sub(o);
+    let _ = "";
+    return h.isZero || (_ += `${h.days}d `), f.isZero || (_ += `${f.hours}h `), g.isZero || (_ += `${g.minutes}m `), d.isZero || (_ += `${d.seconds}s `), B.isZero || (_ += `${B.milliseconds}ms `), M.isZero || (_ += `${M.microseconds}µs `), ue.isZero || (_ += `${ue.nanoseconds}ns`), _.trim();
+  }
+  mult(e) {
+    return new y(this.valueOf() * BigInt(e));
+  }
+  /** @returns the decimal number of days in the timespan */
+  get days() {
+    return Number(this.valueOf()) / Number(y.DAY.valueOf());
+  }
+  /** @returns the decimal number of hours in the timespan */
+  get hours() {
+    return Number(this.valueOf()) / Number(y.HOUR.valueOf());
+  }
+  /** @returns the decimal number of minutes in the timespan */
+  get minutes() {
+    return Number(this.valueOf()) / Number(y.MINUTE.valueOf());
+  }
+  /** @returns The number of seconds in the TimeSpan. */
+  get seconds() {
+    return Number(this.valueOf()) / Number(y.SECOND.valueOf());
+  }
+  /** @returns The number of milliseconds in the TimeSpan. */
+  get milliseconds() {
+    return Number(this.valueOf()) / Number(y.MILLISECOND.valueOf());
+  }
+  get microseconds() {
+    return Number(this.valueOf()) / Number(y.MICROSECOND.valueOf());
+  }
+  get nanoseconds() {
+    return Number(this.valueOf());
+  }
+  /**
+   * Checks if the TimeSpan represents a zero duration.
+   *
+   * @returns True if the TimeSpan represents a zero duration, false otherwise.
+   */
+  get isZero() {
+    return this.valueOf() === BigInt(0);
+  }
+  /**
+   * Checks if the TimeSpan is equal to another TimeSpan.
+   *
+   * @returns True if the TimeSpans are equal, false otherwise.
+   */
+  equals(e) {
+    return this.valueOf() === new y(e).valueOf();
+  }
+  /**
+   * Adds a TimeSpan to the TimeSpan.
+   *
+   * @returns A new TimeSpan representing the sum of the two TimeSpans.
+   */
+  add(e) {
+    return new y(this.valueOf() + new y(e).valueOf());
+  }
+  /**
+   * Creates a TimeSpan representing the duration between the two timestamps.
+   *
+   * @param other
+   */
+  sub(e) {
+    return new y(this.valueOf() - new y(e).valueOf());
+  }
+  /**
+   * Creates a TimeSpan representing the given number of nanoseconds.
+   *
+   * @param value - The number of nanoseconds.
+   * @returns A TimeSpan representing the given number of nanoseconds.
+   */
+  static nanoseconds(e = 1) {
+    return new y(e);
+  }
+  /**
+   * Creates a TimeSpan representing the given number of microseconds.
+   *
+   * @param value - The number of microseconds.
+   * @returns A TimeSpan representing the given number of microseconds.
+   */
+  static microseconds(e = 1) {
+    return y.nanoseconds(X(e, 1e3));
+  }
+  /**
+   * Creates a TimeSpan representing the given number of milliseconds.
+   *
+   * @param value - The number of milliseconds.
+   * @returns A TimeSpan representing the given number of milliseconds.
+   */
+  static milliseconds(e = 1) {
+    return y.microseconds(X(e, 1e3));
+  }
+  /**
+   * Creates a TimeSpan representing the given number of seconds.
+   *
+   * @param value - The number of seconds.
+   * @returns A TimeSpan representing the given number of seconds.
+   */
+  static seconds(e = 1) {
+    return y.milliseconds(X(e, 1e3));
+  }
+  /**
+   * Creates a TimeSpan representing the given number of minutes.
+   *
+   * @param value - The number of minutes.
+   * @returns A TimeSpan representing the given number of minutes.
+   */
+  static minutes(e = 1) {
+    return y.seconds(X(e, 60));
+  }
+  /**
+   * Creates a TimeSpan representing the given number of hours.
+   *
+   * @param value - The number of hours.
+   * @returns A TimeSpan representing the given number of hours.
+   */
+  static hours(e) {
+    return y.minutes(X(e, 60));
+  }
+  /**
+   * Creates a TimeSpan representing the given number of days.
+   *
+   * @param value - The number of days.
+   * @returns A TimeSpan representing the given number of days.
+   */
+  static days(e) {
+    return y.hours(X(e, 24));
+  }
+};
+l(v, "NANOSECOND", v.nanoseconds(1)), /** A microsecond. */
+l(v, "MICROSECOND", v.microseconds(1)), /** A millisecond. */
+l(v, "MILLISECOND", v.milliseconds(1)), /** A second. */
+l(v, "SECOND", v.seconds(1)), /** A minute. */
+l(v, "MINUTE", v.minutes(1)), /** Represents an hour. */
+l(v, "HOUR", v.hours(1)), /** Represents a day. */
+l(v, "DAY", v.days(1)), /** The maximum possible value for a TimeSpan. */
+l(v, "MAX", new v((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
+l(v, "MIN", new v(0)), /** The zero value for a TimeSpan. */
+l(v, "ZERO", new v(0)), /** A zod schema for validating and transforming timespans */
+l(v, "z", a.union([
+  a.object({ value: a.bigint() }).transform((r) => new v(r.value)),
+  a.string().transform((r) => new v(BigInt(r))),
+  a.instanceof(Number).transform((r) => new v(r)),
+  a.number().transform((r) => new v(r)),
+  a.instanceof(v)
+]));
+let O = v;
+const ye = class He extends Number {
+  constructor(e) {
+    e instanceof Number ? super(e.valueOf()) : super(e);
+  }
+  /** @returns a pretty string representation of the rate in the format "X Hz". */
+  toString() {
+    return `${this.valueOf()} Hz`;
+  }
+  /** @returns The number of seconds in the Rate. */
+  equals(e) {
+    return this.valueOf() === new He(e).valueOf();
+  }
+  /**
+   * Calculates the period of the Rate as a TimeSpan.
+   *
+   * @returns A TimeSpan representing the period of the Rate.
+   */
+  get period() {
+    return O.seconds(1 / this.valueOf());
+  }
+  /**
+   * Calculates the number of samples in the given TimeSpan at this rate.
+   *
+   * @param duration - The duration to calculate the sample count from.
+   * @returns The number of samples in the given TimeSpan at this rate.
+   */
+  sampleCount(e) {
+    return new O(e).seconds * this.valueOf();
+  }
+  /**
+   * Calculates the number of bytes in the given TimeSpan at this rate.
+   *
+   * @param span - The duration to calculate the byte count from.
+   * @param density - The density of the data in bytes per sample.
+   * @returns The number of bytes in the given TimeSpan at this rate.
+   */
+  byteCount(e, t) {
+    return this.sampleCount(e) * new A(t).valueOf();
+  }
+  /**
+   * Calculates a TimeSpan given the number of samples at this rate.
+   *
+   * @param sampleCount - The number of samples in the span.
+   * @returns A TimeSpan that corresponds to the given number of samples.
+   */
+  span(e) {
+    return O.seconds(e / this.valueOf());
+  }
+  /**
+   * Calculates a TimeSpan given the number of bytes at this rate.
+   *
+   * @param size - The number of bytes in the span.
+   * @param density - The density of the data in bytes per sample.
+   * @returns A TimeSpan that corresponds to the given number of bytes.
+   */
+  byteSpan(e, t) {
+    return this.span(e.valueOf() / t.valueOf());
+  }
+  /**
+   * Creates a Rate representing the given number of Hz.
+   *
+   * @param value - The number of Hz.
+   * @returns A Rate representing the given number of Hz.
+   */
+  static hz(e) {
+    return new He(e);
+  }
+  /**
+   * Creates a Rate representing the given number of kHz.
+   *
+   * @param value - The number of kHz.
+   * @returns A Rate representing the given number of kHz.
+   */
+  static khz(e) {
+    return He.hz(e * 1e3);
+  }
+};
+l(ye, "z", a.union([
+  a.number().transform((r) => new ye(r)),
+  a.instanceof(Number).transform((r) => new ye(r)),
+  a.instanceof(ye)
+]));
+let dr = ye;
+const U = class extends Number {
+  /**
+   * Creates a Density representing the given number of bytes per value.
+   *
+   * @class
+   * @param value - The number of bytes per value.
+   * @returns A Density representing the given number of bytes per value.
+   */
+  constructor(e) {
+    e instanceof Number ? super(e.valueOf()) : super(e);
+  }
+  length(e) {
+    return e.valueOf() / this.valueOf();
+  }
+  size(e) {
+    return new Ke(e * this.valueOf());
+  }
+};
+l(U, "UNKNOWN", new U(0)), /** 128 bits per value. */
+l(U, "BIT128", new U(16)), /** 64 bits per value. */
+l(U, "BIT64", new U(8)), /** 32 bits per value. */
+l(U, "BIT32", new U(4)), /** 16 bits per value. */
+l(U, "BIT16", new U(2)), /** 8 bits per value. */
+l(U, "BIT8", new U(1)), /** A zod schema for validating and transforming densities */
+l(U, "z", a.union([
+  a.number().transform((r) => new U(r)),
+  a.instanceof(Number).transform((r) => new U(r)),
+  a.instanceof(U)
+]));
+let A = U;
+const R = class me {
+  /**
+   * Creates a TimeRange from the given start and end TimeStamps.
+   *
+   * @param start - A TimeStamp representing the start of the range.
+   * @param end - A TimeStamp representing the end of the range.
+   */
+  constructor(e, t) {
+    l(this, "start"), l(this, "end"), typeof e == "object" && "start" in e ? (this.start = new x(e.start), this.end = new x(e.end)) : (this.start = new x(e), this.end = new x(t));
+  }
+  /** @returns The TimeSpan occupied by the TimeRange. */
+  get span() {
+    return new O(this.end.valueOf() - this.start.valueOf());
+  }
+  /**
+   * Checks if the timestamp is valid i.e. the start is before the end.
+   *
+   * @returns True if the TimeRange is valid.
+   */
+  get isValid() {
+    return this.start.valueOf() <= this.end.valueOf();
+  }
+  /**
+   * Makes sure the TimeRange is valid i.e. the start is before the end.
+   *
+   * @returns A TimeRange that is valid.
+   */
+  makeValid() {
+    return this.isValid ? this : this.swap();
+  }
+  /**
+   * Checks if the TimeRange has a zero span.
+   *
+   * @returns True if the TimeRange has a zero span.
+   */
+  get isZero() {
+    return this.span.isZero;
+  }
+  /**
+   * @returns the TimeRange as a numeric object with start and end properties.
+   */
+  get numeric() {
+    return { start: Number(this.start.valueOf()), end: Number(this.end.valueOf()) };
+  }
+  /**
+   * Creates a new TimeRange with the start and end swapped.
+   *
+   * @returns A TimeRange with the start and end swapped.
+   */
+  swap() {
+    return new me(this.end, this.start);
+  }
+  get numericBounds() {
+    return {
+      lower: Number(this.start.valueOf()),
+      upper: Number(this.end.valueOf())
+    };
+  }
+  /**
+   * Checks if the TimeRange is equal to the given TimeRange.
+   *
+   * @param other - The TimeRange to compare to.
+   * @returns True if the TimeRange is equal to the given TimeRange.
+   */
+  equals(e, t = O.ZERO) {
+    if (t.isZero)
+      return this.start.equals(e.start) && this.end.equals(e.end);
+    let n = this.start.sub(e.start).valueOf(), s = this.end.sub(e.end).valueOf();
+    return n < 0 && (n = -n), s < 0 && (s = -s), n <= t.valueOf() && s <= t.valueOf();
+  }
+  toString() {
+    return `${this.start.toString()} - ${this.end.toString()}`;
+  }
+  toPrettyString() {
+    return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
+  }
+  /**
+   * Checks if the two time ranges overlap. If the two time ranges are equal, returns
+   * true.  If the start of one range is equal to the end of the other, it returns false.
+   * Just follow the rule [start, end), i.e., start is inclusive, and the end is exclusive.
+   *
+   * @param other - The other TimeRange to compare to.
+   * @param delta - A TimeSpan representing the minimum amount of overlap for
+   * overlap to return true. This allows for a slight amount of leeway when
+   * checking for overlap.
+   * @returns True if the two TimeRanges overlap, false otherwise.
+   */
+  overlapsWith(e, t = O.ZERO) {
+    e = e.makeValid();
+    const n = this.makeValid();
+    if (this.equals(e)) return !0;
+    if (e.end.equals(n.start) || n.end.equals(e.start)) return !1;
+    const s = x.max(n.start, e.start), i = x.min(n.end, e.end);
+    return i.before(s) ? !1 : new O(i.sub(s)).greaterThanOrEqual(t);
+  }
+  contains(e) {
+    return e instanceof me ? this.contains(e.start) && this.contains(e.end) : this.start.beforeEq(e) && this.end.after(e);
+  }
+  boundBy(e) {
+    const t = new me(this.start, this.end);
+    return e.start.after(this.start) && (t.start = e.start), e.start.after(this.end) && (t.end = e.start), e.end.before(this.end) && (t.end = e.end), e.end.before(this.start) && (t.start = e.end), t;
+  }
+  static max(...e) {
+    return new me(
+      x.min(...e.map((t) => t.start)),
+      x.max(...e.map((t) => t.end))
+    );
+  }
+};
+l(R, "MAX", new R(x.MIN, x.MAX)), /** The minimum possible time range. */
+l(R, "MIN", new R(x.MAX, x.MIN)), /** A time range whose start and end are both zero. */
+l(R, "ZERO", new R(x.ZERO, x.ZERO)), /** A zod schema for validating and transforming time ranges */
+l(R, "z", a.union([
+  a.object({ start: x.z, end: x.z }).transform((r) => new R(r.start, r.end)),
+  a.instanceof(R)
+]));
+let re = R;
+const c = class I {
+  constructor(e) {
+    if (l(this, "value"), l(this, "encodeValue", !0), e instanceof I || typeof e == "string" || typeof e.valueOf() == "string") {
+      this.value = e.valueOf();
+      return;
+    }
+    const t = I.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
+    if (t != null) {
+      this.value = t.valueOf();
+      return;
+    }
+    throw this.value = I.UNKNOWN.valueOf(), new Error(`unable to find data type for ${e.toString()}`);
+  }
+  valueOf() {
+    return this.value;
+  }
+  /**
+   * @returns the TypedArray constructor for the DataType.
+   */
+  get Array() {
+    const e = I.ARRAY_CONSTRUCTORS.get(this.toString());
+    if (e == null)
+      throw new Error(`unable to find array constructor for ${this.valueOf()}`);
+    return e;
+  }
+  /**
+   * @returns true if the DataType is equal to the given DataType.
+   */
+  equals(e) {
+    return this.valueOf() === e.valueOf();
+  }
+  /**
+   * @returns true if the DataType is equal to any of the given DataTypes.
+   */
+  matches(...e) {
+    return e.some((t) => this.equals(t));
+  }
+  /** @returns a string representation of the DataType. */
+  toString() {
+    return this.valueOf();
+  }
+  get isVariable() {
+    return this.equals(I.JSON) || this.equals(I.STRING);
+  }
+  get isNumeric() {
+    return !this.isVariable && !this.equals(I.UUID);
+  }
+  get isInteger() {
+    const e = this.toString();
+    return e.startsWith("int") || e.startsWith("uint");
+  }
+  get isFloat() {
+    return this.toString().startsWith("float");
+  }
+  get density() {
+    const e = I.DENSITIES.get(this.toString());
+    if (e == null) throw new Error(`unable to find density for ${this.valueOf()}`);
+    return e;
+  }
+  /** @returns ture if the data type is an unsigned numeric integer type */
+  get isUnsigned() {
+    return this.equals(I.UINT8) || this.equals(I.UINT16) || this.equals(I.UINT32) || this.equals(I.UINT64);
+  }
+  /** @returns true if the data type is a signed numeric integer type */
+  get isSigned() {
+    return this.equals(I.INT8) || this.equals(I.INT16) || this.equals(I.INT32) || this.equals(I.INT64);
+  }
+  /** @returns true if the data type can be cast to the other data type without loss of precision. */
+  canSafelyCastTo(e) {
+    return this.equals(e) ? !0 : !this.isNumeric || !e.isNumeric || this.isVariable || e.isVariable || this.isUnsigned && e.isSigned ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(I.INT32) && e.equals(I.FLOAT64) || this.equals(I.INT8) && e.equals(I.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsigned === e.isUnsigned : !1;
+  }
+  /** @returns true if the data type can be cast to the other data type, even if there is a loss of precision. */
+  canCastTo(e) {
+    return this.isNumeric && e.isNumeric ? !0 : this.equals(e);
+  }
+  toJSON() {
+    return this.toString();
+  }
+  get usesBigInt() {
+    return I.BIG_INT_TYPES.some((e) => e.equals(this));
+  }
+};
+l(c, "UNKNOWN", new c("unknown")), /** Represents a 64-bit floating point value. */
+l(c, "FLOAT64", new c("float64")), /** Represents a 32-bit floating point value. */
+l(c, "FLOAT32", new c("float32")), /** Represents a 64-bit signed integer value. */
+l(c, "INT64", new c("int64")), /** Represents a 32-bit signed integer value. */
+l(c, "INT32", new c("int32")), /** Represents a 16-bit signed integer value. */
+l(c, "INT16", new c("int16")), /** Represents a 8-bit signed integer value. */
+l(c, "INT8", new c("int8")), /** Represents a 64-bit unsigned integer value. */
+l(c, "UINT64", new c("uint64")), /** Represents a 32-bit unsigned integer value. */
+l(c, "UINT32", new c("uint32")), /** Represents a 16-bit unsigned integer value. */
+l(c, "UINT16", new c("uint16")), /** Represents a 8-bit unsigned integer value. */
+l(c, "UINT8", new c("uint8")), /** Represents a boolean value. Alias for UINT8. */
+l(c, "BOOLEAN", c.UINT8), /** Represents a 64-bit unix epoch. */
+l(c, "TIMESTAMP", new c("timestamp")), /** Represents a UUID data type */
+l(c, "UUID", new c("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
+* by a newline character. */
+l(c, "STRING", new c("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+* newline character. */
+l(c, "JSON", new c("json")), l(c, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
+  [c.UINT8.toString(), Uint8Array],
+  [c.UINT16.toString(), Uint16Array],
+  [c.UINT32.toString(), Uint32Array],
+  [c.UINT64.toString(), BigUint64Array],
+  [c.FLOAT32.toString(), Float32Array],
+  [c.FLOAT64.toString(), Float64Array],
+  [c.INT8.toString(), Int8Array],
+  [c.INT16.toString(), Int16Array],
+  [c.INT32.toString(), Int32Array],
+  [c.INT64.toString(), BigInt64Array],
+  [c.TIMESTAMP.toString(), BigInt64Array],
+  [c.STRING.toString(), Uint8Array],
+  [c.JSON.toString(), Uint8Array],
+  [c.UUID.toString(), Uint8Array]
+])), l(c, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
+  [Uint8Array.name, c.UINT8],
+  [Uint16Array.name, c.UINT16],
+  [Uint32Array.name, c.UINT32],
+  [BigUint64Array.name, c.UINT64],
+  [Float32Array.name, c.FLOAT32],
+  [Float64Array.name, c.FLOAT64],
+  [Int8Array.name, c.INT8],
+  [Int16Array.name, c.INT16],
+  [Int32Array.name, c.INT32],
+  [BigInt64Array.name, c.INT64]
+])), l(c, "DENSITIES", /* @__PURE__ */ new Map([
+  [c.UINT8.toString(), A.BIT8],
+  [c.UINT16.toString(), A.BIT16],
+  [c.UINT32.toString(), A.BIT32],
+  [c.UINT64.toString(), A.BIT64],
+  [c.FLOAT32.toString(), A.BIT32],
+  [c.FLOAT64.toString(), A.BIT64],
+  [c.INT8.toString(), A.BIT8],
+  [c.INT16.toString(), A.BIT16],
+  [c.INT32.toString(), A.BIT32],
+  [c.INT64.toString(), A.BIT64],
+  [c.TIMESTAMP.toString(), A.BIT64],
+  [c.STRING.toString(), A.UNKNOWN],
+  [c.JSON.toString(), A.UNKNOWN],
+  [c.UUID.toString(), A.BIT128]
+])), /** All the data types. */
+l(c, "ALL", [
+  c.UNKNOWN,
+  c.FLOAT64,
+  c.FLOAT32,
+  c.INT64,
+  c.INT32,
+  c.INT16,
+  c.INT8,
+  c.UINT64,
+  c.UINT32,
+  c.UINT16,
+  c.UINT8,
+  c.TIMESTAMP,
+  c.UUID,
+  c.STRING,
+  c.JSON
+]), l(c, "BIG_INT_TYPES", [c.INT64, c.UINT64, c.TIMESTAMP]), /** A zod schema for a DataType. */
+l(c, "z", a.union([
+  a.string().transform((r) => new c(r)),
+  a.instanceof(c)
+]));
+let w = c;
+const E = class N extends Number {
+  constructor(e) {
+    super(e.valueOf());
+  }
+  /** @returns true if the Size is larger than the other size. */
+  largerThan(e) {
+    return this.valueOf() > e.valueOf();
+  }
+  /** @returns true if the Size is smaller than the other size. */
+  smallerThan(e) {
+    return this.valueOf() < e.valueOf();
+  }
+  add(e) {
+    return N.bytes(this.valueOf() + e.valueOf());
+  }
+  sub(e) {
+    return N.bytes(this.valueOf() - e.valueOf());
+  }
+  truncate(e) {
+    return new N(Math.trunc(this.valueOf() / e.valueOf()) * e.valueOf());
+  }
+  remainder(e) {
+    return N.bytes(this.valueOf() % e.valueOf());
+  }
+  get gigabytes() {
+    return this.valueOf() / N.GIGABYTE.valueOf();
+  }
+  get megabytes() {
+    return this.valueOf() / N.MEGABYTE.valueOf();
+  }
+  get kilobytes() {
+    return this.valueOf() / N.KILOBYTE.valueOf();
+  }
+  get terabytes() {
+    return this.valueOf() / N.TERABYTE.valueOf();
+  }
+  toString() {
+    const e = this.truncate(N.TERABYTE), t = this.truncate(N.GIGABYTE), n = this.truncate(N.MEGABYTE), s = this.truncate(N.KILOBYTE), i = this.truncate(N.BYTE), o = e, u = t.sub(e), h = n.sub(t), f = s.sub(n), g = i.sub(s);
+    let d = "";
+    return o.isZero || (d += `${o.terabytes}TB `), u.isZero || (d += `${u.gigabytes}GB `), h.isZero || (d += `${h.megabytes}MB `), f.isZero || (d += `${f.kilobytes}KB `), (!g.isZero || d === "") && (d += `${g.valueOf()}B`), d.trim();
+  }
+  /**
+   * Creates a Size from the given number of bytes.
+   *
+   * @param value - The number of bytes.
+   * @returns A Size representing the given number of bytes.
+   */
+  static bytes(e = 1) {
+    return new N(e);
+  }
+  /**
+   * Creates a Size from the given number if kilobytes.
+   *
+   * @param value - The number of kilobytes.
+   * @returns A Size representing the given number of kilobytes.
+   */
+  static kilobytes(e = 1) {
+    return N.bytes(e.valueOf() * 1e3);
+  }
+  /**
+   * Creates a Size from the given number of megabytes.
+   *
+   * @param value - The number of megabytes.
+   * @returns A Size representing the given number of megabytes.
+   */
+  static megabytes(e = 1) {
+    return N.kilobytes(e.valueOf() * 1e3);
+  }
+  /**
+   * Creates a Size from the given number of gigabytes.
+   *
+   * @param value - The number of gigabytes.
+   * @returns A Size representing the given number of gigabytes.
+   */
+  static gigabytes(e = 1) {
+    return N.megabytes(e.valueOf() * 1e3);
+  }
+  /**
+   * Creates a Size from the given number of terabytes.
+   *
+   * @param value - The number of terabytes.
+   * @returns  A Size representing the given number of terabytes.
+   */
+  static terabytes(e) {
+    return N.gigabytes(e.valueOf() * 1e3);
+  }
+  get isZero() {
+    return this.valueOf() === 0;
+  }
+};
+l(E, "BYTE", new E(1)), /** A kilobyte */
+l(E, "KILOBYTE", E.kilobytes(1)), /** A megabyte */
+l(E, "MEGABYTE", E.megabytes(1)), /** A gigabyte */
+l(E, "GIGABYTE", E.gigabytes(1)), /** A terabyte. */
+l(E, "TERABYTE", E.terabytes(1)), /** The zero value for Size */
+l(E, "ZERO", new E(0)), /** A zod schema for a Size. */
+l(E, "z", a.union([
+  a.number().transform((r) => new E(r)),
+  a.instanceof(E)
+]));
+let Ke = E;
+const nl = a.union([
+  a.instanceof(Uint8Array),
+  a.instanceof(Uint16Array),
+  a.instanceof(Uint32Array),
+  a.instanceof(BigUint64Array),
+  a.instanceof(Float32Array),
+  a.instanceof(Float64Array),
+  a.instanceof(Int8Array),
+  a.instanceof(Int16Array),
+  a.instanceof(Int32Array),
+  a.instanceof(BigInt64Array)
+]), gn = (r) => {
+  const e = typeof r;
+  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || r instanceof x || r instanceof O || r instanceof Date;
+}, Jo = (r, e, t, n = 0) => r.usesBigInt && !e.usesBigInt ? Number(t) - Number(n) : !r.usesBigInt && e.usesBigInt ? BigInt(t.valueOf()) - BigInt(n.valueOf()) : we(t, -n).valueOf(), we = (r, e) => e == 0 ? r : r == 0 ? e : typeof r == "bigint" && typeof e == "bigint" || typeof r == "number" && typeof e == "number" ? r + e : Number(r) + Number(e), Xo = (r) => r == null ? !1 : Array.isArray(r) || r instanceof ArrayBuffer || ArrayBuffer.isView(r) && !(r instanceof DataView) || r instanceof ta ? !0 : gn(r), q = -1, Bt = {
+  [Symbol.iterator]: () => Bt,
+  next: () => ({ done: !0, value: void 0 })
+}, Qo = a.string().transform(
+  (r) => new Uint8Array(
+    atob(r).split("").map((e) => e.charCodeAt(0))
+  ).buffer
+), ea = a.union([a.null(), a.undefined()]).transform(() => new Uint8Array().buffer), Et = 10, pn = (r, e) => {
+  if (r === "string" && !e.isVariable)
+    throw new Error(`cannot convert series of type ${e.toString()} to string`);
+  if (r === "number" && !e.isNumeric)
+    throw new Error(`cannot convert series of type ${e.toString()} to number`);
+  if (r === "bigint" && !e.usesBigInt)
+    throw new Error(`cannot convert series of type ${e.toString()} to bigint`);
+}, be = class j {
+  constructor(e) {
+    l(this, "key", ""), l(this, "isSynnaxSeries", !0), l(this, "dataType"), l(this, "sampleOffset"), l(this, "gl"), l(this, "_data"), l(this, "timeRange", re.ZERO), l(this, "alignment", 0n), l(this, "_cachedMin"), l(this, "_cachedMax"), l(this, "writePos", q), l(this, "_refCount", 0), l(this, "_cachedLength"), l(this, "_cachedIndexes"), Xo(e) && (e = { data: e });
+    const {
+      dataType: t,
+      timeRange: n,
+      sampleOffset: s = 0,
+      glBufferUsage: i = "static",
+      alignment: o = 0n,
+      key: u = fn()
+    } = e, h = e.data ?? [];
+    if (h instanceof j || typeof h == "object" && "isSynnaxSeries" in h && h.isSynnaxSeries === !0) {
+      const d = h;
+      this.key = d.key, this.dataType = d.dataType, this.sampleOffset = d.sampleOffset, this.gl = d.gl, this._data = d._data, this.timeRange = d.timeRange, this.alignment = d.alignment, this._cachedMin = d._cachedMin, this._cachedMax = d._cachedMax, this.writePos = d.writePos, this._refCount = d._refCount, this._cachedLength = d._cachedLength;
+      return;
+    }
+    const f = gn(h), g = Array.isArray(h);
+    if (t != null) this.dataType = new w(t);
+    else {
+      if (h instanceof ArrayBuffer)
+        throw new Error(
+          "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
+        );
+      if (g || f) {
+        let d = h;
+        if (!f) {
+          if (h.length === 0)
+            throw new Error(
+              "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
+            );
+          d = h[0];
+        }
+        if (typeof d == "string") this.dataType = w.STRING;
+        else if (typeof d == "number") this.dataType = w.FLOAT64;
+        else if (typeof d == "bigint") this.dataType = w.INT64;
+        else if (typeof d == "boolean") this.dataType = w.BOOLEAN;
+        else if (d instanceof x || d instanceof Date || d instanceof x)
+          this.dataType = w.TIMESTAMP;
+        else if (typeof d == "object") this.dataType = w.JSON;
+        else
+          throw new Error(
+            `cannot infer data type of ${typeof d} when constructing a Series from a JS array`
+          );
+      } else this.dataType = new w(h);
+    }
+    if (!g && !f) this._data = h;
+    else {
+      let d = f ? [h] : h;
+      const B = d[0];
+      (B instanceof x || B instanceof Date || B instanceof O) && (d = d.map((M) => new x(M).valueOf())), this.dataType.equals(w.STRING) ? (this._cachedLength = d.length, this._data = new TextEncoder().encode(`${d.join(`
+`)}
+`).buffer) : this.dataType.equals(w.JSON) ? (this._cachedLength = d.length, this._data = new TextEncoder().encode(
+        `${d.map((M) => Ve.encodeString(M)).join(`
+`)}
+`
+      ).buffer) : this.dataType.usesBigInt && typeof B == "number" ? this._data = new this.dataType.Array(
+        d.map((M) => BigInt(Math.round(M)))
+      ).buffer : !this.dataType.usesBigInt && typeof B == "bigint" ? this._data = new this.dataType.Array(
+        d.map((M) => Number(M))
+      ).buffer : this._data = new this.dataType.Array(d).buffer;
+    }
+    this.key = u, this.alignment = o, this.sampleOffset = s ?? 0, this.timeRange = n ?? re.ZERO, this.gl = {
+      control: null,
+      buffer: null,
+      prevBuffer: 0,
+      bufferUsage: i
+    };
+  }
+  static alloc({ capacity: e, dataType: t, ...n }) {
+    if (e === 0)
+      throw new Error("[Series] - cannot allocate an array of length 0");
+    const s = new new w(t).Array(e), i = new j({
+      data: s.buffer,
+      dataType: t,
+      ...n
+    });
+    return i.writePos = 0, i;
+  }
+  static createTimestamps(e, t, n) {
+    const s = n.spanRange(t.span(e)), i = new BigInt64Array(e);
+    for (let o = 0; o < e; o++)
+      i[o] = BigInt(n.add(t.span(o)).valueOf());
+    return new j({ data: i, dataType: w.TIMESTAMP, timeRange: s });
+  }
+  get refCount() {
+    return this._refCount;
+  }
+  static fromStrings(e, t) {
+    const n = new TextEncoder().encode(
+      `${e.join(`
+`)}
+`
+    );
+    return new j({ data: n, dataType: w.STRING, timeRange: t });
+  }
+  static fromJSON(e, t) {
+    const n = new TextEncoder().encode(
+      `${e.map((s) => Ve.encodeString(s)).join(`
+`)}
+`
+    );
+    return new j({ data: n, dataType: w.JSON, timeRange: t });
+  }
+  acquire(e) {
+    this._refCount++, e != null && this.updateGLBuffer(e);
+  }
+  release() {
+    if (this._refCount <= 0) {
+      console.warn("attempted to release a series with a negative reference count");
+      return;
+    }
+    this._refCount--, this._refCount === 0 && this.gl.control != null && this.maybeGarbageCollectGLBuffer(this.gl.control);
+  }
+  /**
+   * Writes the given series to this series. If the series being written exceeds the
+   * remaining of series being written to, only the portion that fits will be written.
+   * @param other the series to write to this series. The data type of the series written
+   * must be the same as the data type of the series being written to.
+   * @returns the number of samples written. If the entire series fits, this value is
+   * equal to the length of the series being written.
+   */
+  write(e) {
+    if (!e.dataType.equals(this.dataType))
+      throw new Error("buffer must be of the same type as this array");
+    return this.dataType.isVariable ? this.writeVariable(e) : this.writeFixed(e);
+  }
+  writeVariable(e) {
+    if (this.writePos === q) return 0;
+    const t = this.byteCapacity.valueOf() - this.writePos, n = e.subBytes(0, t);
+    return this.writeToUnderlyingData(n), this.writePos += n.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += n.length, this.calculateCachedLength()), n.length;
+  }
+  writeFixed(e) {
+    if (this.writePos === q) return 0;
+    const t = this.capacity - this.writePos, n = e.sub(0, t);
+    return this.writeToUnderlyingData(n), this._cachedLength = void 0, this.maybeRecomputeMinMax(n), this.writePos += n.length, n.length;
+  }
+  writeToUnderlyingData(e) {
+    this.underlyingData.set(
+      e.data,
+      this.writePos
+    );
+  }
+  /** @returns the underlying buffer backing this array. */
+  get buffer() {
+    return typeof this._data == "object" && "buffer" in this._data ? this._data.buffer : this._data;
+  }
+  get underlyingData() {
+    return new this.dataType.Array(this._data);
+  }
+  /** @returns a native typed array with the proper data type. */
+  get data() {
+    return this.writePos === q ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
+  }
+  toStrings() {
+    if (!this.dataType.matches(w.STRING, w.UUID))
+      throw new Error("cannot convert non-string series to strings");
+    return new TextDecoder().decode(this.underlyingData).split(`
+`).slice(0, -1);
+  }
+  toUUIDs() {
+    if (!this.dataType.equals(w.UUID))
+      throw new Error("cannot convert non-uuid series to uuids");
+    const e = w.UUID.density.valueOf(), t = Array(this.length);
+    for (let n = 0; n < this.length; n++) {
+      const s = this.underlyingData.slice(n * e, (n + 1) * e), i = Array.from(
+        new Uint8Array(s.buffer),
+        (o) => o.toString(16).padStart(2, "0")
+      ).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+      t[n] = i;
+    }
+    return t;
+  }
+  parseJSON(e) {
+    if (!this.dataType.equals(w.JSON))
+      throw new Error("cannot parse non-JSON series as JSON");
+    return new TextDecoder().decode(this.underlyingData).split(`
+`).slice(0, -1).map((t) => e.parse(Ve.decodeString(t)));
+  }
+  /** @returns the capacity of the series in bytes. */
+  get byteCapacity() {
+    return new Ke(this.underlyingData.byteLength);
+  }
+  /** @returns the capacity of the series in samples. */
+  get capacity() {
+    return this.dataType.isVariable ? this.byteCapacity.valueOf() : this.dataType.density.length(this.byteCapacity);
+  }
+  /** @returns the length of the series in bytes. */
+  get byteLength() {
+    return this.writePos === q ? this.byteCapacity : this.dataType.isVariable ? new Ke(this.writePos) : this.dataType.density.size(this.writePos);
+  }
+  /** @returns the number of samples in this array. */
+  get length() {
+    return this._cachedLength != null ? this._cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === q ? this.data.length : this.writePos;
+  }
+  calculateCachedLength() {
+    if (!this.dataType.isVariable)
+      throw new Error("cannot calculate length of a non-variable length data type");
+    let e = 0;
+    const t = [0];
+    return this.data.forEach((n, s) => {
+      n === Et && (e++, t.push(s + 1));
+    }), this._cachedIndexes = t, this._cachedLength = e, e;
+  }
+  /**
+   * Creates a new array with a different data type.
+   * @param target the data type to convert to.
+   * @param sampleOffset an offset to apply to each sample. This can help with precision
+   * issues when converting between data types.
+   *
+   * WARNING: This method is expensive and copies the entire underlying array. There
+   * also may be untimely precision issues when converting between data types.
+   */
+  convert(e, t = 0) {
+    if (this.dataType.equals(e)) return this;
+    const n = new e.Array(this.length);
+    for (let s = 0; s < this.length; s++)
+      n[s] = Jo(this.dataType, e, this.data[s], t);
+    return new j({
+      data: n.buffer,
+      dataType: e,
+      timeRange: this.timeRange,
+      sampleOffset: t,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment
+    });
+  }
+  calcRawMax() {
+    if (this.length === 0) return -1 / 0;
+    if (this.dataType.equals(w.TIMESTAMP))
+      this._cachedMax = this.data[this.data.length - 1];
+    else if (this.dataType.usesBigInt) {
+      const e = this.data;
+      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
+    } else {
+      const e = this.data;
+      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
+    }
+    return this._cachedMax;
+  }
+  /** @returns the maximum value in the array */
+  get max() {
+    if (this.dataType.isVariable)
+      throw new Error("cannot calculate maximum on a variable length data type");
+    return this.writePos === 0 ? -1 / 0 : (this._cachedMax ?? (this._cachedMax = this.calcRawMax()), we(this._cachedMax, this.sampleOffset));
+  }
+  calcRawMin() {
+    if (this.length === 0) return 1 / 0;
+    if (this.dataType.equals(w.TIMESTAMP)) this._cachedMin = this.data[0];
+    else if (this.dataType.usesBigInt) {
+      const e = this.data;
+      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
+    } else {
+      const e = this.data;
+      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
+    }
+    return this._cachedMin;
+  }
+  /** @returns the minimum value in the array */
+  get min() {
+    if (this.dataType.isVariable)
+      throw new Error("cannot calculate minimum on a variable length data type");
+    return this.writePos === 0 ? 1 / 0 : (this._cachedMin ?? (this._cachedMin = this.calcRawMin()), we(this._cachedMin, this.sampleOffset));
+  }
+  /** @returns the bounds of this array. */
+  get bounds() {
+    return m(Number(this.min), Number(this.max));
+  }
+  maybeRecomputeMinMax(e) {
+    if (this._cachedMin != null) {
+      const t = e._cachedMin ?? e.calcRawMin();
+      t < this._cachedMin && (this._cachedMin = t);
+    }
+    if (this._cachedMax != null) {
+      const t = e._cachedMax ?? e.calcRawMax();
+      t > this._cachedMax && (this._cachedMax = t);
+    }
+  }
+  enrich() {
+    this.max, this.min;
+  }
+  get range() {
+    return we(this.max, -this.min);
+  }
+  atAlignment(e, t) {
+    const n = Number(e - this.alignment);
+    if (n < 0 || n >= this.length) {
+      if (t === !0) throw new Error(`[series] - no value at index ${n}`);
+      return;
+    }
+    return this.at(n, t);
+  }
+  at(e, t) {
+    if (this.dataType.isVariable) return this.atVariable(e, t ?? !1);
+    e < 0 && (e = this.length + e);
+    const n = this.data[e];
+    if (n == null) {
+      if (t === !0) throw new Error(`[series] - no value at index ${e}`);
+      return;
+    }
+    return we(n, this.sampleOffset);
+  }
+  atVariable(e, t) {
+    let n = 0, s = 0;
+    if (this._cachedIndexes != null)
+      n = this._cachedIndexes[e], s = this._cachedIndexes[e + 1] - 1;
+    else {
+      e < 0 && (e = this.length + e);
+      for (let o = 0; o < this.data.length; o++)
+        if (this.data[o] === Et) {
+          if (e === 0) {
+            s = o;
+            break;
+          }
+          n = o + 1, e--;
+        }
+      if (s === 0 && (s = this.data.length), n >= s || e > 0) {
+        if (t) throw new Error(`[series] - no value at index ${e}`);
+        return;
+      }
+    }
+    const i = this.data.slice(n, s);
+    return this.dataType.equals(w.STRING) ? new TextDecoder().decode(i) : tt(JSON.parse(new TextDecoder().decode(i)));
+  }
+  /**
+   * @returns the index of the first sample that is greater than or equal to the given value.
+   * The underlying array must be sorted. If it is not, the behavior of this method is undefined.
+   * @param value the value to search for.
+   */
+  binarySearch(e) {
+    let t = 0, n = this.length - 1;
+    const s = it(e);
+    for (; t <= n; ) {
+      const i = Math.floor((t + n) / 2), o = s(this.at(i, !0), e);
+      if (o === 0) return i;
+      o < 0 ? t = i + 1 : n = i - 1;
+    }
+    return t;
+  }
+  updateGLBuffer(e) {
+    if (this.gl.control = e, !this.dataType.equals(w.FLOAT32) && !this.dataType.equals(w.UINT8))
+      throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
+    const { buffer: t, bufferUsage: n, prevBuffer: s } = this.gl;
+    if (t == null && (this.gl.buffer = e.createBuffer()), this.writePos !== s)
+      if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== q) {
+        s === 0 && e.bufferData(e.ARRAY_BUFFER, this.byteCapacity.valueOf(), e.STATIC_DRAW);
+        const i = this.dataType.density.size(s).valueOf(), o = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
+        e.bufferSubData(e.ARRAY_BUFFER, i, o.buffer), this.gl.prevBuffer = this.writePos;
+      } else
+        e.bufferData(
+          e.ARRAY_BUFFER,
+          this.buffer,
+          n === "static" ? e.STATIC_DRAW : e.DYNAMIC_DRAW
+        ), this.gl.prevBuffer = q;
+  }
+  as(e) {
+    return pn(e, this.dataType), this;
+  }
+  get digest() {
+    var e;
+    return {
+      key: this.key,
+      dataType: this.dataType.toString(),
+      sampleOffset: this.sampleOffset,
+      alignment: {
+        lower: $r(this.alignmentBounds.lower),
+        upper: $r(this.alignmentBounds.upper)
+      },
+      timeRange: (e = this.timeRange) == null ? void 0 : e.toString(),
+      length: this.length,
+      capacity: this.capacity
+    };
+  }
+  get memInfo() {
+    return {
+      key: this.key,
+      length: this.length,
+      byteLength: this.byteLength,
+      glBuffer: this.gl.buffer != null
+    };
+  }
+  get alignmentBounds() {
+    return m(this.alignment, this.alignment + BigInt(this.length));
+  }
+  maybeGarbageCollectGLBuffer(e) {
+    this.gl.buffer != null && (e.deleteBuffer(this.gl.buffer), this.gl.buffer = null, this.gl.prevBuffer = 0, this.gl.control = null);
+  }
+  get glBuffer() {
+    if (this.gl.buffer == null) throw new Error("gl buffer not initialized");
+    return this.gl.prevBuffer !== this.writePos && console.warn("buffer not updated"), this.gl.buffer;
+  }
+  [Symbol.iterator]() {
+    if (this.dataType.isVariable) {
+      const e = new ra(this);
+      return this.dataType.equals(w.JSON) ? new na(e) : e;
+    }
+    return new sa(this);
+  }
+  slice(e, t) {
+    return this.sliceSub(!1, e, t);
+  }
+  sub(e, t) {
+    return this.sliceSub(!0, e, t);
+  }
+  subIterator(e, t) {
+    return new gr(this, e, t ?? this.length);
+  }
+  subAlignmentIterator(e, t) {
+    return new gr(
+      this,
+      Number(e - this.alignment),
+      Number(t - this.alignment)
+    );
+  }
+  subBytes(e, t) {
+    if (e >= 0 && (t == null || t >= this.byteLength.valueOf())) return this;
+    const n = this.data.subarray(e, t);
+    return new j({
+      data: n,
+      dataType: this.dataType,
+      timeRange: this.timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + BigInt(e)
+    });
+  }
+  sliceSub(e, t, n) {
+    if (t <= 0 && (n == null || n >= this.length)) return this;
+    let s;
+    return e ? s = this.data.subarray(t, n) : s = this.data.slice(t, n), new j({
+      data: s,
+      dataType: this.dataType,
+      timeRange: this.timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + BigInt(t)
+    });
+  }
+  reAlign(e) {
+    return new j({
+      data: this.buffer,
+      dataType: this.dataType,
+      timeRange: re.ZERO,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: "static",
+      alignment: e
+    });
+  }
+  toString() {
+    var e, t;
+    let n = `${this.dataType.toString()} ${this.length} [`;
+    if (this.length <= 10) n += Array.from(this).map((s) => s.toString());
+    else {
+      for (let s = 0; s < 5; s++)
+        n += `${(e = this.at(s)) == null ? void 0 : e.toString()}`, s < 4 && (n += ",");
+      n += "...";
+      for (let s = -5; s < 0; s++)
+        n += (t = this.at(s)) == null ? void 0 : t.toString(), s < -1 && (n += ",");
+    }
+    return n += "]", n;
+  }
+};
+l(be, "crudeZ", a.object({
+  timeRange: re.z.optional(),
+  dataType: w.z,
+  alignment: a.coerce.bigint().optional(),
+  data: a.union([
+    Qo,
+    ea,
+    a.instanceof(ArrayBuffer),
+    a.instanceof(Uint8Array)
+  ]),
+  glBufferUsage: Ko.optional().default("static").optional()
+})), l(be, "z", be.crudeZ.transform((r) => new be(r)));
+let ta = be, gr = class {
+  constructor(e, t, n) {
+    l(this, "series"), l(this, "end"), l(this, "index"), this.series = e;
+    const s = m(0, e.length);
+    this.end = yt(s, n), this.index = yt(s, t);
+  }
+  next() {
+    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}, ra = class {
+  constructor(e) {
+    if (l(this, "series"), l(this, "index"), l(this, "decoder"), !e.dataType.isVariable)
+      throw new Error(
+        "cannot create a variable series iterator for a non-variable series"
+      );
+    this.series = e, this.index = 0, this.decoder = new TextDecoder();
+  }
+  next() {
+    const e = this.index, t = this.series.data;
+    for (; this.index < t.length && t[this.index] !== Et; ) this.index++;
+    const n = this.index;
+    return e === n ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(e, n)) });
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+};
+var pr, yr;
+const yn = class mn {
+  constructor(e) {
+    l(this, "wrapped"), l(this, pr, "JSONSeriesIterator"), this.wrapped = e;
+  }
+  next() {
+    const e = this.wrapped.next();
+    return e.done === !0 ? { done: !0, value: void 0 } : {
+      done: !1,
+      value: Ve.decodeString(e.value, mn.SCHEMA)
+    };
+  }
+  [(yr = Symbol.iterator, pr = Symbol.toStringTag, yr)]() {
+    return this;
+  }
+};
+l(yn, "SCHEMA", a.record(a.string(), a.unknown()));
+let na = yn;
+var mr, wr;
+class sa {
+  constructor(e) {
+    l(this, "series"), l(this, "index"), l(this, mr, "SeriesIterator"), this.series = e, this.index = 0;
+  }
+  next() {
+    return this.index >= this.series.length ? { done: !0, value: void 0 } : {
+      done: !1,
+      value: this.series.at(this.index++, !0)
+    };
+  }
+  [(wr = Symbol.iterator, mr = Symbol.toStringTag, wr)]() {
+    return this;
+  }
+}
+class ol {
+  constructor(e = []) {
+    if (l(this, "series"), e.length !== 0) {
+      const t = e[0].dataType;
+      for (let n = 1; n < e.length; n++)
+        if (!e[n].dataType.equals(t))
+          throw new Error("[multi-series] - series must have the same data type");
+    }
+    this.series = e;
+  }
+  as(e) {
+    return pn(e, this.dataType), this;
+  }
+  get dataType() {
+    return this.series.length === 0 ? w.UNKNOWN : this.series[0].dataType;
+  }
+  get timeRange() {
+    return this.series.length === 0 ? re.ZERO : new re(
+      this.series[0].timeRange.start,
+      this.series[this.series.length - 1].timeRange.end
+    );
+  }
+  get alignment() {
+    return this.series.length === 0 ? 0n : this.series[0].alignment;
+  }
+  get alignmentBounds() {
+    return this.series.length === 0 ? m(0n, 0n) : m(
+      this.series[0].alignmentBounds.lower,
+      this.series[this.series.length - 1].alignmentBounds.upper
+    );
+  }
+  push(e) {
+    "isSynnaxSeries" in e && e.isSynnaxSeries ? this.series.push(e) : this.series.push(...e.series);
+  }
+  get length() {
+    return this.series.reduce((e, t) => e + t.length, 0);
+  }
+  atAlignment(e, t) {
+    if (this.series.length === 0) {
+      if (t) throw new Error(`[series] - no value at alignment ${e}`);
+      return;
+    }
+    for (const n of this.series)
+      if (C(n.alignmentBounds, e))
+        return n.atAlignment(e, t);
+    if (t) throw new Error(`[series] - no value at alignment ${e}`);
+  }
+  at(e, t = !1) {
+    e < 0 && (e = this.length + e);
+    for (const n of this.series) {
+      if (e < n.length) return n.at(e, t);
+      e -= n.length;
+    }
+    if (t) throw new Error(`[series] - no value at index ${e}`);
+  }
+  subIterator(e, t) {
+    return new ht(this, e, t ?? this.length);
+  }
+  subAlignmentIterator(e, t) {
+    if (e >= this.alignmentBounds.upper || t <= this.alignmentBounds.lower)
+      return Bt;
+    let n = 0;
+    for (let i = 0; i < this.series.length; i++) {
+      const o = this.series[i];
+      if (e < o.alignment) break;
+      if (e >= o.alignmentBounds.upper) n += o.length;
+      else if (C(o.alignmentBounds, e)) {
+        n += Number(e - o.alignment);
+        break;
+      }
+    }
+    let s = 0;
+    for (let i = 0; i < this.series.length; i++) {
+      const o = this.series[i];
+      if (t < o.alignment) break;
+      if (t >= o.alignmentBounds.upper) s += o.length;
+      else if (C(o.alignmentBounds, t)) {
+        s += Number(t - o.alignment);
+        break;
+      }
+    }
+    return new ht(this, n, s);
+  }
+  subAlignmentSpanIterator(e, t) {
+    if (e >= this.alignmentBounds.upper) return Bt;
+    let n = 0;
+    for (let s = 0; s < this.series.length; s++) {
+      const i = this.series[s];
+      if (e < i.alignment) break;
+      if (e >= i.alignmentBounds.upper) n += i.length;
+      else if (C(i.alignmentBounds, e)) {
+        n += Number(e - i.alignment);
+        break;
+      }
+    }
+    return new ht(this, n, n + t);
+  }
+  updateGLBuffer(e) {
+    this.series.forEach((t) => t.updateGLBuffer(e));
+  }
+  get bounds() {
+    return Mr(this.series.map((e) => e.bounds));
+  }
+  get byteLength() {
+    return new Ke(this.series.reduce((e, t) => e + t.byteLength.valueOf(), 0));
+  }
+  get data() {
+    const e = new this.dataType.Array(this.length);
+    let t = 0;
+    for (const n of this.series)
+      e.set(n.data, t), t += n.length;
+    return new this.dataType.Array(e.buffer);
+  }
+  traverseAlignment(e, t) {
+    const n = this.series.map((s) => s.alignmentBounds);
+    return Cr(n, e, t);
+  }
+  acquire() {
+    this.series.forEach((e) => e.acquire());
+  }
+  release() {
+    this.series.forEach((e) => e.release());
+  }
+  distance(e, t) {
+    const n = this.series.map((s) => s.alignmentBounds);
+    return Lr(n, e, t);
+  }
+  parseJSON(e) {
+    if (!this.dataType.equals(w.JSON))
+      throw new Error("cannot parse non-JSON series as JSON");
+    return this.series.flatMap((t) => t.parseJSON(e));
+  }
+  [Symbol.iterator]() {
+    return this.series.length === 0 ? {
+      next() {
+        return { done: !0, value: void 0 };
+      }
+    } : new ia(this.series);
+  }
+}
+var br, vr;
+let ia = class {
+  constructor(e) {
+    l(this, "series"), l(this, "seriesIndex"), l(this, "internal"), l(this, br, "MultiSeriesIterator"), this.series = e, this.seriesIndex = 0, this.internal = e[0][Symbol.iterator]();
+  }
+  next() {
+    const e = this.internal.next();
+    return e.done === !1 ? e : this.seriesIndex === this.series.length - 1 ? { done: !0, value: void 0 } : (this.internal = this.series[++this.seriesIndex][Symbol.iterator](), this.next());
+  }
+  [(vr = Symbol.iterator, br = Symbol.toStringTag, vr)]() {
+    return this;
+  }
+}, ht = class {
+  constructor(e, t, n) {
+    l(this, "series"), l(this, "index"), l(this, "end"), this.series = e, this.end = n, this.index = t;
+  }
+  next() {
+    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+};
+const $r = (r) => {
+  const e = r >> 32n, t = r & 0xffffffffn;
+  return { domain: e, sample: t };
+}, oa = (r, e, t = ".") => {
+  const n = r.split(t);
+  return n.map((s, i) => {
+    const o = e(s, i, n);
+    return o == null ? null : typeof o == "string" ? o : o.join(t);
+  }).filter((s) => s != null).join(t);
+}, wn = (r, e, t = { optional: !1, separator: "." }) => {
+  t.separator ?? (t.separator = ".");
+  const { optional: n, getter: s = (u, h) => u[h] } = t, i = e.split(t.separator);
+  if (i.length === 1 && i[0] === "") return r;
+  let o = r;
+  for (const u of i) {
+    const h = s(o, u);
+    if (h == null) {
+      if (n) return null;
+      throw new Error(`Path ${e} does not exist. ${u} is null`);
+    }
+    o = h;
+  }
+  return o;
+}, ll = (r, e, t) => {
+  const n = e.split(".");
+  let s = r;
+  for (let i = 0; i < n.length - 1; i++) {
+    const o = n[i];
+    s[o] ?? (s[o] = {}), s = s[o];
+  }
+  try {
+    s[n[n.length - 1]] = t;
+  } catch (i) {
+    throw console.error("failed to set value", t, "at path", e, "on object", r), i;
+  }
+}, hl = (r, e) => {
+  const t = e.split(".");
+  let n = r;
+  for (let s = 0; s < t.length - 1; s++) {
+    const i = t[s];
+    if (n[i] == null) return;
+    n = n[i];
+  }
+  if (Array.isArray(n)) {
+    const s = parseInt(t[t.length - 1]);
+    if (isNaN(s)) return;
+    n.splice(s, 1);
+    return;
+  }
+  delete n[t[t.length - 1]];
+}, cl = (r, e) => {
+  const t = r.split(".");
+  return e < 0 ? t[t.length + e] : t[e];
+}, fl = (r, e) => {
+  try {
+    return wn(r, e), !0;
+  } catch {
+    return !1;
+  }
+}, dl = (r, e) => {
+  if (e.length === 0) return !0;
+  const t = r.split("."), n = e.split(".");
+  if (n.length > t.length) return !1;
+  for (let s = 0; s < n.length; s++) {
+    const i = t[s], o = n[s];
+    if (o !== "*" && i !== o)
+      return !1;
+  }
+  return !0;
+};
+a.object({ key: a.string(), value: a.string() });
+const gl = a.record(
+  a.union([a.number(), a.string(), a.symbol()]),
+  a.unknown()
+), bn = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", aa = bn(), vn = ["macOS", "Windows", "Linux"], ua = ["macos", "windows", "linux"], la = {
+  macos: "macOS",
+  windows: "Windows",
+  linux: "Linux"
+}, ha = a.enum(vn).or(
+  a.enum(ua).transform((r) => la[r])
+), ca = () => {
+  if (typeof window > "u") return;
+  const r = window.navigator.userAgent.toLowerCase();
+  if (r.includes("mac")) return "macOS";
+  if (r.includes("win")) return "Windows";
+  if (r.includes("linux")) return "Linux";
+};
+let ct;
+const fa = (r = {}) => {
+  const { force: e, default: t } = r;
+  return e ?? ct ?? (ct = ca(), ct ?? t);
+}, pl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  OPERATING_SYSTEMS: vn,
+  RUNTIME: aa,
+  detect: bn,
+  getOS: fa,
+  osZ: ha
+}, Symbol.toStringTag, { value: "Module" }));
+var da = Object.defineProperty, ga = (r, e, t) => e in r ? da(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, ve = (r, e, t) => ga(r, typeof e != "symbol" ? e + "" : e, t);
+const pa = (...r) => r.map($n).join(""), $n = (r) => (r.endsWith("/") || (r += "/"), r.startsWith("/") && (r = r.slice(1)), r), ya = (r) => r.endsWith("/") ? r.slice(0, -1) : r, xr = class At {
+  /**
+   * @param host - The hostname or IP address of the server.
+   * @param port - The port number of the server.
+   * @param protocol - The protocol to use for all requests. Defaults to "".
+   * @param pathPrefix - A path prefix to use for all requests. Defaults to "".
+   */
+  constructor({ host: e, port: t, protocol: n = "", pathPrefix: s = "" }) {
+    ve(this, "protocol"), ve(this, "host"), ve(this, "port"), ve(this, "path"), this.protocol = n, this.host = e, this.port = t, this.path = $n(s);
+  }
+  /**
+   * Replaces creates a new URL with the specified properties replaced.
+   * @param props - The properties to replace.
+   * @returns a new URL.
+   */
+  replace(e) {
+    return new At({
+      host: e.host ?? this.host,
+      port: e.port ?? this.port,
+      protocol: e.protocol ?? this.protocol,
+      pathPrefix: e.pathPrefix ?? this.path
+    });
+  }
+  /**
+   * Creates a new url with the given path appended to the current path.
+   * @param path - the path to append to the URL.
+   * @returns a new URL.
+   */
+  child(e) {
+    return new At({
+      ...this,
+      pathPrefix: pa(this.path, e)
+    });
+  }
+  /** @returns a string representation of the url */
+  toString() {
+    return ya(
+      `${this.protocol}://${this.host}:${this.port}/${this.path}`
+    );
+  }
+};
+ve(xr, "UNKNOWN", new xr({ host: "unknown", port: 0 }));
+const ma = -128, wa = 127, ba = a.number().int().min(ma).max(wa), va = -32768, $a = 32767, xa = a.number().int().min(va).max($a), Oa = -2147483648, Ta = 2147483647, Sa = a.number().int().min(Oa).max(Ta), Ia = -9223372036854775808n, Na = 9223372036854775807n, Ua = a.bigint().min(Ia).max(Na), Ba = 255, Ea = a.number().int().min(0).max(Ba), Aa = 65535, Ma = a.number().int().min(0).max(Aa), Ca = 4294967295, La = a.number().int().min(0).max(Ca), Ra = 18446744073709551615n, ja = a.bigint().min(0n).max(Ra), xn = (r) => oa(r, (e, t, n) => {
+  const s = t === n.length - 1, i = !isNaN(parseInt(e)), o = !isNaN(parseInt(n[t + 1]));
+  return i && (e = "element"), s || o ? e : [e, "shape"];
+}), Or = (r, e) => {
+  if (r == null) return null;
+  const t = r[e];
+  return t == null && typeof r == "object" && "sourceType" in r ? r.sourceType()[e] : t;
+}, ka = (r, e, t) => wn(
+  Or(r, "shape"),
+  xn(e),
+  { ...t, getter: Or }
+), yl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getFieldSchema: ka,
+  getFieldSchemaPath: xn,
+  int16: xa,
+  int32: Sa,
+  int64: Ua,
+  int8: ba,
+  uint16: Ma,
+  uint32: La,
+  uint64: ja,
+  uint8: Ea
+}, Symbol.toStringTag, { value: "Module" }));
+var Da = Object.defineProperty, Pa = (r, e, t) => e in r ? Da(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, Q = (r, e, t) => Pa(r, typeof e != "symbol" ? e + "" : e, t);
+const za = 2, Fa = 3, _a = 2, qa = (r, e) => {
+  if (Number.isNaN(r) || !Number.isFinite(r)) return r;
+  const t = Me(e);
+  if (t == 0) return r;
+  let n;
+  t >= 1e3 ? n = za : t >= 1 ? n = Fa : n = Math.ceil(-Math.log10(t)) + _a;
+  const s = 10 ** n;
+  return Math.round(r * s) / s;
+}, ml = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  abs: Ar,
+  add: Br,
+  closeTo: Qn,
+  div: rs,
+  equal: gt,
+  max: ts,
+  min: Er,
+  mult: X,
+  roundBySpan: qa,
+  roundToNearestMagnitude: es,
+  sub: $e
+}, Symbol.toStringTag, { value: "Module" }));
+a.object({
+  baseInterval: O.z.optional(),
+  maxRetries: a.number().optional(),
+  scale: a.number().optional()
+});
+const Wa = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i, nr = a.string().regex(Wa), oe = a.number().min(0).max(255), Va = a.number().min(0).max(1), sr = a.tuple([oe, oe, oe, Va]), On = a.tuple([oe, oe, oe]), Ya = (r) => Le.safeParse(r).success, Za = (r) => sr.safeParse(r).success, Ha = (r) => {
+  if (r == null) return;
+  const e = Le.safeParse(r);
+  if (e.success) return In(e.data);
+  if (typeof r == "string") return r;
+  throw e.error;
+}, $ = (r, e = 1) => {
+  if (typeof r == "string") return nu(r, e);
+  if (Array.isArray(r)) {
+    if (r.length < 3 || r.length > 4)
+      throw new Error(`Invalid color: [${r.join(", ")}]`);
+    return r.length === 3 ? [...r, e] : r;
+  }
+  throw new Error(`Invalid color: ${JSON.stringify(r)}`);
+}, Tn = (r, e) => {
+  if (r == null || e == null) return !1;
+  const t = $(r), n = $(e);
+  return t.every((s, i) => s === n[i]);
+}, Sn = (r) => {
+  if (r == null) return;
+  const [e, t, n, s] = $(r);
+  return `#${ze(e)}${ze(t)}${ze(n)}${s === 1 ? "" : ze(s * 255)}`;
+}, In = (r) => {
+  const [e, t, n, s] = $(r);
+  return `rgba(${e}, ${t}, ${n}, ${s})`;
+}, Ga = (r) => `rgb(${Nn(r)})`, Nn = (r) => {
+  const [e, t, n] = $(r);
+  return `${e}, ${t}, ${n}`;
+}, Ka = (r) => [...ir(r), Ie(r)], ir = (r) => [
+  Oe(r) / 255,
+  Te(r) / 255,
+  Se(r) / 255
+], Oe = (r) => $(r)[0], Te = (r) => $(r)[1], Se = (r) => $(r)[2], Ie = (r) => $(r)[3], Ja = (r) => Tn(or, r), Xa = (r) => ou($(r)), Qa = (r, e) => {
+  const [t, n, s] = $(r);
+  if (e > 100)
+    throw new Error(`Color opacity must be between 0 and 100, got ${e}`);
+  return e > 1 && (e /= 100), [t, n, s, e];
+}, Je = (r) => {
+  const [e, t, n] = ir(r).map(
+    (s) => s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4
+  );
+  return Number((0.2126 * e + 0.7152 * t + 0.0722 * n).toFixed(3));
+}, eu = (r) => {
+  const [e, t, n] = ir(r);
+  return 1 - (Math.max(e, t, n) - Math.min(e, t, n));
+}, Mt = (r, e) => {
+  const t = $(r), n = $(e), s = Je(t), i = Je(n);
+  return (Math.max(s, i) + 0.5) / (Math.min(s, i) + 0.5);
+}, tu = (r, ...e) => {
+  if (e.length === 0)
+    throw new Error("[Color.pickByContrast] - must provide at least one color");
+  const t = $(r), [n] = e.map((s) => $(s)).sort((s, i) => Mt(t, i) - Mt(t, s));
+  return n;
+}, Un = (r) => Je(r) < 0.5, ru = (r) => !Un(r), Le = a.union([nr, sr, On]).transform((r) => $(r)), nu = (r, e = 1) => {
+  if (!nr.safeParse(r).success) throw new Error(`Invalid hex color: ${r}`);
+  return r = su(r), [
+    Fe(r, 0),
+    Fe(r, 2),
+    Fe(r, 4),
+    r.length === 8 ? Fe(r, 6) / 255 : e
+  ];
+}, or = [0, 0, 0, 0], ze = (r) => Math.floor(r).toString(16).padStart(2, "0"), Fe = (r, e) => parseInt(r.slice(e, e + 2), 16), su = (r) => r.startsWith("#") ? r.slice(1) : r, iu = (r) => {
+  let [e, t, n] = r;
+  const s = r[3];
+  e /= 360, t /= 100, n /= 100;
+  let i, o, u;
+  if (t === 0)
+    i = o = u = n;
+  else {
+    const h = n < 0.5 ? n * (1 + t) : n + t - n * t, f = 2 * n - h;
+    i = ft(f, h, e + 1 / 3), o = ft(f, h, e), u = ft(f, h, e - 1 / 3);
+  }
+  return [Math.round(i * 255), Math.round(o * 255), Math.round(u * 255), s];
+}, ft = (r, e, t) => (t < 0 && (t += 1), t > 1 && (t -= 1), t < 1 / 6 ? r + (e - r) * 6 * t : t < 1 / 2 ? e : t < 2 / 3 ? r + (e - r) * (2 / 3 - t) * 6 : r), ou = (r) => {
+  let [e, t, n] = r;
+  const s = r[3];
+  e /= 255, t /= 255, n /= 255;
+  const i = Math.max(e, t, n), o = Math.min(e, t, n);
+  let u, h, f = (i + o) / 2;
+  if (i === o)
+    u = h = 0;
+  else {
+    const g = i - o;
+    h = f > 0.5 ? g / (2 - i - o) : g / (i + o), i === e ? u = (t - n) / g + (t < n ? 6 : 0) : i === t ? u = (n - e) / g + 2 : u = (e - t) / g + 4, u /= 6;
+  }
+  return u *= 360, h *= 100, f *= 100, [Math.round(u), Math.round(h), Math.round(f), s];
+}, Bn = a.union([nr, sr, a.string(), On]), au = $("#000000"), uu = $("#ffffff"), En = a.object({
+  key: a.string(),
+  color: Bn,
+  position: a.number(),
+  switched: a.boolean().optional()
+}), lu = a.array(En), hu = (r, e) => {
+  if (r.length === 0) return or;
+  if (r = r.slice().sort((t, n) => t.position - n.position), e <= r[0].position) return $(r[0].color);
+  if (e >= r[r.length - 1].position)
+    return $(r[r.length - 1].color);
+  for (let t = 0; t < r.length - 1; t++) {
+    const n = r[t], s = r[t + 1];
+    if (e >= n.position && e <= s.position) {
+      if (e === n.position) return $(n.color);
+      if (e === s.position) return $(s.color);
+      const i = (e - n.position) / (s.position - n.position), o = $(n.color), u = $(s.color), h = Math.round(
+        Oe(o) + i * (Oe(u) - Oe(o))
+      ), f = Math.round(
+        Te(o) + i * (Te(u) - Te(o))
+      ), g = Math.round(
+        Se(o) + i * (Se(u) - Se(o))
+      ), d = Ie(o) + i * (Ie(u) - Ie(o));
+      return $([h, f, g, d]);
+    }
+  }
+  return $(r[r.length - 1].color);
+}, cu = a.object({
+  key: a.string(),
+  name: a.string(),
+  color: Le
+}), fu = a.object({
+  key: a.string(),
+  name: a.string(),
+  swatches: a.array(cu)
+}), An = (r) => {
+  const e = Le.safeParse(r);
+  if (e.success) return Sn(e.data);
+  if (typeof r == "object" && r != null) {
+    const t = Array.isArray(r) ? [] : {};
+    for (const n of Object.keys(r))
+      t[n] = An(r[n]);
+    return t;
+  }
+  return r;
+}, wl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BLACK: au,
+  WHITE: uu,
+  ZERO: or,
+  aValue: Ie,
+  bValue: Se,
+  colorZ: Le,
+  construct: $,
+  contrast: Mt,
+  crudeZ: Bn,
+  cssString: Ha,
+  equals: Tn,
+  fromGradient: hu,
+  fromHSLA: iu,
+  gValue: Te,
+  gradientZ: lu,
+  grayness: eu,
+  hex: Sn,
+  hsla: Xa,
+  isColor: Za,
+  isCrude: Ya,
+  isDark: Un,
+  isLight: ru,
+  isZero: Ja,
+  luminance: Je,
+  paletteZ: fu,
+  pickByContrast: tu,
+  rValue: Oe,
+  rgbCSS: Ga,
+  rgbString: Nn,
+  rgba1: Ka,
+  rgbaCSS: In,
+  setAlpha: Qa,
+  stopZ: En,
+  transformColorsToHex: An
+}, Symbol.toStringTag, { value: "Module" })), Mn = a.number().int().min(0).max(255), Cn = 255, Ln = 0, du = {
+  lower: Ln,
+  upper: Cn + 1
+}, Rn = a.object({
+  name: a.string(),
+  key: a.string()
+}), Ae = (r) => a.object({
+  subject: Rn,
+  resource: r,
+  authority: Mn
+}), gu = (...r) => (e) => e.filter((t) => {
+  let n = !1;
+  return t.to != null && (n = r.includes(t.to.resource)), t.from != null && !n && (n = r.includes(t.from.resource)), n;
+}), jn = a.object({
+  from: Ae(a.any()),
+  to: a.null()
+}), kn = a.object({
+  from: a.null(),
+  to: Ae(a.any())
+}), pu = a.union([
+  jn,
+  kn,
+  a.object({
+    from: Ae(a.any()),
+    to: Ae(a.any())
+  })
+]), bl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ABSOLUTE_AUTHORITY: Cn,
+  AUTHORITY_BOUNDS: du,
+  ZERO_AUTHORITY: Ln,
+  acquireZ: kn,
+  authorityZ: Mn,
+  filterTransfersByChannelKey: gu,
+  releaseZ: jn,
+  stateZ: Ae,
+  subjectZ: Rn,
+  transferZ: pu
+}, Symbol.toStringTag, { value: "Module" })), yu = (r) => Object.getOwnPropertySymbols(globalThis).includes(r), mu = (r, e) => {
+  const t = Symbol.for(r);
+  if (!yu(t)) {
+    const n = e();
+    Object.defineProperty(globalThis, t, { value: n });
+  }
+  return () => globalThis[t];
+}, wu = (r) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.startsWith(r) : e instanceof Error ? e.message.startsWith(r) : typeof e != "string" ? !1 : e.startsWith(r), ar = (r) => {
+  var e;
+  return e = class extends Error {
+    constructor(t, n) {
+      super(t, n), Q(this, "discriminator", e.discriminator), Q(this, "type", e.TYPE), Q(this, "matches", e.matches), this.name = e.TYPE;
+    }
+    static sub(t) {
+      return ar(`${r}.${t}`);
+    }
+  }, Q(e, "discriminator", "FreighterError"), Q(e, "TYPE", r), Q(e, "matches", wu(r)), e;
+}, bu = (r) => {
+  if (r == null || typeof r != "object") return !1;
+  const e = r;
+  if (e.discriminator !== "FreighterError") return !1;
+  if (!("type" in e))
+    throw new Error(
+      `Freighter error is missing its type property: ${JSON.stringify(e)}`
+    );
+  return !0;
+}, ce = "unknown", Tr = "nil";
+class vu {
+  constructor() {
+    Q(this, "providers", []);
+  }
+  register(e) {
+    this.providers.push(e);
+  }
+  encode(e) {
+    if (e == null) return { type: Tr, data: "" };
+    if (bu(e))
+      for (const t of this.providers) {
+        const n = t.encode(e);
+        if (n != null) return n;
+      }
+    if (e instanceof Error) return { type: ce, data: e.message };
+    if (typeof e == "string") return { type: ce, data: e };
+    try {
+      return { type: ce, data: JSON.stringify(e) };
+    } catch {
+      return { type: ce, data: "unable to encode error information" };
+    }
+  }
+  decode(e) {
+    if (e == null || e.type === Tr) return null;
+    if (e.type === ce) return new Sr(e.data);
+    for (const t of this.providers) {
+      const n = t.decode(e);
+      if (n != null) return n;
+    }
+    return new Sr(e.data);
+  }
+}
+mu("synnax-error-registry", () => new vu());
+class Sr extends ar("unknown") {
+}
+a.object({ type: a.string(), data: a.string() });
+class vl extends ar("canceled") {
+}
+const $l = (r) => r ? -1 : 1;
+se.object({
+  jsonrpc: se.string(),
+  id: se.number().optional(),
+  method: se.string().optional(),
+  params: se.unknown().optional(),
+  result: se.unknown().optional()
+});
+const Ct = a.string().regex(/^\d+\.\d+\.\d+$/), Re = (r, e, t = {}) => {
+  t.checkMajor ?? (t.checkMajor = !0), t.checkMinor ?? (t.checkMinor = !0), t.checkPatch ?? (t.checkPatch = !0);
+  const n = Ct.parse(r), s = Ct.parse(e), [i, o, u] = n.split(".").map(Number), [h, f, g] = s.split(".").map(Number);
+  if (t.checkMajor) {
+    if (i < h) return Ye;
+    if (i > h) return Ze;
+  }
+  if (t.checkMinor) {
+    if (o < f) return Ye;
+    if (o > f) return Ze;
+  }
+  if (t.checkPatch) {
+    if (u < g) return Ye;
+    if (u > g) return Ze;
+  }
+  return ae;
+}, $u = (r, e, t = {}) => cn(Re(r, e, t)), Dn = (r, e, t = {}) => hn(Re(r, e, t)), xu = (r, e, t = {}) => ln(Re(r, e, t)), Ou = ({
+  name: r,
+  migrate: e
+}) => (t) => {
+  try {
+    const n = e(t);
+    return console.log(`${r} migrated: ${t.version} -> ${n.version}`), n;
+  } catch (n) {
+    throw console.log(`${r} failed to migrate from ${t.version}`), console.error(n), n;
+  }
+}, Tu = ({
+  name: r,
+  migrations: e,
+  targetSchema: t,
+  defaultVersion: n,
+  def: s
+}) => {
+  const i = Object.keys(e).sort(Re).pop();
+  if (i == null)
+    return (f) => {
+      if (f.version ?? (f.version = n), f.version !== s.version)
+        return console.log(
+          `${r} version ${f.version} is newer than latest version of ${s.version}.
+          Returning default instead.
+          `
+        ), s;
+      try {
+        return t != null ? t.parse(f) : f;
+      } catch (g) {
+        return console.log(`${r} failed to parse default. Exiting with default`), console.error(g), s;
+      }
+    };
+  const o = Object.keys(e).length;
+  let u = !1;
+  const h = (f) => {
+    try {
+      if (o === 0 || Dn(f.version, i))
+        return console.log(u ? `${r} ${f.version} now up to date` : `${r} version ${f.version} is up to date with target version ${s.version}`), f;
+      const g = f.version, d = e[g], B = d(f);
+      return u = !0, h(B);
+    } catch (g) {
+      return console.log(
+        `${r} failed to migrate from ${f.version} to ${i}`
+      ), console.error(g), s;
+    }
+  };
+  return (f) => {
+    try {
+      if (f.version == null)
+        if (n != null)
+          console.log(
+            `${r} version is null. Setting version to default of ${n}`
+          ), f.version = n;
+        else
+          return console.log(
+            `${r} version is null and no default version set. Exiting with default`
+          ), s;
+      return h(f);
+    } catch (g) {
+      return console.log(`${r} failed to parse final result. Exiting with default`), console.error(g), s;
+    }
+  };
+}, xl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  compareSemVer: Re,
+  createMigration: Ou,
+  migrator: Tu,
+  semVerNewer: Dn,
+  semVerOlder: xu,
+  semVerZ: Ct,
+  versionsEqual: $u
+}, Symbol.toStringTag, { value: "Module" })), Pn = ["standard", "scientific", "engineering"], Su = a.enum(Pn), Iu = (r, e, t) => {
+  if (Number.isNaN(r)) return "NaN";
+  if (r === 1 / 0) return "∞";
+  if (r === -1 / 0) return "-∞";
+  if (t === "standard") return r.toFixed(e);
+  if (r === 0)
+    return e === 0 ? "0ᴇ0" : `0.${"0".repeat(e)}ᴇ0`;
+  let n;
+  return t === "scientific" ? n = Math.floor(Math.log10(Math.abs(r))) : n = Math.floor(Math.log10(Math.abs(r)) / 3) * 3, `${(r / 10 ** n).toFixed(e)}ᴇ${n}`;
+}, Ol = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NOTATIONS: Pn,
+  notationZ: Su,
+  stringifyNumber: Iu
+}, Symbol.toStringTag, { value: "Module" })), Tl = (r) => {
+  if (r === void 0 || typeof r == "string" || typeof r == "number")
+    return r;
+  if (r.toString === void 0) throw new Error("invalid renderer");
+  return r.toString();
+}, Sl = (r) => Array.isArray(r) ? [...r] : typeof r == "object" && r !== null ? { ...r } : r, Nu = new Error("request for lock canceled");
+var Uu = function(r, e, t, n) {
+  function s(i) {
+    return i instanceof t ? i : new t(function(o) {
+      o(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, o) {
+    function u(g) {
+      try {
+        f(n.next(g));
+      } catch (d) {
+        o(d);
+      }
+    }
+    function h(g) {
+      try {
+        f(n.throw(g));
+      } catch (d) {
+        o(d);
+      }
+    }
+    function f(g) {
+      g.done ? i(g.value) : s(g.value).then(u, h);
+    }
+    f((n = n.apply(r, e || [])).next());
+  });
+};
+class Bu {
+  constructor(e, t = Nu) {
+    this._value = e, this._cancelError = t, this._queue = [], this._weightedWaiters = [];
+  }
+  acquire(e = 1, t = 0) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    return new Promise((n, s) => {
+      const i = { resolve: n, reject: s, weight: e, priority: t }, o = zn(this._queue, (u) => t <= u.priority);
+      o === -1 && e <= this._value ? this._dispatchItem(i) : this._queue.splice(o + 1, 0, i);
+    });
+  }
+  runExclusive(e) {
+    return Uu(this, arguments, void 0, function* (t, n = 1, s = 0) {
+      const [i, o] = yield this.acquire(n, s);
+      try {
+        return yield t(i);
+      } finally {
+        o();
+      }
+    });
+  }
+  waitForUnlock(e = 1, t = 0) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    return this._couldLockImmediately(e, t) ? Promise.resolve() : new Promise((n) => {
+      this._weightedWaiters[e - 1] || (this._weightedWaiters[e - 1] = []), Eu(this._weightedWaiters[e - 1], { resolve: n, priority: t });
+    });
+  }
+  isLocked() {
+    return this._value <= 0;
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(e) {
+    this._value = e, this._dispatchQueue();
+  }
+  release(e = 1) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    this._value += e, this._dispatchQueue();
+  }
+  cancel() {
+    this._queue.forEach((e) => e.reject(this._cancelError)), this._queue = [];
+  }
+  _dispatchQueue() {
+    for (this._drainUnlockWaiters(); this._queue.length > 0 && this._queue[0].weight <= this._value; )
+      this._dispatchItem(this._queue.shift()), this._drainUnlockWaiters();
+  }
+  _dispatchItem(e) {
+    const t = this._value;
+    this._value -= e.weight, e.resolve([t, this._newReleaser(e.weight)]);
+  }
+  _newReleaser(e) {
+    let t = !1;
+    return () => {
+      t || (t = !0, this.release(e));
+    };
+  }
+  _drainUnlockWaiters() {
+    if (this._queue.length === 0)
+      for (let e = this._value; e > 0; e--) {
+        const t = this._weightedWaiters[e - 1];
+        t && (t.forEach((n) => n.resolve()), this._weightedWaiters[e - 1] = []);
+      }
+    else {
+      const e = this._queue[0].priority;
+      for (let t = this._value; t > 0; t--) {
+        const n = this._weightedWaiters[t - 1];
+        if (!n)
+          continue;
+        const s = n.findIndex((i) => i.priority <= e);
+        (s === -1 ? n : n.splice(0, s)).forEach((i) => i.resolve());
+      }
+    }
+  }
+  _couldLockImmediately(e, t) {
+    return (this._queue.length === 0 || this._queue[0].priority < t) && e <= this._value;
+  }
+}
+function Eu(r, e) {
+  const t = zn(r, (n) => e.priority <= n.priority);
+  r.splice(t + 1, 0, e);
+}
+function zn(r, e) {
+  for (let t = r.length - 1; t >= 0; t--)
+    if (e(r[t]))
+      return t;
+  return -1;
+}
+var Au = function(r, e, t, n) {
+  function s(i) {
+    return i instanceof t ? i : new t(function(o) {
+      o(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, o) {
+    function u(g) {
+      try {
+        f(n.next(g));
+      } catch (d) {
+        o(d);
+      }
+    }
+    function h(g) {
+      try {
+        f(n.throw(g));
+      } catch (d) {
+        o(d);
+      }
+    }
+    function f(g) {
+      g.done ? i(g.value) : s(g.value).then(u, h);
+    }
+    f((n = n.apply(r, e || [])).next());
+  });
+};
+class Mu {
+  constructor(e) {
+    this._semaphore = new Bu(1, e);
+  }
+  acquire() {
+    return Au(this, arguments, void 0, function* (e = 0) {
+      const [, t] = yield this._semaphore.acquire(1, e);
+      return t;
+    });
+  }
+  runExclusive(e, t = 0) {
+    return this._semaphore.runExclusive(() => e(), 1, t);
+  }
+  isLocked() {
+    return this._semaphore.isLocked();
+  }
+  waitForUnlock(e = 0) {
+    return this._semaphore.waitForUnlock(1, e);
+  }
+  release() {
+    this._semaphore.isLocked() && this._semaphore.release();
+  }
+  cancel() {
+    return this._semaphore.cancel();
+  }
+}
+class ot extends Mu {
+  static new(e) {
+    return new ot(e);
+  }
+  constructor(e) {
+    super(), Object.assign(this, e);
+  }
+}
+const Cu = (r) => new ot(r), Il = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  mutex: ot,
+  newMutex: Cu
+}, Symbol.toStringTag, { value: "Module" }));
+class Lu {
+  constructor(e = "") {
+    je(this, "rows", []);
+    je(this, "columns", []);
+    je(this, "prefix");
+    this.prefix = e;
+  }
+  row(e, t, n) {
+    const { prefix: s } = this;
+    return this.rows.push({ startLabel: s + e, endLabel: s + t, size: n }), this;
+  }
+  col(e, t, n) {
+    const { prefix: s } = this;
+    return this.columns.push({ startLabel: s + e, endLabel: s + t, size: n }), this;
+  }
+  build() {
+    return {
+      display: "grid",
+      gridTemplateRows: this.rows.map((e, t) => {
+        let n = t === 0 ? "[" : "";
+        return n += `${e.startLabel}] ${e.size}${typeof e.size == "number" ? "px" : ""} [${e.endLabel}`, n += t === this.rows.length - 1 ? "]" : "", n;
+      }).join(" "),
+      gridTemplateColumns: this.columns.map((e, t) => {
+        let n = t === 0 ? "[" : "";
+        return n += `${e.startLabel}] ${e.size}${typeof e.size == "number" ? "px" : ""} [${e.endLabel}`, n += t === this.columns.length - 1 ? "]" : "", n;
+      }).join(" ")
+    };
+  }
+}
+const Ru = (r, e) => Object.entries(e).forEach(
+  ([t, n]) => n != null && r.style.setProperty(t, `${n}`)
+), ju = (r, e) => Array.from(r.style).forEach((t) => {
+  t.startsWith(e) && r.style.removeProperty(t);
+}), ku = (r) => {
+  const e = Jr(r);
+  return e.visible = (t) => e.M(t ? "visible" : "hidden"), e.expanded = (t) => e.M(t ? "expanded" : "collapsed"), e.loc = (t) => e.M(Fs.construct(t)), e.disabled = (t) => t === !0 && e.M("disabled"), e.align = (t) => e.M(t), e.dir = (t) => t != null && e.M($s.construct(t)), e.size = (t) => typeof t == "string" && e.M(t), e.sharp = (t) => t !== !1 && e.M("sharp"), e.rounded = (t) => t !== !1 && e.M("rounded"), e.bordered = (t) => typeof t == "boolean" ? t && e.M("bordered") : t != null ? e.M(`bordered-${t.toString()}`) : e.M("bordered"), e.selected = (t) => t && e.M("selected"), e.altColor = (t) => t && e.M("alt-color"), e.editable = (t) => t && e.M("editable"), e.noSelect = e.M("no-select"), e.noWrap = (t) => t && e.M("no-wrap"), e.applyVars = Ru, e.removeVars = ju, e.newGridBuilder = (t) => new Lu(t), e.dropRegion = (t) => t && e.B("haul-drop-region"), e.px = (t) => `${t}px`, e.inheritDims = (t = !0) => t && e.M("inherit-dims"), e.shade = (t) => t != null && e.M(`shade-${t}`), e.shadeVar = (t) => {
+    if (t != null)
+      return `var(--${r}-gray-l${t})`;
+  }, e.levelSizeVar = (t) => `var(--${r}-${t}-size)`, e;
+}, Nl = ku("pluto");
+export {
+  qu as $,
+  Gi as A,
+  Kt as B,
+  Nl as C,
+  ks as D,
+  Ti as E,
+  el as F,
+  Sl as G,
+  Fu as H,
+  zu as I,
+  _u as J,
+  Fs as K,
+  tl as L,
+  Ii as M,
+  ol as N,
+  O,
+  Cs as P,
+  re as Q,
+  Qu as R,
+  pl as S,
+  Ce as T,
+  w as U,
+  nl as V,
+  dr as W,
+  ta as X,
+  Tl as Y,
+  Ol as Z,
+  Wu as _,
+  fl as a,
+  Ke as a0,
+  ml as a1,
+  Il as a2,
+  Pi as a3,
+  bl as a4,
+  xl as a5,
+  yl as a6,
+  A as a7,
+  Xu as b,
+  wn as c,
+  gl as d,
+  js as e,
+  ll as f,
+  $s as g,
+  hl as h,
+  zt as i,
+  S as j,
+  F as k,
+  G as l,
+  x as m,
+  Jr as n,
+  tr as o,
+  cl as p,
+  H as q,
+  Oi as r,
+  Vu as s,
+  J as t,
+  oa as u,
+  $l as v,
+  Rs as w,
+  Vt as x,
+  dl as y,
+  wl as z
+};