@synnaxlabs/x 0.32.0 → 0.34.0

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

@@ -1,28 +1,28 @@
-var j = Object.defineProperty;
-var K = (f, t, e) => t in f ? j(f, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : f[t] = e;
-var s = (f, t, e) => K(f, typeof t != "symbol" ? t + "" : t, e);
+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";
-import { J as L } from "./index-B5THJ1eb.js";
-import { s as z } from "./index-Duv1uH08.js";
-import { n as H } from "./index-B3BUDIdi.js";
-import { c as $ } from "./bounds-CpboA0q6.js";
-import "./box-xRqO6NvI.js";
+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 "./dimensions-D-1PnJVI.js";
 import "./base-DnZzEvvz.js";
-import "./location-DjcaXEps.js";
-import "./scale-qw6vRO4s.js";
+import "./location-CI9x53qR.js";
+import "./scale-DNQE1LMm.js";
 import "./xy-CrgPnICw.js";
-import { b as X } from "./zodutil-qNM8aVYC.js";
-let Q = (f, t = 21) => (e = t) => {
-  let r = "", u = e;
-  for (; u--; )
-    r += f[Math.random() * f.length | 0];
-  return r;
+import { b as at } from "./zodutil-Tmuc4CNq.js";
+let ut = (l, t = 21) => (e = t) => {
+  let n = "", i = e;
+  for (; i--; )
+    n += l[Math.random() * l.length | 0];
+  return n;
 };
-const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k = Q(_, 11), Nt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const ot = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", X = ut(ot, 11), Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  id: k
-}, Symbol.toStringTag, { value: "Module" })), tt = o.enum(["static", "dynamic"]), J = (f, t) => {
+  id: X
+}, Symbol.toStringTag, { value: "Module" })), lt = o.enum(["static", "dynamic"]), Q = (l, t) => {
   const e = new m(t);
   if (![
     y.DAY,
@@ -32,30 +32,30 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
     y.MILLISECOND,
     y.MICROSECOND,
     y.NANOSECOND
-  ].some((u) => u.equals(e)))
+  ].some((i) => i.equals(e)))
     throw new Error(
       "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
     );
-  const r = f.valueOf() % e.valueOf();
-  return f instanceof m ? new m(r) : new y(r);
-}, i = class i {
+  const n = l.valueOf() % e.valueOf();
+  return l instanceof m ? new m(n) : new y(n);
+}, a = class a {
   constructor(t, e = "UTC") {
     s(this, "value");
     s(this, "encodeValue", !0);
-    if (t == null) this.value = i.now().valueOf();
+    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 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;
     }
   }
-  static parseDate([t = 1970, e = 1, r = 1]) {
-    const u = new Date(t, e - 1, r, 0, 0, 0, 0);
-    return new i(BigInt(u.getTime()) * i.MILLISECOND.valueOf()).truncate(i.DAY).valueOf();
+  static parseDate([t = 1970, e = 1, n = 1]) {
+    const i = new Date(t, e - 1, n, 0, 0, 0, 0);
+    return new a(BigInt(i.getTime()) * a.MILLISECOND.valueOf()).truncate(a.DAY).valueOf();
   }
   encode() {
     return this.value.toString();
@@ -64,18 +64,18 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
     return this.value;
   }
   static parseTimeString(t, e = "UTC") {
-    const [r, u, d] = t.split(":");
-    let g = "00", S = "00";
-    d != null && ([g, S] = d.split("."));
-    let O = i.hours(parseInt(r ?? "00", 10)).add(i.minutes(parseInt(u ?? "00", 10))).add(i.seconds(parseInt(g ?? "00", 10))).add(i.milliseconds(parseInt(S ?? "00", 10)));
-    return e === "local" && (O = O.add(i.utcOffset)), O.valueOf();
+    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")));
+    return e === "local" && (O = O.add(a.utcOffset)), O.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 n = new Date(t);
+    return t.includes(":") || n.setUTCHours(0, 0, 0, 0), new a(
+      BigInt(n.getTime()) * a.MILLISECOND.valueOf(),
       e
     ).valueOf();
   }
@@ -100,19 +100,19 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
     }
   }
   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 n = this.toISOString(e);
+    return t ? n.slice(11, 23) : n.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" }), n = t.toLocaleString("default", { day: "numeric" });
+    return `${e} ${n}`;
   }
   static get utcOffset() {
     return new y(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * i.MINUTE.valueOf()
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * a.MINUTE.valueOf()
     );
   }
   /**
@@ -121,7 +121,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    * @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() {
@@ -134,7 +134,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    * @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.
@@ -154,7 +154,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   valid, regardless of the TimeStamp order.
    */
   range(t) {
-    return new B(this, t).makeValid();
+    return new E(this, t).makeValid();
   }
   /**
    * Creates a TimeRange starting at the TimeStamp and spanning the given
@@ -183,7 +183,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   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.
@@ -193,7 +193,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   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.
@@ -203,7 +203,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   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.
@@ -213,7 +213,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   false otherwise.
    */
   beforeEq(t) {
-    return this.valueOf() <= new i(t).valueOf();
+    return this.valueOf() <= new a(t).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeStamp.
@@ -223,7 +223,7 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   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.
@@ -233,13 +233,13 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    *   TimeSpan.
    */
   sub(t) {
-    return new i(this.valueOf() - BigInt(t.valueOf()));
+    return new a(this.valueOf() - BigInt(t.valueOf()));
   }
   /**
    * @returns The number of milliseconds since the unix epoch.
    */
   milliseconds() {
-    return Number(this.valueOf()) / Number(i.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
   }
   toString() {
     return this.date().toISOString();
@@ -256,11 +256,11 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(t) {
-    return J(this, t);
+    return Q(this, t);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(y.DAY).equals(i.now().truncate(y.DAY));
+    return this.truncate(y.DAY).equals(a.now().truncate(y.DAY));
   }
   truncate(t) {
     return this.sub(this.remainder(t));
@@ -271,78 +271,84 @@ const _ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", k =
    * JavaScript can do).
    */
   static now() {
-    return new i(/* @__PURE__ */ new Date());
+    return new a(/* @__PURE__ */ new Date());
   }
   static max(...t) {
-    let e = i.MIN;
-    for (const r of t) {
-      const u = new i(r);
-      u.after(e) && (e = u);
+    let e = a.MIN;
+    for (const n of t) {
+      const i = new a(n);
+      i.after(e) && (e = i);
     }
     return e;
   }
   static min(...t) {
-    let e = i.MAX;
-    for (const r of t) {
-      const u = new i(r);
-      u.before(e) && (e = u);
+    let e = a.MAX;
+    for (const n of t) {
+      const i = new a(n);
+      i.before(e) && (e = i);
     }
     return e;
   }
   /** @returns a new TimeStamp n nanoseconds after the unix epoch */
   static nanoseconds(t) {
-    return new i(t);
+    return new a(t);
   }
   /** @returns a new TimeStamp n microseconds after the unix epoch */
   static microseconds(t) {
-    return i.nanoseconds(t * 1e3);
+    return a.nanoseconds(t * 1e3);
   }
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
   static milliseconds(t) {
-    return i.microseconds(t * 1e3);
+    return a.microseconds(t * 1e3);
   }
   /** @returns a new TimeStamp n seconds after the unix epoch */
   static seconds(t) {
-    return i.milliseconds(t * 1e3);
+    return a.milliseconds(t * 1e3);
   }
   /** @returns a new TimeStamp n minutes after the unix epoch */
   static minutes(t) {
-    return i.seconds(t * 60);
+    return a.seconds(t * 60);
   }
   /** @returns a new TimeStamp n hours after the unix epoch */
   static hours(t) {
-    return i.minutes(t * 60);
+    return a.minutes(t * 60);
   }
   /** @returns a new TimeStamp n days after the unix epoch */
   static days(t) {
-    return i.hours(t * 24);
+    return a.hours(t * 24);
   }
 };
 /* 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", o.union([
-  o.object({ value: o.bigint() }).transform((t) => new i(t.value)),
-  o.string().transform((t) => new i(BigInt(t))),
-  o.instanceof(Number).transform((t) => new i(t)),
-  o.number().transform((t) => new i(t)),
-  o.instanceof(i)
+s(a, "NANOSECOND", a.nanoseconds(1)), /** One microsecond after the unix epoch */
+s(a, "MICROSECOND", a.microseconds(1)), /** One millisecond after the unix epoch */
+s(a, "MILLISECOND", a.milliseconds(1)), /** One second after the unix epoch */
+s(a, "SECOND", a.seconds(1)), /** One minute after the unix epoch */
+s(a, "MINUTE", a.minutes(1)), /** One hour after the unix epoch */
+s(a, "HOUR", a.hours(1)), /** One day after the unix epoch */
+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)
 ]));
