@synnaxlabs/pluto 0.43.1 → 0.44.1

package/dist/css-Dl9aM7Jz.js

@@ -0,0 +1,4337 @@
+import x, { z as a } from "zod";
+const tn = (t) => {
+  const e = t.replace(/_[a-z]/g, (r) => r[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);
+}, lt = (t) => {
+  const e = (r, n = Ge) => {
+    if (typeof r == "string") return t(r);
+    if (Array.isArray(r)) return r.map((o) => e(o, n));
+    if (!Fe(r)) return r;
+    n = sn(n);
+    const s = {}, i = r;
+    return "toJSON" in i && typeof i.toJSON == "function" ? e(i.toJSON(), n) : (Object.keys(i).forEach((o) => {
+      let c = i[o];
+      const l = t(o);
+      n.recursive && (Fe(c) ? Rt(c) || (c = e(c, n)) : n.recursiveInArray && jt(c) && (c = [...c].map((f) => {
+        let p = f;
+        return Fe(f) ? Rt(p) || (p = e(f, n)) : jt(f) && (p = e({ key: f }, n).key), p;
+      }))), s[l] = c;
+    }), s);
+  };
+  return e;
+}, ct = lt(tn), rn = (t) => (
+  // Don't convert the first character and don't convert a character that is after a
+  // non-alphanumeric character
+  t.replace(
+    /([a-z0-9])([A-Z])/g,
+    (e, r, n) => `${r}_${n.toLowerCase()}`
+  )
+), Ft = lt(rn), Zt = (t) => t.length === 0 ? t : t[0].toUpperCase() + t.slice(1), nn = [Number, String, Uint8Array], Ge = {
+  recursive: !0,
+  recursiveInArray: !0
+}, sn = (t = Ge) => (t.recursive == null ? t = Ge : t.recursiveInArray ??= !1, t), jt = (t) => t != null && Array.isArray(t), Fe = (t) => t != null && typeof t == "object" && !Array.isArray(t), Rt = (t) => nn.some((e) => t instanceof e), an = (t) => t.replace(/\s+/g, "-").replace(
+  /([a-z0-9])([A-Z])/g,
+  (e, r, n) => `${r}-${n.toLowerCase()}`
+).toLowerCase(), on = lt(an), uo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  camelToSnake: Ft,
+  capitalize: Zt,
+  snakeToCamel: ct,
+  toKebab: on
+}, Symbol.toStringTag, { value: "Module" }));
+let un = class {
+  contentType = "application/json";
+  decoder;
+  encoder;
+  constructor() {
+    this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
+  }
+  encode(e) {
+    return this.encoder.encode(this.encodeString(e));
+  }
+  decode(e, r) {
+    return this.decodeString(this.decoder.decode(e), r);
+  }
+  decodeString(e, r) {
+    const n = JSON.parse(e), s = ct(n);
+    return r != null ? r.parse(s) : s;
+  }
+  encodeString(e) {
+    const r = Ft(e);
+    return JSON.stringify(r, (n, s) => ArrayBuffer.isView(s) ? Array.from(s) : typeof s == "bigint" ? s.toString() : s);
+  }
+};
+const He = new un(), Je = (t) => [...new Set(t)], ln = (t, e, r = !0) => {
+  const n = /* @__PURE__ */ new Map();
+  return t.forEach((s) => {
+    const i = e(s);
+    if (n.has(i)) {
+      if (r) return;
+      n.delete(i);
+    }
+    n.set(i, s);
+  }), Array.from(n.values());
+}, co = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  by: ln,
+  unique: Je
+}, Symbol.toStringTag, { value: "Module" }));
+let J = class {
+  /** The underlying primitive value */
+  value;
+  constructor(e) {
+    this.value = e;
+  }
+  /** Overrides the JS default valueOf() function to return the primitive value. */
+  valueOf() {
+    return this.value;
+  }
+  /** toJSON ensures that only the primitive value gets encoded during JSON
+   * stringification. */
+  toJSON() {
+    return this.value;
+  }
+  /** @returns a string representation of the item. */
+  toString() {
+    return this.value.toString();
+  }
+};
+const ht = (t) => t != null && typeof t == "object" && "toString" in t, cn = (t) => {
+  if (ht(t)) return t?.toString().length === 0;
+  switch (typeof t) {
+    case "string":
+      return t.length === 0;
+    case "number":
+      return t === 0;
+    case "bigint":
+      return t === 0n;
+    case "boolean":
+      return !t;
+    case "undefined":
+      return !0;
+    case "object":
+      return t == null;
+    default:
+      return !1;
+  }
+}, fo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ValueExtension: J,
+  isStringer: ht,
+  isZero: cn
+}, Symbol.toStringTag, { value: "Module" })), Be = (t, e = !1) => {
+  const r = ht(t) ? "stringer" : typeof t;
+  let n;
+  switch (r) {
+    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 ${r}`), () => -1;
+  }
+  return e ? Vt(n) : n;
+}, hn = (t, e, r) => {
+  const n = Be(e[t], r);
+  return (s, i) => n(s[t], i[t]);
+}, fn = (t, e) => t.length !== e.length ? t.length - e.length : t.every((r, n) => r === e[n]) ? 0 : -1, Yt = (t, e) => {
+  if (t.length !== e.length) return t.length - e.length;
+  if (t.length === 0) return 0;
+  const r = Be(t[0]), n = [...t].sort(r), s = [...e].sort(r);
+  return n.every((i, o) => i === s[o]) ? 0 : -1;
+}, dn = (t, e) => {
+  const r = Je(t), n = Je(e);
+  return Yt(r, n);
+}, gn = (t, e) => t === e ? 0 : t === "first" && e === "last" ? 1 : -1, Vt = (t) => (e, r) => t(r, e), ee = 0, xe = -1, $e = 1, Wt = (t) => t < ee, Gt = (t) => t > ee, pn = (t) => t >= ee, Ht = (t) => t === ee, yn = (t, e) => {
+  const r = /([a-zA-Z]+)|(\d+)/g, n = t.replace(/[\s_.-]+/g, "").match(r), s = e.replace(/[\s_.-]+/g, "").match(r);
+  if (!n || !s) return 0;
+  for (let i = 0; i < Math.min(n.length, s.length); i++) {
+    const o = n[i], c = s[i];
+    if (isNaN(Number(o)) && isNaN(Number(c))) {
+      const l = o.localeCompare(c);
+      if (l !== 0) return l;
+    } else if (!isNaN(Number(o)) && !isNaN(Number(c))) {
+      const l = Number(o) - Number(c);
+      if (l !== 0) return l;
+    } else return isNaN(Number(o)) ? -1 : 1;
+  }
+  return n.length - s.length;
+}, go = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EQUAL: ee,
+  GREATER_THAN: $e,
+  LESS_THAN: xe,
+  isEqualTo: Ht,
+  isGreaterThan: Gt,
+  isGreaterThanEqual: pn,
+  isLessThan: Wt,
+  newF: Be,
+  newFieldF: hn,
+  order: gn,
+  primitiveArrays: fn,
+  reverseF: Vt,
+  stringsWithNumbers: yn,
+  uniqueUnorderedPrimitiveArrays: dn,
+  unorderedPrimitiveArrays: Yt
+}, Symbol.toStringTag, { value: "Module" })), Ue = a.tuple([a.number(), a.number()]);
+a.tuple([a.bigint(), a.bigint()]);
+const ft = a.object({ width: a.number(), height: a.number() }), mn = a.object({
+  signedWidth: a.number(),
+  signedHeight: a.number()
+}), bn = ["width", "height"];
+a.enum(bn);
+const wn = ["start", "center", "end"], On = ["signedWidth", "signedHeight"];
+a.enum(On);
+const he = a.object({ x: a.number(), y: a.number() }), Jt = a.object({ clientX: a.number(), clientY: a.number() }), Ce = ["x", "y"], dt = a.enum(Ce), Xt = ["top", "right", "bottom", "left"], vn = a.enum(Xt), je = ["left", "right"], gt = a.enum(je), Re = ["top", "bottom"], pt = a.enum(Re), yt = ["center"], Xe = a.enum(yt), Tn = [...Xt, ...yt], mt = a.enum(Tn);
+a.enum(wn);
+const xn = ["first", "last"];
+a.enum(xn);
+const Kt = a.object({ lower: a.number(), upper: a.number() }), $n = a.object({ lower: a.bigint(), upper: a.bigint() });
+a.union([Kt, Ue]);
+a.union([$n, Ue]);
+const Sn = a.enum([...dt.options, ...mt.options]), Nn = a.union([dt, mt, a.instanceof(String)]), ae = (t, e) => typeof t == "bigint" ? t - BigInt(e) : t - Number(e), Qt = (t, e) => typeof t == "bigint" ? t + BigInt(e) : t + Number(e), In = (t, e, r = 1e-4) => Math.abs(t - e) < r, Ke = (t, e) => typeof t == "bigint" ? t === BigInt(e) : t === Number(e), Mn = (t) => {
+  const e = 10 ** Math.floor(Math.log10(t));
+  return Math.round(t / e) * e;
+}, _t = (t, e) => t <= e ? t : typeof t == "bigint" ? t <= e ? t : BigInt(e) : t <= e ? t : Number(e), En = (t, e) => typeof t == "bigint" ? t >= e ? t : BigInt(e) : t >= e ? t : Number(e), er = (t) => t < 0 ? -t : t, Y = (t, e) => typeof t == "bigint" ? t * BigInt(e) : t * Number(e), An = (t, e) => typeof t == "bigint" ? t / BigInt(e) : t / Number(e), y = (t, e, r) => {
+  const n = {};
+  if (typeof e == "object" && (r = e, e = void 0), r = { makeValid: !0, ...r }, typeof t == "number" || typeof t == "bigint")
+    e != null ? (n.lower = t, n.upper = e) : (n.lower = typeof t == "bigint" ? 0n : 0, n.upper = t);
+  else if (Array.isArray(t)) {
+    if (t.length !== 2) throw new Error("bounds: expected array of length 2");
+    [n.lower, n.upper] = t;
+  } else
+    n.lower = t.lower, n.upper = t.upper;
+  return r?.makeValid ? tr(n) : n;
+}, Bn = Object.freeze({ lower: 0, upper: 0 }), Un = Object.freeze({ lower: -1 / 0, upper: 1 / 0 }), Cn = Object.freeze({ lower: 0, upper: 1 }), jn = Object.freeze({ lower: -1, upper: 1 }), Rn = (t, e) => {
+  if (t == null && e == null) return !0;
+  if (t == null || e == null) return !1;
+  const r = y(t), n = y(e);
+  return r?.lower === n?.lower && r?.upper === n?.upper;
+}, tr = (t) => t.lower > t.upper ? { lower: t.upper, upper: t.lower } : t, Qe = (t, e) => {
+  const r = y(t);
+  return e < r.lower ? r.lower : e >= r.upper ? r.upper - (typeof r.upper == "number" ? 1 : 1n) : e;
+}, I = (t, e) => {
+  const r = y(t);
+  if (typeof e == "number" || typeof e == "bigint")
+    return e >= r.lower && e < r.upper;
+  const n = y(e);
+  return n.lower >= r.lower && n.upper <= r.upper;
+}, Ln = (t, e) => {
+  const r = y(t), n = y(e);
+  return r.lower === n.lower ? !0 : n.upper === r.lower || n.lower === r.upper ? !1 : I(r, n.upper) || I(r, n.lower) || I(n, r.upper) || I(n, r.lower);
+}, ye = (t) => {
+  const e = y(t);
+  return e.upper - e.lower;
+}, Dn = (t) => {
+  const e = y(t);
+  return typeof e.lower == "bigint" ? e.lower === 0n && e.upper === 0n : e.lower === 0 && e.upper === 0;
+}, Pn = (t) => {
+  const e = ye(t);
+  return typeof e == "number" ? e === 0 : e === 0n;
+}, qn = (t) => {
+  const e = y(t);
+  return typeof e.lower == "bigint" ? !0 : Number.isFinite(e.lower) && Number.isFinite(e.upper);
+}, kn = (t) => {
+  const e = y(t);
+  return (e.upper + e.lower) / 2;
+}, rr = (t) => ({
+  lower: Math.min(...t.map((e) => y(e).lower)),
+  upper: Math.max(...t.map((e) => y(e).upper))
+}), zn = (t) => ({
+  lower: Math.max(...t.map((e) => y(e).lower)),
+  upper: Math.min(...t.map((e) => y(e).upper))
+}), Fn = (t) => {
+  const e = y(t), r = typeof e.lower == "bigint";
+  return Array.from({ length: Number(ye(t)) }, (n, s) => r ? e.lower + BigInt(s) : e.lower + s);
+}, _e = (t, e) => {
+  const r = t.map((i) => y(i)), n = r.findIndex((i) => I(i, e) || e < i.lower);
+  if (n === -1) return { index: t.length, position: 0 };
+  const s = r[n];
+  return I(s, e) ? { index: n, position: Number(e - s.lower) } : { index: n, position: 0 };
+}, Ze = {
+  removeBefore: 0,
+  removeAfter: 0,
+  insertInto: 0,
+  deleteInBetween: 0
+}, Zn = (t, e) => {
+  const r = t.map((f) => y(f)), n = y(e);
+  if (r.length === 0) return Ze;
+  const s = _e(r, n.lower), i = _e(r, n.upper);
+  if (s.index === t.length) return { ...Ze, insertInto: t.length };
+  if (i.index === 0) return { ...Ze, 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, c = s.index, l = ae(Number(ye(r[s.index])), s.position);
+  return s.position !== 0 ? (o -= 1, c += 1) : l = 0, {
+    removeBefore: l,
+    removeAfter: i.position,
+    insertInto: c,
+    deleteInBetween: o
+  };
+}, nr = (t, e, r) => {
+  const n = t.map((c) => y(c)), s = r > 0 ? 1 : r < 0 ? -1 : 0;
+  if (s === 0) return e;
+  let i = r, o = e;
+  for (; Ke(i, 0) === !1; ) {
+    const c = n.findIndex((l) => s > 0 ? o >= l.lower && o < l.upper : o > l.lower && o <= l.upper);
+    if (c !== -1) {
+      const l = n[c];
+      let f;
+      if (s > 0 ? f = ae(l.upper, o) : f = ae(o, l.lower), f > 0) {
+        const p = _t(er(i), f);
+        if (o = Qt(
+          o,
+          s > 0 ? p : -p
+        ), i = ae(i, s > 0 ? p : -p), Ke(i, 0)) return o;
+        continue;
+      }
+    }
+    if (s > 0) {
+      const l = n.filter((f) => f.lower > o);
+      if (l.length > 0) o = l[0].lower;
+      else return o;
+    } else {
+      const l = n.filter((f) => f.upper < o);
+      if (l.length > 0)
+        o = l[l.length - 1].upper;
+      else return o;
+    }
+  }
+  return o;
+}, sr = (t, e, r) => {
+  const n = t.map((o) => y(o));
+  if (e === r) return typeof e == "bigint" ? 0n : 0;
+  const s = e < r ? y([e, r]) : y([r, e]);
+  let i = typeof e == "bigint" ? 0n : 0;
+  for (const o of n) {
+    const c = o.lower > s.lower ? o.lower : s.lower, l = o.upper < s.upper ? o.upper : s.upper;
+    if (c < l) {
+      const f = l - c;
+      i = i + f;
+    }
+  }
+  return i;
+}, po = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  CLIP: jn,
+  DECIMAL: Cn,
+  INFINITE: Un,
+  ZERO: Bn,
+  bounds: Kt,
+  buildInsertionPlan: Zn,
+  clamp: Qe,
+  construct: y,
+  contains: I,
+  distance: sr,
+  equals: Rn,
+  findInsertPosition: _e,
+  isFinite: qn,
+  isZero: Dn,
+  linspace: Fn,
+  makeValid: tr,
+  max: rr,
+  mean: kn,
+  min: zn,
+  overlapsWith: Ln,
+  span: ye,
+  spanIsZero: Pn,
+  traverse: nr
+}, Symbol.toStringTag, { value: "Module" })), ir = Sn, Z = (t) => Ce.includes(t) ? t : Re.includes(t) ? "y" : "x", Yn = (t) => Z(t) === "x" ? "y" : "x", Vn = (t) => Z(t) === "x" ? "width" : "height", Wn = (t) => Z(t) === "x" ? "left" : "top", Gn = (t) => ir.safeParse(t).success, Hn = (t) => Z(t) === "x" ? "signedWidth" : "signedHeight", Jn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DIRECTIONS: Ce,
+  construct: Z,
+  crude: ir,
+  dimension: Vn,
+  direction: dt,
+  isDirection: Gn,
+  location: Wn,
+  signedDimension: Hn,
+  swap: Yn
+}, Symbol.toStringTag, { value: "Module" })), Xn = gt, Kn = pt, Qn = Xe, _n = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right",
+  center: "center"
+}, es = {
+  top: "left",
+  right: "top",
+  bottom: "right",
+  left: "bottom",
+  center: "center"
+}, ts = Nn, k = (t) => t instanceof String || !Ce.includes(t) ? t : t === "x" ? "left" : "top", rs = (t) => _n[k(t)], ns = (t) => es[k(t)], fe = (t) => {
+  const e = k(t);
+  return e === "top" || e === "bottom" ? "y" : "x";
+}, ss = a.object({
+  x: gt.or(Xe),
+  y: pt.or(Xe)
+}), ar = a.object({ x: gt, y: pt }), me = Object.freeze({ x: "left", y: "top" }), bt = Object.freeze({ x: "right", y: "top" }), Le = Object.freeze({ x: "left", y: "bottom" }), wt = Object.freeze({ x: "right", y: "bottom" }), Ot = Object.freeze({ x: "center", y: "center" }), vt = Object.freeze({ x: "center", y: "top" }), Tt = Object.freeze({ x: "center", y: "bottom" }), xt = Object.freeze({ x: "right", y: "center" }), $t = Object.freeze({ x: "left", y: "center" }), is = Object.freeze([
+  $t,
+  xt,
+  vt,
+  Tt,
+  me,
+  bt,
+  Le,
+  wt,
+  Ot
+]), St = (t, e) => t.x === e.x && t.y === e.y, as = (t, e) => {
+  if (typeof e == "object") {
+    let r = !0;
+    return "x" in e && (t.x === e.x || (r = !1)), "y" in e && (t.y === e.y || (r = !1)), r;
+  }
+  return t.x === e || t.y === e;
+}, or = (t) => [t.x, t.y], Se = (t) => fe(k(t)) === "x", os = (t) => fe(k(t)) === "y", us = (t) => `${t.x}${Zt(t.y)}`, ls = (t, e) => {
+  let r, n;
+  if (typeof t == "object" && "x" in t ? (r = t.x, n = t.y) : (r = k(t), n = k(e ?? t)), fe(r) === fe(n) && r !== "center" && n !== "center")
+    throw new Error(
+      `[XYLocation] - encountered two locations with the same direction: ${r.toString()} - ${n.toString()}`
+    );
+  const s = { ...Ot };
+  return r === "center" ? Se(n) ? [s.x, s.y] = [n, r] : [s.x, s.y] = [r, n] : n === "center" ? Se(r) ? [s.x, s.y] = [r, n] : [s.x, s.y] = [n, r] : Se(r) ? [s.x, s.y] = [r, n] : [s.x, s.y] = [n, r], s;
+}, cs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BOTTOM_CENTER: Tt,
+  BOTTOM_LEFT: Le,
+  BOTTOM_RIGHT: wt,
+  CENTER: Ot,
+  CENTER_LEFT: $t,
+  CENTER_LOCATIONS: yt,
+  CENTER_RIGHT: xt,
+  TOP_CENTER: vt,
+  TOP_LEFT: me,
+  TOP_RIGHT: bt,
+  XY_LOCATIONS: is,
+  X_LOCATIONS: je,
+  Y_LOCATIONS: Re,
+  center: Qn,
+  construct: k,
+  constructXY: ls,
+  corner: ar,
+  crude: ts,
+  direction: fe,
+  isX: Se,
+  isY: os,
+  location: mt,
+  outer: vn,
+  rotate90: ns,
+  swap: rs,
+  x: Xn,
+  xy: ss,
+  xyCouple: or,
+  xyEquals: St,
+  xyMatches: as,
+  xyToString: us,
+  y: Kn
+}, Symbol.toStringTag, { value: "Module" })), et = a.union([
+  a.number(),
+  he,
+  Ue,
+  ft,
+  mn,
+  Jt
+]), v = (t, e) => {
+  if (typeof t == "string") {
+    if (e === void 0) throw new Error("The y coordinate must be given.");
+    return t === "x" ? { x: e, y: 0 } : { x: 0, y: e };
+  }
+  return typeof t == "number" ? { x: t, y: e ?? t } : Array.isArray(t) ? { x: t[0], y: t[1] } : "signedWidth" in t ? { x: t.signedWidth, y: t.signedHeight } : "clientX" in t ? { x: t.clientX, y: t.clientY } : "width" in t ? { x: t.width, y: t.height } : { x: t.x, y: t.y };
+}, U = Object.freeze({ x: 0, y: 0 }), ur = Object.freeze({ x: 1, y: 1 }), hs = Object.freeze({ x: 1 / 0, y: 1 / 0 }), fs = Object.freeze({ x: NaN, y: NaN }), Ae = (t, e, r = 0) => {
+  const n = v(t), s = v(e);
+  return r === 0 ? n.x === s.x && n.y === s.y : Math.abs(n.x - s.x) <= r && Math.abs(n.y - s.y) <= r;
+}, ds = (t) => Ae(t, U), Nt = (t, e, r) => {
+  const n = v(t), s = v(e, r);
+  return { x: n.x * s.x, y: n.y * s.y };
+}, lr = (t, e) => {
+  const r = v(t);
+  return { x: r.x + e, y: r.y };
+}, cr = (t, e) => {
+  const r = v(t);
+  return { x: r.x, y: r.y + e };
+}, de = (t, e, r, ...n) => typeof e == "string" && typeof r == "number" ? e === "x" ? lr(t, r) : cr(t, r) : [t, e, r ?? U, ...n].reduce((s, i) => {
+  const o = v(i);
+  return { x: s.x + o.x, y: s.y + o.y };
+}, U), gs = (t, e, r) => {
+  const n = v(t);
+  return e === "x" ? { x: r, y: n.y } : { x: n.x, y: r };
+}, ps = (t, e) => {
+  const r = v(t), n = v(e);
+  return Math.sqrt((r.x - n.x) ** 2 + (r.y - n.y) ** 2);
+}, ys = (t, e) => {
+  const r = v(t), n = v(e);
+  return { x: n.x - r.x, y: n.y - r.y };
+}, ms = (t) => {
+  const e = v(t);
+  return Number.isNaN(e.x) || Number.isNaN(e.y);
+}, bs = (t) => {
+  const e = v(t);
+  return Number.isFinite(e.x) && Number.isFinite(e.y);
+}, ws = (t) => {
+  const e = v(t);
+  return [e.x, e.y];
+}, Os = (t) => {
+  const e = v(t);
+  return { left: e.x, top: e.y };
+}, tt = (t, e = 0) => {
+  const r = v(t);
+  return { x: Number(r.x.toFixed(e)), y: Number(r.y.toFixed(e)) };
+}, ne = (t, e) => {
+  const r = v(t), n = v(e);
+  return { x: r.x - n.x, y: r.y - n.y };
+}, se = (t) => {
+  const e = v(t), r = Math.hypot(e.x, e.y);
+  return r === 0 ? { x: 0, y: 0 } : { x: -e.y / r, y: e.x / r };
+}, hr = (t) => {
+  const e = v(t), r = Math.hypot(e.x, e.y);
+  return r === 0 ? { x: 0, y: 0 } : { x: e.x / r, y: e.y / r };
+}, fr = (...t) => {
+  const e = t.reduce((r, n) => de(r, n), U);
+  return Nt(e, 1 / t.length);
+}, vs = (t, e) => {
+  const r = [];
+  for (let n = 0; n < t.length; n++) {
+    const s = t[n];
+    let i, o, c, l;
+    if (n === 0) {
+      const f = t[n + 1], p = ne(f, s);
+      o = se(p), c = o, l = e;
+    } else if (n === t.length - 1) {
+      const f = t[n - 1], p = ne(s, f);
+      i = se(p), c = i, l = e;
+    } else {
+      const f = t[n - 1], p = t[n + 1], g = ne(s, f), S = ne(p, s);
+      i = se(g), o = se(S);
+      const E = Math.acos(
+        (g.x * S.x + g.y * S.y) / (Math.hypot(g.x, g.y) * Math.hypot(S.x, S.y))
+      ), te = Math.sin(E / 2);
+      te === 0 ? l = e : l = e / te, c = hr(fr(i, o));
+    }
+    r.push(Nt(c, l));
+  }
+  return r;
+}, Ts = (t) => {
+  const e = v(t);
+  return { x: e.y, y: e.x };
+}, rt = (t) => {
+  const e = v(t);
+  return { x: Math.round(e.x), y: Math.round(e.y) };
+}, yo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  INFINITY: hs,
+  NAN: fs,
+  ONE: ur,
+  ZERO: U,
+  average: fr,
+  calculateMiters: vs,
+  clientXY: Jt,
+  construct: v,
+  couple: ws,
+  crudeZ: et,
+  css: Os,
+  distance: ps,
+  equals: Ae,
+  isFinite: bs,
+  isNan: ms,
+  isZero: ds,
+  normal: se,
+  normalize: hr,
+  round: rt,
+  scale: Nt,
+  set: gs,
+  sub: ne,
+  swap: Ts,
+  translate: de,
+  translateX: lr,
+  translateY: cr,
+  translation: ys,
+  truncate: tt,
+  xy: he
+}, Symbol.toStringTag, { value: "Module" })), we = a.union([a.number(), a.string()]), xs = a.object({
+  top: we,
+  left: we,
+  width: we,
+  height: we
+}), $s = a.object({
+  left: a.number(),
+  top: a.number(),
+  right: a.number(),
+  bottom: a.number()
+}), Ss = a.object({
+  one: he,
+  two: he,
+  root: ar
+}), dr = { one: U, two: U, root: me }, Ns = { one: U, two: ur, root: Le }, gr = (t, e) => ({
+  one: t.one,
+  two: t.two,
+  root: e ?? t.root
+}), O = (t, e, r = 0, n = 0, s) => {
+  const i = {
+    one: { ...U },
+    two: { ...U },
+    root: s ?? me
+  };
+  if (typeof t == "number") {
+    if (typeof e != "number")
+      throw new Error("Box constructor called with invalid arguments");
+    return i.one = { x: t, y: e }, i.two = { x: i.one.x + r, y: i.one.y + n }, i;
+  }
+  return "one" in t && "two" in t && "root" in t ? { ...t, root: s ?? t.root } : ("getBoundingClientRect" in t && (t = t.getBoundingClientRect()), "left" in t ? (i.one = { x: t.left, y: t.top }, i.two = { x: t.right, y: t.bottom }, i) : (i.one = t, e == null ? i.two = { x: i.one.x + r, y: i.one.y + n } : typeof e == "number" ? i.two = { x: i.one.x + e, y: i.one.y + r } : "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));
+}, Is = (t, e, r) => {
+  const n = O(t);
+  if (typeof e == "string") {
+    if (r == null) throw new Error("Invalid arguments for resize");
+    const s = Z(e);
+    return O(
+      n.one,
+      void 0,
+      s === "x" ? r : z(n),
+      s === "y" ? r : F(n),
+      n.root
+    );
+  }
+  return O(n.one, e, void 0, void 0, n.root);
+}, Ms = (t, e, r = !0) => {
+  const n = O(t);
+  let s = (i, o) => i < o;
+  return r && (s = (i, o) => i <= o), "one" in e ? s(P(n), P(e)) && s(W(e), W(n)) && s(q(n), q(e)) && s(G(e), G(n)) : s(P(n), e.x) && s(e.x, W(n)) && s(q(n), e.y) && s(e.y, G(n));
+}, Es = (t, e) => Ae(t.one, e.one) && Ae(t.two, e.two) && St(t.root, e.root), pr = (t) => ({
+  width: z(t),
+  height: F(t)
+}), As = (t) => ({
+  signedWidth: De(t),
+  signedHeight: Pe(t)
+}), Bs = (t) => ({
+  top: q(t),
+  left: P(t),
+  width: z(t),
+  height: F(t)
+}), It = (t, e, r = !1) => {
+  const n = Z(e) === "y" ? Pe(t) : De(t);
+  return r ? n : Math.abs(n);
+}, j = (t, e) => {
+  const r = O(t);
+  return {
+    x: e.x === "center" ? nt(r).x : H(r, e.x),
+    y: e.y === "center" ? nt(r).y : H(r, e.y)
+  };
+}, H = (t, e) => {
+  const r = O(t), n = or(r.root).includes(e) ? Math.min : Math.max;
+  return je.includes(e) ? n(r.one.x, r.two.x) : n(r.one.y, r.two.y);
+}, Us = (t) => t.one.x === t.two.x && t.one.y === t.two.y, z = (t) => It(t, "x"), F = (t) => It(t, "y"), De = (t) => {
+  const e = O(t);
+  return e.two.x - e.one.x;
+}, Pe = (t) => {
+  const e = O(t);
+  return e.two.y - e.one.y;
+}, yr = (t) => j(t, me), Cs = (t) => j(t, vt), js = (t) => j(t, bt), Rs = (t) => j(t, Le), Ls = (t) => j(t, Tt), Ds = (t) => j(t, wt), Ps = (t) => j(t, $t), qs = (t) => j(t, xt), W = (t) => H(t, "right"), G = (t) => H(t, "bottom"), P = (t) => H(t, "left"), q = (t) => H(t, "top"), nt = (t) => de(yr(t), {
+  x: De(t) / 2,
+  y: Pe(t) / 2
+}), Mt = (t) => {
+  const e = O(t);
+  return e.root.x === "left" ? P(e) : W(e);
+}, Et = (t) => {
+  const e = O(t);
+  return e.root.y === "top" ? q(e) : G(e);
+}, ks = (t) => ({ x: Mt(t), y: Et(t) }), Ne = (t) => {
+  const e = O(t);
+  return { lower: e.one.x, upper: e.two.x };
+}, Ie = (t) => {
+  const e = O(t);
+  return { lower: e.one.y, upper: e.two.y };
+}, zs = (t, e) => gr(t, e), Fs = (t, e) => {
+  const r = O(t), n = je.includes(e) ? "x" : Re.includes(e) ? "y" : null;
+  if (n === null) throw new Error(`Invalid location: ${e}`);
+  const s = e === "top" || e === "left" ? Math.min : Math.max, i = { ...r.one }, o = { ...r.two };
+  return i[n] = s(r.one[n], r.two[n]), o[n] = s(r.one[n], r.two[n]), [i, o];
+}, Zs = (t, e) => {
+  const r = O(t), n = O(e), s = Mt(n) + (z(n) - z(r)) / 2, i = Et(n) + (F(n) - F(r)) / 2;
+  return O({ x: s, y: i }, pr(r));
+}, mr = (t) => typeof t != "object" || t == null ? !1 : "one" in t && "two" in t && "root" in t, Ys = (t) => z(t) / F(t), Vs = (t, e, r) => {
+  if (typeof e == "string") {
+    if (r == null) throw new Error("Undefined amount passed into box.translate");
+    const s = Z(e);
+    e = v(s, r);
+  }
+  const n = O(t);
+  return O(
+    de(n.one, e),
+    de(n.two, e),
+    void 0,
+    void 0,
+    n.root
+  );
+}, Ws = (t, e) => {
+  const r = Math.max(P(t), P(e)), n = Math.max(q(t), q(e)), s = Math.min(W(t), W(e)), i = Math.min(G(t), G(e));
+  return r > s || n > i ? dr : O({ x: r, y: n }, { x: s, y: i }, void 0, void 0, t.root);
+}, Gs = (t) => z(t) * F(t), Hs = (t, e) => {
+  const r = O(t);
+  return O(
+    tt(r.one, e),
+    tt(r.two, e),
+    void 0,
+    void 0,
+    r.root
+  );
+}, Js = (t, e, r, n, s, i) => {
+  const o = { x: t, y: e }, c = { x: t + r, y: e + n };
+  return s.x !== i.x && (s.x === "center" ? (o.x -= r / 2, c.x -= r / 2) : (o.x -= r, c.x -= r)), s.y !== i.y && (s.y === "center" ? (o.y -= n / 2, c.y -= n / 2) : (o.y -= n, c.y -= n)), O(o, c, void 0, void 0, i);
+}, Xs = (t) => {
+  const e = O(t);
+  return O(rt(e.one), rt(e.two), void 0, void 0, e.root);
+}, mo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DECIMAL: Ns,
+  ZERO: dr,
+  area: Gs,
+  areaIsZero: Us,
+  aspect: Ys,
+  bottom: G,
+  bottomCenter: Ls,
+  bottomLeft: Rs,
+  bottomRight: Ds,
+  box: Ss,
+  center: nt,
+  centerLeft: Ps,
+  centerRight: qs,
+  construct: O,
+  constructWithAlternateRoot: Js,
+  contains: Ms,
+  copy: gr,
+  css: Bs,
+  cssBox: xs,
+  dim: It,
+  dims: pr,
+  domRect: $s,
+  edgePoints: Fs,
+  equals: Es,
+  height: F,
+  intersection: Ws,
+  isBox: mr,
+  left: P,
+  loc: H,
+  positionInCenter: Zs,
+  reRoot: zs,
+  resize: Is,
+  right: W,
+  root: ks,
+  round: Xs,
+  signedDims: As,
+  signedHeight: Pe,
+  signedWidth: De,
+  top: q,
+  topCenter: Cs,
+  topLeft: yr,
+  topRight: js,
+  translate: Vs,
+  truncate: Hs,
+  width: z,
+  x: Mt,
+  xBounds: Ne,
+  xyLoc: j,
+  y: Et,
+  yBounds: Ie
+}, Symbol.toStringTag, { value: "Module" })), br = a.object({ signedWidth: a.number(), signedHeight: a.number() }), Ks = a.union([ft, br, he, Ue]), Qs = { width: 0, height: 0 }, _s = { width: 1, height: 1 }, M = (t, e) => typeof t == "number" ? { width: t, height: e ?? t } : Array.isArray(t) ? { width: t[0], height: t[1] } : "x" in t ? { width: t.x, height: t.y } : "signedWidth" in t ? { width: t.signedWidth, height: t.signedHeight } : { ...t }, ei = (t, e) => {
+  if (e == null) return !1;
+  const r = M(t), n = M(e);
+  return r.width === n.width && r.height === n.height;
+}, ti = (t) => {
+  const e = M(t);
+  return { width: e.height, height: e.width };
+}, ri = (t) => {
+  const e = M(t);
+  return `0 0 ${e.width} ${e.height}`;
+}, ni = (t) => {
+  const e = M(t);
+  return [e.width, e.height];
+}, si = (t) => ({
+  width: Math.max(...t.map((e) => M(e).width)),
+  height: Math.max(...t.map((e) => M(e).height))
+}), ii = (t) => ({
+  width: Math.min(...t.map((e) => M(e).width)),
+  height: Math.min(...t.map((e) => M(e).height))
+}), ai = (t, e) => {
+  const r = M(t);
+  return { width: r.width * e, height: r.height * e };
+}, bo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DECIMAL: _s,
+  ZERO: Qs,
+  construct: M,
+  couple: ni,
+  crude: Ks,
+  dimensions: ft,
+  equals: ei,
+  max: si,
+  min: ii,
+  scale: ai,
+  signed: br,
+  svgViewBox: ri,
+  swap: ti
+}, Symbol.toStringTag, { value: "Module" })), oi = (t, e, r) => e !== void 0 && t < e ? e : r !== void 0 && t > r ? r : t, ui = a.object({ offset: et, scale: et }), li = a.object({ offset: a.number(), scale: a.number() }), ci = (t) => (e, r, n, s) => r === "dimension" ? [e, n] : [
+  e,
+  s ? n - t : n + t
+], hi = (t) => (e, r, n, s) => [
+  e,
+  s ? n / t : n * t
+], fi = (t) => (e, r, n) => {
+  if (e === null) return [t, n];
+  const { lower: s, upper: i } = e, { lower: o, upper: c } = t, l = i - s, f = c - o;
+  if (r === "dimension") return [t, n * (f / l)];
+  const p = (n - s) * (f / l) + o;
+  return [t, p];
+}, di = (t) => (e, r, n) => [t, n], gi = () => (t, e, r) => {
+  if (t === null) throw new Error("cannot invert without bounds");
+  if (e === "dimension") return [t, r];
+  const { lower: n, upper: s } = t;
+  return [t, s - (r - n)];
+}, pi = (t) => (e, r, n) => {
+  const { lower: s, upper: i } = t;
+  return n = oi(n, s, i), [e, n];
+};
+let st = class K {
+  ops = [];
+  currBounds = null;
+  currType = null;
+  reversed = !1;
+  constructor() {
+    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 K().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 K().magnify(e);
+  }
+  static scale(e, r) {
+    return new K().scale(e, r);
+  }
+  /**
+   * @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 r = this.new(), n = ci(e);
+    return n.type = "translate", r.ops.push(n), r;
+  }
+  /**
+   * @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 r = this.new(), n = hi(e);
+    return n.type = "magnify", r.ops.push(n), r;
+  }
+  scale(e, r) {
+    const n = y(e, r), s = this.new(), i = fi(n);
+    return i.type = "scale", s.ops.push(i), s;
+  }
+  clamp(e, r) {
+    const n = y(e, r), s = this.new(), i = pi(n);
+    return i.type = "clamp", s.ops.push(i), s;
+  }
+  reBound(e, r) {
+    const n = y(e, r), s = this.new(), i = di(n);
+    return i.type = "re-bound", s.ops.push(i), s;
+  }
+  invert() {
+    const e = gi();
+    e.type = "invert";
+    const r = this.new();
+    return r.ops.push(e), r;
+  }
+  pos(e) {
+    return this.exec("position", e);
+  }
+  dim(e) {
+    return this.exec("dimension", e);
+  }
+  new() {
+    const e = new K();
+    return e.ops = this.ops.slice(), e.reversed = this.reversed, e;
+  }
+  exec(e, r) {
+    return this.currBounds = null, this.ops.reduce(
+      ([n, s], i) => i(n, e, s, this.reversed),
+      [null, r]
+    )[1];
+  }
+  reverse() {
+    const e = this.new();
+    e.ops.reverse();
+    const r = [];
+    return e.ops.forEach((n, s) => {
+      if (n.type === "scale" || r.some(([o, c]) => s >= o && s <= c))
+        return;
+      const i = e.ops.findIndex((o, c) => o.type === "scale" && c > s);
+      i !== -1 && r.push([s, i]);
+    }), r.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) };
+  }
+  static IDENTITY = new K();
+}, yi = class A {
+  x;
+  y;
+  currRoot;
+  constructor(e = new st(), r = new st(), n = null) {
+    this.x = e, this.y = r, this.currRoot = n;
+  }
+  static translate(e, r) {
+    return new A().translate(e, r);
+  }
+  static translateX(e) {
+    return new A().translateX(e);
+  }
+  static translateY(e) {
+    return new A().translateY(e);
+  }
+  static clamp(e) {
+    return new A().clamp(e);
+  }
+  static magnify(e) {
+    return new A().magnify(e);
+  }
+  static scale(e) {
+    return new A().scale(e);
+  }
+  static reBound(e) {
+    return new A().reBound(e);
+  }
+  translate(e, r) {
+    const n = v(e, r), s = this.copy();
+    return s.x = this.x.translate(n.x), s.y = this.y.translate(n.y), s;
+  }
+  translateX(e) {
+    const r = this.copy();
+    return r.x = this.x.translate(e), r;
+  }
+  translateY(e) {
+    const r = this.copy();
+    return r.y = this.y.translate(e), r;
+  }
+  magnify(e) {
+    const r = this.copy();
+    return r.x = this.x.magnify(e.x), r.y = this.y.magnify(e.y), r;
+  }
+  scale(e) {
+    const r = this.copy();
+    if (mr(e)) {
+      const n = this.currRoot;
+      return r.currRoot = e.root, n != null && !St(n, e.root) && (n.x !== e.root.x && (r.x = r.x.invert()), n.y !== e.root.y && (r.y = r.y.invert())), r.x = r.x.scale(Ne(e)), r.y = r.y.scale(Ie(e)), r;
+    }
+    return r.x = r.x.scale(e.width), r.y = r.y.scale(e.height), r;
+  }
+  reBound(e) {
+    const r = this.copy();
+    return r.x = this.x.reBound(Ne(e)), r.y = this.y.reBound(Ie(e)), r;
+  }
+  clamp(e) {
+    const r = this.copy();
+    return r.x = this.x.clamp(Ne(e)), r.y = this.y.clamp(Ie(e)), r;
+  }
+  copy() {
+    const e = new A();
+    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 O(
+      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 })
+    };
+  }
+  static IDENTITY = new A();
+};
+const wo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Scale: st,
+  XY: yi,
+  crudeXYTransform: ui,
+  transform: li
+}, Symbol.toStringTag, { value: "Module" }));
+let mi = (t, e = 21) => (r = e) => {
+  let n = "", s = r | 0;
+  for (; s--; )
+    n += t[Math.random() * t.length | 0];
+  return n;
+};
+const bi = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", wr = 11, wi = mi(bi, wr), At = () => wi(), Oo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LENGTH: wr,
+  create: At
+}, Symbol.toStringTag, { value: "Module" })), Oi = (t, e) => (r) => r instanceof e || typeof r == "object" && r !== null && "discriminator" in r && r.discriminator === t, vi = a.enum(["static", "dynamic"]), Ti = a.union([
+  a.tuple([a.int()]),
+  a.tuple([a.int(), a.int().min(1).max(12)]),
+  a.tuple([a.int(), a.int().min(1).max(12), a.int().min(1).max(31)])
+]), Or = (t, e) => {
+  const r = new b(e);
+  if (![
+    h.DAY,
+    h.HOUR,
+    h.MINUTE,
+    h.SECOND,
+    h.MILLISECOND,
+    h.MICROSECOND,
+    h.NANOSECOND
+  ].some((s) => s.equals(r)))
+    throw new Error(
+      "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
+    );
+  const n = t.valueOf() % r.valueOf();
+  return t instanceof b ? new b(n) : new h(n);
+};
+let b = class d extends J {
+  constructor(e, r = "UTC") {
+    if (e == null) super(d.now().valueOf());
+    else if (e instanceof Date)
+      super(BigInt(e.getTime()) * d.MILLISECOND.valueOf());
+    else if (typeof e == "string")
+      super(d.parseDateTimeString(e, r).valueOf());
+    else if (Array.isArray(e)) super(d.parseDate(e));
+    else {
+      let n = 0n;
+      e instanceof Number && (e = e.valueOf()), r === "local" && (n = d.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = d.MAX : e = d.MIN)), super(BigInt(e.valueOf()) + n);
+    }
+  }
+  static parseDate([e = 1970, r = 1, n = 1]) {
+    const s = new Date(e, r - 1, n, 0, 0, 0, 0);
+    return new d(BigInt(s.getTime()) * d.MILLISECOND.valueOf()).truncate(d.DAY).valueOf();
+  }
+  /**
+   * @returns the primitive value of the TimeStamp. Overrides standard JS valueOf()
+   * method.
+   */
+  valueOf() {
+    return this.value;
+  }
+  static parseTimeString(e, r = "UTC") {
+    const [n, s, i] = e.split(":");
+    let o = "00", c = "00";
+    i != null && ([o, c] = i.split("."));
+    let l = d.hours(parseInt(n ?? "00")).add(d.minutes(parseInt(s ?? "00"))).add(d.seconds(parseInt(o ?? "00"))).add(d.milliseconds(parseInt(c ?? "00")));
+    return r === "local" && (l = l.add(d.utcOffset)), l.valueOf();
+  }
+  static parseDateTimeString(e, r = "UTC") {
+    if (!e.includes("/") && !e.includes("-"))
+      return d.parseTimeString(e, r);
+    const n = new Date(e);
+    return e.includes(":") || n.setUTCHours(0, 0, 0, 0), new d(
+      BigInt(n.getTime()) * d.MILLISECOND.valueOf(),
+      r
+    ).valueOf();
+  }
+  /**
+   * Formats the TimeStamp as a string in the specified format.
+   *
+   * @param format - The format to use for the string representation.
+   * @param tzInfo - The timezone to use when creating the string representation.
+   * @returns A string representation of the TimeStamp in the specified format.
+   */
+  fString(e = "ISO", r = "UTC") {
+    switch (e) {
+      case "ISODate":
+        return this.toISOString(r).slice(0, 10);
+      case "ISOTime":
+        return this.toISOString(r).slice(11, 23);
+      case "time":
+        return this.timeString(!1, r);
+      case "preciseTime":
+        return this.timeString(!0, r);
+      case "date":
+        return this.dateString();
+      case "preciseDate":
+        return `${this.dateString()} ${this.timeString(!0, r)}`;
+      case "dateTime":
+        return `${this.dateString()} ${this.timeString(!1, r)}`;
+      default:
+        return this.toISOString(r);
+    }
+  }
+  toISOString(e = "UTC") {
+    return e === "UTC" ? this.date().toISOString() : this.sub(d.utcOffset).date().toISOString();
+  }
+  timeString(e = !1, r = "UTC") {
+    const n = this.toISOString(r);
+    return e ? n.slice(11, 23) : n.slice(11, 19);
+  }
+  dateString() {
+    const e = this.date(), r = e.toLocaleString("default", { month: "short" }), n = e.toLocaleString("default", { day: "numeric" });
+    return `${r} ${n}`;
+  }
+  /** @returns The UTC offset for the time zone of the machine. */
+  static get utcOffset() {
+    return new h(
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * d.MINUTE.valueOf()
+    );
+  }
+  /**
+   * @returns a TimeSpan representing the amount time elapsed since
+   * the other timestamp.
+   * @param other - The other timestamp.
+   */
+  static since(e) {
+    return new d().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 d(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 V(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() === 0n;
+  }
+  /**
+   * 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 d(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 d(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 d(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 d(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 d(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 d(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(h.HOUR.valueOf());
+  }
+  /**
+   * @returns the floating point number of minutes since the unix epoch to the timestamp
+   * value.
+   */
+  get minutes() {
+    return Number(this.valueOf()) / Number(h.MINUTE.valueOf());
+  }
+  /**
+   * @returns the floating point number of days since the unix epoch to the timestamp
+   * value.
+   */
+  get days() {
+    return Number(this.valueOf()) / Number(h.DAY.valueOf());
+  }
+  /**
+   * @returns the floating point number of seconds since the unix epoch to the timestamp
+   * value.
+   */
+  get seconds() {
+    return Number(this.valueOf()) / Number(h.SECOND.valueOf());
+  }
+  /** @returns the floating point number of milliseconds since the unix epoch. */
+  get milliseconds() {
+    return Number(this.valueOf()) / Number(d.MILLISECOND.valueOf());
+  }
+  /** @returns the floating point number of microseconds since the unix epoch. */
+  get microseconds() {
+    return Number(this.valueOf()) / Number(d.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().getUTCFullYear();
+  }
+  /**
+   * @returns a copy of the timestamp with the year changed.
+   * @param year the value to set the year to.
+   */
+  setYear(e) {
+    const r = this.date();
+    return r.setUTCFullYear(e), new d(r);
+  }
+  /** @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 r = this.date();
+    return r.setUTCMonth(e), new d(r);
+  }
+  /** @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 r = this.date();
+    return r.setUTCDate(e), new d(r);
+  }
+  /**
+   * @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 r = this.date();
+    return r.setUTCHours(e), new d(r, "UTC");
+  }
+  /** @returns the integer minute that the timestamp corresponds to within its hour. */
+  get minute() {
+    return this.date().getUTCMinutes();
+  }
+  /**
+   * @returns a copy of the timestamp with the minute changed.
+   * @param minute the value to set the minute to.
+   */
+  setMinute(e) {
+    const r = this.date();
+    return r.setUTCMinutes(e), new d(r);
+  }
+  /**
+   * @returns the integer second that the timestamp corresponds to within its
+   * minute.
+   */
+  get second() {
+    return this.date().getUTCSeconds();
+  }
+  /**
+   * @returns a copy of the timestamp with the second changed.
+   * @param second the value to set the second to.
+   */
+  setSecond(e) {
+    const r = this.date();
+    return r.setUTCSeconds(e), new d(r);
+  }
+  /**
+   * @reutrns the integer millisecond that the timestamp corresponds to within
+   * its second.
+   */
+  get millisecond() {
+    return this.date().getUTCMilliseconds();
+  }
+  /**
+   * @returns a copy of the timestamp with the milliseconds changed.
+   * @param millisecond the value to set the millisecond to.
+   */
+  setMillisecond(e) {
+    const r = this.date();
+    return r.setUTCMilliseconds(e), new d(r);
+  }
+  /** @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 Or(this, e);
+  }
+  /** @returns true if the day portion TimeStamp is today, false otherwise. */
+  get isToday() {
+    return this.truncate(h.DAY).equals(d.now().truncate(h.DAY));
+  }
+  /**
+   * Truncates the TimeStamp to the nearest multiple of the given span.
+   *
+   * @param span - The TimeSpan to truncate to.
+   * @returns A new TimeStamp that is truncated to the nearest multiple of the given span.
+   */
+  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 d(/* @__PURE__ */ new Date());
+  }
+  /**
+   * Finds the maximum timestamp among the provided timestamps.
+   *
+   * @param timestamps - The timestamps to compare.
+   * @returns The maximum (latest) timestamp from the input.
+   */
+  static max(...e) {
+    let r = d.MIN;
+    for (const n of e) {
+      const s = new d(n);
+      s.after(r) && (r = s);
+    }
+    return r;
+  }
+  /**
+   * Finds the minimum timestamp among the provided timestamps.
+   *
+   * @param timestamps - The timestamps to compare.
+   * @returns The minimum (earliest) timestamp from the input.
+   */
+  static min(...e) {
+    let r = d.MAX;
+    for (const n of e) {
+      const s = new d(n);
+      s.before(r) && (r = s);
+    }
+    return r;
+  }
+  /**
+   * Creates a TimeStamp representing the given number of nanoseconds.
+   *
+   * @param value - The number of nanoseconds.
+   * @returns A TimeStamp representing the given number of nanoseconds.
+   */
+  static nanoseconds(e, r = "UTC") {
+    return new d(e, r);
+  }
+  /** One nanosecond after the unix epoch */
+  static NANOSECOND = d.nanoseconds(1);
+  /** @returns a new TimeStamp n microseconds after the unix epoch */
+  static microseconds(e, r = "UTC") {
+    return d.nanoseconds(e * 1e3, r);
+  }
+  /** One microsecond after the unix epoch */
+  static MICROSECOND = d.microseconds(1);
+  /** @returns a new TimeStamp n milliseconds after the unix epoch */
+  static milliseconds(e, r = "UTC") {
+    return d.microseconds(e * 1e3, r);
+  }
+  /** One millisecond after the unix epoch */
+  static MILLISECOND = d.milliseconds(1);
+  /** @returns a new TimeStamp n seconds after the unix epoch */
+  static seconds(e, r = "UTC") {
+    return d.milliseconds(e * 1e3, r);
+  }
+  /** One second after the unix epoch */
+  static SECOND = d.seconds(1);
+  /** @returns a new TimeStamp n minutes after the unix epoch */
+  static minutes(e, r = "UTC") {
+    return d.seconds(e * 60, r);
+  }
+  /** One minute after the unix epoch */
+  static MINUTE = d.minutes(1);
+  /** @returns a new TimeStamp n hours after the unix epoch */
+  static hours(e, r = "UTC") {
+    return d.minutes(e * 60, r);
+  }
+  /** One hour after the unix epoch */
+  static HOUR = d.hours(1);
+  /** @returns a new TimeStamp n days after the unix epoch */
+  static days(e, r = "UTC") {
+    return d.hours(e * 24, r);
+  }
+  /** One day after the unix epoch */
+  static DAY = d.days(1);
+  /** The maximum possible value for a timestamp */
+  static MAX = new d((1n << 63n) - 1n);
+  /** The minimum possible value for a timestamp */
+  static MIN = new d(0);
+  /** The unix epoch */
+  static ZERO = new d(0);
+  /** A zod schema for validating timestamps */
+  static z = a.union([
+    a.instanceof(d),
+    a.object({ value: a.bigint() }).transform((e) => new d(e.value)),
+    a.string().transform((e) => new d(BigInt(e))),
+    a.number().transform((e) => new d(e)),
+    a.bigint().transform((e) => new d(e)),
+    a.date().transform((e) => new d(e)),
+    a.custom((e) => e instanceof h).transform((e) => new d(e)),
+    Ti.transform((e) => new d(e))
+  ]);
+  /**
+   * Sorts two timestamps.
+   *
+   * @param a - The first timestamp.
+   * @param b - The second timestamp.
+   * @returns A number indicating the order of the two timestamps (positive if a is
+   * greater than b, negative if a is less than b, and 0 if they are equal).
+   */
+  static sort(e, r) {
+    return Number(e.valueOf() - r.valueOf());
+  }
+};
+class h extends J {
+  constructor(e) {
+    typeof e == "number" && (e = Math.trunc(e.valueOf())), super(BigInt(e.valueOf()));
+  }
+  /**
+   * Creates a TimeSpan representing the given number of seconds.
+   *
+   * @param span - The number of seconds.
+   * @returns A TimeSpan representing the given number of seconds.
+   */
+  static fromSeconds(e) {
+    return e instanceof h ? e : e instanceof Lt ? e.period : e instanceof b ? new h(e) : ["number", "bigint"].includes(typeof e) ? h.seconds(e) : new h(e);
+  }
+  /**
+   * Creates a TimeSpan representing the given number of milliseconds.
+   *
+   * @param span - The number of milliseconds.
+   * @returns A TimeSpan representing the given number of milliseconds.
+   */
+  static fromMilliseconds(e) {
+    return e instanceof h ? e : e instanceof Lt ? e.period : e instanceof b ? new h(e) : ["number", "bigint"].includes(typeof e) ? h.milliseconds(e) : new h(e);
+  }
+  /**
+   * @returns the primitive value of the TimeSpan. Overrides standard JS valueOf()
+   * method.
+   */
+  valueOf() {
+    return this.value;
+  }
+  /**
+   * Checks if the TimeSpan is less than another TimeSpan.
+   *
+   * @param other - The TimeSpan to compare against.
+   * @returns True if the TimeSpan is less than the other TimeSpan, false otherwise.
+   */
+  lessThan(e) {
+    return this.valueOf() < new h(e).valueOf();
+  }
+  /**
+   * Checks if the TimeSpan is greater than another TimeSpan.
+   *
+   * @param other - The TimeSpan to compare against.
+   * @returns True if the TimeSpan is greater than the other TimeSpan, false otherwise.
+   */
+  greaterThan(e) {
+    return this.valueOf() > new h(e).valueOf();
+  }
+  /**
+   * Checks if the TimeSpan is less than or equal to another TimeSpan.
+   *
+   * @param other - The TimeSpan to compare against.
+   * @returns True if the TimeSpan is less than or equal to the other TimeSpan, false otherwise.
+   */
+  lessThanOrEqual(e) {
+    return this.valueOf() <= new h(e).valueOf();
+  }
+  /**
+   * Checks if the TimeSpan is greater than or equal to another TimeSpan.
+   *
+   * @param other - The TimeSpan to compare against.
+   * @returns True if the TimeSpan is greater than or equal to the other TimeSpan, false otherwise.
+   */
+  greaterThanOrEqual(e) {
+    return this.valueOf() >= new h(e).valueOf();
+  }
+  /**
+   * Calculates the remainder of the TimeSpan when divided by another TimeSpan.
+   *
+   * @param divisor - The TimeSpan to divide by.
+   * @returns A new TimeSpan representing the remainder.
+   */
+  remainder(e) {
+    return Or(this, e);
+  }
+  /**
+   * Truncates the TimeSpan to the nearest multiple of the given span.
+   *
+   * @param span - The TimeSpan to truncate to.
+   * @returns A new TimeSpan that is truncated to the nearest multiple of the given span.
+   */
+  truncate(e) {
+    return new h(
+      BigInt(Math.trunc(Number(this.valueOf() / e.valueOf()))) * e.valueOf()
+    );
+  }
+  /**
+   * Returns a string representation of the TimeSpan.
+   *
+   * @returns A string representation of the TimeSpan.
+   */
+  toString() {
+    const e = this.truncate(h.DAY), r = this.truncate(h.HOUR), n = this.truncate(h.MINUTE), s = this.truncate(h.SECOND), i = this.truncate(h.MILLISECOND), o = this.truncate(h.MICROSECOND), c = this.truncate(h.NANOSECOND), l = e, f = r.sub(e), p = n.sub(r), g = s.sub(n), S = i.sub(s), E = o.sub(i), te = c.sub(o);
+    let R = "";
+    return l.isZero || (R += `${l.days}d `), f.isZero || (R += `${f.hours}h `), p.isZero || (R += `${p.minutes}m `), g.isZero || (R += `${g.seconds}s `), S.isZero || (R += `${S.milliseconds}ms `), E.isZero || (R += `${E.microseconds}µs `), te.isZero || (R += `${te.nanoseconds}ns`), R.trim();
+  }
+  /**
+   * Multiplies the TimeSpan by a scalar value.
+   *
+   * @param value - The scalar value to multiply by.
+   * @returns A new TimeSpan that is this TimeSpan multiplied by the provided value.
+   */
+  mult(e) {
+    return new h(this.valueOf() * BigInt(e));
+  }
+  /** @returns the decimal number of days in the TimeSpan. */
+  get days() {
+    return Number(this.valueOf()) / Number(h.DAY.valueOf());
+  }
+  /** @returns the decimal number of hours in the TimeSpan. */
+  get hours() {
+    return Number(this.valueOf()) / Number(h.HOUR.valueOf());
+  }
+  /** @returns the decimal number of minutes in the TimeSpan. */
+  get minutes() {
+    return Number(this.valueOf()) / Number(h.MINUTE.valueOf());
+  }
+  /** @returns The number of seconds in the TimeSpan. */
+  get seconds() {
+    return Number(this.valueOf()) / Number(h.SECOND.valueOf());
+  }
+  /** @returns The number of milliseconds in the TimeSpan. */
+  get milliseconds() {
+    return Number(this.valueOf()) / Number(h.MILLISECOND.valueOf());
+  }
+  /** @returns The number of microseconds in the TimeSpan. */
+  get microseconds() {
+    return Number(this.valueOf()) / Number(h.MICROSECOND.valueOf());
+  }
+  /** @returns The number of nanoseconds in the TimeSpan. */
+  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() === 0n;
+  }
+  /**
+   * Checks if the TimeSpan is equal to another TimeSpan.
+   *
+   * @returns True if the TimeSpans are equal, false otherwise.
+   */
+  equals(e) {
+    return this.valueOf() === new h(e).valueOf();
+  }
+  /**
+   * Adds a TimeSpan to the TimeSpan.
+   *
+   * @returns A new TimeSpan representing the sum of the two TimeSpans.
+   */
+  add(e) {
+    return new h(this.valueOf() + new h(e).valueOf());
+  }
+  /**
+   * Creates a TimeSpan representing the duration between the two timestamps.
+   *
+   * @param other
+   */
+  sub(e) {
+    return new h(this.valueOf() - new h(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 h(e);
+  }
+  /** A nanosecond. */
+  static NANOSECOND = h.nanoseconds(1);
+  /**
+   * 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 h.nanoseconds(Y(e, 1e3));
+  }
+  /** A microsecond. */
+  static MICROSECOND = h.microseconds(1);
+  /**
+   * 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 h.microseconds(Y(e, 1e3));
+  }
+  /** A millisecond. */
+  static MILLISECOND = h.milliseconds(1);
+  /**
+   * 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 h.milliseconds(Y(e, 1e3));
+  }
+  /** A second. */
+  static SECOND = h.seconds(1);
+  /**
+   * 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 h.seconds(Y(e, 60));
+  }
+  /** A minute. */
+  static MINUTE = h.minutes(1);
+  /**
+   * 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 h.minutes(Y(e, 60));
+  }
+  /** Represents an hour. */
+  static HOUR = h.hours(1);
+  /**
+   * 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 h.hours(Y(e, 24));
+  }
+  /** Represents a day. */
+  static DAY = h.days(1);
+  /** The maximum possible value for a TimeSpan. */
+  static MAX = new h((1n << 63n) - 1n);
+  /** The minimum possible value for a TimeSpan. */
+  static MIN = new h(0);
+  /** The zero value for a TimeSpan. */
+  static ZERO = new h(0);
+  /** A zod schema for validating and transforming timespans */
+  static z = a.union([
+    a.object({ value: a.bigint() }).transform((e) => new h(e.value)),
+    a.string().transform((e) => new h(BigInt(e))),
+    a.number().transform((e) => new h(e)),
+    a.instanceof(h)
+  ]);
+}
+let Lt = class Q extends J {
+  constructor(e) {
+    super(e.valueOf());
+  }
+  /** @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 Q(e).valueOf();
+  }
+  /**
+   * Calculates the period of the Rate as a TimeSpan.
+   *
+   * @returns A TimeSpan representing the period of the Rate.
+   */
+  get period() {
+    return h.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 h(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, r) {
+    return this.sampleCount(e) * new N(r).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 h.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, r) {
+    return this.span(e.valueOf() / r.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 Q(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 Q.hz(e * 1e3);
+  }
+  /** A zod schema for validating and transforming rates */
+  static z = a.union([
+    a.number().transform((e) => new Q(e)),
+    a.instanceof(Q)
+  ]);
+}, N = class C extends J {
+  /**
+   * 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) {
+    super(e.valueOf());
+  }
+  /**
+   * Calculates the number of values in the given Size.
+   *
+   * @param size - The Size to calculate the value count from.
+   * @returns The number of values in the given Size.
+   */
+  length(e) {
+    return e.valueOf() / this.valueOf();
+  }
+  /**
+   * Calculates a Size representing the given number of values.
+   *
+   * @param sampleCount - The number of values in the Size.
+   * @returns A Size representing the given number of values.
+   */
+  size(e) {
+    return new m(e * this.valueOf());
+  }
+  /** Unknown/Invalid Density. */
+  static UNKNOWN = new C(0);
+  /** 128 bits per value. */
+  static BIT128 = new C(16);
+  /** 64 bits per value. */
+  static BIT64 = new C(8);
+  /** 32 bits per value. */
+  static BIT32 = new C(4);
+  /** 16 bits per value. */
+  static BIT16 = new C(2);
+  /** 8 bits per value. */
+  static BIT8 = new C(1);
+  /** A zod schema for validating and transforming densities */
+  static z = a.union([
+    a.number().transform((e) => new C(e)),
+    a.instanceof(C)
+  ]);
+}, V = class B {
+  /**
+   * The starting TimeStamp of the TimeRange.
+   *
+   * Note that this value is not guaranteed to be before or equal to the ending value.
+   * To ensure that this is the case, call TimeRange.make_valid().
+   *
+   * In most cases, operations should treat start as inclusive.
+   */
+  start;
+  /**
+   * The starting TimeStamp of the TimeRange.
+   *
+   * Note that this value is not guaranteed to be before or equal to the ending value.
+   * To ensure that this is the case, call TimeRange.make_valid().
+   *
+   * In most cases, operations should treat end as exclusive.
+   */
+  end;
+  /**
+   * 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, r) {
+    typeof e == "object" && "start" in e ? (this.start = new b(e.start), this.end = new b(e.end)) : (this.start = new b(e), this.end = new b(r));
+  }
+  /** @returns The TimeSpan occupied by the TimeRange. */
+  get span() {
+    return new h(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 B(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, r = h.ZERO) {
+    if (r.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 <= r.valueOf() && s <= r.valueOf();
+  }
+  /**
+   * Returns a string representation of the TimeRange.
+   *
+   * @returns A string representation of the TimeRange.
+   */
+  toString() {
+    return `${this.start.toString()} - ${this.end.toString()}`;
+  }
+  /**
+   * Returns a pretty string representation of the TimeRange.
+   *
+   * @returns A pretty string representation of the TimeRange.
+   */
+  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, r = h.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 = b.max(n.start, e.start), i = b.min(n.end, e.end);
+    return i.before(s) ? !1 : new h(i.sub(s)).greaterThanOrEqual(r);
+  }
+  contains(e) {
+    return e instanceof B ? this.contains(e.start) && this.contains(e.end) : this.start.beforeEq(e) && this.end.after(e);
+  }
+  /**
+   * Returns a new TimeRange that is bound by the given TimeRange.
+   *
+   * @param other - The TimeRange to bound by.
+   * @returns A new TimeRange that is bound by the given TimeRange.
+   * @example
+   * const range = new TimeRange(new TimeStamp(1000), new TimeStamp(2000));
+   * const other = new TimeRange(new TimeStamp(1500), new TimeStamp(2500));
+   * const bounded = range.boundBy(other);
+   * console.log(bounded); // TimeRange(1500, 2000)
+   */
+  boundBy(e) {
+    const r = new B(this.start, this.end);
+    return e.start.after(this.start) && (r.start = e.start), e.start.after(this.end) && (r.end = e.start), e.end.before(this.end) && (r.end = e.end), e.end.before(this.start) && (r.start = e.end), r;
+  }
+  static max(...e) {
+    return new B(
+      b.min(...e.map((r) => r.start)),
+      b.max(...e.map((r) => r.end))
+    );
+  }
+  /** The maximum possible time range. */
+  static MAX = new B(b.MIN, b.MAX);
+  /** The minimum possible time range. */
+  static MIN = new B(b.MAX, b.MIN);
+  /** A time range whose start and end are both zero. */
+  static ZERO = new B(b.ZERO, b.ZERO);
+  /** A zod schema for validating and transforming time ranges */
+  static z = a.union([
+    a.object({ start: b.z, end: b.z }).transform((e) => new B(e.start, e.end)),
+    a.instanceof(B)
+  ]);
+  /**
+   * Sorts two time ranges. The range with the earlier start time is considered less than
+   * the range with the later start time. If the start times are equal, the range with the
+   * earlier end time is considered less than the range with the later end time.
+   *
+   * @param a - The first time range.
+   * @param b - The second time range.
+   * @returns A number indicating the order of the two time ranges. This number is
+   * positive if a is earlier than b, negative if a is later than b, and 0 if they are
+   * equal.
+   */
+  static sort(e, r) {
+    return b.sort(e.start, r.start) || b.sort(e.end, r.end);
+  }
+}, T = class u extends J {
+  constructor(e) {
+    if (e instanceof u || typeof e == "string" || typeof e.valueOf() == "string")
+      super(e.valueOf());
+    else {
+      const r = u.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
+      if (r == null)
+        throw new Error(`unable to find data type for ${e.toString()}`);
+      super(r.valueOf());
+    }
+  }
+  /**
+   * @returns the TypedArray constructor for the DataType.
+   */
+  get Array() {
+    const e = u.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((r) => this.equals(r));
+  }
+  /** @returns a string representation of the DataType. */
+  toString() {
+    return this.valueOf();
+  }
+  /**
+   * @returns true if the DataType has a variable density.
+   * @example DataType.STRING.isVariable // true
+   * @example DataType.INT32.isVariable // false
+   */
+  get isVariable() {
+    return this.equals(u.JSON) || this.equals(u.STRING);
+  }
+  /**
+   * @returns true if the DataType is numeric.
+   * @example DataType.INT32.isNumeric // true
+   * @example DataType.STRING.isNumeric // false
+   */
+  get isNumeric() {
+    return !this.isVariable && !this.equals(u.UUID);
+  }
+  /**
+   * @returns true if the DataType is an integer.
+   * @example DataType.INT32.isInteger // true
+   * @example DataType.FLOAT32.isInteger // false
+   */
+  get isInteger() {
+    const e = this.toString();
+    return e.startsWith("int") || e.startsWith("uint");
+  }
+  /**
+   * @returns true if the DataType is a floating point number.
+   * @example DataType.FLOAT32.isFloat // true
+   * @example DataType.INT32.isFloat // false
+   */
+  get isFloat() {
+    return this.toString().startsWith("float");
+  }
+  /**
+   * @returns the density of the DataType.
+   * @example DataType.INT16.density // Density.BIT32
+   * @example DataType.FLOAT32.density // Density.BIT32
+   */
+  get density() {
+    const e = u.DENSITIES.get(this.toString());
+    if (e == null) throw new Error(`unable to find density for ${this.valueOf()}`);
+    return e;
+  }
+  /**
+   * @returns true if the DataType is an unsigned integer.
+   * @example DataType.UINT32.isUnsigned // true
+   * @example DataType.INT32.isUnsigned // false
+   */
+  get isUnsignedInteger() {
+    return this.equals(u.UINT8) || this.equals(u.UINT16) || this.equals(u.UINT32) || this.equals(u.UINT64);
+  }
+  /**
+   * @returns true if the DataType is a signed integer.
+   * @example DataType.INT32.isSigned // true
+   * @example DataType.UINT32.isSigned // false
+   */
+  get isSignedInteger() {
+    return this.equals(u.INT8) || this.equals(u.INT16) || this.equals(u.INT32) || this.equals(u.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.isUnsignedInteger && e.isSignedInteger ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(u.INT32) && e.equals(u.FLOAT64) || this.equals(u.INT8) && e.equals(u.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsignedInteger === e.isUnsignedInteger : !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);
+  }
+  /**
+   * Checks whether the given TypedArray is of the same type as the DataType.
+   *
+   * @param array - The TypedArray to check.
+   * @returns True if the TypedArray is of the same type as the DataType.
+   */
+  checkArray(e) {
+    return e.constructor === this.Array;
+  }
+  /** @returns true if the data type uses bigints to store values. */
+  get usesBigInt() {
+    return u.BIG_INT_TYPES.some((e) => e.equals(this));
+  }
+  /** Represents an Unknown/Invalid DataType. */
+  static UNKNOWN = new u("unknown");
+  /** Represents a 64-bit floating point value. */
+  static FLOAT64 = new u("float64");
+  /** Represents a 32-bit floating point value. */
+  static FLOAT32 = new u("float32");
+  /** Represents a 64-bit signed integer value. */
+  static INT64 = new u("int64");
+  /** Represents a 32-bit signed integer value. */
+  static INT32 = new u("int32");
+  /** Represents a 16-bit signed integer value. */
+  static INT16 = new u("int16");
+  /** Represents a 8-bit signed integer value. */
+  static INT8 = new u("int8");
+  /** Represents a 64-bit unsigned integer value. */
+  static UINT64 = new u("uint64");
+  /** Represents a 32-bit unsigned integer value. */
+  static UINT32 = new u("uint32");
+  /** Represents a 16-bit unsigned integer value. */
+  static UINT16 = new u("uint16");
+  /** Represents a 8-bit unsigned integer value. */
+  static UINT8 = new u("uint8");
+  /** Represents a boolean value. Alias for UINT8. */
+  static BOOLEAN = this.UINT8;
+  /** Represents a 64-bit unix epoch. */
+  static TIMESTAMP = new u("timestamp");
+  /** Represents a UUID data type */
+  static UUID = new u("uuid");
+  /** Represents a string data type. Strings have an unknown density, and are separate
+   * by a newline character. */
+  static STRING = new u("string");
+  /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+   * newline character. */
+  static JSON = new u("json");
+  static ARRAY_CONSTRUCTORS = /* @__PURE__ */ new Map([
+    [u.UINT8.toString(), Uint8Array],
+    [u.UINT16.toString(), Uint16Array],
+    [u.UINT32.toString(), Uint32Array],
+    [u.UINT64.toString(), BigUint64Array],
+    [u.FLOAT32.toString(), Float32Array],
+    [u.FLOAT64.toString(), Float64Array],
+    [u.INT8.toString(), Int8Array],
+    [u.INT16.toString(), Int16Array],
+    [u.INT32.toString(), Int32Array],
+    [u.INT64.toString(), BigInt64Array],
+    [u.TIMESTAMP.toString(), BigInt64Array],
+    [u.STRING.toString(), Uint8Array],
+    [u.JSON.toString(), Uint8Array],
+    [u.UUID.toString(), Uint8Array]
+  ]);
+  static ARRAY_CONSTRUCTOR_DATA_TYPES = /* @__PURE__ */ new Map([
+    [Uint8Array.name, u.UINT8],
+    [Uint16Array.name, u.UINT16],
+    [Uint32Array.name, u.UINT32],
+    [BigUint64Array.name, u.UINT64],
+    [Float32Array.name, u.FLOAT32],
+    [Float64Array.name, u.FLOAT64],
+    [Int8Array.name, u.INT8],
+    [Int16Array.name, u.INT16],
+    [Int32Array.name, u.INT32],
+    [BigInt64Array.name, u.INT64]
+  ]);
+  static DENSITIES = /* @__PURE__ */ new Map([
+    [u.UINT8.toString(), N.BIT8],
+    [u.UINT16.toString(), N.BIT16],
+    [u.UINT32.toString(), N.BIT32],
+    [u.UINT64.toString(), N.BIT64],
+    [u.FLOAT32.toString(), N.BIT32],
+    [u.FLOAT64.toString(), N.BIT64],
+    [u.INT8.toString(), N.BIT8],
+    [u.INT16.toString(), N.BIT16],
+    [u.INT32.toString(), N.BIT32],
+    [u.INT64.toString(), N.BIT64],
+    [u.TIMESTAMP.toString(), N.BIT64],
+    [u.STRING.toString(), N.UNKNOWN],
+    [u.JSON.toString(), N.UNKNOWN],
+    [u.UUID.toString(), N.BIT128]
+  ]);
+  /** All the data types. */
+  static ALL = [
+    u.UNKNOWN,
+    u.FLOAT64,
+    u.FLOAT32,
+    u.INT64,
+    u.INT32,
+    u.INT16,
+    u.INT8,
+    u.UINT64,
+    u.UINT32,
+    u.UINT16,
+    u.UINT8,
+    u.TIMESTAMP,
+    u.UUID,
+    u.STRING,
+    u.JSON
+  ];
+  static BIG_INT_TYPES = [u.INT64, u.UINT64, u.TIMESTAMP];
+  /** A zod schema for a DataType. */
+  static z = a.union([
+    a.string().transform((e) => new u(e)),
+    a.instanceof(u)
+  ]);
+};
+class m extends J {
+  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();
+  }
+  /** @returns a new Size representing the sum of the two Sizes. */
+  add(e) {
+    return m.bytes(this.valueOf() + e.valueOf());
+  }
+  /** @returns a new Size representing the difference of the two Sizes. */
+  sub(e) {
+    return m.bytes(this.valueOf() - e.valueOf());
+  }
+  /** @returns a new Size representing the truncated value of the Size. */
+  truncate(e) {
+    return new m(Math.trunc(this.valueOf() / e.valueOf()) * e.valueOf());
+  }
+  /** @returns a new Size representing the remainder of the Size. */
+  remainder(e) {
+    return m.bytes(this.valueOf() % e.valueOf());
+  }
+  /** @returns the number of gigabytes in the Size. */
+  get gigabytes() {
+    return this.valueOf() / m.GIGABYTE.valueOf();
+  }
+  /** @returns the number of megabytes in the Size. */
+  get megabytes() {
+    return this.valueOf() / m.MEGABYTE.valueOf();
+  }
+  /** @returns the number of kilobytes in the Size. */
+  get kilobytes() {
+    return this.valueOf() / m.KILOBYTE.valueOf();
+  }
+  /** @returns the number of terabytes in the Size. */
+  get terabytes() {
+    return this.valueOf() / m.TERABYTE.valueOf();
+  }
+  /** @returns a nicely formatted string representation of the Size. */
+  toString() {
+    const e = this.truncate(m.TERABYTE), r = this.truncate(m.GIGABYTE), n = this.truncate(m.MEGABYTE), s = this.truncate(m.KILOBYTE), i = this.truncate(m.BYTE), o = e, c = r.sub(e), l = n.sub(r), f = s.sub(n), p = i.sub(s);
+    let g = "";
+    return o.isZero || (g += `${o.terabytes}TB `), c.isZero || (g += `${c.gigabytes}GB `), l.isZero || (g += `${l.megabytes}MB `), f.isZero || (g += `${f.kilobytes}KB `), (!p.isZero || g === "") && (g += `${p.valueOf()}B`), g.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 m(e);
+  }
+  /** A single byte */
+  static BYTE = new m(1);
+  /**
+   * 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 m.bytes(e.valueOf() * 1e3);
+  }
+  /** A kilobyte */
+  static KILOBYTE = m.kilobytes(1);
+  /**
+   * 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 m.kilobytes(e.valueOf() * 1e3);
+  }
+  /** A megabyte */
+  static MEGABYTE = m.megabytes(1);
+  /**
+   * 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 m.megabytes(e.valueOf() * 1e3);
+  }
+  /** A gigabyte */
+  static GIGABYTE = m.gigabytes(1);
+  /**
+   * 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 m.gigabytes(e.valueOf() * 1e3);
+  }
+  /** A terabyte. */
+  static TERABYTE = m.terabytes(1);
+  /** The zero value for Size */
+  static ZERO = new m(0);
+  /** A zod schema for a Size. */
+  static z = a.union([
+    a.number().transform((e) => new m(e)),
+    a.instanceof(m)
+  ]);
+  /** @returns true if the Size is zero. */
+  get isZero() {
+    return this.valueOf() === 0;
+  }
+}
+const vo = 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)
+]), vr = (t) => {
+  const e = typeof t;
+  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || t instanceof b || t instanceof h || t instanceof Date;
+}, xi = (t, e, r, n = 0) => t.usesBigInt && !e.usesBigInt ? Number(r) - Number(n) : !t.usesBigInt && e.usesBigInt ? BigInt(r.valueOf()) - BigInt(n.valueOf()) : Me(r, -n), Me = (t, e) => e == 0 ? t : t == 0 ? e : typeof t == "bigint" && typeof e == "bigint" || typeof t == "number" && typeof e == "number" ? t + e : Number(t) + Number(e), $i = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function Si(t) {
+  return typeof t == "string" && $i.test(t);
+}
+const $ = [];
+for (let t = 0; t < 256; ++t)
+  $.push((t + 256).toString(16).slice(1));
+function Ni(t, e = 0) {
+  return ($[t[e + 0]] + $[t[e + 1]] + $[t[e + 2]] + $[t[e + 3]] + "-" + $[t[e + 4]] + $[t[e + 5]] + "-" + $[t[e + 6]] + $[t[e + 7]] + "-" + $[t[e + 8]] + $[t[e + 9]] + "-" + $[t[e + 10]] + $[t[e + 11]] + $[t[e + 12]] + $[t[e + 13]] + $[t[e + 14]] + $[t[e + 15]]).toLowerCase();
+}
+function Ii(t, e = 0) {
+  const r = Ni(t, e);
+  if (!Si(r))
+    throw TypeError("Stringified UUID is invalid");
+  return r;
+}
+typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const Tr = (t, e) => Ii(t, e), L = -1, it = {
+  [Symbol.iterator]: () => it,
+  next: () => ({ done: !0, value: void 0 })
+}, Mi = a.string().transform(
+  (t) => new Uint8Array(
+    atob(t).split("").map((e) => e.charCodeAt(0))
+  ).buffer
+), Ei = a.union([a.null(), a.undefined()]).transform(() => new Uint8Array().buffer), at = 10, xr = (t, e) => {
+  if (t === "number" && !e.isNumeric)
+    throw new Error(`cannot convert series of type ${e.toString()} to number`);
+  if (t === "bigint" && !e.usesBigInt)
+    throw new Error(`cannot convert series of type ${e.toString()} to bigint`);
+}, $r = "sy_x_telem_series";
+let Sr = class D {
+  /**
+   * A unique identifier for the series. If specified by the user, it is their
+   * responsibility to ensure that it is unique. If not specified, a new ID will be
+   * generated.
+   */
+  key;
+  /**
+   * A discriminator used for identifying instances of the series class even
+   * when bundlers mangle the class name.
+   */
+  discriminator = $r;
+  /** The data type of the series. */
+  dataType;
+  /**
+   * A sample offset that can be used to shift the values of all samples upwards or
+   * downwards. Useful to convert series to lower precision data types while preserving
+   * the relative range of actual values.
+   */
+  sampleOffset;
+  /**
+   * Stores information about the buffer state of this array into a WebGL buffer.
+   */
+  gl;
+  /** The underlying data. */
+  _data;
+  /** The time range occupied by the series' data. */
+  timeRange = V.ZERO;
+  /**
+   * Alignment defines the location of the series relative to other series in a logical
+   * group. Useful for defining the position of the series within a channel's data.
+   */
+  alignment = 0n;
+  /** A cached minimum value. */
+  cachedMin;
+  /** A cached maximum value. */
+  cachedMax;
+  /** The write position of the buffer. */
+  writePos = L;
+  /** Tracks the number of entities currently using this array. */
+  _refCount = 0;
+  /** Caches the length of the array for variable length data types. */
+  cachedLength;
+  /** Caches the indexes of the array for variable length data types. */
+  _cachedIndexes;
+  /**
+   * A zod schema that can be used to validate that a particular value
+   * can be constructed into a series.
+   */
+  static crudeZ = a.object({
+    timeRange: V.z.optional(),
+    dataType: T.z,
+    alignment: a.coerce.bigint().optional(),
+    data: a.union([
+      Mi,
+      Ei,
+      a.instanceof(ArrayBuffer),
+      a.instanceof(Uint8Array)
+    ]),
+    glBufferUsage: vi.optional().default("static").optional()
+  });
+  /**
+   * A zod schema that validates and constructs a series from it's crude
+   * representation.
+   */
+  static z = D.crudeZ.transform((e) => new D(e));
+  /**
+   * The Series constructor accepts either a SeriesArgs object or a CrudeSeries value.
+   *
+   * SeriesArgs interface properties:
+   * @property {CrudeSeries | null} [data] - The data to construct the series from. Can be:
+   *   - A typed array (e.g. Float32Array, Int32Array)
+   *   - A JS array of numbers, strings, or objects
+   *   - A single value (number, string, bigint, etc.)
+   *   - An ArrayBuffer
+   *   - Another Series instance
+   * @property {CrudeDataType} [dataType] - The data type of the series. If not provided,
+   *   will be inferred from the data. Required when constructing from an ArrayBuffer, or
+   *   an empty JS array.
+   * @property {TimeRange} [timeRange] - The time range occupied by the series' data.
+   *   Defaults to TimeRange.ZERO.
+   * @property {math.Numeric} [sampleOffset] - An offset to apply to each sample value.
+   *   Useful for converting arrays to lower precision while preserving relative range.
+   *   Defaults to 0.
+   * @property {GLBufferUsage} [glBufferUsage] - The WebGL buffer usage hint. Can be
+   *   "static" or "dynamic". Defaults to "static".
+   * @property {bigint} [alignment] - The logical position of the series relative to other
+   *   series in a group. Defaults to 0n.
+   * @property {string} [key] - A unique identifier for the series. If not provided,
+   *   a new ID will be generated.
+   *
+   * @example
+   * // Create a series from a typed array
+   * const s1 = new Series(new Float32Array([1, 2, 3]));
+   *
+   * @example
+   * // Create a series from a JS array with explicit data type
+   * const s2 = new Series({ data: [1, 2, 3], dataType: DataType.FLOAT32 });
+   *
+   * @example
+   * // Create a series from a single value (data type inferred)
+   * const s3 = new Series(1); // Creates a FLOAT64 series
+   * const s4 = new Series("abc"); // Creates a STRING series
+   * const s5 = new Series(1n); // Creates an INT64 series
+   *
+   * @example
+   * // Create a series from objects (automatically uses JSON data type)
+   * const s6 = new Series([{ a: 1, b: "apple" }]);
+   *
+   * @example
+   * // Create a series with time range and alignment
+   * const s7 = new Series({
+   *   data: new Float32Array([1, 2, 3]),
+   *   timeRange: new TimeRange(1, 2),
+   *   alignment: 1n
+   * });
+   *
+   * @example
+   * // Create a series from another series (copies properties)
+   * const s8 = new Series(s1);
+   *
+   * @example
+   * // Create a series with sample offset
+   * const s9 = new Series({
+   *   data: new Float32Array([1, 2, 3]),
+   *   sampleOffset: 2
+   * }); // Values will be 3, 4, 5
+   *
+   * @example
+   * // Create a series with WebGL buffer usage
+   * const s10 = new Series({
+   *   data: new Float32Array([1, 2, 3]),
+   *   glBufferUsage: "dynamic"
+   * });
+   *
+   * @throws Error if constructing from an empty JS array without specifying data type
+   * @throws Error if constructing from an ArrayBuffer without specifying data type
+   * @throws Error if data type cannot be inferred from input
+   */
+  constructor(e) {
+    Ai(e) && (e = { data: e }), e.data ??= [];
+    const {
+      dataType: r,
+      timeRange: n,
+      sampleOffset: s = 0,
+      glBufferUsage: i = "static",
+      alignment: o = 0n,
+      key: c = At(),
+      data: l
+    } = e;
+    if (Nr(l)) {
+      const g = l;
+      this.key = g.key, this.dataType = g.dataType, this.sampleOffset = g.sampleOffset, this.gl = g.gl, this._data = g._data, this.timeRange = g.timeRange, this.alignment = g.alignment, this.cachedMin = g.cachedMin, this.cachedMax = g.cachedMax, this.writePos = g.writePos, this._refCount = g._refCount, this.cachedLength = g.cachedLength;
+      return;
+    }
+    const f = vr(l), p = Array.isArray(l);
+    if (r != null) this.dataType = new T(r);
+    else {
+      if (l instanceof ArrayBuffer)
+        throw new Error(
+          "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
+        );
+      if (p || f) {
+        let g = l;
+        if (!f) {
+          if (l.length === 0)
+            throw new Error(
+              "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
+            );
+          g = l[0];
+        }
+        if (typeof g == "string") this.dataType = T.STRING;
+        else if (typeof g == "number") this.dataType = T.FLOAT64;
+        else if (typeof g == "bigint") this.dataType = T.INT64;
+        else if (typeof g == "boolean") this.dataType = T.BOOLEAN;
+        else if (g instanceof b || g instanceof Date || g instanceof b)
+          this.dataType = T.TIMESTAMP;
+        else if (typeof g == "object") this.dataType = T.JSON;
+        else
+          throw new Error(
+            `cannot infer data type of ${typeof g} when constructing a Series from a JS array`
+          );
+      } else this.dataType = new T(l);
+    }
+    if (!p && !f) this._data = l;
+    else if (p && l.length === 0)
+      this._data = new this.dataType.Array([]).buffer;
+    else {
+      let g = f ? [l] : l;
+      const S = g[0];
+      (S instanceof b || S instanceof Date || S instanceof h) && (g = g.map((E) => new b(E).valueOf())), this.dataType.equals(T.STRING) ? (this.cachedLength = g.length, this._data = new TextEncoder().encode(`${g.join(`
+`)}
+`).buffer) : this.dataType.equals(T.JSON) ? (this.cachedLength = g.length, this._data = new TextEncoder().encode(
+        `${g.map((E) => He.encodeString(E)).join(`
+`)}
+`
+      ).buffer) : this.dataType.usesBigInt && typeof S == "number" ? this._data = new this.dataType.Array(
+        g.map((E) => BigInt(Math.round(E)))
+      ).buffer : !this.dataType.usesBigInt && typeof S == "bigint" ? this._data = new this.dataType.Array(
+        g.map(Number)
+      ).buffer : this._data = new this.dataType.Array(g).buffer;
+    }
+    this.key = c, this.alignment = o, this.sampleOffset = s ?? 0, this.timeRange = n ?? V.ZERO, this.gl = {
+      control: null,
+      buffer: null,
+      prevBuffer: 0,
+      bufferUsage: i
+    };
+  }
+  /**
+   * Allocates a new series with a given capacity and data type.
+   * @param args.capacity the capacity of the series in samples. If the data type is of
+   * variable density (i.e. JSON, STRING, BYTES), this is the capacity in bytes.
+   * @param args.dataType the data type of the series.
+   * @param args.rest the rest of the arguments to pass to the series constructor.
+   */
+  static alloc({ capacity: e, dataType: r, ...n }) {
+    if (e === 0)
+      throw new Error("[Series] - cannot allocate an array of length 0");
+    const s = new new T(r).Array(e), i = new D({ data: s.buffer, dataType: r, ...n });
+    return i.writePos = 0, i;
+  }
+  /**
+   * @returns the number of references to this series i.e. the number of times this
+   * series has been acquired (by calling acquire) and not released (by calling
+   * release).
+   */
+  get refCount() {
+    return this._refCount;
+  }
+  /**
+   * Acquires a reference to this series, optionally buffering its data into the
+   * specified buffer controller. This method is useful for managing the life span
+   * of series buffered to the GPU.
+   * @param gl the buffer controller to buffer the series to. If not provided, the series
+   * will not be buffered to the GPU.
+   */
+  acquire(e) {
+    this._refCount++, e != null && this.updateGLBuffer(e);
+  }
+  /**
+   * Releases a reference to this series. If the reference count to the series reaches
+   * 0 and the series has been buffered to the GPU, the series will be deleted from
+   * the GPU.
+   */
+  release() {
+    this._refCount--, this.refCount === 0 && this.gl.control != null ? this.maybeGarbageCollectGLBuffer(this.gl.control) : this.refCount < 0 && console.warn("cannot release a series with a negative reference count");
+  }
+  /**
+   * 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 === L) return 0;
+    const r = this.byteCapacity.valueOf() - this.writePos, n = e.subBytes(0, r);
+    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 === L) return 0;
+    const r = this.capacity - this.writePos, n = e.sub(0, r);
+    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 JS typed array with the proper data type.
+   * If the series is not full, returns a view of the data up to the write position.
+   * @returns A typed array containing the series data.
+   */
+  get data() {
+    return this.writePos === L ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
+  }
+  /**
+   * Returns an array of the values in the series as strings.
+   * For variable length data types (like STRING or JSON), this decodes the underlying buffer.
+   * @returns An array of string representations of the series values.
+   */
+  toStrings() {
+    return this.dataType.isVariable ? new TextDecoder().decode(this.underlyingData).split(`
+`).slice(0, -1) : Array.from(this).map((e) => e.toString());
+  }
+  /**
+   * Parses a JSON series into an array of values using the provided zod schema.
+   * @template Z The zod schema type.
+   * @param schema The zod schema to use to parse the JSON series.
+   * @throws Error if the series does not have a data type of JSON.
+   * @returns An array of values parsed from the JSON series.
+   */
+  parseJSON(e) {
+    if (!this.dataType.equals(T.JSON))
+      throw new Error("cannot parse non-JSON series as JSON");
+    return this.toStrings().map((r) => e.parse(He.decodeString(r)));
+  }
+  /**
+   * Returns the capacity of the series in bytes.
+   * @returns The size of the underlying buffer in bytes.
+   */
+  get byteCapacity() {
+    return new m(this.underlyingData.byteLength);
+  }
+  /**
+   * Returns the capacity of the series in samples.
+   * For variable length data types, this is the capacity in bytes.
+   * @returns The number of samples that can be stored in the series.
+   */
+  get capacity() {
+    return this.dataType.isVariable ? this.byteCapacity.valueOf() : this.dataType.density.length(this.byteCapacity);
+  }
+  /**
+   * Returns the length of the series in bytes.
+   * For variable length data types, this is the actual number of bytes used.
+   * @returns The size of the data in bytes.
+   */
+  get byteLength() {
+    return this.writePos === L ? this.byteCapacity : this.dataType.isVariable ? new m(this.writePos) : this.dataType.density.size(this.writePos);
+  }
+  /**
+   * Returns the number of samples in this array.
+   * For variable length data types, this is calculated by counting newlines.
+   * @returns The number of samples in the series.
+   */
+  get length() {
+    return this.cachedLength != null ? this.cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === L ? this.byteCapacity.valueOf() / this.dataType.density.valueOf() : this.writePos;
+  }
+  calculateCachedLength() {
+    if (!this.dataType.isVariable)
+      throw new Error("cannot calculate length of a non-variable length data type");
+    let e = 0;
+    const r = [0];
+    return this.data.forEach((n, s) => {
+      n === at && (e++, r.push(s + 1));
+    }), this._cachedIndexes = r, 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, r = 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] = xi(this.dataType, e, this.data[s], r);
+    return new D({
+      data: n.buffer,
+      dataType: e,
+      timeRange: this.timeRange,
+      sampleOffset: r,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment
+    });
+  }
+  calcRawMax() {
+    if (this.length === 0) return -1 / 0;
+    if (this.dataType.equals(T.TIMESTAMP))
+      this.cachedMax = this.data[this.data.length - 1];
+    else if (this.dataType.usesBigInt) {
+      const e = this.data;
+      this.cachedMax = e.reduce((r, n) => r > n ? r : n);
+    } else {
+      const e = this.data;
+      this.cachedMax = e.reduce((r, n) => r > n ? r : n);
+    }
+    return this.cachedMax;
+  }
+  /** @returns the maximum value in the array */
+  get max() {
+    return this.calcMax();
+  }
+  calcMax() {
+    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.calcRawMax(), Me(this.cachedMax, this.sampleOffset));
+  }
+  calcRawMin() {
+    if (this.length === 0) return 1 / 0;
+    if (this.dataType.equals(T.TIMESTAMP)) this.cachedMin = this.data[0];
+    else if (this.dataType.usesBigInt) {
+      const e = this.data;
+      this.cachedMin = e.reduce((r, n) => r < n ? r : n);
+    } else {
+      const e = this.data;
+      this.cachedMin = e.reduce((r, n) => r < n ? r : n);
+    }
+    return this.cachedMin;
+  }
+  /** @returns the minimum value in the array */
+  get min() {
+    return this.calcMin();
+  }
+  calcMin() {
+    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.calcRawMin(), Me(this.cachedMin, this.sampleOffset));
+  }
+  /** @returns the bounds of the series. */
+  get bounds() {
+    return y(Number(this.min), Number(this.max), { makeValid: !1 });
+  }
+  maybeRecomputeMinMax(e) {
+    if (this.cachedMin != null) {
+      const r = e.cachedMin ?? e.calcRawMin();
+      r < this.cachedMin && (this.cachedMin = r);
+    }
+    if (this.cachedMax != null) {
+      const r = e.cachedMax ?? e.calcRawMax();
+      r > this.cachedMax && (this.cachedMax = r);
+    }
+  }
+  atAlignment(e, r) {
+    const n = Number(e - this.alignment);
+    if (n < 0 || n >= this.length) {
+      if (r === !0) throw new Error(`[series] - no value at index ${n}`);
+      return;
+    }
+    return this.at(n, r);
+  }
+  at(e, r = !1) {
+    if (this.dataType.isVariable) return this.atVariable(e, r ?? !1);
+    if (this.dataType.equals(T.UUID)) return this.atUUID(e, r);
+    e < 0 && (e = this.length + e);
+    const n = this.data[e];
+    if (n == null) {
+      if (r === !0) throw new Error(`[series] - no value at index ${e}`);
+      return;
+    }
+    return Me(n, this.sampleOffset);
+  }
+  atUUID(e, r) {
+    e < 0 && (e = this.length + e);
+    const n = Tr(
+      new Uint8Array(this.buffer, e * this.dataType.density.valueOf())
+    );
+    if (n == null) {
+      if (r) throw new Error(`[series] - no value at index ${e}`);
+      return;
+    }
+    return n;
+  }
+  atVariable(e, r) {
+    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] === at) {
+          if (e === 0) {
+            s = o;
+            break;
+          }
+          n = o + 1, e--;
+        }
+      if (s === 0 && (s = this.data.length), n >= s || e > 0) {
+        if (r) throw new Error(`[series] - no value at index ${e}`);
+        return;
+      }
+    }
+    const i = this.data.slice(n, s);
+    return this.dataType.equals(T.STRING) ? new TextDecoder().decode(i) : ct(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 r = 0, n = this.length - 1;
+    const s = Be(e);
+    for (; r <= n; ) {
+      const i = Math.floor((r + n) / 2), o = s(this.at(i, !0), e);
+      if (o === 0) return i;
+      o < 0 ? r = i + 1 : n = i - 1;
+    }
+    return r;
+  }
+  /**
+   * Updates the WebGL buffer for the series if it is not up to date. This method
+   * should be called whenever a series has been previously buffered to the GPU and
+   * then modified via calls to write().
+   * @param gl the buffer controller to update the buffer for. This controller should
+   * be the same buffer previously passed to {@method acquire} or {@method updateGLBuffer}.
+   */
+  updateGLBuffer(e) {
+    if (this.gl.control = e, !this.dataType.equals(T.FLOAT32) && !this.dataType.equals(T.UINT8))
+      throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
+    const { buffer: r, bufferUsage: n, prevBuffer: s } = this.gl;
+    if (r == null && (this.gl.buffer = e.createBuffer()), this.writePos !== s)
+      if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== L) {
+        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 = L;
+  }
+  as(e) {
+    return xr(e, this.dataType), this;
+  }
+  /** @returns a digest containing information about the series. */
+  get digest() {
+    return {
+      key: this.key,
+      dataType: this.dataType.toString(),
+      sampleOffset: this.sampleOffset,
+      alignment: {
+        lower: Pt(this.alignmentBounds.lower),
+        upper: Pt(this.alignmentBounds.upper)
+      },
+      timeRange: this.timeRange.toString(),
+      length: this.length,
+      capacity: this.capacity
+    };
+  }
+  /**
+   * @returns the alignment bounds of the series, representing the logical space
+   * occupied by the series in a group of series. This is typically used to order the
+   * series within a channel's data.
+   *
+   * The lower bound is the alignment of the first sample, and the upper bound is the
+   * alignment of the last sample + 1. The lower bound is inclusive, while the upper bound
+   * is exclusive.
+   */
+  get alignmentBounds() {
+    return y(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);
+  }
+  /**
+   * @returns the WebGL buffer for the series. This method should only be called after
+   * the series has been buffered to the GPU via a call to {@method acquire} or
+   * {@method updateGLBuffer}.
+   * @throws if the series has not been buffered to the GPU.
+   */
+  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 Bi(this);
+      return this.dataType.equals(T.JSON) ? new Ui(e) : e;
+    }
+    return this.dataType.equals(T.UUID) ? new Ci(this) : new ji(this);
+  }
+  /**
+   * Returns a slice of the series from start to end.
+   * @param start The start index (inclusive).
+   * @param end The end index (exclusive).
+   * @returns A new series containing the sliced data.
+   */
+  slice(e, r) {
+    return this.sliceSub(!1, e, r);
+  }
+  /**
+   * Returns a subarray view of the series from start to end.
+   * @param start The start index (inclusive).
+   * @param end The end index (exclusive).
+   * @returns A new series containing the subarray data.
+   */
+  sub(e, r) {
+    return this.sliceSub(!0, e, r);
+  }
+  /**
+   * Returns an iterator over a portion of the series.
+   * @param start The start index (inclusive).
+   * @param end The end index (exclusive).
+   * @returns An iterator over the specified range.
+   */
+  subIterator(e, r) {
+    return new Dt(this, e, r ?? this.length);
+  }
+  /**
+   * Returns an iterator over a portion of the series based on alignment.
+   * @param start The start alignment (inclusive).
+   * @param end The end alignment (exclusive).
+   * @returns An iterator over the specified alignment range.
+   */
+  subAlignmentIterator(e, r) {
+    return new Dt(
+      this,
+      Number(e - this.alignment),
+      Number(r - this.alignment)
+    );
+  }
+  subBytes(e, r) {
+    if (e >= 0 && (r == null || r >= this.byteLength.valueOf())) return this;
+    const n = this.data.subarray(e, r);
+    return new D({
+      data: n,
+      dataType: this.dataType,
+      timeRange: this.timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + BigInt(e)
+    });
+  }
+  sliceSub(e, r, n) {
+    if (r <= 0 && (n == null || n >= this.length)) return this;
+    let s;
+    return e ? s = this.data.subarray(r, n) : s = this.data.slice(r, n), new D({
+      data: s,
+      dataType: this.dataType,
+      timeRange: this.timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + BigInt(r)
+    });
+  }
+  /**
+   * Creates a new series with a different alignment.
+   * @param alignment The new alignment value.
+   * @returns A new series with the specified alignment.
+   */
+  reAlign(e) {
+    return new D({
+      data: this.buffer,
+      dataType: this.dataType,
+      timeRange: V.ZERO,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: "static",
+      alignment: e
+    });
+  }
+  /**
+   * Returns a string representation of the series.
+   * For series with more than 10 elements, shows the first 5 and last 5 elements.
+   * @returns A string representation of the series.
+   */
+  toString() {
+    let e = `Series(${this.dataType.toString()} ${this.length} [`;
+    if (this.length <= 10) e += Array.from(this).map((r) => r.toString());
+    else {
+      for (let r = 0; r < 5; r++)
+        e += `${this.at(r)?.toString()}`, e += ",";
+      e += "...,";
+      for (let r = -5; r < 0; r++)
+        e += this.at(r)?.toString(), r < -1 && (e += ",");
+    }
+    return e += "])", e;
+  }
+};
+const Ai = (t) => t == null ? !1 : Array.isArray(t) || t instanceof ArrayBuffer || ArrayBuffer.isView(t) && !(t instanceof DataView) || t instanceof Sr ? !0 : vr(t), Nr = Oi($r, Sr);
+let Dt = class {
+  series;
+  end;
+  index;
+  constructor(e, r, n) {
+    this.series = e;
+    const s = y(0, e.length);
+    this.end = Qe(s, n), this.index = Qe(s, r);
+  }
+  next() {
+    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
+  }
+};
+class Bi {
+  series;
+  index;
+  decoder;
+  constructor(e) {
+    if (!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, r = this.series.data;
+    for (; this.index < r.length && r[this.index] !== at; ) 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)) });
+  }
+}
+let Ui = class Ir {
+  wrapped;
+  static schema = a.record(a.string(), a.unknown());
+  constructor(e) {
+    this.wrapped = e;
+  }
+  next() {
+    const e = this.wrapped.next();
+    return e.done === !0 ? { done: !0, value: void 0 } : {
+      done: !1,
+      value: He.decodeString(e.value, Ir.schema)
+    };
+  }
+}, Ci = class {
+  series;
+  index;
+  data;
+  density;
+  constructor(e) {
+    if (!e.dataType.equals(T.UUID))
+      throw new Error("cannot create a UUID series iterator for a non-UUID series");
+    this.series = e, this.index = 0, this.data = new Uint8Array(e.buffer), this.density = T.UUID.density.valueOf();
+  }
+  next() {
+    if (this.index >= this.series.length) return { done: !0, value: void 0 };
+    const e = Tr(this.data, this.index * this.density);
+    return this.index++, { done: !1, value: e };
+  }
+}, ji = class {
+  series;
+  index;
+  constructor(e) {
+    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)
+    };
+  }
+}, So = class {
+  /** The array of series in this collection */
+  series;
+  /**
+   * The MultiSeries constructor accepts an optional array of Series instances. All series
+   * in the collection must have the same data type.
+   *
+   * @example
+   * // Create an empty MultiSeries
+   * const ms1 = new MultiSeries();
+   *
+   * @example
+   * // Create a MultiSeries from multiple numeric series
+   * const s1 = new Series(new Float32Array([1, 2, 3]));
+   * const s2 = new Series(new Float32Array([4, 5, 6]));
+   * const ms2 = new MultiSeries([s1, s2]);
+   *
+   * @example
+   * // Create a MultiSeries from string series
+   * const s3 = new Series(["apple", "banana"]);
+   * const s4 = new Series(["carrot", "date"]);
+   * const ms3 = new MultiSeries([s3, s4]);
+   *
+   * @example
+   * // Create a MultiSeries from JSON series
+   * const s5 = new Series([{ a: 1, b: "apple" }]);
+   * const s6 = new Series([{ a: 2, b: "banana" }]);
+   * const ms4 = new MultiSeries([s5, s6]);
+   *
+   * @example
+   * // Add series to an existing MultiSeries
+   * const ms5 = new MultiSeries();
+   * ms5.push(s1);
+   * ms5.push(s2);
+   *
+   * @example
+   * // Combine two MultiSeries
+   * const ms6 = new MultiSeries([s1]);
+   * const ms7 = new MultiSeries([s2]);
+   * ms6.push(ms7);
+   *
+   * @throws Error if attempting to add a series with a different data type
+   */
+  constructor(e = []) {
+    if (e.length !== 0) {
+      const r = e[0].dataType;
+      for (let n = 1; n < e.length; n++)
+        if (!e[n].dataType.equals(r))
+          throw new Error("[multi-series] - series must have the same data type");
+    }
+    this.series = e;
+  }
+  as(e) {
+    return xr(e, this.dataType), this;
+  }
+  /**
+   * Returns the data type of the series in this collection. If the collection is empty,
+   * returns DataType.UNKNOWN.
+   */
+  get dataType() {
+    return this.series.length === 0 ? T.UNKNOWN : this.series[0].dataType;
+  }
+  /**
+   * Returns the combined time range of all series in the collection. If the collection
+   * is empty, returns TimeRange.ZERO. The time range spans from the start of the first
+   * series to the end of the last series.
+   */
+  get timeRange() {
+    return this.series.length === 0 ? V.ZERO : new V(
+      this.series[0].timeRange.start,
+      this.series[this.series.length - 1].timeRange.end
+    );
+  }
+  /**
+   * Returns the alignment of the first series in the collection. If the collection is
+   * empty, returns 0n.
+   */
+  get alignment() {
+    return this.series.length === 0 ? 0n : this.series[0].alignment;
+  }
+  /**
+   * Returns the alignment bounds of the entire collection. The lower bound is the
+   * alignment of the first series, and the upper bound is the alignment of the last
+   * series + its length. If the collection is empty, returns bounds.construct(0n, 0n).
+   */
+  get alignmentBounds() {
+    return this.series.length === 0 ? y(0n, 0n) : y(
+      this.series[0].alignmentBounds.lower,
+      this.series[this.series.length - 1].alignmentBounds.upper
+    );
+  }
+  push(e) {
+    const r = () => new Error(
+      `cannot push a ${e.dataType.toString()} series to a ${this.dataType.toString()} multi-series`
+    ), n = e.dataType.equals(this.dataType);
+    if (Nr(e)) {
+      if (this.series.length !== 0 && !n) throw r();
+      this.series.push(e);
+    } else {
+      if (this.series.length !== 0 && e.series.length !== 0 && !n)
+        throw r();
+      this.series.push(...e.series);
+    }
+  }
+  /**
+   * Returns the total length of all series in the collection.
+   * @returns The sum of the lengths of all series.
+   */
+  get length() {
+    return this.series.reduce((e, r) => e + r.length, 0);
+  }
+  atAlignment(e, r) {
+    for (const n of this.series)
+      if (I(n.alignmentBounds, e))
+        return n.atAlignment(e, r);
+    if (r) throw new Error(`[series] - no value at alignment ${e}`);
+  }
+  at(e, r = !1) {
+    e < 0 && (e = this.length + e);
+    for (const n of this.series) {
+      if (e < n.length) return n.at(e, r);
+      e -= n.length;
+    }
+    if (r) throw new Error(`[series] - no value at index ${e}`);
+  }
+  /**
+   * Returns an iterator over a portion of the multi-series.
+   * @param start - The start index (inclusive).
+   * @param end - The end index (exclusive).
+   * @returns An iterator over the specified range.
+   */
+  subIterator(e, r) {
+    return new Ye(this, e, r ?? this.length);
+  }
+  /**
+   * Returns an iterator over a portion of the multi-series based on alignment.
+   * @param start - The start alignment (inclusive).
+   * @param end - The end alignment (exclusive).
+   * @returns An iterator over the specified alignment range.
+   */
+  subAlignmentIterator(e, r) {
+    if (e >= this.alignmentBounds.upper || r <= this.alignmentBounds.lower)
+      return it;
+    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 (I(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 (r < o.alignment) break;
+      if (r >= o.alignmentBounds.upper) s += o.length;
+      else if (I(o.alignmentBounds, r)) {
+        s += Number(r - o.alignment);
+        break;
+      }
+    }
+    return new Ye(this, n, s);
+  }
+  /**
+   * Returns an iterator over the specified alignment range and span.
+   * @param start - The start alignment (inclusive).
+   * @param span - The number of samples to include.
+   * @returns An iterator over the specified range.
+   */
+  subAlignmentSpanIterator(e, r) {
+    if (e >= this.alignmentBounds.upper) return it;
+    r = Math.min(r, Number(this.distance(e, this.alignmentBounds.upper)));
+    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 (I(i.alignmentBounds, e)) {
+        n += Number(e - i.alignment);
+        break;
+      }
+    }
+    return new Ye(this, n, n + r);
+  }
+  /**
+   * Updates the WebGL buffer for all series in the collection.
+   * @param gl - The WebGL buffer controller to use.
+   */
+  updateGLBuffer(e) {
+    this.series.forEach((r) => r.updateGLBuffer(e));
+  }
+  /**
+   * Returns the bounds containing the minimum and maximum values across all series.
+   */
+  get bounds() {
+    return rr(this.series.map((e) => e.bounds));
+  }
+  /**
+   * Returns the sum of the byte lengths of all series.
+   */
+  get byteLength() {
+    return new m(this.series.reduce((e, r) => e + r.byteLength.valueOf(), 0));
+  }
+  /**
+   * Returns a combined typed array containing all data from all series.
+   * @returns A typed array containing all data from all series.
+   */
+  get data() {
+    const e = new this.dataType.Array(this.length);
+    let r = 0;
+    for (const n of this.series)
+      e.set(n.data, r), r += n.length;
+    return new this.dataType.Array(e.buffer);
+  }
+  /**
+   * Traverses the alignment space by a given distance from a start point.
+   * @param start - The starting alignment.
+   * @param dist - The distance to traverse.
+   * @returns The resulting alignment after traversal.
+   */
+  traverseAlignment(e, r) {
+    const n = this.series.map((s) => s.alignmentBounds);
+    return nr(n, e, r);
+  }
+  /**
+   * Acquires a reference to the WebGL buffer for all series.
+   * @param gl - Optional WebGL buffer controller to use.
+   */
+  acquire(e) {
+    this.series.forEach((r) => r.acquire(e));
+  }
+  /**
+   * Releases the WebGL buffer reference for all series.
+   */
+  release() {
+    this.series.forEach((e) => e.release());
+  }
+  /**
+   * Calculates the number of samples between two alignments in the multi-series.
+   * @param start - The starting alignment.
+   * @param end - The ending alignment.
+   * @returns The distance between the alignments.
+   */
+  distance(e, r) {
+    const n = this.series.map((s) => s.alignmentBounds);
+    return sr(n, e, r);
+  }
+  /**
+   * Parses a JSON multi-series into an array of values using the provided zod schema.
+   * @template Z - The zod schema type.
+   * @param schema - The zod schema to use to parse the JSON series.
+   * @throws Error if the series does not have a data type of JSON.
+   * @returns An array of values parsed from the JSON series.
+   */
+  parseJSON(e) {
+    if (!this.dataType.equals(T.JSON))
+      throw new Error("cannot parse non-JSON series as JSON");
+    return this.series.flatMap((r) => r.parseJSON(e));
+  }
+  /**
+   * Returns an iterator over all values in the multi-series.
+   * @returns An iterator that yields all values from all series in sequence.
+   */
+  [Symbol.iterator]() {
+    return this.series.length === 0 ? {
+      next() {
+        return { done: !0, value: void 0 };
+      }
+    } : new Ri(this.series);
+  }
+  /**
+   * Returns an array of the values in the multi-series as strings.
+   * For variable length data types (like STRING or JSON), this decodes the underlying buffer.
+   * @returns An array of string representations of the multi-series values.
+   */
+  toStrings() {
+    return this.series.flatMap((e) => e.toStrings());
+  }
+}, Ri = class {
+  series;
+  seriesIndex;
+  internal;
+  constructor(e) {
+    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());
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}, Ye = class {
+  series;
+  index;
+  end;
+  constructor(e, r, n) {
+    this.series = e, this.end = n, this.index = r;
+  }
+  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 Pt = (t) => {
+  const e = t >> 32n, r = t & 0xffffffffn;
+  return { domain: e, sample: r };
+};
+a.object({ key: a.string(), value: a.string() });
+const Li = a.record(
+  a.union([a.number(), a.string(), a.symbol()]),
+  a.unknown()
+), Bt = (t) => Object.entries(t), Di = (t, e) => Object.fromEntries(Bt(t).map(([r, n]) => [r, e(n, r)])), Pi = (t) => Object.fromEntries(Bt(t).filter(([e, r]) => r !== void 0)), Eo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  entries: Bt,
+  map: Di,
+  purgeUndefined: Pi,
+  unknownZ: Li
+}, Symbol.toStringTag, { value: "Module" })), Mr = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", qi = Mr(), Er = ["macOS", "Windows", "Linux"], ki = ["macos", "windows", "linux"], zi = {
+  macos: "macOS",
+  windows: "Windows",
+  linux: "Linux"
+}, Fi = a.enum(Er).or(
+  a.enum(ki).transform((t) => zi[t])
+), Zi = () => {
+  if (typeof window > "u") return;
+  const t = window.navigator.userAgent.toLowerCase();
+  if (t.includes("mac")) return "macOS";
+  if (t.includes("win")) return "Windows";
+  if (t.includes("linux")) return "Linux";
+};
+let Ve;
+const Yi = (t = {}) => {
+  const { force: e, default: r } = t;
+  return e ?? Ve ?? (Ve = Zi(), Ve ?? r);
+}, Ao = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  OPERATING_SYSTEMS: Er,
+  RUNTIME: qi,
+  detect: Mr,
+  getOS: Yi,
+  osZ: Fi
+}, Symbol.toStringTag, { value: "Module" })), Vi = (...t) => t.map(Ar).join(""), Ar = (t) => (t.endsWith("/") || (t += "/"), t.startsWith("/") && (t = t.slice(1)), t), Wi = (t) => t.endsWith("/") ? t.slice(0, -1) : t;
+class Ee {
+  protocol;
+  host;
+  port;
+  path;
+  /**
+   * @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: r, protocol: n = "", pathPrefix: s = "" }) {
+    this.protocol = n, this.host = e, this.port = r, this.path = Ar(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 Ee({
+      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 Ee({
+      ...this,
+      pathPrefix: Vi(this.path, e)
+    });
+  }
+  /** @returns a string representation of the url */
+  toString() {
+    return Wi(
+      `${this.protocol}://${this.host}:${this.port}/${this.path}`
+    );
+  }
+  static UNKNOWN = new Ee({ host: "unknown", port: 0 });
+}
+const Gi = 2, Hi = 3, Ji = 2, Xi = (t, e) => {
+  if (Number.isNaN(t) || !Number.isFinite(t)) return t;
+  const r = ye(e);
+  if (r == 0) return t;
+  let n;
+  r >= 1e3 ? n = Gi : r >= 1 ? n = Hi : n = Math.ceil(-Math.log10(r)) + Ji;
+  const s = 10 ** n;
+  return Math.round(t * s) / s;
+}, Bo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  abs: er,
+  add: Qt,
+  closeTo: In,
+  div: An,
+  equal: Ke,
+  max: En,
+  min: _t,
+  mult: Y,
+  roundBySpan: Xi,
+  roundToNearestMagnitude: Mn,
+  sub: ae
+}, Symbol.toStringTag, { value: "Module" }));
+a.object({
+  baseInterval: h.z.optional(),
+  maxRetries: a.number().optional(),
+  scale: a.number().optional()
+});
+const Ki = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i, Br = a.string().regex(Ki), _ = a.number().min(0).max(255), Ur = a.number().min(0).max(1), qe = a.tuple([_, _, _, Ur]), Qi = a.tuple([_, _, _]), _i = a.object({ rgba255: qe }), ea = a.number().min(0).max(360), ta = a.number().min(0).max(100), ra = a.number().min(0).max(100), Cr = a.tuple([ea, ta, ra, Ur]), ke = a.union([Br, Qi, qe, Cr, _i]), ze = ke.transform((t) => w(t)), na = (t) => ze.safeParse(t).success, sa = (t) => qe.safeParse(t).success, ia = (t) => {
+  if (t == null) return;
+  const e = ze.safeParse(t);
+  if (e.success) return Rr(e.data);
+  if (typeof t == "string") return t;
+  throw e.error;
+}, w = (t, e = 1) => {
+  if (t = ke.parse(t), typeof t == "string") return ya(t, e);
+  if (Array.isArray(t)) {
+    if (t.length < 3 || t.length > 4)
+      throw new Error(`Invalid color: [${t.join(", ")}]`);
+    return t.length === 3 ? [...t, e] : t;
+  }
+  return t.rgba255;
+}, jr = (t, e) => {
+  if (t == null || e == null) return t == e;
+  const r = w(t), n = w(e);
+  return r.every((s, i) => s === n[i]);
+}, aa = (t) => {
+  if (t == null) return;
+  const [e, r, n, s] = w(t);
+  return `#${Oe(e)}${Oe(r)}${Oe(n)}${s === 1 ? "" : Oe(s * 255)}`;
+}, Rr = (t) => {
+  const [e, r, n, s] = w(t);
+  return `rgba(${e}, ${r}, ${n}, ${s})`;
+}, oa = (t) => `rgb(${Lr(t)})`, Lr = (t) => {
+  const [e, r, n] = w(t);
+  return `${e}, ${r}, ${n}`;
+}, ua = (t) => [...Ut(t), ce(t)], Ut = (t) => [
+  oe(t) / 255,
+  ue(t) / 255,
+  le(t) / 255
+], oe = (t) => w(t)[0], ue = (t) => w(t)[1], le = (t) => w(t)[2], ce = (t) => w(t)[3], la = (t) => jr(Ct, t), ca = (t) => wa(w(t)), ha = (t, e) => {
+  const [r, n, s] = w(t);
+  if (e > 100)
+    throw new Error(`Color opacity must be between 0 and 100, got ${e}`);
+  return e > 1 && (e /= 100), [r, n, s, e];
+}, ge = (t) => {
+  const [e, r, n] = Ut(t).map(
+    (s) => s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4
+  );
+  return Number((0.2126 * e + 0.7152 * r + 0.0722 * n).toFixed(3));
+}, fa = (t) => {
+  const [e, r, n] = Ut(t);
+  return 1 - (Math.max(e, r, n) - Math.min(e, r, n));
+}, ot = (t, e) => {
+  const r = w(t), n = w(e), s = ge(r), i = ge(n);
+  return (Math.max(s, i) + 0.5) / (Math.min(s, i) + 0.5);
+}, da = (t, ...e) => {
+  if (e.length === 0)
+    throw new Error("[Color.pickByContrast] - must provide at least one color");
+  const r = w(t), [n] = e.sort((s, i) => ot(r, i) - ot(r, s));
+  return w(n);
+}, ga = (t) => ge(t) < 0.5, pa = (t) => ge(t) > 0.5, ya = (t, e = 1) => (t = Br.parse(t), t = ma(t), [
+  ve(t, 0),
+  ve(t, 2),
+  ve(t, 4),
+  t.length === 8 ? ve(t, 6) / 255 : e
+]), Ct = [0, 0, 0, 0], Oe = (t) => Math.floor(t).toString(16).padStart(2, "0"), ve = (t, e) => parseInt(t.slice(e, e + 2), 16), ma = (t) => t.startsWith("#") ? t.slice(1) : t, ba = (t) => {
+  t = Cr.parse(t);
+  let [e, r, n] = t;
+  const s = t[3];
+  e /= 360, r /= 100, n /= 100;
+  let i, o, c;
+  if (r === 0)
+    i = o = c = n;
+  else {
+    const l = n < 0.5 ? n * (1 + r) : n + r - n * r, f = 2 * n - l;
+    i = We(f, l, e + 1 / 3), o = We(f, l, e), c = We(f, l, e - 1 / 3);
+  }
+  return [Math.round(i * 255), Math.round(o * 255), Math.round(c * 255), s];
+}, We = (t, e, r) => (r < 0 && (r += 1), r > 1 && (r -= 1), r < 1 / 6 ? t + (e - t) * 6 * r : r < 1 / 2 ? e : r < 2 / 3 ? t + (e - t) * (2 / 3 - r) * 6 : t), wa = (t) => {
+  t = qe.parse(t);
+  let [e, r, n] = t;
+  const s = t[3];
+  e /= 255, r /= 255, n /= 255;
+  const i = Math.max(e, r, n), o = Math.min(e, r, n);
+  let c, l, f = (i + o) / 2;
+  if (i === o)
+    c = l = 0;
+  else {
+    const p = i - o;
+    l = f > 0.5 ? p / (2 - i - o) : p / (i + o), i === e ? c = (r - n) / p + (r < n ? 6 : 0) : i === r ? c = (n - e) / p + 2 : c = (e - r) / p + 4, c /= 6;
+  }
+  return c *= 360, l *= 100, f *= 100, [Math.round(c), Math.round(l), Math.round(f), s];
+}, Oa = w("#000000"), va = w("#ffffff"), Dr = a.object({
+  key: a.string(),
+  color: ke,
+  position: a.number(),
+  switched: a.boolean().optional()
+}), Ta = a.array(Dr), xa = (t, e) => {
+  if (t.length === 0) return Ct;
+  if (t = t.slice().sort((r, n) => r.position - n.position), e <= t[0].position) return w(t[0].color);
+  if (e >= t[t.length - 1].position)
+    return w(t[t.length - 1].color);
+  for (let r = 0; r < t.length - 1; r++) {
+    const n = t[r], s = t[r + 1];
+    if (e < n.position || e > s.position) continue;
+    if (e === n.position) return w(n.color);
+    if (e === s.position) return w(s.color);
+    const i = (e - n.position) / (s.position - n.position), o = w(n.color), c = w(s.color), l = Math.round(
+      oe(o) + i * (oe(c) - oe(o))
+    ), f = Math.round(
+      ue(o) + i * (ue(c) - ue(o))
+    ), p = Math.round(
+      le(o) + i * (le(c) - le(o))
+    ), g = ce(o) + i * (ce(c) - ce(o));
+    return w([l, f, p, g]);
+  }
+  return w(t[t.length - 1].color);
+}, $a = a.object({
+  key: a.string(),
+  name: a.string(),
+  color: ze
+}), Sa = a.object({
+  key: a.string(),
+  name: a.string(),
+  swatches: a.array($a)
+}), Na = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BLACK: Oa,
+  WHITE: va,
+  ZERO: Ct,
+  aValue: ce,
+  bValue: le,
+  colorZ: ze,
+  construct: w,
+  contrast: ot,
+  crudeZ: ke,
+  cssString: ia,
+  equals: jr,
+  fromGradient: xa,
+  fromHSLA: ba,
+  gValue: ue,
+  gradientZ: Ta,
+  grayness: fa,
+  hex: aa,
+  hsla: ca,
+  isColor: sa,
+  isCrude: na,
+  isDark: ga,
+  isLight: pa,
+  isZero: la,
+  luminance: ge,
+  paletteZ: Sa,
+  pickByContrast: da,
+  rValue: oe,
+  rgbCSS: oa,
+  rgbString: Lr,
+  rgba1: ua,
+  rgbaCSS: Rr,
+  setAlpha: ha,
+  stopZ: Dr
+}, Symbol.toStringTag, { value: "Module" })), Pr = a.int().min(0).max(255), qr = 255, kr = 0, Ia = {
+  lower: kr,
+  upper: qr + 1
+}, zr = a.object({
+  name: a.string(),
+  key: a.string()
+}), pe = (t) => a.object({
+  subject: zr,
+  resource: t,
+  authority: Pr
+}), Ma = (...t) => (e) => e.filter((r) => {
+  let n = !1;
+  return r.to != null && (n = t.includes(r.to.resource)), r.from != null && !n && (n = t.includes(r.from.resource)), n;
+}), Fr = (t) => a.object({
+  from: pe(t),
+  to: a.null()
+}), Zr = (t) => a.object({
+  from: a.null(),
+  to: pe(t)
+}), Ea = (t) => a.union([
+  Fr(t),
+  Zr(t),
+  a.object({
+    from: pe(t),
+    to: pe(t)
+  })
+]), Uo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ABSOLUTE_AUTHORITY: qr,
+  AUTHORITY_BOUNDS: Ia,
+  ZERO_AUTHORITY: kr,
+  acquireZ: Zr,
+  authorityZ: Pr,
+  filterTransfersByChannelKey: Ma,
+  releaseZ: Fr,
+  stateZ: pe,
+  subjectZ: zr,
+  transferZ: Ea
+}, Symbol.toStringTag, { value: "Module" })), Aa = (t) => Object.getOwnPropertySymbols(globalThis).includes(t), Ba = (t, e) => {
+  const r = Symbol.for(t);
+  if (!Aa(r)) {
+    const n = e();
+    Object.defineProperty(globalThis, r, { value: n });
+  }
+  return () => globalThis[r];
+}, Yr = "sy_x_error", Ua = (t) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.startsWith(t) : e instanceof Error ? e.message.startsWith(t) : typeof e != "string" ? !1 : e.startsWith(t), Vr = (t) => class ie extends Error {
+  static discriminator = Yr;
+  discriminator = ie.discriminator;
+  static TYPE = t;
+  type = ie.TYPE;
+  static matches = Ua(t);
+  matches = ie.matches;
+  constructor(r, n) {
+    super(r, n), this.name = ie.TYPE;
+  }
+  static sub(r) {
+    return Vr(`${t}.${r}`);
+  }
+}, Ca = (t) => {
+  if (t == null || typeof t != "object") return !1;
+  const e = t;
+  if (e.discriminator !== Yr) return !1;
+  if (!("type" in e))
+    throw new Error(
+      `X Error is missing its type property: ${JSON.stringify(e)}`
+    );
+  return !0;
+}, re = "unknown", qt = "nil";
+class ja {
+  providers = [];
+  register(e) {
+    this.providers.push(e);
+  }
+  encode(e) {
+    if (e == null) return { type: qt, data: "" };
+    if (Ca(e))
+      for (const r of this.providers) {
+        const n = r.encode(e);
+        if (n != null) return n;
+      }
+    if (e instanceof Error) return { type: re, data: e.message };
+    if (typeof e == "string") return { type: re, data: e };
+    try {
+      return { type: re, data: JSON.stringify(e) };
+    } catch {
+      return { type: re, data: "unable to encode error information" };
+    }
+  }
+  decode(e) {
+    if (e == null || e.type === qt) return null;
+    if (e.type === re) return new kt(e.data);
+    for (const r of this.providers) {
+      const n = r.decode(e);
+      if (n != null) return n;
+    }
+    return new kt(e.data);
+  }
+}
+Ba("synnax-error-registry", () => new ja());
+class kt extends Vr("unknown") {
+}
+a.object({ type: a.string(), data: a.string() });
+const Co = () => new Promise((t) => setTimeout(t, 0)), jo = (t) => t ? -1 : 1, Ra = x.object({
+  jsonrpc: x.literal("2.0"),
+  method: x.string(),
+  // params should be z.union([z.record(z.string(), z.json()),
+  // z.array(z.json())]).optional() but the VSCode JSON RPC implementation uses a looser
+  // definition of params then in the JSON-RPC spec.
+  params: x.any().optional(),
+  id: x.union([x.string(), x.number(), x.null()]).optional()
+}), Wr = x.object({
+  jsonrpc: x.literal("2.0"),
+  id: x.union([x.string(), x.number(), x.null()])
+}), La = Wr.extend({
+  result: x.json()
+}), Da = Wr.extend({
+  error: x.object({
+    code: x.number().int(),
+    // This should be z.string(), but the VSCode JSON RPC implementation uses a looser
+    // definition of error than the JSON-RPC spec.
+    message: x.string().optional(),
+    data: x.json().optional()
+  })
+}), Pa = x.union([La, Da]);
+x.union([Ra, Pa]);
+const qa = (t, e, r) => {
+  const n = t.get(e);
+  return n === void 0 ? (t.set(e, r), r) : n;
+}, Ro = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getOrSetDefault: qa
+}, Symbol.toStringTag, { value: "Module" })), ut = a.string().regex(/^\d+\.\d+\.\d+$/), be = (t, e, r = {}) => {
+  r.checkMajor ??= !0, r.checkMinor ??= !0, r.checkPatch ??= !0;
+  const n = ut.parse(t), s = ut.parse(e), [i, o, c] = n.split(".").map(Number), [l, f, p] = s.split(".").map(Number);
+  if (r.checkMajor) {
+    if (i < l) return xe;
+    if (i > l) return $e;
+  }
+  if (r.checkMinor) {
+    if (o < f) return xe;
+    if (o > f) return $e;
+  }
+  if (r.checkPatch) {
+    if (c < p) return xe;
+    if (c > p) return $e;
+  }
+  return ee;
+}, ka = (t, e, r = {}) => Ht(be(t, e, r)), Gr = (t, e, r = {}) => Gt(be(t, e, r)), za = (t, e, r = {}) => Wt(be(t, e, r)), Fa = ({
+  name: t,
+  migrate: e
+}) => (r) => {
+  try {
+    const n = e(r);
+    return console.log(`${t} migrated: ${r.version} -> ${n.version}`), n;
+  } catch (n) {
+    throw console.log(`${t} failed to migrate from ${r.version}`), console.error(n), n;
+  }
+}, Za = ({
+  name: t,
+  migrations: e,
+  targetSchema: r,
+  defaultVersion: n,
+  def: s
+}) => {
+  const i = Object.keys(e).sort(be).pop();
+  if (i == null)
+    return (f) => {
+      if (f.version ??= n, f.version !== s.version)
+        return console.log(
+          `${t} version ${f.version} is newer than latest version of ${s.version}.
+          Returning default instead.
+          `
+        ), s;
+      try {
+        return r != null ? r.parse(f) : f;
+      } catch (p) {
+        return console.log(`${t} failed to parse default. Exiting with default`), console.error(p), s;
+      }
+    };
+  const o = Object.keys(e).length;
+  let c = !1;
+  const l = (f) => {
+    try {
+      if (o === 0 || Gr(f.version, i))
+        return console.log(c ? `${t} ${f.version} now up to date` : `${t} version ${f.version} is up to date with target version ${s.version}`), f;
+      const p = f.version, g = e[p], S = g(f);
+      return c = !0, l(S);
+    } catch (p) {
+      return console.log(
+        `${t} failed to migrate from ${f.version} to ${i}`
+      ), console.error(p), s;
+    }
+  };
+  return (f) => {
+    try {
+      if (f.version == null)
+        if (n != null)
+          console.log(
+            `${t} version is null. Setting version to default of ${n}`
+          ), f.version = n;
+        else
+          return console.log(
+            `${t} version is null and no default version set. Exiting with default`
+          ), s;
+      return l(f);
+    } catch (p) {
+      return console.log(`${t} failed to parse final result. Exiting with default`), console.error(p), s;
+    }
+  };
+}, Lo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  compareSemVer: be,
+  createMigration: Fa,
+  migrator: Za,
+  semVerNewer: Gr,
+  semVerOlder: za,
+  semVerZ: ut,
+  versionsEqual: ka
+}, Symbol.toStringTag, { value: "Module" })), Hr = ["standard", "scientific", "engineering"], Ya = a.enum(Hr), Va = (t, e, r) => {
+  if (Number.isNaN(t)) return "NaN";
+  if (t === 1 / 0) return "∞";
+  if (t === -1 / 0) return "-∞";
+  if (r === "standard") return t.toFixed(e);
+  if (t === 0)
+    return e === 0 ? "0ᴇ0" : `0.${"0".repeat(e)}ᴇ0`;
+  let n;
+  return r === "scientific" ? n = Math.floor(Math.log10(Math.abs(t))) : n = Math.floor(Math.log10(Math.abs(t)) / 3) * 3, `${(t / 10 ** n).toFixed(e)}ᴇ${n}`;
+}, Do = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NOTATIONS: Hr,
+  notationZ: Ya,
+  stringifyNumber: Va
+}, Symbol.toStringTag, { value: "Module" })), Po = (t) => Array.isArray(t) ? [...t] : typeof t == "object" && t !== null ? { ...t } : t, Jr = a.enum([
+  "success",
+  "info",
+  "warning",
+  "error",
+  "loading",
+  "disabled"
+]), Wa = (t) => a.object({
+  key: a.string(),
+  variant: Jr,
+  message: a.string(),
+  description: a.string().optional(),
+  time: b.z,
+  details: t ?? a.unknown().optional()
+}), Ga = (t, e) => {
+  if (!(t instanceof Error)) throw t;
+  return Xr({
+    variant: "error",
+    message: e ?? t.message,
+    description: e != null ? t.message : void 0,
+    details: {
+      stack: t.stack ?? ""
+    }
+  });
+}, Xr = (t) => ({
+  key: At(),
+  time: b.now(),
+  ...t
+}), qo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  create: Xr,
+  fromException: Ga,
+  statusZ: Wa,
+  variantZ: Jr
+}, Symbol.toStringTag, { value: "Module" })), Ha = new Error("request for lock canceled");
+var Ja = function(t, e, r, n) {
+  function s(i) {
+    return i instanceof r ? i : new r(function(o) {
+      o(i);
+    });
+  }
+  return new (r || (r = Promise))(function(i, o) {
+    function c(p) {
+      try {
+        f(n.next(p));
+      } catch (g) {
+        o(g);
+      }
+    }
+    function l(p) {
+      try {
+        f(n.throw(p));
+      } catch (g) {
+        o(g);
+      }
+    }
+    function f(p) {
+      p.done ? i(p.value) : s(p.value).then(c, l);
+    }
+    f((n = n.apply(t, e || [])).next());
+  });
+};
+class Xa {
+  constructor(e, r = Ha) {
+    this._value = e, this._cancelError = r, this._queue = [], this._weightedWaiters = [];
+  }
+  acquire(e = 1, r = 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: r }, o = Kr(this._queue, (c) => r <= c.priority);
+      o === -1 && e <= this._value ? this._dispatchItem(i) : this._queue.splice(o + 1, 0, i);
+    });
+  }
+  runExclusive(e) {
+    return Ja(this, arguments, void 0, function* (r, n = 1, s = 0) {
+      const [i, o] = yield this.acquire(n, s);
+      try {
+        return yield r(i);
+      } finally {
+        o();
+      }
+    });
+  }
+  waitForUnlock(e = 1, r = 0) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    return this._couldLockImmediately(e, r) ? Promise.resolve() : new Promise((n) => {
+      this._weightedWaiters[e - 1] || (this._weightedWaiters[e - 1] = []), Ka(this._weightedWaiters[e - 1], { resolve: n, priority: r });
+    });
+  }
+  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 r = this._value;
+    this._value -= e.weight, e.resolve([r, this._newReleaser(e.weight)]);
+  }
+  _newReleaser(e) {
+    let r = !1;
+    return () => {
+      r || (r = !0, this.release(e));
+    };
+  }
+  _drainUnlockWaiters() {
+    if (this._queue.length === 0)
+      for (let e = this._value; e > 0; e--) {
+        const r = this._weightedWaiters[e - 1];
+        r && (r.forEach((n) => n.resolve()), this._weightedWaiters[e - 1] = []);
+      }
+    else {
+      const e = this._queue[0].priority;
+      for (let r = this._value; r > 0; r--) {
+        const n = this._weightedWaiters[r - 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, r) {
+    return (this._queue.length === 0 || this._queue[0].priority < r) && e <= this._value;
+  }
+}
+function Ka(t, e) {
+  const r = Kr(t, (n) => e.priority <= n.priority);
+  t.splice(r + 1, 0, e);
+}
+function Kr(t, e) {
+  for (let r = t.length - 1; r >= 0; r--)
+    if (e(t[r]))
+      return r;
+  return -1;
+}
+var Qa = function(t, e, r, n) {
+  function s(i) {
+    return i instanceof r ? i : new r(function(o) {
+      o(i);
+    });
+  }
+  return new (r || (r = Promise))(function(i, o) {
+    function c(p) {
+      try {
+        f(n.next(p));
+      } catch (g) {
+        o(g);
+      }
+    }
+    function l(p) {
+      try {
+        f(n.throw(p));
+      } catch (g) {
+        o(g);
+      }
+    }
+    function f(p) {
+      p.done ? i(p.value) : s(p.value).then(c, l);
+    }
+    f((n = n.apply(t, e || [])).next());
+  });
+};
+class _a {
+  constructor(e) {
+    this._semaphore = new Xa(1, e);
+  }
+  acquire() {
+    return Qa(this, arguments, void 0, function* (e = 0) {
+      const [, r] = yield this._semaphore.acquire(1, e);
+      return r;
+    });
+  }
+  runExclusive(e, r = 0) {
+    return this._semaphore.runExclusive(() => e(), 1, r);
+  }
+  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 Qr extends _a {
+  constructor(e) {
+    super(), Object.assign(this, e);
+  }
+}
+const eo = (t) => new Qr(t), ko = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  mutex: Qr,
+  newMutex: eo
+}, Symbol.toStringTag, { value: "Module" }));
+function _r(t) {
+  var e, r, n = "";
+  if (typeof t == "string" || typeof t == "number") n += t;
+  else if (typeof t == "object") if (Array.isArray(t)) {
+    var s = t.length;
+    for (e = 0; e < s; e++) t[e] && (r = _r(t[e])) && (n && (n += " "), n += r);
+  } else for (r in t) t[r] && (n && (n += " "), n += r);
+  return n;
+}
+function to() {
+  for (var t, e, r = 0, n = "", s = arguments.length; r < s; r++) (t = arguments[r]) && (e = _r(t)) && (n && (n += " "), n += e);
+  return n;
+}
+const ro = to, X = "-", zt = "__", Te = "--", en = (t) => {
+  const e = (...r) => ro(...r);
+  return e.B = (...r) => t + X + r.join(X), e.E = (r) => t + zt + r, e.M = (...r) => t + Te + r.join("-"), e.BM = (r, ...n) => e.B(r) + Te + n.join("-"), e.BE = (r, ...n) => e.B(r) + zt + n.join(X), e.BEM = (r, n, ...s) => e.BE(r, n) + Te + s.join(X), e.extend = (r) => en(e.B(r)), e.var = (...r) => Te + t + X + r.join(X), e;
+};
+class no {
+  rows = [];
+  columns = [];
+  prefix;
+  constructor(e = "") {
+    this.prefix = e;
+  }
+  row(e, r, n) {
+    const { prefix: s } = this;
+    return this.rows.push({ startLabel: s + e, endLabel: s + r, size: n }), this;
+  }
+  col(e, r, n) {
+    const { prefix: s } = this;
+    return this.columns.push({ startLabel: s + e, endLabel: s + r, size: n }), this;
+  }
+  build() {
+    return {
+      display: "grid",
+      gridTemplateRows: this.rows.map((e, r) => {
+        let n = r === 0 ? "[" : "";
+        return n += `${e.startLabel}] ${e.size}${typeof e.size == "number" ? "px" : ""} [${e.endLabel}`, n += r === this.rows.length - 1 ? "]" : "", n;
+      }).join(" "),
+      gridTemplateColumns: this.columns.map((e, r) => {
+        let n = r === 0 ? "[" : "";
+        return n += `${e.startLabel}] ${e.size}${typeof e.size == "number" ? "px" : ""} [${e.endLabel}`, n += r === this.columns.length - 1 ? "]" : "", n;
+      }).join(" ")
+    };
+  }
+}
+const so = (t, e) => Object.entries(e).forEach(
+  ([r, n]) => n != null && t.style.setProperty(r, `${n}`)
+), io = (t, e) => Array.from(t.style).forEach((r) => {
+  r.startsWith(e) && t.style.removeProperty(r);
+}), ao = (t) => {
+  const e = en(t);
+  return e.visible = (r) => e.M(r ? "visible" : "hidden"), e.expanded = (r) => e.M(r ? "expanded" : "collapsed"), e.loc = (r) => e.M("location", cs.construct(r)), e.disabled = (r) => r === !0 && e.M("disabled"), e.align = (r) => e.M(r), e.dir = (r) => r != null && e.M("direction", Jn.construct(r)), e.sharp = (r) => r !== !1 && e.M("sharp"), e.rounded = (r) => r !== !1 && e.M("rounded"), e.bordered = (r) => typeof r == "boolean" ? r && e.M("bordered") : r != null ? e.M(`bordered-${r.toString()}`) : e.M("bordered"), e.selected = (r) => r && e.M("selected"), e.altColor = (r) => r && e.M("alt-color"), e.editable = (r) => r && e.M("editable"), e.noSelect = e.M("no-select"), e.applyVars = so, e.removeVars = io, e.newGridBuilder = (r) => new no(r), e.dropRegion = (r) => r && e.B("haul-drop-region"), e.px = (r) => `${r}px`, e.inheritDims = (r = !0) => r && e.M("inherit-dims"), e.shade = (r) => r != null && e.M(`shade-${r}`), e.colorVar = (r) => {
+    if (!(r == null || r === !1))
+      return typeof r == "number" ? `var(--${t}-gray-l${r})` : Na.cssString(r);
+  }, e.levelSizeVar = (r) => `var(--${t}-${r}-size)`, e.level = (r) => e.M(`level-${r}`), e;
+}, zo = ao("pluto");
+export {
+  Oo as $,
+  Z as A,
+  is as B,
+  zo as C,
+  as as D,
+  Lt as E,
+  fo as F,
+  St as G,
+  mo as H,
+  Sr as I,
+  Ot as J,
+  yo as K,
+  O as L,
+  j as M,
+  Js as N,
+  go as O,
+  rs as P,
+  F as Q,
+  oi as R,
+  Ao as S,
+  me as T,
+  z as U,
+  So as V,
+  po as W,
+  Gs as X,
+  vo as Y,
+  Ws as Z,
+  qo as _,
+  wo as a,
+  jo as a0,
+  Po as b,
+  co as c,
+  bo as d,
+  b as e,
+  h as f,
+  Jn as g,
+  m as h,
+  Na as i,
+  Bo as j,
+  ko as k,
+  Uo as l,
+  Do as m,
+  en as n,
+  cs as o,
+  to as p,
+  Lo as q,
+  T as r,
+  Ro as s,
+  Eo as t,
+  Co as u,
+  N as v,
+  V as w,
+  ss as x,
+  mt as y,
+  uo as z
+};