@synnaxlabs/x 0.43.0 → 0.44.0

package/dist/{index-DBGAIs_7.js → series-BeJyqCoP.js}

@@ -1,84 +1,64 @@
-var dt = Object.defineProperty;
-var gt = (n, t, e) => t in n ? dt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
-var i = (n, t, e) => gt(n, typeof t != "symbol" ? t + "" : t, e);
-import { J as W } from "./index-4GlOgZuh.js";
-import { s as mt } from "./index-Dql5FMcH.js";
-import { V as D, n as Ot } from "./index-C07SBJhr.js";
-import { g as x, j as q, k as Q, l as F, n as yt, t as bt, o as wt } from "./index-C9EdKeu1.js";
-import "./index-ClrGyGDp.js";
-import "./dimensions.js";
-import "./base-B5lQIJKc.js";
-import "./index-D6V-8SKw.js";
-import "./index-BUa-NXAX.js";
-import "./index-C-qYOegc.js";
-import { b8 as It, bc as Tt, dN as Nt, bb as pt, dC as vt, b9 as St, d2 as At, ba as Ut, d9 as Bt, d0 as Et, _ as Mt, u as S, o as G, s as $, a as O, n as P, b as rt, eI as Ct, f5 as Rt, r as xt, c as Lt } from "./schemas-55Usj0Fg.js";
-function Dt(n) {
-  return Tt(Nt, n);
-}
-function qt(n) {
-  return pt(vt, n);
-}
-function $t(n) {
-  return St(At, n);
-}
-function st(n) {
-  return It(Et, n);
-}
-function Pt(n) {
-  return Ut(Bt, n);
-}
-const be = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  bigint: st,
-  boolean: $t,
-  date: Pt,
-  number: qt,
-  string: Dt
-}, Symbol.toStringTag, { value: "Module" }));
-let Ft = (n, t = 21) => (e = t) => {
-  let r = "", a = e | 0;
-  for (; a--; )
-    r += n[Math.random() * n.length | 0];
-  return r;
+import { z as o } from "zod";
+import { J as L } from "./index-B5l_quQn.js";
+import { s as z } from "./index-D2xcvEO5.js";
+import { V as M, n as _ } from "./index-PNh31WTW.js";
+import { m as B, c as C, a as Y, d as R, e as tt, t as et, f as st } from "./bounds-Dj9nG39I.js";
+import "./box-D_qdUyEe.js";
+import "./dimensions-CRgergMS.js";
+import "./base-DFq0vvGn.js";
+import "./location-Ar5y2DX2.js";
+import "./scale-CdTNWu-d.js";
+import "./xy-D_LqxaGt.js";
+let rt = (i, t = 21) => (e = t) => {
+  let s = "", u = e | 0;
+  for (; u--; )
+    s += i[Math.random() * i.length | 0];
+  return s;
 };
-const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt = Ft(Zt, 11), nt = () => Yt(), we = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const nt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", G = 11, it = rt(nt, G), J = () => it(), $t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  create: nt
-}, Symbol.toStringTag, { value: "Module" })), it = (n, t) => (e) => e instanceof t || typeof e == "object" && e !== null && "discriminator" in e && e.discriminator === n, Ie = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  LENGTH: G,
+  create: J
+}, Symbol.toStringTag, { value: "Module" })), j = (i, t) => (e) => e instanceof t || typeof e == "object" && e !== null && "discriminator" in e && e.discriminator === i, Ft = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  createMatcher: it
-}, Symbol.toStringTag, { value: "Module" })), Vt = Mt(["static", "dynamic"]), at = (n, t) => {
-  const e = new d(t);
+  createMatcher: j
+}, Symbol.toStringTag, { value: "Module" })), at = o.enum(["static", "dynamic"]), ut = o.union([
+  o.tuple([o.int()]),
+  o.tuple([o.int(), o.int().min(1).max(12)]),
+  o.tuple([o.int(), o.int().min(1).max(12), o.int().min(1).max(31)])
+]), W = (i, t) => {
+  const e = new n(t);
   if (![
-    g.DAY,
-    g.HOUR,
-    g.MINUTE,
-    g.SECOND,
-    g.MILLISECOND,
-    g.MICROSECOND,
-    g.NANOSECOND
-  ].some((a) => a.equals(e)))
+    a.DAY,
+    a.HOUR,
+    a.MINUTE,
+    a.SECOND,
+    a.MILLISECOND,
+    a.MICROSECOND,
+    a.NANOSECOND
+  ].some((u) => u.equals(e)))
     throw new Error(
       "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
     );