-let m = i;
-const a = class a {
+let m = a;
+const u = class u {
   constructor(t) {
     s(this, "value");
     s(this, "encodeValue", !0);
     typeof t == "number" && (t = Math.trunc(t.valueOf())), this.value = BigInt(t.valueOf());
   }
+  static fromSeconds(t) {
+    return t instanceof u ? t : t instanceof P ? 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);
+  }
   encode() {
     return this.value.toString();
   }
@@ -350,52 +356,52 @@ const a = class a {
     return this.value;
   }
   lessThan(t) {
-    return this.valueOf() < new a(t).valueOf();
+    return this.valueOf() < new u(t).valueOf();
   }
   greaterThan(t) {
-    return this.valueOf() > new a(t).valueOf();
+    return this.valueOf() > new u(t).valueOf();
   }
   lessThanOrEqual(t) {
-    return this.valueOf() <= new a(t).valueOf();
+    return this.valueOf() <= new u(t).valueOf();
   }
   greaterThanOrEqual(t) {
-    return this.valueOf() >= new a(t).valueOf();
+    return this.valueOf() >= new u(t).valueOf();
   }
   remainder(t) {
-    return J(this, t);
+    return Q(this, t);
   }
   truncate(t) {
-    return new a(
+    return new u(
       BigInt(Math.trunc(Number(this.valueOf() / t.valueOf()))) * t.valueOf()
     );
   }
   toString() {
-    const t = this.truncate(a.DAY), e = this.truncate(a.HOUR), r = this.truncate(a.MINUTE), u = this.truncate(a.SECOND), d = this.truncate(a.MILLISECOND), g = this.truncate(a.MICROSECOND), S = this.truncate(a.NANOSECOND), O = t, N = e.sub(t), p = r.sub(e), c = u.sub(r), M = d.sub(u), U = g.sub(d), D = S.sub(g);
+    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);
     let A = "";
-    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 `), D.isZero || (A += `${D.nanoseconds}ns`), A.trim();
+    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();
   }
   /** @returns the decimal number of days in the timespan */
   get days() {
-    return Number(this.valueOf()) / Number(a.DAY.valueOf());
+    return Number(this.valueOf()) / Number(u.DAY.valueOf());
   }
   /** @returns the decimal number of hours in the timespan */
   get hours() {
-    return Number(this.valueOf()) / Number(a.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(u.HOUR.valueOf());
   }
   /** @returns the decimal number of minutes in the timespan */
   get minutes() {
-    return Number(this.valueOf()) / Number(a.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(u.MINUTE.valueOf());
   }
   /** @returns The number of seconds in the TimeSpan. */
   get seconds() {
-    return Number(this.valueOf()) / Number(a.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(u.SECOND.valueOf());
   }
   /** @returns The number of milliseconds in the TimeSpan. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(u.MILLISECOND.valueOf());
   }
   get microseconds() {
-    return Number(this.valueOf()) / Number(a.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(u.MICROSECOND.valueOf());
   }
   get nanoseconds() {
     return Number(this.valueOf());
@@ -414,7 +420,7 @@ const a = class a {
    * @returns True if the TimeSpans are equal, false otherwise.
    */
   equals(t) {
-    return this.valueOf() === new a(t).valueOf();
+    return this.valueOf() === new u(t).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeSpan.
@@ -422,7 +428,7 @@ const a = class a {
    * @returns A new TimeSpan representing the sum of the two TimeSpans.
    */
   add(t) {
-    return new a(this.valueOf() + new a(t).valueOf());
+    return new u(this.valueOf() + new u(t).valueOf());
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -430,7 +436,7 @@ const a = class a {
    * @param other
    */
   sub(t) {
-    return new a(this.valueOf() - new a(t).valueOf());
+    return new u(this.valueOf() - new u(t).valueOf());
   }
   /**
    * Creates a TimeSpan representing the given number of nanoseconds.
@@ -439,7 +445,7 @@ const a = class a {
    * @returns A TimeSpan representing the given number of nanoseconds.
    */
   static nanoseconds(t = 1) {
-    return new a(t);
+    return new u(t);
   }
   /**
    * Creates a TimeSpan representing the given number of microseconds.
@@ -448,7 +454,7 @@ const a = class a {
    * @returns A TimeSpan representing the given number of microseconds.
    */
   static microseconds(t = 1) {
-    return a.nanoseconds(t * 1e3);
+    return u.nanoseconds(R(t, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
@@ -457,7 +463,7 @@ const a = class a {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static milliseconds(t = 1) {
-    return a.microseconds(t * 1e3);
+    return u.microseconds(R(t, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of seconds.
@@ -466,7 +472,7 @@ const a = class a {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static seconds(t = 1) {
-    return a.milliseconds(t * 1e3);
+    return u.milliseconds(R(t, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of minutes.
@@ -474,8 +480,8 @@ const a = class a {
    * @param value - The number of minutes.
    * @returns A TimeSpan representing the given number of minutes.
    */
-  static minutes(t) {
-    return a.seconds(t.valueOf() * 60);
+  static minutes(t = 1) {
+    return u.seconds(R(t, 60));
   }
   /**
    * Creates a TimeSpan representing the given number of hours.
@@ -484,7 +490,7 @@ const a = class a {
    * @returns A TimeSpan representing the given number of hours.
    */
   static hours(t) {
-    return a.minutes(t * 60);
+    return u.minutes(R(t, 60));
   }
   /**
    * Creates a TimeSpan representing the given number of days.
@@ -493,28 +499,28 @@ const a = class a {
    * @returns A TimeSpan representing the given number of days.
    */
   static days(t) {
-    return a.hours(t * 24);
+    return u.hours(R(t, 24));
   }
 };
 /** A nanosecond. */
-s(a, "NANOSECOND", a.nanoseconds(1)), /** A microsecond. */
-s(a, "MICROSECOND", a.microseconds(1)), /** A millisecond. */
-s(a, "MILLISECOND", a.milliseconds(1)), /** A second. */
-s(a, "SECOND", a.seconds(1)), /** A minute. */
-s(a, "MINUTE", a.minutes(1)), /** Represents an hour. */
-s(a, "HOUR", a.hours(1)), /** Represents a day. */
-s(a, "DAY", a.days(1)), /** The maximum possible value for a TimeSpan. */
-s(a, "MAX", new a((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-s(a, "MIN", new a(0)), /** The zero value for a TimeSpan. */
-s(a, "ZERO", new a(0)), /** A zod schema for validating and transforming timespans */
-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(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", 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)
 ]));
-let y = a;
+let y = u;
 const v = class v extends Number {
   constructor(t) {
     t instanceof Number ? super(t.valueOf()) : super(t);
@@ -598,7 +604,7 @@ s(v, "z", o.union([
   o.instanceof(Number).transform((t) => new v(t)),
   o.instanceof(v)
 ]));
-let q = v;
+let P = v;
 const w = class w extends Number {
   /**
    * Creates a Density representing the given number of bytes per value.
@@ -614,7 +620,7 @@ const w = class w extends Number {
     return t.valueOf() / this.valueOf();
   }
   size(t) {
-    return new C(t * this.valueOf());
+    return new x(t * this.valueOf());
   }
 };
 /** Unknown/Invalid Density. */
@@ -630,7 +636,7 @@ s(w, "z", o.union([
   o.instanceof(w)
 ]));
 let b = w;
-const I = class I {
+const T = class T {
   /**
    * Creates a TimeRange from the given start and end TimeStamps.
    *
@@ -698,7 +704,7 @@ const I = class I {
    * @returns A TimeRange with the start and end swapped.
    */
   swap() {
-    return new I(this.end, this.start);
+    return new T(this.end, this.start);
   }
   /**
    * Checks if the TimeRange is equal to the given TimeRange.
@@ -725,52 +731,51 @@ const I = class I {
    */
   overlapsWith(t, e = y.ZERO) {
     t = t.makeValid();
-    const r = this.makeValid();
+    const n = this.makeValid();
     if (this.equals(t)) return !0;
-    if (t.end.equals(r.start) || r.end.equals(t.start)) return !1;
-    const u = m.max(r.start, t.start), d = m.min(r.end, t.end);
-    return d.before(u) ? !1 : new y(d.sub(u)).greaterThanOrEqual(e);
+    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);
   }
   roughlyEquals(t, e) {
-    let r = this.start.sub(t.start).valueOf(), u = this.end.sub(t.end).valueOf();
-    return r < 0 && (r = -r), u < 0 && (u = -u), r <= e.valueOf() && u <= e.valueOf();
+    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();
   }
   contains(t) {
-    return t instanceof I ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
+    return t instanceof T ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
   }
   boundBy(t) {
-    const e = new I(this.start, this.end);
+    const e = new T(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;
   }
 };
 /** The maximum possible time range. */
-s(I, "MAX", new I(m.MIN, m.MAX)), /** The minimum possible time range. */
-s(I, "MIN", new I(m.MAX, m.MIN)), /** A zero time range. */
-s(I, "ZERO", new I(m.ZERO, m.ZERO)), /** A zod schema for validating and transforming time ranges */
-s(I, "z", o.union([
-  o.object({ start: m.z, end: m.z }).transform((t) => new I(t.start, t.end)),
-  o.instanceof(I)
+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)
 ]));
-let B = I;
-const n = class n extends String {
+let E = T;
+const r = class r extends String {
   constructor(t) {
-    if (t instanceof n || typeof t == "string" || typeof t.valueOf() == "string") {
+    if (t instanceof r || typeof t == "string" || typeof t.valueOf() == "string") {
       super(t.valueOf());
       return;
-    } else {
-      const e = n.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
-      if (e != null) {
-        super(e.valueOf());
-        return;
-      }
     }
-    throw super(n.UNKNOWN.valueOf()), new Error(`unable to find data type for ${t.toString()}`);
+    const e = r.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()}`);
   }
   /**
    * @returns the TypedArray constructor for the DataType.
    */
   get Array() {
-    const t = n.ARRAY_CONSTRUCTORS.get(this.toString());
+    const t = r.ARRAY_CONSTRUCTORS.get(this.toString());
     if (t == null)
       throw new Error(`unable to find array constructor for ${this.valueOf()}`);
     return t;
@@ -792,10 +797,10 @@ const n = class n extends String {
     return this.valueOf();
   }
   get isVariable() {
-    return this.equals(n.JSON) || this.equals(n.STRING);
+    return this.equals(r.JSON) || this.equals(r.STRING);
   }
   get isNumeric() {
-    return !this.isVariable && !this.equals(n.UUID);
+    return !this.isVariable && !this.equals(r.UUID);
   }
   get isInteger() {
     return this.toString().startsWith("int");
@@ -804,7 +809,7 @@ const n = class n extends String {
     return this.toString().startsWith("float");
   }
   get density() {
-    const t = n.DENSITIES.get(this.toString());
+    const t = r.DENSITIES.get(this.toString());
     if (t == null) throw new Error(`unable to find density for ${this.valueOf()}`);
     return t;
   }
@@ -829,92 +834,92 @@ const n = class n extends String {
     return this.toString();
   }
   get usesBigInt() {
-    return n.BIG_INT_TYPES.some((t) => t.equals(this));
+    return r.BIG_INT_TYPES.some((t) => t.equals(this));
   }
 };
 /** 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
+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
  * 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
+s(r, "STRING", new r("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([
-  [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]
+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]
 ])), /** All the data types. */
-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", o.union([
-  o.string().transform((t) => new n(t)),
-  o.instanceof(n)
+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)
 ]));
