@synnaxlabs/x 0.47.0 → 0.49.0

package/dist/series-Cf8rT2IX.js

@@ -1,2810 +0,0 @@
-import { z as o } from "zod";
-import { J as k } from "./index-yz34Wc2p.js";
-import { s as ft } from "./index-qmkoZBNO.js";
-import { V as R, i as U, n as ct } from "./compare-Bnx9CdjS.js";
-import { a as P, s as F, m as C, d as Y, c as L, e as X, f as $, g as ht, t as dt, h as gt } from "./bounds-4BWKPqaP.js";
-import "./box-BXWXSkKu.js";
-import "./dimensions-DC0uLPwn.js";
-import "./base-DRybODwJ.js";
-import "./location-BIzpxczO.js";
-import "./scale-DJCMZbfU.js";
-import "./xy-DnrCAZaw.js";
-let _ = (u, t = 21) => (e = t) => {
-  let s = "", i = e | 0;
-  for (; i--; )
-    s += u[Math.random() * u.length | 0];
-  return s;
-};
-const tt = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Ot = `0123456789${tt}`, et = 11, wt = _(tt, 1), bt = _(Ot, et - 1), st = () => `${wt()}${bt()}`, Dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  LENGTH: et,
-  create: st
-}, Symbol.toStringTag, { value: "Module" })), nt = (u, t) => (e) => e instanceof t || typeof e == "object" && e !== null && "discriminator" in e && e.discriminator === u, zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  createMatcher: nt
-}, Symbol.toStringTag, { value: "Module" })), It = o.enum(["static", "dynamic"]), _t = 2 ** 8 - 1, te = 2 ** 16 - 1, ee = 2 ** 32 - 1, se = 2n ** 64n - 1n, ne = 2 ** 64 - 1, re = -128, ie = 2 ** 7 - 1, ae = -32768, ue = 2 ** 15 - 1, oe = -2147483648, le = 2 ** 31 - 1, fe = -(2n ** 63n), G = 2n ** 63n - 1n, ce = -9223372036854776e3, Nt = 2 ** 63 - 1, K = 365, p = 30, mt = o.union([
-  o.tuple([o.int()]),
-  o.tuple([o.int(), o.int().min(1).max(12)]),
-  o.tuple([o.int(), o.int().min(1).max(12), o.int().min(1).max(31)])
-]), rt = (u, t) => {
-  const e = new r(t);
-  if (![
-    a.DAY,
-    a.HOUR,
-    a.MINUTE,
-    a.SECOND,
-    a.MILLISECOND,
-    a.MICROSECOND,
-    a.NANOSECOND
-  ].some((i) => i.equals(e)))
-    throw new Error(
-      "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
-    );
-  const s = u.valueOf() % e.valueOf();
-  return u instanceof r ? new r(s) : new a(s);
-};
-class r extends R {
-  constructor(t, e = "UTC") {
-    if (t == null) super(r.now().valueOf());
-    else if (t instanceof Date)
-      super(BigInt(t.getTime()) * r.MILLISECOND.valueOf());
-    else if (typeof t == "string")
-      super(r.parseDateTimeString(t, e).valueOf());
-    else if (Array.isArray(t)) super(r.parseDate(t));
-    else {
-      let s = 0n;
-      t instanceof Number && (t = t.valueOf()), e === "local" && (s = r.utcOffset.valueOf()), typeof t == "number" && (isFinite(t) ? t === Nt ? t = G : t = Math.trunc(t) : (isNaN(t) && (t = 0), t === 1 / 0 ? t = r.MAX : t = r.MIN)), U(t) && (t = t.value), super(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 r(BigInt(i.getTime()) * r.MILLISECOND.valueOf()).truncate(r.DAY).valueOf();
-  }
-  /**
-   * @returns the primitive value of the TimeStamp. Overrides standard JS valueOf()
-   * method.
-   */
-  valueOf() {
-    return this.value;
-  }
-  static parseTimeString(t, e = "UTC") {
-    const [s, i, l] = t.split(":");
-    let h = "00", M = "00";
-    l != null && ([h, M] = l.split("."));
-    let y = r.hours(parseInt(s ?? "00")).add(r.minutes(parseInt(i ?? "00"))).add(r.seconds(parseInt(h ?? "00"))).add(r.milliseconds(parseInt(M ?? "00")));
-    return e === "local" && (y = y.add(r.utcOffset)), y.valueOf();
-  }
-  static parseDateTimeString(t, e = "UTC") {
-    if (!t.includes("/") && !t.includes("-"))
-      return r.parseTimeString(t, e);
-    const s = new Date(t);
-    return t.includes(":") || s.setUTCHours(0, 0, 0, 0), new r(
-      BigInt(s.getTime()) * r.MILLISECOND.valueOf(),
-      e
-    ).valueOf();
-  }
-  toISOString(t = "UTC") {
-    return t === "UTC" ? this.date().toISOString() : this.sub(r.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}`;
-  }
-  /** @returns The UTC offset for the time zone of the machine. */
-  static get utcOffset() {
-    return new a(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * r.MINUTE.valueOf()
-    );
-  }
-  /**
-   * @returns a TimeSpan representing the amount time elapsed since
-   * the other timestamp.
-   * @param other - The other timestamp.
-   */
-  static since(t) {
-    return new r().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 r(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 m(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() === 0n;
-  }
-  /**
-   * Checks if the TimeStamp is after the given TimeStamp.
-   *
-   * @param other - The other TimeStamp to compare to.
-   * @returns True if the TimeStamp is after the given TimeStamp, false
-   *   otherwise.
-   */
-  after(t) {
-    return this.valueOf() > new r(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 r(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 r(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 r(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 r(P(this.valueOf(), new a(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 r(F(this.valueOf(), new a(t).valueOf()));
-  }
-  /**
-   * @returns the floating point number of hours since the unix epoch to the timestamp
-   * value.
-   */
-  get hours() {
-    return Number(this.valueOf()) / Number(a.HOUR.valueOf());
-  }
-  /**
-   * @returns the floating point number of minutes since the unix epoch to the timestamp
-   * value.
-   */
-  get minutes() {
-    return Number(this.valueOf()) / Number(a.MINUTE.valueOf());
-  }
-  /**
-   * @returns the floating point number of days since the unix epoch to the timestamp
-   * value.
-   */
-  get days() {
-    return Number(this.valueOf()) / Number(a.DAY.valueOf());
-  }
-  /**
-   * @returns the floating point number of seconds since the unix epoch to the timestamp
-   * value.
-   */
-  get seconds() {
-    return Number(this.valueOf()) / Number(a.SECOND.valueOf());
-  }
-  /** @returns the floating point number of milliseconds since the unix epoch. */
-  get milliseconds() {
-    return Number(this.valueOf()) / Number(r.MILLISECOND.valueOf());
-  }
-  /** @returns the floating point number of microseconds since the unix epoch. */
-  get microseconds() {
-    return Number(this.valueOf()) / Number(r.MICROSECOND.valueOf());
-  }
-  /**
-   * @returns the floating point number of nanoseconds since the unix epoch.
-   * Note that since we're converting to float64, this reduces the resolution
-   * to a quarter of a microsecond.
-   */
-  get nanoseconds() {
-    return Number(this.valueOf());
-  }
-  /** @returns the integer year that the timestamp corresponds to. */
-  get year() {
-    return this.date().getUTCFullYear();
-  }
-  /**
-   * @returns a copy of the timestamp with the year changed.
-   * @param year the value to set the year to.
-   */
-  setYear(t) {
-    const e = this.date();
-    return e.setUTCFullYear(t), new r(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 r(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 r(e);
-  }
-  /**
-   * @returns the integer hour that the timestamp corresponds to within its day.
-   */
-  get hour() {
-    return this.date().getUTCHours();
-  }
-  /**
-   * @returns the integer hour that the timestamp corresponds to within its day in local time.
-   */
-  get localHour() {
-    return this.date().getHours();
-  }
-  /**
-   * @returns a copy of the timestamp with the hour changed.
-   * @param hour the value to set the hour to.
-   */
-  setLocalHour(t) {
-    const e = this.date();
-    return e.setHours(t), new r(e);
-  }
-  /**
-   * @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 r(e);
-  }
-  /** @returns the integer minute that the timestamp corresponds to within its hour. */
-  get minute() {
-    return this.date().getUTCMinutes();
-  }
-  /**
-   * @returns a copy of the timestamp with the minute changed.
-   * @param minute the value to set the minute to.
-   */
-  setMinute(t) {
-    const e = this.date();
-    return e.setUTCMinutes(t), new r(e);
-  }
-  /**
-   * @returns the integer second that the timestamp corresponds to within its
-   * minute.
-   */
-  get second() {
-    return this.date().getUTCSeconds();
-  }
-  /**
-   * @returns a copy of the timestamp with the second changed.
-   * @param second the value to set the second to.
-   */
-  setSecond(t) {
-    const e = this.date();
-    return e.setUTCSeconds(t), new r(e);
-  }
-  /**
-   * @returns the integer millisecond that the timestamp corresponds to within its
-   * second.
-   */
-  get millisecond() {
-    return this.date().getUTCMilliseconds();
-  }
-  /**
-   * @returns a copy of the timestamp with the milliseconds changed.
-   * @param millisecond the value to set the millisecond to.
-   */
-  setMillisecond(t) {
-    const e = this.date();
-    return e.setUTCMilliseconds(t), new r(e);
-  }
-  /**
-   * Returns a string representation of the TimeStamp.
-   *
-   * @param format - Optional format for the string representation. Defaults to "ISO".
-   * @param tzInfo - Optional timezone info. Defaults to "UTC".
-   * @returns A string representation of the TimeStamp.
-   */
-  toString(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);
-    }
-  }
-  /**
-   * @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 rt(this, t);
-  }
-  /** @returns true if the day portion TimeStamp is today, false otherwise. */
-  get isToday() {
-    return this.truncate(a.DAY).equals(r.now().truncate(a.DAY));
-  }
-  /**
-   * Truncates the TimeStamp to the nearest multiple of the given span.
-   *
-   * @param span - The TimeSpan to truncate to.
-   * @returns A new TimeStamp that is truncated to the nearest multiple of the given span.
-   */
-  truncate(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 r(/* @__PURE__ */ new Date());
-  }
-  /**
-   * Finds the maximum timestamp among the provided timestamps.
-   *
-   * @param timestamps - The timestamps to compare.
-   * @returns The maximum (latest) timestamp from the input.
-   */
-  static max(...t) {
-    let e = r.MIN;
-    for (const s of t) {
-      const i = new r(s);
-      i.after(e) && (e = i);
-    }
-    return e;
-  }
-  /**
-   * Finds the minimum timestamp among the provided timestamps.
-   *
-   * @param timestamps - The timestamps to compare.
-   * @returns The minimum (earliest) timestamp from the input.
-   */
-  static min(...t) {
-    let e = r.MAX;
-    for (const s of t) {
-      const i = new r(s);
-      i.before(e) && (e = i);
-    }
-    return e;
-  }
-  /**
-   * Creates a TimeStamp representing the given number of nanoseconds.
-   *
-   * @param value - The number of nanoseconds.
-   * @returns A TimeStamp representing the given number of nanoseconds.
-   */
-  static nanoseconds(t, e = "UTC") {
-    return new r(t, e);
-  }
-  /** One nanosecond after the unix epoch */
-  static NANOSECOND = r.nanoseconds(1);
-  /** @returns a new TimeStamp n microseconds after the unix epoch */
-  static microseconds(t, e = "UTC") {
-    return r.nanoseconds(t * 1e3, e);
-  }
-  /** One microsecond after the unix epoch */
-  static MICROSECOND = r.microseconds(1);
-  /** @returns a new TimeStamp n milliseconds after the unix epoch */
-  static milliseconds(t, e = "UTC") {
-    return r.microseconds(t * 1e3, e);
-  }
-  /** One millisecond after the unix epoch */
-  static MILLISECOND = r.milliseconds(1);
-  /** @returns a new TimeStamp n seconds after the unix epoch */
-  static seconds(t, e = "UTC") {
-    return r.milliseconds(t * 1e3, e);
-  }
-  /** One second after the unix epoch */
-  static SECOND = r.seconds(1);
-  /** @returns a new TimeStamp n minutes after the unix epoch */
-  static minutes(t, e = "UTC") {
-    return r.seconds(t * 60, e);
-  }
-  /** One minute after the unix epoch */
-  static MINUTE = r.minutes(1);
-  /** @returns a new TimeStamp n hours after the unix epoch */
-  static hours(t, e = "UTC") {
-    return r.minutes(t * 60, e);
-  }
-  /** One hour after the unix epoch */
-  static HOUR = r.hours(1);
-  /** @returns a new TimeStamp n days after the unix epoch */
-  static days(t, e = "UTC") {
-    return r.hours(t * 24, e);
-  }
-  /** One day after the unix epoch */
-  static DAY = r.days(1);
-  /** The maximum possible value for a timestamp */
-  static MAX = new r(G);
-  /** The minimum possible value for a timestamp */
-  static MIN = new r(0);
-  /** The unix epoch */
-  static ZERO = new r(0);
-  /** A zod schema for validating timestamps */
-  static z = o.union([
-    o.instanceof(r),
-    o.object({ value: o.bigint() }).transform((t) => new r(t.value)),
-    o.string().transform((t) => new r(BigInt(t))),
-    o.number().transform((t) => new r(t)),
-    o.bigint().transform((t) => new r(t)),
-    o.date().transform((t) => new r(t)),
-    o.custom((t) => t instanceof a).transform((t) => new r(t)),
-    mt.transform((t) => new r(t))
-  ]);
-  /**
-   * Sorts two timestamps.
-   *
-   * @param a - The first timestamp.
-   * @param b - The second timestamp.
-   * @returns A number indicating the order of the two timestamps (positive if a is
-   * greater than b, negative if a is less than b, and 0 if they are equal).
-   */
-  static sort(t, e) {
-    return Number(t.valueOf() - e.valueOf());
-  }
-}
-class a extends R {
-  constructor(t) {
-    typeof t == "number" && (t = Math.trunc(t.valueOf())), U(t) && (t = t.value), super(BigInt(t.valueOf()));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of seconds.
-   *
-   * @param span - The number of seconds.
-   * @returns A TimeSpan representing the given number of seconds.
-   */
-  static fromSeconds(t) {
-    return t instanceof a ? t : t instanceof v ? t.period : t instanceof r ? new a(t) : (U(t) && (t = t.value), ["number", "bigint"].includes(typeof t) ? a.seconds(t) : new a(t));
-  }
-  /**
-   * Creates a TimeSpan representing the given number of milliseconds.
-   *
-   * @param span - The number of milliseconds.
-   * @returns A TimeSpan representing the given number of milliseconds.
-   */
-  static fromMilliseconds(t) {
-    return t instanceof a ? t : t instanceof v ? t.period : t instanceof r ? new a(t) : (U(t) && (t = t.value), ["number", "bigint"].includes(typeof t) ? a.milliseconds(t) : new a(t));
-  }
-  /**
-   * @returns the primitive value of the TimeSpan. Overrides standard JS valueOf()
-   * method.
-   */
-  valueOf() {
-    return this.value;
-  }
-  /**
-   * Checks if the TimeSpan is less than another TimeSpan.
-   *
-   * @param other - The TimeSpan to compare against.
-   * @returns True if the TimeSpan is less than the other TimeSpan, false otherwise.
-   */
-  lessThan(t) {
-    return this.valueOf() < new a(t).valueOf();
-  }
-  /**
-   * Checks if the TimeSpan is greater than another TimeSpan.
-   *
-   * @param other - The TimeSpan to compare against.
-   * @returns True if the TimeSpan is greater than the other TimeSpan, false otherwise.
-   */
-  greaterThan(t) {
-    return this.valueOf() > new a(t).valueOf();
-  }
-  /**
-   * Checks if the TimeSpan is less than or equal to another TimeSpan.
-   *
-   * @param other - The TimeSpan to compare against.
-   * @returns True if the TimeSpan is less than or equal to the other TimeSpan, false otherwise.
-   */
-  lessThanOrEqual(t) {
-    return this.valueOf() <= new a(t).valueOf();
-  }
-  /**
-   * Checks if the TimeSpan is greater than or equal to another TimeSpan.
-   *
-   * @param other - The TimeSpan to compare against.
-   * @returns True if the TimeSpan is greater than or equal to the other TimeSpan, false otherwise.
-   */
-  greaterThanOrEqual(t) {
-    return this.valueOf() >= new a(t).valueOf();
-  }
-  /**
-   * Calculates the remainder of the TimeSpan when divided by another TimeSpan.
-   *
-   * @param divisor - The TimeSpan to divide by.
-   * @returns A new TimeSpan representing the remainder.
-   */
-  remainder(t) {
-    return rt(this, t);
-  }
-  /**
-   * Truncates the TimeSpan to the nearest multiple of the given span.
-   *
-   * @param span - The TimeSpan to truncate to.
-   * @returns A new TimeSpan that is truncated to the nearest multiple of the given span.
-   */
-  truncate(t) {
-    return new a(
-      BigInt(Math.trunc(Number(this.valueOf() / t.valueOf()))) * t.valueOf()
-    );
-  }
-  /**
-   * Returns a string representation of the TimeSpan.
-   *
-   * @param format - Optional format for the string representation. Defaults to "full".
-   *   - "full": Shows all non-zero units with full precision (e.g., "2d 3h 45m 12s 500ms")
-   *   - "semantic": Shows 1-2 most significant units (e.g., "2d 3h")
-   * @returns A string representation of the TimeSpan.
-   */
-  toString(t = "full") {
-    if (t === "semantic") return this.toSemanticString();
-    const e = this.truncate(a.DAY), s = this.truncate(a.HOUR), i = this.truncate(a.MINUTE), l = this.truncate(a.SECOND), h = this.truncate(a.MILLISECOND), M = this.truncate(a.MICROSECOND), y = this.truncate(a.NANOSECOND), O = e, b = s.sub(e), I = i.sub(s), f = l.sub(i), A = h.sub(l), B = M.sub(h), E = y.sub(M);
-    let d = "";
-    return O.isZero || (d += `${O.days}d `), b.isZero || (d += `${b.hours}h `), I.isZero || (d += `${I.minutes}m `), f.isZero || (d += `${f.seconds}s `), A.isZero || (d += `${A.milliseconds}ms `), B.isZero || (d += `${B.microseconds}µs `), E.isZero || (d += `${E.nanoseconds}ns`), d.trim();
-  }
-  toSemanticString() {
-    const t = this.valueOf() < 0n ? -this.valueOf() : this.valueOf(), e = new a(t), s = this.valueOf() < 0n;
-    if (e.valueOf() === 0n) return "0s";
-    if (e.lessThan(a.SECOND)) return "< 1s";
-    const i = e.days, l = e.hours, h = e.minutes, M = e.seconds, y = Math.floor(i / K), O = Math.floor(i / p), b = Math.floor(i / 7), I = Math.floor(i), f = Math.floor(l), A = Math.floor(h), B = Math.floor(M), E = s ? "-" : "";
-    if (y >= 1) {
-      let d = `${y}y`;
-      if (y < 2) {
-        const w = Math.floor(
-          i % K / p
-        );
-        w > 0 && (d += ` ${w}mo`);
-      }
-      return E + d;
-    }
-    if (b >= 1 && i < p && i % 7 === 0) {
-      let d = `${b}w`;
-      const w = Math.floor(i % 7), T = Math.floor(l - b * 7 * 24);
-      return b < 2 && (w > 0 ? d += ` ${w}d` : T > 0 && T < 24 && (d += ` ${T}h`)), E + d;
-    }
-    if (O >= 1) {
-      let d = `${O}mo`;
-      if (O < 3) {
-        const w = Math.floor(i % p);
-        w > 0 && (d += ` ${w}d`);
-      }
-      return E + d;
-    }
-    if (b >= 1) {
-      let d = `${b}w`;
-      const w = Math.floor(i % 7), T = Math.floor(l - b * 7 * 24);
-      return b < 2 && (w > 0 ? d += ` ${w}d` : T > 0 && T < 24 && (d += ` ${T}h`)), E + d;
-    }
-    if (I >= 1) {
-      let d = `${I}d`;
-      const w = Math.floor(l - I * 24);
-      return I < 2 && w > 0 && (d += ` ${w}h`), E + d;
-    }
-    if (f >= 1) {
-      let d = `${f}h`;
-      if (f < 3) {
-        const w = Math.floor(h - f * 60);
-        w > 0 && (d += ` ${w}m`);
-      }
-      return E + d;
-    }
-    if (A >= 1) {
-      let d = `${A}m`;
-      if (A < 5) {
-        const w = Math.floor(M - A * 60);
-        w > 0 && (d += ` ${w}s`);
-      }
-      return E + d;
-    }
-    return `${E}${B}s`;
-  }
-  /**
-   * Multiplies the TimeSpan by a scalar value.
-   *
-   * @param value - The scalar value to multiply by.
-   * @returns A new TimeSpan that is this TimeSpan multiplied by the provided value.
-   */
-  mult(t) {
-    return new a(C(this.valueOf(), t));
-  }
-  /**
-   * Divides the TimeSpan by a scalar value.
-   *
-   * @param value - The scalar value to divide by.
-   * @returns A new TimeSpan that is this TimeSpan divided by the provided value.
-   */
-  div(t) {
-    return new a(Y(this.valueOf(), t));
-  }
-  /** @returns the decimal number of days in the TimeSpan. */
-  get days() {
-    return Number(this.valueOf()) / Number(a.DAY.valueOf());
-  }
-  /** @returns the decimal number of hours in the TimeSpan. */
-  get hours() {
-    return Number(this.valueOf()) / Number(a.HOUR.valueOf());
-  }
-  /** @returns the decimal number of minutes in the TimeSpan. */
-  get minutes() {
-    return Number(this.valueOf()) / Number(a.MINUTE.valueOf());
-  }
-  /** @returns The number of seconds in the TimeSpan. */
-  get seconds() {
-    return Number(this.valueOf()) / Number(a.SECOND.valueOf());
-  }
-  /** @returns The number of milliseconds in the TimeSpan. */
-  get milliseconds() {
-    return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
-  }
-  /** @returns The number of microseconds in the TimeSpan. */
-  get microseconds() {
-    return Number(this.valueOf()) / Number(a.MICROSECOND.valueOf());
-  }
-  /** @returns The number of nanoseconds in the TimeSpan. */
-  get nanoseconds() {
-    return Number(this.valueOf());
-  }
-  /**
-   * Checks if the TimeSpan represents a zero duration.
-   *
-   * @returns True if the TimeSpan represents a zero duration, false otherwise.
-   */
-  get isZero() {
-    return this.valueOf() === 0n;
-  }
-  /**
-   * Checks if the TimeSpan is equal to another TimeSpan.
-   *
-   * @returns True if the TimeSpans are equal, false otherwise.
-   */
-  equals(t) {
-    return this.valueOf() === new a(t).valueOf();
-  }
-  /**
-   * Adds a TimeSpan to the TimeSpan.
-   *
-   * @returns A new TimeSpan representing the sum of the two TimeSpans.
-   */
-  add(t) {
-    return new a(this.valueOf() + new a(t).valueOf());
-  }
-  /**
-   * Creates a TimeSpan representing the duration between the two timestamps.
-   *
-   * @param other
-   */
-  sub(t) {
-    return new a(this.valueOf() - new a(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 a(t);
-  }
-  /** A nanosecond. */
-  static NANOSECOND = a.nanoseconds(1);
-  /**
-   * Creates a TimeSpan representing the given number of microseconds.
-   *
-   * @param value - The number of microseconds.
-   * @returns A TimeSpan representing the given number of microseconds.
-   */
-  static microseconds(t = 1) {
-    return a.nanoseconds(C(t, 1e3));
-  }
-  /** A microsecond. */
-  static MICROSECOND = a.microseconds(1);
-  /**
-   * Creates a TimeSpan representing the given number of milliseconds.
-   *
-   * @param value - The number of milliseconds.
-   * @returns A TimeSpan representing the given number of milliseconds.
-   */
-  static milliseconds(t = 1) {
-    return a.microseconds(C(t, 1e3));
-  }
-  /** A millisecond. */
-  static MILLISECOND = a.milliseconds(1);
-  /**
-   * Creates a TimeSpan representing the given number of seconds.
-   *
-   * @param value - The number of seconds.
-   * @returns A TimeSpan representing the given number of seconds.
-   */
-  static seconds(t = 1) {
-    return a.milliseconds(C(t, 1e3));
-  }
-  /** A second. */
-  static SECOND = a.seconds(1);
-  /**
-   * Creates a TimeSpan representing the given number of minutes.
-   *
-   * @param value - The number of minutes.
-   * @returns A TimeSpan representing the given number of minutes.
-   */
-  static minutes(t = 1) {
-    return a.seconds(C(t, 60));
-  }
-  /** A minute. */
-  static MINUTE = a.minutes(1);
-  /**
-   * Creates a TimeSpan representing the given number of hours.
-   *
-   * @param value - The number of hours.
-   * @returns A TimeSpan representing the given number of hours.
-   */
-  static hours(t) {
-    return a.minutes(C(t, 60));
-  }
-  /** Represents an hour. */
-  static HOUR = a.hours(1);
-  /**
-   * Creates a TimeSpan representing the given number of days.
-   *
-   * @param value - The number of days.
-   * @returns A TimeSpan representing the given number of days.
-   */
-  static days(t) {
-    return a.hours(C(t, 24));
-  }
-  /** Represents a day. */
-  static DAY = a.days(1);
-  /** The maximum possible value for a TimeSpan. */
-  static MAX = new a(G);
-  /** The minimum possible value for a TimeSpan. */
-  static MIN = new a(0);
-  /** The zero value for a TimeSpan. */
-  static ZERO = new a(0);
-  /** A zod schema for validating and transforming time spans */
-  static z = o.union([
-    o.object({ value: o.bigint() }).transform((t) => new a(t.value)),
-    o.string().transform((t) => new a(BigInt(t))),
-    o.number().transform((t) => new a(t)),
-    o.bigint().transform((t) => new a(t)),
-    o.instanceof(a),
-    o.instanceof(r).transform((t) => new a(t)),
-    o.custom((t) => t instanceof v).transform((t) => new a(t))
-  ]);
-}
-class v extends R {
-  constructor(t) {
-    U(t) && (t = t.value), super(t.valueOf());
-  }
-  /** @returns a pretty string representation of the rate in the format "X Hz". */
-  toString() {
-    return `${this.valueOf()} Hz`;
-  }
-  /** @returns The number of seconds in the Rate. */
-  equals(t) {
-    return this.valueOf() === new v(t).valueOf();
-  }
-  /**
-   * Calculates the period of the Rate as a TimeSpan.
-   *
-   * @returns A TimeSpan representing the period of the Rate.
-   */
-  get period() {
-    return a.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 a(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 g(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 a.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() / new g(e).valueOf());
-  }
-  /**
-   * Adds another Rate to this Rate.
-   *
-   * @param other - The Rate to add.
-   * @returns A new Rate representing the sum of the two rates.
-   */
-  add(t) {
-    return new v(P(this.valueOf(), new v(t).valueOf()));
-  }
-  /**
-   * Subtracts another Rate from this Rate.
-   *
-   * @param other - The Rate to subtract.
-   * @returns A new Rate representing the difference of the two rates.
-   */
-  sub(t) {
-    return new v(F(this.valueOf(), new v(t).valueOf()));
-  }
-  /**
-   * Multiplies this Rate by a scalar value.
-   *
-   * @param value - The scalar value to multiply by.
-   * @returns A new Rate representing this Rate multiplied by the value.
-   */
-  mult(t) {
-    return new v(C(this.valueOf(), t));
-  }
-  /**
-   * Divides this Rate by a scalar value.
-   *
-   * @param value - The scalar value to divide by.
-   * @returns A new Rate representing this Rate divided by the value.
-   */
-  div(t) {
-    return new v(Y(this.valueOf(), t));
-  }
-  /**
-   * 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 v(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 v.hz(t * 1e3);
-  }
-  /** A zod schema for validating and transforming rates */
-  static z = o.union([
-    o.number().transform((t) => new v(t)),
-    o.instanceof(v)
-  ]);
-}
-class g extends R {
-  /**
-   * 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) {
-    U(t) && (t = t.value), super(t.valueOf());
-  }
-  /**
-   * Calculates the number of values in the given Size.
-   *
-   * @param size - The Size to calculate the value count from.
-   * @returns The number of values in the given Size.
-   */
-  length(t) {
-    return t.valueOf() / this.valueOf();
-  }
-  /**
-   * Calculates a Size representing the given number of values.
-   *
-   * @param sampleCount - The number of values in the Size.
-   * @returns A Size representing the given number of values.
-   */
-  size(t) {
-    return new c(t * this.valueOf());
-  }
-  /**
-   * Adds another Density to this Density.
-   *
-   * @param other - The Density to add.
-   * @returns A new Density representing the sum of the two densities.
-   */
-  add(t) {
-    return new g(P(this.valueOf(), new g(t).valueOf()));
-  }
-  /**
-   * Subtracts another Density from this Density.
-   *
-   * @param other - The Density to subtract.
-   * @returns A new Density representing the difference of the two densities.
-   */
-  sub(t) {
-    return new g(F(this.valueOf(), new g(t).valueOf()));
-  }
-  /**
-   * Multiplies this Density by a scalar value.
-   *
-   * @param value - The scalar value to multiply by.
-   * @returns A new Density representing this Density multiplied by the value.
-   */
-  mult(t) {
-    return new g(C(this.valueOf(), t));
-  }
-  /**
-   * Divides this Density by a scalar value.
-   *
-   * @param value - The scalar value to divide by.
-   * @returns A new Density representing this Density divided by the value.
-   */
-  div(t) {
-    return new g(Y(this.valueOf(), t));
-  }
-  /** Unknown/Invalid Density. */
-  static UNKNOWN = new g(0);
-  /** 128 bits per value. */
-  static BIT128 = new g(16);
-  /** 64 bits per value. */
-  static BIT64 = new g(8);
-  /** 32 bits per value. */
-  static BIT32 = new g(4);
-  /** 16 bits per value. */
-  static BIT16 = new g(2);
-  /** 8 bits per value. */
-  static BIT8 = new g(1);
-  /** A zod schema for validating and transforming densities */
-  static z = o.union([
-    o.number().transform((t) => new g(t)),
-    o.instanceof(g)
-  ]);
-}
-class m {
-  /**
-   * The starting TimeStamp of the TimeRange.
-   *
-   * Note that this value is not guaranteed to be before or equal to the ending value.
-   * To ensure that this is the case, call TimeRange.make_valid().
-   *
-   * In most cases, operations should treat start as inclusive.
-   */
-  start;
-  /**
-   * The starting TimeStamp of the TimeRange.
-   *
-   * Note that this value is not guaranteed to be before or equal to the ending value.
-   * To ensure that this is the case, call TimeRange.make_valid().
-   *
-   * In most cases, operations should treat end as exclusive.
-   */
-  end;
-  /**
-   * Creates a TimeRange from the given start and end TimeStamps.
-   *
-   * @param start - A TimeStamp representing the start of the range.
-   * @param end - A TimeStamp representing the end of the range.
-   */
-  constructor(t, e) {
-    typeof t == "object" && "start" in t ? (this.start = new r(t.start), this.end = new r(t.end)) : (this.start = new r(t), this.end = new r(e));
-  }
-  /** @returns The TimeSpan occupied by the TimeRange. */
-  get span() {
-    return new a(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 is zero (both start and end are TimeStamp.ZERO).
-   *
-   * @returns True if both start and end are TimeStamp.ZERO, false otherwise.
-   */
-  get isZero() {
-    return this.start.isZero && this.end.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 m(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 = a.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();
-  }
-  /**
-   * Returns a string representation of the TimeRange.
-   *
-   * @returns A string representation of the TimeRange.
-   */
-  toString() {
-    return `${this.start.toString()} - ${this.end.toString()}`;
-  }
-  /**
-   * Returns a pretty string representation of the TimeRange.
-   *
-   * @returns A pretty string representation of the TimeRange.
-   */
-  toPrettyString() {
-    return `${this.start.toString("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 = a.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 = r.max(s.start, t.start), l = r.min(s.end, t.end);
-    return l.before(i) ? !1 : new a(l.sub(i)).greaterThanOrEqual(e);
-  }
-  contains(t) {
-    return t instanceof m ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
-  }
-  /**
-   * Returns a new TimeRange that is bound by the given TimeRange.
-   *
-   * @param other - The TimeRange to bound by.
-   * @returns A new TimeRange that is bound by the given TimeRange.
-   * @example
-   * const range = new TimeRange(new TimeStamp(1000), new TimeStamp(2000));
-   * const other = new TimeRange(new TimeStamp(1500), new TimeStamp(2500));
-   * const bounded = range.boundBy(other);
-   * console.log(bounded); // TimeRange(1500, 2000)
-   */
-  boundBy(t) {
-    const e = new m(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 m(
-      r.min(...t.map((e) => e.start)),
-      r.max(...t.map((e) => e.end))
-    );
-  }
-  /** The maximum possible time range. */
-  static MAX = new m(r.MIN, r.MAX);
-  /** A time range whose start and end are both zero. */
-  static ZERO = new m(r.ZERO, r.ZERO);
-  /** A zod schema for validating and transforming time ranges */
-  static z = o.union([
-    o.object({ start: r.z, end: r.z }).transform((t) => new m(t.start, t.end)),
-    o.instanceof(m)
-  ]);
-  /**
-   * Sorts two time ranges. The range with the earlier start time is considered less than
-   * the range with the later start time. If the start times are equal, the range with the
-   * earlier end time is considered less than the range with the later end time.
-   *
-   * @param a - The first time range.
-   * @param b - The second time range.
-   * @returns A number indicating the order of the two time ranges. This number is
-   * positive if a is earlier than b, negative if a is later than b, and 0 if they are
-   * equal.
-   */
-  static sort(t, e) {
-    return r.sort(t.start, e.start) || r.sort(t.end, e.end);
-  }
-  /**
-   * Simplify takes the list of `TimeRange`s, makes all of them valid, sorts them, and
-   * merges any overlapping ranges.
-   *
-   * @param ranges - The list of `TimeRange`s to simplify.
-   * @returns A list of simplified `TimeRange`s.
-   */
-  static simplify(t) {
-    return t.map((e) => e.makeValid()).sort((e, s) => m.sort(e, s)).reduce((e, s) => {
-      if (s.span.isZero) return e;
-      if (e.length === 0)
-        return e.push(s), e;
-      const i = e[e.length - 1];
-      return i.overlapsWith(s) || i.end.equals(s.start) ? i.end = r.max(i.end, s.end) : e.push(s), e;
-    }, []);
-  }
-}
-class n extends R {
-  constructor(t) {
-    if (U(t) && (t = t.value), t instanceof n || typeof t == "string" || typeof t.valueOf() == "string")
-      super(t.valueOf());
-    else {
-      const e = n.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
-      if (e == null)
-        throw new Error(`unable to find data type for ${t.toString()}`);
-      super(e.valueOf());
-    }
-  }
-  /**
-   * @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. If short is true, a 1-4
-   * character representation (i64, str, etc.) is returned instead. */
-  toString(t = !1) {
-    return t ? n.SHORT_STRINGS.get(this.valueOf()) ?? this.valueOf() : this.valueOf();
-  }
-  /**
-   * @returns true if the DataType has a variable density.
-   * @example DataType.STRING.isVariable // true
-   * @example DataType.INT32.isVariable // false
-   */
-  get isVariable() {
-    return this.equals(n.JSON) || this.equals(n.STRING);
-  }
-  /**
-   * @returns true if the DataType is numeric.
-   * @example DataType.INT32.isNumeric // true
-   * @example DataType.STRING.isNumeric // false
-   */
-  get isNumeric() {
-    return !this.isVariable && !this.equals(n.UUID);
-  }
-  /**
-   * @returns true if the DataType is an integer.
-   * @example DataType.INT32.isInteger // true
-   * @example DataType.FLOAT32.isInteger // false
-   */
-  get isInteger() {
-    const t = this.toString();
-    return t.startsWith("int") || t.startsWith("uint");
-  }
-  /**
-   * @returns true if the DataType is a floating point number.
-   * @example DataType.FLOAT32.isFloat // true
-   * @example DataType.INT32.isFloat // false
-   */
-  get isFloat() {
-    return this.toString().startsWith("float");
-  }
-  /**
-   * @returns the density of the DataType.
-   * @example DataType.INT16.density // Density.BIT32
-   * @example DataType.FLOAT32.density // Density.BIT32
-   */
-  get density() {
-    const t = n.DENSITIES.get(this.toString());
-    if (t == null) throw new Error(`unable to find density for ${this.valueOf()}`);
-    return t;
-  }
-  /**
-   * @returns true if the DataType is an unsigned integer.
-   * @example DataType.UINT32.isUnsigned // true
-   * @example DataType.INT32.isUnsigned // false
-   */
-  get isUnsignedInteger() {
-    return this.equals(n.UINT8) || this.equals(n.UINT16) || this.equals(n.UINT32) || this.equals(n.UINT64);
-  }
-  /**
-   * @returns true if the DataType is a signed integer.
-   * @example DataType.INT32.isSigned // true
-   * @example DataType.UINT32.isSigned // false
-   */
-  get isSignedInteger() {
-    return this.equals(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.isUnsignedInteger && t.isSignedInteger ? !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.isUnsignedInteger === t.isUnsignedInteger : !1;
-  }
-  /** @returns true if the data type can be cast to the other data type, even if there is a loss of precision. */
-  canCastTo(t) {
-    return this.isNumeric && t.isNumeric ? !0 : this.equals(t);
-  }
-  /**
-   * 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(t) {
-    return t.constructor === this.Array;
-  }
-  /** @returns true if the data type uses bigints to store values. */
-  get usesBigInt() {
-    return n.BIG_INT_TYPES.some((t) => t.equals(this));
-  }
-  /** Represents an Unknown/Invalid DataType. */
-  static UNKNOWN = new n("unknown");
-  /** Represents a 64-bit floating point value. */
-  static FLOAT64 = new n("float64");
-  /** Represents a 32-bit floating point value. */
-  static FLOAT32 = new n("float32");
-  /** Represents a 64-bit signed integer value. */
-  static INT64 = new n("int64");
-  /** Represents a 32-bit signed integer value. */
-  static INT32 = new n("int32");
-  /** Represents a 16-bit signed integer value. */
-  static INT16 = new n("int16");
-  /** Represents a 8-bit signed integer value. */
-  static INT8 = new n("int8");
-  /** Represents a 64-bit unsigned integer value. */
-  static UINT64 = new n("uint64");
-  /** Represents a 32-bit unsigned integer value. */
-  static UINT32 = new n("uint32");
-  /** Represents a 16-bit unsigned integer value. */
-  static UINT16 = new n("uint16");
-  /** Represents a 8-bit unsigned integer value. */
-  static UINT8 = new n("uint8");
-  /** Represents a boolean value. Stored as a 8-bit unsigned integer. */
-  static BOOLEAN = new n("boolean");
-  /** Represents a 64-bit unix epoch. */
-  static TIMESTAMP = new n("timestamp");
-  /** Represents a UUID data type. */
-  static UUID = new n("uuid");
-  /** Represents a string data type. Strings have an unknown density, and are separate
-   * by a newline character. */
-  static STRING = new n("string");
-  /** Represents a JSON data type. JSON has an unknown density, and is separated by a
-   * newline character. */
-  static JSON = new n("json");
-  static 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]
-  ]);
-  static 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]
-  ]);
-  static DENSITIES = /* @__PURE__ */ new Map([
-    [n.UINT8.toString(), g.BIT8],
-    [n.UINT16.toString(), g.BIT16],
-    [n.UINT32.toString(), g.BIT32],
-    [n.UINT64.toString(), g.BIT64],
-    [n.FLOAT32.toString(), g.BIT32],
-    [n.FLOAT64.toString(), g.BIT64],
-    [n.INT8.toString(), g.BIT8],
-    [n.INT16.toString(), g.BIT16],
-    [n.INT32.toString(), g.BIT32],
-    [n.INT64.toString(), g.BIT64],
-    [n.TIMESTAMP.toString(), g.BIT64],
-    [n.STRING.toString(), g.UNKNOWN],
-    [n.JSON.toString(), g.UNKNOWN],
-    [n.UUID.toString(), g.BIT128]
-  ]);
-  /** All the data types. */
-  static 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
-  ];
-  static SHORT_STRINGS = /* @__PURE__ */ new Map([
-    [n.UINT8.toString(), "u8"],
-    [n.UINT16.toString(), "u16"],
-    [n.UINT32.toString(), "u32"],
-    [n.UINT64.toString(), "u64"],
-    [n.INT8.toString(), "i8"],
-    [n.INT16.toString(), "i16"],
-    [n.INT32.toString(), "i32"],
-    [n.INT64.toString(), "i64"],
-    [n.FLOAT32.toString(), "f32"],
-    [n.FLOAT64.toString(), "f64"],
-    [n.BOOLEAN.toString(), "bool"],
-    [n.TIMESTAMP.toString(), "ts"],
-    [n.UUID.toString(), "uuid"],
-    [n.STRING.toString(), "str"],
-    [n.JSON.toString(), "json"]
-  ]);
-  static BIG_INT_TYPES = [n.INT64, n.UINT64, n.TIMESTAMP];
-  /** A zod schema for a DataType. */
-  static z = o.union([
-    o.string().transform((t) => new n(t)),
-    o.instanceof(n)
-  ]);
-}
-class c extends R {
-  constructor(t) {
-    U(t) && (t = t.value), super(t.valueOf());
-  }
-  /** @returns true if the Size is larger than the other size. */
-  largerThan(t) {
-    return U(t) && (t = t.value), this.valueOf() > t.valueOf();
-  }
-  /** @returns true if the Size is smaller than the other size. */
-  smallerThan(t) {
-    return U(t) && (t = t.value), this.valueOf() < t.valueOf();
-  }
-  /** @returns a new Size representing the sum of the two Sizes. */
-  add(t) {
-    return U(t) && (t = t.value), new c(P(this.valueOf(), t.valueOf()));
-  }
-  /** @returns a new Size representing the difference of the two Sizes. */
-  sub(t) {
-    return U(t) && (t = t.value), new c(F(this.valueOf(), t.valueOf()));
-  }
-  /**
-   * Multiplies this Size by a scalar value.
-   *
-   * @param value - The scalar value to multiply by.
-   * @returns A new Size representing this Size multiplied by the value.
-   */
-  mult(t) {
-    return new c(C(this.valueOf(), t));
-  }
-  /**
-   * Divides this Size by a scalar value.
-   *
-   * @param value - The scalar value to divide by.
-   * @returns A new Size representing this Size divided by the value.
-   */
-  div(t) {
-    return new c(Y(this.valueOf(), t));
-  }
-  /** @returns a new Size representing the truncated value of the Size. */
-  truncate(t) {
-    return new c(
-      Math.trunc(this.valueOf() / new c(t).valueOf()) * new c(t).valueOf()
-    );
-  }
-  /** @returns a new Size representing the remainder of the Size. */
-  remainder(t) {
-    return c.bytes(this.valueOf() % new c(t).valueOf());
-  }
-  /** @returns the number of gigabytes in the Size. */
-  get gigabytes() {
-    return this.valueOf() / c.GIGABYTE.valueOf();
-  }
-  /** @returns the number of megabytes in the Size. */
-  get megabytes() {
-    return this.valueOf() / c.MEGABYTE.valueOf();
-  }
-  /** @returns the number of kilobytes in the Size. */
-  get kilobytes() {
-    return this.valueOf() / c.KILOBYTE.valueOf();
-  }
-  /** @returns the number of terabytes in the Size. */
-  get terabytes() {
-    return this.valueOf() / c.TERABYTE.valueOf();
-  }
-  /** @returns a nicely formatted string representation of the Size. */
-  toString() {
-    const t = this.truncate(c.TERABYTE), e = this.truncate(c.GIGABYTE), s = this.truncate(c.MEGABYTE), i = this.truncate(c.KILOBYTE), l = this.truncate(c.BYTE), h = t, M = e.sub(t), y = s.sub(e), O = i.sub(s), b = l.sub(i);
-    let I = "";
-    return h.isZero || (I += `${h.terabytes}TB `), M.isZero || (I += `${M.gigabytes}GB `), y.isZero || (I += `${y.megabytes}MB `), O.isZero || (I += `${O.kilobytes}KB `), (!b.isZero || I === "") && (I += `${b.valueOf()}B`), I.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 c(t);
-  }
-  /** A single byte */
-  static BYTE = new c(1);
-  /**
-   * Creates a Size from the given number if kilobytes.
-   *
-   * @param value - The number of kilobytes.
-   * @returns A Size representing the given number of kilobytes.
-   */
-  static kilobytes(t = 1) {
-    return c.bytes(new c(t).valueOf() * 1e3);
-  }
-  /** A kilobyte */
-  static KILOBYTE = c.kilobytes(1);
-  /**
-   * Creates a Size from the given number of megabytes.
-   *
-   * @param value - The number of megabytes.
-   * @returns A Size representing the given number of megabytes.
-   */
-  static megabytes(t = 1) {
-    return c.kilobytes(new c(t).valueOf() * 1e3);
-  }
-  /** A megabyte */
-  static MEGABYTE = c.megabytes(1);
-  /**
-   * Creates a Size from the given number of gigabytes.
-   *
-   * @param value - The number of gigabytes.
-   * @returns A Size representing the given number of gigabytes.
-   */
-  static gigabytes(t = 1) {
-    return c.megabytes(new c(t).valueOf() * 1e3);
-  }
-  /** A gigabyte */
-  static GIGABYTE = c.gigabytes(1);
-  /**
-   * Creates a Size from the given number of terabytes.
-   *
-   * @param value - The number of terabytes.
-   * @returns  A Size representing the given number of terabytes.
-   */
-  static terabytes(t) {
-    return c.gigabytes(new c(t).valueOf() * 1e3);
-  }
-  /** A terabyte. */
-  static TERABYTE = c.terabytes(1);
-  /** The zero value for Size */
-  static ZERO = new c(0);
-  /** A zod schema for a Size. */
-  static z = o.union([
-    o.number().transform((t) => new c(t)),
-    o.instanceof(c)
-  ]);
-  /** @returns true if the Size is zero. */
-  get isZero() {
-    return this.valueOf() === 0;
-  }
-}
-const he = o.object({
-  start: o.number(),
-  end: o.number()
-}), de = o.union([
-  o.instanceof(Uint8Array),
-  o.instanceof(Uint16Array),
-  o.instanceof(Uint32Array),
-  o.instanceof(BigUint64Array),
-  o.instanceof(Float32Array),
-  o.instanceof(Float64Array),
-  o.instanceof(Int8Array),
-  o.instanceof(Int16Array),
-  o.instanceof(Int32Array),
-  o.instanceof(BigInt64Array)
-]), it = (u) => {
-  const t = typeof u;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || u instanceof r || u instanceof a || u instanceof Date;
-}, vt = (u, t, e, s = 0) => u.usesBigInt && !t.usesBigInt ? Number(e) - Number(s) : !u.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(s.valueOf()) : q(e, -s), q = (u, t) => t == 0 ? u : u == 0 ? t : typeof u == "bigint" && typeof t == "bigint" || typeof u == "number" && typeof t == "number" ? u + t : Number(u) + Number(t), yt = "00000000-0000-0000-0000-000000000000", Mt = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-function At(u) {
-  return typeof u == "string" && Mt.test(u);
-}
-const N = [];
-for (let u = 0; u < 256; ++u)
-  N.push((u + 256).toString(16).slice(1));
-function at(u, t = 0) {
-  return (N[u[t + 0]] + N[u[t + 1]] + N[u[t + 2]] + N[u[t + 3]] + "-" + N[u[t + 4]] + N[u[t + 5]] + "-" + N[u[t + 6]] + N[u[t + 7]] + "-" + N[u[t + 8]] + N[u[t + 9]] + "-" + N[u[t + 10]] + N[u[t + 11]] + N[u[t + 12]] + N[u[t + 13]] + N[u[t + 14]] + N[u[t + 15]]).toLowerCase();
-}
-function Ut(u, t = 0) {
-  const e = at(u, t);
-  if (!At(e))
-    throw TypeError("Stringified UUID is invalid");
-  return e;
-}
-let Z;
-const Et = new Uint8Array(16);
-function Bt() {
-  if (!Z) {
-    if (typeof crypto > "u" || !crypto.getRandomValues)
-      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-    Z = crypto.getRandomValues.bind(crypto);
-  }
-  return Z(Et);
-}
-const Ct = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), Q = { randomUUID: Ct };
-function xt(u, t, e) {
-  u = u || {};
-  const s = u.random ?? u.rng?.() ?? Bt();
-  if (s.length < 16)
-    throw new Error("Random bytes length must be >= 16");
-  return s[6] = s[6] & 15 | 64, s[8] = s[8] & 63 | 128, at(s);
-}
-function St(u, t, e) {
-  return Q.randomUUID && !u ? Q.randomUUID() : xt(u);
-}
-const Tt = () => St(), j = (u, t) => Ut(u, t), Rt = yt, ge = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  ZERO: Rt,
-  create: Tt,
-  parse: j
-}, Symbol.toStringTag, { value: "Module" })), S = -1, H = {
-  [Symbol.iterator]: () => H,
-  next: () => ({ done: !0, value: void 0 })
-}, Lt = o.string().transform(
-  (u) => new Uint8Array(
-    atob(u).split("").map((t) => t.charCodeAt(0))
-  ).buffer
-), $t = o.union([o.null(), o.undefined()]).transform(() => new Uint8Array().buffer), J = 10, ut = (u, t) => {
-  if (u === "number" && !t.isNumeric)
-    throw new Error(`cannot convert series of type ${t.toString()} to number`);
-  if (u === "bigint" && !t.usesBigInt)
-    throw new Error(`cannot convert series of type ${t.toString()} to bigint`);
-}, ot = "sy_x_telem_series";
-class x {
-  /**
-   * A unique identifier for the series. If specified by the user, it is their
-   * responsibility to ensure that it is unique. If not specified, a new ID will be
-   * generated.
-   */
-  key;
-  /**
-   * A discriminator used for identifying instances of the series class even
-   * when bundlers mangle the class name.
-   */
-  discriminator = ot;
-  /** The data type of the series. */
-  dataType;
-  /**
-   * A sample offset that can be used to shift the values of all samples upwards or
-   * downwards. Useful to convert series to lower precision data types while preserving
-   * the relative range of actual values.
-   */
-  sampleOffset;
-  /**
-   * Stores information about the buffer state of this array into a WebGL buffer.
-   */
-  gl;
-  /** The underlying data. */
-  _data;
-  /** The time range occupied by the series' data. */
-  timeRange = m.ZERO;
-  /**
-   * Alignment defines the location of the series relative to other series in a logical
-   * group. Useful for defining the position of the series within a channel's data.
-   */
-  alignment = 0n;
-  /**
-   * Alignment multiple defines the number of alignment steps taken per sample. This is
-   * useful for when the samples in a series represent a partial view of the raw data
-   * i.e. decimation or averaging.
-   */
-  alignmentMultiple = 1n;
-  /** A cached minimum value. */
-  cachedMin;
-  /** A cached maximum value. */
-  cachedMax;
-  /** The write position of the buffer. */
-  writePos = S;
-  /** Tracks the number of entities currently using this array. */
-  _refCount = 0;
-  /** Caches the length of the array for variable length data types. */
-  cachedLength;
-  /** Caches the indexes of the array for variable length data types. */
-  _cachedIndexes;
-  /**
-   * A zod schema that can be used to validate that a particular value
-   * can be constructed into a series.
-   */
-  static crudeZ = o.object({
-    timeRange: m.z.optional(),
-    dataType: n.z,
-    alignment: o.coerce.bigint().optional(),
-    data: o.union([
-      Lt,
-      $t,
-      o.instanceof(ArrayBuffer),
-      o.instanceof(Uint8Array)
-    ]),
-    glBufferUsage: It.optional().default("static").optional()
-  });
-  /**
-   * A zod schema that validates and constructs a series from it's crude
-   * representation.
-   */
-  static z = x.crudeZ.transform((t) => new x(t));
-  /**
-   * The Series constructor accepts either a SeriesArgs object or a CrudeSeries value.
-   *
-   * SeriesArgs interface properties:
-   * @property {CrudeSeries | null} [data] - The data to construct the series from. Can be:
-   *   - A typed array (e.g. Float32Array, Int32Array)
-   *   - A JS array of numbers, strings, or objects
-   *   - A single value (number, string, bigint, etc.)
-   *   - An ArrayBuffer
-   *   - Another Series instance
-   * @property {CrudeDataType} [dataType] - The data type of the series. If not provided,
-   *   will be inferred from the data. Required when constructing from an ArrayBuffer, or
-   *   an empty JS array.
-   * @property {TimeRange} [timeRange] - The time range occupied by the series' data.
-   *   Defaults to TimeRange.ZERO.
-   * @property {math.Numeric} [sampleOffset] - An offset to apply to each sample value.
-   *   Useful for converting arrays to lower precision while preserving relative range.
-   *   Defaults to 0.
-   * @property {GLBufferUsage} [glBufferUsage] - The WebGL buffer usage hint. Can be
-   *   "static" or "dynamic". Defaults to "static".
-   * @property {bigint} [alignment] - The logical position of the series relative to other
-   *   series in a group. Defaults to 0n.
-   * @property {string} [key] - A unique identifier for the series. If not provided,
-   *   a new ID will be generated.
-   *
-   * @example
-   * // Create a series from a typed array
-   * const s1 = new Series(new Float32Array([1, 2, 3]));
-   *
-   * @example
-   * // Create a series from a JS array with explicit data type
-   * const s2 = new Series({ data: [1, 2, 3], dataType: DataType.FLOAT32 });
-   *
-   * @example
-   * // Create a series from a single value (data type inferred)
-   * const s3 = new Series(1); // Creates a FLOAT64 series
-   * const s4 = new Series("abc"); // Creates a STRING series
-   * const s5 = new Series(1n); // Creates an INT64 series
-   *
-   * @example
-   * // Create a series from objects (automatically uses JSON data type)
-   * const s6 = new Series([{ a: 1, b: "apple" }]);
-   *
-   * @example
-   * // Create a series with time range and alignment
-   * const s7 = new Series({
-   *   data: new Float32Array([1, 2, 3]),
-   *   timeRange: new TimeRange(1, 2),
-   *   alignment: 1n
-   * });
-   *
-   * @example
-   * // Create a series from another series (copies properties)
-   * const s8 = new Series(s1);
-   *
-   * @example
-   * // Create a series with sample offset
-   * const s9 = new Series({
-   *   data: new Float32Array([1, 2, 3]),
-   *   sampleOffset: 2
-   * }); // Values will be 3, 4, 5
-   *
-   * @example
-   * // Create a series with WebGL buffer usage
-   * const s10 = new Series({
-   *   data: new Float32Array([1, 2, 3]),
-   *   glBufferUsage: "dynamic"
-   * });
-   *
-   * @throws Error if constructing from an empty JS array without specifying data type
-   * @throws Error if constructing from an ArrayBuffer without specifying data type
-   * @throws Error if data type cannot be inferred from input
-   */
-  constructor(t) {
-    pt(t) && (t = { data: t }), t.data ??= [];
-    const {
-      dataType: e,
-      timeRange: s,
-      sampleOffset: i = 0,
-      glBufferUsage: l = "static",
-      alignment: h = 0n,
-      alignmentMultiple: M = 1n,
-      key: y = st(),
-      data: O
-    } = t;
-    if (lt(O)) {
-      const f = O;
-      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.alignmentMultiple = f.alignmentMultiple, this.cachedMin = f.cachedMin, this.cachedMax = f.cachedMax, this.writePos = f.writePos, this._refCount = f._refCount, this.cachedLength = f.cachedLength;
-      return;
-    }
-    const b = it(O), I = Array.isArray(O);
-    if (e != null) this.dataType = new n(e);
-    else {
-      if (O instanceof ArrayBuffer)
-        throw new Error(
-          "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
-        );
-      if (I || b) {
-        let f = O;
-        if (!b) {
-          if (O.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 = O[0];
-        }
-        if (typeof f == "string") this.dataType = n.STRING;
-        else if (typeof f == "number") this.dataType = n.FLOAT64;
-        else if (typeof f == "bigint") this.dataType = n.INT64;
-        else if (typeof f == "boolean") this.dataType = n.BOOLEAN;
-        else if (f instanceof r || f instanceof Date || f instanceof r)
-          this.dataType = n.TIMESTAMP;
-        else if (typeof f == "object") this.dataType = n.JSON;
-        else
-          throw new Error(
-            `cannot infer data type of ${typeof f} when constructing a Series from a JS array`
-          );
-      } else this.dataType = new n(O);
-    }
-    if (!I && !b) this._data = O;
-    else if (I && O.length === 0)
-      this._data = new this.dataType.Array([]).buffer;
-    else {
-      let f = b ? [O] : O;
-      const A = f[0];
-      (A instanceof r || A instanceof Date || A instanceof a) && (f = f.map((B) => new r(B).valueOf())), this.dataType.equals(n.STRING) ? (this.cachedLength = f.length, this._data = new TextEncoder().encode(`${f.join(`
-`)}
-`).buffer) : this.dataType.equals(n.JSON) ? (this.cachedLength = f.length, this._data = new TextEncoder().encode(
-        `${f.map((B) => k.encodeString(B)).join(`
-`)}
-`
-      ).buffer) : this.dataType.usesBigInt && typeof A == "number" ? this._data = new this.dataType.Array(
-        f.map((B) => BigInt(Math.round(B)))
-      ).buffer : !this.dataType.usesBigInt && typeof A == "bigint" ? this._data = new this.dataType.Array(
-        f.map(Number)
-      ).buffer : this._data = new this.dataType.Array(f).buffer;
-    }
-    this.key = y, this.alignment = h, this.alignmentMultiple = M, this.sampleOffset = i ?? 0, this.timeRange = s ?? m.ZERO, this.gl = {
-      control: null,
-      buffer: null,
-      prevBuffer: 0,
-      bufferUsage: l
-    };
-  }
-  /**
-   * Allocates a new series with a given capacity and data type.
-   * @param args.capacity the capacity of the series in samples. If the data type is of
-   * variable density (i.e. JSON, STRING, BYTES), this is the capacity in bytes.
-   * @param args.dataType the data type of the series.
-   * @param args.rest the rest of the arguments to pass to the series constructor.
-   */
-  static alloc({ capacity: t, dataType: e, ...s }) {
-    if (t === 0)
-      throw new Error("[Series] - cannot allocate an array of length 0");
-    const i = new new n(e).Array(t), l = new x({ data: i.buffer, dataType: e, ...s });
-    return l.writePos = 0, l;
-  }
-  /**
-   * @returns the number of references to this series i.e. the number of times this
-   * series has been acquired (by calling acquire) and not released (by calling
-   * release).
-   */
-  get refCount() {
-    return this._refCount;
-  }
-  /**
-   * Acquires a reference to this series, optionally buffering its data into the
-   * specified buffer controller. This method is useful for managing the life span
-   * of series buffered to the GPU.
-   * @param gl the buffer controller to buffer the series to. If not provided, the series
-   * will not be buffered to the GPU.
-   */
-  acquire(t) {
-    this._refCount++, t != null && this.updateGLBuffer(t);
-  }
-  /**
-   * Releases a reference to this series. If the reference count to the series reaches
-   * 0 and the series has been buffered to the GPU, the series will be deleted from
-   * the GPU.
-   */
-  release() {
-    this._refCount--, this.refCount === 0 && this.gl.control != null ? this.maybeGarbageCollectGLBuffer(this.gl.control) : this.refCount < 0 && console.warn("cannot release a series with a negative reference count");
-  }
-  /**
-   * Writes the given series to this series. If the series being written exceeds the
-   * remaining of series being written to, only the portion that fits will be written.
-   * @param other the series to write to this series. The data type of the series written
-   * must be the same as the data type of the series being written to.
-   * @returns the number of samples written. If the entire series fits, this value is
-   * equal to the length of the series being written.
-   */
-  write(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 === S) 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 === S) 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 JS typed array with the proper data type.
-   * If the series is not full, returns a view of the data up to the write position.
-   * @returns A typed array containing the series data.
-   */
-  get data() {
-    return this.writePos === S ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
-  }
-  /**
-   * Returns an array of the values in the series as strings.
-   * For variable length data types (like STRING or JSON), this decodes the underlying buffer.
-   * @returns An array of string representations of the series values.
-   */
-  toStrings() {
-    return this.dataType.isVariable ? new TextDecoder().decode(this.underlyingData).split(`
-`).slice(0, -1) : Array.from(this).map((t) => t.toString());
-  }
-  /**
-   * Parses a JSON series into an array of values using the provided zod schema.
-   * @template Z The zod schema type.
-   * @param schema The zod schema to use to parse the JSON series.
-   * @throws Error if the series does not have a data type of JSON.
-   * @returns An array of values parsed from the JSON series.
-   */
-  parseJSON(t) {
-    if (!this.dataType.equals(n.JSON))
-      throw new Error("cannot parse non-JSON series as JSON");
-    return this.toStrings().map((e) => t.parse(k.decodeString(e)));
-  }
-  /**
-   * Returns the capacity of the series in bytes.
-   * @returns The size of the underlying buffer in bytes.
-   */
-  get byteCapacity() {
-    return new c(this.underlyingData.byteLength);
-  }
-  /**
-   * Returns the capacity of the series in samples.
-   * For variable length data types, this is the capacity in bytes.
-   * @returns The number of samples that can be stored in the series.
-   */
-  get capacity() {
-    return this.dataType.isVariable ? this.byteCapacity.valueOf() : this.dataType.density.length(this.byteCapacity);
-  }
-  /**
-   * Returns the length of the series in bytes.
-   * For variable length data types, this is the actual number of bytes used.
-   * @returns The size of the data in bytes.
-   */
-  get byteLength() {
-    return this.writePos === S ? this.byteCapacity : this.dataType.isVariable ? new c(this.writePos) : this.dataType.density.size(this.writePos);
-  }
-  /**
-   * Returns the number of samples in this array.
-   * For variable length data types, this is calculated by counting newlines.
-   * @returns The number of samples in the series.
-   */
-  get length() {
-    return this.cachedLength != null ? this.cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === S ? this.byteCapacity.valueOf() / this.dataType.density.valueOf() : this.writePos;
-  }
-  calculateCachedLength() {
-    if (!this.dataType.isVariable)
-      throw new Error("cannot calculate length of a non-variable length data type");
-    let t = 0;
-    const e = [0];
-    return this.data.forEach((s, i) => {
-      s === J && (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] = vt(this.dataType, t, this.data[i], e);
-    return new x({
-      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(n.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() {
-    return this.calcMax();
-  }
-  calcMax() {
-    if (this.dataType.isVariable)
-      throw new Error("cannot calculate maximum on a variable length data type");
-    return this.writePos === 0 ? -1 / 0 : (this.cachedMax ??= this.calcRawMax(), q(this.cachedMax, this.sampleOffset));
-  }
-  calcRawMin() {
-    if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(n.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() {
-    return this.calcMin();
-  }
-  calcMin() {
-    if (this.dataType.isVariable)
-      throw new Error("cannot calculate minimum on a variable length data type");
-    return this.writePos === 0 ? 1 / 0 : (this.cachedMin ??= this.calcRawMin(), q(this.cachedMin, this.sampleOffset));
-  }
-  /** @returns the bounds of the series. */
-  get bounds() {
-    return L(Number(this.min), Number(this.max), { makeValid: !1 });
-  }
-  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);
-    }
-  }
-  atAlignment(t, e) {
-    const s = Number((t - this.alignment) / this.alignmentMultiple);
-    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 = !1) {
-    if (this.dataType.isVariable) return this.atVariable(t, e ?? !1);
-    if (this.dataType.equals(n.UUID)) return this.atUUID(t, e);
-    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 q(s, this.sampleOffset);
-  }
-  atUUID(t, e) {
-    t < 0 && (t = this.length + t);
-    const s = j(
-      new Uint8Array(this.buffer, t * this.dataType.density.valueOf())
-    );
-    if (s == null) {
-      if (e) throw new Error(`[series] - no value at index ${t}`);
-      return;
-    }
-    return s;
-  }
-  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 h = 0; h < this.data.length; h++)
-        if (this.data[h] === J) {
-          if (t === 0) {
-            i = h;
-            break;
-          }
-          s = h + 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 l = this.data.slice(s, i);
-    return this.dataType.equals(n.STRING) ? new TextDecoder().decode(l) : ft(JSON.parse(new TextDecoder().decode(l)));
-  }
-  /**
-   * @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 = ct(t);
-    for (; e <= s; ) {
-      const l = Math.floor((e + s) / 2), h = i(this.at(l, !0), t);
-      if (h === 0) return l;
-      h < 0 ? e = l + 1 : s = l - 1;
-    }
-    return e;
-  }
-  /**
-   * Updates the WebGL buffer for the series if it is not up to date. This method
-   * should be called whenever a series has been previously buffered to the GPU and
-   * then modified via calls to write().
-   * @param gl the buffer controller to update the buffer for. This controller should
-   * be the same buffer previously passed to {@method acquire} or {@method updateGLBuffer}.
-   */
-  updateGLBuffer(t) {
-    if (this.gl.control = t, !this.dataType.equals(n.FLOAT32) && !this.dataType.equals(n.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 !== S) {
-        i === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
-        const l = this.dataType.density.size(i).valueOf(), h = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        t.bufferSubData(t.ARRAY_BUFFER, l, h.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 = S;
-  }
-  as(t) {
-    return ut(t, this.dataType), this;
-  }
-  /** @returns a digest containing information about the series. */
-  get digest() {
-    return {
-      key: this.key,
-      dataType: this.dataType.toString(),
-      sampleOffset: this.sampleOffset,
-      alignment: {
-        lower: z(this.alignmentBounds.lower),
-        upper: z(this.alignmentBounds.upper),
-        multiple: this.alignmentMultiple
-      },
-      timeRange: this.timeRange.toString(),
-      length: this.length,
-      capacity: this.capacity
-    };
-  }
-  /**
-   * @returns the alignment bounds of the series, representing the logical space
-   * occupied by the series in a group of series. This is typically used to order the
-   * series within a channel's data.
-   *
-   * The lower bound is the alignment of the first sample, and the upper bound is the
-   * alignment of the last sample + 1. The lower bound is inclusive, while the upper bound
-   * is exclusive.
-   */
-  get alignmentBounds() {
-    return L(
-      this.alignment,
-      this.alignment + BigInt(this.length) * this.alignmentMultiple
-    );
-  }
-  maybeGarbageCollectGLBuffer(t) {
-    this.gl.buffer != null && (t.deleteBuffer(this.gl.buffer), this.gl.buffer = null, this.gl.prevBuffer = 0, this.gl.control = null);
-  }
-  /**
-   * @returns the WebGL buffer for the series. This method should only be called after
-   * the series has been buffered to the GPU via a call to {@method acquire} or
-   * {@method updateGLBuffer}.
-   * @throws if the series has not been buffered to the GPU.
-   */
-  get glBuffer() {
-    if (this.gl.buffer == null) throw new Error("gl buffer not initialized");
-    return this.gl.prevBuffer !== this.writePos && console.warn("buffer not updated"), this.gl.buffer;
-  }
-  [Symbol.iterator]() {
-    if (this.dataType.isVariable) {
-      const t = new qt(this);
-      return this.dataType.equals(n.JSON) ? new W(t) : t;
-    }
-    return this.dataType.equals(n.UUID) ? new Pt(this) : new Ft(this);
-  }
-  /**
-   * Returns a slice of the series from start to end.
-   * @param start The start index (inclusive).
-   * @param end The end index (exclusive).
-   * @returns A new series containing the sliced data.
-   */
-  slice(t, e) {
-    return this.sliceSub(!1, t, e);
-  }
-  /**
-   * Returns a subarray view of the series from start to end.
-   * @param start The start index (inclusive).
-   * @param end The end index (exclusive).
-   * @returns A new series containing the subarray data.
-   */
-  sub(t, e) {
-    return this.sliceSub(!0, t, e);
-  }
-  /**
-   * Returns an iterator over a portion of the series.
-   * @param start The start index (inclusive).
-   * @param end The end index (exclusive).
-   * @returns An iterator over the specified range.
-   */
-  subIterator(t, e) {
-    return new D(this, t, e ?? this.length);
-  }
-  /**
-   * Returns an iterator over a portion of the series based on alignment.
-   * @param start The start alignment (inclusive).
-   * @param end The end alignment (exclusive).
-   * @returns An iterator over the specified alignment range.
-   */
-  subAlignmentIterator(t, e) {
-    const s = Math.ceil(
-      Number(t - this.alignment) / Number(this.alignmentMultiple)
-    ), i = Math.ceil(
-      Number(e - this.alignment) / Number(this.alignmentMultiple)
-    );
-    return new D(this, s, i);
-  }
-  subBytes(t, e) {
-    if (t >= 0 && (e == null || e >= this.byteLength.valueOf())) return this;
-    const s = this.data.subarray(t, e);
-    return new x({
-      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 x({
-      data: i,
-      dataType: this.dataType,
-      timeRange: this.timeRange,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: this.gl.bufferUsage,
-      alignment: this.alignment + BigInt(e)
-    });
-  }
-  /**
-   * Creates a new series with a different alignment.
-   * @param alignment The new alignment value.
-   * @returns A new series with the specified alignment.
-   */
-  reAlign(t) {
-    return new x({
-      data: this.buffer,
-      dataType: this.dataType,
-      timeRange: m.ZERO,
-      sampleOffset: this.sampleOffset,
-      glBufferUsage: "static",
-      alignment: t
-    });
-  }
-  /**
-   * Returns a string representation of the series.
-   * For series with more than 10 elements, shows the first 5 and last 5 elements.
-   * @returns A string representation of the series.
-   */
-  toString() {
-    let t = `Series(${this.dataType.toString()} ${this.length} [`;
-    if (this.length <= 10) t += Array.from(this).map((e) => e.toString());
-    else {
-      for (let e = 0; e < 5; e++)
-        t += `${this.at(e)?.toString()}`, t += ",";
-      t += "...,";
-      for (let e = -5; e < 0; e++)
-        t += this.at(e)?.toString(), e < -1 && (t += ",");
-    }
-    return t += "])", t;
-  }
-}
-const pt = (u) => u == null ? !1 : Array.isArray(u) || u instanceof ArrayBuffer || ArrayBuffer.isView(u) && !(u instanceof DataView) || u instanceof x ? !0 : it(u), lt = nt(ot, x);
-class D {
-  series;
-  end;
-  index;
-  constructor(t, e, s) {
-    this.series = t;
-    const i = L(0, t.length + 1);
-    this.end = X(i, s), this.index = X(i, e);
-  }
-  next() {
-    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
-  }
-}
-class qt {
-  series;
-  index;
-  decoder;
-  constructor(t) {
-    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] !== J; ) 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)) });
-  }
-}
-class W {
-  wrapped;
-  static schema = o.record(o.string(), o.unknown());
-  constructor(t) {
-    this.wrapped = t;
-  }
-  next() {
-    const t = this.wrapped.next();
-    return t.done === !0 ? { done: !0, value: void 0 } : {
-      done: !1,
-      value: k.decodeString(t.value, W.schema)
-    };
-  }
-}
-class Pt {
-  series;
-  index;
-  data;
-  density;
-  constructor(t) {
-    if (!t.dataType.equals(n.UUID))
-      throw new Error("cannot create a UUID series iterator for a non-UUID series");
-    this.series = t, this.index = 0, this.data = new Uint8Array(t.buffer), this.density = n.UUID.density.valueOf();
-  }
-  next() {
-    if (this.index >= this.series.length) return { done: !0, value: void 0 };
-    const t = j(this.data, this.index * this.density);
-    return this.index++, { done: !1, value: t };
-  }
-}
-class Ft {
-  series;
-  index;
-  constructor(t) {
-    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)
-    };
-  }
-}
-class Oe {
-  /** The array of series in this collection */
-  series;
-  /**
-   * The MultiSeries constructor accepts an optional array of Series instances. All series
-   * in the collection must have the same data type.
-   *
-   * @example
-   * // Create an empty MultiSeries
-   * const ms1 = new MultiSeries();
-   *
-   * @example
-   * // Create a MultiSeries from multiple numeric series
-   * const s1 = new Series(new Float32Array([1, 2, 3]));
-   * const s2 = new Series(new Float32Array([4, 5, 6]));
-   * const ms2 = new MultiSeries([s1, s2]);
-   *
-   * @example
-   * // Create a MultiSeries from string series
-   * const s3 = new Series(["apple", "banana"]);
-   * const s4 = new Series(["carrot", "date"]);
-   * const ms3 = new MultiSeries([s3, s4]);
-   *
-   * @example
-   * // Create a MultiSeries from JSON series
-   * const s5 = new Series([{ a: 1, b: "apple" }]);
-   * const s6 = new Series([{ a: 2, b: "banana" }]);
-   * const ms4 = new MultiSeries([s5, s6]);
-   *
-   * @example
-   * // Add series to an existing MultiSeries
-   * const ms5 = new MultiSeries();
-   * ms5.push(s1);
-   * ms5.push(s2);
-   *
-   * @example
-   * // Combine two MultiSeries
-   * const ms6 = new MultiSeries([s1]);
-   * const ms7 = new MultiSeries([s2]);
-   * ms6.push(ms7);
-   *
-   * @throws Error if attempting to add a series with a different data type
-   */
-  constructor(t = []) {
-    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 ut(t, this.dataType), this;
-  }
-  /**
-   * Returns the data type of the series in this collection. If the collection is empty,
-   * returns DataType.UNKNOWN.
-   */
-  get dataType() {
-    return this.series.length === 0 ? n.UNKNOWN : this.series[0].dataType;
-  }
-  /**
-   * Returns the combined time range of all series in the collection. If the collection
-   * is empty, returns TimeRange.ZERO. The time range spans from the start of the first
-   * series to the end of the last series.
-   */
-  get timeRange() {
-    return this.series.length === 0 ? m.ZERO : new m(
-      this.series[0].timeRange.start,
-      this.series[this.series.length - 1].timeRange.end
-    );
-  }
-  /**
-   * Returns the alignment of the first series in the collection. If the collection is
-   * empty, returns 0n.
-   */
-  get alignment() {
-    return this.series.length === 0 ? 0n : this.series[0].alignment;
-  }
-  /**
-   * Returns the alignment bounds of the entire collection. The lower bound is the
-   * alignment of the first series, and the upper bound is the alignment of the last
-   * series + its length. If the collection is empty, returns bounds.construct(0n, 0n).
-   */
-  get alignmentBounds() {
-    return this.series.length === 0 ? L(0n, 0n) : L(
-      this.series[0].alignmentBounds.lower,
-      this.series[this.series.length - 1].alignmentBounds.upper
-    );
-  }
-  push(t) {
-    const e = () => new Error(
-      `cannot push a ${t.dataType.toString()} series to a ${this.dataType.toString()} multi-series`
-    ), s = t.dataType.equals(this.dataType);
-    if (lt(t)) {
-      if (this.series.length !== 0 && !s) throw e();
-      this.series.push(t);
-    } else {
-      if (this.series.length !== 0 && t.series.length !== 0 && !s)
-        throw e();
-      this.series.push(...t.series);
-    }
-  }
-  /**
-   * Returns the total length of all series in the collection.
-   * @returns The sum of the lengths of all series.
-   */
-  get length() {
-    return this.series.reduce((t, e) => t + e.length, 0);
-  }
-  atAlignment(t, e) {
-    for (const s of this.series)
-      if ($(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}`);
-  }
-  /**
-   * Returns an iterator over a portion of the multi-series.
-   * @param start - The start index (inclusive).
-   * @param end - The end index (exclusive).
-   * @returns An iterator over the specified range.
-   */
-  subIterator(t, e) {
-    return new V(this, t, e ?? this.length);
-  }
-  /**
-   * Returns an iterator over a portion of the multi-series based on alignment.
-   * @param start - The start alignment (inclusive).
-   * @param end - The end alignment (exclusive).
-   * @returns An iterator over the specified alignment range.
-   */
-  subAlignmentIterator(t, e) {
-    if (t >= this.alignmentBounds.upper || e <= this.alignmentBounds.lower)
-      return H;
-    let s = 0;
-    for (let l = 0; l < this.series.length; l++) {
-      const h = this.series[l];
-      if (t < h.alignment) break;
-      if (t >= h.alignmentBounds.upper) s += h.length;
-      else if ($(h.alignmentBounds, t)) {
-        s += Math.ceil(
-          Number(t - h.alignment) / Number(h.alignmentMultiple)
-        );
-        break;
-      }
-    }
-    let i = 0;
-    for (let l = 0; l < this.series.length; l++) {
-      const h = this.series[l];
-      if (e < h.alignment) break;
-      if (e >= h.alignmentBounds.upper) i += h.length;
-      else if ($(h.alignmentBounds, e)) {
-        i += Math.ceil(
-          Number(e - h.alignment) / Number(h.alignmentMultiple)
-        );
-        break;
-      }
-    }
-    return new V(this, s, i);
-  }
-  /**
-   * Returns an iterator over the specified alignment range and span.
-   * @param start - The start alignment (inclusive).
-   * @param span - The number of samples to include.
-   * @returns An iterator over the specified range.
-   */
-  subAlignmentSpanIterator(t, e) {
-    if (t >= this.alignmentBounds.upper) return H;
-    e = Math.min(e, Number(this.distance(t, this.alignmentBounds.upper)));
-    let s = 0;
-    for (let i = 0; i < this.series.length; i++) {
-      const l = this.series[i];
-      if (t < l.alignment) break;
-      if (t >= l.alignmentBounds.upper) s += l.length;
-      else if ($(l.alignmentBounds, t)) {
-        s += Number(t - l.alignment);
-        break;
-      }
-    }
-    return new V(this, s, s + e);
-  }
-  /**
-   * Updates the WebGL buffer for all series in the collection.
-   * @param gl - The WebGL buffer controller to use.
-   */
-  updateGLBuffer(t) {
-    this.series.forEach((e) => e.updateGLBuffer(t));
-  }
-  /**
-   * Returns the bounds containing the minimum and maximum values across all series.
-   */
-  get bounds() {
-    return ht(this.series.map((t) => t.bounds));
-  }
-  /**
-   * Returns the sum of the byte lengths of all series.
-   */
-  get byteLength() {
-    return new c(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
-  }
-  /**
-   * Returns a combined typed array containing all data from all series.
-   * @returns A typed array containing all data from all series.
-   */
-  get data() {
-    const 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);
-  }
-  /**
-   * Traverses the alignment space by a given distance from a start point.
-   * @param start - The starting alignment.
-   * @param dist - The distance to traverse.
-   * @returns The resulting alignment after traversal.
-   */
-  traverseAlignment(t, e) {
-    const s = this.series.map((i) => i.alignmentBounds);
-    return dt(s, t, e);
-  }
-  /**
-   * Acquires a reference to the WebGL buffer for all series.
-   * @param gl - Optional WebGL buffer controller to use.
-   */
-  acquire(t) {
-    this.series.forEach((e) => e.acquire(t));
-  }
-  /**
-   * Releases the WebGL buffer reference for all series.
-   */
-  release() {
-    this.series.forEach((t) => t.release());
-  }
-  /**
-   * Calculates the number of samples between two alignments in the multi-series.
-   * @param start - The starting alignment.
-   * @param end - The ending alignment.
-   * @returns The distance between the alignments.
-   */
-  distance(t, e) {
-    const s = this.series.map((i) => i.alignmentBounds);
-    return gt(s, t, e);
-  }
-  /**
-   * Parses a JSON multi-series into an array of values using the provided zod schema.
-   * @template Z - The zod schema type.
-   * @param schema - The zod schema to use to parse the JSON series.
-   * @throws Error if the series does not have a data type of JSON.
-   * @returns An array of values parsed from the JSON series.
-   */
-  parseJSON(t) {
-    if (!this.dataType.equals(n.JSON))
-      throw new Error("cannot parse non-JSON series as JSON");
-    return this.series.flatMap((e) => e.parseJSON(t));
-  }
-  /**
-   * Returns an iterator over all values in the multi-series.
-   * @returns An iterator that yields all values from all series in sequence.
-   */
-  [Symbol.iterator]() {
-    return this.series.length === 0 ? {
-      next() {
-        return { done: !0, value: void 0 };
-      }
-    } : new Yt(this.series);
-  }
-  /**
-   * Returns an array of the values in the multi-series as strings.
-   * For variable length data types (like STRING or JSON), this decodes the underlying buffer.
-   * @returns An array of string representations of the multi-series values.
-   */
-  toStrings() {
-    return this.series.flatMap((t) => t.toStrings());
-  }
-}
-class Yt {
-  series;
-  seriesIndex;
-  internal;
-  constructor(t) {
-    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]() {
-    return this;
-  }
-}
-class V {
-  series;
-  index;
-  end;
-  constructor(t, e, s) {
-    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 z = (u) => {
-  const t = u >> 32n, e = u & 0xffffffffn;
-  return { domain: t, sample: e };
-};
-export {
-  Dt as A,
-  zt as B,
-  ge as C,
-  g as D,
-  Oe as M,
-  v as R,
-  x as S,
-  r as T,
-  a,
-  m as b,
-  n as c,
-  c as d,
-  it as e,
-  vt as f,
-  q as g,
-  ue as h,
-  pt as i,
-  le as j,
-  G as k,
-  Nt as l,
-  ie as m,
-  he as n,
-  te as o,
-  ee as p,
-  se as q,
-  ne as r,
-  _t as s,
-  de as t,
-  ae as u,
-  oe as v,
-  fe as w,
-  ce as x,
-  re as y,
-  st as z
-};