@synnaxlabs/x 0.42.1 → 0.43.0

package/dist/series-B9JERcqi.js

@@ -1,1977 +0,0 @@
-var rt = Object.defineProperty;
-var it = (o, t, e) => t in o ? rt(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var r = (o, t, e) => it(o, typeof t != "symbol" ? t + "" : t, e);
-import { z as l } from "zod";
-import { J as q } from "./index-BywOGO8U.js";
-import { s as at } from "./index-DizUWH6z.js";
-import { n as ut } from "./index-QGplUHuy.js";
-import { m as C, c as L, a as J, d as D, e as ot, t as lt, f as ft } from "./bounds-Bn5_l4Z3.js";
-import "./box-Cc8IzcNo.js";
-import "./dimensions-CRgergMS.js";
-import "./base-DFq0vvGn.js";
-import "./location-C3aeu046.js";
-import "./scale-DfJe9755.js";
-import "./xy-D_LqxaGt.js";
-let ht = (o, t = 21) => (e = t) => {
-  let s = "", i = e | 0;
-  for (; i--; )
-    s += o[Math.random() * o.length | 0];
-  return s;
-};
-const ct = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", dt = ht(ct, 11), tt = () => dt(), Lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  create: tt
-}, Symbol.toStringTag, { value: "Module" })), gt = l.enum(["static", "dynamic"]), et = (o, t) => {
-  const e = new m(t);
-  if (![
-    O.DAY,
-    O.HOUR,
-    O.MINUTE,
-    O.SECOND,
-    O.MILLISECOND,
-    O.MICROSECOND,
-    O.NANOSECOND
-  ].some((i) => i.equals(e)))
-    throw new Error(
-      "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
-    );
-  const s = o.valueOf() % e.valueOf();
-  return o instanceof m ? new m(s) : new O(s);
-}, a = class a {
-  constructor(t, e = "UTC") {
-    /** The underlying value for the time stamp */
-    r(this, "value");
-    /** Makes sure JSON encodes the value and not the class. */
-    r(this, "encodeValue", !0);
-    if (t == null) this.value = a.now().valueOf();
-    else if (t instanceof Date)
-      this.value = BigInt(t.getTime()) * a.MILLISECOND.valueOf();
-    else if (typeof t == "string")
-      this.value = a.parseDateTimeString(t, e).valueOf();
-    else if (Array.isArray(t)) this.value = a.parseDate(t);
-    else {
-      let s = BigInt(0);
-      t instanceof Number && (t = t.valueOf()), e === "local" && (s = a.utcOffset.valueOf()), typeof t == "number" && (isFinite(t) ? t = Math.trunc(t) : (isNaN(t) && (t = 0), t === 1 / 0 ? t = a.MAX : t = a.MIN)), this.value = BigInt(t.valueOf()) + s;
-    }
-  }
-  static parseDate([t = 1970, e = 1, s = 1]) {
-    const i = new Date(t, e - 1, s, 0, 0, 0, 0);
-    return new a(BigInt(i.getTime()) * a.MILLISECOND.valueOf()).truncate(a.DAY).valueOf();
-  }
-  valueOf() {
-    return this.value;
-  }
-  static parseTimeString(t, e = "UTC") {
-    const [s, i, h] = t.split(":");
-    let c = "00", v = "00";
-    h != null && ([c, v] = h.split("."));
-    let b = a.hours(parseInt(s ?? "00")).add(a.minutes(parseInt(i ?? "00"))).add(a.seconds(parseInt(c ?? "00"))).add(a.milliseconds(parseInt(v ?? "00")));
-    return e === "local" && (b = b.add(a.utcOffset)), b.valueOf();
-  }
-  static parseDateTimeString(t, e = "UTC") {
-    if (!t.includes("/") && !t.includes("-"))
-      return a.parseTimeString(t, e);
-    const s = new Date(t);
-    return t.includes(":") || s.setUTCHours(0, 0, 0, 0), new a(
-      BigInt(s.getTime()) * a.MILLISECOND.valueOf(),
-      e
-    ).valueOf();
-  }
-  fString(t = "ISO", e = "UTC") {
-    switch (t) {
-      case "ISODate":
-        return this.toISOString(e).slice(0, 10);
-      case "ISOTime":
-        return this.toISOString(e).slice(11, 23);
-      case "time":
-        return this.timeString(!1, e);
-      case "preciseTime":
-        return this.timeString(!0, e);
-      case "date":
-        return this.dateString();
-      case "preciseDate":
-        return `${this.dateString()} ${this.timeString(!0, e)}`;
-      case "dateTime":
-        return `${this.dateString()} ${this.timeString(!1, e)}`;
-      default:
-        return this.toISOString(e);
-    }
-  }
-  toISOString(t = "UTC") {
-    return t === "UTC" ? this.date().toISOString() : this.sub(a.utcOffset).date().toISOString();
-  }
-  timeString(t = !1, e = "UTC") {
-    const s = this.toISOString(e);
-    return t ? s.slice(11, 23) : s.slice(11, 19);
-  }
-  dateString() {
-    const t = this.date(), e = t.toLocaleString("default", { month: "short" }), s = t.toLocaleString("default", { day: "numeric" });
-    return `${e} ${s}`;
-  }
-  static get utcOffset() {
-    return new O(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * a.MINUTE.valueOf()
-    );
-  }
-  /**
-   * @returns a TimeSpan representing the amount time elapsed since
-   * the other timestamp.
-   * @param other - The other timestamp.
-   */
-  static since(t) {
-    return new a().span(t);
-  }
-  /** @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(t) {
-    return this.valueOf() === new a(t).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(t) {
-    return this.range(t).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(t) {
-    return new A(this, t).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(t) {
-    return this.range(this.add(t)).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(t) {
-    return this.valueOf() > new a(t).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(t) {
-    return this.valueOf() >= new a(t).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(t) {
-    return this.valueOf() < new a(t).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(t) {
-    return this.valueOf() <= new a(t).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(t) {
-    return new a(this.valueOf() + BigInt(t.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(t) {
-    return new a(this.valueOf() - BigInt(t.valueOf()));
-  }
-  /**
-   * @returns the floating point number of hours since the unix epoch to the timestamp
-   * value.
-   */
-  get hours() {
-    return Number(this.valueOf()) / Number(O.HOUR.valueOf());
-  }
-  /**
-   * @returns the floating point number of minutes since the unix epoch to the timestamp
-   * value.
-   */
-  get minutes() {
-    return Number(this.valueOf()) / Number(O.MINUTE.valueOf());
-  }
-  /**
-   * @returns the floating point number of days since the unix epoch to the timestamp
-   * value.
-   */
-  get days() {
-    return Number(this.valueOf()) / Number(O.DAY.valueOf());
-  }
-  /**
-   * @returns the floating point number of seconds since the unix epoch to the timestamp
-   * value.
-   */
-  get seconds() {
-    return Number(this.valueOf()) / Number(O.SECOND.valueOf());
-  }
-  /** @returns the floating point number of milliseconds since the unix epoch. */
-  get milliseconds() {
-    return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
-  }
-  /** @returns the floating point number of microseconds since the unix epoch */
-  get microseconds() {
-    return Number(this.valueOf()) / Number(a.MICROSECOND.valueOf());
-  }
-  /**
-   * @returns the floating point number of nanoseconds since the unix epoch.
-   * Note that since we're converting to float64, this reduces the resolution
-   * to a quarter of a microsecond.
-   */
-  get nanoseconds() {
-    return Number(this.valueOf());
-  }
-  /** @returns the integer year that the timestamp corresponds to. */
-  get year() {
-    return this.date().getFullYear();
-  }
-  /**
-   * @returns a copy of the timestamp with the year changed.
-   * @param year the value to set the year to.
-   */
-  setYear(t) {
-    const e = this.date();
-    return e.setFullYear(t), new a(e);
-  }
-  /** @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(t) {
-    const e = this.date();
-    return e.setUTCMonth(t), new a(e);
-  }
-  /** @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(t) {
-    const e = this.date();
-    return e.setUTCDate(t), new a(e);
-  }
-  /**
-   * @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(t) {
-    const e = this.date();
-    return e.setUTCHours(t), new a(e, "UTC");
-  }
-  /** @returns the integer minute that the timestamp corresponds to within its hour. */
-  get minute() {
-    return this.date().getMinutes();
-  }
-  /**
-   * @returns a copy of the timestamp with the minute changed.
-   * @param minute the value to set the minute to.
-   */
-  setMinute(t) {
-    const e = this.date();
-    return e.setUTCMinutes(t), new a(e);
-  }
-  /**
-   * @returns the integer second that the timestamp corresponds to within its
-   * minute.
-   */
-  get second() {
-    return this.date().getSeconds();
-  }
-  /**
-   * @returns a copy of the timestamp with the second changed.
-   * @param second the value to set the second to.
-   */
-  setSecond(t) {
-    const e = this.date();
-    return e.setUTCSeconds(t), new a(e);
-  }
-  /**
-   * @reutrns the integer millisecond that the timestamp corresponds to within
-   * its second.
-   */
-  get millisecond() {
-    return this.date().getMilliseconds();
-  }
-  /**
-   * @returns a copy of the timestamp with the milliseconds changed.
-   * @param millisecond the value to set the millisecond to.
-   */
-  setMillisecond(t) {
-    const e = this.date();
-    return e.setMilliseconds(t), new a(e);
-  }
-  /** @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(t) {
-    return et(this, t);
-  }
-  /** @returns true if the day portion TimeStamp is today, false otherwise. */
-  get isToday() {
-    return this.truncate(O.DAY).equals(a.now().truncate(O.DAY));
-  }
-  truncate(t) {
-    return this.sub(this.remainder(t));
-  }
-  /**
-   * @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 a(/* @__PURE__ */ new Date());
-  }
-  /** @returns the maximum value of all the timestamps. */
-  static max(...t) {
-    let e = a.MIN;
-    for (const s of t) {
-      const i = new a(s);
-      i.after(e) && (e = i);
-    }
-    return e;
-  }
-  /** @returns the minimum value of all the timestamps. */
-  static min(...t) {
-    let e = a.MAX;
-    for (const s of t) {
-      const i = new a(s);
-      i.before(e) && (e = i);
-    }
-    return e;
-  }
-  /** @returns a new TimeStamp n nanoseconds after the unix epoch */
-  static nanoseconds(t, e = "UTC") {
-    return new a(t, e);
-  }
-  /** @returns a new TimeStamp n microseconds after the unix epoch */
-  static microseconds(t, e = "UTC") {
-    return a.nanoseconds(t * 1e3, e);
-  }
-  /** @returns a new TimeStamp n milliseconds after the unix epoch */
-  static milliseconds(t, e = "UTC") {
-    return a.microseconds(t * 1e3, e);
-  }
-  /** @returns a new TimeStamp n seconds after the unix epoch */
-  static seconds(t, e = "UTC") {
-    return a.milliseconds(t * 1e3, e);
-  }
-  /** @returns a new TimeStamp n minutes after the unix epoch */
-  static minutes(t, e = "UTC") {
-    return a.seconds(t * 60, e);
-  }
-  /** @returns a new TimeStamp n hours after the unix epoch */
-  static hours(t, e = "UTC") {
-    return a.minutes(t * 60, e);
-  }
-  /** @returns a new TimeStamp n days after the unix epoch */
-  static days(t, e = "UTC") {
-    return a.hours(t * 24, e);
-  }
-};
-/** One nanosecond after the unix epoch */
-r(a, "NANOSECOND", a.nanoseconds(1)), /** One microsecond after the unix epoch */
-r(a, "MICROSECOND", a.microseconds(1)), /** One millisecond after the unix epoch */
-r(a, "MILLISECOND", a.milliseconds(1)), /** One second after the unix epoch */
-r(a, "SECOND", a.seconds(1)), /** One minute after the unix epoch */
-r(a, "MINUTE", a.minutes(1)), /** One hour after the unix epoch */
-r(a, "HOUR", a.hours(1)), /** One day after the unix epoch */
-r(a, "DAY", a.days(1)), /** The maximum possible value for a timestamp */
-r(a, "MAX", new a((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
-r(a, "MIN", new a(0)), /** The unix epoch */
-r(a, "ZERO", new a(0)), /** A zod schema for validating timestamps */
-r(a, "z", l.union([
-  l.object({ value: l.bigint() }).transform((t) => new a(t.value)),
-  l.string().transform((t) => new a(BigInt(t))),
-  l.instanceof(Number).transform((t) => new a(t)),
-  l.number().transform((t) => new a(t)),
-  l.instanceof(a)
-]));
-let m = a;
-const u = class u {
-  constructor(t) {
-    r(this, "value");
-    r(this, "encodeValue", !0);
-    typeof t == "number" && (t = Math.trunc(t.valueOf())), this.value = BigInt(t.valueOf());
-  }
-  static fromSeconds(t) {
-    return t instanceof u ? t : t instanceof $ ? t.period : t instanceof m ? new u(t) : ["number", "bigint"].includes(typeof t) ? u.seconds(t) : new u(t);
-  }
-  static fromMilliseconds(t) {
-    return t instanceof u ? t : t instanceof $ ? t.period : t instanceof m ? new u(t) : ["number", "bigint"].includes(typeof t) ? u.milliseconds(t) : new u(t);
-  }
-  encode() {
-    return this.value.toString();
-  }
-  valueOf() {
-    return this.value;
-  }
-  lessThan(t) {
-    return this.valueOf() < new u(t).valueOf();
-  }
-  greaterThan(t) {
-    return this.valueOf() > new u(t).valueOf();
-  }
-  lessThanOrEqual(t) {
-    return this.valueOf() <= new u(t).valueOf();
-  }
-  greaterThanOrEqual(t) {
-    return this.valueOf() >= new u(t).valueOf();
-  }
-  remainder(t) {
-    return et(this, t);
-  }
-  truncate(t) {
-    return new u(
-      BigInt(Math.trunc(Number(this.valueOf() / t.valueOf()))) * t.valueOf()
-    );
-  }
-  toString() {
-    const t = this.truncate(u.DAY), e = this.truncate(u.HOUR), s = this.truncate(u.MINUTE), i = this.truncate(u.SECOND), h = this.truncate(u.MILLISECOND), c = this.truncate(u.MICROSECOND), v = this.truncate(u.NANOSECOND), b = t, N = e.sub(t), B = s.sub(e), f = i.sub(s), U = h.sub(i), S = c.sub(h), V = v.sub(c);
-    let E = "";
-    return b.isZero || (E += `${b.days}d `), N.isZero || (E += `${N.hours}h `), B.isZero || (E += `${B.minutes}m `), f.isZero || (E += `${f.seconds}s `), U.isZero || (E += `${U.milliseconds}ms `), S.isZero || (E += `${S.microseconds}µs `), V.isZero || (E += `${V.nanoseconds}ns`), E.trim();
-  }
-  mult(t) {
-    return new u(this.valueOf() * BigInt(t));
-  }
-  /** @returns the decimal number of days in the timespan */
-  get days() {
-    return Number(this.valueOf()) / Number(u.DAY.valueOf());
-  }
-  /** @returns the decimal number of hours in the timespan */
-  get hours() {
-    return Number(this.valueOf()) / Number(u.HOUR.valueOf());
-  }
-  /** @returns the decimal number of minutes in the timespan */
-  get minutes() {
-    return Number(this.valueOf()) / Number(u.MINUTE.valueOf());
-  }
-  /** @returns The number of seconds in the TimeSpan. */
-  get seconds() {
-    return Number(this.valueOf()) / Number(u.SECOND.valueOf());
-  }
-  /** @returns The number of milliseconds in the TimeSpan. */
-  get milliseconds() {
-    return Number(this.valueOf()) / Number(u.MILLISECOND.valueOf());
-  }
-  get microseconds() {
-    return Number(this.valueOf()) / Number(u.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(t) {
-    return this.valueOf() === new u(t).valueOf();
-  }
-  /**
-   * Adds a TimeSpan to the TimeSpan.
-   *
-   * @returns A new TimeSpan representing the sum of the two TimeSpans.
-   */
-  add(t) {
-    return new u(this.valueOf() + new u(t).valueOf());
-  }
-  /**
-   * Creates a TimeSpan representing the duration between the two timestamps.
-   *
-   * @param other
-   */
-  sub(t) {
-    return new u(this.valueOf() - new u(t).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(t = 1) {
-    return new u(t);
-  }
-  /**
-   * 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(t = 1) {
-    return u.nanoseconds(C(t, 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(t = 1) {
-    return u.microseconds(C(t, 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(t = 1) {
-    return u.milliseconds(C(t, 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(t = 1) {
-    return u.seconds(C(t, 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(t) {
-    return u.minutes(C(t, 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(t) {
-    return u.hours(C(t, 24));
-  }
-};
-/** A nanosecond. */
-r(u, "NANOSECOND", u.nanoseconds(1)), /** A microsecond. */
-r(u, "MICROSECOND", u.microseconds(1)), /** A millisecond. */
-r(u, "MILLISECOND", u.milliseconds(1)), /** A second. */
-r(u, "SECOND", u.seconds(1)), /** A minute. */
-r(u, "MINUTE", u.minutes(1)), /** Represents an hour. */
-r(u, "HOUR", u.hours(1)), /** Represents a day. */
-r(u, "DAY", u.days(1)), /** The maximum possible value for a TimeSpan. */
-r(u, "MAX", new u((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-r(u, "MIN", new u(0)), /** The zero value for a TimeSpan. */
-r(u, "ZERO", new u(0)), /** A zod schema for validating and transforming timespans */
-r(u, "z", l.union([
-  l.object({ value: l.bigint() }).transform((t) => new u(t.value)),
-  l.string().transform((t) => new u(BigInt(t))),
-  l.instanceof(Number).transform((t) => new u(t)),
-  l.number().transform((t) => new u(t)),
-  l.instanceof(u)
-]));
-let O = u;
-const p = class p extends Number {
-  constructor(t) {
-    t instanceof Number ? super(t.valueOf()) : super(t);
-  }
-  /** @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(t) {
-    return this.valueOf() === new p(t).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(t) {
-    return new O(t).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(t, e) {
-    return this.sampleCount(t) * new y(e).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(t) {
-    return O.seconds(t / 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(t, e) {
-    return this.span(t.valueOf() / e.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(t) {
-    return new p(t);
-  }
-  /**
-   * 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(t) {
-    return p.hz(t * 1e3);
-  }
-};
-/** A zod schema for validating and transforming rates */
-r(p, "z", l.union([
-  l.number().transform((t) => new p(t)),
-  l.instanceof(Number).transform((t) => new p(t)),
-  l.instanceof(p)
-]));
-let $ = p;
-const w = class w 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(t) {
-    t instanceof Number ? super(t.valueOf()) : super(t);
-  }
-  length(t) {
-    return t.valueOf() / this.valueOf();
-  }
-  size(t) {
-    return new R(t * this.valueOf());
-  }
-};
-/** Unknown/Invalid Density. */
-r(w, "UNKNOWN", new w(0)), /** 128 bits per value. */
-r(w, "BIT128", new w(16)), /** 64 bits per value. */
-r(w, "BIT64", new w(8)), /** 32 bits per value. */
-r(w, "BIT32", new w(4)), /** 16 bits per value. */
-r(w, "BIT16", new w(2)), /** 8 bits per value. */
-r(w, "BIT8", new w(1)), /** A zod schema for validating and transforming densities */
-r(w, "z", l.union([
-  l.number().transform((t) => new w(t)),
-  l.instanceof(Number).transform((t) => new w(t)),
-  l.instanceof(w)
-]));
-let y = w;
-const I = class I {
-  /**
-   * 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(t, e) {
-    /**
-     * 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.
-     */
-    r(this, "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.
-     */
-    r(this, "end");
-    typeof t == "object" && "start" in t ? (this.start = new m(t.start), this.end = new m(t.end)) : (this.start = new m(t), this.end = new m(e));
-  }
-  /** @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 I(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(t, e = O.ZERO) {
-    if (e.isZero)
-      return this.start.equals(t.start) && this.end.equals(t.end);
-    let s = this.start.sub(t.start).valueOf(), i = this.end.sub(t.end).valueOf();
-    return s < 0 && (s = -s), i < 0 && (i = -i), s <= e.valueOf() && i <= e.valueOf();
-  }
-  toString() {
-    return `${this.start.toString()} - ${this.end.toString()}`;
-  }
-  toPrettyString() {
-    return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
-  }
-  /**
-   * Checks if the two time ranges overlap. If the two time ranges are equal, returns
-   * true.  If the start of one range is equal to the end of the other, it returns false.
-   * Just follow the rule [start, end), i.e., start is inclusive, and the end is exclusive.
-   *
-   * @param other - The other TimeRange to compare to.
-   * @param delta - A TimeSpan representing the minimum amount of overlap for
-   * overlap to return true. This allows for a slight amount of leeway when
-   * checking for overlap.
-   * @returns True if the two TimeRanges overlap, false otherwise.
-   */
-  overlapsWith(t, e = O.ZERO) {
-    t = t.makeValid();
-    const s = this.makeValid();
-    if (this.equals(t)) return !0;
-    if (t.end.equals(s.start) || s.end.equals(t.start)) return !1;
-    const i = m.max(s.start, t.start), h = m.min(s.end, t.end);
-    return h.before(i) ? !1 : new O(h.sub(i)).greaterThanOrEqual(e);
-  }
-  contains(t) {
-    return t instanceof I ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
-  }
-  boundBy(t) {
-    const e = new I(this.start, this.end);
-    return t.start.after(this.start) && (e.start = t.start), t.start.after(this.end) && (e.end = t.start), t.end.before(this.end) && (e.end = t.end), t.end.before(this.start) && (e.start = t.end), e;
-  }
-  static max(...t) {
-    return new I(
-      m.min(...t.map((e) => e.start)),
-      m.max(...t.map((e) => e.end))
-    );
-  }
-};
-/** The maximum possible time range. */
-r(I, "MAX", new I(m.MIN, m.MAX)), /** The minimum possible time range. */
-r(I, "MIN", new I(m.MAX, m.MIN)), /** A time range whose start and end are both zero. */
-r(I, "ZERO", new I(m.ZERO, m.ZERO)), /** A zod schema for validating and transforming time ranges */
-r(I, "z", l.union([
-  l.object({ start: m.z, end: m.z }).transform((t) => new I(t.start, t.end)),
-  l.instanceof(I)
-]));
-let A = I;
-const Dt = (o, t) => o.start.before(t.start) ? -1 : o.start.after(t.start) ? 1 : o.end.before(t.end) ? -1 : o.end.after(t.end) ? 1 : 0, n = class n {
-  constructor(t) {
-    r(this, "value");
-    r(this, "encodeValue", !0);
-    if (t instanceof n || typeof t == "string" || typeof t.valueOf() == "string") {
-      this.value = t.valueOf();
-      return;
-    }
-    const e = n.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
-    if (e != null) {
-      this.value = e.valueOf();
-      return;
-    }
-    throw this.value = n.UNKNOWN.valueOf(), new Error(`unable to find data type for ${t.toString()}`);
-  }
-  valueOf() {
-    return this.value;
-  }
-  /**
-   * @returns the TypedArray constructor for the DataType.
-   */
-  get Array() {
-    const t = n.ARRAY_CONSTRUCTORS.get(this.toString());
-    if (t == null)
-      throw new Error(`unable to find array constructor for ${this.valueOf()}`);
-    return t;
-  }
-  /**
-   * @returns true if the DataType is equal to the given DataType.
-   */
-  equals(t) {
-    return this.valueOf() === t.valueOf();
-  }
-  /**
-   * @returns true if the DataType is equal to any of the given DataTypes.
-   */
-  matches(...t) {
-    return t.some((e) => this.equals(e));
-  }
-  /** @returns a string representation of the DataType. */
-  toString() {
-    return this.valueOf();
-  }
-  get isVariable() {
-    return this.equals(n.JSON) || this.equals(n.STRING);
-  }
-  get isNumeric() {
-    return !this.isVariable && !this.equals(n.UUID);
-  }
-  get isInteger() {
-    const t = this.toString();
-    return t.startsWith("int") || t.startsWith("uint");
-  }
-  get isFloat() {
-    return this.toString().startsWith("float");
-  }
-  get density() {
-    const t = n.DENSITIES.get(this.toString());
-    if (t == null) throw new Error(`unable to find density for ${this.valueOf()}`);
-    return t;
-  }
-  /** @returns ture if the data type is an unsigned numeric integer type */
-  get isUnsigned() {
-    return this.equals(n.UINT8) || this.equals(n.UINT16) || this.equals(n.UINT32) || this.equals(n.UINT64);
-  }
-  /** @returns true if the data type is a signed numeric integer type */
-  get isSigned() {
-    return this.equals(n.INT8) || this.equals(n.INT16) || this.equals(n.INT32) || this.equals(n.INT64);
-  }
-  /** @returns true if the data type can be cast to the other data type without loss of precision. */
-  canSafelyCastTo(t) {
-    return this.equals(t) ? !0 : !this.isNumeric || !t.isNumeric || this.isVariable || t.isVariable || this.isUnsigned && t.isSigned ? !1 : this.isFloat ? t.isFloat && this.density.valueOf() <= t.density.valueOf() : this.equals(n.INT32) && t.equals(n.FLOAT64) || this.equals(n.INT8) && t.equals(n.FLOAT32) ? !0 : this.isInteger && t.isInteger ? this.density.valueOf() <= t.density.valueOf() && this.isUnsigned === t.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(t) {
-    return this.isNumeric && t.isNumeric ? !0 : this.equals(t);
-  }
-  toJSON() {
-    return this.toString();
-  }
-  get usesBigInt() {
-    return n.BIG_INT_TYPES.some((t) => t.equals(this));
-  }
-};
-/** Represents an Unknown/Invalid DataType. */
-r(n, "UNKNOWN", new n("unknown")), /** Represents a 64-bit floating point value. */
-r(n, "FLOAT64", new n("float64")), /** Represents a 32-bit floating point value. */
-r(n, "FLOAT32", new n("float32")), /** Represents a 64-bit signed integer value. */
-r(n, "INT64", new n("int64")), /** Represents a 32-bit signed integer value. */
-r(n, "INT32", new n("int32")), /** Represents a 16-bit signed integer value. */
-r(n, "INT16", new n("int16")), /** Represents a 8-bit signed integer value. */
-r(n, "INT8", new n("int8")), /** Represents a 64-bit unsigned integer value. */
-r(n, "UINT64", new n("uint64")), /** Represents a 32-bit unsigned integer value. */
-r(n, "UINT32", new n("uint32")), /** Represents a 16-bit unsigned integer value. */
-r(n, "UINT16", new n("uint16")), /** Represents a 8-bit unsigned integer value. */
-r(n, "UINT8", new n("uint8")), /** Represents a boolean value. Alias for UINT8. */
-r(n, "BOOLEAN", n.UINT8), /** Represents a 64-bit unix epoch. */
-r(n, "TIMESTAMP", new n("timestamp")), /** Represents a UUID data type */
-r(n, "UUID", new n("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
- * by a newline character. */
-r(n, "STRING", new n("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
- * newline character. */
-r(n, "JSON", new n("json")), r(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
-  [n.UINT8.toString(), Uint8Array],
-  [n.UINT16.toString(), Uint16Array],
-  [n.UINT32.toString(), Uint32Array],
-  [n.UINT64.toString(), BigUint64Array],
-  [n.FLOAT32.toString(), Float32Array],
-  [n.FLOAT64.toString(), Float64Array],
-  [n.INT8.toString(), Int8Array],
-  [n.INT16.toString(), Int16Array],
-  [n.INT32.toString(), Int32Array],
-  [n.INT64.toString(), BigInt64Array],
-  [n.TIMESTAMP.toString(), BigInt64Array],
-  [n.STRING.toString(), Uint8Array],
-  [n.JSON.toString(), Uint8Array],
-  [n.UUID.toString(), Uint8Array]
-])), r(n, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
-  [Uint8Array.name, n.UINT8],
-  [Uint16Array.name, n.UINT16],
-  [Uint32Array.name, n.UINT32],
-  [BigUint64Array.name, n.UINT64],
-  [Float32Array.name, n.FLOAT32],
-  [Float64Array.name, n.FLOAT64],
-  [Int8Array.name, n.INT8],
-  [Int16Array.name, n.INT16],
-  [Int32Array.name, n.INT32],
-  [BigInt64Array.name, n.INT64]
-])), r(n, "DENSITIES", /* @__PURE__ */ new Map([
-  [n.UINT8.toString(), y.BIT8],
-  [n.UINT16.toString(), y.BIT16],
-  [n.UINT32.toString(), y.BIT32],
-  [n.UINT64.toString(), y.BIT64],
-  [n.FLOAT32.toString(), y.BIT32],
-  [n.FLOAT64.toString(), y.BIT64],
-  [n.INT8.toString(), y.BIT8],
-  [n.INT16.toString(), y.BIT16],
-  [n.INT32.toString(), y.BIT32],
-  [n.INT64.toString(), y.BIT64],
-  [n.TIMESTAMP.toString(), y.BIT64],
-  [n.STRING.toString(), y.UNKNOWN],
-  [n.JSON.toString(), y.UNKNOWN],
-  [n.UUID.toString(), y.BIT128]
-])), /** All the data types. */
-r(n, "ALL", [
-  n.UNKNOWN,
-  n.FLOAT64,
-  n.FLOAT32,
-  n.INT64,
-  n.INT32,
-  n.INT16,
-  n.INT8,
-  n.UINT64,
-  n.UINT32,
-  n.UINT16,
-  n.UINT8,
-  n.TIMESTAMP,
-  n.UUID,
-  n.STRING,
-  n.JSON
-]), r(n, "BIG_INT_TYPES", [n.INT64, n.UINT64, n.TIMESTAMP]), /** A zod schema for a DataType. */
-r(n, "z", l.union([
-  l.string().transform((t) => new n(t)),
-  l.instanceof(n)
-]));
-let g = n;
-const d = class d extends Number {
-  constructor(t) {
-    super(t.valueOf());
-  }
-  /** @returns true if the Size is larger than the other size. */
-  largerThan(t) {
-    return this.valueOf() > t.valueOf();
-  }
-  /** @returns true if the Size is smaller than the other size. */
-  smallerThan(t) {
-    return this.valueOf() < t.valueOf();
-  }
-  add(t) {
-    return d.bytes(this.valueOf() + t.valueOf());
-  }
-  sub(t) {
-    return d.bytes(this.valueOf() - t.valueOf());
-  }
-  truncate(t) {
-    return new d(Math.trunc(this.valueOf() / t.valueOf()) * t.valueOf());
-  }
-  remainder(t) {
-    return d.bytes(this.valueOf() % t.valueOf());
-  }
-  get gigabytes() {
-    return this.valueOf() / d.GIGABYTE.valueOf();
-  }
-  get megabytes() {
-    return this.valueOf() / d.MEGABYTE.valueOf();
-  }
-  get kilobytes() {
-    return this.valueOf() / d.KILOBYTE.valueOf();
-  }
-  get terabytes() {
-    return this.valueOf() / d.TERABYTE.valueOf();
-  }
-  toString() {
-    const t = this.truncate(d.TERABYTE), e = this.truncate(d.GIGABYTE), s = this.truncate(d.MEGABYTE), i = this.truncate(d.KILOBYTE), h = this.truncate(d.BYTE), c = t, v = e.sub(t), b = s.sub(e), N = i.sub(s), B = h.sub(i);
-    let f = "";
-    return c.isZero || (f += `${c.terabytes}TB `), v.isZero || (f += `${v.gigabytes}GB `), b.isZero || (f += `${b.megabytes}MB `), N.isZero || (f += `${N.kilobytes}KB `), (!B.isZero || f === "") && (f += `${B.valueOf()}B`), f.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(t = 1) {
-    return new d(t);
-  }
-  /**
-   * 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(t = 1) {
-    return d.bytes(t.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(t = 1) {
-    return d.kilobytes(t.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(t = 1) {
-    return d.megabytes(t.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(t) {
-    return d.gigabytes(t.valueOf() * 1e3);
-  }
-  get isZero() {
-    return this.valueOf() === 0;
-  }
-};
-/** A single byte */
-r(d, "BYTE", new d(1)), /** A kilobyte */
-r(d, "KILOBYTE", d.kilobytes(1)), /** A megabyte */
-r(d, "MEGABYTE", d.megabytes(1)), /** A gigabyte */
-r(d, "GIGABYTE", d.gigabytes(1)), /** A terabyte. */
-r(d, "TERABYTE", d.terabytes(1)), /** The zero value for Size */
-r(d, "ZERO", new d(0)), /** A zod schema for a Size. */
-r(d, "z", l.union([
-  l.number().transform((t) => new d(t)),
-  l.instanceof(d)
-]));
-let R = d;
-const qt = l.union([
-  l.instanceof(Uint8Array),
-  l.instanceof(Uint16Array),
-  l.instanceof(Uint32Array),
-  l.instanceof(BigUint64Array),
-  l.instanceof(Float32Array),
-  l.instanceof(Float64Array),
-  l.instanceof(Int8Array),
-  l.instanceof(Int16Array),
-  l.instanceof(Int32Array),
-  l.instanceof(BigInt64Array)
-]), st = (o) => {
-  const t = typeof o;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || o instanceof m || o instanceof O || o instanceof Date;
-}, mt = (o, t, e, s = 0) => o.usesBigInt && !t.usesBigInt ? Number(e) - Number(s) : !o.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(s.valueOf()) : x(e, -s).valueOf(), x = (o, t) => t == 0 ? o : o == 0 ? t : typeof o == "bigint" && typeof t == "bigint" || typeof o == "number" && typeof t == "number" ? o + t : Number(o) + Number(t), Ot = (o) => o == null ? !1 : Array.isArray(o) || o instanceof ArrayBuffer || ArrayBuffer.isView(o) && !(o instanceof DataView) || o instanceof k ? !0 : st(o), M = -1, Y = {
-  [Symbol.iterator]: () => Y,
-  next: () => ({ done: !0, value: void 0 })
-}, bt = l.string().transform(
-  (o) => new Uint8Array(
-    atob(o).split("").map((t) => t.charCodeAt(0))
-  ).buffer
-), wt = l.union([l.null(), l.undefined()]).transform(() => new Uint8Array().buffer), Z = 10, nt = (o, t) => {
-  if (o === "string" && !t.isVariable)
-    throw new Error(`cannot convert series of type ${t.toString()} to string`);
-  if (o === "number" && !t.isNumeric)
-    throw new Error(`cannot convert series of type ${t.toString()} to number`);
-  if (o === "bigint" && !t.usesBigInt)
-    throw new Error(`cannot convert series of type ${t.toString()} to bigint`);
-}, T = class T {
-  constructor(t) {
-    r(this, "key", "");
-    r(this, "isSynnaxSeries", !0);
-    /** The data type of the array */
-    r(this, "dataType");
-    /**
-     * A sample offset that can be used to shift the values of all samples upwards or
-     * downwards. Typically used to convert arrays to lower precision while preserving
-     * the relative range of actual values.
-     */
-    r(this, "sampleOffset");
-    /**
-     * Stores information about the buffer state of this array into a WebGL buffer.
-     */
-    r(this, "gl");
-    /** The underlying data. */
-    r(this, "_data");
-    r(this, "timeRange", A.ZERO);
-    r(this, "alignment", 0n);
-    /** A cached minimum value. */
-    r(this, "_cachedMin");
-    /** A cached maximum value. */
-    r(this, "_cachedMax");
-    /** The write position of the buffer. */
-    r(this, "writePos", M);
-    /** Tracks the number of entities currently using this array. */
-    r(this, "_refCount", 0);
-    /** Caches the length of the array for variable length data types. */
-    r(this, "_cachedLength");
-    /** Caches the indexes of the array for variable length data types. */
-    r(this, "_cachedIndexes");
-    Ot(t) && (t = { data: t });
-    const {
-      dataType: e,
-      timeRange: s,
-      sampleOffset: i = 0,
-      glBufferUsage: h = "static",
-      alignment: c = 0n,
-      key: v = tt()
-    } = t, b = t.data ?? [];
-    if (b instanceof T || typeof b == "object" && "isSynnaxSeries" in b && b.isSynnaxSeries === !0) {
-      const f = b;
-      this.key = f.key, this.dataType = f.dataType, this.sampleOffset = f.sampleOffset, this.gl = f.gl, this._data = f._data, this.timeRange = f.timeRange, this.alignment = f.alignment, this._cachedMin = f._cachedMin, this._cachedMax = f._cachedMax, this.writePos = f.writePos, this._refCount = f._refCount, this._cachedLength = f._cachedLength;
-      return;
-    }
-    const N = st(b), B = Array.isArray(b);
-    if (e != null) this.dataType = new g(e);
-    else {
-      if (b instanceof ArrayBuffer)
-        throw new Error(
-          "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
-        );
-      if (B || N) {
-        let f = b;
-        if (!N) {
-          if (b.length === 0)
-            throw new Error(
-              "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
-            );
-          f = b[0];
-        }
-        if (typeof f == "string") this.dataType = g.STRING;
-        else if (typeof f == "number") this.dataType = g.FLOAT64;
-        else if (typeof f == "bigint") this.dataType = g.INT64;
-        else if (typeof f == "boolean") this.dataType = g.BOOLEAN;
-        else if (f instanceof m || f instanceof Date || f instanceof m)
-          this.dataType = g.TIMESTAMP;
-        else if (typeof f == "object") this.dataType = g.JSON;
-        else
-          throw new Error(
-            `cannot infer data type of ${typeof f} when constructing a Series from a JS array`
-          );
-      } else this.dataType = new g(b);
-    }
-    if (!B && !N) this._data = b;
-    else {
-      let f = N ? [b] : b;
-      const U = f[0];
-      (U instanceof m || U instanceof Date || U instanceof O) && (f = f.map((S) => new m(S).valueOf())), this.dataType.equals(g.STRING) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(`${f.join(`
-`)}
-`).buffer) : this.dataType.equals(g.JSON) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(
-        `${f.map((S) => q.encodeString(S)).join(`
-`)}
-`
-      ).buffer) : this.dataType.usesBigInt && typeof U == "number" ? this._data = new this.dataType.Array(
-        f.map((S) => BigInt(Math.round(S)))
-      ).buffer : !this.dataType.usesBigInt && typeof U == "bigint" ? this._data = new this.dataType.Array(
-        f.map((S) => Number(S))
-      ).buffer : this._data = new this.dataType.Array(f).buffer;
-    }
-    this.key = v, this.alignment = c, this.sampleOffset = i ?? 0, this.timeRange = s ?? A.ZERO, this.gl = {
-      control: null,
-      buffer: null,
-      prevBuffer: 0,
-      bufferUsage: h
-    };
-  }
-  static alloc({ capacity: t, dataType: e, ...s }) {
-    if (t === 0)
-      throw new Error("[Series] - cannot allocate an array of length 0");
-    const i = new new g(e).Array(t), h = new T({
-      data: i.buffer,
-      dataType: e,
-      ...s
-    });
-    return h.writePos = 0, h;
-  }
-  static createTimestamps(t, e, s) {
-    const i = s.spanRange(e.span(t)), h = new BigInt64Array(t);
-    for (let c = 0; c < t; c++)
-      h[c] = BigInt(s.add(e.span(c)).valueOf());
-    return new T({ data: h, dataType: g.TIMESTAMP, timeRange: i });
-  }
-  get refCount() {
-    return this._refCount;
-  }
-  static fromStrings(t, e) {
-    const s = new TextEncoder().encode(
-      `${t.join(`
-`)}
-`
-    );
-    return new T({ data: s, dataType: g.STRING, timeRange: e });
-  }
-  static fromJSON(t, e) {
-    const s = new TextEncoder().encode(
-      `${t.map((i) => q.encodeString(i)).join(`
-`)}
-`
-    );
-    return new T({ data: s, dataType: g.JSON, timeRange: e });
-  }
-  acquire(t) {
-    this._refCount++, t != null && this.updateGLBuffer(t);
-  }
-  release() {
-    if (this._refCount <= 0) {
-      console.warn("attempted to release a series with a negative reference count");
-      return;
-    }
-    this._refCount--, this._refCount === 0 && this.gl.control != null && this.maybeGarbageCollectGLBuffer(this.gl.control);
-  }
-  /**
-   * Writes the given series to this series. If the series being written exceeds the
-   * remaining of series being written to, only the portion that fits will be written.
-   * @param other the series to write to this series. The data type of the series written
-   * must be the same as the data type of the series being written to.
-   * @returns the number of samples written. If the entire series fits, this value is
-   * equal to the length of the series being written.
-   */
-  write(t) {
-    if (!t.dataType.equals(this.dataType))
-      throw new Error("buffer must be of the same type as this array");
-    return this.dataType.isVariable ? this.writeVariable(t) : this.writeFixed(t);
-  }
-  writeVariable(t) {
-    if (this.writePos === M) return 0;
-    const e = this.byteCapacity.valueOf() - this.writePos, s = t.subBytes(0, e);
-    return this.writeToUnderlyingData(s), this.writePos += s.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += s.length, this.calculateCachedLength()), s.length;
-  }
-  writeFixed(t) {
-    if (this.writePos === M) return 0;
-    const e = this.capacity - this.writePos, s = t.sub(0, e);
-    return this.writeToUnderlyingData(s), this._cachedLength = void 0, this.maybeRecomputeMinMax(s), this.writePos += s.length, s.length;
-  }
-  writeToUnderlyingData(t) {
-    this.underlyingData.set(
-      t.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 === M ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
-  }
-  toStrings() {
-    if (!this.dataType.matches(g.STRING, g.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(g.UUID))
-      throw new Error("cannot convert non-uuid series to uuids");
-    const t = g.UUID.density.valueOf(), e = Array(this.length);
-    for (let s = 0; s < this.length; s++) {
-      const i = this.underlyingData.slice(s * t, (s + 1) * t), h = Array.from(
-        new Uint8Array(i.buffer),
-        (c) => c.toString(16).padStart(2, "0")
-      ).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-      e[s] = h;
-    }
-    return e;
-  }
-  parseJSON(t) {
-    if (!this.dataType.equals(g.JSON))
-      throw new Error("cannot parse non-JSON series as JSON");
-    return new TextDecoder().decode(this.underlyingData).split(`
-`).slice(0, -1).map((e) => t.parse(q.decodeString(e)));
-  }
-  /** @returns the capacity of the series in bytes. */
-  get byteCapacity() {
-    return new R(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 === M ? this.byteCapacity : this.dataType.isVariable ? new R(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 === M ? this.data.length : this.writePos;
-  }
-  calculateCachedLength() {
-    if (!this.dataType.isVariable)
-      throw new Error("cannot calculate length of a non-variable length data type");
-    let t = 0;
-    const e = [0];
-    return this.data.forEach((s, i) => {
-      s === Z && (t++, e.push(i + 1));
-    }), this._cachedIndexes = e, this._cachedLength = t, t;
-  }
-  /**
-   * 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(t, e = 0) {
-    if (this.dataType.equals(t)) return this;
-    const s = new t.Array(this.length);
-    for (let i = 0; i < this.length; i++)
-      s[i] = mt(this.dataType, t, this.data[i], e);
-    return new T({
-      data: s.buffer,
-      dataType: t,
-      timeRange: this.timeRange,
-      sampleOffset: e,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment
-    });
-  }
-  calcRawMax() {
-    if (this.length === 0) return -1 / 0;
-    if (this.dataType.equals(g.TIMESTAMP))
-      this._cachedMax = this.data[this.data.length - 1];
-    else if (this.dataType.usesBigInt) {
-      const t = this.data;
-      this._cachedMax = t.reduce((e, s) => e > s ? e : s);
-    } else {
-      const t = this.data;
-      this._cachedMax = t.reduce((e, s) => e > s ? e : s);
-    }
-    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()), x(this._cachedMax, this.sampleOffset));
-  }
-  calcRawMin() {
-    if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(g.TIMESTAMP)) this._cachedMin = this.data[0];
-    else if (this.dataType.usesBigInt) {
-      const t = this.data;
-      this._cachedMin = t.reduce((e, s) => e < s ? e : s);
-    } else {
-      const t = this.data;
-      this._cachedMin = t.reduce((e, s) => e < s ? e : s);
-    }
-    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()), x(this._cachedMin, this.sampleOffset));
-  }
-  /** @returns the bounds of this array. */
-  get bounds() {
-    return L(Number(this.min), Number(this.max));
-  }
-  maybeRecomputeMinMax(t) {
-    if (this._cachedMin != null) {
-      const e = t._cachedMin ?? t.calcRawMin();
-      e < this._cachedMin && (this._cachedMin = e);
-    }
-    if (this._cachedMax != null) {
-      const e = t._cachedMax ?? t.calcRawMax();
-      e > this._cachedMax && (this._cachedMax = e);
-    }
-  }
-  enrich() {
-    this.max, this.min;
-  }
-  get range() {
-    return x(this.max, -this.min);
-  }
-  atAlignment(t, e) {
-    const s = Number(t - this.alignment);
-    if (s < 0 || s >= this.length) {
-      if (e === !0) throw new Error(`[series] - no value at index ${s}`);
-      return;
-    }
-    return this.at(s, e);
-  }
-  at(t, e) {
-    if (this.dataType.isVariable) return this.atVariable(t, e ?? !1);
-    t < 0 && (t = this.length + t);
-    const s = this.data[t];
-    if (s == null) {
-      if (e === !0) throw new Error(`[series] - no value at index ${t}`);
-      return;
-    }
-    return x(s, this.sampleOffset);
-  }
-  atVariable(t, e) {
-    let s = 0, i = 0;
-    if (this._cachedIndexes != null)
-      s = this._cachedIndexes[t], i = this._cachedIndexes[t + 1] - 1;
-    else {
-      t < 0 && (t = this.length + t);
-      for (let c = 0; c < this.data.length; c++)
-        if (this.data[c] === Z) {
-          if (t === 0) {
-            i = c;
-            break;
-          }
-          s = c + 1, t--;
-        }
-      if (i === 0 && (i = this.data.length), s >= i || t > 0) {
-        if (e) throw new Error(`[series] - no value at index ${t}`);
-        return;
-      }
-    }
-    const h = this.data.slice(s, i);
-    return this.dataType.equals(g.STRING) ? new TextDecoder().decode(h) : at(JSON.parse(new TextDecoder().decode(h)));
-  }
-  /**
-   * @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(t) {
-    let e = 0, s = this.length - 1;
-    const i = ut(t);
-    for (; e <= s; ) {
-      const h = Math.floor((e + s) / 2), c = i(this.at(h, !0), t);
-      if (c === 0) return h;
-      c < 0 ? e = h + 1 : s = h - 1;
-    }
-    return e;
-  }
-  updateGLBuffer(t) {
-    if (this.gl.control = t, !this.dataType.equals(g.FLOAT32) && !this.dataType.equals(g.UINT8))
-      throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
-    const { buffer: e, bufferUsage: s, prevBuffer: i } = this.gl;
-    if (e == null && (this.gl.buffer = t.createBuffer()), this.writePos !== i)
-      if (t.bindBuffer(t.ARRAY_BUFFER, this.gl.buffer), this.writePos !== M) {
-        i === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
-        const h = this.dataType.density.size(i).valueOf(), c = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        t.bufferSubData(t.ARRAY_BUFFER, h, c.buffer), this.gl.prevBuffer = this.writePos;
-      } else
-        t.bufferData(
-          t.ARRAY_BUFFER,
-          this.buffer,
-          s === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
-        ), this.gl.prevBuffer = M;
-  }
-  as(t) {
-    return nt(t, this.dataType), this;
-  }
-  get digest() {
-    var t;
-    return {
-      key: this.key,
-      dataType: this.dataType.toString(),
-      sampleOffset: this.sampleOffset,
-      alignment: {
-        lower: H(this.alignmentBounds.lower),
-        upper: H(this.alignmentBounds.upper)
-      },
-      timeRange: (t = this.timeRange) == null ? void 0 : t.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 L(this.alignment, this.alignment + BigInt(this.length));
-  }
-  maybeGarbageCollectGLBuffer(t) {
-    this.gl.buffer != null && (t.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 t = new yt(this);
-      return this.dataType.equals(g.JSON) ? new G(t) : t;
-    }
-    return new It(this);
-  }
-  slice(t, e) {
-    return this.sliceSub(!1, t, e);
-  }
-  sub(t, e) {
-    return this.sliceSub(!0, t, e);
-  }
-  subIterator(t, e) {
-    return new W(this, t, e ?? this.length);
-  }
-  subAlignmentIterator(t, e) {
-    return new W(
-      this,
-      Number(t - this.alignment),
-      Number(e - this.alignment)
-    );
-  }
-  subBytes(t, e) {
-    if (t >= 0 && (e == null || e >= this.byteLength.valueOf())) return this;
-    const s = this.data.subarray(t, e);
-    return new T({
-      data: s,
-      dataType: this.dataType,
-      timeRange: this.timeRange,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment + BigInt(t)
-    });
-  }
-  sliceSub(t, e, s) {
-    if (e <= 0 && (s == null || s >= this.length)) return this;
-    let i;
-    return t ? i = this.data.subarray(e, s) : i = this.data.slice(e, s), new T({
-      data: i,
-      dataType: this.dataType,
-      timeRange: this.timeRange,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment + BigInt(e)
-    });
-  }
-  reAlign(t) {
-    return new T({
-      data: this.buffer,
-      dataType: this.dataType,
-      timeRange: A.ZERO,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: "static",
-      alignment: t
-    });
-  }
-  toString() {
-    var e, s;
-    let t = `${this.dataType.toString()} ${this.length} [`;
-    if (this.length <= 10) t += Array.from(this).map((i) => i.toString());
-    else {
-      for (let i = 0; i < 5; i++)
-        t += `${(e = this.at(i)) == null ? void 0 : e.toString()}`, i < 4 && (t += ",");
-      t += "...";
-      for (let i = -5; i < 0; i++)
-        t += (s = this.at(i)) == null ? void 0 : s.toString(), i < -1 && (t += ",");
-    }
-    return t += "]", t;
-  }
-};
-r(T, "crudeZ", l.object({
-  timeRange: A.z.optional(),
-  dataType: g.z,
-  alignment: l.coerce.bigint().optional(),
-  data: l.union([
-    bt,
-    wt,
-    l.instanceof(ArrayBuffer),
-    l.instanceof(Uint8Array)
-  ]),
-  glBufferUsage: gt.optional().default("static").optional()
-})), r(T, "z", T.crudeZ.transform((t) => new T(t)));
-let k = T;
-class W {
-  constructor(t, e, s) {
-    r(this, "series");
-    r(this, "end");
-    r(this, "index");
-    this.series = t;
-    const i = L(0, t.length);
-    this.end = J(i, s), this.index = J(i, e);
-  }
-  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 yt {
-  constructor(t) {
-    r(this, "series");
-    r(this, "index");
-    r(this, "decoder");
-    if (!t.dataType.isVariable)
-      throw new Error(
-        "cannot create a variable series iterator for a non-variable series"
-      );
-    this.series = t, this.index = 0, this.decoder = new TextDecoder();
-  }
-  next() {
-    const t = this.index, e = this.series.data;
-    for (; this.index < e.length && e[this.index] !== Z; ) this.index++;
-    const s = this.index;
-    return t === s ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(t, s)) });
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-}
-var j, K;
-const P = class P {
-  constructor(t) {
-    r(this, "wrapped");
-    r(this, j, "JSONSeriesIterator");
-    this.wrapped = t;
-  }
-  next() {
-    const t = this.wrapped.next();
-    return t.done === !0 ? { done: !0, value: void 0 } : {
-      done: !1,
-      value: q.decodeString(t.value, P.SCHEMA)
-    };
-  }
-  [(K = Symbol.iterator, j = Symbol.toStringTag, K)]() {
-    return this;
-  }
-};
-r(P, "SCHEMA", l.record(l.string(), l.unknown()));
-let G = P;
-var z, X;
-class It {
-  constructor(t) {
-    r(this, "series");
-    r(this, "index");
-    r(this, z, "SeriesIterator");
-    this.series = t, this.index = 0;
-  }
-  next() {
-    return this.index >= this.series.length ? { done: !0, value: void 0 } : {
-      done: !1,
-      value: this.series.at(this.index++, !0)
-    };
-  }
-  [(X = Symbol.iterator, z = Symbol.toStringTag, X)]() {
-    return this;
-  }
-}
-class $t {
-  constructor(t = []) {
-    r(this, "series");
-    if (t.length !== 0) {
-      const e = t[0].dataType;
-      for (let s = 1; s < t.length; s++)
-        if (!t[s].dataType.equals(e))
-          throw new Error("[multi-series] - series must have the same data type");
-    }
-    this.series = t;
-  }
-  as(t) {
-    return nt(t, this.dataType), this;
-  }
-  get dataType() {
-    return this.series.length === 0 ? g.UNKNOWN : this.series[0].dataType;
-  }
-  get timeRange() {
-    return this.series.length === 0 ? A.ZERO : new A(
-      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 ? L(0n, 0n) : L(
-      this.series[0].alignmentBounds.lower,
-      this.series[this.series.length - 1].alignmentBounds.upper
-    );
-  }
-  push(t) {
-    "isSynnaxSeries" in t && t.isSynnaxSeries ? this.series.push(t) : this.series.push(...t.series);
-  }
-  get length() {
-    return this.series.reduce((t, e) => t + e.length, 0);
-  }
-  atAlignment(t, e) {
-    if (this.series.length === 0) {
-      if (e) throw new Error(`[series] - no value at alignment ${t}`);
-      return;
-    }
-    for (const s of this.series)
-      if (D(s.alignmentBounds, t))
-        return s.atAlignment(t, e);
-    if (e) throw new Error(`[series] - no value at alignment ${t}`);
-  }
-  at(t, e = !1) {
-    t < 0 && (t = this.length + t);
-    for (const s of this.series) {
-      if (t < s.length) return s.at(t, e);
-      t -= s.length;
-    }
-    if (e) throw new Error(`[series] - no value at index ${t}`);
-  }
-  subIterator(t, e) {
-    return new F(this, t, e ?? this.length);
-  }
-  subAlignmentIterator(t, e) {
-    if (t >= this.alignmentBounds.upper || e <= this.alignmentBounds.lower)
-      return Y;
-    let s = 0;
-    for (let h = 0; h < this.series.length; h++) {
-      const c = this.series[h];
-      if (t < c.alignment) break;
-      if (t >= c.alignmentBounds.upper) s += c.length;
-      else if (D(c.alignmentBounds, t)) {
-        s += Number(t - c.alignment);
-        break;
-      }
-    }
-    let i = 0;
-    for (let h = 0; h < this.series.length; h++) {
-      const c = this.series[h];
-      if (e < c.alignment) break;
-      if (e >= c.alignmentBounds.upper) i += c.length;
-      else if (D(c.alignmentBounds, e)) {
-        i += Number(e - c.alignment);
-        break;
-      }
-    }
-    return new F(this, s, i);
-  }
-  subAlignmentSpanIterator(t, e) {
-    if (t >= this.alignmentBounds.upper) return Y;
-    let s = 0;
-    for (let i = 0; i < this.series.length; i++) {
-      const h = this.series[i];
-      if (t < h.alignment) break;
-      if (t >= h.alignmentBounds.upper) s += h.length;
-      else if (D(h.alignmentBounds, t)) {
-        s += Number(t - h.alignment);
-        break;
-      }
-    }
-    return new F(this, s, s + e);
-  }
-  updateGLBuffer(t) {
-    this.series.forEach((e) => e.updateGLBuffer(t));
-  }
-  get bounds() {
-    return ot(this.series.map((t) => t.bounds));
-  }
-  get byteLength() {
-    return new R(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
-  }
-  get data() {
-    const t = new this.dataType.Array(this.length);
-    let e = 0;
-    for (const s of this.series)
-      t.set(s.data, e), e += s.length;
-    return new this.dataType.Array(t.buffer);
-  }
-  traverseAlignment(t, e) {
-    const s = this.series.map((i) => i.alignmentBounds);
-    return lt(s, t, e);
-  }
-  acquire() {
-    this.series.forEach((t) => t.acquire());
-  }
-  release() {
-    this.series.forEach((t) => t.release());
-  }
-  distance(t, e) {
-    const s = this.series.map((i) => i.alignmentBounds);
-    return ft(s, t, e);
-  }
-  parseJSON(t) {
-    if (!this.dataType.equals(g.JSON))
-      throw new Error("cannot parse non-JSON series as JSON");
-    return this.series.flatMap((e) => e.parseJSON(t));
-  }
-  [Symbol.iterator]() {
-    return this.series.length === 0 ? {
-      next() {
-        return { done: !0, value: void 0 };
-      }
-    } : new Tt(this.series);
-  }
-}
-var Q, _;
-class Tt {
-  constructor(t) {
-    r(this, "series");
-    r(this, "seriesIndex");
-    r(this, "internal");
-    r(this, Q, "MultiSeriesIterator");
-    this.series = t, this.seriesIndex = 0, this.internal = t[0][Symbol.iterator]();
-  }
-  next() {
-    const t = this.internal.next();
-    return t.done === !1 ? t : this.seriesIndex === this.series.length - 1 ? { done: !0, value: void 0 } : (this.internal = this.series[++this.seriesIndex][Symbol.iterator](), this.next());
-  }
-  [(_ = Symbol.iterator, Q = Symbol.toStringTag, _)]() {
-    return this;
-  }
-}
-class F {
-  constructor(t, e, s) {
-    r(this, "series");
-    r(this, "index");
-    r(this, "end");
-    this.series = t, this.end = s, this.index = e;
-  }
-  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 H = (o) => {
-  const t = o >> 32n, e = o & 0xffffffffn;
-  return { domain: t, sample: e };
-};
-export {
-  y as D,
-  $t as M,
-  $ as R,
-  k as S,
-  m as T,
-  O as a,
-  A as b,
-  g as c,
-  R as d,
-  st as e,
-  mt as f,
-  x as g,
-  Lt as h,
-  Ot as i,
-  Dt as s,
-  qt as t
-};