-let h = n;
-const l = class l extends Number {
+let g = r;
+const d = class d extends Number {
   constructor(t) {
     super(t.valueOf());
   }
@@ -927,33 +932,33 @@ const l = class l extends Number {
     return this.valueOf() < t.valueOf();
   }
   add(t) {
-    return l.bytes(this.valueOf() + t.valueOf());
+    return d.bytes(this.valueOf() + t.valueOf());
   }
   sub(t) {
-    return l.bytes(this.valueOf() - t.valueOf());
+    return d.bytes(this.valueOf() - t.valueOf());
   }
   truncate(t) {
-    return new l(Math.trunc(this.valueOf() / t.valueOf()) * t.valueOf());
+    return new d(Math.trunc(this.valueOf() / t.valueOf()) * t.valueOf());
   }
   remainder(t) {
-    return l.bytes(this.valueOf() % t.valueOf());
+    return d.bytes(this.valueOf() % t.valueOf());
   }
   get gigabytes() {
-    return this.valueOf() / l.GIGABYTE.valueOf();
+    return this.valueOf() / d.GIGABYTE.valueOf();
   }
   get megabytes() {
-    return this.valueOf() / l.MEGABYTE.valueOf();
+    return this.valueOf() / d.MEGABYTE.valueOf();
   }
   get kilobytes() {
-    return this.valueOf() / l.KILOBYTE.valueOf();
+    return this.valueOf() / d.KILOBYTE.valueOf();
   }
   get terabytes() {
-    return this.valueOf() / l.TERABYTE.valueOf();
+    return this.valueOf() / d.TERABYTE.valueOf();
   }
   toString() {
-    const t = this.truncate(l.TERABYTE), e = this.truncate(l.GIGABYTE), r = this.truncate(l.MEGABYTE), u = this.truncate(l.KILOBYTE), d = this.truncate(l.BYTE), g = t, S = e.sub(t), O = r.sub(e), N = u.sub(r), p = d.sub(u);
-    let c = "";
-    return g.isZero || (c += `${g.terabytes}TB `), S.isZero || (c += `${S.gigabytes}GB `), O.isZero || (c += `${O.megabytes}MB `), N.isZero || (c += `${N.kilobytes}KB `), (!p.isZero || c === "") && (c += `${p.valueOf()}B`), c.trim();
+    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();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -962,7 +967,7 @@ const l = class l extends Number {
    * @returns A Size representing the given number of bytes.
    */
   static bytes(t = 1) {
-    return new l(t);
+    return new d(t);
   }
   /**
    * Creates a Size from the given number if kilobytes.
@@ -971,7 +976,7 @@ const l = class l extends Number {
    * @returns A Size representing the given number of kilobytes.
    */
   static kilobytes(t = 1) {
-    return l.bytes(t.valueOf() * 1e3);
+    return d.bytes(t.valueOf() * 1e3);
   }
   /**
    * Creates a Size from the given number of megabytes.
@@ -980,7 +985,7 @@ const l = class l extends Number {
    * @returns A Size representing the given number of megabytes.
    */
   static megabytes(t = 1) {
-    return l.kilobytes(t.valueOf() * 1e3);
+    return d.kilobytes(t.valueOf() * 1e3);
   }
   /**
    * Creates a Size from the given number of gigabytes.
@@ -989,7 +994,7 @@ const l = class l extends Number {
    * @returns A Size representing the given number of gigabytes.
    */
   static gigabytes(t = 1) {
-    return l.megabytes(t.valueOf() * 1e3);
+    return d.megabytes(t.valueOf() * 1e3);
   }
   /**
    * Creates a Size from the given number of terabytes.
@@ -998,25 +1003,25 @@ const l = class l extends Number {
    * @returns  A Size representing the given number of terabytes.
    */
   static terabytes(t) {
-    return l.gigabytes(t.valueOf() * 1e3);
+    return d.gigabytes(t.valueOf() * 1e3);
   }
   get isZero() {
     return this.valueOf() === 0;
   }
 };
 /** A single byte */
-s(l, "BYTE", new l(1)), /** A kilobyte */
-s(l, "KILOBYTE", l.kilobytes(1)), /** A megabyte */
-s(l, "MEGABYTE", l.megabytes(1)), /** A gigabyte */
-s(l, "GIGABYTE", l.gigabytes(1)), /** A terabyte. */
-s(l, "TERABYTE", l.terabytes(1)), /** The zero value for Size */
-s(l, "ZERO", new l(0)), /** A zod schema for a Size. */
-s(l, "z", o.union([
-  o.number().transform((t) => new l(t)),
-  o.instanceof(l)
+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", o.union([
+  o.number().transform((t) => new d(t)),
+  o.instanceof(d)
 ]));
-let C = l;
-const St = o.union([
+let x = d;
+const xt = o.union([
   o.instanceof(Uint8Array),
   o.instanceof(Uint16Array),
   o.instanceof(Uint32Array),
@@ -1027,14 +1032,17 @@ const St = o.union([
   o.instanceof(Int16Array),
   o.instanceof(Int32Array),
   o.instanceof(BigInt64Array)
-]), W = (f) => {
-  const t = typeof f;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || f instanceof m || f instanceof y || f instanceof Date;
-}, et = (f, t, e, r = 0) => f.usesBigInt && !t.usesBigInt ? Number(e) - Number(r) : !f.usesBigInt && t.usesBigInt ? BigInt(e) - BigInt(r) : R(e, -r), rt = (f) => f == null ? !1 : Array.isArray(f) || f instanceof ArrayBuffer || ArrayBuffer.isView(f) && !(f instanceof DataView) || f instanceof x ? !0 : W(f), E = -1, nt = o.string().transform(
-  (f) => new Uint8Array(
-    atob(f).split("").map((t) => t.charCodeAt(0))
+]), _ = (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,
+  next: () => ({ done: !0, value: void 0 })
+}, ht = o.string().transform(
+  (l) => new Uint8Array(
+    atob(l).split("").map((t) => t.charCodeAt(0))
   ).buffer
-), st = o.union([o.null(), o.undefined()]).transform(() => new Uint8Array().buffer), T = class T {
+), dt = o.union([o.null(), o.undefined()]).transform(() => new Uint8Array().buffer), Y = 10, I = class I {
   constructor(t) {
     s(this, "key", "");
     s(this, "isSynnaxSeries", !0);
@@ -1059,104 +1067,107 @@ const St = o.union([
     /** A cached maximum value. */
     s(this, "_cachedMax");
     /** The write position of the buffer. */
-    s(this, "writePos", E);
+    s(this, "writePos", B);
     /** Tracks the number of entities currently using this array. */
     s(this, "_refCount", 0);
+    /** Caches the length of the array for variable length data types. */
     s(this, "_cachedLength");
-    rt(t) && (t = { data: t });
+    /** Caches the indexes of the array for variable length data types. */
+    s(this, "_cachedIndexes");
+    ft(t) && (t = { data: t });
     const {
       dataType: e,
-      timeRange: r,
-      sampleOffset: u = 0,
-      glBufferUsage: d = "static",
-      alignment: g = 0n,
-      key: S = k()
+      timeRange: n,
+      sampleOffset: i = 0,
+      glBufferUsage: c = "static",
+      alignment: h = 0n,
+      key: S = X()
     } = t, O = t.data ?? [];
-    if (O instanceof T || typeof O == "object" && "isSynnaxSeries" in O && O.isSynnaxSeries === !0) {
-      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;
+    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;
       return;
     }
-    const N = W(O), p = Array.isArray(O);
-    if (e != null) this.dataType = new h(e);
+    const N = _(O), p = Array.isArray(O);
+    if (e != null) this.dataType = new g(e);
     else {
       if (O instanceof ArrayBuffer)
         throw new Error(
           "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
         );
       if (p || N) {
-        let c = O;
+        let f = 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."
             );
-          c = O[0];
+          f = O[0];
         }
-        if (typeof c == "string") this.dataType = h.STRING;
-        else if (typeof c == "number") this.dataType = h.FLOAT64;
-        else if (typeof c == "bigint") this.dataType = h.INT64;
-        else if (typeof c == "boolean") this.dataType = h.BOOLEAN;
-        else if (c instanceof m || c instanceof Date || c instanceof m)
-          this.dataType = h.TIMESTAMP;
-        else if (typeof c == "object") this.dataType = h.JSON;
+        if (typeof f == "string") this.dataType = g.STRING;
+        else if (typeof f == "number") this.dataType = g.FLOAT64;
+        else if (typeof f == "bigint") this.dataType = g.INT64;
+        else if (typeof f == "boolean") this.dataType = g.BOOLEAN;
+        else if (f instanceof m || f instanceof Date || f instanceof m)
+          this.dataType = g.TIMESTAMP;
+        else if (typeof f == "object") this.dataType = g.JSON;
         else
           throw new Error(
-            `cannot infer data type of ${typeof c} when constructing a Series from a JS array`
+            `cannot infer data type of ${typeof f} when constructing a Series from a JS array`
           );
-      } else this.dataType = new h(O);
+      } else this.dataType = new g(O);
     }
     if (!p && !N) this._data = O;
     else {
-      let c = N ? [O] : O;
-      const M = c[0];
-      (M instanceof m || M instanceof Date || M instanceof y) && (c = c.map((U) => new m(U).valueOf())), this.dataType.equals(h.STRING) ? (this._cachedLength = c.length, this._data = new TextEncoder().encode(c.join(`
-`) + `
-`)) : this.dataType.equals(h.JSON) ? (this._cachedLength = c.length, this._data = new TextEncoder().encode(
-        c.map((U) => L.encodeString(U)).join(`
-`) + `
+      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(`
+`)}
+`)) : this.dataType.equals(g.JSON) ? (this._cachedLength = f.length, this._data = new TextEncoder().encode(
+        `${f.map((U) => $.encodeString(U)).join(`
+`)}
 `
-      )) : this._data = new this.dataType.Array(c).buffer;
+      )) : this._data = new this.dataType.Array(f).buffer;
     }
-    this.key = S, this.alignment = g, this.sampleOffset = u ?? 0, this._timeRange = r, this.gl = {
+    this.key = S, this.alignment = h, this.sampleOffset = i ?? 0, this._timeRange = n, this.gl = {
       control: null,
       buffer: null,
       prevBuffer: 0,
-      bufferUsage: d
+      bufferUsage: c
     };
   }
-  static alloc({ capacity: t, dataType: e, ...r }) {
+  static alloc({ capacity: t, dataType: e, ...n }) {
     if (t === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
-    const u = new new h(e).Array(t), d = new T({
-      data: u.buffer,
+    const i = new new g(e).Array(t), c = new I({
+      data: i.buffer,
       dataType: e,
-      ...r
+      ...n
     });
-    return d.writePos = 0, d;
+    return c.writePos = 0, c;
   }
-  static generateTimestamps(t, e, r) {
-    const u = r.spanRange(e.span(t)), d = new BigInt64Array(t);
-    for (let g = 0; g < t; g++)
-      d[g] = BigInt(r.add(e.span(g)).valueOf());
-    return new T({ data: d, dataType: h.TIMESTAMP, timeRange: u });
+  static generateTimestamps(t, e, n) {
+    const i = n.spanRange(e.span(t)), c = 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 });
   }
   get refCount() {
     return this._refCount;
   }
   static fromStrings(t, e) {
-    const r = new TextEncoder().encode(t.join(`
-`) + `
+    const n = new TextEncoder().encode(`${t.join(`
+`)}
 `);
-    return new T({ data: r, dataType: h.STRING, timeRange: e });
+    return new I({ data: n, dataType: g.STRING, timeRange: e });
   }
   static fromJSON(t, e) {
-    const r = new TextEncoder().encode(
-      t.map((u) => L.encodeString(u)).join(`
-`) + `
+    const n = new TextEncoder().encode(
+      `${t.map((i) => $.encodeString(i)).join(`
+`)}
 `
     );
-    return new T({ data: r, dataType: h.JSON, timeRange: e });
+    return new I({ data: n, dataType: g.JSON, timeRange: e });
   }
   acquire(t) {
     this._refCount++, t != null && this.updateGLBuffer(t);
@@ -1178,45 +1189,56 @@ const St = o.union([
   write(t) {
     if (!t.dataType.equals(this.dataType))
       throw new Error("buffer must be of the same type as this array");
-    if (this.writePos === E) return 0;
-    const e = this.capacity - this.writePos, r = e < t.length ? t.slice(0, e) : t;
-    return this.underlyingData.set(
-      r.data,
+    return this.dataType.isVariable ? this.writeVariable(t) : this.writeFixed(t);
+  }
+  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;
+  }
+  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;
+  }
+  writeToUnderlyingData(t) {
+    this.underlyingData.set(
+      t.data,
       this.writePos
-    ), this.maybeRecomputeMinMax(r), this._cachedLength = void 0, this.writePos += r.length, r.length;
+    );
   }
   /** @returns the underlying buffer backing this array. */
   get buffer() {
-    return this._data;
+    return this._data instanceof ArrayBuffer || this._data instanceof SharedArrayBuffer ? this._data : this._data.buffer;
   }
   get underlyingData() {
     return new this.dataType.Array(this._data);
   }
   /** @returns a native typed array with the proper data type. */
   get data() {
-    return this.writePos === E ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
+    return this.writePos === B ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
   }
   toStrings() {
-    if (!this.dataType.matches(h.STRING, h.UUID))
+    if (!this.dataType.matches(g.STRING, g.UUID))
       throw new Error("cannot convert non-string series to strings");
-    return new TextDecoder().decode(this.buffer).split(`
+    return new TextDecoder().decode(this.underlyingData).split(`
 `).slice(0, -1);
   }
   toUUIDs() {
-    if (!this.dataType.equals(h.UUID))
+    if (!this.dataType.equals(g.UUID))
       throw new Error("cannot convert non-uuid series to uuids");
-    const t = h.UUID.density.valueOf(), e = Array(this.length);
-    for (let r = 0; r < this.length; r++) {
-      const u = this.buffer.slice(r * t, (r + 1) * t), d = Array.from(new Uint8Array(u), (g) => g.toString(16).padStart(2, "0")).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-      e[r] = d;
+    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;
     }
     return e;
   }
   parseJSON(t) {
-    if (!this.dataType.equals(h.JSON))
+    if (!this.dataType.equals(g.JSON))
       throw new Error("cannot convert non-string series to strings");
-    return new TextDecoder().decode(this.buffer).split(`
-`).slice(0, -1).map((e) => t.parse(L.decodeString(e)));
+    return new TextDecoder().decode(this.underlyingData).split(`
+`).slice(0, -1).map((e) => t.parse($.decodeString(e)));
   }
   /** @returns the time range of this array. */
   get timeRange() {
@@ -1225,27 +1247,28 @@ const St = o.union([
   }
   /** @returns the capacity of the series in bytes. */
   get byteCapacity() {
-    return new C(this.buffer.byteLength);
+    return new x(this.underlyingData.byteLength);
   }
   /** @returns the capacity of the series in samples. */
   get capacity() {
-    return this.dataType.density.length(this.byteCapacity);
+    return this.dataType.isVariable ? this.byteCapacity.valueOf() : this.dataType.density.length(this.byteCapacity);
   }
   /** @returns the length of the series in bytes. */
   get byteLength() {
-    return this.writePos === E ? this.byteCapacity : this.dataType.density.size(this.writePos);
+    return this.writePos === B ? this.byteCapacity : this.dataType.isVariable ? new x(this.writePos) : this.dataType.density.size(this.writePos);
   }
   /** @returns the number of samples in this array. */
   get length() {
-    return this._cachedLength != null ? this._cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === E ? this.data.length : this.writePos;
+    return this._cachedLength != null ? this._cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === B ? this.data.length : this.writePos;
   }
   calculateCachedLength() {
     if (!this.dataType.isVariable)
       throw new Error("cannot calculate length of a non-variable length data type");
     let t = 0;
-    return this.data.forEach((e) => {
-      e === 10 && t++;
-    }), this._cachedLength = t, t;
+    const e = [0];
+    return this.data.forEach((n, i) => {
+      n === Y && (t++, e.push(i + 1));
+    }), this._cachedIndexes = e, this._cachedLength = t, t;
   }
   /**
    * Creates a new array with a different data type.
@@ -1258,11 +1281,11 @@ const St = o.union([
    */
   convert(t, e = 0) {
     if (this.dataType.equals(t)) return this;
-    const r = new t.Array(this.length);
-    for (let u = 0; u < this.length; u++)
-      r[u] = et(this.dataType, t, this.data[u], e);
-    return new T({
-      data: r.buffer,
+    const n = new t.Array(this.length);
+    for (let i = 0; i < this.length; i++)
+      n[i] = ct(this.dataType, t, this.data[i], e);
+    return new I({
+      data: n.buffer,
       dataType: t,
       timeRange: this._timeRange,
       sampleOffset: e,
@@ -1272,14 +1295,14 @@ const St = o.union([
   }
   calcRawMax() {
     if (this.length === 0) return -1 / 0;
-    if (this.dataType.equals(h.TIMESTAMP))
+    if (this.dataType.equals(g.TIMESTAMP))
       this._cachedMax = this.data[this.data.length - 1];
     else if (this.dataType.usesBigInt) {
       const t = this.data;
-      this._cachedMax = t.reduce((e, r) => e > r ? e : r);
+      this._cachedMax = t.reduce((e, n) => e > n ? e : n);
     } else {
       const t = this.data;
-      this._cachedMax = t.reduce((e, r) => e > r ? e : r);
+      this._cachedMax = t.reduce((e, n) => e > n ? e : n);
     }
     return this._cachedMax;
   }
@@ -1287,18 +1310,17 @@ const St = o.union([
   get max() {
     if (this.dataType.isVariable)
       throw new Error("cannot calculate maximum on a variable length data type");
-    return this.writePos === 0 ? -1 / 0 : (this._cachedMax == null && (this._cachedMax = this.calcRawMax()), R(this._cachedMax, this.sampleOffset));
+    return this.writePos === 0 ? -1 / 0 : (this._cachedMax ?? (this._cachedMax = this.calcRawMax()), C(this._cachedMax, this.sampleOffset));
   }
   calcRawMin() {
     if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(h.TIMESTAMP))
-      this._cachedMin = this.data[0];
+    if (this.dataType.equals(g.TIMESTAMP)) this._cachedMin = this.data[0];
     else if (this.dataType.usesBigInt) {
       const t = this.data;
-      this._cachedMin = t.reduce((e, r) => e < r ? e : r);
+      this._cachedMin = t.reduce((e, n) => e < n ? e : n);
     } else {
       const t = this.data;
-      this._cachedMin = t.reduce((e, r) => e < r ? e : r);
+      this._cachedMin = t.reduce((e, n) => e < n ? e : n);
     }
     return this._cachedMin;
   }
@@ -1306,11 +1328,11 @@ const St = o.union([
   get min() {
     if (this.dataType.isVariable)
       throw new Error("cannot calculate minimum on a variable length data type");
-    return this.writePos === 0 ? 1 / 0 : (this._cachedMin == null && (this._cachedMin = this.calcRawMin()), R(this._cachedMin, this.sampleOffset));
+    return this.writePos === 0 ? 1 / 0 : (this._cachedMin ?? (this._cachedMin = this.calcRawMin()), C(this._cachedMin, this.sampleOffset));
   }
   /** @returns the bounds of this array. */
   get bounds() {
-    return $(Number(this.min), Number(this.max));
+    return L(Number(this.min), Number(this.max));
   }
   maybeRecomputeMinMax(t) {
     if (this._cachedMin != null) {
@@ -1326,36 +1348,48 @@ const St = o.union([
     this.max, this.min;
   }
   get range() {
-    return R(this.max, -this.min);
+    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}`);
+      return;
+    }
+    return this.at(n, 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 n = this.data[t];
+    if (n == null) {
       if (e === !0) throw new Error(`[series] - no value at index ${t}`);
       return;
     }
-    return R(r, this.sampleOffset);
+    return C(n, this.sampleOffset);
   }
   atVariable(t, e) {
-    t < 0 && (t = this.length + t);
-    let r = 0, u = 0;
-    for (let g = 0; g < this.data.length; g++)
-      if (this.data[g] === 10) {
-        if (t === 0) {
-          u = g;
-          break;
+    let n = 0, i = 0;
+    if (this._cachedIndexes != null)
+      n = 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 (t === 0) {
+            i = h;
+            break;
+          }
+          n = h + 1, t--;
         }
-        r = g + 1, t--;
+      if (i === 0 && (i = this.data.length), n >= i || t > 0) {
+        if (e) throw new Error(`[series] - no value at index ${t}`);
+        return;
       }
-    if (u === 0 && (u = this.data.length), r >= u || t > 0) {
-      if (e) throw new Error(`[series] - no value at index ${t}`);
-      return;
     }
-    const d = this.data.slice(r, u);
-    return this.dataType.equals(h.STRING) ? new TextDecoder().decode(d) : z(
-      JSON.parse(new TextDecoder().decode(d))
+    const c = this.data.slice(n, i);
+    return this.dataType.equals(g.STRING) ? new TextDecoder().decode(c) : nt(
+      JSON.parse(new TextDecoder().decode(c))
     );
   }
   /**
@@ -1364,34 +1398,34 @@ const St = o.union([
    * @param value the value to search for.
    */
   binarySearch(t) {
-    let e = 0, r = this.length - 1;
-    const u = H(t);
-    for (; e <= r; ) {
-      const d = Math.floor((e + r) / 2), g = u(this.at(d, !0), t);
-      if (g === 0) return d;
-      g < 0 ? e = d + 1 : r = d - 1;
+    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;
     }
     return e;
   }
   updateGLBuffer(t) {
-    if (this.gl.control = t, !this.dataType.equals(h.FLOAT32))
+    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: r, prevBuffer: u } = this.gl;
-    if (e == null && (this.gl.buffer = t.createBuffer()), this.writePos !== u)
-      if (t.bindBuffer(t.ARRAY_BUFFER, this.gl.buffer), this.writePos !== E) {
-        u === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
-        const d = this.dataType.density.size(u).valueOf(), g = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        t.bufferSubData(t.ARRAY_BUFFER, d, g.buffer), this.gl.prevBuffer = this.writePos;
+    const { buffer: e, bufferUsage: n, 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;
       } else
         t.bufferData(
           t.ARRAY_BUFFER,
-          this.buffer,
-          r === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
-        ), this.gl.prevBuffer = E;
+          this.underlyingData,
+          n === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
+        ), this.gl.prevBuffer = B;
   }
   as(t) {
     if (t === "string") {
-      if (!this.dataType.equals(h.STRING))
+      if (!this.dataType.equals(g.STRING))
         throw new Error(
           `cannot convert series of type ${this.dataType.toString()} to string`
         );
@@ -1405,7 +1439,7 @@ const St = o.union([
       return this;
     }
     if (t === "bigint") {
-      if (!this.dataType.equals(h.INT64))
+      if (!this.dataType.equals(g.INT64))
         throw new Error(
           `cannot convert series of type ${this.dataType.toString()} to bigint`
         );
@@ -1434,7 +1468,7 @@ const St = o.union([
     };
   }
   get alignmentBounds() {
-    return $(this.alignment, this.alignment + BigInt(this.length));
+    return L(this.alignment, this.alignment + BigInt(this.length));
   }
   maybeGarbageCollectGLBuffer(t) {
     this.gl.buffer != null && (t.deleteBuffer(this.gl.buffer), this.gl.buffer = null, this.gl.prevBuffer = 0, this.gl.control = null);
@@ -1445,16 +1479,32 @@ const St = o.union([
   }
   [Symbol.iterator]() {
     if (this.dataType.isVariable) {
-      const t = new it(this);
-      return this.dataType.equals(h.JSON) ? new at(t) : t;
+      const t = new gt(this);
+      return this.dataType.equals(g.JSON) ? new mt(t) : t;
     }
-    return new ut(this);
+    return new Ot(this);
   }
   slice(t, e) {
-    if (t <= 0 && (e == null || e >= this.length)) return this;
-    const r = this.data.slice(t, e);
-    return new T({
-      data: r,
+    return this.sliceSub(!1, t, e);
+  }
+  sub(t, e) {
+    return this.sliceSub(!0, t, e);
+  }
+  subIterator(t, e) {
+    return new G(this, t, e ?? this.length);
+  }
+  subAlignmentIterator(t, e) {
+    return new G(
+      this,
+      Number(t - this.alignment),
+      Number(e - this.alignment)
+    );
+  }
+  subBytes(t, e) {
+    if (t >= 0 && (e == null || e >= this.byteLength.valueOf())) return this;
+    const n = this.data.subarray(t, e);
+    return new I({
+      data: n,
       dataType: this.dataType,
       timeRange: this._timeRange,
       sampleOffset: this.sampleOffset,
@@ -1462,26 +1512,54 @@ const St = o.union([
       alignment: this.alignment + BigInt(t)
     });
   }
+  sliceSub(t, e, n) {
+    if (e <= 0 && (n == null || n >= this.length)) return this;
+    let i;
+    return t ? i = this.data.subarray(e, n) : i = this.data.slice(e, n), new I({
+      data: i,
+      dataType: this.dataType,
+      timeRange: this._timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + BigInt(e)
+    });
+  }
   reAlign(t) {
-    return new T({
+    return new I({
       data: this.buffer,
       dataType: this.dataType,
-      timeRange: B.ZERO,
+      timeRange: E.ZERO,
       sampleOffset: this.sampleOffset,
       glBufferUsage: "static",
       alignment: t
     });
   }
 };
-s(T, "crudeZ", o.object({
-  timeRange: B.z.optional(),
-  dataType: h.z,
-  alignment: X.optional(),
-  data: o.union([nt, st, o.instanceof(ArrayBuffer)]),
-  glBufferUsage: tt.optional().default("static").optional()
-})), s(T, "z", T.crudeZ.transform((t) => new T(t)));
-let x = T;
-class it {
+s(I, "crudeZ", o.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()
+})), s(I, "z", I.crudeZ.transform((t) => new I(t)));
+let V = I;
+class G {
+  constructor(t, e, n) {
+    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);
+  }
+  next() {
+    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+class gt {
   constructor(t) {
     s(this, "series");
     s(this, "index");
@@ -1494,38 +1572,38 @@ class it {
   }
   next() {
     const t = this.index, e = this.series.data;
-    for (; this.index < e.length && e[this.index] !== 10; ) 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] !== 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)) });
   }
   [Symbol.iterator]() {
     return this;
   }
 }
-var F, P;
-class at {
+var J, W;
+class mt {
   constructor(t) {
     s(this, "wrapped");
-    s(this, F, "JSONSeriesIterator");
+    s(this, J, "JSONSeriesIterator");
     this.wrapped = t;
   }
   next() {
     const t = this.wrapped.next();
     return t.done === !0 ? { done: !0, value: void 0 } : {
       done: !1,
-      value: L.decodeString(t.value)
+      value: $.decodeString(t.value)
     };
   }
-  [(P = Symbol.iterator, F = Symbol.toStringTag, P)]() {
+  [(W = Symbol.iterator, J = Symbol.toStringTag, W)]() {
     return this;
   }
 }
-var Y, Z;
-class ut {
+var j, K;
+class Ot {
   constructor(t) {
     s(this, "series");
     s(this, "index");
-    s(this, Y, "SeriesIterator");
+    s(this, j, "SeriesIterator");
     this.series = t, this.index = 0;
   }
   next() {
@@ -1534,101 +1612,184 @@ class ut {
       value: this.series.at(this.index++, !0)
     };
   }
-  [(Z = Symbol.iterator, Y = Symbol.toStringTag, Z)]() {
+  [(K = Symbol.iterator, j = Symbol.toStringTag, K)]() {
     return this;
   }
 }
-const R = (f, t) => typeof f == "bigint" && typeof t == "bigint" || typeof f == "number" && typeof t == "number" ? f + t : t === 0 ? f : f === 0 ? t : Number(f) + Number(t);
-class vt {
+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 {
   constructor(t) {
     s(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 n = 1; n < t.length; n++)
+        if (!t[n].dataType.equals(e))
           throw new Error("[multi-series] - series must have the same data type");
     }
     this.series = t;
   }
   as(t) {
-    if (!new h(t).equals(this.dataType))
+    if (!new g(t).equals(this.dataType))
       throw new Error(
         `cannot convert series of type ${this.dataType.toString()} to ${t.toString()}`
       );
     return this;
   }
   get dataType() {
-    return this.series.length === 0 ? h.UNKNOWN : this.series[0].dataType;
+    return this.series.length === 0 ? g.UNKNOWN : this.series[0].dataType;
   }
   get timeRange() {
-    return this.series.length === 0 ? B.ZERO : new B(
+    return this.series.length === 0 ? E.ZERO : new E(
       this.series[0].timeRange.start,
       this.series[this.series.length - 1].timeRange.end
     );
   }
+  get alignment() {
+    return this.series.length === 0 ? 0n : this.series[0].alignment;
+  }
+  get alignmentBounds() {
+    return this.series.length === 0 ? L(0n, 0n) : L(
+      this.series[0].alignmentBounds.lower,
+      this.series[this.series.length - 1].alignmentBounds.upper
+    );
+  }
   push(t) {
     this.series.push(t);
   }
   get length() {
     return this.series.reduce((t, e) => t + e.length, 0);
   }
+  atAlignment(t, e) {
+    if (this.series.length === 0) {
+      if (e) throw new Error(`[series] - no value at alignment ${t}`);
+      return;
+    }
+    for (const n of this.series)
+      if (D(n.alignmentBounds, t))
+        return n.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 n of this.series) {
+      if (t < n.length) return n.at(t, e);
+      t -= n.length;
     }
     if (e) throw new Error(`[series] - no value at index ${t}`);
   }
+  subIterator(t, e) {
+    return new F(this, t, e ?? this.length);
+  }
+  subAlignmentIterator(t, e) {
+    if (t >= this.alignmentBounds.upper || e <= this.alignmentBounds.lower)
+      return q;
+    let n = 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) n += h.length;
+      else if (D(h.alignmentBounds, t)) {
+        n += Number(t - h.alignment);
+        break;
+      }
+    }
+    let i = 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) i += h.length;
+      else if (D(h.alignmentBounds, e)) {
+        i += Number(e - h.alignment);
+        break;
+      }
+    }
+    return new F(this, n, i);
+  }
+  subAlignmentSpanIterator(t, e) {
+    if (t >= this.alignmentBounds.upper) return q;
+    let n = 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);
+        break;
+      }
+    }
+    return new F(this, n, n + e);
+  }
   get byteLength() {
-    return new C(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
+    return new x(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 n of this.series)
+      t.set(n.data, e), e += n.length;
     return new this.dataType.Array(t);
   }
+  traverseAlignment(t, e) {
+    const n = this.series.map((i) => i.alignmentBounds);
+    return st(n, t, e);
+  }
+  distance(t, e) {
+    const n = this.series.map((i) => i.alignmentBounds);
+    return it(n, t, e);
+  }
   [Symbol.iterator]() {
     return this.series.length === 0 ? {
       next() {
         return { done: !0, value: void 0 };
       }
-    } : new ot(this.series);
+    } : new yt(this.series);
   }
 }
-var G, V;
-class ot {
+var z, H;
+class yt {
   constructor(t) {
     s(this, "series");
     s(this, "seriesIndex");
     s(this, "internal");
-    s(this, G, "MultiSeriesIterator");
+    s(this, z, "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());
   }
-  [(V = Symbol.iterator, G = Symbol.toStringTag, V)]() {
+  [(H = Symbol.iterator, z = Symbol.toStringTag, H)]() {
+    return this;
+  }
+}
+class F {
+  constructor(t, e, n) {
+    s(this, "series");
+    s(this, "index");
+    s(this, "end");
+    this.series = t, this.end = n, this.index = e;
+  }
+  next() {
+    return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
+  }
+  [Symbol.iterator]() {
     return this;
   }
 }
 export {
   b as D,
-  vt as M,
-  q as R,
-  x as S,
+  Ct as M,
+  P as R,
+  V as S,
   m as T,
-  R as a,
+  C as a,
   y as b,
-  B as c,
-  h as d,
-  C as e,
-  W as f,
-  et as g,
-  Nt as h,
-  rt as i,
-  St as t
+  E as c,
+  g as d,
+  x as e,
+  _ as f,
+  ct as g,
+  Rt as h,
+  ft as i,
+  xt as t
 };