@synnaxlabs/pluto 0.40.1 → 0.42.0

package/dist/state-CUPEHHgf.js

@@ -1,2405 +0,0 @@
-import { z as ve, A as Ge, E as D, F as z, H as he, I as Z, U as Ye, V as Ze } from "./css-rxwBYwM1.js";
-import { z as u } from "zod";
-import { useState as ue } from "react";
-const Se = (r) => r != null && typeof r == "object" && !Array.isArray(r);
-var Je = Object.defineProperty, We = (r, e, t) => e in r ? Je(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, V = (r, e, t) => We(r, typeof e != "symbol" ? e + "" : e, t);
-let He = class {
-  constructor() {
-    V(this, "contentType", "application/json"), V(this, "decoder"), V(this, "encoder"), this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
-  }
-  encode(e) {
-    return this.encoder.encode(this.encodeString(e)).buffer;
-  }
-  decode(e, t) {
-    return this.decodeString(this.decoder.decode(e), t);
-  }
-  decodeString(e, t) {
-    const n = JSON.parse(e), s = ve(n);
-    return t != null ? t.parse(s) : s;
-  }
-  encodeString(e) {
-    const t = Ge(e);
-    return JSON.stringify(t, (n, s) => ArrayBuffer.isView(s) ? Array.from(s) : Se(s) && "encode_value" in s ? typeof s.value == "bigint" ? s.value.toString() : s.value : typeof s == "bigint" ? s.toString() : s);
-  }
-  static registerCustomType() {
-  }
-}, Ke = class {
-  constructor() {
-    V(this, "contentType", "text/csv");
-  }
-  encode(e) {
-    const t = this.encodeString(e);
-    return new TextEncoder().encode(t).buffer;
-  }
-  decode(e, t) {
-    const n = new TextDecoder().decode(e);
-    return this.decodeString(n, t);
-  }
-  encodeString(e) {
-    if (!Array.isArray(e) || e.length === 0 || !Se(e[0]))
-      throw new Error("Payload must be an array of objects");
-    const t = Object.keys(e[0]), n = [t.join(",")];
-    return e.forEach((s) => {
-      const a = t.map((l) => JSON.stringify(s[l] ?? ""));
-      n.push(a.join(","));
-    }), n.join(`
-`);
-  }
-  decodeString(e, t) {
-    const [n, ...s] = e.trim().split(`
-`).map((m) => m.trim());
-    if (n.length === 0)
-      return t != null ? t.parse({}) : {};
-    const a = n.split(",").map((m) => m.trim()), l = {};
-    return a.forEach((m) => {
-      l[m] = [];
-    }), s.forEach((m) => {
-      const f = m.split(",").map((g) => g.trim());
-      a.forEach((g, v) => {
-        const c = this.parseValue(f[v]);
-        c != null && l[g].push(c);
-      });
-    }), t != null ? t.parse(l) : l;
-  }
-  parseValue(e) {
-    if (e == null || e.length === 0) return null;
-    const t = Number(e);
-    return isNaN(t) ? e.startsWith('"') && e.endsWith('"') ? e.slice(1, -1) : e : t;
-  }
-  static registerCustomType() {
-  }
-}, Xe = class {
-  constructor() {
-    V(this, "contentType", "text/plain");
-  }
-  encode(e) {
-    return new TextEncoder().encode(e).buffer;
-  }
-  decode(e, t) {
-    const n = new TextDecoder().decode(e);
-    return t != null ? t.parse(n) : n;
-  }
-};
-const J = new He();
-new Ke();
-new Xe();
-const ne = (r) => [...new Set(r)], Qe = (r, e, t = !0) => {
-  const n = /* @__PURE__ */ new Map();
-  return r.forEach((s) => {
-    const a = e(s);
-    if (n.has(a)) {
-      if (t) return;
-      n.delete(a);
-    }
-    n.set(a, s);
-  }), Array.from(n.values());
-}, Tr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  by: Qe,
-  unique: ne
-}, Symbol.toStringTag, { value: "Module" })), Ne = (r) => r != null && typeof r == "object" && "toString" in r, vr = (r) => {
-  if (Ne(r)) return (r == null ? void 0 : r.toString().length) === 0;
-  switch (typeof r) {
-    case "string":
-      return r.length === 0;
-    case "number":
-      return r === 0;
-    case "bigint":
-      return r === 0n;
-    case "boolean":
-      return !r;
-    case "undefined":
-      return !0;
-    case "object":
-      return r === null;
-  }
-}, _ = (r, e = !1) => {
-  const t = Ne(r) ? "stringer" : typeof r;
-  let n;
-  switch (t) {
-    case "string":
-      n = (s, a) => s.localeCompare(a);
-      break;
-    case "stringer":
-      n = (s, a) => s.toString().localeCompare(a.toString());
-      break;
-    case "number":
-      n = (s, a) => Number(s) - Number(a);
-      break;
-    case "bigint":
-      n = (s, a) => BigInt(s) - BigInt(a) > 0n ? 1 : -1;
-      break;
-    case "boolean":
-      n = (s, a) => Number(s) - Number(a);
-      break;
-    case "undefined":
-      n = () => 0;
-      break;
-    default:
-      return console.warn(`sortFunc: unknown type ${t}`), () => -1;
-  }
-  return e ? Ae(n) : n;
-}, _e = (r, e, t) => {
-  const n = _(e[r], t);
-  return (s, a) => n(s[r], a[r]);
-}, et = (r, e) => r.length !== e.length ? r.length - e.length : r.every((t, n) => t === e[n]) ? 0 : -1, Ie = (r, e) => {
-  if (r.length !== e.length) return r.length - e.length;
-  if (r.length === 0) return 0;
-  const t = _(r[0]), n = [...r].sort(t), s = [...e].sort(t);
-  return n.every((a, l) => a === s[l]) ? 0 : -1;
-}, tt = (r, e) => {
-  const t = ne(r), n = ne(e);
-  return Ie(t, n);
-}, rt = (r, e) => r === e ? 0 : r === "first" && e === "last" ? 1 : -1, Ae = (r) => (e, t) => r(t, e), L = 0, W = -1, H = 1, Ee = (r) => r < L, $e = (r) => r > L, nt = (r) => r >= L, Me = (r) => r === L, st = (r, e) => {
-  const t = /([a-zA-Z]+)|(\d+)/g, n = r.replace(/[\s_.-]+/g, "").match(t), s = e.replace(/[\s_.-]+/g, "").match(t);
-  if (!n || !s) return 0;
-  for (let a = 0; a < Math.min(n.length, s.length); a++) {
-    const l = n[a], m = s[a];
-    if (isNaN(Number(l)) && isNaN(Number(m))) {
-      const f = l.localeCompare(m);
-      if (f !== 0) return f;
-    } else if (!isNaN(Number(l)) && !isNaN(Number(m))) {
-      const f = Number(l) - Number(m);
-      if (f !== 0) return f;
-    } else return isNaN(Number(l)) ? -1 : 1;
-  }
-  return n.length - s.length;
-}, Sr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  EQUAL: L,
-  GREATER_THAN: H,
-  LESS_THAN: W,
-  isEqualTo: Me,
-  isGreaterThan: $e,
-  isGreaterThanEqual: nt,
-  isLessThan: Ee,
-  newF: _,
-  newFieldF: _e,
-  order: rt,
-  primitiveArrays: et,
-  reverseF: Ae,
-  stringsWithNumbers: st,
-  uniqueUnorderedPrimitiveArrays: tt,
-  unorderedPrimitiveArrays: Ie
-}, Symbol.toStringTag, { value: "Module" }));
-var it = Object.defineProperty, at = (r, e, t) => e in r ? it(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, i = (r, e, t) => at(r, typeof e != "symbol" ? e + "" : e, t);
-let ot = (r, e = 21) => (t = e) => {
-  let n = "", s = t | 0;
-  for (; s--; )
-    n += r[Math.random() * r.length | 0];
-  return n;
-};
-const ut = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", lt = ot(ut, 11), Be = () => lt(), Nr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  create: Be
-}, Symbol.toStringTag, { value: "Module" })), ht = u.enum(["static", "dynamic"]), Ue = (r, e) => {
-  const t = new w(e);
-  if (![
-    O.DAY,
-    O.HOUR,
-    O.MINUTE,
-    O.SECOND,
-    O.MILLISECOND,
-    O.MICROSECOND,
-    O.NANOSECOND
-  ].some((s) => s.equals(t)))
-    throw new Error(
-      "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
-    );
-  const n = r.valueOf() % t.valueOf();
-  return r instanceof w ? new w(n) : new O(n);
-}, y = class h {
-  constructor(e, t = "UTC") {
-    if (i(this, "value"), i(this, "encodeValue", !0), e == null) this.value = h.now().valueOf();
-    else if (e instanceof Date)
-      this.value = BigInt(e.getTime()) * h.MILLISECOND.valueOf();
-    else if (typeof e == "string")
-      this.value = h.parseDateTimeString(e, t).valueOf();
-    else if (Array.isArray(e)) this.value = h.parseDate(e);
-    else {
-      let n = BigInt(0);
-      e instanceof Number && (e = e.valueOf()), t === "local" && (n = h.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = h.MAX : e = h.MIN)), this.value = BigInt(e.valueOf()) + n;
-    }
-  }
-  static parseDate([e = 1970, t = 1, n = 1]) {
-    const s = new Date(e, t - 1, n, 0, 0, 0, 0);
-    return new h(BigInt(s.getTime()) * h.MILLISECOND.valueOf()).truncate(h.DAY).valueOf();
-  }
-  encode() {
-    return this.value.toString();
-  }
-  valueOf() {
-    return this.value;
-  }
-  static parseTimeString(e, t = "UTC") {
-    const [n, s, a] = e.split(":");
-    let l = "00", m = "00";
-    a != null && ([l, m] = a.split("."));
-    let f = h.hours(parseInt(n ?? "00")).add(h.minutes(parseInt(s ?? "00"))).add(h.seconds(parseInt(l ?? "00"))).add(h.milliseconds(parseInt(m ?? "00")));
-    return t === "local" && (f = f.add(h.utcOffset)), f.valueOf();
-  }
-  static parseDateTimeString(e, t = "UTC") {
-    if (!e.includes("/") && !e.includes("-"))
-      return h.parseTimeString(e, t);
-    const n = new Date(e);
-    return e.includes(":") || n.setUTCHours(0, 0, 0, 0), new h(
-      BigInt(n.getTime()) * h.MILLISECOND.valueOf(),
-      t
-    ).valueOf();
-  }
-  fString(e = "ISO", t = "UTC") {
-    switch (e) {
-      case "ISODate":
-        return this.toISOString(t).slice(0, 10);
-      case "ISOTime":
-        return this.toISOString(t).slice(11, 23);
-      case "time":
-        return this.timeString(!1, t);
-      case "preciseTime":
-        return this.timeString(!0, t);
-      case "date":
-        return this.dateString();
-      case "preciseDate":
-        return `${this.dateString()} ${this.timeString(!0, t)}`;
-      case "dateTime":
-        return `${this.dateString()} ${this.timeString(!1, t)}`;
-      default:
-        return this.toISOString(t);
-    }
-  }
-  toISOString(e = "UTC") {
-    return e === "UTC" ? this.date().toISOString() : this.sub(h.utcOffset).date().toISOString();
-  }
-  timeString(e = !1, t = "UTC") {
-    const n = this.toISOString(t);
-    return e ? n.slice(11, 23) : n.slice(11, 19);
-  }
-  dateString() {
-    const e = this.date(), t = e.toLocaleString("default", { month: "short" }), n = e.toLocaleString("default", { day: "numeric" });
-    return `${t} ${n}`;
-  }
-  static get utcOffset() {
-    return new O(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * h.MINUTE.valueOf()
-    );
-  }
-  /**
-   * @returns a TimeSpan representing the amount time elapsed since
-   * the other timestamp.
-   * @param other - The other timestamp.
-   */
-  static since(e) {
-    return new h().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 h(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 G(this, e).makeValid();
-  }
-  /**
-   * Creates a TimeRange starting at the TimeStamp and spanning the given
-   * TimeSpan.
-   *
-   * @param other - The TimeSpan to span.
-   * @returns A TimeRange starting at the TimeStamp and spanning the given
-   *   TimeSpan. The TimeRange is guaranteed to be valid.
-   */
-  spanRange(e) {
-    return this.range(this.add(e)).makeValid();
-  }
-  /**
-   * Checks if the TimeStamp represents the unix epoch.
-   *
-   * @returns True if the TimeStamp represents the unix epoch, false otherwise.
-   */
-  get isZero() {
-    return this.valueOf() === BigInt(0);
-  }
-  /**
-   * Checks if the TimeStamp is after the given TimeStamp.
-   *
-   * @param other - The other TimeStamp to compare to.
-   * @returns True if the TimeStamp is after the given TimeStamp, false
-   *   otherwise.
-   */
-  after(e) {
-    return this.valueOf() > new h(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 h(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 h(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 h(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 h(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 h(this.valueOf() - BigInt(e.valueOf()));
-  }
-  /**
-   * @returns the floating point number of hours since the unix epoch to the timestamp
-   * value.
-   */
-  get hours() {
-    return Number(this.valueOf()) / Number(O.HOUR.valueOf());
-  }
-  /**
-   * @returns the floating point number of minutes since the unix epoch to the timestamp
-   * value.
-   */
-  get minutes() {
-    return Number(this.valueOf()) / Number(O.MINUTE.valueOf());
-  }
-  /**
-   * @returns the floating point number of days since the unix epoch to the timestamp
-   * value.
-   */
-  get days() {
-    return Number(this.valueOf()) / Number(O.DAY.valueOf());
-  }
-  /**
-   * @returns the floating point number of seconds since the unix epoch to the timestamp
-   * value.
-   */
-  get seconds() {
-    return Number(this.valueOf()) / Number(O.SECOND.valueOf());
-  }
-  /**
-   * @returns The number of milliseconds since the unix epoch.
-   */
-  get milliseconds() {
-    return Number(this.valueOf()) / Number(h.MILLISECOND.valueOf());
-  }
-  get microseconds() {
-    return Number(this.valueOf()) / Number(h.MICROSECOND.valueOf());
-  }
-  get nanoseconds() {
-    return Number(this.valueOf());
-  }
-  /** @returns the integer year that the timestamp corresponds to. */
-  get year() {
-    return this.date().getFullYear();
-  }
-  setYear(e) {
-    const t = this.date();
-    return t.setFullYear(e), new h(t);
-  }
-  /** @returns the integer month that the timestamp corresponds to with its year. */
-  get month() {
-    return this.date().getMonth();
-  }
-  setMonth(e) {
-    const t = this.date();
-    return t.setMonth(e), new h(t);
-  }
-  /** @returns the integer day that the timestamp corresponds to within its month. */
-  get day() {
-    return this.date().getDate();
-  }
-  setDay(e) {
-    const t = this.date();
-    return t.setDate(e), new h(t);
-  }
-  /** @returns the integer hour that the timestamp corresponds to within its day. */
-  get hour() {
-    return this.date().getHours();
-  }
-  setHour(e) {
-    const t = this.date();
-    return t.setHours(e), new h(t);
-  }
-  /** @returns the integer minute that the timestamp corresponds to within its hour. */
-  get minute() {
-    return this.date().getMinutes();
-  }
-  setMinute(e) {
-    const t = this.date();
-    return t.setMinutes(e), new h(t);
-  }
-  get second() {
-    return this.date().getSeconds();
-  }
-  setSecond(e) {
-    const t = this.date();
-    return t.setSeconds(e), new h(t);
-  }
-  get millisecond() {
-    return this.date().getMilliseconds();
-  }
-  setMillisecond(e) {
-    const t = this.date();
-    return t.setMilliseconds(e), new h(t);
-  }
-  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 Ue(this, e);
-  }
-  /** @returns true if the day portion TimeStamp is today, false otherwise. */
-  get isToday() {
-    return this.truncate(O.DAY).equals(h.now().truncate(O.DAY));
-  }
-  truncate(e) {
-    return this.sub(this.remainder(e));
-  }
-  /**
-   * @returns A new TimeStamp representing the current time in UTC. It's important to
-   * note that this TimeStamp is only accurate to the millisecond level (that's the best
-   * JavaScript can do).
-   */
-  static now() {
-    return new h(/* @__PURE__ */ new Date());
-  }
-  static max(...e) {
-    let t = h.MIN;
-    for (const n of e) {
-      const s = new h(n);
-      s.after(t) && (t = s);
-    }
-    return t;
-  }
-  static min(...e) {
-    let t = h.MAX;
-    for (const n of e) {
-      const s = new h(n);
-      s.before(t) && (t = s);
-    }
-    return t;
-  }
-  /** @returns a new TimeStamp n nanoseconds after the unix epoch */
-  static nanoseconds(e) {
-    return new h(e);
-  }
-  /** @returns a new TimeStamp n microseconds after the unix epoch */
-  static microseconds(e) {
-    return h.nanoseconds(e * 1e3);
-  }
-  /** @returns a new TimeStamp n milliseconds after the unix epoch */
-  static milliseconds(e) {
-    return h.microseconds(e * 1e3);
-  }
-  /** @returns a new TimeStamp n seconds after the unix epoch */
-  static seconds(e) {
-    return h.milliseconds(e * 1e3);
-  }
-  /** @returns a new TimeStamp n minutes after the unix epoch */
-  static minutes(e) {
-    return h.seconds(e * 60);
-  }
-  /** @returns a new TimeStamp n hours after the unix epoch */
-  static hours(e) {
-    return h.minutes(e * 60);
-  }
-  /** @returns a new TimeStamp n days after the unix epoch */
-  static days(e) {
-    return h.hours(e * 24);
-  }
-};
-i(y, "NANOSECOND", y.nanoseconds(1)), /** One microsecond after the unix epoch */
-i(y, "MICROSECOND", y.microseconds(1)), /** One millisecond after the unix epoch */
-i(y, "MILLISECOND", y.milliseconds(1)), /** One second after the unix epoch */
-i(y, "SECOND", y.seconds(1)), /** One minute after the unix epoch */
-i(y, "MINUTE", y.minutes(1)), /** One hour after the unix epoch */
-i(y, "HOUR", y.hours(1)), /** One day after the unix epoch */
-i(y, "DAY", y.days(1)), /** The maximum possible value for a timestamp */
-i(y, "MAX", new y((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
-i(y, "MIN", new y(0)), /** The unix epoch */
-i(y, "ZERO", new y(0)), /** A zod schema for validating timestamps */
-i(y, "z", u.union([
-  u.object({ value: u.bigint() }).transform((r) => new y(r.value)),
-  u.string().transform((r) => new y(BigInt(r))),
-  u.instanceof(Number).transform((r) => new y(r)),
-  u.number().transform((r) => new y(r)),
-  u.instanceof(y)
-]));
-let w = y;
-const b = class d {
-  constructor(e) {
-    i(this, "value"), i(this, "encodeValue", !0), typeof e == "number" && (e = Math.trunc(e.valueOf())), this.value = BigInt(e.valueOf());
-  }
-  static fromSeconds(e) {
-    return e instanceof d ? e : e instanceof ce ? e.period : e instanceof w ? new d(e) : ["number", "bigint"].includes(typeof e) ? d.seconds(e) : new d(e);
-  }
-  static fromMilliseconds(e) {
-    return e instanceof d ? e : e instanceof ce ? e.period : e instanceof w ? new d(e) : ["number", "bigint"].includes(typeof e) ? d.milliseconds(e) : new d(e);
-  }
-  encode() {
-    return this.value.toString();
-  }
-  valueOf() {
-    return this.value;
-  }
-  lessThan(e) {
-    return this.valueOf() < new d(e).valueOf();
-  }
-  greaterThan(e) {
-    return this.valueOf() > new d(e).valueOf();
-  }
-  lessThanOrEqual(e) {
-    return this.valueOf() <= new d(e).valueOf();
-  }
-  greaterThanOrEqual(e) {
-    return this.valueOf() >= new d(e).valueOf();
-  }
-  remainder(e) {
-    return Ue(this, e);
-  }
-  truncate(e) {
-    return new d(
-      BigInt(Math.trunc(Number(this.valueOf() / e.valueOf()))) * e.valueOf()
-    );
-  }
-  toString() {
-    const e = this.truncate(d.DAY), t = this.truncate(d.HOUR), n = this.truncate(d.MINUTE), s = this.truncate(d.SECOND), a = this.truncate(d.MILLISECOND), l = this.truncate(d.MICROSECOND), m = this.truncate(d.NANOSECOND), f = e, g = t.sub(e), v = n.sub(t), c = s.sub(n), E = a.sub(s), $ = l.sub(a), le = m.sub(l);
-    let x = "";
-    return f.isZero || (x += `${f.days}d `), g.isZero || (x += `${g.hours}h `), v.isZero || (x += `${v.minutes}m `), c.isZero || (x += `${c.seconds}s `), E.isZero || (x += `${E.milliseconds}ms `), $.isZero || (x += `${$.microseconds}µs `), le.isZero || (x += `${le.nanoseconds}ns`), x.trim();
-  }
-  mult(e) {
-    return new d(this.valueOf() * BigInt(e));
-  }
-  /** @returns the decimal number of days in the timespan */
-  get days() {
-    return Number(this.valueOf()) / Number(d.DAY.valueOf());
-  }
-  /** @returns the decimal number of hours in the timespan */
-  get hours() {
-    return Number(this.valueOf()) / Number(d.HOUR.valueOf());
-  }
-  /** @returns the decimal number of minutes in the timespan */
-  get minutes() {
-    return Number(this.valueOf()) / Number(d.MINUTE.valueOf());
-  }
-  /** @returns The number of seconds in the TimeSpan. */
-  get seconds() {
-    return Number(this.valueOf()) / Number(d.SECOND.valueOf());
-  }
-  /** @returns The number of milliseconds in the TimeSpan. */
-  get milliseconds() {
-    return Number(this.valueOf()) / Number(d.MILLISECOND.valueOf());
-  }
-  get microseconds() {
-    return Number(this.valueOf()) / Number(d.MICROSECOND.valueOf());
-  }
-  get nanoseconds() {
-    return Number(this.valueOf());
-  }
-  /**
-   * Checks if the TimeSpan represents a zero duration.
-   *
-   * @returns True if the TimeSpan represents a zero duration, false otherwise.
-   */
-  get isZero() {
-    return this.valueOf() === BigInt(0);
-  }
-  /**
-   * Checks if the TimeSpan is equal to another TimeSpan.
-   *
-   * @returns True if the TimeSpans are equal, false otherwise.
-   */
-  equals(e) {
-    return this.valueOf() === new d(e).valueOf();
-  }
-  /**
-   * Adds a TimeSpan to the TimeSpan.
-   *
-   * @returns A new TimeSpan representing the sum of the two TimeSpans.
-   */
-  add(e) {
-    return new d(this.valueOf() + new d(e).valueOf());
-  }
-  /**
-   * Creates a TimeSpan representing the duration between the two timestamps.
-   *
-   * @param other
-   */
-  sub(e) {
-    return new d(this.valueOf() - new d(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 d(e);
-  }
-  /**
-   * Creates a TimeSpan representing the given number of microseconds.
-   *
-   * @param value - The number of microseconds.
-   * @returns A TimeSpan representing the given number of microseconds.
-   */
-  static microseconds(e = 1) {
-    return d.nanoseconds(D(e, 1e3));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of milliseconds.
-   *
-   * @param value - The number of milliseconds.
-   * @returns A TimeSpan representing the given number of milliseconds.
-   */
-  static milliseconds(e = 1) {
-    return d.microseconds(D(e, 1e3));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of seconds.
-   *
-   * @param value - The number of seconds.
-   * @returns A TimeSpan representing the given number of seconds.
-   */
-  static seconds(e = 1) {
-    return d.milliseconds(D(e, 1e3));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of minutes.
-   *
-   * @param value - The number of minutes.
-   * @returns A TimeSpan representing the given number of minutes.
-   */
-  static minutes(e = 1) {
-    return d.seconds(D(e, 60));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of hours.
-   *
-   * @param value - The number of hours.
-   * @returns A TimeSpan representing the given number of hours.
-   */
-  static hours(e) {
-    return d.minutes(D(e, 60));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of days.
-   *
-   * @param value - The number of days.
-   * @returns A TimeSpan representing the given number of days.
-   */
-  static days(e) {
-    return d.hours(D(e, 24));
-  }
-};
-i(b, "NANOSECOND", b.nanoseconds(1)), /** A microsecond. */
-i(b, "MICROSECOND", b.microseconds(1)), /** A millisecond. */
-i(b, "MILLISECOND", b.milliseconds(1)), /** A second. */
-i(b, "SECOND", b.seconds(1)), /** A minute. */
-i(b, "MINUTE", b.minutes(1)), /** Represents an hour. */
-i(b, "HOUR", b.hours(1)), /** Represents a day. */
-i(b, "DAY", b.days(1)), /** The maximum possible value for a TimeSpan. */
-i(b, "MAX", new b((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-i(b, "MIN", new b(0)), /** The zero value for a TimeSpan. */
-i(b, "ZERO", new b(0)), /** A zod schema for validating and transforming timespans */
-i(b, "z", u.union([
-  u.object({ value: u.bigint() }).transform((r) => new b(r.value)),
-  u.string().transform((r) => new b(BigInt(r))),
-  u.instanceof(Number).transform((r) => new b(r)),
-  u.number().transform((r) => new b(r)),
-  u.instanceof(b)
-]));
-let O = b;
-const C = class K extends Number {
-  constructor(e) {
-    e instanceof Number ? super(e.valueOf()) : super(e);
-  }
-  /** @returns a pretty string representation of the rate in the format "X Hz". */
-  toString() {
-    return `${this.valueOf()} Hz`;
-  }
-  /** @returns The number of seconds in the Rate. */
-  equals(e) {
-    return this.valueOf() === new K(e).valueOf();
-  }
-  /**
-   * Calculates the period of the Rate as a TimeSpan.
-   *
-   * @returns A TimeSpan representing the period of the Rate.
-   */
-  get period() {
-    return O.seconds(1 / this.valueOf());
-  }
-  /**
-   * Calculates the number of samples in the given TimeSpan at this rate.
-   *
-   * @param duration - The duration to calculate the sample count from.
-   * @returns The number of samples in the given TimeSpan at this rate.
-   */
-  sampleCount(e) {
-    return new O(e).seconds * this.valueOf();
-  }
-  /**
-   * Calculates the number of bytes in the given TimeSpan at this rate.
-   *
-   * @param span - The duration to calculate the byte count from.
-   * @param density - The density of the data in bytes per sample.
-   * @returns The number of bytes in the given TimeSpan at this rate.
-   */
-  byteCount(e, t) {
-    return this.sampleCount(e) * new A(t).valueOf();
-  }
-  /**
-   * Calculates a TimeSpan given the number of samples at this rate.
-   *
-   * @param sampleCount - The number of samples in the span.
-   * @returns A TimeSpan that corresponds to the given number of samples.
-   */
-  span(e) {
-    return O.seconds(e / this.valueOf());
-  }
-  /**
-   * Calculates a TimeSpan given the number of bytes at this rate.
-   *
-   * @param size - The number of bytes in the span.
-   * @param density - The density of the data in bytes per sample.
-   * @returns A TimeSpan that corresponds to the given number of bytes.
-   */
-  byteSpan(e, t) {
-    return this.span(e.valueOf() / t.valueOf());
-  }
-  /**
-   * Creates a Rate representing the given number of Hz.
-   *
-   * @param value - The number of Hz.
-   * @returns A Rate representing the given number of Hz.
-   */
-  static hz(e) {
-    return new K(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 K.hz(e * 1e3);
-  }
-};
-i(C, "z", u.union([
-  u.number().transform((r) => new C(r)),
-  u.instanceof(Number).transform((r) => new C(r)),
-  u.instanceof(C)
-]));
-let ce = C;
-const N = class extends Number {
-  /**
-   * Creates a Density representing the given number of bytes per value.
-   *
-   * @class
-   * @param value - The number of bytes per value.
-   * @returns A Density representing the given number of bytes per value.
-   */
-  constructor(e) {
-    e instanceof Number ? super(e.valueOf()) : super(e);
-  }
-  length(e) {
-    return e.valueOf() / this.valueOf();
-  }
-  size(e) {
-    return new Q(e * this.valueOf());
-  }
-};
-i(N, "UNKNOWN", new N(0)), /** 128 bits per value. */
-i(N, "BIT128", new N(16)), /** 64 bits per value. */
-i(N, "BIT64", new N(8)), /** 32 bits per value. */
-i(N, "BIT32", new N(4)), /** 16 bits per value. */
-i(N, "BIT16", new N(2)), /** 8 bits per value. */
-i(N, "BIT8", new N(1)), /** A zod schema for validating and transforming densities */
-i(N, "z", u.union([
-  u.number().transform((r) => new N(r)),
-  u.instanceof(Number).transform((r) => new N(r)),
-  u.instanceof(N)
-]));
-let A = N;
-const M = class X {
-  /**
-   * Creates a TimeRange from the given start and end TimeStamps.
-   *
-   * @param start - A TimeStamp representing the start of the range.
-   * @param end - A TimeStamp representing the end of the range.
-   */
-  constructor(e, t) {
-    i(this, "start"), i(this, "end"), typeof e == "object" && "start" in e ? (this.start = new w(e.start), this.end = new w(e.end)) : (this.start = new w(e), this.end = new w(t));
-  }
-  /** @returns The TimeSpan occupied by the TimeRange. */
-  get span() {
-    return new O(this.end.valueOf() - this.start.valueOf());
-  }
-  /**
-   * Checks if the timestamp is valid i.e. the start is before the end.
-   *
-   * @returns True if the TimeRange is valid.
-   */
-  get isValid() {
-    return this.start.valueOf() <= this.end.valueOf();
-  }
-  /**
-   * Makes sure the TimeRange is valid i.e. the start is before the end.
-   *
-   * @returns A TimeRange that is valid.
-   */
-  makeValid() {
-    return this.isValid ? this : this.swap();
-  }
-  /**
-   * Checks if the TimeRange has a zero span.
-   *
-   * @returns True if the TimeRange has a zero span.
-   */
-  get isZero() {
-    return this.span.isZero;
-  }
-  /**
-   * @returns the TimeRange as a numeric object with start and end properties.
-   */
-  get numeric() {
-    return { start: Number(this.start.valueOf()), end: Number(this.end.valueOf()) };
-  }
-  /**
-   * Creates a new TimeRange with the start and end swapped.
-   *
-   * @returns A TimeRange with the start and end swapped.
-   */
-  swap() {
-    return new X(this.end, this.start);
-  }
-  /**
-   * 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) {
-    return this.start.equals(e.start) && this.end.equals(e.end);
-  }
-  toString() {
-    return `${this.start.toString()} - ${this.end.toString()}`;
-  }
-  toPrettyString() {
-    return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
-  }
-  /**
-   * Checks if 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, returns false.
-   * Just follow the rule [start, end) i.e. start is inclusive and end is exclusive.
-   *
-   * @param other - The other TimeRange to compare to.
-   * @returns True if the two TimeRanges overlap, false otherwise.
-   */
-  overlapsWith(e, t = O.ZERO) {
-    e = e.makeValid();
-    const n = this.makeValid();
-    if (this.equals(e)) return !0;
-    if (e.end.equals(n.start) || n.end.equals(e.start)) return !1;
-    const s = w.max(n.start, e.start), a = w.min(n.end, e.end);
-    return a.before(s) ? !1 : new O(a.sub(s)).greaterThanOrEqual(t);
-  }
-  roughlyEquals(e, t) {
-    let n = this.start.sub(e.start).valueOf(), s = this.end.sub(e.end).valueOf();
-    return n < 0 && (n = -n), s < 0 && (s = -s), n <= t.valueOf() && s <= t.valueOf();
-  }
-  contains(e) {
-    return e instanceof X ? this.contains(e.start) && this.contains(e.end) : this.start.beforeEq(e) && this.end.after(e);
-  }
-  boundBy(e) {
-    const t = new X(this.start, this.end);
-    return e.start.after(this.start) && (t.start = e.start), e.start.after(this.end) && (t.end = e.start), e.end.before(this.end) && (t.end = e.end), e.end.before(this.start) && (t.start = e.end), t;
-  }
-};
-i(M, "MAX", new M(w.MIN, w.MAX)), /** The minimum possible time range. */
-i(M, "MIN", new M(w.MAX, w.MIN)), /** A zero time range. */
-i(M, "ZERO", new M(w.ZERO, w.ZERO)), /** A zod schema for validating and transforming time ranges */
-i(M, "z", u.union([
-  u.object({ start: w.z, end: w.z }).transform((r) => new M(r.start, r.end)),
-  u.instanceof(M)
-]));
-let G = M;
-const o = class T extends String {
-  constructor(e) {
-    if (e instanceof T || typeof e == "string" || typeof e.valueOf() == "string") {
-      super(e.valueOf());
-      return;
-    }
-    const t = T.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
-    if (t != null) {
-      super(t.valueOf());
-      return;
-    }
-    throw super(T.UNKNOWN.valueOf()), new Error(`unable to find data type for ${e.toString()}`);
-  }
-  /**
-   * @returns the TypedArray constructor for the DataType.
-   */
-  get Array() {
-    const e = T.ARRAY_CONSTRUCTORS.get(this.toString());
-    if (e == null)
-      throw new Error(`unable to find array constructor for ${this.valueOf()}`);
-    return e;
-  }
-  /**
-   * @returns true if the DataType is equal to the given DataType.
-   */
-  equals(e) {
-    return this.valueOf() === e.valueOf();
-  }
-  /**
-   * @returns true if the DataType is equal to any of the given DataTypes.
-   */
-  matches(...e) {
-    return e.some((t) => this.equals(t));
-  }
-  /** @returns a string representation of the DataType. */
-  toString() {
-    return this.valueOf();
-  }
-  get isVariable() {
-    return this.equals(T.JSON) || this.equals(T.STRING);
-  }
-  get isNumeric() {
-    return !this.isVariable && !this.equals(T.UUID);
-  }
-  get isInteger() {
-    const e = this.toString();
-    return e.startsWith("int") || e.startsWith("uint");
-  }
-  get isFloat() {
-    return this.toString().startsWith("float");
-  }
-  get density() {
-    const e = T.DENSITIES.get(this.toString());
-    if (e == null) throw new Error(`unable to find density for ${this.valueOf()}`);
-    return e;
-  }
-  get isUnsigned() {
-    return this.equals(T.UINT8) || this.equals(T.UINT16) || this.equals(T.UINT32) || this.equals(T.UINT64);
-  }
-  get isSigned() {
-    return this.equals(T.INT8) || this.equals(T.INT16) || this.equals(T.INT32) || this.equals(T.INT64);
-  }
-  /** @returns true if the data type can be cast to the other data type without loss of precision. */
-  canSafelyCastTo(e) {
-    return this.equals(e) ? !0 : !this.isNumeric || !e.isNumeric || this.isVariable || e.isVariable || this.isUnsigned && e.isSigned ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(T.INT32) && e.equals(T.FLOAT64) || this.equals(T.INT8) && e.equals(T.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsigned === e.isUnsigned : !1;
-  }
-  /** @returns true if the data type can be cast to the other data type, even if there is a loss of precision. */
-  canCastTo(e) {
-    return this.isNumeric && e.isNumeric ? !0 : this.equals(e);
-  }
-  /**
-   * 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;
-  }
-  toJSON() {
-    return this.toString();
-  }
-  get usesBigInt() {
-    return T.BIG_INT_TYPES.some((e) => e.equals(this));
-  }
-};
-i(o, "UNKNOWN", new o("unknown")), /** Represents a 64-bit floating point value. */
-i(o, "FLOAT64", new o("float64")), /** Represents a 32-bit floating point value. */
-i(o, "FLOAT32", new o("float32")), /** Represents a 64-bit signed integer value. */
-i(o, "INT64", new o("int64")), /** Represents a 32-bit signed integer value. */
-i(o, "INT32", new o("int32")), /** Represents a 16-bit signed integer value. */
-i(o, "INT16", new o("int16")), /** Represents a 8-bit signed integer value. */
-i(o, "INT8", new o("int8")), /** Represents a 64-bit unsigned integer value. */
-i(o, "UINT64", new o("uint64")), /** Represents a 32-bit unsigned integer value. */
-i(o, "UINT32", new o("uint32")), /** Represents a 16-bit unsigned integer value. */
-i(o, "UINT16", new o("uint16")), /** Represents a 8-bit unsigned integer value. */
-i(o, "UINT8", new o("uint8")), /** Represents a boolean value. Alias for UINT8. */
-i(o, "BOOLEAN", o.UINT8), /** Represents a 64-bit unix epoch. */
-i(o, "TIMESTAMP", new o("timestamp")), /** Represents a UUID data type */
-i(o, "UUID", new o("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
-* by a newline character. */
-i(o, "STRING", new o("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
-* newline character. */
-i(o, "JSON", new o("json")), i(o, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
-  [o.UINT8.toString(), Uint8Array],
-  [o.UINT16.toString(), Uint16Array],
-  [o.UINT32.toString(), Uint32Array],
-  [o.UINT64.toString(), BigUint64Array],
-  [o.FLOAT32.toString(), Float32Array],
-  [o.FLOAT64.toString(), Float64Array],
-  [o.INT8.toString(), Int8Array],
-  [o.INT16.toString(), Int16Array],
-  [o.INT32.toString(), Int32Array],
-  [o.INT64.toString(), BigInt64Array],
-  [o.TIMESTAMP.toString(), BigInt64Array],
-  [o.STRING.toString(), Uint8Array],
-  [o.JSON.toString(), Uint8Array],
-  [o.UUID.toString(), Uint8Array]
-])), i(o, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
-  [Uint8Array.name, o.UINT8],
-  [Uint16Array.name, o.UINT16],
-  [Uint32Array.name, o.UINT32],
-  [BigUint64Array.name, o.UINT64],
-  [Float32Array.name, o.FLOAT32],
-  [Float64Array.name, o.FLOAT64],
-  [Int8Array.name, o.INT8],
-  [Int16Array.name, o.INT16],
-  [Int32Array.name, o.INT32],
-  [BigInt64Array.name, o.INT64]
-])), i(o, "DENSITIES", /* @__PURE__ */ new Map([
-  [o.UINT8.toString(), A.BIT8],
-  [o.UINT16.toString(), A.BIT16],
-  [o.UINT32.toString(), A.BIT32],
-  [o.UINT64.toString(), A.BIT64],
-  [o.FLOAT32.toString(), A.BIT32],
-  [o.FLOAT64.toString(), A.BIT64],
-  [o.INT8.toString(), A.BIT8],
-  [o.INT16.toString(), A.BIT16],
-  [o.INT32.toString(), A.BIT32],
-  [o.INT64.toString(), A.BIT64],
-  [o.TIMESTAMP.toString(), A.BIT64],
-  [o.STRING.toString(), A.UNKNOWN],
-  [o.JSON.toString(), A.UNKNOWN],
-  [o.UUID.toString(), A.BIT128]
-])), /** All the data types. */
-i(o, "ALL", [
-  o.UNKNOWN,
-  o.FLOAT64,
-  o.FLOAT32,
-  o.INT64,
-  o.INT32,
-  o.INT16,
-  o.INT8,
-  o.UINT64,
-  o.UINT32,
-  o.UINT16,
-  o.UINT8,
-  o.TIMESTAMP,
-  o.UUID,
-  o.STRING,
-  o.JSON
-]), i(o, "BIG_INT_TYPES", [o.INT64, o.UINT64, o.TIMESTAMP]), /** A zod schema for a DataType. */
-i(o, "z", u.union([
-  u.string().transform((r) => new o(r)),
-  u.instanceof(o)
-]));
-let p = o;
-const I = class S extends Number {
-  constructor(e) {
-    super(e.valueOf());
-  }
-  /** @returns true if the Size is larger than the other size. */
-  largerThan(e) {
-    return this.valueOf() > e.valueOf();
-  }
-  /** @returns true if the Size is smaller than the other sisze. */
-  smallerThan(e) {
-    return this.valueOf() < e.valueOf();
-  }
-  add(e) {
-    return S.bytes(this.valueOf() + e.valueOf());
-  }
-  sub(e) {
-    return S.bytes(this.valueOf() - e.valueOf());
-  }
-  truncate(e) {
-    return new S(Math.trunc(this.valueOf() / e.valueOf()) * e.valueOf());
-  }
-  remainder(e) {
-    return S.bytes(this.valueOf() % e.valueOf());
-  }
-  get gigabytes() {
-    return this.valueOf() / S.GIGABYTE.valueOf();
-  }
-  get megabytes() {
-    return this.valueOf() / S.MEGABYTE.valueOf();
-  }
-  get kilobytes() {
-    return this.valueOf() / S.KILOBYTE.valueOf();
-  }
-  get terabytes() {
-    return this.valueOf() / S.TERABYTE.valueOf();
-  }
-  toString() {
-    const e = this.truncate(S.TERABYTE), t = this.truncate(S.GIGABYTE), n = this.truncate(S.MEGABYTE), s = this.truncate(S.KILOBYTE), a = this.truncate(S.BYTE), l = e, m = t.sub(e), f = n.sub(t), g = s.sub(n), v = a.sub(s);
-    let c = "";
-    return l.isZero || (c += `${l.terabytes}TB `), m.isZero || (c += `${m.gigabytes}GB `), f.isZero || (c += `${f.megabytes}MB `), g.isZero || (c += `${g.kilobytes}KB `), (!v.isZero || c === "") && (c += `${v.valueOf()}B`), c.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 S(e);
-  }
-  /**
-   * Creates a Size from the given number if kilobytes.
-   *
-   * @param value - The number of kilobytes.
-   * @returns A Size representing the given number of kilobytes.
-   */
-  static kilobytes(e = 1) {
-    return S.bytes(e.valueOf() * 1e3);
-  }
-  /**
-   * Creates a Size from the given number of megabytes.
-   *
-   * @param value - The number of megabytes.
-   * @returns A Size representing the given number of megabytes.
-   */
-  static megabytes(e = 1) {
-    return S.kilobytes(e.valueOf() * 1e3);
-  }
-  /**
-   * Creates a Size from the given number of gigabytes.
-   *
-   * @param value - The number of gigabytes.
-   * @returns A Size representing the given number of gigabytes.
-   */
-  static gigabytes(e = 1) {
-    return S.megabytes(e.valueOf() * 1e3);
-  }
-  /**
-   * Creates a Size from the given number of terabytes.
-   *
-   * @param value - The number of terabytes.
-   * @returns  A Size representing the given number of terabytes.
-   */
-  static terabytes(e) {
-    return S.gigabytes(e.valueOf() * 1e3);
-  }
-  get isZero() {
-    return this.valueOf() === 0;
-  }
-};
-i(I, "BYTE", new I(1)), /** A kilobyte */
-i(I, "KILOBYTE", I.kilobytes(1)), /** A megabyte */
-i(I, "MEGABYTE", I.megabytes(1)), /** A gigabyte */
-i(I, "GIGABYTE", I.gigabytes(1)), /** A terabyte. */
-i(I, "TERABYTE", I.terabytes(1)), /** The zero value for Size */
-i(I, "ZERO", new I(0)), /** A zod schema for a Size. */
-i(I, "z", u.union([
-  u.number().transform((r) => new I(r)),
-  u.instanceof(I)
-]));
-let Q = I;
-const Ar = u.union([
-  u.instanceof(Uint8Array),
-  u.instanceof(Uint16Array),
-  u.instanceof(Uint32Array),
-  u.instanceof(BigUint64Array),
-  u.instanceof(Float32Array),
-  u.instanceof(Float64Array),
-  u.instanceof(Int8Array),
-  u.instanceof(Int16Array),
-  u.instanceof(Int32Array),
-  u.instanceof(BigInt64Array)
-]), xe = (r) => {
-  const e = typeof r;
-  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || r instanceof w || r instanceof O || r instanceof Date;
-}, ct = (r, e, t, n = 0) => r.usesBigInt && !e.usesBigInt ? Number(t) - Number(n) : !r.usesBigInt && e.usesBigInt ? BigInt(t.valueOf()) - BigInt(n.valueOf()) : P(t, -n).valueOf(), P = (r, e) => typeof r == "bigint" && typeof e == "bigint" || typeof r == "number" && typeof e == "number" ? r + e : e === 0 ? r : r === 0 ? e : Number(r) + Number(e), ft = (r) => r == null ? !1 : Array.isArray(r) || r instanceof ArrayBuffer || ArrayBuffer.isView(r) && !(r instanceof DataView) || r instanceof mt ? !0 : xe(r), R = -1, se = {
-  [Symbol.iterator]: () => se,
-  next: () => ({ done: !0, value: void 0 })
-}, dt = u.string().transform(
-  (r) => new Uint8Array(
-    atob(r).split("").map((e) => e.charCodeAt(0))
-  ).buffer
-), gt = u.union([u.null(), u.undefined()]).transform(() => new Uint8Array().buffer), ie = 10, j = class B {
-  constructor(e) {
-    i(this, "key", ""), i(this, "isSynnaxSeries", !0), i(this, "dataType"), i(this, "sampleOffset"), i(this, "gl"), i(this, "_data"), i(this, "_timeRange"), i(this, "alignment", 0n), i(this, "_cachedMin"), i(this, "_cachedMax"), i(this, "writePos", R), i(this, "_refCount", 0), i(this, "_cachedLength"), i(this, "_cachedIndexes"), ft(e) && (e = { data: e });
-    const {
-      dataType: t,
-      timeRange: n,
-      sampleOffset: s = 0,
-      glBufferUsage: a = "static",
-      alignment: l = 0n,
-      key: m = Be()
-    } = e, f = e.data ?? [];
-    if (f instanceof B || typeof f == "object" && "isSynnaxSeries" in f && f.isSynnaxSeries === !0) {
-      const c = f;
-      this.key = c.key, this.dataType = c.dataType, this.sampleOffset = c.sampleOffset, this.gl = c.gl, this._data = c._data, this._timeRange = c._timeRange, this.alignment = c.alignment, this._cachedMin = c._cachedMin, this._cachedMax = c._cachedMax, this.writePos = c.writePos, this._refCount = c._refCount, this._cachedLength = c._cachedLength;
-      return;
-    }
-    const g = xe(f), v = Array.isArray(f);
-    if (t != null) this.dataType = new p(t);
-    else {
-      if (f instanceof ArrayBuffer)
-        throw new Error(
-          "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
-        );
-      if (v || g) {
-        let c = f;
-        if (!g) {
-          if (f.length === 0)
-            throw new Error(
-              "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
-            );
-          c = f[0];
-        }
-        if (typeof c == "string") this.dataType = p.STRING;
-        else if (typeof c == "number") this.dataType = p.FLOAT64;
-        else if (typeof c == "bigint") this.dataType = p.INT64;
-        else if (typeof c == "boolean") this.dataType = p.BOOLEAN;
-        else if (c instanceof w || c instanceof Date || c instanceof w)
-          this.dataType = p.TIMESTAMP;
-        else if (typeof c == "object") this.dataType = p.JSON;
-        else
-          throw new Error(
-            `cannot infer data type of ${typeof c} when constructing a Series from a JS array`
-          );
-      } else this.dataType = new p(f);
-    }
-    if (!v && !g) this._data = f;
-    else {
-      let c = g ? [f] : f;
-      const E = c[0];
-      (E instanceof w || E instanceof Date || E instanceof O) && (c = c.map(($) => new w($).valueOf())), this.dataType.equals(p.STRING) ? (this._cachedLength = c.length, this._data = new TextEncoder().encode(`${c.join(`
-`)}
-`).buffer) : this.dataType.equals(p.JSON) ? (this._cachedLength = c.length, this._data = new TextEncoder().encode(
-        `${c.map(($) => J.encodeString($)).join(`
-`)}
-`
-      ).buffer) : this.dataType.usesBigInt && typeof E == "number" ? this._data = new this.dataType.Array(
-        c.map(($) => BigInt(Math.round($)))
-      ).buffer : !this.dataType.usesBigInt && typeof E == "bigint" ? this._data = new this.dataType.Array(
-        c.map(($) => Number($))
-      ).buffer : this._data = new this.dataType.Array(c).buffer;
-    }
-    this.key = m, this.alignment = l, this.sampleOffset = s ?? 0, this._timeRange = n, this.gl = {
-      control: null,
-      buffer: null,
-      prevBuffer: 0,
-      bufferUsage: a
-    };
-  }
-  static alloc({ capacity: e, dataType: t, ...n }) {
-    if (e === 0)
-      throw new Error("[Series] - cannot allocate an array of length 0");
-    const s = new new p(t).Array(e), a = new B({
-      data: s.buffer,
-      dataType: t,
-      ...n
-    });
-    return a.writePos = 0, a;
-  }
-  static createTimestamps(e, t, n) {
-    const s = n.spanRange(t.span(e)), a = new BigInt64Array(e);
-    for (let l = 0; l < e; l++)
-      a[l] = BigInt(n.add(t.span(l)).valueOf());
-    return new B({ data: a, dataType: p.TIMESTAMP, timeRange: s });
-  }
-  get refCount() {
-    return this._refCount;
-  }
-  static fromStrings(e, t) {
-    const n = new TextEncoder().encode(
-      `${e.join(`
-`)}
-`
-    );
-    return new B({ data: n, dataType: p.STRING, timeRange: t });
-  }
-  static fromJSON(e, t) {
-    const n = new TextEncoder().encode(
-      `${e.map((s) => J.encodeString(s)).join(`
-`)}
-`
-    );
-    return new B({ data: n, dataType: p.JSON, timeRange: t });
-  }
-  acquire(e) {
-    this._refCount++, e != null && this.updateGLBuffer(e);
-  }
-  release() {
-    if (this._refCount--, this._refCount === 0 && this.gl.control != null)
-      this.maybeGarbageCollectGLBuffer(this.gl.control);
-    else if (this._refCount < 0)
-      throw new Error("cannot release an array 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 === R) return 0;
-    const t = this.byteCapacity.valueOf() - this.writePos, n = e.subBytes(0, t);
-    return this.writeToUnderlyingData(n), this.writePos += n.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += n.length, this.calculateCachedLength()), n.length;
-  }
-  writeFixed(e) {
-    if (this.writePos === R) return 0;
-    const t = this.capacity - this.writePos, n = e.sub(0, t);
-    return this.writeToUnderlyingData(n), this._cachedLength = void 0, this.maybeRecomputeMinMax(n), this.writePos += n.length, n.length;
-  }
-  writeToUnderlyingData(e) {
-    this.underlyingData.set(
-      e.data,
-      this.writePos
-    );
-  }
-  /** @returns the underlying buffer backing this array. */
-  get buffer() {
-    return typeof this._data == "object" && "buffer" in this._data ? this._data.buffer : this._data;
-  }
-  get underlyingData() {
-    return new this.dataType.Array(this._data);
-  }
-  /** @returns a native typed array with the proper data type. */
-  get data() {
-    return this.writePos === R ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
-  }
-  toStrings() {
-    if (!this.dataType.matches(p.STRING, p.UUID))
-      throw new Error("cannot convert non-string series to strings");
-    return new TextDecoder().decode(this.underlyingData).split(`
-`).slice(0, -1);
-  }
-  toUUIDs() {
-    if (!this.dataType.equals(p.UUID))
-      throw new Error("cannot convert non-uuid series to uuids");
-    const e = p.UUID.density.valueOf(), t = Array(this.length);
-    for (let n = 0; n < this.length; n++) {
-      const s = this.underlyingData.slice(n * e, (n + 1) * e), a = Array.from(
-        new Uint8Array(s.buffer),
-        (l) => l.toString(16).padStart(2, "0")
-      ).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-      t[n] = a;
-    }
-    return t;
-  }
-  parseJSON(e) {
-    if (!this.dataType.equals(p.JSON))
-      throw new Error("cannot parse non-JSON series as JSON");
-    return new TextDecoder().decode(this.underlyingData).split(`
-`).slice(0, -1).map((t) => e.parse(J.decodeString(t)));
-  }
-  /** @returns the time range of this array. */
-  get timeRange() {
-    if (this._timeRange == null) throw new Error("time range not set on series");
-    return this._timeRange;
-  }
-  /** @returns the capacity of the series in bytes. */
-  get byteCapacity() {
-    return new Q(this.underlyingData.byteLength);
-  }
-  /** @returns the capacity of the series in samples. */
-  get capacity() {
-    return this.dataType.isVariable ? this.byteCapacity.valueOf() : this.dataType.density.length(this.byteCapacity);
-  }
-  /** @returns the length of the series in bytes. */
-  get byteLength() {
-    return this.writePos === R ? this.byteCapacity : this.dataType.isVariable ? new Q(this.writePos) : this.dataType.density.size(this.writePos);
-  }
-  /** @returns the number of samples in this array. */
-  get length() {
-    return this._cachedLength != null ? this._cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === R ? this.data.length : this.writePos;
-  }
-  calculateCachedLength() {
-    if (!this.dataType.isVariable)
-      throw new Error("cannot calculate length of a non-variable length data type");
-    let e = 0;
-    const t = [0];
-    return this.data.forEach((n, s) => {
-      n === ie && (e++, t.push(s + 1));
-    }), this._cachedIndexes = t, this._cachedLength = e, e;
-  }
-  /**
-   * Creates a new array with a different data type.
-   * @param target the data type to convert to.
-   * @param sampleOffset an offset to apply to each sample. This can help with precision
-   * issues when converting between data types.
-   *
-   * WARNING: This method is expensive and copies the entire underlying array. There
-   * also may be untimely precision issues when converting between data types.
-   */
-  convert(e, t = 0) {
-    if (this.dataType.equals(e)) return this;
-    const n = new e.Array(this.length);
-    for (let s = 0; s < this.length; s++)
-      n[s] = ct(this.dataType, e, this.data[s], t);
-    return new B({
-      data: n.buffer,
-      dataType: e,
-      timeRange: this._timeRange,
-      sampleOffset: t,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment
-    });
-  }
-  calcRawMax() {
-    if (this.length === 0) return -1 / 0;
-    if (this.dataType.equals(p.TIMESTAMP))
-      this._cachedMax = this.data[this.data.length - 1];
-    else if (this.dataType.usesBigInt) {
-      const e = this.data;
-      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
-    } else {
-      const e = this.data;
-      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
-    }
-    return this._cachedMax;
-  }
-  /** @returns the maximum value in the array */
-  get max() {
-    if (this.dataType.isVariable)
-      throw new Error("cannot calculate maximum on a variable length data type");
-    return this.writePos === 0 ? -1 / 0 : (this._cachedMax ?? (this._cachedMax = this.calcRawMax()), P(this._cachedMax, this.sampleOffset));
-  }
-  calcRawMin() {
-    if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(p.TIMESTAMP)) this._cachedMin = this.data[0];
-    else if (this.dataType.usesBigInt) {
-      const e = this.data;
-      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
-    } else {
-      const e = this.data;
-      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
-    }
-    return this._cachedMin;
-  }
-  /** @returns the minimum value in the array */
-  get min() {
-    if (this.dataType.isVariable)
-      throw new Error("cannot calculate minimum on a variable length data type");
-    return this.writePos === 0 ? 1 / 0 : (this._cachedMin ?? (this._cachedMin = this.calcRawMin()), P(this._cachedMin, this.sampleOffset));
-  }
-  /** @returns the bounds of this array. */
-  get bounds() {
-    return z(Number(this.min), Number(this.max));
-  }
-  maybeRecomputeMinMax(e) {
-    if (this._cachedMin != null) {
-      const t = e._cachedMin ?? e.calcRawMin();
-      t < this._cachedMin && (this._cachedMin = t);
-    }
-    if (this._cachedMax != null) {
-      const t = e._cachedMax ?? e.calcRawMax();
-      t > this._cachedMax && (this._cachedMax = t);
-    }
-  }
-  enrich() {
-    this.max, this.min;
-  }
-  get range() {
-    return P(this.max, -this.min);
-  }
-  atAlignment(e, t) {
-    const n = Number(e - this.alignment);
-    if (n < 0 || n >= this.length) {
-      if (t === !0) throw new Error(`[series] - no value at index ${n}`);
-      return;
-    }
-    return this.at(n, t);
-  }
-  at(e, t) {
-    if (this.dataType.isVariable) return this.atVariable(e, t ?? !1);
-    e < 0 && (e = this.length + e);
-    const n = this.data[e];
-    if (n == null) {
-      if (t === !0) throw new Error(`[series] - no value at index ${e}`);
-      return;
-    }
-    return P(n, this.sampleOffset);
-  }
-  atVariable(e, t) {
-    let n = 0, s = 0;
-    if (this._cachedIndexes != null)
-      n = this._cachedIndexes[e], s = this._cachedIndexes[e + 1] - 1;
-    else {
-      e < 0 && (e = this.length + e);
-      for (let l = 0; l < this.data.length; l++)
-        if (this.data[l] === ie) {
-          if (e === 0) {
-            s = l;
-            break;
-          }
-          n = l + 1, e--;
-        }
-      if (s === 0 && (s = this.data.length), n >= s || e > 0) {
-        if (t) throw new Error(`[series] - no value at index ${e}`);
-        return;
-      }
-    }
-    const a = this.data.slice(n, s);
-    return this.dataType.equals(p.STRING) ? new TextDecoder().decode(a) : ve(JSON.parse(new TextDecoder().decode(a)));
-  }
-  /**
-   * @returns the index of the first sample that is greater than or equal to the given value.
-   * The underlying array must be sorted. If it is not, the behavior of this method is undefined.
-   * @param value the value to search for.
-   */
-  binarySearch(e) {
-    let t = 0, n = this.length - 1;
-    const s = _(e);
-    for (; t <= n; ) {
-      const a = Math.floor((t + n) / 2), l = s(this.at(a, !0), e);
-      if (l === 0) return a;
-      l < 0 ? t = a + 1 : n = a - 1;
-    }
-    return t;
-  }
-  updateGLBuffer(e) {
-    if (this.gl.control = e, !this.dataType.equals(p.FLOAT32) && !this.dataType.equals(p.UINT8))
-      throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
-    const { buffer: t, bufferUsage: n, prevBuffer: s } = this.gl;
-    if (t == null && (this.gl.buffer = e.createBuffer()), this.writePos !== s)
-      if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== R) {
-        s === 0 && e.bufferData(e.ARRAY_BUFFER, this.byteCapacity.valueOf(), e.STATIC_DRAW);
-        const a = this.dataType.density.size(s).valueOf(), l = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        e.bufferSubData(e.ARRAY_BUFFER, a, l.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 = R;
-  }
-  as(e) {
-    if (e === "string") {
-      if (!this.dataType.equals(p.STRING))
-        throw new Error(
-          `cannot convert series of type ${this.dataType.toString()} to string`
-        );
-      return this;
-    }
-    if (e === "number") {
-      if (!this.dataType.isNumeric)
-        throw new Error(
-          `cannot convert series of type ${this.dataType.toString()} to number`
-        );
-      return this;
-    }
-    if (e === "bigint") {
-      if (!this.dataType.equals(p.INT64))
-        throw new Error(
-          `cannot convert series of type ${this.dataType.toString()} to bigint`
-        );
-      return this;
-    }
-    throw new Error(`cannot convert series to ${e}`);
-  }
-  get digest() {
-    var e;
-    return {
-      key: this.key,
-      dataType: this.dataType.toString(),
-      sampleOffset: this.sampleOffset,
-      alignment: {
-        lower: we(this.alignmentBounds.lower),
-        upper: we(this.alignmentBounds.upper)
-      },
-      timeRange: (e = this._timeRange) == null ? void 0 : e.toString(),
-      length: this.length,
-      capacity: this.capacity
-    };
-  }
-  get memInfo() {
-    return {
-      key: this.key,
-      length: this.length,
-      byteLength: this.byteLength,
-      glBuffer: this.gl.buffer != null
-    };
-  }
-  get alignmentBounds() {
-    return z(this.alignment, this.alignment + BigInt(this.length));
-  }
-  maybeGarbageCollectGLBuffer(e) {
-    this.gl.buffer != null && (e.deleteBuffer(this.gl.buffer), this.gl.buffer = null, this.gl.prevBuffer = 0, this.gl.control = null);
-  }
-  get glBuffer() {
-    if (this.gl.buffer == null) throw new Error("gl buffer not initialized");
-    return this.gl.prevBuffer !== this.writePos && console.warn("buffer not updated"), this.gl.buffer;
-  }
-  [Symbol.iterator]() {
-    if (this.dataType.isVariable) {
-      const e = new pt(this);
-      return this.dataType.equals(p.JSON) ? new yt(e) : e;
-    }
-    return new bt(this);
-  }
-  slice(e, t) {
-    return this.sliceSub(!1, e, t);
-  }
-  sub(e, t) {
-    return this.sliceSub(!0, e, t);
-  }
-  subIterator(e, t) {
-    return new fe(this, e, t ?? this.length);
-  }
-  subAlignmentIterator(e, t) {
-    return new fe(
-      this,
-      Number(e - this.alignment),
-      Number(t - this.alignment)
-    );
-  }
-  subBytes(e, t) {
-    if (e >= 0 && (t == null || t >= this.byteLength.valueOf())) return this;
-    const n = this.data.subarray(e, t);
-    return new B({
-      data: n,
-      dataType: this.dataType,
-      timeRange: this._timeRange,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment + BigInt(e)
-    });
-  }
-  sliceSub(e, t, n) {
-    if (t <= 0 && (n == null || n >= this.length)) return this;
-    let s;
-    return e ? s = this.data.subarray(t, n) : s = this.data.slice(t, n), new B({
-      data: s,
-      dataType: this.dataType,
-      timeRange: this._timeRange,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment + BigInt(t)
-    });
-  }
-  reAlign(e) {
-    return new B({
-      data: this.buffer,
-      dataType: this.dataType,
-      timeRange: G.ZERO,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: "static",
-      alignment: e
-    });
-  }
-};
-i(j, "crudeZ", u.object({
-  timeRange: G.z.optional(),
-  dataType: p.z,
-  alignment: u.coerce.bigint().optional(),
-  data: u.union([
-    dt,
-    gt,
-    u.instanceof(ArrayBuffer),
-    u.instanceof(Uint8Array)
-  ]),
-  glBufferUsage: ht.optional().default("static").optional()
-})), i(j, "z", j.crudeZ.transform((r) => new j(r)));
-let mt = j, fe = class {
-  constructor(e, t, n) {
-    i(this, "series"), i(this, "end"), i(this, "index"), this.series = e;
-    const s = z(0, e.length);
-    this.end = he(s, n), this.index = he(s, t);
-  }
-  next() {
-    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-};
-class pt {
-  constructor(e) {
-    if (i(this, "series"), i(this, "index"), i(this, "decoder"), !e.dataType.isVariable)
-      throw new Error(
-        "cannot create a variable series iterator for a non-variable series"
-      );
-    this.series = e, this.index = 0, this.decoder = new TextDecoder();
-  }
-  next() {
-    const e = this.index, t = this.series.data;
-    for (; this.index < t.length && t[this.index] !== ie; ) this.index++;
-    const n = this.index;
-    return e === n ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(e, n)) });
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-}
-var de, ge;
-class yt {
-  constructor(e) {
-    i(this, "wrapped"), i(this, de, "JSONSeriesIterator"), this.wrapped = e;
-  }
-  next() {
-    const e = this.wrapped.next();
-    return e.done === !0 ? { done: !0, value: void 0 } : {
-      done: !1,
-      value: J.decodeString(e.value)
-    };
-  }
-  [(ge = Symbol.iterator, de = Symbol.toStringTag, ge)]() {
-    return this;
-  }
-}
-var me, pe;
-class bt {
-  constructor(e) {
-    i(this, "series"), i(this, "index"), i(this, me, "SeriesIterator"), this.series = e, this.index = 0;
-  }
-  next() {
-    return this.index >= this.series.length ? { done: !0, value: void 0 } : {
-      done: !1,
-      value: this.series.at(this.index++, !0)
-    };
-  }
-  [(pe = Symbol.iterator, me = Symbol.toStringTag, pe)]() {
-    return this;
-  }
-}
-class $r {
-  constructor(e) {
-    if (i(this, "series"), e.length !== 0) {
-      const t = e[0].dataType;
-      for (let n = 1; n < e.length; n++)
-        if (!e[n].dataType.equals(t))
-          throw new Error("[multi-series] - series must have the same data type");
-    }
-    this.series = e;
-  }
-  as(e) {
-    if (!new p(e).equals(this.dataType))
-      throw new Error(
-        `cannot convert series of type ${this.dataType.toString()} to ${e.toString()}`
-      );
-    return this;
-  }
-  get dataType() {
-    return this.series.length === 0 ? p.UNKNOWN : this.series[0].dataType;
-  }
-  get timeRange() {
-    return this.series.length === 0 ? G.ZERO : new G(
-      this.series[0].timeRange.start,
-      this.series[this.series.length - 1].timeRange.end
-    );
-  }
-  get alignment() {
-    return this.series.length === 0 ? 0n : this.series[0].alignment;
-  }
-  get alignmentBounds() {
-    return this.series.length === 0 ? z(0n, 0n) : z(
-      this.series[0].alignmentBounds.lower,
-      this.series[this.series.length - 1].alignmentBounds.upper
-    );
-  }
-  push(e) {
-    this.series.push(e);
-  }
-  get length() {
-    return this.series.reduce((e, t) => e + t.length, 0);
-  }
-  atAlignment(e, t) {
-    if (this.series.length === 0) {
-      if (t) throw new Error(`[series] - no value at alignment ${e}`);
-      return;
-    }
-    for (const n of this.series)
-      if (Z(n.alignmentBounds, e))
-        return n.atAlignment(e, t);
-    if (t) throw new Error(`[series] - no value at alignment ${e}`);
-  }
-  at(e, t = !1) {
-    e < 0 && (e = this.length + e);
-    for (const n of this.series) {
-      if (e < n.length) return n.at(e, t);
-      e -= n.length;
-    }
-    if (t) throw new Error(`[series] - no value at index ${e}`);
-  }
-  subIterator(e, t) {
-    return new te(this, e, t ?? this.length);
-  }
-  subAlignmentIterator(e, t) {
-    if (e >= this.alignmentBounds.upper || t <= this.alignmentBounds.lower)
-      return se;
-    let n = 0;
-    for (let a = 0; a < this.series.length; a++) {
-      const l = this.series[a];
-      if (e < l.alignment) break;
-      if (e >= l.alignmentBounds.upper) n += l.length;
-      else if (Z(l.alignmentBounds, e)) {
-        n += Number(e - l.alignment);
-        break;
-      }
-    }
-    let s = 0;
-    for (let a = 0; a < this.series.length; a++) {
-      const l = this.series[a];
-      if (t < l.alignment) break;
-      if (t >= l.alignmentBounds.upper) s += l.length;
-      else if (Z(l.alignmentBounds, t)) {
-        s += Number(t - l.alignment);
-        break;
-      }
-    }
-    return new te(this, n, s);
-  }
-  subAlignmentSpanIterator(e, t) {
-    if (e >= this.alignmentBounds.upper) return se;
-    let n = 0;
-    for (let s = 0; s < this.series.length; s++) {
-      const a = this.series[s];
-      if (e < a.alignment) break;
-      if (e >= a.alignmentBounds.upper) n += a.length;
-      else if (Z(a.alignmentBounds, e)) {
-        n += Number(e - a.alignment);
-        break;
-      }
-    }
-    return new te(this, n, n + t);
-  }
-  get byteLength() {
-    return new Q(this.series.reduce((e, t) => e + t.byteLength.valueOf(), 0));
-  }
-  get data() {
-    const e = new this.dataType.Array(this.length);
-    let t = 0;
-    for (const n of this.series)
-      e.set(n.data, t), t += n.length;
-    return new this.dataType.Array(e.buffer);
-  }
-  traverseAlignment(e, t) {
-    const n = this.series.map((s) => s.alignmentBounds);
-    return Ye(n, e, t);
-  }
-  distance(e, t) {
-    const n = this.series.map((s) => s.alignmentBounds);
-    return Ze(n, e, t);
-  }
-  parseJSON(e) {
-    if (!this.dataType.equals(p.JSON))
-      throw new Error("cannot parse non-JSON series as JSON");
-    return this.series.flatMap((t) => t.parseJSON(e));
-  }
-  [Symbol.iterator]() {
-    return this.series.length === 0 ? {
-      next() {
-        return { done: !0, value: void 0 };
-      }
-    } : new wt(this.series);
-  }
-}
-var ye, be;
-class wt {
-  constructor(e) {
-    i(this, "series"), i(this, "seriesIndex"), i(this, "internal"), i(this, ye, "MultiSeriesIterator"), this.series = e, this.seriesIndex = 0, this.internal = e[0][Symbol.iterator]();
-  }
-  next() {
-    const e = this.internal.next();
-    return e.done === !1 ? e : this.seriesIndex === this.series.length - 1 ? { done: !0, value: void 0 } : (this.internal = this.series[++this.seriesIndex][Symbol.iterator](), this.next());
-  }
-  [(be = Symbol.iterator, ye = Symbol.toStringTag, be)]() {
-    return this;
-  }
-}
-let te = class {
-  constructor(e, t, n) {
-    i(this, "series"), i(this, "index"), i(this, "end"), this.series = e, this.end = n, this.index = t;
-  }
-  next() {
-    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-};
-const we = (r) => {
-  const e = r >> 32n, t = r & 0xffffffffn;
-  return { domain: e, sample: t };
-}, Ot = (r, e, t = ".") => {
-  const n = r.split(t);
-  return n.map((s, a) => {
-    const l = e(s, a, n);
-    return l == null ? null : typeof l == "string" ? l : l.join(t);
-  }).filter((s) => s != null).join(t);
-}, Re = (r, e, t = { optional: !1, separator: "." }) => {
-  t.separator ?? (t.separator = ".");
-  const { optional: n, getter: s = (m, f) => m[f] } = t, a = e.split(t.separator);
-  if (a.length === 1 && a[0] === "") return r;
-  let l = r;
-  for (const m of a) {
-    const f = s(l, m);
-    if (f == null) {
-      if (n) return null;
-      throw new Error(`Path ${e} does not exist. ${m} is null`);
-    }
-    l = f;
-  }
-  return l;
-}, Br = (r, e, t) => {
-  const n = e.split(".");
-  let s = r;
-  for (let a = 0; a < n.length - 1; a++) {
-    const l = n[a];
-    s[l] ?? (s[l] = {}), s = s[l];
-  }
-  try {
-    s[n[n.length - 1]] = t;
-  } catch (a) {
-    throw console.error("failed to set value", t, "at path", e, "on object", r), a;
-  }
-}, Ur = (r, e) => {
-  const t = e.split(".");
-  let n = r;
-  for (let s = 0; s < t.length - 1; s++) {
-    const a = t[s];
-    if (n[a] == null) return;
-    n = n[a];
-  }
-  if (Array.isArray(n)) {
-    const s = parseInt(t[t.length - 1]);
-    if (isNaN(s)) return;
-    n.splice(s, 1);
-    return;
-  }
-  delete n[t[t.length - 1]];
-}, xr = (r, e) => {
-  const t = r.split(".");
-  return e < 0 ? t[t.length + e] : t[e];
-}, Rr = (r, e) => {
-  try {
-    return Re(r, e), !0;
-  } catch {
-    return !1;
-  }
-}, Dr = (r, e) => {
-  if (e.length === 0) return !0;
-  const t = r.split("."), n = e.split(".");
-  if (n.length > t.length) return !1;
-  for (let s = 0; s < n.length; s++) {
-    const a = t[s], l = n[s];
-    if (l !== "*" && a !== l)
-      return !1;
-  }
-  return !0;
-};
-u.object({ key: u.string(), value: u.string() });
-u.record(
-  u.union([u.number(), u.string(), u.symbol()]),
-  u.unknown()
-);
-const De = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", Tt = De(), Le = ["macOS", "Windows", "Linux"], vt = ["macos", "windows", "linux"], St = {
-  macos: "macOS",
-  windows: "Windows",
-  linux: "Linux"
-}, Nt = u.enum(Le).or(
-  u.enum(vt).transform((r) => St[r])
-), It = () => {
-  if (typeof window > "u") return;
-  const r = window.navigator.userAgent.toLowerCase();
-  if (r.includes("mac")) return "macOS";
-  if (r.includes("win")) return "Windows";
-  if (r.includes("linux")) return "Linux";
-};
-let re;
-const At = (r = {}) => {
-  const { force: e, default: t } = r;
-  return e ?? re ?? (re = It(), re ?? t);
-}, Lr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  OPERATING_SYSTEMS: Le,
-  RUNTIME: Tt,
-  detect: De,
-  getOS: At,
-  osZ: Nt
-}, Symbol.toStringTag, { value: "Module" }));
-var Et = Object.defineProperty, $t = (r, e, t) => e in r ? Et(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, q = (r, e, t) => $t(r, typeof e != "symbol" ? e + "" : e, t);
-const Mt = (...r) => r.map(Ce).join(""), Ce = (r) => (r.endsWith("/") || (r += "/"), r.startsWith("/") && (r = r.slice(1)), r), Bt = (r) => r.endsWith("/") ? r.slice(0, -1) : r, Oe = class ae {
-  /**
-   * @param host - The hostname or IP address of the server.
-   * @param port - The port number of the server.
-   * @param protocol - The protocol to use for all requests. Defaults to "".
-   * @param pathPrefix - A path prefix to use for all requests. Defaults to "".
-   */
-  constructor({ host: e, port: t, protocol: n = "", pathPrefix: s = "" }) {
-    q(this, "protocol"), q(this, "host"), q(this, "port"), q(this, "path"), this.protocol = n, this.host = e, this.port = t, this.path = Ce(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 ae({
-      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 ae({
-      ...this,
-      pathPrefix: Mt(this.path, e)
-    });
-  }
-  /** @returns a string representation of the url */
-  toString() {
-    return Bt(
-      `${this.protocol}://${this.host}:${this.port}/${this.path}`
-    );
-  }
-};
-q(Oe, "UNKNOWN", new Oe({ host: "unknown", port: 0 }));
-const Ut = -128, xt = 127, Rt = u.number().int().min(Ut).max(xt), Dt = -32768, Lt = 32767, Ct = u.number().int().min(Dt).max(Lt), Pt = -2147483648, jt = 2147483647, qt = u.number().int().min(Pt).max(jt), kt = -9223372036854775808n, Ft = 9223372036854775807n, Vt = u.bigint().min(kt).max(Ft), zt = 255, Gt = u.number().int().min(0).max(zt), Yt = 65535, Zt = u.number().int().min(0).max(Yt), Jt = 4294967295, Wt = u.number().int().min(0).max(Jt), Ht = 18446744073709551615n, Kt = u.bigint().min(0n).max(Ht), Pe = (r) => Ot(r, (e, t, n) => {
-  const s = t === n.length - 1, a = !isNaN(parseInt(e)), l = !isNaN(parseInt(n[t + 1]));
-  return a && (e = "element"), s || l ? e : [e, "shape"];
-}), Te = (r, e) => {
-  if (r == null) return null;
-  const t = r[e];
-  return t == null && typeof r == "object" && "sourceType" in r ? r.sourceType()[e] : t;
-}, Xt = (r, e, t) => Re(
-  Te(r, "shape"),
-  Pe(e),
-  { ...t, getter: Te }
-), Cr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  getFieldSchema: Xt,
-  getFieldSchemaPath: Pe,
-  int16: Ct,
-  int32: qt,
-  int64: Vt,
-  int8: Rt,
-  uint16: Zt,
-  uint32: Wt,
-  uint64: Kt,
-  uint8: Gt
-}, Symbol.toStringTag, { value: "Module" }));
-var Qt = Object.defineProperty, _t = (r, e, t) => e in r ? Qt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, k = (r, e, t) => _t(r, typeof e != "symbol" ? e + "" : e, t);
-u.object({
-  interval: O.z.optional(),
-  maxRetries: u.number().optional(),
-  scale: u.number().optional()
-});
-const U = class extends Number {
-};
-k(U, "ABSOLUTE", 255), k(U, "MINIMUM", 0), k(U, "BOUNDS", {
-  lower: U.MINIMUM,
-  // upper bound is exclusive, so we add 1
-  upper: U.ABSOLUTE + 1
-}), k(U, "z", u.union([
-  u.instanceof(U),
-  u.number().int().min(0).max(255).transform((r) => new U(r)),
-  u.instanceof(Number).transform((r) => new U(r))
-]));
-let je = U;
-const qe = u.object({
-  name: u.string(),
-  key: u.string()
-}), er = (r) => u.object({
-  subject: qe,
-  resource: r,
-  authority: je.z
-}), tr = (...r) => (e) => e.filter((t) => {
-  let n = !1;
-  return t.to != null && (n = r.includes(t.to.resource)), t.from != null && !n && (n = r.includes(t.from.resource)), n;
-}), jr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  Authority: je,
-  filterTransfersByChannelKey: tr,
-  stateZ: er,
-  subjectZ: qe
-}, Symbol.toStringTag, { value: "Module" })), ke = class F extends Error {
-  constructor() {
-    super(F.MESSAGE);
-  }
-  /** Returns true if the error or message is a cancellation error" */
-  matches(e) {
-    return typeof e == "string" ? e.includes(F.MESSAGE) : e instanceof F || e.message.includes(F.MESSAGE);
-  }
-};
-k(ke, "MESSAGE", "canceled");
-let rr = ke;
-new rr();
-const qr = (r) => r ? -1 : 1, oe = u.string().regex(/^\d+\.\d+\.\d+$/), Y = (r, e, t = {}) => {
-  t.checkMajor ?? (t.checkMajor = !0), t.checkMinor ?? (t.checkMinor = !0), t.checkPatch ?? (t.checkPatch = !0);
-  const n = oe.parse(r), s = oe.parse(e), [a, l, m] = n.split(".").map(Number), [f, g, v] = s.split(".").map(Number);
-  if (t.checkMajor) {
-    if (a < f) return W;
-    if (a > f) return H;
-  }
-  if (t.checkMinor) {
-    if (l < g) return W;
-    if (l > g) return H;
-  }
-  if (t.checkPatch) {
-    if (m < v) return W;
-    if (m > v) return H;
-  }
-  return L;
-}, nr = (r, e, t = {}) => Me(Y(r, e, t)), Fe = (r, e, t = {}) => $e(Y(r, e, t)), sr = (r, e, t = {}) => Ee(Y(r, e, t)), ir = ({
-  name: r,
-  migrate: e
-}) => (t) => {
-  try {
-    const n = e(t);
-    return console.log(`${r} migrated: ${t.version} -> ${n.version}`), n;
-  } catch (n) {
-    throw console.log(`${r} failed to migrate from ${t.version}`), console.error(n), n;
-  }
-}, ar = ({
-  name: r,
-  migrations: e,
-  targetSchema: t,
-  defaultVersion: n,
-  def: s
-}) => {
-  const a = Object.keys(e).sort(Y).pop();
-  if (a == null)
-    return (g) => {
-      if (g.version ?? (g.version = n), g.version !== s.version)
-        return console.log(
-          `${r} version ${g.version} is newer than latest version of ${s.version}.
-          Returning default instead.
-          `
-        ), s;
-      try {
-        return t != null ? t.parse(g) : g;
-      } catch (v) {
-        return console.log(`${r} failed to parse default. Exiting with default`), console.error(v), s;
-      }
-    };
-  const l = Object.keys(e).length;
-  let m = !1;
-  const f = (g) => {
-    try {
-      if (l === 0 || Fe(g.version, a))
-        return console.log(m ? `${r} ${g.version} now up to date` : `${r} version ${g.version} is up to date with target version ${s.version}`), g;
-      const v = g.version, c = e[v], E = c(g);
-      return m = !0, f(E);
-    } catch (v) {
-      return console.log(
-        `${r} failed to migrate from ${g.version} to ${a}`
-      ), console.error(v), s;
-    }
-  };
-  return (g) => {
-    try {
-      if (g.version == null)
-        if (n != null)
-          console.log(
-            `${r} version is null. Setting version to default of ${n}`
-          ), g.version = n;
-        else
-          return console.log(
-            `${r} version is null and no default version set. Exiting with default`
-          ), s;
-      return f(g);
-    } catch (v) {
-      return console.log(`${r} failed to parse final result. Exiting with default`), console.error(v), s;
-    }
-  };
-}, kr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  compareSemVer: Y,
-  createMigration: ir,
-  migrator: ar,
-  semVerNewer: Fe,
-  semVerOlder: sr,
-  semVerZ: oe,
-  versionsEqual: nr
-}, Symbol.toStringTag, { value: "Module" })), Fr = (r) => {
-  if (r === void 0 || typeof r == "string" || typeof r == "number")
-    return r;
-  if (r.toString === void 0) throw new Error("invalid renderer");
-  return r.toString();
-}, Vr = (r) => Array.isArray(r) ? [...r] : typeof r == "object" && r !== null ? { ...r } : r, or = ["h1", "h2", "h3", "h4", "h5", "p", "small"], zr = u.enum(or), ur = {
-  h1: "h2",
-  h2: "h3",
-  h3: "h4",
-  h4: "h5",
-  h5: "p",
-  p: "small",
-  small: "small"
-}, Gr = (r) => ur[r], lr = {
-  h1: "h1",
-  h2: "h1",
-  h3: "h2",
-  h4: "h3",
-  h5: "h4",
-  p: "h5",
-  small: "p"
-}, Yr = (r) => lr[r], hr = ["normal", "bold", "bolder", "lighter"], Zr = u.union([u.number(), u.enum(hr)]), Jr = u.object({
-  size: u.number(),
-  weight: u.union([u.number(), u.string()]),
-  lineHeight: u.number(),
-  textTransform: u.string().optional()
-}), Wr = {
-  small: "small",
-  medium: "p",
-  large: "h5",
-  huge: "h2"
-}, Hr = {
-  h1: "huge",
-  h2: "huge",
-  h3: "huge",
-  h4: "large",
-  h5: "small",
-  p: "medium",
-  small: "small"
-}, Ve = (r) => typeof r == "function", cr = (r, e) => Ve(r) ? r(e) : r, ee = (r) => ze(r) ? r() : r, ze = (r) => typeof r == "function", fr = ({
-  initial: r,
-  value: e,
-  onChange: t
-}) => {
-  const [n, s] = ue(ee(e ?? r));
-  return e != null && t != null ? [e, t] : [n, s];
-}, dr = ({
-  initial: r,
-  value: e,
-  onChange: t
-}) => {
-  const [n, s] = ue(ee(e ?? r));
-  return e != null && t != null ? [e, t] : [n, s];
-}, gr = (r, e) => {
-  const [t, n] = ue(() => {
-    const s = localStorage.getItem(e);
-    return s == null ? ee(r) : JSON.parse(s);
-  });
-  return [
-    t,
-    (s) => {
-      n(s), localStorage.setItem(e, JSON.stringify(s));
-    }
-  ];
-}, Kr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  executeInitialSetter: ee,
-  executeSetter: cr,
-  isInitialSetter: ze,
-  isSetter: Ve,
-  usePassthrough: fr,
-  usePersisted: gr,
-  usePurePassthrough: dr
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  ce as $,
-  Ar as A,
-  Q as B,
-  Wr as C,
-  $r as D,
-  kr as E,
-  Sr as F,
-  Vr as G,
-  Cr as H,
-  Kr as I,
-  A as J,
-  or as L,
-  Nr as R,
-  Lr as S,
-  G as U,
-  jr as Y,
-  mt as Z,
-  Hr as a,
-  Yr as b,
-  Re as c,
-  Gr as d,
-  Tr as e,
-  Br as f,
-  Rr as g,
-  Ur as h,
-  O as i,
-  fr as j,
-  dr as k,
-  zr as l,
-  w as m,
-  cr as n,
-  Se as o,
-  xr as p,
-  Ve as q,
-  qr as r,
-  Jr as s,
-  ee as t,
-  Ot as u,
-  Fr as v,
-  Zr as w,
-  vr as x,
-  Dr as y,
-  p as z
-};