@synnaxlabs/x 0.34.0 → 0.36.0

package/dist/{series-sjWkW8qe.js → series-CnEQe1dh.js}

@@ -1,43 +1,43 @@
-var tt = Object.defineProperty;
-var et = (l, t, e) => t in l ? tt(l, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : l[t] = e;
-var s = (l, t, e) => et(l, typeof t != "symbol" ? t + "" : t, e);
-import { z as o } from "zod";
+var et = Object.defineProperty;
+var rt = (o, t, e) => t in o ? et(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var s = (o, t, e) => rt(o, typeof t != "symbol" ? t + "" : t, e);
+import { z as l } from "zod";
 import { J as $ } from "./index-BBa2mWG1.js";
 import { s as nt } from "./index-eue4dSQX.js";
-import { n as rt } from "./index-HQonyH7n.js";
-import { m as R, c as L, a as k, d as D, t as st, e as it } from "./bounds-CFI9wDXn.js";
-import "./box-DVCNGsJG.js";
+import { n as st } from "./index-HQonyH7n.js";
+import { m as R, c as L, a as k, d as D, t as it, e as at } from "./bounds-BtccGJW0.js";
+import "./box-CYXc9-qp.js";
 import "./dimensions-D-1PnJVI.js";
 import "./base-DnZzEvvz.js";
-import "./location-CI9x53qR.js";
-import "./scale-DNQE1LMm.js";
-import "./xy-CrgPnICw.js";
-import { b as at } from "./zodutil-Tmuc4CNq.js";
-let ut = (l, t = 21) => (e = t) => {
-  let n = "", i = e;
+import "./location-Cn1ByVTZ.js";
+import "./scale-rZ1YKDFy.js";
+import "./xy-DQdccWlc.js";
+import { b as ut } from "./zodutil-DI4gVZkT.js";
+let ot = (o, t = 21) => (e = t) => {
+  let r = "", i = e;
   for (; i--; )
-    n += l[Math.random() * l.length | 0];
-  return n;
+    r += o[Math.random() * o.length | 0];
+  return r;
 };
-const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X = ut(ot, 11), Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const lt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Q = ot(lt, 11), xt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  id: X
-}, Symbol.toStringTag, { value: "Module" })), lt = o.enum(["static", "dynamic"]), Q = (l, t) => {
+  id: Q
+}, Symbol.toStringTag, { value: "Module" })), ft = l.enum(["static", "dynamic"]), _ = (o, t) => {
   const e = new m(t);
   if (![
-    y.DAY,
-    y.HOUR,
-    y.MINUTE,
-    y.SECOND,
-    y.MILLISECOND,
-    y.MICROSECOND,
-    y.NANOSECOND
+    w.DAY,
+    w.HOUR,
+    w.MINUTE,
+    w.SECOND,
+    w.MILLISECOND,
+    w.MICROSECOND,
+    w.NANOSECOND
   ].some((i) => i.equals(e)))
     throw new Error(
       "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
     );
-  const n = l.valueOf() % e.valueOf();
-  return l instanceof m ? new m(n) : new y(n);
+  const r = o.valueOf() % e.valueOf();
+  return o instanceof m ? new m(r) : new w(r);
 }, a = class a {
   constructor(t, e = "UTC") {
     s(this, "value");
@@ -49,12 +49,12 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
       this.value = a.parseDateTimeString(t, e).valueOf();
     else if (Array.isArray(t)) this.value = a.parseDate(t);
     else {
-      let n = BigInt(0);
-      t instanceof Number && (t = t.valueOf()), e === "local" && (n = 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()) + n;
+      let r = BigInt(0);
+      t instanceof Number && (t = t.valueOf()), e === "local" && (r = 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()) + r;
     }
   }
-  static parseDate([t = 1970, e = 1, n = 1]) {
-    const i = new Date(t, e - 1, n, 0, 0, 0, 0);
+  static parseDate([t = 1970, e = 1, r = 1]) {
+    const i = new Date(t, e - 1, r, 0, 0, 0, 0);
     return new a(BigInt(i.getTime()) * a.MILLISECOND.valueOf()).truncate(a.DAY).valueOf();
   }
   encode() {
@@ -64,18 +64,18 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
     return this.value;
   }
   static parseTimeString(t, e = "UTC") {
-    const [n, i, c] = t.split(":");
-    let h = "00", S = "00";
-    c != null && ([h, S] = c.split("."));
-    let O = a.hours(parseInt(n ?? "00")).add(a.minutes(parseInt(i ?? "00"))).add(a.seconds(parseInt(h ?? "00"))).add(a.milliseconds(parseInt(S ?? "00")));
+    const [r, i, f] = t.split(":");
+    let h = "00", v = "00";
+    f != null && ([h, v] = f.split("."));
+    let O = a.hours(parseInt(r ?? "00")).add(a.minutes(parseInt(i ?? "00"))).add(a.seconds(parseInt(h ?? "00"))).add(a.milliseconds(parseInt(v ?? "00")));
     return e === "local" && (O = O.add(a.utcOffset)), O.valueOf();
   }
   static parseDateTimeString(t, e = "UTC") {
     if (!t.includes("/") && !t.includes("-"))
       return a.parseTimeString(t, e);
-    const n = new Date(t);
-    return t.includes(":") || n.setUTCHours(0, 0, 0, 0), new a(
-      BigInt(n.getTime()) * a.MILLISECOND.valueOf(),
+    const r = new Date(t);
+    return t.includes(":") || r.setUTCHours(0, 0, 0, 0), new a(
+      BigInt(r.getTime()) * a.MILLISECOND.valueOf(),
       e
     ).valueOf();
   }
@@ -103,15 +103,15 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
     return t === "UTC" ? this.date().toISOString() : this.sub(a.utcOffset).date().toISOString();
   }
   timeString(t = !1, e = "UTC") {
-    const n = this.toISOString(e);
-    return t ? n.slice(11, 23) : n.slice(11, 19);
+    const r = this.toISOString(e);
+    return t ? r.slice(11, 23) : r.slice(11, 19);
   }
   dateString() {
-    const t = this.date(), e = t.toLocaleString("default", { month: "short" }), n = t.toLocaleString("default", { day: "numeric" });
-    return `${e} ${n}`;
+    const t = this.date(), e = t.toLocaleString("default", { month: "short" }), r = t.toLocaleString("default", { day: "numeric" });
+    return `${e} ${r}`;
   }
   static get utcOffset() {
-    return new y(
+    return new w(
       BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * a.MINUTE.valueOf()
     );
   }
@@ -125,7 +125,7 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
   }
   /** @returns A JavaScript Date object representing the TimeStamp. */
   date() {
-    return new Date(this.milliseconds());
+    return new Date(this.milliseconds);
   }
   /**
    * Checks if the TimeStamp is equal to another TimeStamp.
@@ -235,12 +235,94 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
   sub(t) {
     return new a(this.valueOf() - BigInt(t.valueOf()));
   }
+  /**
+   * @returns the floating point number of hours since the unix epoch to the timestamp
+   * value.
+   */
+  get hours() {
+    return Number(this.valueOf()) / Number(w.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());
+  }
+  /**
+   * @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());
+  }
+  /**
+   * @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());
+  }
   /**
    * @returns The number of milliseconds since the unix epoch.
    */
-  milliseconds() {
+  get milliseconds() {
     return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
   }
+  /** @returns the integer year that the timestamp corresponds to. */
+  get year() {
+    return this.date().getFullYear();
+  }
+  setYear(t) {
+    const e = this.date();
+    return e.setFullYear(t), new a(e);
+  }
+  /** @returns the integer month that the timestamp corresponds to with its year. */
+  get month() {
+    return this.date().getMonth();
+  }
+  setMonth(t) {
+    const e = this.date();
+    return e.setMonth(t), new a(e);
+  }
+  /** @returns the integer day that the timestamp corresponds to within its month. */
+  get day() {
+    return this.date().getDate();
+  }
+  setDay(t) {
+    const e = this.date();
+    return e.setDate(t), new a(e);
+  }
+  /** @returns the integer hour that the timestamp corresponds to within its day. */
+  get hour() {
+    return this.date().getHours();
+  }
+  setHour(t) {
+    const e = this.date();
+    return e.setHours(t), new a(e);
+  }
+  /** @returns the integer minute that the timestamp corresponds to within its hour. */
+  get minute() {
+    return this.date().getMinutes();
+  }
+  setMinute(t) {
+    const e = this.date();
+    return e.setMinutes(t), new a(e);
+  }
+  get second() {
+    return this.date().getSeconds();
+  }
+  setSecond(t) {
+    const e = this.date();
+    return e.setSeconds(t), new a(e);
+  }
+  get millisecond() {
+    return this.date().getMilliseconds();
+  }
+  setMillisecond(t) {
+    const e = this.date();
+    return e.setMilliseconds(t), new a(e);
+  }
   toString() {
     return this.date().toISOString();
   }
@@ -256,11 +338,11 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(t) {
-    return Q(this, t);
+    return _(this, t);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(y.DAY).equals(a.now().truncate(y.DAY));
+    return this.truncate(w.DAY).equals(a.now().truncate(w.DAY));
   }
   truncate(t) {
     return this.sub(this.remainder(t));
@@ -275,16 +357,16 @@ const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X =
   }
   static max(...t) {
     let e = a.MIN;
-    for (const n of t) {
-      const i = new a(n);
+    for (const r of t) {
+      const i = new a(r);
       i.after(e) && (e = i);
     }
     return e;
   }
   static min(...t) {
     let e = a.MAX;
-    for (const n of t) {
-      const i = new a(n);
+    for (const r of t) {
+      const i = new a(r);
       i.before(e) && (e = i);
     }
     return e;
@@ -329,12 +411,12 @@ s(a, "DAY", a.days(1)), /** The maximum possible value for a timestamp */
 s(a, "MAX", new a((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
 s(a, "MIN", new a(0)), /** The unix epoch */
 s(a, "ZERO", new a(0)), /** A zod schema for validating timestamps */
-s(a, "z", o.union([
-  o.object({ value: o.bigint() }).transform((t) => new a(t.value)),
-  o.string().transform((t) => new a(BigInt(t))),
-  o.instanceof(Number).transform((t) => new a(t)),
-  o.number().transform((t) => new a(t)),
-  o.instanceof(a)
+s(a, "z", l.union([
+  l.object({ value: l.bigint() }).transform((t) => new a(t.value)),
+  l.string().transform((t) => new a(BigInt(t))),
+  l.instanceof(Number).transform((t) => new a(t)),
+  l.number().transform((t) => new a(t)),
+  l.instanceof(a)
 ]));
 let m = a;
 const u = class u {
@@ -344,10 +426,10 @@ const u = class u {
     typeof t == "number" && (t = Math.trunc(t.valueOf())), this.value = BigInt(t.valueOf());
   }
   static fromSeconds(t) {
-    return t instanceof u ? t : t instanceof P ? t.period : t instanceof m ? new u(t) : ["number", "bigint"].includes(typeof t) ? u.seconds(t) : new u(t);
+    return t instanceof u ? t : t instanceof F ? t.period : t instanceof m ? new u(t) : ["number", "bigint"].includes(typeof t) ? u.seconds(t) : new u(t);
   }
   static fromMilliseconds(t) {
-    return t instanceof u ? t : t instanceof P ? t.period : t instanceof m ? new u(t) : ["number", "bigint"].includes(typeof t) ? u.milliseconds(t) : new u(t);
+    return t instanceof u ? t : t instanceof F ? t.period : t instanceof m ? new u(t) : ["number", "bigint"].includes(typeof t) ? u.milliseconds(t) : new u(t);
   }
   encode() {
     return this.value.toString();
@@ -368,7 +450,7 @@ const u = class u {
     return this.valueOf() >= new u(t).valueOf();
   }
   remainder(t) {
-    return Q(this, t);
+    return _(this, t);
   }
   truncate(t) {
     return new u(
@@ -376,9 +458,12 @@ const u = class u {
     );
   }
   toString() {
-    const t = this.truncate(u.DAY), e = this.truncate(u.HOUR), n = this.truncate(u.MINUTE), i = this.truncate(u.SECOND), c = this.truncate(u.MILLISECOND), h = this.truncate(u.MICROSECOND), S = this.truncate(u.NANOSECOND), O = t, N = e.sub(t), p = n.sub(e), f = i.sub(n), M = c.sub(i), U = h.sub(c), Z = S.sub(h);
+    const t = this.truncate(u.DAY), e = this.truncate(u.HOUR), r = this.truncate(u.MINUTE), i = this.truncate(u.SECOND), f = this.truncate(u.MILLISECOND), h = this.truncate(u.MICROSECOND), v = this.truncate(u.NANOSECOND), O = t, N = e.sub(t), p = r.sub(e), c = i.sub(r), M = f.sub(i), U = h.sub(f), Z = v.sub(h);
     let A = "";
-    return O.isZero || (A += `${O.days}d `), N.isZero || (A += `${N.hours}h `), p.isZero || (A += `${p.minutes}m `), f.isZero || (A += `${f.seconds}s `), M.isZero || (A += `${M.milliseconds}ms `), U.isZero || (A += `${U.microseconds}µs `), Z.isZero || (A += `${Z.nanoseconds}ns`), A.trim();
+    return O.isZero || (A += `${O.days}d `), N.isZero || (A += `${N.hours}h `), p.isZero || (A += `${p.minutes}m `), c.isZero || (A += `${c.seconds}s `), M.isZero || (A += `${M.milliseconds}ms `), U.isZero || (A += `${U.microseconds}µs `), Z.isZero || (A += `${Z.nanoseconds}ns`), A.trim();
+  }
+  mult(t) {
+    return new u(this.valueOf() * BigInt(t));
   }
   /** @returns the decimal number of days in the timespan */
   get days() {
@@ -513,15 +598,15 @@ 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", o.union([
-  o.object({ value: o.bigint() }).transform((t) => new u(t.value)),
-  o.string().transform((t) => new u(BigInt(t))),
-  o.instanceof(Number).transform((t) => new u(t)),
-  o.number().transform((t) => new u(t)),
-  o.instanceof(u)
+s(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 y = u;
-const v = class v extends Number {
+let w = u;
+const S = class S extends Number {
   constructor(t) {
     t instanceof Number ? super(t.valueOf()) : super(t);
   }
@@ -531,7 +616,7 @@ const v = class v extends Number {
   }
   /** @returns The number of seconds in the Rate. */
   equals(t) {
-    return this.valueOf() === new v(t).valueOf();
+    return this.valueOf() === new S(t).valueOf();
   }
   /**
    * Calculates the period of the Rate as a TimeSpan.
@@ -539,7 +624,7 @@ const v = class v extends Number {
    * @returns A TimeSpan representing the period of the Rate.
    */
   get period() {
-    return y.seconds(1 / this.valueOf());
+    return w.seconds(1 / this.valueOf());
   }
   /**
    * Calculates the number of samples in the given TimeSpan at this rate.
@@ -548,7 +633,7 @@ const v = class v extends Number {
    * @returns The number of samples in the given TimeSpan at this rate.
    */
   sampleCount(t) {
-    return new y(t).seconds * this.valueOf();
+    return new w(t).seconds * this.valueOf();
   }
   /**
    * Calculates the number of bytes in the given TimeSpan at this rate.
@@ -567,7 +652,7 @@ const v = class v extends Number {
    * @returns A TimeSpan that corresponds to the given number of samples.
    */
   span(t) {
-    return y.seconds(t / this.valueOf());
+    return w.seconds(t / this.valueOf());
   }
   /**
    * Calculates a TimeSpan given the number of bytes at this rate.
@@ -586,7 +671,7 @@ const v = class v extends Number {
    * @returns A Rate representing the given number of Hz.
    */
   static hz(t) {
-    return new v(t);
+    return new S(t);
   }
   /**
    * Creates a Rate representing the given number of kHz.
@@ -595,17 +680,17 @@ const v = class v extends Number {
    * @returns A Rate representing the given number of kHz.
    */
   static khz(t) {
-    return v.hz(t * 1e3);
+    return S.hz(t * 1e3);
   }
 };
 /** A zod schema for validating and transforming rates */
-s(v, "z", o.union([
-  o.number().transform((t) => new v(t)),
-  o.instanceof(Number).transform((t) => new v(t)),
-  o.instanceof(v)
+s(S, "z", l.union([
+  l.number().transform((t) => new S(t)),
+  l.instanceof(Number).transform((t) => new S(t)),
+  l.instanceof(S)
 ]));
-let P = v;
-const w = class w extends Number {
+let F = S;
+const y = class y extends Number {
   /**
    * Creates a Density representing the given number of bytes per value.
    *
@@ -624,18 +709,18 @@ const w = class w extends Number {
   }
 };
 /** Unknown/Invalid Density. */
-s(w, "UNKNOWN", new w(0)), /** 128 bits per value. */
-s(w, "BIT128", new w(16)), /** 64 bits per value. */
-s(w, "BIT64", new w(8)), /** 32 bits per value. */
-s(w, "BIT32", new w(4)), /** 16 bits per value. */
-s(w, "BIT16", new w(2)), /** 8 bits per value. */
-s(w, "BIT8", new w(1)), /** A zod schema for validating and transforming densities */
-s(w, "z", o.union([
-  o.number().transform((t) => new w(t)),
-  o.instanceof(Number).transform((t) => new w(t)),
-  o.instanceof(w)
+s(y, "UNKNOWN", new y(0)), /** 128 bits per value. */
+s(y, "BIT128", new y(16)), /** 64 bits per value. */
+s(y, "BIT64", new y(8)), /** 32 bits per value. */
+s(y, "BIT32", new y(4)), /** 16 bits per value. */
+s(y, "BIT16", new y(2)), /** 8 bits per value. */
+s(y, "BIT8", new y(1)), /** A zod schema for validating and transforming densities */
+s(y, "z", l.union([
+  l.number().transform((t) => new y(t)),
+  l.instanceof(Number).transform((t) => new y(t)),
+  l.instanceof(y)
 ]));
-let b = w;
+let b = y;
 const T = class T {
   /**
    * Creates a TimeRange from the given start and end TimeStamps.
@@ -666,7 +751,7 @@ const T = class T {
   }
   /** @returns The TimeSpan occupied by the TimeRange. */
   get span() {
-    return new y(this.end.valueOf() - this.start.valueOf());
+    return new w(this.end.valueOf() - this.start.valueOf());
   }
   /**
    * Checks if the timestamp is valid i.e. the start is before the end.
@@ -729,17 +814,17 @@ const T = class T {
    * @param other - The other TimeRange to compare to.
    * @returns True if the two TimeRanges overlap, false otherwise.
    */
-  overlapsWith(t, e = y.ZERO) {
+  overlapsWith(t, e = w.ZERO) {
     t = t.makeValid();
-    const n = this.makeValid();
+    const r = this.makeValid();
     if (this.equals(t)) return !0;
-    if (t.end.equals(n.start) || n.end.equals(t.start)) return !1;
-    const i = m.max(n.start, t.start), c = m.min(n.end, t.end);
-    return c.before(i) ? !1 : new y(c.sub(i)).greaterThanOrEqual(e);
+    if (t.end.equals(r.start) || r.end.equals(t.start)) return !1;
+    const i = m.max(r.start, t.start), f = m.min(r.end, t.end);
+    return f.before(i) ? !1 : new w(f.sub(i)).greaterThanOrEqual(e);
   }
   roughlyEquals(t, e) {
-    let n = this.start.sub(t.start).valueOf(), i = this.end.sub(t.end).valueOf();
-    return n < 0 && (n = -n), i < 0 && (i = -i), n <= e.valueOf() && i <= e.valueOf();
+    let r = this.start.sub(t.start).valueOf(), i = this.end.sub(t.end).valueOf();
+    return r < 0 && (r = -r), i < 0 && (i = -i), r <= e.valueOf() && i <= e.valueOf();
   }
   contains(t) {
     return t instanceof T ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
@@ -753,29 +838,29 @@ const T = class T {
 s(T, "MAX", new T(m.MIN, m.MAX)), /** The minimum possible time range. */
 s(T, "MIN", new T(m.MAX, m.MIN)), /** A zero time range. */
 s(T, "ZERO", new T(m.ZERO, m.ZERO)), /** A zod schema for validating and transforming time ranges */
-s(T, "z", o.union([
-  o.object({ start: m.z, end: m.z }).transform((t) => new T(t.start, t.end)),
-  o.instanceof(T)
+s(T, "z", l.union([
+  l.object({ start: m.z, end: m.z }).transform((t) => new T(t.start, t.end)),
+  l.instanceof(T)
 ]));
 let E = T;
-const r = class r extends String {
+const Ct = (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 {
   constructor(t) {
-    if (t instanceof r || typeof t == "string" || typeof t.valueOf() == "string") {
+    if (t instanceof n || typeof t == "string" || typeof t.valueOf() == "string") {
       super(t.valueOf());
       return;
     }
-    const e = r.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
+    const e = n.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
     if (e != null) {
       super(e.valueOf());
       return;
     }
-    throw super(r.UNKNOWN.valueOf()), new Error(`unable to find data type for ${t.toString()}`);
+    throw super(n.UNKNOWN.valueOf()), new Error(`unable to find data type for ${t.toString()}`);
   }
   /**
    * @returns the TypedArray constructor for the DataType.
    */
   get Array() {
-    const t = r.ARRAY_CONSTRUCTORS.get(this.toString());
+    const t = n.ARRAY_CONSTRUCTORS.get(this.toString());
     if (t == null)
       throw new Error(`unable to find array constructor for ${this.valueOf()}`);
     return t;
@@ -797,10 +882,10 @@ const r = class r extends String {
     return this.valueOf();
   }
   get isVariable() {
-    return this.equals(r.JSON) || this.equals(r.STRING);
+    return this.equals(n.JSON) || this.equals(n.STRING);
   }
   get isNumeric() {
-    return !this.isVariable && !this.equals(r.UUID);
+    return !this.isVariable && !this.equals(n.UUID);
   }
   get isInteger() {
     return this.toString().startsWith("int");
@@ -809,7 +894,7 @@ const r = class r extends String {
     return this.toString().startsWith("float");
   }
   get density() {
-    const t = r.DENSITIES.get(this.toString());
+    const t = n.DENSITIES.get(this.toString());
     if (t == null) throw new Error(`unable to find density for ${this.valueOf()}`);
     return t;
   }
@@ -834,91 +919,91 @@ const r = class r extends String {
     return this.toString();
   }
   get usesBigInt() {
-    return r.BIG_INT_TYPES.some((t) => t.equals(this));
+    return n.BIG_INT_TYPES.some((t) => t.equals(this));
   }
 };
 /** Represents an Unknown/Invalid DataType. */
-s(r, "UNKNOWN", new r("unknown")), /** Represents a 64-bit floating point value. */
-s(r, "FLOAT64", new r("float64")), /** Represents a 32-bit floating point value. */
-s(r, "FLOAT32", new r("float32")), /** Represents a 64-bit signed integer value. */
-s(r, "INT64", new r("int64")), /** Represents a 32-bit signed integer value. */
-s(r, "INT32", new r("int32")), /** Represents a 16-bit signed integer value. */
-s(r, "INT16", new r("int16")), /** Represents a 8-bit signed integer value. */
-s(r, "INT8", new r("int8")), /** Represents a 64-bit unsigned integer value. */
-s(r, "UINT64", new r("uint64")), /** Represents a 32-bit unsigned integer value. */
-s(r, "UINT32", new r("uint32")), /** Represents a 16-bit unsigned integer value. */
-s(r, "UINT16", new r("uint16")), /** Represents a 8-bit unsigned integer value. */
-s(r, "UINT8", new r("uint8")), /** Represents a boolean value. Alias for UINT8. */
-s(r, "BOOLEAN", r.UINT8), /** Represents a 64-bit unix epoch. */
-s(r, "TIMESTAMP", new r("timestamp")), /** Represents a UUID data type */
-s(r, "UUID", new r("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
+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
  * by a newline character. */
-s(r, "STRING", new r("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+s(n, "STRING", new n("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
  * newline character. */
-s(r, "JSON", new r("json")), s(r, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
-  [r.UINT8.toString(), Uint8Array],
-  [r.UINT16.toString(), Uint16Array],
-  [r.UINT32.toString(), Uint32Array],
-  [r.UINT64.toString(), BigUint64Array],
-  [r.FLOAT32.toString(), Float32Array],
-  [r.FLOAT64.toString(), Float64Array],
-  [r.INT8.toString(), Int8Array],
-  [r.INT16.toString(), Int16Array],
-  [r.INT32.toString(), Int32Array],
-  [r.INT64.toString(), BigInt64Array],
-  [r.TIMESTAMP.toString(), BigInt64Array],
-  [r.STRING.toString(), Uint8Array],
-  [r.JSON.toString(), Uint8Array],
-  [r.UUID.toString(), Uint8Array]
-])), s(r, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
-  [Uint8Array.name, r.UINT8],
-  [Uint16Array.name, r.UINT16],
-  [Uint32Array.name, r.UINT32],
-  [BigUint64Array.name, r.UINT64],
-  [Float32Array.name, r.FLOAT32],
-  [Float64Array.name, r.FLOAT64],
-  [Int8Array.name, r.INT8],
-  [Int16Array.name, r.INT16],
-  [Int32Array.name, r.INT32],
-  [BigInt64Array.name, r.INT64]
-])), s(r, "DENSITIES", /* @__PURE__ */ new Map([
-  [r.UINT8.toString(), b.BIT8],
-  [r.UINT16.toString(), b.BIT16],
-  [r.UINT32.toString(), b.BIT32],
-  [r.UINT64.toString(), b.BIT64],
-  [r.FLOAT32.toString(), b.BIT32],
-  [r.FLOAT64.toString(), b.BIT64],
-  [r.INT8.toString(), b.BIT8],
-  [r.INT16.toString(), b.BIT16],
-  [r.INT32.toString(), b.BIT32],
-  [r.INT64.toString(), b.BIT64],
-  [r.TIMESTAMP.toString(), b.BIT64],
-  [r.STRING.toString(), b.UNKNOWN],
-  [r.JSON.toString(), b.UNKNOWN],
-  [r.UUID.toString(), b.BIT128]
+s(n, "JSON", new n("json")), s(n, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
+  [n.UINT8.toString(), Uint8Array],
+  [n.UINT16.toString(), Uint16Array],
+  [n.UINT32.toString(), Uint32Array],
+  [n.UINT64.toString(), BigUint64Array],
+  [n.FLOAT32.toString(), Float32Array],
+  [n.FLOAT64.toString(), Float64Array],
+  [n.INT8.toString(), Int8Array],
+  [n.INT16.toString(), Int16Array],
+  [n.INT32.toString(), Int32Array],
+  [n.INT64.toString(), BigInt64Array],
+  [n.TIMESTAMP.toString(), BigInt64Array],
+  [n.STRING.toString(), Uint8Array],
+  [n.JSON.toString(), Uint8Array],
+  [n.UUID.toString(), Uint8Array]
+])), s(n, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
+  [Uint8Array.name, n.UINT8],
+  [Uint16Array.name, n.UINT16],
+  [Uint32Array.name, n.UINT32],
+  [BigUint64Array.name, n.UINT64],
+  [Float32Array.name, n.FLOAT32],
+  [Float64Array.name, n.FLOAT64],
+  [Int8Array.name, n.INT8],
+  [Int16Array.name, n.INT16],
+  [Int32Array.name, n.INT32],
+  [BigInt64Array.name, n.INT64]
+])), s(n, "DENSITIES", /* @__PURE__ */ new Map([
+  [n.UINT8.toString(), b.BIT8],
+  [n.UINT16.toString(), b.BIT16],
+  [n.UINT32.toString(), b.BIT32],
+  [n.UINT64.toString(), b.BIT64],
+  [n.FLOAT32.toString(), b.BIT32],
+  [n.FLOAT64.toString(), b.BIT64],
+  [n.INT8.toString(), b.BIT8],
+  [n.INT16.toString(), b.BIT16],
+  [n.INT32.toString(), b.BIT32],
+  [n.INT64.toString(), b.BIT64],
+  [n.TIMESTAMP.toString(), b.BIT64],
+  [n.STRING.toString(), b.UNKNOWN],
+  [n.JSON.toString(), b.UNKNOWN],
+  [n.UUID.toString(), b.BIT128]
 ])), /** All the data types. */
-s(r, "ALL", [
-  r.UNKNOWN,
-  r.FLOAT64,
-  r.FLOAT32,
-  r.INT64,
-  r.INT32,
-  r.INT16,
-  r.INT8,
-  r.UINT64,
-  r.UINT32,
-  r.UINT16,
-  r.UINT8,
-  r.TIMESTAMP,
-  r.UUID,
-  r.STRING,
-  r.JSON
-]), s(r, "BIG_INT_TYPES", [r.INT64, r.UINT64, r.TIMESTAMP]), /** A zod schema for a DataType. */
-s(r, "z", o.union([
-  o.string().transform((t) => new r(t)),
-  o.instanceof(r)
+s(n, "ALL", [
+  n.UNKNOWN,
+  n.FLOAT64,
+  n.FLOAT32,
+  n.INT64,
+  n.INT32,
+  n.INT16,
+  n.INT8,
+  n.UINT64,
+  n.UINT32,
+  n.UINT16,
+  n.UINT8,
+  n.TIMESTAMP,
+  n.UUID,
+  n.STRING,
+  n.JSON
+]), s(n, "BIG_INT_TYPES", [n.INT64, n.UINT64, n.TIMESTAMP]), /** A zod schema for a DataType. */
+s(n, "z", l.union([
+  l.string().transform((t) => new n(t)),
+  l.instanceof(n)
 ]));
-let g = r;
+let g = n;
 const d = class d extends Number {
   constructor(t) {
     super(t.valueOf());
@@ -956,9 +1041,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), n = this.truncate(d.MEGABYTE), i = this.truncate(d.KILOBYTE), c = this.truncate(d.BYTE), h = t, S = e.sub(t), O = n.sub(e), N = i.sub(n), p = c.sub(i);
-    let f = "";
-    return h.isZero || (f += `${h.terabytes}TB `), S.isZero || (f += `${S.gigabytes}GB `), O.isZero || (f += `${O.megabytes}MB `), N.isZero || (f += `${N.kilobytes}KB `), (!p.isZero || f === "") && (f += `${p.valueOf()}B`), f.trim();
+    const t = this.truncate(d.TERABYTE), e = this.truncate(d.GIGABYTE), r = this.truncate(d.MEGABYTE), i = this.truncate(d.KILOBYTE), f = this.truncate(d.BYTE), h = t, v = e.sub(t), O = r.sub(e), N = i.sub(r), p = f.sub(i);
+    let c = "";
+    return h.isZero || (c += `${h.terabytes}TB `), v.isZero || (c += `${v.gigabytes}GB `), O.isZero || (c += `${O.megabytes}MB `), N.isZero || (c += `${N.kilobytes}KB `), (!p.isZero || c === "") && (c += `${p.valueOf()}B`), c.trim();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -1016,33 +1101,33 @@ 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", o.union([
-  o.number().transform((t) => new d(t)),
-  o.instanceof(d)
+s(d, "z", l.union([
+  l.number().transform((t) => new d(t)),
+  l.instanceof(d)
 ]));
 let x = d;
-const xt = 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)
-]), _ = (l) => {
-  const t = typeof l;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || l instanceof m || l instanceof y || l instanceof Date;
-}, ct = (l, t, e, n = 0) => l.usesBigInt && !t.usesBigInt ? Number(e) - Number(n) : !l.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(n.valueOf()) : C(e, -n).valueOf(), ft = (l) => l == null ? !1 : Array.isArray(l) || l instanceof ArrayBuffer || ArrayBuffer.isView(l) && !(l instanceof DataView) || l instanceof V ? !0 : _(l), B = -1, q = {
-  [Symbol.iterator]: () => q,
+const Lt = l.union([
+  l.instanceof(Uint8Array),
+  l.instanceof(Uint16Array),
+  l.instanceof(Uint32Array),
+  l.instanceof(BigUint64Array),
+  l.instanceof(Float32Array),
+  l.instanceof(Float64Array),
+  l.instanceof(Int8Array),
+  l.instanceof(Int16Array),
+  l.instanceof(Int32Array),
+  l.instanceof(BigInt64Array)
+]), tt = (o) => {
+  const t = typeof o;
+  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || o instanceof m || o instanceof w || o instanceof Date;
+}, ct = (o, t, e, r = 0) => o.usesBigInt && !t.usesBigInt ? Number(e) - Number(r) : !o.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(r.valueOf()) : C(e, -r).valueOf(), ht = (o) => o == null ? !1 : Array.isArray(o) || o instanceof ArrayBuffer || ArrayBuffer.isView(o) && !(o instanceof DataView) || o instanceof V ? !0 : tt(o), B = -1, Y = {
+  [Symbol.iterator]: () => Y,
   next: () => ({ done: !0, value: void 0 })
-}, ht = o.string().transform(
-  (l) => new Uint8Array(
-    atob(l).split("").map((t) => t.charCodeAt(0))
+}, dt = l.string().transform(
+  (o) => new Uint8Array(
+    atob(o).split("").map((t) => t.charCodeAt(0))
   ).buffer
-), dt = o.union([o.null(), o.undefined()]).transform(() => new Uint8Array().buffer), Y = 10, I = class I {
+), gt = l.union([l.null(), l.undefined()]).transform(() => new Uint8Array().buffer), q = 10, I = class I {
   constructor(t) {
     s(this, "key", "");
     s(this, "isSynnaxSeries", !0);
@@ -1074,21 +1159,21 @@ const xt = o.union([
     s(this, "_cachedLength");
     /** Caches the indexes of the array for variable length data types. */
     s(this, "_cachedIndexes");
-    ft(t) && (t = { data: t });
+    ht(t) && (t = { data: t });
     const {
       dataType: e,
-      timeRange: n,
+      timeRange: r,
       sampleOffset: i = 0,
-      glBufferUsage: c = "static",
+      glBufferUsage: f = "static",
       alignment: h = 0n,
-      key: S = X()
+      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;
+      const c = O;
+      this.key = c.key, this.dataType = c.dataType, this.sampleOffset = c.sampleOffset, this.gl = c.gl, this._data = c._data, this._timeRange = c._timeRange, this.alignment = c.alignment, this._cachedMin = c._cachedMin, this._cachedMax = c._cachedMax, this.writePos = c.writePos, this._refCount = c._refCount, this._cachedLength = c._cachedLength;
       return;
     }
-    const N = _(O), p = Array.isArray(O);
+    const N = tt(O), p = Array.isArray(O);
     if (e != null) this.dataType = new g(e);
     else {
       if (O instanceof ArrayBuffer)
@@ -1096,78 +1181,80 @@ const xt = o.union([
           "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
         );
       if (p || N) {
-        let f = O;
+        let c = O;
         if (!N) {
           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];
+          c = O[0];
         }
-        if (typeof f == "string") this.dataType = g.STRING;
-        else if (typeof f == "number") this.dataType = g.FLOAT64;
-        else if (typeof f == "bigint") this.dataType = g.INT64;
-        else if (typeof f == "boolean") this.dataType = g.BOOLEAN;
-        else if (f instanceof m || f instanceof Date || f instanceof m)
+        if (typeof c == "string") this.dataType = g.STRING;
+        else if (typeof c == "number") this.dataType = g.FLOAT64;
+        else if (typeof c == "bigint") this.dataType = g.INT64;
+        else if (typeof c == "boolean") this.dataType = g.BOOLEAN;
+        else if (c instanceof m || c instanceof Date || c instanceof m)
           this.dataType = g.TIMESTAMP;
-        else if (typeof f == "object") this.dataType = g.JSON;
+        else if (typeof c == "object") this.dataType = g.JSON;
         else
           throw new Error(
-            `cannot infer data type of ${typeof f} when constructing a Series from a JS array`
+            `cannot infer data type of ${typeof c} when constructing a Series from a JS array`
           );
       } else this.dataType = new g(O);
     }
     if (!p && !N) this._data = O;
     else {
-      let f = N ? [O] : O;
-      const M = f[0];
-      (M instanceof m || M instanceof Date || M instanceof y) && (f = f.map((U) => new m(U).valueOf())), this.dataType.equals(g.STRING) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(`${f.join(`
+      let c = N ? [O] : O;
+      const M = c[0];
+      (M instanceof m || M instanceof Date || M instanceof w) && (c = c.map((U) => new m(U).valueOf())), this.dataType.equals(g.STRING) ? (this._cachedLength = c.length, this._data = new TextEncoder().encode(`${c.join(`
 `)}
-`)) : this.dataType.equals(g.JSON) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(
-        `${f.map((U) => $.encodeString(U)).join(`
+`).buffer) : this.dataType.equals(g.JSON) ? (this._cachedLength = c.length, this._data = new TextEncoder().encode(
+        `${c.map((U) => $.encodeString(U)).join(`
 `)}
 `
-      )) : this._data = new this.dataType.Array(f).buffer;
+      ).buffer) : this._data = new this.dataType.Array(c).buffer;
     }
-    this.key = S, this.alignment = h, this.sampleOffset = i ?? 0, this._timeRange = n, this.gl = {
+    this.key = v, this.alignment = h, this.sampleOffset = i ?? 0, this._timeRange = r, this.gl = {
       control: null,
       buffer: null,
       prevBuffer: 0,
-      bufferUsage: c
+      bufferUsage: f
     };
   }
-  static alloc({ capacity: t, dataType: e, ...n }) {
+  static alloc({ capacity: t, dataType: e, ...r }) {
     if (t === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
-    const i = new new g(e).Array(t), c = new I({
+    const i = new new g(e).Array(t), f = new I({
       data: i.buffer,
       dataType: e,
-      ...n
+      ...r
     });
-    return c.writePos = 0, c;
+    return f.writePos = 0, f;
   }
-  static generateTimestamps(t, e, n) {
-    const i = n.spanRange(e.span(t)), c = new BigInt64Array(t);
+  static generateTimestamps(t, e, r) {
+    const i = r.spanRange(e.span(t)), f = new BigInt64Array(t);
     for (let h = 0; h < t; h++)
-      c[h] = BigInt(n.add(e.span(h)).valueOf());
-    return new I({ data: c, dataType: g.TIMESTAMP, timeRange: i });
+      f[h] = BigInt(r.add(e.span(h)).valueOf());
+    return new I({ data: f, dataType: g.TIMESTAMP, timeRange: i });
   }
   get refCount() {
     return this._refCount;
   }
   static fromStrings(t, e) {
-    const n = new TextEncoder().encode(`${t.join(`
+    const r = new TextEncoder().encode(
+      `${t.join(`
 `)}
-`);
-    return new I({ data: n, dataType: g.STRING, timeRange: e });
+`
+    );
+    return new I({ data: r, dataType: g.STRING, timeRange: e });
   }
   static fromJSON(t, e) {
-    const n = new TextEncoder().encode(
+    const r = new TextEncoder().encode(
       `${t.map((i) => $.encodeString(i)).join(`
 `)}
 `
     );
-    return new I({ data: n, dataType: g.JSON, timeRange: e });
+    return new I({ data: r, dataType: g.JSON, timeRange: e });
   }
   acquire(t) {
     this._refCount++, t != null && this.updateGLBuffer(t);
@@ -1193,13 +1280,13 @@ const xt = o.union([
   }
   writeVariable(t) {
     if (this.writePos === B) return 0;
-    const e = this.byteCapacity.valueOf() - this.writePos, n = t.subBytes(0, e);
-    return this.writeToUnderlyingData(n), this.writePos += n.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += n.length, this.calculateCachedLength()), n.length;
+    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;
   }
   writeFixed(t) {
     if (this.writePos === B) return 0;
-    const e = this.capacity - this.writePos, n = t.sub(0, e);
-    return this.writeToUnderlyingData(n), this._cachedLength = void 0, this.maybeRecomputeMinMax(n), this.writePos += n.length, n.length;
+    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;
   }
   writeToUnderlyingData(t) {
     this.underlyingData.set(
@@ -1209,7 +1296,7 @@ const xt = o.union([
   }
   /** @returns the underlying buffer backing this array. */
   get buffer() {
-    return this._data instanceof ArrayBuffer || this._data instanceof SharedArrayBuffer ? this._data : this._data.buffer;
+    return typeof this._data == "object" && "buffer" in this._data ? this._data.buffer : this._data;
   }
   get underlyingData() {
     return new this.dataType.Array(this._data);
@@ -1228,9 +1315,12 @@ const xt = o.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 n = 0; n < this.length; n++) {
-      const i = this.underlyingData.slice(n * t, (n + 1) * t), c = Array.from(new Uint8Array(i), (h) => h.toString(16).padStart(2, "0")).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-      e[n] = c;
+    for (let r = 0; r < this.length; r++) {
+      const i = this.underlyingData.slice(r * t, (r + 1) * t), f = Array.from(
+        new Uint8Array(i.buffer),
+        (h) => h.toString(16).padStart(2, "0")
+      ).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+      e[r] = f;
     }
     return e;
   }
@@ -1266,8 +1356,8 @@ const xt = o.union([
       throw new Error("cannot calculate length of a non-variable length data type");
     let t = 0;
     const e = [0];
-    return this.data.forEach((n, i) => {
-      n === Y && (t++, e.push(i + 1));
+    return this.data.forEach((r, i) => {
+      r === q && (t++, e.push(i + 1));
     }), this._cachedIndexes = e, this._cachedLength = t, t;
   }
   /**
@@ -1281,11 +1371,11 @@ const xt = o.union([
    */
   convert(t, e = 0) {
     if (this.dataType.equals(t)) return this;
-    const n = new t.Array(this.length);
+    const r = new t.Array(this.length);
     for (let i = 0; i < this.length; i++)
-      n[i] = ct(this.dataType, t, this.data[i], e);
+      r[i] = ct(this.dataType, t, this.data[i], e);
     return new I({
-      data: n.buffer,
+      data: r.buffer,
       dataType: t,
       timeRange: this._timeRange,
       sampleOffset: e,
@@ -1299,10 +1389,10 @@ const xt = o.union([
       this._cachedMax = this.data[this.data.length - 1];
     else if (this.dataType.usesBigInt) {
       const t = this.data;
-      this._cachedMax = t.reduce((e, n) => e > n ? e : n);
+      this._cachedMax = t.reduce((e, r) => e > r ? e : r);
     } else {
       const t = this.data;
-      this._cachedMax = t.reduce((e, n) => e > n ? e : n);
+      this._cachedMax = t.reduce((e, r) => e > r ? e : r);
     }
     return this._cachedMax;
   }
@@ -1317,10 +1407,10 @@ const xt = o.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, n) => e < n ? e : n);
+      this._cachedMin = t.reduce((e, r) => e < r ? e : r);
     } else {
       const t = this.data;
-      this._cachedMin = t.reduce((e, n) => e < n ? e : n);
+      this._cachedMin = t.reduce((e, r) => e < r ? e : r);
     }
     return this._cachedMin;
   }
@@ -1351,45 +1441,45 @@ const xt = o.union([
     return C(this.max, -this.min);
   }
   atAlignment(t, e) {
-    const n = Number(t - this.alignment);
-    if (n < 0 || n >= this.length) {
-      if (e === !0) throw new Error(`[series] - no value at index ${n}`);
+    const r = Number(t - this.alignment);
+    if (r < 0 || r >= this.length) {
+      if (e === !0) throw new Error(`[series] - no value at index ${r}`);
       return;
     }
-    return this.at(n, e);
+    return this.at(r, e);
   }
   at(t, e) {
     if (this.dataType.isVariable) return this.atVariable(t, e ?? !1);
     t < 0 && (t = this.length + t);
-    const n = this.data[t];
-    if (n == null) {
+    const r = this.data[t];
+    if (r == null) {
       if (e === !0) throw new Error(`[series] - no value at index ${t}`);
       return;
     }
-    return C(n, this.sampleOffset);
+    return C(r, this.sampleOffset);
   }
   atVariable(t, e) {
-    let n = 0, i = 0;
+    let r = 0, i = 0;
     if (this._cachedIndexes != null)
-      n = this._cachedIndexes[t], i = this._cachedIndexes[t + 1] - 1;
+      r = 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) {
+        if (this.data[h] === q) {
           if (t === 0) {
             i = h;
             break;
           }
-          n = h + 1, t--;
+          r = h + 1, t--;
         }
-      if (i === 0 && (i = this.data.length), n >= i || t > 0) {
+      if (i === 0 && (i = this.data.length), r >= i || t > 0) {
         if (e) throw new Error(`[series] - no value at index ${t}`);
         return;
       }
     }
-    const c = this.data.slice(n, i);
-    return this.dataType.equals(g.STRING) ? new TextDecoder().decode(c) : nt(
-      JSON.parse(new TextDecoder().decode(c))
+    const f = this.data.slice(r, i);
+    return this.dataType.equals(g.STRING) ? new TextDecoder().decode(f) : nt(
+      JSON.parse(new TextDecoder().decode(f))
     );
   }
   /**
@@ -1398,29 +1488,29 @@ const xt = o.union([
    * @param value the value to search for.
    */
   binarySearch(t) {
-    let e = 0, n = this.length - 1;
-    const i = rt(t);
-    for (; e <= n; ) {
-      const c = Math.floor((e + n) / 2), h = i(this.at(c, !0), t);
-      if (h === 0) return c;
-      h < 0 ? e = c + 1 : n = c - 1;
+    let e = 0, r = this.length - 1;
+    const i = st(t);
+    for (; e <= r; ) {
+      const f = Math.floor((e + r) / 2), h = i(this.at(f, !0), t);
+      if (h === 0) return f;
+      h < 0 ? e = f + 1 : r = f - 1;
     }
     return e;
   }
   updateGLBuffer(t) {
     if (this.gl.control = t, !this.dataType.equals(g.FLOAT32))
       throw new Error("Only FLOAT32 arrays can be used in WebGL");
-    const { buffer: e, bufferUsage: n, prevBuffer: i } = this.gl;
+    const { buffer: e, bufferUsage: r, 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 !== B) {
         i === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
-        const c = this.dataType.density.size(i).valueOf(), h = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        t.bufferSubData(t.ARRAY_BUFFER, c, h.buffer), this.gl.prevBuffer = this.writePos;
+        const f = this.dataType.density.size(i).valueOf(), h = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
+        t.bufferSubData(t.ARRAY_BUFFER, f, h.buffer), this.gl.prevBuffer = this.writePos;
       } else
         t.bufferData(
           t.ARRAY_BUFFER,
-          this.underlyingData,
-          n === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
+          this.buffer,
+          r === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
         ), this.gl.prevBuffer = B;
   }
   as(t) {
@@ -1453,7 +1543,10 @@ const xt = o.union([
       key: this.key,
       dataType: this.dataType.toString(),
       sampleOffset: this.sampleOffset,
-      alignment: this.alignmentBounds,
+      alignment: {
+        lower: J(this.alignmentBounds.lower),
+        upper: J(this.alignmentBounds.upper)
+      },
       timeRange: (t = this._timeRange) == null ? void 0 : t.toString(),
       length: this.length,
       capacity: this.capacity
@@ -1479,10 +1572,10 @@ const xt = o.union([
   }
   [Symbol.iterator]() {
     if (this.dataType.isVariable) {
-      const t = new gt(this);
-      return this.dataType.equals(g.JSON) ? new mt(t) : t;
+      const t = new mt(this);
+      return this.dataType.equals(g.JSON) ? new Ot(t) : t;
     }
-    return new Ot(this);
+    return new wt(this);
   }
   slice(t, e) {
     return this.sliceSub(!1, t, e);
@@ -1502,9 +1595,9 @@ const xt = o.union([
   }
   subBytes(t, e) {
     if (t >= 0 && (e == null || e >= this.byteLength.valueOf())) return this;
-    const n = this.data.subarray(t, e);
+    const r = this.data.subarray(t, e);
     return new I({
-      data: n,
+      data: r,
       dataType: this.dataType,
       timeRange: this._timeRange,
       sampleOffset: this.sampleOffset,
@@ -1512,10 +1605,10 @@ const xt = o.union([
       alignment: this.alignment + BigInt(t)
     });
   }
-  sliceSub(t, e, n) {
-    if (e <= 0 && (n == null || n >= this.length)) return this;
+  sliceSub(t, e, r) {
+    if (e <= 0 && (r == null || r >= this.length)) return this;
     let i;
-    return t ? i = this.data.subarray(e, n) : i = this.data.slice(e, n), new I({
+    return t ? i = this.data.subarray(e, r) : i = this.data.slice(e, r), new I({
       data: i,
       dataType: this.dataType,
       timeRange: this._timeRange,
@@ -1535,22 +1628,27 @@ const xt = o.union([
     });
   }
 };
-s(I, "crudeZ", o.object({
+s(I, "crudeZ", l.object({
   timeRange: E.z.optional(),
   dataType: g.z,
-  alignment: at.optional(),
-  data: o.union([ht, dt, o.instanceof(ArrayBuffer)]),
-  glBufferUsage: lt.optional().default("static").optional()
+  alignment: ut.optional(),
+  data: l.union([
+    dt,
+    gt,
+    l.instanceof(ArrayBuffer),
+    l.instanceof(Uint8Array)
+  ]),
+  glBufferUsage: ft.optional().default("static").optional()
 })), s(I, "z", I.crudeZ.transform((t) => new I(t)));
 let V = I;
 class G {
-  constructor(t, e, n) {
+  constructor(t, e, r) {
     s(this, "series");
     s(this, "end");
     s(this, "index");
     this.series = t;
     const i = L(0, t.length);
-    this.end = k(i, n), this.index = k(i, e);
+    this.end = k(i, r), this.index = k(i, e);
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
@@ -1559,7 +1657,7 @@ class G {
     return this;
   }
 }
-class gt {
+class mt {
   constructor(t) {
     s(this, "series");
     s(this, "index");
@@ -1572,19 +1670,19 @@ class gt {
   }
   next() {
     const t = this.index, e = this.series.data;
-    for (; this.index < e.length && e[this.index] !== Y; ) this.index++;
-    const n = this.index;
-    return t === n ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(t, n)) });
+    for (; this.index < e.length && e[this.index] !== q; ) 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)) });
   }
   [Symbol.iterator]() {
     return this;
   }
 }
-var J, W;
-class mt {
+var W, j;
+class Ot {
   constructor(t) {
     s(this, "wrapped");
-    s(this, J, "JSONSeriesIterator");
+    s(this, W, "JSONSeriesIterator");
     this.wrapped = t;
   }
   next() {
@@ -1594,16 +1692,16 @@ class mt {
       value: $.decodeString(t.value)
     };
   }
-  [(W = Symbol.iterator, J = Symbol.toStringTag, W)]() {
+  [(j = Symbol.iterator, W = Symbol.toStringTag, j)]() {
     return this;
   }
 }
-var j, K;
-class Ot {
+var H, K;
+class wt {
   constructor(t) {
     s(this, "series");
     s(this, "index");
-    s(this, j, "SeriesIterator");
+    s(this, H, "SeriesIterator");
     this.series = t, this.index = 0;
   }
   next() {
@@ -1612,18 +1710,18 @@ class Ot {
       value: this.series.at(this.index++, !0)
     };
   }
-  [(K = Symbol.iterator, j = Symbol.toStringTag, K)]() {
+  [(K = Symbol.iterator, H = Symbol.toStringTag, K)]() {
     return this;
   }
 }
-const C = (l, t) => typeof l == "bigint" && typeof t == "bigint" || typeof l == "number" && typeof t == "number" ? l + t : t === 0 ? l : l === 0 ? t : Number(l) + Number(t);
-class Ct {
+const C = (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);
+class Dt {
   constructor(t) {
     s(this, "series");
     if (t.length !== 0) {
       const e = t[0].dataType;
-      for (let n = 1; n < t.length; n++)
-        if (!t[n].dataType.equals(e))
+      for (let r = 1; r < t.length; r++)
+        if (!t[r].dataType.equals(e))
           throw new Error("[multi-series] - series must have the same data type");
     }
     this.series = t;
@@ -1664,38 +1762,38 @@ class Ct {
       if (e) throw new Error(`[series] - no value at alignment ${t}`);
       return;
     }
-    for (const n of this.series)
-      if (D(n.alignmentBounds, t))
-        return n.atAlignment(t, e);
+    for (const r of this.series)
+      if (D(r.alignmentBounds, t))
+        return r.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 n of this.series) {
-      if (t < n.length) return n.at(t, e);
-      t -= n.length;
+    for (const r of this.series) {
+      if (t < r.length) return r.at(t, e);
+      t -= r.length;
     }
     if (e) throw new Error(`[series] - no value at index ${t}`);
   }
   subIterator(t, e) {
-    return new F(this, t, e ?? this.length);
+    return new P(this, t, e ?? this.length);
   }
   subAlignmentIterator(t, e) {
     if (t >= this.alignmentBounds.upper || e <= this.alignmentBounds.lower)
-      return q;
-    let n = 0;
-    for (let c = 0; c < this.series.length; c++) {
-      const h = this.series[c];
+      return Y;
+    let r = 0;
+    for (let f = 0; f < this.series.length; f++) {
+      const h = this.series[f];
       if (t < h.alignment) break;
-      if (t >= h.alignmentBounds.upper) n += h.length;
+      if (t >= h.alignmentBounds.upper) r += h.length;
       else if (D(h.alignmentBounds, t)) {
-        n += Number(t - h.alignment);
+        r += Number(t - h.alignment);
         break;
       }
     }
     let i = 0;
-    for (let c = 0; c < this.series.length; c++) {
-      const h = this.series[c];
+    for (let f = 0; f < this.series.length; f++) {
+      const h = this.series[f];
       if (e < h.alignment) break;
       if (e >= h.alignmentBounds.upper) i += h.length;
       else if (D(h.alignmentBounds, e)) {
@@ -1703,21 +1801,21 @@ class Ct {
         break;
       }
     }
-    return new F(this, n, i);
+    return new P(this, r, i);
   }
   subAlignmentSpanIterator(t, e) {
-    if (t >= this.alignmentBounds.upper) return q;
-    let n = 0;
+    if (t >= this.alignmentBounds.upper) return Y;
+    let r = 0;
     for (let i = 0; i < this.series.length; i++) {
-      const c = this.series[i];
-      if (t < c.alignment) break;
-      if (t >= c.alignmentBounds.upper) n += c.length;
-      else if (D(c.alignmentBounds, t)) {
-        n += Number(t - c.alignment);
+      const f = this.series[i];
+      if (t < f.alignment) break;
+      if (t >= f.alignmentBounds.upper) r += f.length;
+      else if (D(f.alignmentBounds, t)) {
+        r += Number(t - f.alignment);
         break;
       }
     }
-    return new F(this, n, n + e);
+    return new P(this, r, r + e);
   }
   get byteLength() {
     return new x(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
@@ -1725,17 +1823,17 @@ class Ct {
   get data() {
     const t = new this.dataType.Array(this.length);
     let e = 0;
-    for (const n of this.series)
-      t.set(n.data, e), e += n.length;
-    return new this.dataType.Array(t);
+    for (const r of this.series)
+      t.set(r.data, e), e += r.length;
+    return new this.dataType.Array(t.buffer);
   }
   traverseAlignment(t, e) {
-    const n = this.series.map((i) => i.alignmentBounds);
-    return st(n, t, e);
+    const r = this.series.map((i) => i.alignmentBounds);
+    return it(r, t, e);
   }
   distance(t, e) {
-    const n = this.series.map((i) => i.alignmentBounds);
-    return it(n, t, e);
+    const r = this.series.map((i) => i.alignmentBounds);
+    return at(r, t, e);
   }
   [Symbol.iterator]() {
     return this.series.length === 0 ? {
@@ -1745,7 +1843,7 @@ class Ct {
     } : new yt(this.series);
   }
 }
-var z, H;
+var z, X;
 class yt {
   constructor(t) {
     s(this, "series");
@@ -1758,16 +1856,16 @@ class yt {
     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());
   }
-  [(H = Symbol.iterator, z = Symbol.toStringTag, H)]() {
+  [(X = Symbol.iterator, z = Symbol.toStringTag, X)]() {
     return this;
   }
 }
-class F {
-  constructor(t, e, n) {
+class P {
+  constructor(t, e, r) {
     s(this, "series");
     s(this, "index");
     s(this, "end");
-    this.series = t, this.end = n, this.index = e;
+    this.series = t, this.end = r, this.index = e;
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
@@ -1776,20 +1874,25 @@ class F {
     return this;
   }
 }
+const J = (o) => {
+  const t = o >> 32n, e = o & 0xffffffffn;
+  return { domain: t, sample: e };
+};
 export {
   b as D,
-  Ct as M,
-  P as R,
+  Dt as M,
+  F as R,
   V as S,
   m as T,
   C as a,
-  y as b,
+  w as b,
   E as c,
   g as d,
   x as e,
-  _ as f,
+  tt as f,
   ct as g,
-  Rt as h,
-  ft as i,
-  xt as t
+  xt as h,
+  ht as i,
+  Ct as s,
+  Lt as t
 };