-  const r = n.valueOf() % e.valueOf();
-  return n instanceof d ? new d(r) : new g(r);
-}, u = class u extends D {
+  const s = i.valueOf() % e.valueOf();
+  return i instanceof n ? new n(s) : new a(s);
+};
+class n extends M {
   constructor(t, e = "UTC") {
-    if (t == null) super(u.now().valueOf());
+    if (t == null) super(n.now().valueOf());
     else if (t instanceof Date)
-      super(BigInt(t.getTime()) * u.MILLISECOND.valueOf());
+      super(BigInt(t.getTime()) * n.MILLISECOND.valueOf());
     else if (typeof t == "string")
-      super(u.parseDateTimeString(t, e).valueOf());
-    else if (Array.isArray(t)) super(u.parseDate(t));
+      super(n.parseDateTimeString(t, e).valueOf());
+    else if (Array.isArray(t)) super(n.parseDate(t));
     else {
-      let r = BigInt(0);
-      t instanceof Number && (t = t.valueOf()), e === "local" && (r = u.utcOffset.valueOf()), typeof t == "number" && (isFinite(t) ? t = Math.trunc(t) : (isNaN(t) && (t = 0), t === 1 / 0 ? t = u.MAX : t = u.MIN)), super(BigInt(t.valueOf()) + r);
+      let s = 0n;
+      t instanceof Number && (t = t.valueOf()), e === "local" && (s = n.utcOffset.valueOf()), typeof t == "number" && (isFinite(t) ? t = Math.trunc(t) : (isNaN(t) && (t = 0), t === 1 / 0 ? t = n.MAX : t = n.MIN)), super(BigInt(t.valueOf()) + s);
     }
   }
-  static parseDate([t = 1970, e = 1, r = 1]) {
-    const a = new Date(t, e - 1, r, 0, 0, 0, 0);
-    return new u(BigInt(a.getTime()) * u.MILLISECOND.valueOf()).truncate(u.DAY).valueOf();
+  static parseDate([t = 1970, e = 1, s = 1]) {
+    const u = new Date(t, e - 1, s, 0, 0, 0, 0);
+    return new n(BigInt(u.getTime()) * n.MILLISECOND.valueOf()).truncate(n.DAY).valueOf();
   }
   /**
    * @returns the primitive value of the TimeStamp. Overrides standard JS valueOf()
@@ -88,18 +68,18 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
     return this.value;
   }
   static parseTimeString(t, e = "UTC") {
-    const [r, a, f] = t.split(":");
-    let h = "00", A = "00";
-    f != null && ([h, A] = f.split("."));
-    let y = u.hours(parseInt(r ?? "00")).add(u.minutes(parseInt(a ?? "00"))).add(u.seconds(parseInt(h ?? "00"))).add(u.milliseconds(parseInt(A ?? "00")));
-    return e === "local" && (y = y.add(u.utcOffset)), y.valueOf();
+    const [s, u, f] = t.split(":");
+    let c = "00", y = "00";
+    f != null && ([c, y] = f.split("."));
+    let g = n.hours(parseInt(s ?? "00")).add(n.minutes(parseInt(u ?? "00"))).add(n.seconds(parseInt(c ?? "00"))).add(n.milliseconds(parseInt(y ?? "00")));
+    return e === "local" && (g = g.add(n.utcOffset)), g.valueOf();
   }
   static parseDateTimeString(t, e = "UTC") {
     if (!t.includes("/") && !t.includes("-"))
-      return u.parseTimeString(t, e);
-    const r = new Date(t);
-    return t.includes(":") || r.setUTCHours(0, 0, 0, 0), new u(
-      BigInt(r.getTime()) * u.MILLISECOND.valueOf(),
+      return n.parseTimeString(t, e);
+    const s = new Date(t);
+    return t.includes(":") || s.setUTCHours(0, 0, 0, 0), new n(
+      BigInt(s.getTime()) * n.MILLISECOND.valueOf(),
       e
     ).valueOf();
   }
@@ -131,20 +111,20 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
     }
   }
   toISOString(t = "UTC") {
-    return t === "UTC" ? this.date().toISOString() : this.sub(u.utcOffset).date().toISOString();
+    return t === "UTC" ? this.date().toISOString() : this.sub(n.utcOffset).date().toISOString();
   }
   timeString(t = !1, e = "UTC") {
-    const r = this.toISOString(e);
-    return t ? r.slice(11, 23) : r.slice(11, 19);
+    const s = this.toISOString(e);
+    return t ? s.slice(11, 23) : s.slice(11, 19);
   }
   dateString() {
-    const t = this.date(), e = t.toLocaleString("default", { month: "short" }), r = t.toLocaleString("default", { day: "numeric" });
-    return `${e} ${r}`;
+    const t = this.date(), e = t.toLocaleString("default", { month: "short" }), s = t.toLocaleString("default", { day: "numeric" });
+    return `${e} ${s}`;
   }
   /** @returns The UTC offset for the time zone of the machine. */
   static get utcOffset() {
-    return new g(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * u.MINUTE.valueOf()
+    return new a(
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * n.MINUTE.valueOf()
     );
   }
   /**
@@ -153,7 +133,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @param other - The other timestamp.
    */
   static since(t) {
-    return new u().span(t);
+    return new n().span(t);
   }
   /** @returns A JavaScript Date object representing the TimeStamp. */
   date() {
@@ -166,7 +146,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @returns True if the TimeStamps are equal, false otherwise.
    */
   equals(t) {
-    return this.valueOf() === new u(t).valueOf();
+    return this.valueOf() === new n(t).valueOf();
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -186,7 +166,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   valid, regardless of the TimeStamp order.
    */
   range(t) {
-    return new B(this, t).makeValid();
+    return new w(this, t).makeValid();
   }
   /**
    * Creates a TimeRange starting at the TimeStamp and spanning the given
@@ -205,7 +185,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @returns True if the TimeStamp represents the unix epoch, false otherwise.
    */
   get isZero() {
-    return this.valueOf() === BigInt(0);
+    return this.valueOf() === 0n;
   }
   /**
    * Checks if the TimeStamp is after the given TimeStamp.
@@ -215,7 +195,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   otherwise.
    */
   after(t) {
-    return this.valueOf() > new u(t).valueOf();
+    return this.valueOf() > new n(t).valueOf();
   }
   /**
    * Checks if the TimeStamp is after or equal to the given TimeStamp.
@@ -225,7 +205,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   false otherwise.
    */
   afterEq(t) {
-    return this.valueOf() >= new u(t).valueOf();
+    return this.valueOf() >= new n(t).valueOf();
   }
   /**
    * Checks if the TimeStamp is before the given TimeStamp.
@@ -235,7 +215,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   otherwise.
    */
   before(t) {
-    return this.valueOf() < new u(t).valueOf();
+    return this.valueOf() < new n(t).valueOf();
   }
   /**
    * Checks if TimeStamp is before or equal to the current timestamp.
@@ -245,7 +225,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   false otherwise.
    */
   beforeEq(t) {
-    return this.valueOf() <= new u(t).valueOf();
+    return this.valueOf() <= new n(t).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeStamp.
@@ -255,7 +235,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   TimeSpan.
    */
   add(t) {
-    return new u(this.valueOf() + BigInt(t.valueOf()));
+    return new n(this.valueOf() + BigInt(t.valueOf()));
   }
   /**
    * Subtracts a TimeSpan from the TimeStamp.
@@ -265,43 +245,43 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    *   TimeSpan.
    */
   sub(t) {
-    return new u(this.valueOf() - BigInt(t.valueOf()));
+    return new n(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(g.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(a.HOUR.valueOf());
   }
   /**
    * @returns the floating point number of minutes since the unix epoch to the timestamp
    * value.
    */
   get minutes() {
-    return Number(this.valueOf()) / Number(g.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(a.MINUTE.valueOf());
   }
   /**
    * @returns the floating point number of days since the unix epoch to the timestamp
    * value.
    */
   get days() {
-    return Number(this.valueOf()) / Number(g.DAY.valueOf());
+    return Number(this.valueOf()) / Number(a.DAY.valueOf());
   }
   /**
    * @returns the floating point number of seconds since the unix epoch to the timestamp
    * value.
    */
   get seconds() {
-    return Number(this.valueOf()) / Number(g.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.SECOND.valueOf());
   }
   /** @returns the floating point number of milliseconds since the unix epoch. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(u.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(n.MILLISECOND.valueOf());
   }
   /** @returns the floating point number of microseconds since the unix epoch. */
   get microseconds() {
-    return Number(this.valueOf()) / Number(u.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(n.MICROSECOND.valueOf());
   }
   /**
    * @returns the floating point number of nanoseconds since the unix epoch.
@@ -321,7 +301,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setYear(t) {
     const e = this.date();
-    return e.setUTCFullYear(t), new u(e);
+    return e.setUTCFullYear(t), new n(e);
   }
   /** @returns the integer month that the timestamp corresponds to with its year. */
   get month() {
@@ -333,7 +313,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setMonth(t) {
     const e = this.date();
-    return e.setUTCMonth(t), new u(e);
+    return e.setUTCMonth(t), new n(e);
   }
   /** @returns the integer day that the timestamp corresponds to within its month. */
   get day() {
@@ -345,7 +325,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setDay(t) {
     const e = this.date();
-    return e.setUTCDate(t), new u(e);
+    return e.setUTCDate(t), new n(e);
   }
   /**
    * @returns the integer hour that the timestamp corresponds to within its day.
@@ -359,7 +339,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setHour(t) {
     const e = this.date();
-    return e.setUTCHours(t), new u(e, "UTC");
+    return e.setUTCHours(t), new n(e, "UTC");
   }
   /** @returns the integer minute that the timestamp corresponds to within its hour. */
   get minute() {
@@ -371,7 +351,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setMinute(t) {
     const e = this.date();
-    return e.setUTCMinutes(t), new u(e);
+    return e.setUTCMinutes(t), new n(e);
   }
   /**
    * @returns the integer second that the timestamp corresponds to within its
@@ -386,7 +366,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setSecond(t) {
     const e = this.date();
-    return e.setUTCSeconds(t), new u(e);
+    return e.setUTCSeconds(t), new n(e);
   }
   /**
    * @reutrns the integer millisecond that the timestamp corresponds to within
@@ -401,7 +381,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    */
   setMillisecond(t) {
     const e = this.date();
-    return e.setUTCMilliseconds(t), new u(e);
+    return e.setUTCMilliseconds(t), new n(e);
   }
   /** @returns the time stamp formatted as an ISO string. */
   toString() {
@@ -419,11 +399,11 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(t) {
-    return at(this, t);
+    return W(this, t);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(g.DAY).equals(u.now().truncate(g.DAY));
+    return this.truncate(a.DAY).equals(n.now().truncate(a.DAY));
   }
   /**
    * Truncates the TimeStamp to the nearest multiple of the given span.
@@ -440,7 +420,7 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * JavaScript can do).
    */
   static now() {
-    return new u(/* @__PURE__ */ new Date());
+    return new n(/* @__PURE__ */ new Date());
   }
   /**
    * Finds the maximum timestamp among the provided timestamps.
@@ -449,10 +429,10 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @returns The maximum (latest) timestamp from the input.
    */
   static max(...t) {
-    let e = u.MIN;
-    for (const r of t) {
-      const a = new u(r);
-      a.after(e) && (e = a);
+    let e = n.MIN;
+    for (const s of t) {
+      const u = new n(s);
+      u.after(e) && (e = u);
     }
     return e;
   }
@@ -463,10 +443,10 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @returns The minimum (earliest) timestamp from the input.
    */
   static min(...t) {
-    let e = u.MAX;
-    for (const r of t) {
-      const a = new u(r);
-      a.before(e) && (e = a);
+    let e = n.MAX;
+    for (const s of t) {
+      const u = new n(s);
+      u.before(e) && (e = u);
     }
     return e;
   }
@@ -477,53 +457,76 @@ const Zt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Yt
    * @returns A TimeStamp representing the given number of nanoseconds.
    */
   static nanoseconds(t, e = "UTC") {
-    return new u(t, e);
+    return new n(t, e);
   }
+  /** One nanosecond after the unix epoch */
+  static NANOSECOND = n.nanoseconds(1);
   /** @returns a new TimeStamp n microseconds after the unix epoch */
   static microseconds(t, e = "UTC") {
-    return u.nanoseconds(t * 1e3, e);
+    return n.nanoseconds(t * 1e3, e);
   }
+  /** One microsecond after the unix epoch */
+  static MICROSECOND = n.microseconds(1);
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
   static milliseconds(t, e = "UTC") {
-    return u.microseconds(t * 1e3, e);
+    return n.microseconds(t * 1e3, e);
   }
+  /** One millisecond after the unix epoch */
+  static MILLISECOND = n.milliseconds(1);
   /** @returns a new TimeStamp n seconds after the unix epoch */
   static seconds(t, e = "UTC") {
-    return u.milliseconds(t * 1e3, e);
+    return n.milliseconds(t * 1e3, e);
   }
+  /** One second after the unix epoch */
+  static SECOND = n.seconds(1);
   /** @returns a new TimeStamp n minutes after the unix epoch */
   static minutes(t, e = "UTC") {
-    return u.seconds(t * 60, e);
+    return n.seconds(t * 60, e);
   }
+  /** One minute after the unix epoch */
+  static MINUTE = n.minutes(1);
   /** @returns a new TimeStamp n hours after the unix epoch */
   static hours(t, e = "UTC") {
-    return u.minutes(t * 60, e);
+    return n.minutes(t * 60, e);
   }
+  /** One hour after the unix epoch */
+  static HOUR = n.hours(1);
   /** @returns a new TimeStamp n days after the unix epoch */
   static days(t, e = "UTC") {
-    return u.hours(t * 24, e);
+    return n.hours(t * 24, e);
+  }
+  /** One day after the unix epoch */
+  static DAY = n.days(1);
+  /** The maximum possible value for a timestamp */
+  static MAX = new n((1n << 63n) - 1n);
+  /** The minimum possible value for a timestamp */
+  static MIN = new n(0);
+  /** The unix epoch */
+  static ZERO = new n(0);
+  /** A zod schema for validating timestamps */
+  static z = o.union([
+    o.instanceof(n),
+    o.object({ value: o.bigint() }).transform((t) => new n(t.value)),
+    o.string().transform((t) => new n(BigInt(t))),
+    o.number().transform((t) => new n(t)),
+    o.bigint().transform((t) => new n(t)),
+    o.date().transform((t) => new n(t)),
+    o.custom((t) => t instanceof a).transform((t) => new n(t)),
+    ut.transform((t) => new n(t))
+  ]);
+  /**
+   * Sorts two timestamps.
+   *
+   * @param a - The first timestamp.
+   * @param b - The second timestamp.
+   * @returns A number indicating the order of the two timestamps (positive if a is
+   * greater than b, negative if a is less than b, and 0 if they are equal).
+   */
+  static sort(t, e) {
+    return Number(t.valueOf() - e.valueOf());
   }
-};
-/** One nanosecond after the unix epoch */
-i(u, "NANOSECOND", u.nanoseconds(1)), /** One microsecond after the unix epoch */
-i(u, "MICROSECOND", u.microseconds(1)), /** One millisecond after the unix epoch */
-i(u, "MILLISECOND", u.milliseconds(1)), /** One second after the unix epoch */
-i(u, "SECOND", u.seconds(1)), /** One minute after the unix epoch */
-i(u, "MINUTE", u.minutes(1)), /** One hour after the unix epoch */
-i(u, "HOUR", u.hours(1)), /** One day after the unix epoch */
-i(u, "DAY", u.days(1)), /** The maximum possible value for a timestamp */
-i(u, "MAX", new u((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
-i(u, "MIN", new u(0)), /** The unix epoch */
-i(u, "ZERO", new u(0)), /** A zod schema for validating timestamps */
-i(u, "z", S([
-  G({ value: rt() }).transform((t) => new u(t.value)),
-  $().transform((t) => new u(BigInt(t))),
-  O(Number).transform((t) => new u(t)),
-  P().transform((t) => new u(t)),
-  O(u)
-]));
-let d = u;
-const o = class o extends D {
+}
+class a extends M {
   constructor(t) {
     typeof t == "number" && (t = Math.trunc(t.valueOf())), super(BigInt(t.valueOf()));
   }
@@ -534,7 +537,7 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static fromSeconds(t) {
-    return t instanceof o ? t : t instanceof Y ? t.period : t instanceof d ? new o(t) : ["number", "bigint"].includes(typeof t) ? o.seconds(t) : new o(t);
+    return t instanceof a ? t : t instanceof E ? t.period : t instanceof n ? new a(t) : ["number", "bigint"].includes(typeof t) ? a.seconds(t) : new a(t);
   }
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
@@ -543,7 +546,7 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static fromMilliseconds(t) {
-    return t instanceof o ? t : t instanceof Y ? t.period : t instanceof d ? new o(t) : ["number", "bigint"].includes(typeof t) ? o.milliseconds(t) : new o(t);
+    return t instanceof a ? t : t instanceof E ? t.period : t instanceof n ? new a(t) : ["number", "bigint"].includes(typeof t) ? a.milliseconds(t) : new a(t);
   }
   /**
    * @returns the primitive value of the TimeSpan. Overrides standard JS valueOf()
@@ -559,7 +562,7 @@ const o = class o extends D {
    * @returns True if the TimeSpan is less than the other TimeSpan, false otherwise.
    */
   lessThan(t) {
-    return this.valueOf() < new o(t).valueOf();
+    return this.valueOf() < new a(t).valueOf();
   }
   /**
    * Checks if the TimeSpan is greater than another TimeSpan.
@@ -568,7 +571,7 @@ const o = class o extends D {
    * @returns True if the TimeSpan is greater than the other TimeSpan, false otherwise.
    */
   greaterThan(t) {
-    return this.valueOf() > new o(t).valueOf();
+    return this.valueOf() > new a(t).valueOf();
   }
   /**
    * Checks if the TimeSpan is less than or equal to another TimeSpan.
@@ -577,7 +580,7 @@ const o = class o extends D {
    * @returns True if the TimeSpan is less than or equal to the other TimeSpan, false otherwise.
    */
   lessThanOrEqual(t) {
-    return this.valueOf() <= new o(t).valueOf();
+    return this.valueOf() <= new a(t).valueOf();
   }
   /**
    * Checks if the TimeSpan is greater than or equal to another TimeSpan.
@@ -586,7 +589,7 @@ const o = class o extends D {
    * @returns True if the TimeSpan is greater than or equal to the other TimeSpan, false otherwise.
    */
   greaterThanOrEqual(t) {
-    return this.valueOf() >= new o(t).valueOf();
+    return this.valueOf() >= new a(t).valueOf();
   }
   /**
    * Calculates the remainder of the TimeSpan when divided by another TimeSpan.
@@ -595,7 +598,7 @@ const o = class o extends D {
    * @returns A new TimeSpan representing the remainder.
    */
   remainder(t) {
-    return at(this, t);
+    return W(this, t);
   }
   /**
    * Truncates the TimeSpan to the nearest multiple of the given span.
@@ -604,7 +607,7 @@ const o = class o extends D {
    * @returns A new TimeSpan that is truncated to the nearest multiple of the given span.
    */
   truncate(t) {
-    return new o(
+    return new a(
       BigInt(Math.trunc(Number(this.valueOf() / t.valueOf()))) * t.valueOf()
     );
   }
@@ -614,9 +617,9 @@ const o = class o extends D {
    * @returns A string representation of the TimeSpan.
    */
   toString() {
-    const t = this.truncate(o.DAY), e = this.truncate(o.HOUR), r = this.truncate(o.MINUTE), a = this.truncate(o.SECOND), f = this.truncate(o.MILLISECOND), h = this.truncate(o.MICROSECOND), A = this.truncate(o.NANOSECOND), y = t, p = e.sub(t), E = r.sub(e), l = a.sub(r), M = f.sub(a), v = h.sub(f), X = A.sub(h);
-    let C = "";
-    return y.isZero || (C += `${y.days}d `), p.isZero || (C += `${p.hours}h `), E.isZero || (C += `${E.minutes}m `), l.isZero || (C += `${l.seconds}s `), M.isZero || (C += `${M.milliseconds}ms `), v.isZero || (C += `${v.microseconds}µs `), X.isZero || (C += `${X.nanoseconds}ns`), C.trim();
+    const t = this.truncate(a.DAY), e = this.truncate(a.HOUR), s = this.truncate(a.MINUTE), u = this.truncate(a.SECOND), f = this.truncate(a.MILLISECOND), c = this.truncate(a.MICROSECOND), y = this.truncate(a.NANOSECOND), g = t, b = e.sub(t), N = s.sub(e), l = u.sub(s), m = f.sub(u), v = c.sub(f), F = y.sub(c);
+    let U = "";
+    return g.isZero || (U += `${g.days}d `), b.isZero || (U += `${b.hours}h `), N.isZero || (U += `${N.minutes}m `), l.isZero || (U += `${l.seconds}s `), m.isZero || (U += `${m.milliseconds}ms `), v.isZero || (U += `${v.microseconds}µs `), F.isZero || (U += `${F.nanoseconds}ns`), U.trim();
   }
   /**
    * Multiplies the TimeSpan by a scalar value.
@@ -625,31 +628,31 @@ const o = class o extends D {
    * @returns A new TimeSpan that is this TimeSpan multiplied by the provided value.
    */
   mult(t) {
-    return new o(this.valueOf() * BigInt(t));
+    return new a(this.valueOf() * BigInt(t));
   }
   /** @returns the decimal number of days in the TimeSpan. */
   get days() {
-    return Number(this.valueOf()) / Number(o.DAY.valueOf());
+    return Number(this.valueOf()) / Number(a.DAY.valueOf());
   }
   /** @returns the decimal number of hours in the TimeSpan. */
   get hours() {
-    return Number(this.valueOf()) / Number(o.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(a.HOUR.valueOf());
   }
   /** @returns the decimal number of minutes in the TimeSpan. */
   get minutes() {
-    return Number(this.valueOf()) / Number(o.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(a.MINUTE.valueOf());
   }
   /** @returns The number of seconds in the TimeSpan. */
   get seconds() {
-    return Number(this.valueOf()) / Number(o.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.SECOND.valueOf());
   }
   /** @returns The number of milliseconds in the TimeSpan. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(o.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.MILLISECOND.valueOf());
   }
   /** @returns The number of microseconds in the TimeSpan. */
   get microseconds() {
-    return Number(this.valueOf()) / Number(o.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(a.MICROSECOND.valueOf());
   }
   /** @returns The number of nanoseconds in the TimeSpan. */
   get nanoseconds() {
@@ -661,7 +664,7 @@ const o = class o extends D {
    * @returns True if the TimeSpan represents a zero duration, false otherwise.
    */
   get isZero() {
-    return this.valueOf() === BigInt(0);
+    return this.valueOf() === 0n;
   }
   /**
    * Checks if the TimeSpan is equal to another TimeSpan.
@@ -669,7 +672,7 @@ const o = class o extends D {
    * @returns True if the TimeSpans are equal, false otherwise.
    */
   equals(t) {
-    return this.valueOf() === new o(t).valueOf();
+    return this.valueOf() === new a(t).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeSpan.
@@ -677,7 +680,7 @@ const o = class o extends D {
    * @returns A new TimeSpan representing the sum of the two TimeSpans.
    */
   add(t) {
-    return new o(this.valueOf() + new o(t).valueOf());
+    return new a(this.valueOf() + new a(t).valueOf());
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -685,7 +688,7 @@ const o = class o extends D {
    * @param other
    */
   sub(t) {
-    return new o(this.valueOf() - new o(t).valueOf());
+    return new a(this.valueOf() - new a(t).valueOf());
   }
   /**
    * Creates a TimeSpan representing the given number of nanoseconds.
@@ -694,8 +697,10 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of nanoseconds.
    */
   static nanoseconds(t = 1) {
-    return new o(t);
+    return new a(t);
   }
+  /** A nanosecond. */
+  static NANOSECOND = a.nanoseconds(1);
   /**
    * Creates a TimeSpan representing the given number of microseconds.
    *
@@ -703,8 +708,10 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of microseconds.
    */
   static microseconds(t = 1) {
-    return o.nanoseconds(x(t, 1e3));
+    return a.nanoseconds(B(t, 1e3));
   }
+  /** A microsecond. */
+  static MICROSECOND = a.microseconds(1);
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
    *
@@ -712,8 +719,10 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static milliseconds(t = 1) {
-    return o.microseconds(x(t, 1e3));
+    return a.microseconds(B(t, 1e3));
   }
+  /** A millisecond. */
+  static MILLISECOND = a.milliseconds(1);
   /**
    * Creates a TimeSpan representing the given number of seconds.
    *
@@ -721,8 +730,10 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static seconds(t = 1) {
-    return o.milliseconds(x(t, 1e3));
+    return a.milliseconds(B(t, 1e3));
   }
+  /** A second. */
+  static SECOND = a.seconds(1);
   /**
    * Creates a TimeSpan representing the given number of minutes.
    *
@@ -730,8 +741,10 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of minutes.
    */
   static minutes(t = 1) {
-    return o.seconds(x(t, 60));
+    return a.seconds(B(t, 60));
   }
+  /** A minute. */
+  static MINUTE = a.minutes(1);
   /**
    * Creates a TimeSpan representing the given number of hours.
    *
@@ -739,8 +752,10 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of hours.
    */
   static hours(t) {
-    return o.minutes(x(t, 60));
+    return a.minutes(B(t, 60));
   }
+  /** Represents an hour. */
+  static HOUR = a.hours(1);
   /**
    * Creates a TimeSpan representing the given number of days.
    *
@@ -748,29 +763,25 @@ const o = class o extends D {
    * @returns A TimeSpan representing the given number of days.
    */
   static days(t) {
-    return o.hours(x(t, 24));
-  }
-};
-/** A nanosecond. */
-i(o, "NANOSECOND", o.nanoseconds(1)), /** A microsecond. */
-i(o, "MICROSECOND", o.microseconds(1)), /** A millisecond. */
-i(o, "MILLISECOND", o.milliseconds(1)), /** A second. */
-i(o, "SECOND", o.seconds(1)), /** A minute. */
-i(o, "MINUTE", o.minutes(1)), /** Represents an hour. */
-i(o, "HOUR", o.hours(1)), /** Represents a day. */
-i(o, "DAY", o.days(1)), /** The maximum possible value for a TimeSpan. */
-i(o, "MAX", new o((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-i(o, "MIN", new o(0)), /** The zero value for a TimeSpan. */
-i(o, "ZERO", new o(0)), /** A zod schema for validating and transforming timespans */
-i(o, "z", S([
-  G({ value: rt() }).transform((t) => new o(t.value)),
-  $().transform((t) => new o(BigInt(t))),
-  O(Number).transform((t) => new o(t)),
-  P().transform((t) => new o(t)),
-  O(o)
-]));
-let g = o;
-const U = class U extends D {
+    return a.hours(B(t, 24));
+  }
+  /** Represents a day. */
+  static DAY = a.days(1);
+  /** The maximum possible value for a TimeSpan. */
+  static MAX = new a((1n << 63n) - 1n);
+  /** The minimum possible value for a TimeSpan. */
+  static MIN = new a(0);
+  /** The zero value for a TimeSpan. */
+  static ZERO = new a(0);
+  /** A zod schema for validating and transforming timespans */
+  static z = o.union([
+    o.object({ value: o.bigint() }).transform((t) => new a(t.value)),
+    o.string().transform((t) => new a(BigInt(t))),
+    o.number().transform((t) => new a(t)),
+    o.instanceof(a)
+  ]);
+}
+class E extends M {
   constructor(t) {
     super(t.valueOf());
   }
@@ -780,7 +791,7 @@ const U = class U extends D {
   }
   /** @returns The number of seconds in the Rate. */
   equals(t) {
-    return this.valueOf() === new U(t).valueOf();
+    return this.valueOf() === new E(t).valueOf();
   }
   /**
    * Calculates the period of the Rate as a TimeSpan.
@@ -788,7 +799,7 @@ const U = class U extends D {
    * @returns A TimeSpan representing the period of the Rate.
    */
   get period() {
-    return g.seconds(1 / this.valueOf());
+    return a.seconds(1 / this.valueOf());
   }
   /**
    * Calculates the number of samples in the given TimeSpan at this rate.
@@ -797,7 +808,7 @@ const U = class U extends D {
    * @returns The number of samples in the given TimeSpan at this rate.
    */
   sampleCount(t) {
-    return new g(t).seconds * this.valueOf();
+    return new a(t).seconds * this.valueOf();
   }
   /**
    * Calculates the number of bytes in the given TimeSpan at this rate.
@@ -807,7 +818,7 @@ const U = class U extends D {
    * @returns The number of bytes in the given TimeSpan at this rate.
    */
   byteCount(t, e) {
-    return this.sampleCount(t) * new I(e).valueOf();
+    return this.sampleCount(t) * new d(e).valueOf();
   }
   /**
    * Calculates a TimeSpan given the number of samples at this rate.
@@ -816,7 +827,7 @@ const U = class U extends D {
    * @returns A TimeSpan that corresponds to the given number of samples.
    */
   span(t) {
-    return g.seconds(t / this.valueOf());
+    return a.seconds(t / this.valueOf());
   }
   /**
    * Calculates a TimeSpan given the number of bytes at this rate.
@@ -835,7 +846,7 @@ const U = class U extends D {
    * @returns A Rate representing the given number of Hz.
    */
   static hz(t) {
-    return new U(t);
+    return new E(t);
   }
   /**
    * Creates a Rate representing the given number of kHz.
@@ -844,17 +855,15 @@ const U = class U extends D {
    * @returns A Rate representing the given number of kHz.
    */
   static khz(t) {
-    return U.hz(t * 1e3);
+    return E.hz(t * 1e3);
   }
-};
-/** A zod schema for validating and transforming rates */
-i(U, "z", S([
-  P().transform((t) => new U(t)),
-  O(Number).transform((t) => new U(t)),
-  O(U)
-]));
-let Y = U;
-const b = class b extends D {
+  /** A zod schema for validating and transforming rates */
+  static z = o.union([
+    o.number().transform((t) => new E(t)),
+    o.instanceof(E)
+  ]);
+}
+class d extends M {
   /**
    * Creates a Density representing the given number of bytes per value.
    *
@@ -881,23 +890,45 @@ const b = class b extends D {
    * @returns A Size representing the given number of values.
    */
   size(t) {
-    return new L(t * this.valueOf());
-  }
-};
-/** Unknown/Invalid Density. */
-i(b, "UNKNOWN", new b(0)), /** 128 bits per value. */
-i(b, "BIT128", new b(16)), /** 64 bits per value. */
-i(b, "BIT64", new b(8)), /** 32 bits per value. */
-i(b, "BIT32", new b(4)), /** 16 bits per value. */
-i(b, "BIT16", new b(2)), /** 8 bits per value. */
-i(b, "BIT8", new b(1)), /** A zod schema for validating and transforming densities */
-i(b, "z", S([
-  P().transform((t) => new b(t)),
-  O(Number).transform((t) => new b(t)),
-  O(b)
-]));
-let I = b;
-const T = class T {
+    return new h(t * this.valueOf());
+  }
+  /** Unknown/Invalid Density. */
+  static UNKNOWN = new d(0);
+  /** 128 bits per value. */
+  static BIT128 = new d(16);
+  /** 64 bits per value. */
+  static BIT64 = new d(8);
+  /** 32 bits per value. */
+  static BIT32 = new d(4);
+  /** 16 bits per value. */
+  static BIT16 = new d(2);
+  /** 8 bits per value. */
+  static BIT8 = new d(1);
+  /** A zod schema for validating and transforming densities */
+  static z = o.union([
+    o.number().transform((t) => new d(t)),
+    o.instanceof(d)
+  ]);
+}
+class w {
+  /**
+   * The starting TimeStamp of the TimeRange.
+   *
+   * Note that this value is not guaranteed to be before or equal to the ending value.
+   * To ensure that this is the case, call TimeRange.make_valid().
+   *
+   * In most cases, operations should treat start as inclusive.
+   */
+  start;
+  /**
+   * The starting TimeStamp of the TimeRange.
+   *
+   * Note that this value is not guaranteed to be before or equal to the ending value.
+   * To ensure that this is the case, call TimeRange.make_valid().
+   *
+   * In most cases, operations should treat end as exclusive.
+   */
+  end;
   /**
    * Creates a TimeRange from the given start and end TimeStamps.
    *
@@ -905,29 +936,11 @@ const T = class T {
    * @param end - A TimeStamp representing the end of the range.
    */
   constructor(t, e) {
-    /**
-     * The starting TimeStamp of the TimeRange.
-     *
-     * Note that this value is not guaranteed to be before or equal to the ending value.
-     * To ensure that this is the case, call TimeRange.make_valid().
-     *
-     * In most cases, operations should treat start as inclusive.
-     */
-    i(this, "start");
-    /**
-     * The starting TimeStamp of the TimeRange.
-     *
-     * Note that this value is not guaranteed to be before or equal to the ending value.
-     * To ensure that this is the case, call TimeRange.make_valid().
-     *
-     * In most cases, operations should treat end as exclusive.
-     */
-    i(this, "end");
-    typeof t == "object" && "start" in t ? (this.start = new d(t.start), this.end = new d(t.end)) : (this.start = new d(t), this.end = new d(e));
+    typeof t == "object" && "start" in t ? (this.start = new n(t.start), this.end = new n(t.end)) : (this.start = new n(t), this.end = new n(e));
   }
   /** @returns The TimeSpan occupied by the TimeRange. */
   get span() {
-    return new g(this.end.valueOf() - this.start.valueOf());
+    return new a(this.end.valueOf() - this.start.valueOf());
   }
   /**
    * Checks if the timestamp is valid i.e. the start is before the end.
@@ -965,7 +978,7 @@ const T = class T {
    * @returns A TimeRange with the start and end swapped.
    */
   swap() {
-    return new T(this.end, this.start);
+    return new w(this.end, this.start);
   }
   get numericBounds() {
     return {
@@ -979,11 +992,11 @@ const T = class T {
    * @param other - The TimeRange to compare to.
    * @returns True if the TimeRange is equal to the given TimeRange.
    */
-  equals(t, e = g.ZERO) {
+  equals(t, e = a.ZERO) {
     if (e.isZero)
       return this.start.equals(t.start) && this.end.equals(t.end);
-    let r = this.start.sub(t.start).valueOf(), a = this.end.sub(t.end).valueOf();
-    return r < 0 && (r = -r), a < 0 && (a = -a), r <= e.valueOf() && a <= e.valueOf();
+    let s = this.start.sub(t.start).valueOf(), u = this.end.sub(t.end).valueOf();
+    return s < 0 && (s = -s), u < 0 && (u = -u), s <= e.valueOf() && u <= e.valueOf();
   }
   /**
    * Returns a string representation of the TimeRange.
@@ -1012,16 +1025,16 @@ const T = class T {
    * checking for overlap.
    * @returns True if the two TimeRanges overlap, false otherwise.
    */
-  overlapsWith(t, e = g.ZERO) {
+  overlapsWith(t, e = a.ZERO) {
     t = t.makeValid();
-    const r = this.makeValid();
+    const s = this.makeValid();
     if (this.equals(t)) return !0;
-    if (t.end.equals(r.start) || r.end.equals(t.start)) return !1;
-    const a = d.max(r.start, t.start), f = d.min(r.end, t.end);
-    return f.before(a) ? !1 : new g(f.sub(a)).greaterThanOrEqual(e);
+    if (t.end.equals(s.start) || s.end.equals(t.start)) return !1;
+    const u = n.max(s.start, t.start), f = n.min(s.end, t.end);
+    return f.before(u) ? !1 : new a(f.sub(u)).greaterThanOrEqual(e);
   }
   contains(t) {
-    return t instanceof T ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
+    return t instanceof w ? this.contains(t.start) && this.contains(t.end) : this.start.beforeEq(t) && this.end.after(t);
   }
   /**
    * Returns a new TimeRange that is bound by the given TimeRange.
@@ -1035,31 +1048,47 @@ const T = class T {
    * console.log(bounded); // TimeRange(1500, 2000)
    */
   boundBy(t) {
-    const e = new T(this.start, this.end);
+    const e = new w(this.start, this.end);
     return t.start.after(this.start) && (e.start = t.start), t.start.after(this.end) && (e.end = t.start), t.end.before(this.end) && (e.end = t.end), t.end.before(this.start) && (e.start = t.end), e;
   }
   static max(...t) {
-    return new T(
-      d.min(...t.map((e) => e.start)),
-      d.max(...t.map((e) => e.end))
+    return new w(
+      n.min(...t.map((e) => e.start)),
+      n.max(...t.map((e) => e.end))
     );
   }
-};
-/** The maximum possible time range. */
-i(T, "MAX", new T(d.MIN, d.MAX)), /** The minimum possible time range. */
-i(T, "MIN", new T(d.MAX, d.MIN)), /** A time range whose start and end are both zero. */
-i(T, "ZERO", new T(d.ZERO, d.ZERO)), /** A zod schema for validating and transforming time ranges */
-i(T, "z", S([
-  G({ start: d.z, end: d.z }).transform((t) => new T(t.start, t.end)),
-  O(T)
-]));
-let B = T;
-const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 : n.end.before(t.end) ? -1 : n.end.after(t.end) ? 1 : 0, s = class s extends D {
+  /** The maximum possible time range. */
+  static MAX = new w(n.MIN, n.MAX);
+  /** The minimum possible time range. */
+  static MIN = new w(n.MAX, n.MIN);
+  /** A time range whose start and end are both zero. */
+  static ZERO = new w(n.ZERO, n.ZERO);
+  /** A zod schema for validating and transforming time ranges */
+  static z = o.union([
+    o.object({ start: n.z, end: n.z }).transform((t) => new w(t.start, t.end)),
+    o.instanceof(w)
+  ]);
+  /**
+   * Sorts two time ranges. The range with the earlier start time is considered less than
+   * the range with the later start time. If the start times are equal, the range with the
+   * earlier end time is considered less than the range with the later end time.
+   *
+   * @param a - The first time range.
+   * @param b - The second time range.
+   * @returns A number indicating the order of the two time ranges. This number is
+   * positive if a is earlier than b, negative if a is later than b, and 0 if they are
+   * equal.
+   */
+  static sort(t, e) {
+    return n.sort(t.start, e.start) || n.sort(t.end, e.end);
+  }
+}
+class r extends M {
   constructor(t) {
-    if (t instanceof s || typeof t == "string" || typeof t.valueOf() == "string")
+    if (t instanceof r || typeof t == "string" || typeof t.valueOf() == "string")
       super(t.valueOf());
     else {
-      const e = s.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
+      const e = r.ARRAY_CONSTRUCTOR_DATA_TYPES.get(t.constructor.name);
       if (e == null)
         throw new Error(`unable to find data type for ${t.toString()}`);
       super(e.valueOf());
@@ -1069,7 +1098,7 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
    * @returns the TypedArray constructor for the DataType.
    */
   get Array() {
-    const t = s.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;
@@ -1096,7 +1125,7 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
    * @example DataType.INT32.isVariable // false
    */
   get isVariable() {
-    return this.equals(s.JSON) || this.equals(s.STRING);
+    return this.equals(r.JSON) || this.equals(r.STRING);
   }
   /**
    * @returns true if the DataType is numeric.
@@ -1104,7 +1133,7 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
    * @example DataType.STRING.isNumeric // false
    */
   get isNumeric() {
-    return !this.isVariable && !this.equals(s.UUID);
+    return !this.isVariable && !this.equals(r.UUID);
   }
   /**
    * @returns true if the DataType is an integer.
@@ -1129,7 +1158,7 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
    * @example DataType.FLOAT32.density // Density.BIT32
    */
   get density() {
-    const t = s.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;
   }
@@ -1139,7 +1168,7 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
    * @example DataType.INT32.isUnsigned // false
    */
   get isUnsignedInteger() {
-    return this.equals(s.UINT8) || this.equals(s.UINT16) || this.equals(s.UINT32) || this.equals(s.UINT64);
+    return this.equals(r.UINT8) || this.equals(r.UINT16) || this.equals(r.UINT32) || this.equals(r.UINT64);
   }
   /**
    * @returns true if the DataType is a signed integer.
@@ -1147,11 +1176,11 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
    * @example DataType.UINT32.isSigned // false
    */
   get isSignedInteger() {
-    return this.equals(s.INT8) || this.equals(s.INT16) || this.equals(s.INT32) || this.equals(s.INT64);
+    return this.equals(r.INT8) || this.equals(r.INT16) || this.equals(r.INT32) || this.equals(r.INT64);
   }
   /** @returns true if the data type can be cast to the other data type without loss of precision. */
   canSafelyCastTo(t) {
-    return this.equals(t) ? !0 : !this.isNumeric || !t.isNumeric || this.isVariable || t.isVariable || this.isUnsignedInteger && t.isSignedInteger ? !1 : this.isFloat ? t.isFloat && this.density.valueOf() <= t.density.valueOf() : this.equals(s.INT32) && t.equals(s.FLOAT64) || this.equals(s.INT8) && t.equals(s.FLOAT32) ? !0 : this.isInteger && t.isInteger ? this.density.valueOf() <= t.density.valueOf() && this.isUnsignedInteger === t.isUnsignedInteger : !1;
+    return this.equals(t) ? !0 : !this.isNumeric || !t.isNumeric || this.isVariable || t.isVariable || this.isUnsignedInteger && t.isSignedInteger ? !1 : this.isFloat ? t.isFloat && this.density.valueOf() <= t.density.valueOf() : this.equals(r.INT32) && t.equals(r.FLOAT64) || this.equals(r.INT8) && t.equals(r.FLOAT32) ? !0 : this.isInteger && t.isInteger ? this.density.valueOf() <= t.density.valueOf() && this.isUnsignedInteger === t.isUnsignedInteger : !1;
   }
   /** @returns true if the data type can be cast to the other data type, even if there is a loss of precision. */
   canCastTo(t) {
@@ -1168,92 +1197,112 @@ const Te = (n, t) => n.start.before(t.start) ? -1 : n.start.after(t.start) ? 1 :
   }
   /** @returns true if the data type uses bigints to store values. */
   get usesBigInt() {
-    return s.BIG_INT_TYPES.some((t) => t.equals(this));
-  }
-};
-/** Represents an Unknown/Invalid DataType. */
-i(s, "UNKNOWN", new s("unknown")), /** Represents a 64-bit floating point value. */
-i(s, "FLOAT64", new s("float64")), /** Represents a 32-bit floating point value. */
-i(s, "FLOAT32", new s("float32")), /** Represents a 64-bit signed integer value. */
-i(s, "INT64", new s("int64")), /** Represents a 32-bit signed integer value. */
-i(s, "INT32", new s("int32")), /** Represents a 16-bit signed integer value. */
-i(s, "INT16", new s("int16")), /** Represents a 8-bit signed integer value. */
-i(s, "INT8", new s("int8")), /** Represents a 64-bit unsigned integer value. */
-i(s, "UINT64", new s("uint64")), /** Represents a 32-bit unsigned integer value. */
-i(s, "UINT32", new s("uint32")), /** Represents a 16-bit unsigned integer value. */
-i(s, "UINT16", new s("uint16")), /** Represents a 8-bit unsigned integer value. */
-i(s, "UINT8", new s("uint8")), /** Represents a boolean value. Alias for UINT8. */
-i(s, "BOOLEAN", s.UINT8), /** Represents a 64-bit unix epoch. */
-i(s, "TIMESTAMP", new s("timestamp")), /** Represents a UUID data type */
-i(s, "UUID", new s("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
- * by a newline character. */
-i(s, "STRING", new s("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
- * newline character. */
-i(s, "JSON", new s("json")), i(s, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
-  [s.UINT8.toString(), Uint8Array],
-  [s.UINT16.toString(), Uint16Array],
-  [s.UINT32.toString(), Uint32Array],
-  [s.UINT64.toString(), BigUint64Array],
-  [s.FLOAT32.toString(), Float32Array],
-  [s.FLOAT64.toString(), Float64Array],
-  [s.INT8.toString(), Int8Array],
-  [s.INT16.toString(), Int16Array],
-  [s.INT32.toString(), Int32Array],
-  [s.INT64.toString(), BigInt64Array],
-  [s.TIMESTAMP.toString(), BigInt64Array],
-  [s.STRING.toString(), Uint8Array],
-  [s.JSON.toString(), Uint8Array],
-  [s.UUID.toString(), Uint8Array]
-])), i(s, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
-  [Uint8Array.name, s.UINT8],
-  [Uint16Array.name, s.UINT16],
-  [Uint32Array.name, s.UINT32],
-  [BigUint64Array.name, s.UINT64],
-  [Float32Array.name, s.FLOAT32],
-  [Float64Array.name, s.FLOAT64],
-  [Int8Array.name, s.INT8],
-  [Int16Array.name, s.INT16],
-  [Int32Array.name, s.INT32],
-  [BigInt64Array.name, s.INT64]
-])), i(s, "DENSITIES", /* @__PURE__ */ new Map([
-  [s.UINT8.toString(), I.BIT8],
-  [s.UINT16.toString(), I.BIT16],
-  [s.UINT32.toString(), I.BIT32],
-  [s.UINT64.toString(), I.BIT64],
-  [s.FLOAT32.toString(), I.BIT32],
-  [s.FLOAT64.toString(), I.BIT64],
-  [s.INT8.toString(), I.BIT8],
-  [s.INT16.toString(), I.BIT16],
-  [s.INT32.toString(), I.BIT32],
-  [s.INT64.toString(), I.BIT64],
-  [s.TIMESTAMP.toString(), I.BIT64],
-  [s.STRING.toString(), I.UNKNOWN],
-  [s.JSON.toString(), I.UNKNOWN],
-  [s.UUID.toString(), I.BIT128]
-])), /** All the data types. */
-i(s, "ALL", [
-  s.UNKNOWN,
-  s.FLOAT64,
-  s.FLOAT32,
-  s.INT64,
-  s.INT32,
-  s.INT16,
-  s.INT8,
-  s.UINT64,
-  s.UINT32,
-  s.UINT16,
-  s.UINT8,
-  s.TIMESTAMP,
-  s.UUID,
-  s.STRING,
-  s.JSON
-]), i(s, "BIG_INT_TYPES", [s.INT64, s.UINT64, s.TIMESTAMP]), /** A zod schema for a DataType. */
-i(s, "z", S([
-  $().transform((t) => new s(t)),
-  O(s)
-]));
-let m = s;
-const c = class c extends D {
+    return r.BIG_INT_TYPES.some((t) => t.equals(this));
+  }
+  /** Represents an Unknown/Invalid DataType. */
+  static UNKNOWN = new r("unknown");
+  /** Represents a 64-bit floating point value. */
+  static FLOAT64 = new r("float64");
+  /** Represents a 32-bit floating point value. */
+  static FLOAT32 = new r("float32");
+  /** Represents a 64-bit signed integer value. */
+  static INT64 = new r("int64");
+  /** Represents a 32-bit signed integer value. */
+  static INT32 = new r("int32");
+  /** Represents a 16-bit signed integer value. */
+  static INT16 = new r("int16");
+  /** Represents a 8-bit signed integer value. */
+  static INT8 = new r("int8");
+  /** Represents a 64-bit unsigned integer value. */
+  static UINT64 = new r("uint64");
+  /** Represents a 32-bit unsigned integer value. */
+  static UINT32 = new r("uint32");
+  /** Represents a 16-bit unsigned integer value. */
+  static UINT16 = new r("uint16");
+  /** Represents a 8-bit unsigned integer value. */
+  static UINT8 = new r("uint8");
+  /** Represents a boolean value. Alias for UINT8. */
+  static BOOLEAN = this.UINT8;
+  /** Represents a 64-bit unix epoch. */
+  static TIMESTAMP = new r("timestamp");
+  /** Represents a UUID data type */
+  static UUID = new r("uuid");
+  /** Represents a string data type. Strings have an unknown density, and are separate
+   * by a newline character. */
+  static STRING = new r("string");
+  /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+   * newline character. */
+  static JSON = new r("json");
+  static 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]
+  ]);
+  static 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]
+  ]);
+  static DENSITIES = /* @__PURE__ */ new Map([
+    [r.UINT8.toString(), d.BIT8],
+    [r.UINT16.toString(), d.BIT16],
+    [r.UINT32.toString(), d.BIT32],
+    [r.UINT64.toString(), d.BIT64],
+    [r.FLOAT32.toString(), d.BIT32],
+    [r.FLOAT64.toString(), d.BIT64],
+    [r.INT8.toString(), d.BIT8],
+    [r.INT16.toString(), d.BIT16],
+    [r.INT32.toString(), d.BIT32],
+    [r.INT64.toString(), d.BIT64],
+    [r.TIMESTAMP.toString(), d.BIT64],
+    [r.STRING.toString(), d.UNKNOWN],
+    [r.JSON.toString(), d.UNKNOWN],
+    [r.UUID.toString(), d.BIT128]
+  ]);
+  /** All the data types. */
+  static 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
+  ];
+  static BIG_INT_TYPES = [r.INT64, r.UINT64, r.TIMESTAMP];
+  /** A zod schema for a DataType. */
+  static z = o.union([
+    o.string().transform((t) => new r(t)),
+    o.instanceof(r)
+  ]);
+}
+class h extends M {
   constructor(t) {
     super(t.valueOf());
   }
@@ -1267,41 +1316,41 @@ const c = class c extends D {
   }
   /** @returns a new Size representing the sum of the two Sizes. */
   add(t) {
-    return c.bytes(this.valueOf() + t.valueOf());
+    return h.bytes(this.valueOf() + t.valueOf());
   }
   /** @returns a new Size representing the difference of the two Sizes. */
   sub(t) {
-    return c.bytes(this.valueOf() - t.valueOf());
+    return h.bytes(this.valueOf() - t.valueOf());
   }
   /** @returns a new Size representing the truncated value of the Size. */
   truncate(t) {
-    return new c(Math.trunc(this.valueOf() / t.valueOf()) * t.valueOf());
+    return new h(Math.trunc(this.valueOf() / t.valueOf()) * t.valueOf());
   }
   /** @returns a new Size representing the remainder of the Size. */
   remainder(t) {
-    return c.bytes(this.valueOf() % t.valueOf());
+    return h.bytes(this.valueOf() % t.valueOf());
   }
   /** @returns the number of gigabytes in the Size. */
   get gigabytes() {
-    return this.valueOf() / c.GIGABYTE.valueOf();
+    return this.valueOf() / h.GIGABYTE.valueOf();
   }
   /** @returns the number of megabytes in the Size. */
   get megabytes() {
-    return this.valueOf() / c.MEGABYTE.valueOf();
+    return this.valueOf() / h.MEGABYTE.valueOf();
   }
   /** @returns the number of kilobytes in the Size. */
   get kilobytes() {
-    return this.valueOf() / c.KILOBYTE.valueOf();
+    return this.valueOf() / h.KILOBYTE.valueOf();
   }
   /** @returns the number of terabytes in the Size. */
   get terabytes() {
-    return this.valueOf() / c.TERABYTE.valueOf();
+    return this.valueOf() / h.TERABYTE.valueOf();
   }
   /** @returns a nicely formatted string representation of the Size. */
   toString() {
-    const t = this.truncate(c.TERABYTE), e = this.truncate(c.GIGABYTE), r = this.truncate(c.MEGABYTE), a = this.truncate(c.KILOBYTE), f = this.truncate(c.BYTE), h = t, A = e.sub(t), y = r.sub(e), p = a.sub(r), E = f.sub(a);
+    const t = this.truncate(h.TERABYTE), e = this.truncate(h.GIGABYTE), s = this.truncate(h.MEGABYTE), u = this.truncate(h.KILOBYTE), f = this.truncate(h.BYTE), c = t, y = e.sub(t), g = s.sub(e), b = u.sub(s), N = f.sub(u);
     let l = "";
-    return h.isZero || (l += `${h.terabytes}TB `), A.isZero || (l += `${A.gigabytes}GB `), y.isZero || (l += `${y.megabytes}MB `), p.isZero || (l += `${p.kilobytes}KB `), (!E.isZero || l === "") && (l += `${E.valueOf()}B`), l.trim();
+    return c.isZero || (l += `${c.terabytes}TB `), y.isZero || (l += `${y.gigabytes}GB `), g.isZero || (l += `${g.megabytes}MB `), b.isZero || (l += `${b.kilobytes}KB `), (!N.isZero || l === "") && (l += `${N.valueOf()}B`), l.trim();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -1310,8 +1359,10 @@ const c = class c extends D {
    * @returns A Size representing the given number of bytes.
    */
   static bytes(t = 1) {
-    return new c(t);
+    return new h(t);
   }
+  /** A single byte */
+  static BYTE = new h(1);
   /**
    * Creates a Size from the given number if kilobytes.
    *
@@ -1319,8 +1370,10 @@ const c = class c extends D {
    * @returns A Size representing the given number of kilobytes.
    */
   static kilobytes(t = 1) {
-    return c.bytes(t.valueOf() * 1e3);
+    return h.bytes(t.valueOf() * 1e3);
   }
+  /** A kilobyte */
+  static KILOBYTE = h.kilobytes(1);
   /**
    * Creates a Size from the given number of megabytes.
    *
@@ -1328,8 +1381,10 @@ const c = class c extends D {
    * @returns A Size representing the given number of megabytes.
    */
   static megabytes(t = 1) {
-    return c.kilobytes(t.valueOf() * 1e3);
+    return h.kilobytes(t.valueOf() * 1e3);
   }
+  /** A megabyte */
+  static MEGABYTE = h.megabytes(1);
   /**
    * Creates a Size from the given number of gigabytes.
    *
@@ -1337,8 +1392,10 @@ const c = class c extends D {
    * @returns A Size representing the given number of gigabytes.
    */
   static gigabytes(t = 1) {
-    return c.megabytes(t.valueOf() * 1e3);
+    return h.megabytes(t.valueOf() * 1e3);
   }
+  /** A gigabyte */
+  static GIGABYTE = h.gigabytes(1);
   /**
    * Creates a Size from the given number of terabytes.
    *
@@ -1346,96 +1403,156 @@ const c = class c extends D {
    * @returns  A Size representing the given number of terabytes.
    */
   static terabytes(t) {
-    return c.gigabytes(t.valueOf() * 1e3);
-  }
+    return h.gigabytes(t.valueOf() * 1e3);
+  }
+  /** A terabyte. */
+  static TERABYTE = h.terabytes(1);
+  /** The zero value for Size */
+  static ZERO = new h(0);
+  /** A zod schema for a Size. */
+  static z = o.union([
+    o.number().transform((t) => new h(t)),
+    o.instanceof(h)
+  ]);
   /** @returns true if the Size is zero. */
   get isZero() {
     return this.valueOf() === 0;
   }
-};
-/** A single byte */
-i(c, "BYTE", new c(1)), /** A kilobyte */
-i(c, "KILOBYTE", c.kilobytes(1)), /** A megabyte */
-i(c, "MEGABYTE", c.megabytes(1)), /** A gigabyte */
-i(c, "GIGABYTE", c.gigabytes(1)), /** A terabyte. */
-i(c, "TERABYTE", c.terabytes(1)), /** The zero value for Size */
-i(c, "ZERO", new c(0)), /** A zod schema for a Size. */
-i(c, "z", S([
-  P().transform((t) => new c(t)),
-  O(c)
-]));
-let L = c;
-const Ne = S([
-  O(Uint8Array),
-  O(Uint16Array),
-  O(Uint32Array),
-  O(BigUint64Array),
-  O(Float32Array),
-  O(Float64Array),
-  O(Int8Array),
-  O(Int16Array),
-  O(Int32Array),
-  O(BigInt64Array)
-]), ut = (n) => {
-  const t = typeof n;
-  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || n instanceof d || n instanceof g || n instanceof Date;
-}, kt = (n, t, e, r = 0) => n.usesBigInt && !t.usesBigInt ? Number(e) - Number(r) : !n.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(r.valueOf()) : Z(e, -r).valueOf(), Z = (n, t) => t == 0 ? n : n == 0 ? t : typeof n == "bigint" && typeof t == "bigint" || typeof n == "number" && typeof t == "number" ? n + t : Number(n) + Number(t), Gt = "00000000-0000-0000-0000-000000000000", Jt = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-function jt(n) {
-  return typeof n == "string" && Jt.test(n);
 }
-const w = [];
-for (let n = 0; n < 256; ++n)
-  w.push((n + 256).toString(16).slice(1));
-function ot(n, t = 0) {
-  return (w[n[t + 0]] + w[n[t + 1]] + w[n[t + 2]] + w[n[t + 3]] + "-" + w[n[t + 4]] + w[n[t + 5]] + "-" + w[n[t + 6]] + w[n[t + 7]] + "-" + w[n[t + 8]] + w[n[t + 9]] + "-" + w[n[t + 10]] + w[n[t + 11]] + w[n[t + 12]] + w[n[t + 13]] + w[n[t + 14]] + w[n[t + 15]]).toLowerCase();
+const Yt = 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)
+]), H = (i) => {
+  const t = typeof i;
+  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || i instanceof n || i instanceof a || i instanceof Date;
+}, ot = (i, t, e, s = 0) => i.usesBigInt && !t.usesBigInt ? Number(e) - Number(s) : !i.usesBigInt && t.usesBigInt ? BigInt(e.valueOf()) - BigInt(s.valueOf()) : x(e, -s), x = (i, t) => t == 0 ? i : i == 0 ? t : typeof i == "bigint" && typeof t == "bigint" || typeof i == "number" && typeof t == "number" ? i + t : Number(i) + Number(t), lt = "00000000-0000-0000-0000-000000000000", ft = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function ct(i) {
+  return typeof i == "string" && ft.test(i);
 }
-function Wt(n, t = 0) {
-  const e = ot(n, t);
-  if (!jt(e))
+const O = [];
+for (let i = 0; i < 256; ++i)
+  O.push((i + 256).toString(16).slice(1));
+function K(i, t = 0) {
+  return (O[i[t + 0]] + O[i[t + 1]] + O[i[t + 2]] + O[i[t + 3]] + "-" + O[i[t + 4]] + O[i[t + 5]] + "-" + O[i[t + 6]] + O[i[t + 7]] + "-" + O[i[t + 8]] + O[i[t + 9]] + "-" + O[i[t + 10]] + O[i[t + 11]] + O[i[t + 12]] + O[i[t + 13]] + O[i[t + 14]] + O[i[t + 15]]).toLowerCase();
+}
+function ht(i, t = 0) {
+  const e = K(i, t);
+  if (!ct(e))
     throw TypeError("Stringified UUID is invalid");
   return e;
 }
-let J;
-const Ht = new Uint8Array(16);
-function Kt() {
-  if (!J) {
+let T;
+const dt = new Uint8Array(16);
+function gt() {
+  if (!T) {
     if (typeof crypto > "u" || !crypto.getRandomValues)
       throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-    J = crypto.getRandomValues.bind(crypto);
+    T = crypto.getRandomValues.bind(crypto);
   }
-  return J(Ht);
+  return T(dt);
 }
-const zt = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), _ = { randomUUID: zt };
-function Xt(n, t, e) {
-  var a;
-  if (_.randomUUID && !n)
-    return _.randomUUID();
-  n = n || {};
-  const r = n.random ?? ((a = n.rng) == null ? void 0 : a.call(n)) ?? Kt();
-  if (r.length < 16)
+const Ot = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), Z = { randomUUID: Ot };
+function wt(i, t, e) {
+  if (Z.randomUUID && !i)
+    return Z.randomUUID();
+  i = i || {};
+  const s = i.random ?? i.rng?.() ?? gt();
+  if (s.length < 16)
     throw new Error("Random bytes length must be >= 16");
-  return r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128, ot(r);
+  return s[6] = s[6] & 15 | 64, s[8] = s[8] & 63 | 128, K(s);
 }
-const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const bt = () => wt(), P = (i, t) => ht(i, t), It = lt, Zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ZERO: _t,
-  create: Qt,
-  parse: lt
-}, Symbol.toStringTag, { value: "Module" })), R = -1, H = {
-  [Symbol.iterator]: () => H,
+  ZERO: It,
+  create: bt,
+  parse: P
+}, Symbol.toStringTag, { value: "Module" })), A = -1, p = {
+  [Symbol.iterator]: () => p,
   next: () => ({ done: !0, value: void 0 })
-}, te = $().transform(
-  (n) => new Uint8Array(
-    atob(n).split("").map((t) => t.charCodeAt(0))
+}, yt = o.string().transform(
+  (i) => new Uint8Array(
+    atob(i).split("").map((t) => t.charCodeAt(0))
   ).buffer
-), ee = S([Ct(), Rt()]).transform(() => new Uint8Array().buffer), K = 10, ft = (n, t) => {
-  if (n === "string" && !t.isVariable)
-    throw new Error(`cannot convert series of type ${t.toString()} to string`);
-  if (n === "number" && !t.isNumeric)
+), Nt = o.union([o.null(), o.undefined()]).transform(() => new Uint8Array().buffer), q = 10, D = (i, t) => {
+  if (i === "number" && !t.isNumeric)
     throw new Error(`cannot convert series of type ${t.toString()} to number`);
-  if (n === "bigint" && !t.usesBigInt)
+  if (i === "bigint" && !t.usesBigInt)
     throw new Error(`cannot convert series of type ${t.toString()} to bigint`);
-}, ct = "sy_x_telem_series", N = class N {
+}, X = "sy_x_telem_series";
+class I {
+  /**
+   * A unique identifier for the series. If specified by the user, it is their
+   * responsibility to ensure that it is unique. If not specified, a new ID will be
+   * generated.
+   */
+  key;
+  /**
+   * A discriminator used for identifying instances of the series class even
+   * when bundlers mangle the class name.
+   */
+  discriminator = X;
+  /** The data type of the series. */
+  dataType;
+  /**
+   * A sample offset that can be used to shift the values of all samples upwards or
+   * downwards. Useful to convert series to lower precision data types while preserving
+   * the relative range of actual values.
+   */
+  sampleOffset;
+  /**
+   * Stores information about the buffer state of this array into a WebGL buffer.
+   */
+  gl;
+  /** The underlying data. */
+  _data;
+  /** The time range occupied by the series' data. */
+  timeRange = w.ZERO;
+  /**
+   * Alignment defines the location of the series relative to other series in a logical
+   * group. Useful for defining the position of the series within a channel's data.
+   */
+  alignment = 0n;
+  /** A cached minimum value. */
+  cachedMin;
+  /** A cached maximum value. */
+  cachedMax;
+  /** The write position of the buffer. */
+  writePos = A;
+  /** Tracks the number of entities currently using this array. */
+  _refCount = 0;
+  /** Caches the length of the array for variable length data types. */
+  cachedLength;
+  /** Caches the indexes of the array for variable length data types. */
+  _cachedIndexes;
+  /**
+   * A zod schema that can be used to validate that a particular value
+   * can be constructed into a series.
+   */
+  static crudeZ = o.object({
+    timeRange: w.z.optional(),
+    dataType: r.z,
+    alignment: o.coerce.bigint().optional(),
+    data: o.union([
+      yt,
+      Nt,
+      o.instanceof(ArrayBuffer),
+      o.instanceof(Uint8Array)
+    ]),
+    glBufferUsage: at.optional().default("static").optional()
+  });
+  /**
+   * A zod schema that validates and constructs a series from it's crude
+   * representation.
+   */
+  static z = I.crudeZ.transform((t) => new I(t));
   /**
    * The Series constructor accepts either a SeriesArgs object or a CrudeSeries value.
    *
@@ -1510,111 +1627,69 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @throws Error if data type cannot be inferred from input
    */
   constructor(t) {
-    /**
-     * A unique identifier for the series. If specified by the user, it is their
-     * responsibility to ensure that it is unique. If not specified, a new ID will be
-     * generated.
-     */
-    i(this, "key");
-    /**
-     * A discriminator used for identifying instances of the series class even
-     * when bundlers mangle the class name.
-     */
-    i(this, "discriminator", ct);
-    /** The data type of the series. */
-    i(this, "dataType");
-    /**
-     * A sample offset that can be used to shift the values of all samples upwards or
-     * downwards. Useful to convert series to lower precision data types while preserving
-     * the relative range of actual values.
-     */
-    i(this, "sampleOffset");
-    /**
-     * Stores information about the buffer state of this array into a WebGL buffer.
-     */
-    i(this, "gl");
-    /** The underlying data. */
-    i(this, "_data");
-    /** The time range occupied by the series' data. */
-    i(this, "timeRange", B.ZERO);
-    /**
-     * Alignment defines the location of the series relative to other series in a logical
-     * group. Useful for defining the position of the series within a channel's data.
-     */
-    i(this, "alignment", 0n);
-    /** A cached minimum value. */
-    i(this, "cachedMin");
-    /** A cached maximum value. */
-    i(this, "cachedMax");
-    /** The write position of the buffer. */
-    i(this, "writePos", R);
-    /** Tracks the number of entities currently using this array. */
-    i(this, "_refCount", 0);
-    /** Caches the length of the array for variable length data types. */
-    i(this, "cachedLength");
-    /** Caches the indexes of the array for variable length data types. */
-    i(this, "_cachedIndexes");
-    re(t) && (t = { data: t }), t.data ?? (t.data = []);
+    mt(t) && (t = { data: t }), t.data ??= [];
     const {
       dataType: e,
-      timeRange: r,
-      sampleOffset: a = 0,
+      timeRange: s,
+      sampleOffset: u = 0,
       glBufferUsage: f = "static",
-      alignment: h = 0n,
-      key: A = nt(),
-      data: y
+      alignment: c = 0n,
+      key: y = J(),
+      data: g
     } = t;
-    if (ht(y)) {
-      const l = y;
+    if (Q(g)) {
+      const l = g;
       this.key = l.key, this.dataType = l.dataType, this.sampleOffset = l.sampleOffset, this.gl = l.gl, this._data = l._data, this.timeRange = l.timeRange, this.alignment = l.alignment, this.cachedMin = l.cachedMin, this.cachedMax = l.cachedMax, this.writePos = l.writePos, this._refCount = l._refCount, this.cachedLength = l.cachedLength;
       return;
     }
-    const p = ut(y), E = Array.isArray(y);
-    if (e != null) this.dataType = new m(e);
+    const b = H(g), N = Array.isArray(g);
+    if (e != null) this.dataType = new r(e);
     else {
-      if (y instanceof ArrayBuffer)
+      if (g instanceof ArrayBuffer)
         throw new Error(
           "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
         );
-      if (E || p) {
-        let l = y;
-        if (!p) {
-          if (y.length === 0)
+      if (N || b) {
+        let l = g;
+        if (!b) {
+          if (g.length === 0)
             throw new Error(
               "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
             );
-          l = y[0];
+          l = g[0];
         }
-        if (typeof l == "string") this.dataType = m.STRING;
-        else if (typeof l == "number") this.dataType = m.FLOAT64;
-        else if (typeof l == "bigint") this.dataType = m.INT64;
-        else if (typeof l == "boolean") this.dataType = m.BOOLEAN;
-        else if (l instanceof d || l instanceof Date || l instanceof d)
-          this.dataType = m.TIMESTAMP;
-        else if (typeof l == "object") this.dataType = m.JSON;
+        if (typeof l == "string") this.dataType = r.STRING;
+        else if (typeof l == "number") this.dataType = r.FLOAT64;
+        else if (typeof l == "bigint") this.dataType = r.INT64;
+        else if (typeof l == "boolean") this.dataType = r.BOOLEAN;
+        else if (l instanceof n || l instanceof Date || l instanceof n)
+          this.dataType = r.TIMESTAMP;
+        else if (typeof l == "object") this.dataType = r.JSON;
         else
           throw new Error(
             `cannot infer data type of ${typeof l} when constructing a Series from a JS array`
           );
-      } else this.dataType = new m(y);
+      } else this.dataType = new r(g);
     }
-    if (!E && !p) this._data = y;
+    if (!N && !b) this._data = g;
+    else if (N && g.length === 0)
+      this._data = new this.dataType.Array([]).buffer;
     else {
-      let l = p ? [y] : y;
-      const M = l[0];
-      (M instanceof d || M instanceof Date || M instanceof g) && (l = l.map((v) => new d(v).valueOf())), this.dataType.equals(m.STRING) ? (this.cachedLength = l.length, this._data = new TextEncoder().encode(`${l.join(`
+      let l = b ? [g] : g;
+      const m = l[0];
+      (m instanceof n || m instanceof Date || m instanceof a) && (l = l.map((v) => new n(v).valueOf())), this.dataType.equals(r.STRING) ? (this.cachedLength = l.length, this._data = new TextEncoder().encode(`${l.join(`
 `)}
-`).buffer) : this.dataType.equals(m.JSON) ? (this.cachedLength = l.length, this._data = new TextEncoder().encode(
-        `${l.map((v) => W.encodeString(v)).join(`
+`).buffer) : this.dataType.equals(r.JSON) ? (this.cachedLength = l.length, this._data = new TextEncoder().encode(
+        `${l.map((v) => L.encodeString(v)).join(`
 `)}
 `
-      ).buffer) : this.dataType.usesBigInt && typeof M == "number" ? this._data = new this.dataType.Array(
+      ).buffer) : this.dataType.usesBigInt && typeof m == "number" ? this._data = new this.dataType.Array(
         l.map((v) => BigInt(Math.round(v)))
-      ).buffer : !this.dataType.usesBigInt && typeof M == "bigint" ? this._data = new this.dataType.Array(
-        l.map((v) => Number(v))
+      ).buffer : !this.dataType.usesBigInt && typeof m == "bigint" ? this._data = new this.dataType.Array(
+        l.map(Number)
       ).buffer : this._data = new this.dataType.Array(l).buffer;
     }
-    this.key = A, this.alignment = h, this.sampleOffset = a ?? 0, this.timeRange = r ?? B.ZERO, this.gl = {
+    this.key = y, this.alignment = c, this.sampleOffset = u ?? 0, this.timeRange = s ?? w.ZERO, this.gl = {
       control: null,
       buffer: null,
       prevBuffer: 0,
@@ -1628,10 +1703,10 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @param args.dataType the data type of the series.
    * @param args.rest the rest of the arguments to pass to the series constructor.
    */
-  static alloc({ capacity: t, dataType: e, ...r }) {
+  static alloc({ capacity: t, dataType: e, ...s }) {
     if (t === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
-    const a = new new m(e).Array(t), f = new N({ data: a.buffer, dataType: e, ...r });
+    const u = new new r(e).Array(t), f = new I({ data: u.buffer, dataType: e, ...s });
     return f.writePos = 0, f;
   }
   /**
@@ -1674,14 +1749,14 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
     return this.dataType.isVariable ? this.writeVariable(t) : this.writeFixed(t);
   }
   writeVariable(t) {
-    if (this.writePos === R) return 0;
-    const e = this.byteCapacity.valueOf() - this.writePos, r = t.subBytes(0, e);
-    return this.writeToUnderlyingData(r), this.writePos += r.byteLength.valueOf(), this.cachedLength != null && (this.cachedLength += r.length, this.calculateCachedLength()), r.length;
+    if (this.writePos === A) return 0;
+    const e = this.byteCapacity.valueOf() - this.writePos, s = t.subBytes(0, e);
+    return this.writeToUnderlyingData(s), this.writePos += s.byteLength.valueOf(), this.cachedLength != null && (this.cachedLength += s.length, this.calculateCachedLength()), s.length;
   }
   writeFixed(t) {
-    if (this.writePos === R) return 0;
-    const e = this.capacity - this.writePos, r = t.sub(0, e);
-    return this.writeToUnderlyingData(r), this.cachedLength = void 0, this.maybeRecomputeMinMax(r), this.writePos += r.length, r.length;
+    if (this.writePos === A) return 0;
+    const e = this.capacity - this.writePos, s = t.sub(0, e);
+    return this.writeToUnderlyingData(s), this.cachedLength = void 0, this.maybeRecomputeMinMax(s), this.writePos += s.length, s.length;
   }
   writeToUnderlyingData(t) {
     this.underlyingData.set(
@@ -1702,7 +1777,7 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns A typed array containing the series data.
    */
   get data() {
-    return this.writePos === R ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
+    return this.writePos === A ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
   }
   /**
    * Returns an array of the values in the series as strings.
@@ -1713,17 +1788,6 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
     return this.dataType.isVariable ? new TextDecoder().decode(this.underlyingData).split(`
 `).slice(0, -1) : Array.from(this).map((t) => t.toString());
   }
-  /**
-   * Returns a parsed array of UUIDs from the series.
-   * @throws Error if the series does not have a data type of UUID.
-   * @returns An array of UUID strings.
-   */
-  toUUIDs() {
-    if (!this.dataType.equals(m.UUID))
-      throw new Error("cannot convert non-uuid series to uuids");
-    const t = m.UUID.density.valueOf(), e = new Uint8Array(this.underlyingData.buffer);
-    return Array.from({ length: this.length }, (r, a) => lt(e, a * t));
-  }
   /**
    * Parses a JSON series into an array of values using the provided zod schema.
    * @template Z The zod schema type.
@@ -1732,16 +1796,16 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns An array of values parsed from the JSON series.
    */
   parseJSON(t) {
-    if (!this.dataType.equals(m.JSON))
+    if (!this.dataType.equals(r.JSON))
       throw new Error("cannot parse non-JSON series as JSON");
-    return this.toStrings().map((e) => t.parse(W.decodeString(e)));
+    return this.toStrings().map((e) => t.parse(L.decodeString(e)));
   }
   /**
    * Returns the capacity of the series in bytes.
    * @returns The size of the underlying buffer in bytes.
    */
   get byteCapacity() {
-    return new L(this.underlyingData.byteLength);
+    return new h(this.underlyingData.byteLength);
   }
   /**
    * Returns the capacity of the series in samples.
@@ -1757,7 +1821,7 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns The size of the data in bytes.
    */
   get byteLength() {
-    return this.writePos === R ? this.byteCapacity : this.dataType.isVariable ? new L(this.writePos) : this.dataType.density.size(this.writePos);
+    return this.writePos === A ? this.byteCapacity : this.dataType.isVariable ? new h(this.writePos) : this.dataType.density.size(this.writePos);
   }
   /**
    * Returns the number of samples in this array.
@@ -1765,15 +1829,15 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns The number of samples in the series.
    */
   get length() {
-    return this.cachedLength != null ? this.cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === R ? this.byteCapacity.valueOf() / this.dataType.density.valueOf() : this.writePos;
+    return this.cachedLength != null ? this.cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === A ? this.byteCapacity.valueOf() / this.dataType.density.valueOf() : this.writePos;
   }
   calculateCachedLength() {
     if (!this.dataType.isVariable)
       throw new Error("cannot calculate length of a non-variable length data type");
     let t = 0;
     const e = [0];
-    return this.data.forEach((r, a) => {
-      r === K && (t++, e.push(a + 1));
+    return this.data.forEach((s, u) => {
+      s === q && (t++, e.push(u + 1));
     }), this._cachedIndexes = e, this.cachedLength = t, t;
   }
   /**
@@ -1787,11 +1851,11 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    */
   convert(t, e = 0) {
     if (this.dataType.equals(t)) return this;
-    const r = new t.Array(this.length);
-    for (let a = 0; a < this.length; a++)
-      r[a] = kt(this.dataType, t, this.data[a], e);
-    return new N({
-      data: r.buffer,
+    const s = new t.Array(this.length);
+    for (let u = 0; u < this.length; u++)
+      s[u] = ot(this.dataType, t, this.data[u], e);
+    return new I({
+      data: s.buffer,
       dataType: t,
       timeRange: this.timeRange,
       sampleOffset: e,
@@ -1801,14 +1865,14 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
   }
   calcRawMax() {
     if (this.length === 0) return -1 / 0;
-    if (this.dataType.equals(m.TIMESTAMP))
+    if (this.dataType.equals(r.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, s) => e > s ? e : s);
     } else {
       const t = this.data;
-      this.cachedMax = t.reduce((e, r) => e > r ? e : r);
+      this.cachedMax = t.reduce((e, s) => e > s ? e : s);
     }
     return this.cachedMax;
   }
@@ -1819,17 +1883,17 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
   calcMax() {
     if (this.dataType.isVariable)
       throw new Error("cannot calculate maximum on a variable length data type");
-    return this.writePos === 0 ? -1 / 0 : (this.cachedMax ?? (this.cachedMax = this.calcRawMax()), Z(this.cachedMax, this.sampleOffset));
+    return this.writePos === 0 ? -1 / 0 : (this.cachedMax ??= this.calcRawMax(), x(this.cachedMax, this.sampleOffset));
   }
   calcRawMin() {
     if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(m.TIMESTAMP)) this.cachedMin = this.data[0];
+    if (this.dataType.equals(r.TIMESTAMP)) this.cachedMin = this.data[0];
     else if (this.dataType.usesBigInt) {
       const t = this.data;
-      this.cachedMin = t.reduce((e, r) => e < r ? e : r);
+      this.cachedMin = t.reduce((e, s) => e < s ? e : s);
     } else {
       const t = this.data;
-      this.cachedMin = t.reduce((e, r) => e < r ? e : r);
+      this.cachedMin = t.reduce((e, s) => e < s ? e : s);
     }
     return this.cachedMin;
   }
@@ -1840,11 +1904,11 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
   calcMin() {
     if (this.dataType.isVariable)
       throw new Error("cannot calculate minimum on a variable length data type");
-    return this.writePos === 0 ? 1 / 0 : (this.cachedMin ?? (this.cachedMin = this.calcRawMin()), Z(this.cachedMin, this.sampleOffset));
+    return this.writePos === 0 ? 1 / 0 : (this.cachedMin ??= this.calcRawMin(), x(this.cachedMin, this.sampleOffset));
   }
   /** @returns the bounds of the series. */
   get bounds() {
-    return q(Number(this.min), Number(this.max), { makeValid: !1 });
+    return C(Number(this.min), Number(this.max), { makeValid: !1 });
   }
   maybeRecomputeMinMax(t) {
     if (this.cachedMin != null) {
@@ -1857,44 +1921,56 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
     }
   }
   atAlignment(t, e) {
-    const r = Number(t - this.alignment);
-    if (r < 0 || r >= this.length) {
-      if (e === !0) throw new Error(`[series] - no value at index ${r}`);
+    const s = Number(t - this.alignment);
+    if (s < 0 || s >= this.length) {
+      if (e === !0) throw new Error(`[series] - no value at index ${s}`);
       return;
     }
-    return this.at(r, e);
+    return this.at(s, e);
   }
-  at(t, e) {
+  at(t, e = !1) {
     if (this.dataType.isVariable) return this.atVariable(t, e ?? !1);
+    if (this.dataType.equals(r.UUID)) return this.atUUID(t, e);
     t < 0 && (t = this.length + t);
-    const r = this.data[t];
-    if (r == null) {
+    const s = this.data[t];
+    if (s == null) {
       if (e === !0) throw new Error(`[series] - no value at index ${t}`);
       return;
     }
-    return Z(r, this.sampleOffset);
+    return x(s, this.sampleOffset);
+  }
+  atUUID(t, e) {
+    t < 0 && (t = this.length + t);
+    const s = P(
+      new Uint8Array(this.buffer, t * this.dataType.density.valueOf())
+    );
+    if (s == null) {
+      if (e) throw new Error(`[series] - no value at index ${t}`);
+      return;
+    }
+    return s;
   }
   atVariable(t, e) {
-    let r = 0, a = 0;
+    let s = 0, u = 0;
     if (this._cachedIndexes != null)
-      r = this._cachedIndexes[t], a = this._cachedIndexes[t + 1] - 1;
+      s = this._cachedIndexes[t], u = 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] === K) {
+      for (let c = 0; c < this.data.length; c++)
+        if (this.data[c] === q) {
           if (t === 0) {
-            a = h;
+            u = c;
             break;
           }
-          r = h + 1, t--;
+          s = c + 1, t--;
         }
-      if (a === 0 && (a = this.data.length), r >= a || t > 0) {
+      if (u === 0 && (u = this.data.length), s >= u || t > 0) {
         if (e) throw new Error(`[series] - no value at index ${t}`);
         return;
       }
     }
-    const f = this.data.slice(r, a);
-    return this.dataType.equals(m.STRING) ? new TextDecoder().decode(f) : mt(JSON.parse(new TextDecoder().decode(f)));
+    const f = this.data.slice(s, u);
+    return this.dataType.equals(r.STRING) ? new TextDecoder().decode(f) : z(JSON.parse(new TextDecoder().decode(f)));
   }
   /**
    * @returns the index of the first sample that is greater than or equal to the given value.
@@ -1902,12 +1978,12 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @param value the value to search for.
    */
   binarySearch(t) {
-    let e = 0, r = this.length - 1;
-    const a = Ot(t);
-    for (; e <= r; ) {
-      const f = Math.floor((e + r) / 2), h = a(this.at(f, !0), t);
-      if (h === 0) return f;
-      h < 0 ? e = f + 1 : r = f - 1;
+    let e = 0, s = this.length - 1;
+    const u = _(t);
+    for (; e <= s; ) {
+      const f = Math.floor((e + s) / 2), c = u(this.at(f, !0), t);
+      if (c === 0) return f;
+      c < 0 ? e = f + 1 : s = f - 1;
     }
     return e;
   }
@@ -1919,23 +1995,23 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * be the same buffer previously passed to {@method acquire} or {@method updateGLBuffer}.
    */
   updateGLBuffer(t) {
-    if (this.gl.control = t, !this.dataType.equals(m.FLOAT32) && !this.dataType.equals(m.UINT8))
+    if (this.gl.control = t, !this.dataType.equals(r.FLOAT32) && !this.dataType.equals(r.UINT8))
       throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
-    const { buffer: e, bufferUsage: r, prevBuffer: a } = this.gl;
-    if (e == null && (this.gl.buffer = t.createBuffer()), this.writePos !== a)
-      if (t.bindBuffer(t.ARRAY_BUFFER, this.gl.buffer), this.writePos !== R) {
-        a === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
-        const f = this.dataType.density.size(a).valueOf(), h = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
-        t.bufferSubData(t.ARRAY_BUFFER, f, h.buffer), this.gl.prevBuffer = this.writePos;
+    const { buffer: e, bufferUsage: s, 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 !== A) {
+        u === 0 && t.bufferData(t.ARRAY_BUFFER, this.byteCapacity.valueOf(), t.STATIC_DRAW);
+        const f = this.dataType.density.size(u).valueOf(), c = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
+        t.bufferSubData(t.ARRAY_BUFFER, f, c.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 = R;
+          s === "static" ? t.STATIC_DRAW : t.DYNAMIC_DRAW
+        ), this.gl.prevBuffer = A;
   }
   as(t) {
-    return ft(t, this.dataType), this;
+    return D(t, this.dataType), this;
   }
   /** @returns a digest containing information about the series. */
   get digest() {
@@ -1944,8 +2020,8 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
       dataType: this.dataType.toString(),
       sampleOffset: this.sampleOffset,
       alignment: {
-        lower: et(this.alignmentBounds.lower),
-        upper: et(this.alignmentBounds.upper)
+        lower: k(this.alignmentBounds.lower),
+        upper: k(this.alignmentBounds.upper)
       },
       timeRange: this.timeRange.toString(),
       length: this.length,
@@ -1962,7 +2038,7 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * is exclusive.
    */
   get alignmentBounds() {
-    return q(this.alignment, this.alignment + BigInt(this.length));
+    return C(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);
@@ -1979,10 +2055,10 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
   }
   [Symbol.iterator]() {
     if (this.dataType.isVariable) {
-      const t = new se(this);
-      return this.dataType.equals(m.JSON) ? new z(t) : t;
+      const t = new vt(this);
+      return this.dataType.equals(r.JSON) ? new $(t) : t;
     }
-    return new ne(this);
+    return this.dataType.equals(r.UUID) ? new Ut(this) : new At(this);
   }
   /**
    * Returns a slice of the series from start to end.
@@ -2009,7 +2085,7 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns An iterator over the specified range.
    */
   subIterator(t, e) {
-    return new tt(this, t, e ?? this.length);
+    return new V(this, t, e ?? this.length);
   }
   /**
    * Returns an iterator over a portion of the series based on alignment.
@@ -2018,7 +2094,7 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns An iterator over the specified alignment range.
    */
   subAlignmentIterator(t, e) {
-    return new tt(
+    return new V(
       this,
       Number(t - this.alignment),
       Number(e - this.alignment)
@@ -2026,9 +2102,9 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
   }
   subBytes(t, e) {
     if (t >= 0 && (e == null || e >= this.byteLength.valueOf())) return this;
-    const r = this.data.subarray(t, e);
-    return new N({
-      data: r,
+    const s = this.data.subarray(t, e);
+    return new I({
+      data: s,
       dataType: this.dataType,
       timeRange: this.timeRange,
       sampleOffset: this.sampleOffset,
@@ -2036,11 +2112,11 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
       alignment: this.alignment + BigInt(t)
     });
   }
-  sliceSub(t, e, r) {
-    if (e <= 0 && (r == null || r >= this.length)) return this;
-    let a;
-    return t ? a = this.data.subarray(e, r) : a = this.data.slice(e, r), new N({
-      data: a,
+  sliceSub(t, e, s) {
+    if (e <= 0 && (s == null || s >= this.length)) return this;
+    let u;
+    return t ? u = this.data.subarray(e, s) : u = this.data.slice(e, s), new I({
+      data: u,
       dataType: this.dataType,
       timeRange: this.timeRange,
       sampleOffset: this.sampleOffset,
@@ -2054,10 +2130,10 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns A new series with the specified alignment.
    */
   reAlign(t) {
-    return new N({
+    return new I({
       data: this.buffer,
       dataType: this.dataType,
-      timeRange: B.ZERO,
+      timeRange: w.ZERO,
       sampleOffset: this.sampleOffset,
       glBufferUsage: "static",
       alignment: t
@@ -2069,59 +2145,37 @@ const Qt = () => Xt(), lt = (n, t) => Wt(n, t), _t = Gt, pe = /* @__PURE__ */ Ob
    * @returns A string representation of the series.
    */
   toString() {
-    var e, r;
     let t = `Series(${this.dataType.toString()} ${this.length} [`;
-    if (this.length <= 10) t += Array.from(this).map((a) => a.toString());
+    if (this.length <= 10) t += Array.from(this).map((e) => e.toString());
     else {
-      for (let a = 0; a < 5; a++)
-        t += `${(e = this.at(a)) == null ? void 0 : e.toString()}`, t += ",";
+      for (let e = 0; e < 5; e++)
+        t += `${this.at(e)?.toString()}`, t += ",";
       t += "...,";
-      for (let a = -5; a < 0; a++)
-        t += (r = this.at(a)) == null ? void 0 : r.toString(), a < -1 && (t += ",");
+      for (let e = -5; e < 0; e++)
+        t += this.at(e)?.toString(), e < -1 && (t += ",");
     }
     return t += "])", t;
   }
-};
-/**
- * A zod schema that can be used to validate that a particular value
- * can be constructed into a series.
- */
-i(N, "crudeZ", G({
-  timeRange: B.z.optional(),
-  dataType: m.z,
-  alignment: st().optional(),
-  data: S([
-    te,
-    ee,
-    O(ArrayBuffer),
-    O(Uint8Array)
-  ]),
-  glBufferUsage: Vt.optional().default("static").optional()
-})), /**
- * A zod schema that validates and constructs a series from it's crude
- * representation.
- */
-i(N, "z", N.crudeZ.transform((t) => new N(t)));
-let V = N;
-const re = (n) => n == null ? !1 : Array.isArray(n) || n instanceof ArrayBuffer || ArrayBuffer.isView(n) && !(n instanceof DataView) || n instanceof V ? !0 : ut(n), ht = it(ct, V);
-class tt {
-  constructor(t, e, r) {
-    i(this, "series");
-    i(this, "end");
-    i(this, "index");
+}
+const mt = (i) => i == null ? !1 : Array.isArray(i) || i instanceof ArrayBuffer || ArrayBuffer.isView(i) && !(i instanceof DataView) || i instanceof I ? !0 : H(i), Q = j(X, I);
+class V {
+  series;
+  end;
+  index;
+  constructor(t, e, s) {
     this.series = t;
-    const a = q(0, t.length);
-    this.end = Q(a, r), this.index = Q(a, e);
+    const u = C(0, t.length);
+    this.end = Y(u, s), this.index = Y(u, e);
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
   }
 }
-class se {
+class vt {
+  series;
+  index;
+  decoder;
   constructor(t) {
-    i(this, "series");
-    i(this, "index");
-    i(this, "decoder");
     if (!t.dataType.isVariable)
       throw new Error(
         "cannot create a variable series iterator for a non-variable series"
@@ -2130,30 +2184,45 @@ class se {
   }
   next() {
     const t = this.index, e = this.series.data;
-    for (; this.index < e.length && e[this.index] !== K; ) 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] !== q; ) this.index++;
+    const s = this.index;
+    return t === s ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(t, s)) });
   }
 }
-const k = class k {
+class $ {
+  wrapped;
+  static schema = o.record(o.string(), o.unknown());
   constructor(t) {
-    i(this, "wrapped");
     this.wrapped = t;
   }
   next() {
     const t = this.wrapped.next();
     return t.done === !0 ? { done: !0, value: void 0 } : {
       done: !1,
-      value: W.decodeString(t.value, k.schema)
+      value: L.decodeString(t.value, $.schema)
     };
   }
-};
-i(k, "schema", xt($(), Lt()));
-let z = k;
-class ne {
+}
+class Ut {
+  series;
+  index;
+  data;
+  density;
+  constructor(t) {
+    if (!t.dataType.equals(r.UUID))
+      throw new Error("cannot create a UUID series iterator for a non-UUID series");
+    this.series = t, this.index = 0, this.data = new Uint8Array(t.buffer), this.density = r.UUID.density.valueOf();
+  }
+  next() {
+    if (this.index >= this.series.length) return { done: !0, value: void 0 };
+    const t = P(this.data, this.index * this.density);
+    return this.index++, { done: !1, value: t };
+  }
+}
+class At {
+  series;
+  index;
   constructor(t) {
-    i(this, "series");
-    i(this, "index");
     this.series = t, this.index = 0;
   }
   next() {
@@ -2163,7 +2232,9 @@ class ne {
     };
   }
 }
-class ve {
+class Vt {
+  /** The array of series in this collection */
+  series;
   /**
    * The MultiSeries constructor accepts an optional array of Series instances. All series
    * in the collection must have the same data type.
@@ -2205,25 +2276,23 @@ class ve {
    * @throws Error if attempting to add a series with a different data type
    */
   constructor(t = []) {
-    /** The array of series in this collection */
-    i(this, "series");
     if (t.length !== 0) {
       const e = t[0].dataType;
-      for (let r = 1; r < t.length; r++)
-        if (!t[r].dataType.equals(e))
+      for (let s = 1; s < t.length; s++)
+        if (!t[s].dataType.equals(e))
           throw new Error("[multi-series] - series must have the same data type");
     }
     this.series = t;
   }
   as(t) {
-    return ft(t, this.dataType), this;
+    return D(t, this.dataType), this;
   }
   /**
    * Returns the data type of the series in this collection. If the collection is empty,
    * returns DataType.UNKNOWN.
    */
   get dataType() {
-    return this.series.length === 0 ? m.UNKNOWN : this.series[0].dataType;
+    return this.series.length === 0 ? r.UNKNOWN : this.series[0].dataType;
   }
   /**
    * Returns the combined time range of all series in the collection. If the collection
@@ -2231,7 +2300,7 @@ class ve {
    * series to the end of the last series.
    */
   get timeRange() {
-    return this.series.length === 0 ? B.ZERO : new B(
+    return this.series.length === 0 ? w.ZERO : new w(
       this.series[0].timeRange.start,
       this.series[this.series.length - 1].timeRange.end
     );
@@ -2249,7 +2318,7 @@ class ve {
    * series + its length. If the collection is empty, returns bounds.construct(0n, 0n).
    */
   get alignmentBounds() {
-    return this.series.length === 0 ? q(0n, 0n) : q(
+    return this.series.length === 0 ? C(0n, 0n) : C(
       this.series[0].alignmentBounds.lower,
       this.series[this.series.length - 1].alignmentBounds.upper
     );
@@ -2257,12 +2326,12 @@ class ve {
   push(t) {
     const e = () => new Error(
       `cannot push a ${t.dataType.toString()} series to a ${this.dataType.toString()} multi-series`
-    ), r = t.dataType.equals(this.dataType);
-    if (ht(t)) {
-      if (this.series.length !== 0 && !r) throw e();
+    ), s = t.dataType.equals(this.dataType);
+    if (Q(t)) {
+      if (this.series.length !== 0 && !s) throw e();
       this.series.push(t);
     } else {
-      if (this.series.length !== 0 && t.series.length !== 0 && !r)
+      if (this.series.length !== 0 && t.series.length !== 0 && !s)
         throw e();
       this.series.push(...t.series);
     }
@@ -2275,16 +2344,16 @@ class ve {
     return this.series.reduce((t, e) => t + e.length, 0);
   }
   atAlignment(t, e) {
-    for (const r of this.series)
-      if (F(r.alignmentBounds, t))
-        return r.atAlignment(t, e);
+    for (const s of this.series)
+      if (R(s.alignmentBounds, t))
+        return s.atAlignment(t, e);
     if (e) throw new Error(`[series] - no value at alignment ${t}`);
   }
   at(t, e = !1) {
     t < 0 && (t = this.length + t);
-    for (const r of this.series) {
-      if (t < r.length) return r.at(t, e);
-      t -= r.length;
+    for (const s of this.series) {
+      if (t < s.length) return s.at(t, e);
+      t -= s.length;
     }
     if (e) throw new Error(`[series] - no value at index ${t}`);
   }
@@ -2295,7 +2364,7 @@ class ve {
    * @returns An iterator over the specified range.
    */
   subIterator(t, e) {
-    return new j(this, t, e ?? this.length);
+    return new S(this, t, e ?? this.length);
   }
   /**
    * Returns an iterator over a portion of the multi-series based on alignment.
@@ -2305,28 +2374,28 @@ class ve {
    */
   subAlignmentIterator(t, e) {
     if (t >= this.alignmentBounds.upper || e <= this.alignmentBounds.lower)
-      return H;
-    let r = 0;
+      return p;
+    let s = 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) r += h.length;
-      else if (F(h.alignmentBounds, t)) {
-        r += Number(t - h.alignment);
+      const c = this.series[f];
+      if (t < c.alignment) break;
+      if (t >= c.alignmentBounds.upper) s += c.length;
+      else if (R(c.alignmentBounds, t)) {
+        s += Number(t - c.alignment);
         break;
       }
     }
-    let a = 0;
+    let u = 0;
     for (let f = 0; f < this.series.length; f++) {
-      const h = this.series[f];
-      if (e < h.alignment) break;
-      if (e >= h.alignmentBounds.upper) a += h.length;
-      else if (F(h.alignmentBounds, e)) {
-        a += Number(e - h.alignment);
+      const c = this.series[f];
+      if (e < c.alignment) break;
+      if (e >= c.alignmentBounds.upper) u += c.length;
+      else if (R(c.alignmentBounds, e)) {
+        u += Number(e - c.alignment);
         break;
       }
     }
-    return new j(this, r, a);
+    return new S(this, s, u);
   }
   /**
    * Returns an iterator over the specified alignment range and span.
@@ -2335,19 +2404,19 @@ class ve {
    * @returns An iterator over the specified range.
    */
   subAlignmentSpanIterator(t, e) {
-    if (t >= this.alignmentBounds.upper) return H;
+    if (t >= this.alignmentBounds.upper) return p;
     e = Math.min(e, Number(this.distance(t, this.alignmentBounds.upper)));
-    let r = 0;
-    for (let a = 0; a < this.series.length; a++) {
-      const f = this.series[a];
+    let s = 0;
+    for (let u = 0; u < this.series.length; u++) {
+      const f = this.series[u];
       if (t < f.alignment) break;
-      if (t >= f.alignmentBounds.upper) r += f.length;
-      else if (F(f.alignmentBounds, t)) {
-        r += Number(t - f.alignment);
+      if (t >= f.alignmentBounds.upper) s += f.length;
+      else if (R(f.alignmentBounds, t)) {
+        s += Number(t - f.alignment);
         break;
       }
     }
-    return new j(this, r, r + e);
+    return new S(this, s, s + e);
   }
   /**
    * Updates the WebGL buffer for all series in the collection.
@@ -2360,13 +2429,13 @@ class ve {
    * Returns the bounds containing the minimum and maximum values across all series.
    */
   get bounds() {
-    return yt(this.series.map((t) => t.bounds));
+    return tt(this.series.map((t) => t.bounds));
   }
   /**
    * Returns the sum of the byte lengths of all series.
    */
   get byteLength() {
-    return new L(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
+    return new h(this.series.reduce((t, e) => t + e.byteLength.valueOf(), 0));
   }
   /**
    * Returns a combined typed array containing all data from all series.
@@ -2375,8 +2444,8 @@ class ve {
   get data() {
     const t = new this.dataType.Array(this.length);
     let e = 0;
-    for (const r of this.series)
-      t.set(r.data, e), e += r.length;
+    for (const s of this.series)
+      t.set(s.data, e), e += s.length;
     return new this.dataType.Array(t.buffer);
   }
   /**
@@ -2386,8 +2455,8 @@ class ve {
    * @returns The resulting alignment after traversal.
    */
   traverseAlignment(t, e) {
-    const r = this.series.map((a) => a.alignmentBounds);
-    return bt(r, t, e);
+    const s = this.series.map((u) => u.alignmentBounds);
+    return et(s, t, e);
   }
   /**
    * Acquires a reference to the WebGL buffer for all series.
@@ -2409,8 +2478,8 @@ class ve {
    * @returns The distance between the alignments.
    */
   distance(t, e) {
-    const r = this.series.map((a) => a.alignmentBounds);
-    return wt(r, t, e);
+    const s = this.series.map((u) => u.alignmentBounds);
+    return st(s, t, e);
   }
   /**
    * Parses a JSON multi-series into an array of values using the provided zod schema.
@@ -2420,7 +2489,7 @@ class ve {
    * @returns An array of values parsed from the JSON series.
    */
   parseJSON(t) {
-    if (!this.dataType.equals(m.JSON))
+    if (!this.dataType.equals(r.JSON))
       throw new Error("cannot parse non-JSON series as JSON");
     return this.series.flatMap((e) => e.parseJSON(t));
   }
@@ -2433,14 +2502,22 @@ class ve {
       next() {
         return { done: !0, value: void 0 };
       }
-    } : new ie(this.series);
+    } : new Et(this.series);
+  }
+  /**
+   * Returns an array of the values in the multi-series as strings.
+   * For variable length data types (like STRING or JSON), this decodes the underlying buffer.
+   * @returns An array of string representations of the multi-series values.
+   */
+  toStrings() {
+    return this.series.flatMap((t) => t.toStrings());
   }
 }
-class ie {
+class Et {
+  series;
+  seriesIndex;
+  internal;
   constructor(t) {
-    i(this, "series");
-    i(this, "seriesIndex");
-    i(this, "internal");
     this.series = t, this.seriesIndex = 0, this.internal = t[0][Symbol.iterator]();
   }
   next() {
@@ -2451,12 +2528,12 @@ class ie {
     return this;
   }
 }
-class j {
-  constructor(t, e, r) {
-    i(this, "series");
-    i(this, "index");
-    i(this, "end");
-    this.series = t, this.end = r, this.index = e;
+class S {
+  series;
+  index;
+  end;
+  constructor(t, e, s) {
+    this.series = t, this.end = s, this.index = e;
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
@@ -2465,28 +2542,27 @@ class j {
     return this;
   }
 }
-const et = (n) => {
-  const t = n >> 32n, e = n & 0xffffffffn;
+const k = (i) => {
+  const t = i >> 32n, e = i & 0xffffffffn;
   return { domain: t, sample: e };
 };
 export {
-  I as D,
-  ve as M,
-  Y as R,
-  V as S,
-  g as T,
-  re as a,
-  d as b,
-  be as c,
-  B as d,
-  m as e,
-  L as f,
-  ut as g,
-  kt as h,
-  we as i,
-  Z as j,
-  Ie as m,
-  Te as s,
-  Ne as t,
-  pe as u
+  d as D,
+  Vt as M,
+  E as R,
+  I as S,
+  n as T,
+  a,
+  w as b,
+  r as c,
+  h as d,
+  H as e,
+  ot as f,
+  x as g,
+  J as h,
+  mt as i,
+  $t as j,
+  Ft as m,
+  Yt as t,
+  Zt as u
 };