@synnaxlabs/x 0.41.0 → 0.42.0

package/dist/{series-D0zxMWxP.js → series-B9JERcqi.js}

@@ -1,80 +1,79 @@
 var rt = Object.defineProperty;
-var nt = (o, t, e) => t in o ? rt(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var s = (o, t, e) => nt(o, typeof t != "symbol" ? t + "" : t, e);
+var it = (o, t, e) => t in o ? rt(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var r = (o, t, e) => it(o, typeof t != "symbol" ? t + "" : t, e);
 import { z as l } from "zod";
-import { J as q } from "./index-C3QzbIwt.js";
-import { s as st } from "./index-DizUWH6z.js";
-import { n as it } from "./index-BVC_8Cg9.js";
-import { m as R, c as L, a as V, d as D, t as at, e as ut } from "./bounds-DQrjn60Q.js";
+import { J as q } from "./index-BywOGO8U.js";
+import { s as at } from "./index-DizUWH6z.js";
+import { n as ut } from "./index-QGplUHuy.js";
+import { m as C, c as L, a as J, d as D, e as ot, t as lt, f as ft } from "./bounds-Bn5_l4Z3.js";
 import "./box-Cc8IzcNo.js";
 import "./dimensions-CRgergMS.js";
 import "./base-DFq0vvGn.js";
 import "./location-C3aeu046.js";
-import "./scale-DQwBWnwc.js";
+import "./scale-DfJe9755.js";
 import "./xy-D_LqxaGt.js";
-let ot = (o, t = 21) => (e = t) => {
-  let r = "", a = e | 0;
-  for (; a--; )
-    r += o[Math.random() * o.length | 0];
-  return r;
+let ht = (o, t = 21) => (e = t) => {
+  let s = "", i = e | 0;
+  for (; i--; )
+    s += o[Math.random() * o.length | 0];
+  return s;
 };
-const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft = ot(lt, 11), Q = () => ft(), Ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const ct = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", dt = ht(ct, 11), tt = () => dt(), Lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  create: Q
-}, Symbol.toStringTag, { value: "Module" })), ct = l.enum(["static", "dynamic"]), _ = (o, t) => {
+  create: tt
+}, Symbol.toStringTag, { value: "Module" })), gt = l.enum(["static", "dynamic"]), et = (o, t) => {
   const e = new m(t);
   if (![
-    w.DAY,
-    w.HOUR,
-    w.MINUTE,
-    w.SECOND,
-    w.MILLISECOND,
-    w.MICROSECOND,
-    w.NANOSECOND
-  ].some((a) => a.equals(e)))
+    O.DAY,
+    O.HOUR,
+    O.MINUTE,
+    O.SECOND,
+    O.MILLISECOND,
+    O.MICROSECOND,
+    O.NANOSECOND
+  ].some((i) => i.equals(e)))
     throw new Error(
       "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
     );
-  const r = o.valueOf() % e.valueOf();
-  return o instanceof m ? new m(r) : new w(r);
-}, i = class i {
+  const s = o.valueOf() % e.valueOf();
+  return o instanceof m ? new m(s) : new O(s);
+}, a = class a {
   constructor(t, e = "UTC") {
-    s(this, "value");
-    s(this, "encodeValue", !0);
-    if (t == null) this.value = i.now().valueOf();
+    /** The underlying value for the time stamp */
+    r(this, "value");
+    /** Makes sure JSON encodes the value and not the class. */
+    r(this, "encodeValue", !0);
+    if (t == null) this.value = a.now().valueOf();
     else if (t instanceof Date)
-      this.value = BigInt(t.getTime()) * i.MILLISECOND.valueOf();
+      this.value = BigInt(t.getTime()) * a.MILLISECOND.valueOf();
     else if (typeof t == "string")
-      this.value = i.parseDateTimeString(t, e).valueOf();
-    else if (Array.isArray(t)) this.value = i.parseDate(t);
+      this.value = a.parseDateTimeString(t, e).valueOf();
+    else if (Array.isArray(t)) this.value = a.parseDate(t);
     else {
-      let r = BigInt(0);
-      t instanceof Number && (t = t.valueOf()), e === "local" && (r = i.utcOffset.valueOf()), typeof t == "number" && (isFinite(t) ? t = Math.trunc(t) : (isNaN(t) && (t = 0), t === 1 / 0 ? t = i.MAX : t = i.MIN)), this.value = BigInt(t.valueOf()) + r;
+      let s = BigInt(0);
+      t instanceof Number && (t = t.valueOf()), e === "local" && (s = a.utcOffset.valueOf()), typeof t == "number" && (isFinite(t) ? t = Math.trunc(t) : (isNaN(t) && (t = 0), t === 1 / 0 ? t = a.MAX : t = a.MIN)), this.value = BigInt(t.valueOf()) + s;
     }
   }
-  static parseDate([t = 1970, e = 1, r = 1]) {
-    const a = new Date(t, e - 1, r, 0, 0, 0, 0);
-    return new i(BigInt(a.getTime()) * i.MILLISECOND.valueOf()).truncate(i.DAY).valueOf();
-  }
-  encode() {
-    return this.value.toString();
+  static parseDate([t = 1970, e = 1, s = 1]) {
+    const i = new Date(t, e - 1, s, 0, 0, 0, 0);
+    return new a(BigInt(i.getTime()) * a.MILLISECOND.valueOf()).truncate(a.DAY).valueOf();
   }
   valueOf() {
     return this.value;
   }
   static parseTimeString(t, e = "UTC") {
-    const [r, a, c] = t.split(":");
-    let h = "00", v = "00";
-    c != null && ([h, v] = c.split("."));
-    let O = i.hours(parseInt(r ?? "00")).add(i.minutes(parseInt(a ?? "00"))).add(i.seconds(parseInt(h ?? "00"))).add(i.milliseconds(parseInt(v ?? "00")));
-    return e === "local" && (O = O.add(i.utcOffset)), O.valueOf();
+    const [s, i, h] = t.split(":");
+    let c = "00", v = "00";
+    h != null && ([c, v] = h.split("."));
+    let b = a.hours(parseInt(s ?? "00")).add(a.minutes(parseInt(i ?? "00"))).add(a.seconds(parseInt(c ?? "00"))).add(a.milliseconds(parseInt(v ?? "00")));
+    return e === "local" && (b = b.add(a.utcOffset)), b.valueOf();
   }
   static parseDateTimeString(t, e = "UTC") {
     if (!t.includes("/") && !t.includes("-"))
-      return i.parseTimeString(t, e);
-    const r = new Date(t);
-    return t.includes(":") || r.setUTCHours(0, 0, 0, 0), new i(
-      BigInt(r.getTime()) * i.MILLISECOND.valueOf(),
+      return a.parseTimeString(t, e);
+    const s = new Date(t);
+    return t.includes(":") || s.setUTCHours(0, 0, 0, 0), new a(
+      BigInt(s.getTime()) * a.MILLISECOND.valueOf(),
       e
     ).valueOf();
   }
@@ -99,19 +98,19 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
     }
   }
   toISOString(t = "UTC") {
-    return t === "UTC" ? this.date().toISOString() : this.sub(i.utcOffset).date().toISOString();
+    return t === "UTC" ? this.date().toISOString() : this.sub(a.utcOffset).date().toISOString();
   }
   timeString(t = !1, e = "UTC") {
-    const r = this.toISOString(e);
-    return t ? r.slice(11, 23) : r.slice(11, 19);
+    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" }), r = t.toLocaleString("default", { day: "numeric" });
-    return `${e} ${r}`;
+    const t = this.date(), e = t.toLocaleString("default", { month: "short" }), s = t.toLocaleString("default", { day: "numeric" });
+    return `${e} ${s}`;
   }
   static get utcOffset() {
-    return new w(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * i.MINUTE.valueOf()
+    return new O(
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * a.MINUTE.valueOf()
     );
   }
   /**
@@ -120,7 +119,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    * @param other - The other timestamp.
    */
   static since(t) {
-    return new i().span(t);
+    return new a().span(t);
   }
   /** @returns A JavaScript Date object representing the TimeStamp. */
   date() {
@@ -133,7 +132,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    * @returns True if the TimeStamps are equal, false otherwise.
    */
   equals(t) {
-    return this.valueOf() === new i(t).valueOf();
+    return this.valueOf() === new a(t).valueOf();
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -153,7 +152,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   valid, regardless of the TimeStamp order.
    */
   range(t) {
-    return new U(this, t).makeValid();
+    return new A(this, t).makeValid();
   }
   /**
    * Creates a TimeRange starting at the TimeStamp and spanning the given
@@ -182,7 +181,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   otherwise.
    */
   after(t) {
-    return this.valueOf() > new i(t).valueOf();
+    return this.valueOf() > new a(t).valueOf();
   }
   /**
    * Checks if the TimeStamp is after or equal to the given TimeStamp.
@@ -192,7 +191,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   false otherwise.
    */
   afterEq(t) {
-    return this.valueOf() >= new i(t).valueOf();
+    return this.valueOf() >= new a(t).valueOf();
   }
   /**
    * Checks if the TimeStamp is before the given TimeStamp.
@@ -202,7 +201,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   otherwise.
    */
   before(t) {
-    return this.valueOf() < new i(t).valueOf();
+    return this.valueOf() < new a(t).valueOf();
   }
   /**
    * Checks if TimeStamp is before or equal to the current timestamp.
@@ -212,7 +211,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   false otherwise.
    */
   beforeEq(t) {
-    return this.valueOf() <= new i(t).valueOf();
+    return this.valueOf() <= new a(t).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeStamp.
@@ -222,7 +221,7 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   TimeSpan.
    */
   add(t) {
-    return new i(this.valueOf() + BigInt(t.valueOf()));
+    return new a(this.valueOf() + BigInt(t.valueOf()));
   }
   /**
    * Subtracts a TimeSpan from the TimeStamp.
@@ -232,45 +231,49 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    *   TimeSpan.
    */
   sub(t) {
-    return new i(this.valueOf() - BigInt(t.valueOf()));
+    return new a(this.valueOf() - BigInt(t.valueOf()));
   }
   /**
    * @returns the floating point number of hours since the unix epoch to the timestamp
    * value.
    */
   get hours() {
-    return Number(this.valueOf()) / Number(w.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(O.HOUR.valueOf());
   }
   /**
    * @returns the floating point number of minutes since the unix epoch to the timestamp
    * value.
    */
   get minutes() {
-    return Number(this.valueOf()) / Number(w.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(O.MINUTE.valueOf());
   }
   /**
    * @returns the floating point number of days since the unix epoch to the timestamp
    * value.
    */
   get days() {
-    return Number(this.valueOf()) / Number(w.DAY.valueOf());
+    return Number(this.valueOf()) / Number(O.DAY.valueOf());
   }
   /**
    * @returns the floating point number of seconds since the unix epoch to the timestamp
    * value.
    */
   get seconds() {
-    return Number(this.valueOf()) / Number(w.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(O.SECOND.valueOf());
   }
-  /**
-   * @returns The number of milliseconds since the unix epoch.
-   */
+  /** @returns the floating point number of milliseconds since the unix epoch. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(i.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
   }
+  /** @returns the floating point number of microseconds since the unix epoch */
   get microseconds() {
-    return Number(this.valueOf()) / Number(i.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.MICROSECOND.valueOf());
   }
+  /**
+   * @returns the floating point number of nanoseconds since the unix epoch.
+   * Note that since we're converting to float64, this reduces the resolution
+   * to a quarter of a microsecond.
+   */
   get nanoseconds() {
     return Number(this.valueOf());
   }
@@ -278,63 +281,102 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
   get year() {
     return this.date().getFullYear();
   }
+  /**
+   * @returns a copy of the timestamp with the year changed.
+   * @param year the value to set the year to.
+   */
   setYear(t) {
     const e = this.date();
-    return e.setFullYear(t), new i(e);
+    return e.setFullYear(t), new a(e);
   }
   /** @returns the integer month that the timestamp corresponds to with its year. */
   get month() {
-    return this.date().getMonth();
+    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.setMonth(t), new i(e);
+    return e.setUTCMonth(t), new a(e);
   }
   /** @returns the integer day that the timestamp corresponds to within its month. */
   get day() {
-    return this.date().getDate();
+    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.setDate(t), new i(e);
+    return e.setUTCDate(t), new a(e);
   }
-  /** @returns the integer hour that the timestamp corresponds to within its day. */
+  /**
+   * @returns the integer hour that the timestamp corresponds to within its day.
+   */
   get hour() {
-    return this.date().getHours();
+    return this.date().getUTCHours();
   }
+  /**
+   * @returns a copy of the timestamp with the hour changed.
+   * @param hour the value to set the hour to.
+   */
   setHour(t) {
     const e = this.date();
-    return e.setHours(t), new i(e);
+    return e.setUTCHours(t), new a(e, "UTC");
   }
   /** @returns the integer minute that the timestamp corresponds to within its hour. */
   get minute() {
     return this.date().getMinutes();
   }
+  /**
+   * @returns a copy of the timestamp with the minute changed.
+   * @param minute the value to set the minute to.
+   */
   setMinute(t) {
     const e = this.date();
-    return e.setMinutes(t), new i(e);
+    return e.setUTCMinutes(t), new a(e);
   }
+  /**
+   * @returns the integer second that the timestamp corresponds to within its
+   * minute.
+   */
   get second() {
     return this.date().getSeconds();
   }
+  /**
+   * @returns a copy of the timestamp with the second changed.
+   * @param second the value to set the second to.
+   */
   setSecond(t) {
     const e = this.date();
-    return e.setSeconds(t), new i(e);
+    return e.setUTCSeconds(t), new a(e);
   }
+  /**
+   * @reutrns the integer millisecond that the timestamp corresponds to within
+   * its second.
+   */
   get millisecond() {
     return this.date().getMilliseconds();
   }
+  /**
+   * @returns a copy of the timestamp with the milliseconds changed.
+   * @param millisecond the value to set the millisecond to.
+   */
   setMillisecond(t) {
     const e = this.date();
-    return e.setMilliseconds(t), new i(e);
+    return e.setMilliseconds(t), new a(e);
   }
+  /** @returns the time stamp formatted as an ISO string. */
   toString() {
     return this.date().toISOString();
   }
   /**
    * @returns A new TimeStamp that is the remainder of the TimeStamp divided by the
    * given span. This is useful in cases where you want only part of a TimeStamp's value
-   * i.e. the hours, minutes, seconds, milliseconds, microseconds, and nanoseconds but
+   * 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
@@ -343,11 +385,11 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(t) {
-    return _(this, t);
+    return et(this, t);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(w.DAY).equals(i.now().truncate(w.DAY));
+    return this.truncate(O.DAY).equals(a.now().truncate(O.DAY));
   }
   truncate(t) {
     return this.sub(this.remainder(t));
@@ -358,76 +400,78 @@ const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ft
    * JavaScript can do).
    */
   static now() {
-    return new i(/* @__PURE__ */ new Date());
+    return new a(/* @__PURE__ */ new Date());
   }
+  /** @returns the maximum value of all the timestamps. */
   static max(...t) {
-    let e = i.MIN;
-    for (const r of t) {
-      const a = new i(r);
-      a.after(e) && (e = a);
+    let e = a.MIN;
+    for (const s of t) {
+      const i = new a(s);
+      i.after(e) && (e = i);
     }
     return e;
   }
+  /** @returns the minimum value of all the timestamps. */
   static min(...t) {
-    let e = i.MAX;
-    for (const r of t) {
-      const a = new i(r);
-      a.before(e) && (e = a);
+    let e = a.MAX;
+    for (const s of t) {
+      const i = new a(s);
+      i.before(e) && (e = i);
     }
     return e;
   }
   /** @returns a new TimeStamp n nanoseconds after the unix epoch */
-  static nanoseconds(t) {
-    return new i(t);
+  static nanoseconds(t, e = "UTC") {
+    return new a(t, e);
   }
   /** @returns a new TimeStamp n microseconds after the unix epoch */
-  static microseconds(t) {
-    return i.nanoseconds(t * 1e3);
+  static microseconds(t, e = "UTC") {
+    return a.nanoseconds(t * 1e3, e);
   }
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
-  static milliseconds(t) {
-    return i.microseconds(t * 1e3);
+  static milliseconds(t, e = "UTC") {
+    return a.microseconds(t * 1e3, e);
   }
   /** @returns a new TimeStamp n seconds after the unix epoch */
-  static seconds(t) {
-    return i.milliseconds(t * 1e3);
+  static seconds(t, e = "UTC") {
+    return a.milliseconds(t * 1e3, e);
   }
   /** @returns a new TimeStamp n minutes after the unix epoch */
-  static minutes(t) {
-    return i.seconds(t * 60);
+  static minutes(t, e = "UTC") {
+    return a.seconds(t * 60, e);
   }
   /** @returns a new TimeStamp n hours after the unix epoch */
-  static hours(t) {
-    return i.minutes(t * 60);
+  static hours(t, e = "UTC") {
+    return a.minutes(t * 60, e);
   }
   /** @returns a new TimeStamp n days after the unix epoch */
-  static days(t) {
-    return i.hours(t * 24);
+  static days(t, e = "UTC") {
+    return a.hours(t * 24, e);
   }
 };
-/* One nanosecond after the unix epoch */
-s(i, "NANOSECOND", i.nanoseconds(1)), /** One microsecond after the unix epoch */
-s(i, "MICROSECOND", i.microseconds(1)), /** One millisecond after the unix epoch */
-s(i, "MILLISECOND", i.milliseconds(1)), /** One second after the unix epoch */
-s(i, "SECOND", i.seconds(1)), /** One minute after the unix epoch */
-s(i, "MINUTE", i.minutes(1)), /** One hour after the unix epoch */
-s(i, "HOUR", i.hours(1)), /** One day after the unix epoch */
-s(i, "DAY", i.days(1)), /** The maximum possible value for a timestamp */
-s(i, "MAX", new i((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
-s(i, "MIN", new i(0)), /** The unix epoch */
-s(i, "ZERO", new i(0)), /** A zod schema for validating timestamps */
-s(i, "z", l.union([
-  l.object({ value: l.bigint() }).transform((t) => new i(t.value)),
-  l.string().transform((t) => new i(BigInt(t))),
-  l.instanceof(Number).transform((t) => new i(t)),
-  l.number().transform((t) => new i(t)),
-  l.instanceof(i)
+/** One nanosecond after the unix epoch */
+r(a, "NANOSECOND", a.nanoseconds(1)), /** One microsecond after the unix epoch */
+r(a, "MICROSECOND", a.microseconds(1)), /** One millisecond after the unix epoch */
+r(a, "MILLISECOND", a.milliseconds(1)), /** One second after the unix epoch */
+r(a, "SECOND", a.seconds(1)), /** One minute after the unix epoch */
+r(a, "MINUTE", a.minutes(1)), /** One hour after the unix epoch */
+r(a, "HOUR", a.hours(1)), /** One day after the unix epoch */
+r(a, "DAY", a.days(1)), /** The maximum possible value for a timestamp */
+r(a, "MAX", new a((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
+r(a, "MIN", new a(0)), /** The unix epoch */
+r(a, "ZERO", new a(0)), /** A zod schema for validating timestamps */
+r(a, "z", l.union([
+  l.object({ value: l.bigint() }).transform((t) => new a(t.value)),
+  l.string().transform((t) => new a(BigInt(t))),
+  l.instanceof(Number).transform((t) => new a(t)),
+  l.number().transform((t) => new a(t)),
+  l.instanceof(a)
 ]));
-let m = i;
+let m = a;
 const u = class u {
   constructor(t) {
-    s(this, "value");
-    s(this, "encodeValue", !0);
+    r(this, "value");
+    r(this, "encodeValue", !0);
     typeof t == "number" && (t = Math.trunc(t.valueOf())), this.value = BigInt(t.valueOf());
   }
   static fromSeconds(t) {
@@ -455,7 +499,7 @@ const u = class u {
     return this.valueOf() >= new u(t).valueOf();
   }
   remainder(t) {
-    return _(this, t);
+    return et(this, t);
   }
   truncate(t) {
     return new u(
@@ -463,9 +507,9 @@ const u = class u {
     );
   }
   toString() {
-    const t = this.truncate(u.DAY), e = this.truncate(u.HOUR), r = this.truncate(u.MINUTE), a = this.truncate(u.SECOND), c = this.truncate(u.MILLISECOND), h = this.truncate(u.MICROSECOND), v = this.truncate(u.NANOSECOND), O = t, T = e.sub(t), A = r.sub(e), f = a.sub(r), B = c.sub(a), S = h.sub(c), Z = v.sub(h);
+    const t = this.truncate(u.DAY), e = this.truncate(u.HOUR), s = this.truncate(u.MINUTE), i = this.truncate(u.SECOND), h = this.truncate(u.MILLISECOND), c = this.truncate(u.MICROSECOND), v = this.truncate(u.NANOSECOND), b = t, N = e.sub(t), B = s.sub(e), f = i.sub(s), U = h.sub(i), S = c.sub(h), V = v.sub(c);
     let E = "";
-    return O.isZero || (E += `${O.days}d `), T.isZero || (E += `${T.hours}h `), A.isZero || (E += `${A.minutes}m `), f.isZero || (E += `${f.seconds}s `), B.isZero || (E += `${B.milliseconds}ms `), S.isZero || (E += `${S.microseconds}µs `), Z.isZero || (E += `${Z.nanoseconds}ns`), E.trim();
+    return b.isZero || (E += `${b.days}d `), N.isZero || (E += `${N.hours}h `), B.isZero || (E += `${B.minutes}m `), f.isZero || (E += `${f.seconds}s `), U.isZero || (E += `${U.milliseconds}ms `), S.isZero || (E += `${S.microseconds}µs `), V.isZero || (E += `${V.nanoseconds}ns`), E.trim();
   }
   mult(t) {
     return new u(this.valueOf() * BigInt(t));
@@ -544,7 +588,7 @@ const u = class u {
    * @returns A TimeSpan representing the given number of microseconds.
    */
   static microseconds(t = 1) {
-    return u.nanoseconds(R(t, 1e3));
+    return u.nanoseconds(C(t, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
@@ -553,7 +597,7 @@ const u = class u {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static milliseconds(t = 1) {
-    return u.microseconds(R(t, 1e3));
+    return u.microseconds(C(t, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of seconds.
@@ -562,7 +606,7 @@ const u = class u {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static seconds(t = 1) {
-    return u.milliseconds(R(t, 1e3));
+    return u.milliseconds(C(t, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of minutes.
@@ -571,7 +615,7 @@ const u = class u {
    * @returns A TimeSpan representing the given number of minutes.
    */
   static minutes(t = 1) {
-    return u.seconds(R(t, 60));
+    return u.seconds(C(t, 60));
   }
   /**
    * Creates a TimeSpan representing the given number of hours.
@@ -580,7 +624,7 @@ const u = class u {
    * @returns A TimeSpan representing the given number of hours.
    */
   static hours(t) {
-    return u.minutes(R(t, 60));
+    return u.minutes(C(t, 60));
   }
   /**
    * Creates a TimeSpan representing the given number of days.
@@ -589,28 +633,28 @@ const u = class u {
    * @returns A TimeSpan representing the given number of days.
    */
   static days(t) {
-    return u.hours(R(t, 24));
+    return u.hours(C(t, 24));
   }
 };
 /** A nanosecond. */
-s(u, "NANOSECOND", u.nanoseconds(1)), /** A microsecond. */
-s(u, "MICROSECOND", u.microseconds(1)), /** A millisecond. */
-s(u, "MILLISECOND", u.milliseconds(1)), /** A second. */
-s(u, "SECOND", u.seconds(1)), /** A minute. */
-s(u, "MINUTE", u.minutes(1)), /** Represents an hour. */
-s(u, "HOUR", u.hours(1)), /** Represents a day. */
-s(u, "DAY", u.days(1)), /** The maximum possible value for a TimeSpan. */
-s(u, "MAX", new u((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-s(u, "MIN", new u(0)), /** The zero value for a TimeSpan. */
-s(u, "ZERO", new u(0)), /** A zod schema for validating and transforming timespans */
-s(u, "z", l.union([
+r(u, "NANOSECOND", u.nanoseconds(1)), /** A microsecond. */
+r(u, "MICROSECOND", u.microseconds(1)), /** A millisecond. */
+r(u, "MILLISECOND", u.milliseconds(1)), /** A second. */
+r(u, "SECOND", u.seconds(1)), /** A minute. */
+r(u, "MINUTE", u.minutes(1)), /** Represents an hour. */
+r(u, "HOUR", u.hours(1)), /** Represents a day. */
+r(u, "DAY", u.days(1)), /** The maximum possible value for a TimeSpan. */
+r(u, "MAX", new u((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
+r(u, "MIN", new u(0)), /** The zero value for a TimeSpan. */
+r(u, "ZERO", new u(0)), /** A zod schema for validating and transforming timespans */
+r(u, "z", l.union([
   l.object({ value: l.bigint() }).transform((t) => new u(t.value)),
   l.string().transform((t) => new u(BigInt(t))),
   l.instanceof(Number).transform((t) => new u(t)),
   l.number().transform((t) => new u(t)),
   l.instanceof(u)
 ]));
-let w = u;
+let O = u;
 const p = class p extends Number {
   constructor(t) {
     t instanceof Number ? super(t.valueOf()) : super(t);
@@ -629,7 +673,7 @@ const p = class p extends Number {
    * @returns A TimeSpan representing the period of the Rate.
    */
   get period() {
-    return w.seconds(1 / this.valueOf());
+    return O.seconds(1 / this.valueOf());
   }
   /**
    * Calculates the number of samples in the given TimeSpan at this rate.
@@ -638,7 +682,7 @@ const p = class p extends Number {
    * @returns The number of samples in the given TimeSpan at this rate.
    */
   sampleCount(t) {
-    return new w(t).seconds * this.valueOf();
+    return new O(t).seconds * this.valueOf();
   }
   /**
    * Calculates the number of bytes in the given TimeSpan at this rate.
@@ -657,7 +701,7 @@ const p = class p extends Number {
    * @returns A TimeSpan that corresponds to the given number of samples.
    */
   span(t) {
-    return w.seconds(t / this.valueOf());
+    return O.seconds(t / this.valueOf());
   }
   /**
    * Calculates a TimeSpan given the number of bytes at this rate.
@@ -689,13 +733,13 @@ const p = class p extends Number {
   }
 };
 /** A zod schema for validating and transforming rates */
-s(p, "z", l.union([
+r(p, "z", l.union([
   l.number().transform((t) => new p(t)),
   l.instanceof(Number).transform((t) => new p(t)),
   l.instanceof(p)
 ]));
 let $ = p;
-const b = class b extends Number {
+const w = class w extends Number {
   /**
    * Creates a Density representing the given number of bytes per value.
    *
@@ -710,23 +754,23 @@ const b = class b extends Number {
     return t.valueOf() / this.valueOf();
   }
   size(t) {
-    return new C(t * this.valueOf());
+    return new R(t * this.valueOf());
   }
 };
 /** Unknown/Invalid Density. */
-s(b, "UNKNOWN", new b(0)), /** 128 bits per value. */
-s(b, "BIT128", new b(16)), /** 64 bits per value. */
-s(b, "BIT64", new b(8)), /** 32 bits per value. */
-s(b, "BIT32", new b(4)), /** 16 bits per value. */
-s(b, "BIT16", new b(2)), /** 8 bits per value. */
-s(b, "BIT8", new b(1)), /** A zod schema for validating and transforming densities */
-s(b, "z", l.union([
-  l.number().transform((t) => new b(t)),
-  l.instanceof(Number).transform((t) => new b(t)),
-  l.instanceof(b)
+r(w, "UNKNOWN", new w(0)), /** 128 bits per value. */
+r(w, "BIT128", new w(16)), /** 64 bits per value. */
+r(w, "BIT64", new w(8)), /** 32 bits per value. */
+r(w, "BIT32", new w(4)), /** 16 bits per value. */
+r(w, "BIT16", new w(2)), /** 8 bits per value. */
+r(w, "BIT8", new w(1)), /** A zod schema for validating and transforming densities */
+r(w, "z", l.union([
+  l.number().transform((t) => new w(t)),
+  l.instanceof(Number).transform((t) => new w(t)),
+  l.instanceof(w)
 ]));
-let y = b;
-const N = class N {
+let y = w;
+const I = class I {
   /**
    * Creates a TimeRange from the given start and end TimeStamps.
    *
@@ -742,7 +786,7 @@ const N = class N {
      *
      * In most cases, operations should treat start as inclusive.
      */
-    s(this, "start");
+    r(this, "start");
     /**
      * The starting TimeStamp of the TimeRange.
      *
@@ -751,12 +795,12 @@ const N = class N {
      *
      * In most cases, operations should treat end as exclusive.
      */
-    s(this, "end");
+    r(this, "end");
     typeof t == "object" && "start" in t ? (this.start = new m(t.start), this.end = new m(t.end)) : (this.start = new m(t), this.end = new m(e));
   }
   /** @returns The TimeSpan occupied by the TimeRange. */
   get span() {
-    return new w(this.end.valueOf() - this.start.valueOf());
+    return new O(this.end.valueOf() - this.start.valueOf());
   }
   /**
    * Checks if the timestamp is valid i.e. the start is before the end.
@@ -794,7 +838,13 @@ const N = class N {
    * @returns A TimeRange with the start and end swapped.
    */
   swap() {
-    return new N(this.end, this.start);
+    return new I(this.end, this.start);
+  }
+  get numericBounds() {
+    return {
+      lower: Number(this.start.valueOf()),
+      upper: Number(this.end.valueOf())
+    };
   }
   /**
    * Checks if the TimeRange is equal to the given TimeRange.
@@ -802,8 +852,11 @@ const N = class N {
    * @param other - The TimeRange to compare to.
    * @returns True if the TimeRange is equal to the given TimeRange.
    */
-  equals(t) {
-    return this.start.equals(t.start) && this.end.equals(t.end);
+  equals(t, e = O.ZERO) {
+    if (e.isZero)
+      return this.start.equals(t.start) && this.end.equals(t.end);
+    let s = this.start.sub(t.start).valueOf(), i = this.end.sub(t.end).valueOf();
+    return s < 0 && (s = -s), i < 0 && (i = -i), s <= e.valueOf() && i <= e.valueOf();
   }
   toString() {
     return `${this.start.toString()} - ${this.end.toString()}`;
@@ -812,54 +865,64 @@ const N = class N {
     return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
   }
   /**
-   * Checks if if the two time ranges overlap. If the two time ranges are equal, returns
-   * true.  If the start of one range is equal to the end of the other, returns false.
-   * Just follow the rule [start, end) i.e. start is inclusive and end is exclusive.
+   * 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 = w.ZERO) {
+  overlapsWith(t, e = O.ZERO) {
     t = t.makeValid();
-    const r = this.makeValid();
+    const s = this.makeValid();
     if (this.equals(t)) return !0;
-    if (t.end.equals(r.start) || r.end.equals(t.start)) return !1;
-    const a = m.max(r.start, t.start), c = m.min(r.end, t.end);
-    return c.before(a) ? !1 : new w(c.sub(a)).greaterThanOrEqual(e);
-  }
-  roughlyEquals(t, e) {
-    let r = this.start.sub(t.start).valueOf(), a = this.end.sub(t.end).valueOf();
-    return r < 0 && (r = -r), a < 0 && (a = -a), r <= e.valueOf() && a <= e.valueOf();
+    if (t.end.equals(s.start) || s.end.equals(t.start)) return !1;
+    const i = m.max(s.start, t.start), h = m.min(s.end, t.end);
+    return h.before(i) ? !1 : new O(h.sub(i)).greaterThanOrEqual(e);
   }
   contains(t) {
-    return t instanceof N ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
+    return t instanceof I ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
   }
   boundBy(t) {
-    const e = new N(this.start, this.end);
+    const e = new I(this.start, this.end);
     return t.start.after(this.start) && (e.start = t.start), t.start.after(this.end) && (e.end = t.start), t.end.before(this.end) && (e.end = t.end), t.end.before(this.start) && (e.start = t.end), e;
   }
+  static max(...t) {
+    return new I(
+      m.min(...t.map((e) => e.start)),
+      m.max(...t.map((e) => e.end))
+    );
+  }
 };
 /** The maximum possible time range. */
-s(N, "MAX", new N(m.MIN, m.MAX)), /** The minimum possible time range. */
-s(N, "MIN", new N(m.MAX, m.MIN)), /** A zero time range. */
-s(N, "ZERO", new N(m.ZERO, m.ZERO)), /** A zod schema for validating and transforming time ranges */
-s(N, "z", l.union([
-  l.object({ start: m.z, end: m.z }).transform((t) => new N(t.start, t.end)),
-  l.instanceof(N)
+r(I, "MAX", new I(m.MIN, m.MAX)), /** The minimum possible time range. */
+r(I, "MIN", new I(m.MAX, m.MIN)), /** A time range whose start and end are both zero. */
+r(I, "ZERO", new I(m.ZERO, m.ZERO)), /** A zod schema for validating and transforming time ranges */
+r(I, "z", l.union([
+  l.object({ start: m.z, end: m.z }).transform((t) => new I(t.start, t.end)),
+  l.instanceof(I)
 ]));
-let U = N;
-const xt = (o, t) => o.start.before(t.start) ? -1 : o.start.after(t.start) ? 1 : o.end.before(t.end) ? -1 : o.end.after(t.end) ? 1 : 0, n = class n extends String {
+let A = I;
+const Dt = (o, t) => o.start.before(t.start) ? -1 : o.start.after(t.start) ? 1 : o.end.before(t.end) ? -1 : o.end.after(t.end) ? 1 : 0, n = class n {
   constructor(t) {
+    r(this, "value");
+    r(this, "encodeValue", !0);
     if (t instanceof n || typeof t == "string" || typeof t.valueOf() == "string") {
-      super(t.valueOf());
+      this.value = t.valueOf();
       return;
     }
     const e = n.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
     if (e != null) {
-      super(e.valueOf());
+      this.value = e.valueOf();
       return;
     }
-    throw super(n.UNKNOWN.valueOf()), new Error(`unable to find data type for ${t.toString()}`);
+    throw this.value = n.UNKNOWN.valueOf(), new Error(`unable to find data type for ${t.toString()}`);
+  }
+  valueOf() {
+    return this.value;
   }
   /**
    * @returns the TypedArray constructor for the DataType.
@@ -904,9 +967,11 @@ const xt = (o, t) => o.start.before(t.start) ? -1 : o.start.after(t.start) ? 1 :
     if (t == null) throw new Error(`unable to find density for ${this.valueOf()}`);
     return t;
   }
+  /** @returns ture if the data type is an unsigned numeric integer type */
   get isUnsigned() {
     return this.equals(n.UINT8) || this.equals(n.UINT16) || this.equals(n.UINT32) || this.equals(n.UINT64);
   }
+  /** @returns true if the data type is a signed numeric integer type */
   get isSigned() {
     return this.equals(n.INT8) || this.equals(n.INT16) || this.equals(n.INT32) || this.equals(n.INT64);
   }
@@ -918,15 +983,6 @@ const xt = (o, t) => o.start.before(t.start) ? -1 : o.start.after(t.start) ? 1 :
   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;
-  }
   toJSON() {
     return this.toString();
   }
@@ -935,24 +991,24 @@ const xt = (o, t) => o.start.before(t.start) ? -1 : o.start.after(t.start) ? 1 :
   }
 };
 /** Represents an Unknown/Invalid DataType. */
-s(n, "UNKNOWN", new n("unknown")), /** Represents a 64-bit floating point value. */
-s(n, "FLOAT64", new n("float64")), /** Represents a 32-bit floating point value. */
-s(n, "FLOAT32", new n("float32")), /** Represents a 64-bit signed integer value. */
-s(n, "INT64", new n("int64")), /** Represents a 32-bit signed integer value. */
-s(n, "INT32", new n("int32")), /** Represents a 16-bit signed integer value. */
-s(n, "INT16", new n("int16")), /** Represents a 8-bit signed integer value. */
-s(n, "INT8", new n("int8")), /** Represents a 64-bit unsigned integer value. */
-s(n, "UINT64", new n("uint64")), /** Represents a 32-bit unsigned integer value. */
-s(n, "UINT32", new n("uint32")), /** Represents a 16-bit unsigned integer value. */
-s(n, "UINT16", new n("uint16")), /** Represents a 8-bit unsigned integer value. */
-s(n, "UINT8", new n("uint8")), /** Represents a boolean value. Alias for UINT8. */
-s(n, "BOOLEAN", n.UINT8), /** Represents a 64-bit unix epoch. */
-s(n, "TIMESTAMP", new n("timestamp")), /** Represents a UUID data type */
-s(n, "UUID", new n("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
+r(n, "UNKNOWN", new n("unknown")), /** Represents a 64-bit floating point value. */
+r(n, "FLOAT64", new n("float64")), /** Represents a 32-bit floating point value. */
+r(n, "FLOAT32", new n("float32")), /** Represents a 64-bit signed integer value. */
+r(n, "INT64", new n("int64")), /** Represents a 32-bit signed integer value. */
+r(n, "INT32", new n("int32")), /** Represents a 16-bit signed integer value. */
+r(n, "INT16", new n("int16")), /** Represents a 8-bit signed integer value. */
+r(n, "INT8", new n("int8")), /** Represents a 64-bit unsigned integer value. */
+r(n, "UINT64", new n("uint64")), /** Represents a 32-bit unsigned integer value. */
+r(n, "UINT32", new n("uint32")), /** Represents a 16-bit unsigned integer value. */
+r(n, "UINT16", new n("uint16")), /** Represents a 8-bit unsigned integer value. */
+r(n, "UINT8", new n("uint8")), /** Represents a boolean value. Alias for UINT8. */
+r(n, "BOOLEAN", n.UINT8), /** Represents a 64-bit unix epoch. */
+r(n, "TIMESTAMP", new n("timestamp")), /** Represents a UUID data type */
+r(n, "UUID", new n("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
  * by a newline character. */
-s(n, "STRING", new n("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+r(n, "STRING", new n("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
  * newline character. */
-s(n, "JSON", new n("json")), s(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
+r(n, "JSON", new n("json")), r(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
   [n.UINT8.toString(), Uint8Array],
   [n.UINT16.toString(), Uint16Array],
   [n.UINT32.toString(), Uint32Array],
@@ -967,7 +1023,7 @@ s(n, "JSON", new n("json")), s(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map(
   [n.STRING.toString(), Uint8Array],
   [n.JSON.toString(), Uint8Array],
   [n.UUID.toString(), Uint8Array]
-])), s(n, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
+])), r(n, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
   [Uint8Array.name, n.UINT8],
   [Uint16Array.name, n.UINT16],
   [Uint32Array.name, n.UINT32],
@@ -978,7 +1034,7 @@ s(n, "JSON", new n("json")), s(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map(
   [Int16Array.name, n.INT16],
   [Int32Array.name, n.INT32],
   [BigInt64Array.name, n.INT64]
-])), s(n, "DENSITIES", /* @__PURE__ */ new Map([
+])), r(n, "DENSITIES", /* @__PURE__ */ new Map([
   [n.UINT8.toString(), y.BIT8],
   [n.UINT16.toString(), y.BIT16],
   [n.UINT32.toString(), y.BIT32],
@@ -994,7 +1050,7 @@ s(n, "JSON", new n("json")), s(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map(
   [n.JSON.toString(), y.UNKNOWN],
   [n.UUID.toString(), y.BIT128]
 ])), /** All the data types. */
-s(n, "ALL", [
+r(n, "ALL", [
   n.UNKNOWN,
   n.FLOAT64,
   n.FLOAT32,
@@ -1010,8 +1066,8 @@ s(n, "ALL", [
   n.UUID,
   n.STRING,
   n.JSON
-]), s(n, "BIG_INT_TYPES", [n.INT64, n.UINT64, n.TIMESTAMP]), /** A zod schema for a DataType. */
-s(n, "z", l.union([
+]), r(n, "BIG_INT_TYPES", [n.INT64, n.UINT64, n.TIMESTAMP]), /** A zod schema for a DataType. */
+r(n, "z", l.union([
   l.string().transform((t) => new n(t)),
   l.instanceof(n)
 ]));
@@ -1024,7 +1080,7 @@ const d = class d extends Number {
   largerThan(t) {
     return this.valueOf() > t.valueOf();
   }
-  /** @returns true if the Size is smaller than the other sisze. */
+  /** @returns true if the Size is smaller than the other size. */
   smallerThan(t) {
     return this.valueOf() < t.valueOf();
   }
@@ -1053,9 +1109,9 @@ const d = class d extends Number {
     return this.valueOf() / d.TERABYTE.valueOf();
   }
   toString() {
-    const t = this.truncate(d.TERABYTE), e = this.truncate(d.GIGABYTE), r = this.truncate(d.MEGABYTE), a = this.truncate(d.KILOBYTE), c = this.truncate(d.BYTE), h = t, v = e.sub(t), O = r.sub(e), T = a.sub(r), A = c.sub(a);
+    const t = this.truncate(d.TERABYTE), e = this.truncate(d.GIGABYTE), s = this.truncate(d.MEGABYTE), i = this.truncate(d.KILOBYTE), h = this.truncate(d.BYTE), c = t, v = e.sub(t), b = s.sub(e), N = i.sub(s), B = h.sub(i);
     let f = "";
-    return h.isZero || (f += `${h.terabytes}TB `), v.isZero || (f += `${v.gigabytes}GB `), O.isZero || (f += `${O.megabytes}MB `), T.isZero || (f += `${T.kilobytes}KB `), (!A.isZero || f === "") && (f += `${A.valueOf()}B`), f.trim();
+    return c.isZero || (f += `${c.terabytes}TB `), v.isZero || (f += `${v.gigabytes}GB `), b.isZero || (f += `${b.megabytes}MB `), N.isZero || (f += `${N.kilobytes}KB `), (!B.isZero || f === "") && (f += `${B.valueOf()}B`), f.trim();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -1107,18 +1163,18 @@ const d = class d extends Number {
   }
 };
 /** A single byte */
-s(d, "BYTE", new d(1)), /** A kilobyte */
-s(d, "KILOBYTE", d.kilobytes(1)), /** A megabyte */
-s(d, "MEGABYTE", d.megabytes(1)), /** A gigabyte */
-s(d, "GIGABYTE", d.gigabytes(1)), /** A terabyte. */
-s(d, "TERABYTE", d.terabytes(1)), /** The zero value for Size */
-s(d, "ZERO", new d(0)), /** A zod schema for a Size. */
-s(d, "z", l.union([
+r(d, "BYTE", new d(1)), /** A kilobyte */
+r(d, "KILOBYTE", d.kilobytes(1)), /** A megabyte */
+r(d, "MEGABYTE", d.megabytes(1)), /** A gigabyte */
+r(d, "GIGABYTE", d.gigabytes(1)), /** A terabyte. */
+r(d, "TERABYTE", d.terabytes(1)), /** The zero value for Size */
+r(d, "ZERO", new d(0)), /** A zod schema for a Size. */
+r(d, "z", l.union([
   l.number().transform((t) => new d(t)),
   l.instanceof(d)
 ]));
-let C = d;
-const Lt = l.union([
+let R = d;
+const qt = l.union([
   l.instanceof(Uint8Array),
   l.instanceof(Uint16Array),
   l.instanceof(Uint32Array),
@@ -1129,84 +1185,84 @@ const Lt = l.union([
   l.instanceof(Int16Array),
   l.instanceof(Int32Array),
   l.instanceof(BigInt64Array)
-]), tt = (o) => {
+]), st = (o) => {
   const t = typeof o;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || o instanceof m || o instanceof w || o instanceof Date;
-}, ht = (o, t, e, r = 0) => o.usesBigInt && !t.usesBigInt ? Number(e) - Number(r) : !o.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(r.valueOf()) : x(e, -r).valueOf(), x = (o, t) => typeof o == "bigint" && typeof t == "bigint" || typeof o == "number" && typeof t == "number" ? o + t : t === 0 ? o : o === 0 ? t : Number(o) + Number(t), dt = (o) => o == null ? !1 : Array.isArray(o) || o instanceof ArrayBuffer || ArrayBuffer.isView(o) && !(o instanceof DataView) || o instanceof k ? !0 : tt(o), M = -1, F = {
-  [Symbol.iterator]: () => F,
+  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || o instanceof m || o instanceof O || o instanceof Date;
+}, mt = (o, t, e, s = 0) => o.usesBigInt && !t.usesBigInt ? Number(e) - Number(s) : !o.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(s.valueOf()) : x(e, -s).valueOf(), x = (o, t) => t == 0 ? o : o == 0 ? t : typeof o == "bigint" && typeof t == "bigint" || typeof o == "number" && typeof t == "number" ? o + t : Number(o) + Number(t), Ot = (o) => o == null ? !1 : Array.isArray(o) || o instanceof ArrayBuffer || ArrayBuffer.isView(o) && !(o instanceof DataView) || o instanceof k ? !0 : st(o), M = -1, Y = {
+  [Symbol.iterator]: () => Y,
   next: () => ({ done: !0, value: void 0 })
-}, gt = l.string().transform(
+}, bt = l.string().transform(
   (o) => new Uint8Array(
     atob(o).split("").map((t) => t.charCodeAt(0))
   ).buffer
-), mt = l.union([l.null(), l.undefined()]).transform(() => new Uint8Array().buffer), Y = 10, et = (o, t) => {
+), wt = l.union([l.null(), l.undefined()]).transform(() => new Uint8Array().buffer), Z = 10, nt = (o, t) => {
   if (o === "string" && !t.isVariable)
     throw new Error(`cannot convert series of type ${t.toString()} to string`);
   if (o === "number" && !t.isNumeric)
     throw new Error(`cannot convert series of type ${t.toString()} to number`);
   if (o === "bigint" && !t.usesBigInt)
     throw new Error(`cannot convert series of type ${t.toString()} to bigint`);
-}, I = class I {
+}, T = class T {
   constructor(t) {
-    s(this, "key", "");
-    s(this, "isSynnaxSeries", !0);
+    r(this, "key", "");
+    r(this, "isSynnaxSeries", !0);
     /** The data type of the array */
-    s(this, "dataType");
+    r(this, "dataType");
     /**
      * A sample offset that can be used to shift the values of all samples upwards or
      * downwards. Typically used to convert arrays to lower precision while preserving
      * the relative range of actual values.
      */
-    s(this, "sampleOffset");
+    r(this, "sampleOffset");
     /**
      * Stores information about the buffer state of this array into a WebGL buffer.
      */
-    s(this, "gl");
+    r(this, "gl");
     /** The underlying data. */
-    s(this, "_data");
-    s(this, "_timeRange");
-    s(this, "alignment", 0n);
+    r(this, "_data");
+    r(this, "timeRange", A.ZERO);
+    r(this, "alignment", 0n);
     /** A cached minimum value. */
-    s(this, "_cachedMin");
+    r(this, "_cachedMin");
     /** A cached maximum value. */
-    s(this, "_cachedMax");
+    r(this, "_cachedMax");
     /** The write position of the buffer. */
-    s(this, "writePos", M);
+    r(this, "writePos", M);
     /** Tracks the number of entities currently using this array. */
-    s(this, "_refCount", 0);
+    r(this, "_refCount", 0);
     /** Caches the length of the array for variable length data types. */
-    s(this, "_cachedLength");
+    r(this, "_cachedLength");
     /** Caches the indexes of the array for variable length data types. */
-    s(this, "_cachedIndexes");
-    dt(t) && (t = { data: t });
+    r(this, "_cachedIndexes");
+    Ot(t) && (t = { data: t });
     const {
       dataType: e,
-      timeRange: r,
-      sampleOffset: a = 0,
-      glBufferUsage: c = "static",
-      alignment: h = 0n,
-      key: v = Q()
-    } = t, O = t.data ?? [];
-    if (O instanceof I || typeof O == "object" && "isSynnaxSeries" in O && O.isSynnaxSeries === !0) {
-      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._cachedMin = f._cachedMin, this._cachedMax = f._cachedMax, this.writePos = f.writePos, this._refCount = f._refCount, this._cachedLength = f._cachedLength;
+      timeRange: s,
+      sampleOffset: i = 0,
+      glBufferUsage: h = "static",
+      alignment: c = 0n,
+      key: v = tt()
+    } = t, b = t.data ?? [];
+    if (b instanceof T || typeof b == "object" && "isSynnaxSeries" in b && b.isSynnaxSeries === !0) {
+      const f = b;
+      this.key = f.key, this.dataType = f.dataType, this.sampleOffset = f.sampleOffset, this.gl = f.gl, this._data = f._data, this.timeRange = f.timeRange, this.alignment = f.alignment, this._cachedMin = f._cachedMin, this._cachedMax = f._cachedMax, this.writePos = f.writePos, this._refCount = f._refCount, this._cachedLength = f._cachedLength;
       return;
     }
-    const T = tt(O), A = Array.isArray(O);
+    const N = st(b), B = Array.isArray(b);
     if (e != null) this.dataType = new g(e);
     else {
-      if (O instanceof ArrayBuffer)
+      if (b instanceof ArrayBuffer)
         throw new Error(
           "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
         );
-      if (A || T) {
-        let f = O;
-        if (!T) {
-          if (O.length === 0)
+      if (B || N) {
+        let f = b;
+        if (!N) {
+          if (b.length === 0)
             throw new Error(
               "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
             );
-          f = O[0];
+          f = b[0];
         }
         if (typeof f == "string") this.dataType = g.STRING;
         else if (typeof f == "number") this.dataType = g.FLOAT64;
@@ -1219,74 +1275,75 @@ const Lt = l.union([
           throw new Error(
             `cannot infer data type of ${typeof f} when constructing a Series from a JS array`
           );
-      } else this.dataType = new g(O);
+      } else this.dataType = new g(b);
     }
-    if (!A && !T) this._data = O;
+    if (!B && !N) this._data = b;
     else {
-      let f = T ? [O] : O;
-      const B = f[0];
-      (B instanceof m || B instanceof Date || B instanceof w) && (f = f.map((S) => new m(S).valueOf())), this.dataType.equals(g.STRING) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(`${f.join(`
+      let f = N ? [b] : b;
+      const U = f[0];
+      (U instanceof m || U instanceof Date || U instanceof O) && (f = f.map((S) => new m(S).valueOf())), this.dataType.equals(g.STRING) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(`${f.join(`
 `)}
 `).buffer) : this.dataType.equals(g.JSON) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(
         `${f.map((S) => q.encodeString(S)).join(`
 `)}
 `
-      ).buffer) : this.dataType.usesBigInt && typeof B == "number" ? this._data = new this.dataType.Array(
+      ).buffer) : this.dataType.usesBigInt && typeof U == "number" ? this._data = new this.dataType.Array(
         f.map((S) => BigInt(Math.round(S)))
-      ).buffer : !this.dataType.usesBigInt && typeof B == "bigint" ? this._data = new this.dataType.Array(
+      ).buffer : !this.dataType.usesBigInt && typeof U == "bigint" ? this._data = new this.dataType.Array(
         f.map((S) => Number(S))
       ).buffer : this._data = new this.dataType.Array(f).buffer;
     }
-    this.key = v, this.alignment = h, this.sampleOffset = a ?? 0, this._timeRange = r, this.gl = {
+    this.key = v, this.alignment = c, this.sampleOffset = i ?? 0, this.timeRange = s ?? A.ZERO, this.gl = {
       control: null,
       buffer: null,
       prevBuffer: 0,
-      bufferUsage: c
+      bufferUsage: h
     };
   }
-  static alloc({ capacity: t, dataType: e, ...r }) {
+  static alloc({ capacity: t, dataType: e, ...s }) {
     if (t === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
-    const a = new new g(e).Array(t), c = new I({
-      data: a.buffer,
+    const i = new new g(e).Array(t), h = new T({
+      data: i.buffer,
       dataType: e,
-      ...r
+      ...s
     });
-    return c.writePos = 0, c;
+    return h.writePos = 0, h;
   }
-  static createTimestamps(t, e, r) {
-    const a = r.spanRange(e.span(t)), c = new BigInt64Array(t);
-    for (let h = 0; h < t; h++)
-      c[h] = BigInt(r.add(e.span(h)).valueOf());
-    return new I({ data: c, dataType: g.TIMESTAMP, timeRange: a });
+  static createTimestamps(t, e, s) {
+    const i = s.spanRange(e.span(t)), h = new BigInt64Array(t);
+    for (let c = 0; c < t; c++)
+      h[c] = BigInt(s.add(e.span(c)).valueOf());
+    return new T({ data: h, dataType: g.TIMESTAMP, timeRange: i });
   }
   get refCount() {
     return this._refCount;
   }
   static fromStrings(t, e) {
-    const r = new TextEncoder().encode(
+    const s = new TextEncoder().encode(
       `${t.join(`
 `)}
 `
     );
-    return new I({ data: r, dataType: g.STRING, timeRange: e });
+    return new T({ data: s, dataType: g.STRING, timeRange: e });
   }
   static fromJSON(t, e) {
-    const r = new TextEncoder().encode(
-      `${t.map((a) => q.encodeString(a)).join(`
+    const s = new TextEncoder().encode(
+      `${t.map((i) => q.encodeString(i)).join(`
 `)}
 `
     );
-    return new I({ data: r, dataType: g.JSON, timeRange: e });
+    return new T({ data: s, dataType: g.JSON, timeRange: e });
   }
   acquire(t) {
     this._refCount++, t != null && this.updateGLBuffer(t);
   }
   release() {
-    if (this._refCount--, this._refCount === 0 && this.gl.control != null)
-      this.maybeGarbageCollectGLBuffer(this.gl.control);
-    else if (this._refCount < 0)
-      throw new Error("cannot release an array with a negative reference count");
+    if (this._refCount <= 0) {
+      console.warn("attempted to release a series with a negative reference count");
+      return;
+    }
+    this._refCount--, this._refCount === 0 && this.gl.control != null && this.maybeGarbageCollectGLBuffer(this.gl.control);
   }
   /**
    * Writes the given series to this series. If the series being written exceeds the
@@ -1303,13 +1360,13 @@ const Lt = l.union([
   }
   writeVariable(t) {
     if (this.writePos === M) return 0;
-    const e = this.byteCapacity.valueOf() - this.writePos, r = t.subBytes(0, e);
-    return this.writeToUnderlyingData(r), this.writePos += r.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += r.length, this.calculateCachedLength()), r.length;
+    const e = this.byteCapacity.valueOf() - this.writePos, s = t.subBytes(0, e);
+    return this.writeToUnderlyingData(s), this.writePos += s.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += s.length, this.calculateCachedLength()), s.length;
   }
   writeFixed(t) {
     if (this.writePos === M) return 0;
-    const e = this.capacity - this.writePos, r = t.sub(0, e);
-    return this.writeToUnderlyingData(r), this._cachedLength = void 0, this.maybeRecomputeMinMax(r), this.writePos += r.length, r.length;
+    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(
@@ -1338,12 +1395,12 @@ const Lt = l.union([
     if (!this.dataType.equals(g.UUID))
       throw new Error("cannot convert non-uuid series to uuids");
     const t = g.UUID.density.valueOf(), e = Array(this.length);
-    for (let r = 0; r < this.length; r++) {
-      const a = this.underlyingData.slice(r * t, (r + 1) * t), c = Array.from(
-        new Uint8Array(a.buffer),
-        (h) => h.toString(16).padStart(2, "0")
+    for (let s = 0; s < this.length; s++) {
+      const i = this.underlyingData.slice(s * t, (s + 1) * t), h = Array.from(
+        new Uint8Array(i.buffer),
+        (c) => c.toString(16).padStart(2, "0")
       ).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-      e[r] = c;
+      e[s] = h;
     }
     return e;
   }
@@ -1353,14 +1410,9 @@ const Lt = l.union([
     return new TextDecoder().decode(this.underlyingData).split(`
 `).slice(0, -1).map((e) => t.parse(q.decodeString(e)));
   }
-  /** @returns the time range of this array. */
-  get timeRange() {
-    if (this._timeRange == null) throw new Error("time range not set on series");
-    return this._timeRange;
-  }
   /** @returns the capacity of the series in bytes. */
   get byteCapacity() {
-    return new C(this.underlyingData.byteLength);
+    return new R(this.underlyingData.byteLength);
   }
   /** @returns the capacity of the series in samples. */
   get capacity() {
@@ -1368,7 +1420,7 @@ const Lt = l.union([
   }
   /** @returns the length of the series in bytes. */
   get byteLength() {
-    return this.writePos === M ? this.byteCapacity : this.dataType.isVariable ? new C(this.writePos) : this.dataType.density.size(this.writePos);
+    return this.writePos === M ? this.byteCapacity : this.dataType.isVariable ? new R(this.writePos) : this.dataType.density.size(this.writePos);
   }
   /** @returns the number of samples in this array. */
   get length() {
@@ -1379,8 +1431,8 @@ const Lt = l.union([
       throw new Error("cannot calculate length of a non-variable length data type");
     let t = 0;
     const e = [0];
-    return this.data.forEach((r, a) => {
-      r === Y && (t++, e.push(a + 1));
+    return this.data.forEach((s, i) => {
+      s === Z && (t++, e.push(i + 1));
     }), this._cachedIndexes = e, this._cachedLength = t, t;
   }
   /**
@@ -1394,13 +1446,13 @@ const Lt = l.union([
    */
   convert(t, e = 0) {
     if (this.dataType.equals(t)) return this;
-    const r = new t.Array(this.length);
-    for (let a = 0; a < this.length; a++)
-      r[a] = ht(this.dataType, t, this.data[a], e);
-    return new I({
-      data: r.buffer,
+    const s = new t.Array(this.length);
+    for (let i = 0; i < this.length; i++)
+      s[i] = mt(this.dataType, t, this.data[i], e);
+    return new T({
+      data: s.buffer,
       dataType: t,
-      timeRange: this._timeRange,
+      timeRange: this.timeRange,
       sampleOffset: e,
       glBufferUsage: this.gl.bufferUsage,
       alignment: this.alignment
@@ -1412,10 +1464,10 @@ const Lt = l.union([
       this._cachedMax = this.data[this.data.length - 1];
     else if (this.dataType.usesBigInt) {
       const t = this.data;
-      this._cachedMax = t.reduce((e, r) => e > r ? e : r);
+      this._cachedMax = t.reduce((e, s) => e > s ? e : s);
     } else {
       const t = this.data;
-      this._cachedMax = t.reduce((e, r) => e > r ? e : r);
+      this._cachedMax = t.reduce((e, s) => e > s ? e : s);
     }
     return this._cachedMax;
   }
@@ -1430,10 +1482,10 @@ const Lt = l.union([
     if (this.dataType.equals(g.TIMESTAMP)) this._cachedMin = this.data[0];
     else if (this.dataType.usesBigInt) {
       const t = this.data;
-      this._cachedMin = t.reduce((e, r) => e < r ? e : r);
+      this._cachedMin = t.reduce((e, s) => e < s ? e : s);
     } else {
       const t = this.data;
-      this._cachedMin = t.reduce((e, r) => e < r ? e : r);
+      this._cachedMin = t.reduce((e, s) => e < s ? e : s);
     }
     return this._cachedMin;
   }
@@ -1464,44 +1516,44 @@ const Lt = l.union([
     return x(this.max, -this.min);
   }
   atAlignment(t, e) {
-    const r = Number(t - this.alignment);
-    if (r < 0 || r >= this.length) {
-      if (e === !0) throw new Error(`[series] - no value at index ${r}`);
+    const s = Number(t - this.alignment);
+    if (s < 0 || s >= this.length) {
+      if (e === !0) throw new Error(`[series] - no value at index ${s}`);
       return;
     }
-    return this.at(r, e);
+    return this.at(s, e);
   }
   at(t, e) {
     if (this.dataType.isVariable) return this.atVariable(t, e ?? !1);
     t < 0 && (t = this.length + t);
-    const r = this.data[t];
-    if (r == null) {
+    const s = this.data[t];
+    if (s == null) {
       if (e === !0) throw new Error(`[series] - no value at index ${t}`);
       return;
     }
-    return x(r, this.sampleOffset);
+    return x(s, this.sampleOffset);
   }
   atVariable(t, e) {
-    let r = 0, a = 0;
+    let s = 0, i = 0;
     if (this._cachedIndexes != null)
-      r = this._cachedIndexes[t], a = this._cachedIndexes[t + 1] - 1;
+      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] === Y) {
+      for (let c = 0; c < this.data.length; c++)
+        if (this.data[c] === Z) {
           if (t === 0) {
-            a = h;
+            i = c;
             break;
           }
-          r = h + 1, t--;
+          s = c + 1, t--;
         }
-      if (a === 0 && (a = this.data.length), r >= a || t > 0) {
+      if (i === 0 && (i = this.data.length), s >= i || t > 0) {
         if (e) throw new Error(`[series] - no value at index ${t}`);
         return;
       }
     }
-    const c = this.data.slice(r, a);
-    return this.dataType.equals(g.STRING) ? new TextDecoder().decode(c) : st(JSON.parse(new TextDecoder().decode(c)));
+    const h = this.data.slice(s, i);
+    return this.dataType.equals(g.STRING) ? new TextDecoder().decode(h) : at(JSON.parse(new TextDecoder().decode(h)));
   }
   /**
    * @returns the index of the first sample that is greater than or equal to the given value.
@@ -1509,33 +1561,33 @@ const Lt = l.union([
    * @param value the value to search for.
    */
   binarySearch(t) {
-    let e = 0, r = this.length - 1;
-    const a = it(t);
-    for (; e <= r; ) {
-      const c = Math.floor((e + r) / 2), h = a(this.at(c, !0), t);
-      if (h === 0) return c;
-      h < 0 ? e = c + 1 : r = c - 1;
+    let e = 0, s = this.length - 1;
+    const i = ut(t);
+    for (; e <= s; ) {
+      const h = Math.floor((e + s) / 2), c = i(this.at(h, !0), t);
+      if (c === 0) return h;
+      c < 0 ? e = h + 1 : s = h - 1;
     }
     return e;
   }
   updateGLBuffer(t) {
     if (this.gl.control = t, !this.dataType.equals(g.FLOAT32) && !this.dataType.equals(g.UINT8))
       throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
-    const { buffer: e, bufferUsage: r, prevBuffer: a } = this.gl;
-    if (e == null && (this.gl.buffer = t.createBuffer()), this.writePos !== a)
+    const { buffer: e, bufferUsage: s, prevBuffer: i } = this.gl;
+    if (e == null && (this.gl.buffer = t.createBuffer()), this.writePos !== i)
       if (t.bindBuffer(t.ARRAY_BUFFER, this.gl.buffer), this.writePos !== M) {
-        a === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
-        const c = this.dataType.density.size(a).valueOf(), h = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        t.bufferSubData(t.ARRAY_BUFFER, c, h.buffer), this.gl.prevBuffer = this.writePos;
+        i === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
+        const h = this.dataType.density.size(i).valueOf(), c = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
+        t.bufferSubData(t.ARRAY_BUFFER, h, c.buffer), this.gl.prevBuffer = this.writePos;
       } else
         t.bufferData(
           t.ARRAY_BUFFER,
           this.buffer,
-          r === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
+          s === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
         ), this.gl.prevBuffer = M;
   }
   as(t) {
-    return et(t, this.dataType), this;
+    return nt(t, this.dataType), this;
   }
   get digest() {
     var t;
@@ -1544,10 +1596,10 @@ const Lt = l.union([
       dataType: this.dataType.toString(),
       sampleOffset: this.sampleOffset,
       alignment: {
-        lower: J(this.alignmentBounds.lower),
-        upper: J(this.alignmentBounds.upper)
+        lower: H(this.alignmentBounds.lower),
+        upper: H(this.alignmentBounds.upper)
       },
-      timeRange: (t = this._timeRange) == null ? void 0 : t.toString(),
+      timeRange: (t = this.timeRange) == null ? void 0 : t.toString(),
       length: this.length,
       capacity: this.capacity
     };
@@ -1572,10 +1624,10 @@ const Lt = l.union([
   }
   [Symbol.iterator]() {
     if (this.dataType.isVariable) {
-      const t = new Ot(this);
-      return this.dataType.equals(g.JSON) ? new wt(t) : t;
+      const t = new yt(this);
+      return this.dataType.equals(g.JSON) ? new G(t) : t;
     }
-    return new bt(this);
+    return new It(this);
   }
   slice(t, e) {
     return this.sliceSub(!1, t, e);
@@ -1584,10 +1636,10 @@ const Lt = l.union([
     return this.sliceSub(!0, t, e);
   }
   subIterator(t, e) {
-    return new G(this, t, e ?? this.length);
+    return new W(this, t, e ?? this.length);
   }
   subAlignmentIterator(t, e) {
-    return new G(
+    return new W(
       this,
       Number(t - this.alignment),
       Number(e - this.alignment)
@@ -1595,60 +1647,73 @@ const Lt = l.union([
   }
   subBytes(t, e) {
     if (t >= 0 && (e == null || e >= this.byteLength.valueOf())) return this;
-    const r = this.data.subarray(t, e);
-    return new I({
-      data: r,
+    const s = this.data.subarray(t, e);
+    return new T({
+      data: s,
       dataType: this.dataType,
-      timeRange: this._timeRange,
+      timeRange: this.timeRange,
       sampleOffset: this.sampleOffset,
       glBufferUsage: this.gl.bufferUsage,
       alignment: this.alignment + BigInt(t)
     });
   }
-  sliceSub(t, e, r) {
-    if (e <= 0 && (r == null || r >= this.length)) return this;
-    let a;
-    return t ? a = this.data.subarray(e, r) : a = this.data.slice(e, r), new I({
-      data: a,
+  sliceSub(t, e, s) {
+    if (e <= 0 && (s == null || s >= this.length)) return this;
+    let i;
+    return t ? i = this.data.subarray(e, s) : i = this.data.slice(e, s), new T({
+      data: i,
       dataType: this.dataType,
-      timeRange: this._timeRange,
+      timeRange: this.timeRange,
       sampleOffset: this.sampleOffset,
       glBufferUsage: this.gl.bufferUsage,
       alignment: this.alignment + BigInt(e)
     });
   }
   reAlign(t) {
-    return new I({
+    return new T({
       data: this.buffer,
       dataType: this.dataType,
-      timeRange: U.ZERO,
+      timeRange: A.ZERO,
       sampleOffset: this.sampleOffset,
       glBufferUsage: "static",
       alignment: t
     });
   }
+  toString() {
+    var e, s;
+    let t = `${this.dataType.toString()} ${this.length} [`;
+    if (this.length <= 10) t += Array.from(this).map((i) => i.toString());
+    else {
+      for (let i = 0; i < 5; i++)
+        t += `${(e = this.at(i)) == null ? void 0 : e.toString()}`, i < 4 && (t += ",");
+      t += "...";
+      for (let i = -5; i < 0; i++)
+        t += (s = this.at(i)) == null ? void 0 : s.toString(), i < -1 && (t += ",");
+    }
+    return t += "]", t;
+  }
 };
-s(I, "crudeZ", l.object({
-  timeRange: U.z.optional(),
+r(T, "crudeZ", l.object({
+  timeRange: A.z.optional(),
   dataType: g.z,
   alignment: l.coerce.bigint().optional(),
   data: l.union([
-    gt,
-    mt,
+    bt,
+    wt,
     l.instanceof(ArrayBuffer),
     l.instanceof(Uint8Array)
   ]),
-  glBufferUsage: ct.optional().default("static").optional()
-})), s(I, "z", I.crudeZ.transform((t) => new I(t)));
-let k = I;
-class G {
-  constructor(t, e, r) {
-    s(this, "series");
-    s(this, "end");
-    s(this, "index");
+  glBufferUsage: gt.optional().default("static").optional()
+})), r(T, "z", T.crudeZ.transform((t) => new T(t)));
+let k = T;
+class W {
+  constructor(t, e, s) {
+    r(this, "series");
+    r(this, "end");
+    r(this, "index");
     this.series = t;
-    const a = L(0, t.length);
-    this.end = V(a, r), this.index = V(a, e);
+    const i = L(0, t.length);
+    this.end = J(i, s), this.index = J(i, e);
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
@@ -1657,11 +1722,11 @@ class G {
     return this;
   }
 }
-class Ot {
+class yt {
   constructor(t) {
-    s(this, "series");
-    s(this, "index");
-    s(this, "decoder");
+    r(this, "series");
+    r(this, "index");
+    r(this, "decoder");
     if (!t.dataType.isVariable)
       throw new Error(
         "cannot create a variable series iterator for a non-variable series"
@@ -1670,38 +1735,40 @@ class Ot {
   }
   next() {
     const t = this.index, e = this.series.data;
-    for (; this.index < e.length && e[this.index] !== Y; ) this.index++;
-    const r = this.index;
-    return t === r ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(t, r)) });
+    for (; this.index < e.length && e[this.index] !== Z; ) this.index++;
+    const s = this.index;
+    return t === s ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(t, s)) });
   }
   [Symbol.iterator]() {
     return this;
   }
 }
-var W, j;
-class wt {
+var j, K;
+const P = class P {
   constructor(t) {
-    s(this, "wrapped");
-    s(this, W, "JSONSeriesIterator");
+    r(this, "wrapped");
+    r(this, j, "JSONSeriesIterator");
     this.wrapped = t;
   }
   next() {
     const t = this.wrapped.next();
     return t.done === !0 ? { done: !0, value: void 0 } : {
       done: !1,
-      value: q.decodeString(t.value)
+      value: q.decodeString(t.value, P.SCHEMA)
     };
   }
-  [(j = Symbol.iterator, W = Symbol.toStringTag, j)]() {
+  [(K = Symbol.iterator, j = Symbol.toStringTag, K)]() {
     return this;
   }
-}
-var H, K;
-class bt {
+};
+r(P, "SCHEMA", l.record(l.string(), l.unknown()));
+let G = P;
+var z, X;
+class It {
   constructor(t) {
-    s(this, "series");
-    s(this, "index");
-    s(this, H, "SeriesIterator");
+    r(this, "series");
+    r(this, "index");
+    r(this, z, "SeriesIterator");
     this.series = t, this.index = 0;
   }
   next() {
@@ -1710,29 +1777,29 @@ class bt {
       value: this.series.at(this.index++, !0)
     };
   }
-  [(K = Symbol.iterator, H = Symbol.toStringTag, K)]() {
+  [(X = Symbol.iterator, z = Symbol.toStringTag, X)]() {
     return this;
   }
 }
-class Dt {
-  constructor(t) {
-    s(this, "series");
+class $t {
+  constructor(t = []) {
+    r(this, "series");
     if (t.length !== 0) {
       const e = t[0].dataType;
-      for (let r = 1; r < t.length; r++)
-        if (!t[r].dataType.equals(e))
+      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 et(t, this.dataType), this;
+    return nt(t, this.dataType), this;
   }
   get dataType() {
     return this.series.length === 0 ? g.UNKNOWN : this.series[0].dataType;
   }
   get timeRange() {
-    return this.series.length === 0 ? U.ZERO : new U(
+    return this.series.length === 0 ? A.ZERO : new A(
       this.series[0].timeRange.start,
       this.series[this.series.length - 1].timeRange.end
     );
@@ -1747,7 +1814,7 @@ class Dt {
     );
   }
   push(t) {
-    this.series.push(t);
+    "isSynnaxSeries" in t && t.isSynnaxSeries ? this.series.push(t) : this.series.push(...t.series);
   }
   get length() {
     return this.series.reduce((t, e) => t + e.length, 0);
@@ -1757,78 +1824,90 @@ class Dt {
       if (e) throw new Error(`[series] - no value at alignment ${t}`);
       return;
     }
-    for (const r of this.series)
-      if (D(r.alignmentBounds, t))
-        return r.atAlignment(t, e);
+    for (const s of this.series)
+      if (D(s.alignmentBounds, t))
+        return s.atAlignment(t, e);
     if (e) throw new Error(`[series] - no value at alignment ${t}`);
   }
   at(t, e = !1) {
     t < 0 && (t = this.length + t);
-    for (const r of this.series) {
-      if (t < r.length) return r.at(t, e);
-      t -= r.length;
+    for (const s of this.series) {
+      if (t < s.length) return s.at(t, e);
+      t -= s.length;
     }
     if (e) throw new Error(`[series] - no value at index ${t}`);
   }
   subIterator(t, e) {
-    return new P(this, t, e ?? this.length);
+    return new F(this, t, e ?? this.length);
   }
   subAlignmentIterator(t, e) {
     if (t >= this.alignmentBounds.upper || e <= this.alignmentBounds.lower)
-      return F;
-    let r = 0;
-    for (let c = 0; c < this.series.length; c++) {
-      const h = this.series[c];
-      if (t < h.alignment) break;
-      if (t >= h.alignmentBounds.upper) r += h.length;
-      else if (D(h.alignmentBounds, t)) {
-        r += Number(t - h.alignment);
+      return Y;
+    let s = 0;
+    for (let h = 0; h < this.series.length; h++) {
+      const c = this.series[h];
+      if (t < c.alignment) break;
+      if (t >= c.alignmentBounds.upper) s += c.length;
+      else if (D(c.alignmentBounds, t)) {
+        s += Number(t - c.alignment);
         break;
       }
     }
-    let a = 0;
-    for (let c = 0; c < this.series.length; c++) {
-      const h = this.series[c];
-      if (e < h.alignment) break;
-      if (e >= h.alignmentBounds.upper) a += h.length;
-      else if (D(h.alignmentBounds, e)) {
-        a += Number(e - h.alignment);
+    let i = 0;
+    for (let h = 0; h < this.series.length; h++) {
+      const c = this.series[h];
+      if (e < c.alignment) break;
+      if (e >= c.alignmentBounds.upper) i += c.length;
+      else if (D(c.alignmentBounds, e)) {
+        i += Number(e - c.alignment);
         break;
       }
     }
-    return new P(this, r, a);
+    return new F(this, s, i);
   }
   subAlignmentSpanIterator(t, e) {
-    if (t >= this.alignmentBounds.upper) return F;
-    let r = 0;
-    for (let a = 0; a < this.series.length; a++) {
-      const c = this.series[a];
-      if (t < c.alignment) break;
-      if (t >= c.alignmentBounds.upper) r += c.length;
-      else if (D(c.alignmentBounds, t)) {
-        r += Number(t - c.alignment);
+    if (t >= this.alignmentBounds.upper) return Y;
+    let s = 0;
+    for (let i = 0; i < this.series.length; i++) {
+      const h = this.series[i];
+      if (t < h.alignment) break;
+      if (t >= h.alignmentBounds.upper) s += h.length;
+      else if (D(h.alignmentBounds, t)) {
+        s += Number(t - h.alignment);
         break;
       }
     }
-    return new P(this, r, r + e);
+    return new F(this, s, s + e);
+  }
+  updateGLBuffer(t) {
+    this.series.forEach((e) => e.updateGLBuffer(t));
+  }
+  get bounds() {
+    return ot(this.series.map((t) => t.bounds));
   }
   get byteLength() {
-    return new C(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
+    return new R(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
   }
   get data() {
     const t = new this.dataType.Array(this.length);
     let e = 0;
-    for (const r of this.series)
-      t.set(r.data, e), e += r.length;
+    for (const s of this.series)
+      t.set(s.data, e), e += s.length;
     return new this.dataType.Array(t.buffer);
   }
   traverseAlignment(t, e) {
-    const r = this.series.map((a) => a.alignmentBounds);
-    return at(r, t, e);
+    const s = this.series.map((i) => i.alignmentBounds);
+    return lt(s, t, e);
+  }
+  acquire() {
+    this.series.forEach((t) => t.acquire());
+  }
+  release() {
+    this.series.forEach((t) => t.release());
   }
   distance(t, e) {
-    const r = this.series.map((a) => a.alignmentBounds);
-    return ut(r, t, e);
+    const s = this.series.map((i) => i.alignmentBounds);
+    return ft(s, t, e);
   }
   parseJSON(t) {
     if (!this.dataType.equals(g.JSON))
@@ -1840,32 +1919,32 @@ class Dt {
       next() {
         return { done: !0, value: void 0 };
       }
-    } : new yt(this.series);
+    } : new Tt(this.series);
   }
 }
-var z, X;
-class yt {
+var Q, _;
+class Tt {
   constructor(t) {
-    s(this, "series");
-    s(this, "seriesIndex");
-    s(this, "internal");
-    s(this, z, "MultiSeriesIterator");
+    r(this, "series");
+    r(this, "seriesIndex");
+    r(this, "internal");
+    r(this, Q, "MultiSeriesIterator");
     this.series = t, this.seriesIndex = 0, this.internal = t[0][Symbol.iterator]();
   }
   next() {
     const t = this.internal.next();
     return t.done === !1 ? t : this.seriesIndex === this.series.length - 1 ? { done: !0, value: void 0 } : (this.internal = this.series[++this.seriesIndex][Symbol.iterator](), this.next());
   }
-  [(X = Symbol.iterator, z = Symbol.toStringTag, X)]() {
+  [(_ = Symbol.iterator, Q = Symbol.toStringTag, _)]() {
     return this;
   }
 }
-class P {
-  constructor(t, e, r) {
-    s(this, "series");
-    s(this, "index");
-    s(this, "end");
-    this.series = t, this.end = r, this.index = e;
+class F {
+  constructor(t, e, s) {
+    r(this, "series");
+    r(this, "index");
+    r(this, "end");
+    this.series = t, this.end = s, this.index = e;
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
@@ -1874,25 +1953,25 @@ class P {
     return this;
   }
 }
-const J = (o) => {
+const H = (o) => {
   const t = o >> 32n, e = o & 0xffffffffn;
   return { domain: t, sample: e };
 };
 export {
   y as D,
-  Dt as M,
+  $t as M,
   $ as R,
   k as S,
   m as T,
-  w as a,
-  U as b,
+  O as a,
+  A as b,
   g as c,
-  C as d,
-  tt as e,
-  ht as f,
+  R as d,
+  st as e,
+  mt as f,
   x as g,
-  Ct as h,
-  dt as i,
-  xt as s,
-  Lt as t
+  Lt as h,
+  Ot as i,
+  Dt as s,
+  qt as t
 };