@synnaxlabs/freighter 0.45.1 → 0.47.0

package/dist/freighter.js

@@ -1,36 +1,36 @@
-import O, { z as s } from "zod";
-const Qe = (n) => {
+import b, { z as s } from "zod";
+const tt = (n) => {
   const e = n.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
   return e.length > 1 && e[0] === e[0].toUpperCase() && e[1] === e[1].toUpperCase() || e.length === 0 ? e : e[0].toLowerCase() + e.slice(1);
-}, Ee = (n) => {
-  const e = (t, r = ae) => {
+}, Me = (n) => {
+  const e = (t, r = ue) => {
     if (typeof t == "string") return n(t);
     if (Array.isArray(t)) return t.map((c) => e(c, r));
-    if (!re(t)) return t;
-    r = nt(r);
+    if (!ie(t)) return t;
+    r = it(r);
     const i = {}, a = t;
     return "toJSON" in a && typeof a.toJSON == "function" ? e(a.toJSON(), r) : (Object.keys(a).forEach((c) => {
-      let g = a[c];
+      let d = a[c];
       const y = n(c);
-      r.recursive && (re(g) ? we(g) || (g = e(g, r)) : r.recursiveInArray && ye(g) && (g = [...g].map((f) => {
-        let m = f;
-        return re(f) ? we(m) || (m = e(f, r)) : ye(f) && (m = e({ key: f }, r).key), m;
-      }))), i[y] = g;
+      r.recursive && (ie(d) ? Te(d) || (d = e(d, r)) : r.recursiveInArray && Oe(d) && (d = [...d].map((f) => {
+        let g = f;
+        return ie(f) ? Te(g) || (g = e(f, r)) : Oe(f) && (g = e({ key: f }, r).key), g;
+      }))), i[y] = d;
     }), i);
   };
   return e;
-}, xe = Ee(Qe), _e = (n) => (
+}, $e = Me(tt), nt = (n) => (
   // Don't convert the first character and don't convert a character that is after a
   // non-alphanumeric character
   n.replace(
     /([a-z0-9])([A-Z])/g,
     (e, t, r) => `${t}_${r.toLowerCase()}`
   )
-), et = Ee(_e), tt = [Number, String, Uint8Array], ae = {
+), rt = Me(nt), st = [Number, String, Uint8Array], ue = {
   recursive: !0,
   recursiveInArray: !0
-}, nt = (n = ae) => (n.recursive == null ? n = ae : n.recursiveInArray ??= !1, n), ye = (n) => n != null && Array.isArray(n), re = (n) => n != null && typeof n == "object" && !Array.isArray(n), we = (n) => tt.some((e) => n instanceof e);
-let rt = class {
+}, it = (n = ue) => (n.recursive == null ? n = ue : n.recursiveInArray ??= !1, n), Oe = (n) => n != null && Array.isArray(n), ie = (n) => n != null && typeof n == "object" && !Array.isArray(n), Te = (n) => st.some((e) => n instanceof e);
+let at = class {
   contentType = "application/json";
   decoder;
   encoder;
@@ -44,16 +44,16 @@ let rt = class {
     return this.decodeString(this.decoder.decode(e), t);
   }
   decodeString(e, t) {
-    const r = JSON.parse(e), i = xe(r);
+    const r = JSON.parse(e), i = $e(r);
     return t != null ? t.parse(i) : i;
   }
   encodeString(e) {
-    const t = et(e);
+    const t = rt(e);
     return JSON.stringify(t, (r, i) => ArrayBuffer.isView(i) ? Array.from(i) : typeof i == "bigint" ? i.toString() : i);
   }
 };
-const oe = new rt(), E = (n) => n != null && typeof n == "object" && "value" in n;
-let F = class {
+const le = new at(), U = (n) => n != null && typeof n == "object" && "value" in n;
+let Z = class {
   /** The underlying primitive value */
   value;
   constructor(e) {
@@ -73,8 +73,8 @@ let F = class {
     return this.value.toString();
   }
 };
-const st = (n) => n != null && typeof n == "object" && "toString" in n, it = (n, e = !1) => {
-  const t = st(n) ? "stringer" : typeof n;
+const ot = (n) => n != null && typeof n == "object" && "toString" in n, ut = (n, e = !1) => {
+  const t = ot(n) ? "stringer" : typeof n;
   let r;
   switch (t) {
     case "string":
@@ -98,38 +98,38 @@ const st = (n) => n != null && typeof n == "object" && "toString" in n, it = (n,
     default:
       return console.warn(`sortFunc: unknown type ${t}`), () => -1;
   }
-  return e ? at(r) : r;
-}, at = (n) => (e, t) => n(t, e), Q = s.tuple([s.number(), s.number()]);
+  return e ? lt(r) : r;
+}, lt = (n) => (e, t) => n(t, e), ee = s.tuple([s.number(), s.number()]);
 s.tuple([s.bigint(), s.bigint()]);
-const Ae = s.object({ width: s.number(), height: s.number() }), ot = s.object({
+const Ce = s.object({ width: s.number(), height: s.number() }), ct = s.object({
   signedWidth: s.number(),
   signedHeight: s.number()
-}), ut = ["width", "height"];
-s.enum(ut);
-const lt = ["start", "center", "end"], ct = ["signedWidth", "signedHeight"];
-s.enum(ct);
-const K = s.object({ x: s.number(), y: s.number() }), ht = s.object({ clientX: s.number(), clientY: s.number() }), ft = ["x", "y"], Ue = s.enum(ft), Me = ["top", "right", "bottom", "left"];
-s.enum(Me);
-const dt = ["left", "right"], Ce = s.enum(dt), gt = ["top", "bottom"], $e = s.enum(gt), Be = ["center"], be = s.enum(Be), pt = [...Me, ...Be], Re = s.enum(pt);
-s.enum(lt);
-const mt = ["first", "last"];
-s.enum(mt);
-const yt = s.object({ lower: s.number(), upper: s.number() }), wt = s.object({ lower: s.bigint(), upper: s.bigint() });
-s.union([yt, Q]);
-s.union([wt, Q]);
-s.enum([...Ue.options, ...Re.options]);
+}), ht = ["width", "height"];
+s.enum(ht);
+const ft = ["start", "center", "end"], dt = ["signedWidth", "signedHeight"];
+s.enum(dt);
+const _ = s.object({ x: s.number(), y: s.number() }), gt = s.object({ clientX: s.number(), clientY: s.number() }), pt = ["x", "y"], Be = s.enum(pt), Re = ["top", "right", "bottom", "left"];
+s.enum(Re);
+const mt = ["left", "right"], De = s.enum(mt), yt = ["top", "bottom"], Le = s.enum(yt), Pe = ["center"], ve = s.enum(Pe), wt = [...Re, ...Pe], ke = s.enum(wt);
+s.enum(ft);
+const bt = ["first", "last"];
+s.enum(bt);
+const Ot = s.object({ lower: s.number(), upper: s.number() }), Tt = s.object({ lower: s.bigint(), upper: s.bigint() });
+s.union([Ot, ee]);
+s.union([Tt, ee]);
+s.enum([...Be.options, ...ke.options]);
 s.enum(["x", "left", "right"]);
 s.enum(["y", "top", "bottom"]);
-s.union([Ue, Re, s.instanceof(String)]);
-const _ = (n) => (e, t) => {
+s.union([Be, ke, s.instanceof(String)]);
+const te = (n) => (e, t) => {
   if (typeof e == "bigint") {
-    if (bt(t))
+    if (vt(t))
       return n(e, BigInt(t));
     const r = n(Number(e), Number(t));
     return typeof r == "number" ? BigInt(Math.round(r)) : r;
   }
   return n(Number(e), Number(t));
-}, ee = _((n, e) => n - e), te = _((n, e) => n + e), bt = (n) => typeof n == "bigint" ? !0 : Number.isInteger(n), M = _((n, e) => n * e), ne = _((n, e) => n / e), D = (n, e, t) => {
+}, ne = te((n, e) => n - e), re = te((n, e) => n + e), vt = (n) => typeof n == "bigint" ? !0 : Number.isInteger(n), C = te((n, e) => n * e), se = te((n, e) => n / e), P = (n, e, t) => {
   const r = {};
   if (typeof e == "object" && (t = e, e = void 0), t = { makeValid: !0, ...t }, typeof n == "number" || typeof n == "bigint")
     e != null ? (r.lower = n, r.upper = e) : (r.lower = typeof n == "bigint" ? 0n : 0, r.upper = n);
@@ -138,34 +138,34 @@ const _ = (n) => (e, t) => {
     [r.lower, r.upper] = n;
   } else
     r.lower = n.lower, r.upper = n.upper;
-  return t?.makeValid ? Ot(r) : r;
-}, Ot = (n) => n.lower > n.upper ? { lower: n.upper, upper: n.lower } : n, Oe = (n, e) => {
-  const t = D(n);
+  return t?.makeValid ? St(r) : r;
+}, St = (n) => n.lower > n.upper ? { lower: n.upper, upper: n.lower } : n, Se = (n, e) => {
+  const t = P(n);
   return e < t.lower ? t.lower : e >= t.upper ? t.upper - (typeof t.upper == "number" ? 1 : 1n) : e;
 };
 s.object({
-  x: Ce.or(be),
-  y: $e.or(be)
+  x: De.or(ve),
+  y: Le.or(ve)
 });
-const Tt = s.object({ x: Ce, y: $e }), vt = Object.freeze({ x: "left", y: "top" }), It = (n, e) => n.x === e.x && n.y === e.y, Te = s.union([
+const It = s.object({ x: De, y: Le }), Nt = Object.freeze({ x: "left", y: "top" }), Et = (n, e) => n.x === e.x && n.y === e.y, Ie = s.union([
   s.number(),
-  K,
-  Q,
-  Ae,
-  ot,
-  ht
-]), Nt = (n, e) => {
+  _,
+  ee,
+  Ce,
+  ct,
+  gt
+]), xt = (n, e) => {
   if (typeof n == "string") {
     if (e === void 0) throw new Error("The y coordinate must be given.");
     return n === "x" ? { x: e, y: 0 } : { x: 0, y: e };
   }
   return typeof n == "number" ? { x: n, y: e ?? n } : Array.isArray(n) ? { x: n[0], y: n[1] } : "signedWidth" in n ? { x: n.signedWidth, y: n.signedHeight } : "clientX" in n ? { x: n.clientX, y: n.clientY } : "width" in n ? { x: n.width, y: n.height } : { x: n.x, y: n.y };
-}, ve = Object.freeze({ x: 0, y: 0 }), H = s.union([s.number(), s.string()]);
+}, Ne = Object.freeze({ x: 0, y: 0 }), J = s.union([s.number(), s.string()]);
 s.object({
-  top: H,
-  left: H,
-  width: H,
-  height: H
+  top: J,
+  left: J,
+  width: J,
+  height: J
 });
 s.object({
   left: s.number(),
@@ -174,15 +174,15 @@ s.object({
   bottom: s.number()
 });
 s.object({
-  one: K,
-  two: K,
-  root: Tt
+  one: _,
+  two: _,
+  root: It
 });
-const de = (n, e, t = 0, r = 0, i) => {
+const me = (n, e, t = 0, r = 0, i) => {
   const a = {
-    one: { ...ve },
-    two: { ...ve },
-    root: i ?? vt
+    one: { ...Ne },
+    two: { ...Ne },
+    root: i ?? Nt
   };
   if (typeof n == "number") {
     if (typeof e != "number")
@@ -196,39 +196,39 @@ const de = (n, e, t = 0, r = 0, i) => {
     x: a.one.x + e.signedWidth,
     y: a.one.y + e.signedHeight
   } : a.two = e, a));
-}, se = (n) => {
-  const e = de(n);
+}, ae = (n) => {
+  const e = me(n);
   return { lower: e.one.x, upper: e.two.x };
-}, ie = (n) => {
-  const e = de(n);
+}, oe = (n) => {
+  const e = me(n);
   return { lower: e.one.y, upper: e.two.y };
-}, St = (n) => typeof n != "object" || n == null ? !1 : "one" in n && "two" in n && "root" in n, Et = s.object({ signedWidth: s.number(), signedHeight: s.number() });
-s.union([Ae, Et, K, Q]);
-const xt = (n, e, t) => e !== void 0 && n < e ? e : t !== void 0 && n > t ? t : n;
-s.object({ offset: Te, scale: Te });
+}, At = (n) => typeof n != "object" || n == null ? !1 : "one" in n && "two" in n && "root" in n, Ut = s.object({ signedWidth: s.number(), signedHeight: s.number() });
+s.union([Ce, Ut, _, ee]);
+const Mt = (n, e, t) => e !== void 0 && n < e ? e : t !== void 0 && n > t ? t : n;
+s.object({ offset: Ie, scale: Ie });
 s.object({ offset: s.number(), scale: s.number() });
-const At = (n) => (e, t, r, i) => t === "dimension" ? [e, r] : [
+const $t = (n) => (e, t, r, i) => t === "dimension" ? [e, r] : [
   e,
   i ? r - n : r + n
-], Ut = (n) => (e, t, r, i) => [
+], Ct = (n) => (e, t, r, i) => [
   e,
   i ? r / n : r * n
-], Mt = (n) => (e, t, r) => {
+], Bt = (n) => (e, t, r) => {
   if (e === null) return [n, r];
-  const { lower: i, upper: a } = e, { lower: c, upper: g } = n, y = a - i, f = g - c;
+  const { lower: i, upper: a } = e, { lower: c, upper: d } = n, y = a - i, f = d - c;
   if (t === "dimension") return [n, r * (f / y)];
-  const m = (r - i) * (f / y) + c;
-  return [n, m];
-}, Ct = (n) => (e, t, r) => [n, r], $t = () => (n, e, t) => {
+  const g = (r - i) * (f / y) + c;
+  return [n, g];
+}, Rt = (n) => (e, t, r) => [n, r], Dt = () => (n, e, t) => {
   if (n === null) throw new Error("cannot invert without bounds");
   if (e === "dimension") return [n, t];
   const { lower: r, upper: i } = n;
   return [n, i - (t - r)];
-}, Bt = (n) => (e, t, r) => {
+}, Lt = (n) => (e, t, r) => {
   const { lower: i, upper: a } = n;
-  return r = xt(r, i, a), [e, r];
+  return r = Mt(r, i, a), [e, r];
 };
-let Ie = class L {
+let Ee = class k {
   ops = [];
   currBounds = null;
   currType = null;
@@ -242,7 +242,7 @@ let Ie = class L {
    * @param value - The amount to translate by.
    */
   static translate(e) {
-    return new L().translate(e);
+    return new k().translate(e);
   }
   /**
    * @returns a new scale with a magnification as its first operation. Any number provided
@@ -250,10 +250,10 @@ let Ie = class L {
    * @param value - The amount to translate by.
    */
   static magnify(e) {
-    return new L().magnify(e);
+    return new k().magnify(e);
   }
   static scale(e, t) {
-    return new L().scale(e, t);
+    return new k().scale(e, t);
   }
   /**
    * @returns a copy of the scale with a translation as its next operation. Any
@@ -262,7 +262,7 @@ let Ie = class L {
    * @param value - The amount to translate by.
    */
   translate(e) {
-    const t = this.new(), r = At(e);
+    const t = this.new(), r = $t(e);
     return r.type = "translate", t.ops.push(r), t;
   }
   /**
@@ -272,23 +272,23 @@ let Ie = class L {
    * @param value - The amount to magnify by.
    */
   magnify(e) {
-    const t = this.new(), r = Ut(e);
+    const t = this.new(), r = Ct(e);
     return r.type = "magnify", t.ops.push(r), t;
   }
   scale(e, t) {
-    const r = D(e, t), i = this.new(), a = Mt(r);
+    const r = P(e, t), i = this.new(), a = Bt(r);
     return a.type = "scale", i.ops.push(a), i;
   }
   clamp(e, t) {
-    const r = D(e, t), i = this.new(), a = Bt(r);
+    const r = P(e, t), i = this.new(), a = Lt(r);
     return a.type = "clamp", i.ops.push(a), i;
   }
   reBound(e, t) {
-    const r = D(e, t), i = this.new(), a = Ct(r);
+    const r = P(e, t), i = this.new(), a = Rt(r);
     return a.type = "re-bound", i.ops.push(a), i;
   }
   invert() {
-    const e = $t();
+    const e = Dt();
     e.type = "invert";
     const t = this.new();
     return t.ops.push(e), t;
@@ -300,7 +300,7 @@ let Ie = class L {
     return this.exec("dimension", e);
   }
   new() {
-    const e = new L();
+    const e = new k();
     return e.ops = this.ops.slice(), e.reversed = this.reversed, e;
   }
   exec(e, t) {
@@ -314,9 +314,9 @@ let Ie = class L {
     e.ops.reverse();
     const t = [];
     return e.ops.forEach((r, i) => {
-      if (r.type === "scale" || t.some(([c, g]) => i >= c && i <= g))
+      if (r.type === "scale" || t.some(([c, d]) => i >= c && i <= d))
         return;
-      const a = e.ops.findIndex((c, g) => c.type === "scale" && g > i);
+      const a = e.ops.findIndex((c, d) => c.type === "scale" && d > i);
       a !== -1 && t.push([i, a]);
     }), t.forEach(([r, i]) => {
       const a = e.ops.slice(r, i);
@@ -326,37 +326,37 @@ let Ie = class L {
   get transform() {
     return { scale: this.dim(1), offset: this.pos(0) };
   }
-  static IDENTITY = new L();
-}, _n = class U {
+  static IDENTITY = new k();
+}, sr = class $ {
   x;
   y;
   currRoot;
-  constructor(e = new Ie(), t = new Ie(), r = null) {
+  constructor(e = new Ee(), t = new Ee(), r = null) {
     this.x = e, this.y = t, this.currRoot = r;
   }
   static translate(e, t) {
-    return new U().translate(e, t);
+    return new $().translate(e, t);
   }
   static translateX(e) {
-    return new U().translateX(e);
+    return new $().translateX(e);
   }
   static translateY(e) {
-    return new U().translateY(e);
+    return new $().translateY(e);
   }
   static clamp(e) {
-    return new U().clamp(e);
+    return new $().clamp(e);
   }
   static magnify(e) {
-    return new U().magnify(e);
+    return new $().magnify(e);
   }
   static scale(e) {
-    return new U().scale(e);
+    return new $().scale(e);
   }
   static reBound(e) {
-    return new U().reBound(e);
+    return new $().reBound(e);
   }
   translate(e, t) {
-    const r = Nt(e, t), i = this.copy();
+    const r = xt(e, t), i = this.copy();
     return i.x = this.x.translate(r.x), i.y = this.y.translate(r.y), i;
   }
   translateX(e) {
@@ -373,22 +373,22 @@ let Ie = class L {
   }
   scale(e) {
     const t = this.copy();
-    if (St(e)) {
+    if (At(e)) {
       const r = this.currRoot;
-      return t.currRoot = e.root, r != null && !It(r, e.root) && (r.x !== e.root.x && (t.x = t.x.invert()), r.y !== e.root.y && (t.y = t.y.invert())), t.x = t.x.scale(se(e)), t.y = t.y.scale(ie(e)), t;
+      return t.currRoot = e.root, r != null && !Et(r, e.root) && (r.x !== e.root.x && (t.x = t.x.invert()), r.y !== e.root.y && (t.y = t.y.invert())), t.x = t.x.scale(ae(e)), t.y = t.y.scale(oe(e)), t;
     }
     return t.x = t.x.scale(e.width), t.y = t.y.scale(e.height), t;
   }
   reBound(e) {
     const t = this.copy();
-    return t.x = this.x.reBound(se(e)), t.y = this.y.reBound(ie(e)), t;
+    return t.x = this.x.reBound(ae(e)), t.y = this.y.reBound(oe(e)), t;
   }
   clamp(e) {
     const t = this.copy();
-    return t.x = this.x.clamp(se(e)), t.y = this.y.clamp(ie(e)), t;
+    return t.x = this.x.clamp(ae(e)), t.y = this.y.clamp(oe(e)), t;
   }
   copy() {
-    const e = new U();
+    const e = new $();
     return e.currRoot = this.currRoot, e.x = this.x, e.y = this.y, e;
   }
   reverse() {
@@ -402,7 +402,7 @@ let Ie = class L {
     return { x: this.x.dim(e.x), y: this.y.dim(e.y) };
   }
   box(e) {
-    return de(
+    return me(
       this.pos(e.one),
       this.pos(e.two),
       0,
@@ -416,50 +416,50 @@ let Ie = class L {
       offset: this.pos({ x: 0, y: 0 })
     };
   }
-  static IDENTITY = new U();
-}, De = (n, e = 21) => (t = e) => {
+  static IDENTITY = new $();
+}, je = (n, e = 21) => (t = e) => {
   let r = "", i = t | 0;
   for (; i--; )
     r += n[Math.random() * n.length | 0];
   return r;
 };
-const Le = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Rt = `0123456789${Le}`, Dt = 11, Lt = De(Le, 1), kt = De(Rt, Dt - 1), Pt = () => `${Lt()}${kt()}`, jt = (n, e) => (t) => t instanceof e || typeof t == "object" && t !== null && "discriminator" in t && t.discriminator === n, Yt = s.enum(["static", "dynamic"]), qt = s.union([
+const Ye = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Pt = `0123456789${Ye}`, kt = 11, jt = je(Ye, 1), Yt = je(Pt, kt - 1), qt = () => `${jt()}${Yt()}`, Ft = (n, e) => (t) => t instanceof e || typeof t == "object" && t !== null && "discriminator" in t && t.discriminator === n, Wt = s.enum(["static", "dynamic"]), ce = 2n ** 63n - 1n, Zt = 2 ** 63 - 1, xe = 365, K = 30, Gt = s.union([
   s.tuple([s.int()]),
   s.tuple([s.int(), s.int().min(1).max(12)]),
   s.tuple([s.int(), s.int().min(1).max(12), s.int().min(1).max(31)])
-]), ke = (n, e) => {
-  const t = new o(e);
+]), qe = (n, e) => {
+  const t = new u(e);
   if (![
-    p.DAY,
-    p.HOUR,
-    p.MINUTE,
-    p.SECOND,
-    p.MILLISECOND,
-    p.MICROSECOND,
-    p.NANOSECOND
+    l.DAY,
+    l.HOUR,
+    l.MINUTE,
+    l.SECOND,
+    l.MILLISECOND,
+    l.MICROSECOND,
+    l.NANOSECOND
   ].some((i) => i.equals(t)))
     throw new Error(
       "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
     );
   const r = n.valueOf() % t.valueOf();
-  return n instanceof o ? new o(r) : new p(r);
+  return n instanceof u ? new u(r) : new l(r);
 };
-class o extends F {
+class u extends Z {
   constructor(e, t = "UTC") {
-    if (e == null) super(o.now().valueOf());
+    if (e == null) super(u.now().valueOf());
     else if (e instanceof Date)
-      super(BigInt(e.getTime()) * o.MILLISECOND.valueOf());
+      super(BigInt(e.getTime()) * u.MILLISECOND.valueOf());
     else if (typeof e == "string")
-      super(o.parseDateTimeString(e, t).valueOf());
-    else if (Array.isArray(e)) super(o.parseDate(e));
+      super(u.parseDateTimeString(e, t).valueOf());
+    else if (Array.isArray(e)) super(u.parseDate(e));
     else {
       let r = 0n;
-      e instanceof Number && (e = e.valueOf()), t === "local" && (r = o.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = o.MAX : e = o.MIN)), E(e) && (e = e.value), super(BigInt(e.valueOf()) + r);
+      e instanceof Number && (e = e.valueOf()), t === "local" && (r = u.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e === Zt ? e = ce : e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = u.MAX : e = u.MIN)), U(e) && (e = e.value), super(BigInt(e.valueOf()) + r);
     }
   }
   static parseDate([e = 1970, t = 1, r = 1]) {
     const i = new Date(e, t - 1, r, 0, 0, 0, 0);
-    return new o(BigInt(i.getTime()) * o.MILLISECOND.valueOf()).truncate(o.DAY).valueOf();
+    return new u(BigInt(i.getTime()) * u.MILLISECOND.valueOf()).truncate(u.DAY).valueOf();
   }
   /**
    * @returns the primitive value of the TimeStamp. Overrides standard JS valueOf()
@@ -470,49 +470,22 @@ class o extends F {
   }
   static parseTimeString(e, t = "UTC") {
     const [r, i, a] = e.split(":");
-    let c = "00", g = "00";
-    a != null && ([c, g] = a.split("."));
-    let y = o.hours(parseInt(r ?? "00")).add(o.minutes(parseInt(i ?? "00"))).add(o.seconds(parseInt(c ?? "00"))).add(o.milliseconds(parseInt(g ?? "00")));
-    return t === "local" && (y = y.add(o.utcOffset)), y.valueOf();
+    let c = "00", d = "00";
+    a != null && ([c, d] = a.split("."));
+    let y = u.hours(parseInt(r ?? "00")).add(u.minutes(parseInt(i ?? "00"))).add(u.seconds(parseInt(c ?? "00"))).add(u.milliseconds(parseInt(d ?? "00")));
+    return t === "local" && (y = y.add(u.utcOffset)), y.valueOf();
   }
   static parseDateTimeString(e, t = "UTC") {
     if (!e.includes("/") && !e.includes("-"))
-      return o.parseTimeString(e, t);
+      return u.parseTimeString(e, t);
     const r = new Date(e);
-    return e.includes(":") || r.setUTCHours(0, 0, 0, 0), new o(
-      BigInt(r.getTime()) * o.MILLISECOND.valueOf(),
+    return e.includes(":") || r.setUTCHours(0, 0, 0, 0), new u(
+      BigInt(r.getTime()) * u.MILLISECOND.valueOf(),
       t
     ).valueOf();
   }
-  /**
-   * Formats the TimeStamp as a string in the specified format.
-   *
-   * @param format - The format to use for the string representation.
-   * @param tzInfo - The timezone to use when creating the string representation.
-   * @returns A string representation of the TimeStamp in the specified format.
-   */
-  fString(e = "ISO", t = "UTC") {
-    switch (e) {
-      case "ISODate":
-        return this.toISOString(t).slice(0, 10);
-      case "ISOTime":
-        return this.toISOString(t).slice(11, 23);
-      case "time":
-        return this.timeString(!1, t);
-      case "preciseTime":
-        return this.timeString(!0, t);
-      case "date":
-        return this.dateString();
-      case "preciseDate":
-        return `${this.dateString()} ${this.timeString(!0, t)}`;
-      case "dateTime":
-        return `${this.dateString()} ${this.timeString(!1, t)}`;
-      default:
-        return this.toISOString(t);
-    }
-  }
   toISOString(e = "UTC") {
-    return e === "UTC" ? this.date().toISOString() : this.sub(o.utcOffset).date().toISOString();
+    return e === "UTC" ? this.date().toISOString() : this.sub(u.utcOffset).date().toISOString();
   }
   timeString(e = !1, t = "UTC") {
     const r = this.toISOString(t);
@@ -524,8 +497,8 @@ class o extends F {
   }
   /** @returns The UTC offset for the time zone of the machine. */
   static get utcOffset() {
-    return new p(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * o.MINUTE.valueOf()
+    return new l(
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * u.MINUTE.valueOf()
     );
   }
   /**
@@ -534,7 +507,7 @@ class o extends F {
    * @param other - The other timestamp.
    */
   static since(e) {
-    return new o().span(e);
+    return new u().span(e);
   }
   /** @returns A JavaScript Date object representing the TimeStamp. */
   date() {
@@ -547,7 +520,7 @@ class o extends F {
    * @returns True if the TimeStamps are equal, false otherwise.
    */
   equals(e) {
-    return this.valueOf() === new o(e).valueOf();
+    return this.valueOf() === new u(e).valueOf();
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -567,7 +540,7 @@ class o extends F {
    *   valid, regardless of the TimeStamp order.
    */
   range(e) {
-    return new W(this, e).makeValid();
+    return new x(this, e).makeValid();
   }
   /**
    * Creates a TimeRange starting at the TimeStamp and spanning the given
@@ -596,7 +569,7 @@ class o extends F {
    *   otherwise.
    */
   after(e) {
-    return this.valueOf() > new o(e).valueOf();
+    return this.valueOf() > new u(e).valueOf();
   }
   /**
    * Checks if the TimeStamp is after or equal to the given TimeStamp.
@@ -606,7 +579,7 @@ class o extends F {
    *   false otherwise.
    */
   afterEq(e) {
-    return this.valueOf() >= new o(e).valueOf();
+    return this.valueOf() >= new u(e).valueOf();
   }
   /**
    * Checks if the TimeStamp is before the given TimeStamp.
@@ -616,7 +589,7 @@ class o extends F {
    *   otherwise.
    */
   before(e) {
-    return this.valueOf() < new o(e).valueOf();
+    return this.valueOf() < new u(e).valueOf();
   }
   /**
    * Checks if TimeStamp is before or equal to the current timestamp.
@@ -626,7 +599,7 @@ class o extends F {
    *   false otherwise.
    */
   beforeEq(e) {
-    return this.valueOf() <= new o(e).valueOf();
+    return this.valueOf() <= new u(e).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeStamp.
@@ -636,7 +609,7 @@ class o extends F {
    *   TimeSpan.
    */
   add(e) {
-    return new o(te(this.valueOf(), new p(e).valueOf()));
+    return new u(re(this.valueOf(), new l(e).valueOf()));
   }
   /**
    * Subtracts a TimeSpan from the TimeStamp.
@@ -646,43 +619,43 @@ class o extends F {
    *   TimeSpan.
    */
   sub(e) {
-    return new o(ee(this.valueOf(), new p(e).valueOf()));
+    return new u(ne(this.valueOf(), new l(e).valueOf()));
   }
   /**
    * @returns the floating point number of hours since the unix epoch to the timestamp
    * value.
    */
   get hours() {
-    return Number(this.valueOf()) / Number(p.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(l.HOUR.valueOf());
   }
   /**
    * @returns the floating point number of minutes since the unix epoch to the timestamp
    * value.
    */
   get minutes() {
-    return Number(this.valueOf()) / Number(p.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(l.MINUTE.valueOf());
   }
   /**
    * @returns the floating point number of days since the unix epoch to the timestamp
    * value.
    */
   get days() {
-    return Number(this.valueOf()) / Number(p.DAY.valueOf());
+    return Number(this.valueOf()) / Number(l.DAY.valueOf());
   }
   /**
    * @returns the floating point number of seconds since the unix epoch to the timestamp
    * value.
    */
   get seconds() {
-    return Number(this.valueOf()) / Number(p.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(l.SECOND.valueOf());
   }
   /** @returns the floating point number of milliseconds since the unix epoch. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(o.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(u.MILLISECOND.valueOf());
   }
   /** @returns the floating point number of microseconds since the unix epoch. */
   get microseconds() {
-    return Number(this.valueOf()) / Number(o.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(u.MICROSECOND.valueOf());
   }
   /**
    * @returns the floating point number of nanoseconds since the unix epoch.
@@ -702,7 +675,7 @@ class o extends F {
    */
   setYear(e) {
     const t = this.date();
-    return t.setUTCFullYear(e), new o(t);
+    return t.setUTCFullYear(e), new u(t);
   }
   /** @returns the integer month that the timestamp corresponds to with its year. */
   get month() {
@@ -714,7 +687,7 @@ class o extends F {
    */
   setMonth(e) {
     const t = this.date();
-    return t.setUTCMonth(e), new o(t);
+    return t.setUTCMonth(e), new u(t);
   }
   /** @returns the integer day that the timestamp corresponds to within its month. */
   get day() {
@@ -726,7 +699,7 @@ class o extends F {
    */
   setDay(e) {
     const t = this.date();
-    return t.setUTCDate(e), new o(t);
+    return t.setUTCDate(e), new u(t);
   }
   /**
    * @returns the integer hour that the timestamp corresponds to within its day.
@@ -746,7 +719,7 @@ class o extends F {
    */
   setLocalHour(e) {
     const t = this.date();
-    return t.setHours(e), new o(t);
+    return t.setHours(e), new u(t);
   }
   /**
    * @returns a copy of the timestamp with the hour changed.
@@ -754,7 +727,7 @@ class o extends F {
    */
   setHour(e) {
     const t = this.date();
-    return t.setUTCHours(e), new o(t);
+    return t.setUTCHours(e), new u(t);
   }
   /** @returns the integer minute that the timestamp corresponds to within its hour. */
   get minute() {
@@ -766,7 +739,7 @@ class o extends F {
    */
   setMinute(e) {
     const t = this.date();
-    return t.setUTCMinutes(e), new o(t);
+    return t.setUTCMinutes(e), new u(t);
   }
   /**
    * @returns the integer second that the timestamp corresponds to within its
@@ -781,11 +754,11 @@ class o extends F {
    */
   setSecond(e) {
     const t = this.date();
-    return t.setUTCSeconds(e), new o(t);
+    return t.setUTCSeconds(e), new u(t);
   }
   /**
-   * @reutrns the integer millisecond that the timestamp corresponds to within
-   * its second.
+   * @returns the integer millisecond that the timestamp corresponds to within its
+   * second.
    */
   get millisecond() {
     return this.date().getUTCMilliseconds();
@@ -796,11 +769,34 @@ class o extends F {
    */
   setMillisecond(e) {
     const t = this.date();
-    return t.setUTCMilliseconds(e), new o(t);
+    return t.setUTCMilliseconds(e), new u(t);
   }
-  /** @returns the time stamp formatted as an ISO string. */
-  toString() {
-    return this.date().toISOString();
+  /**
+   * Returns a string representation of the TimeStamp.
+   *
+   * @param format - Optional format for the string representation. Defaults to "ISO".
+   * @param tzInfo - Optional timezone info. Defaults to "UTC".
+   * @returns A string representation of the TimeStamp.
+   */
+  toString(e = "ISO", t = "UTC") {
+    switch (e) {
+      case "ISODate":
+        return this.toISOString(t).slice(0, 10);
+      case "ISOTime":
+        return this.toISOString(t).slice(11, 23);
+      case "time":
+        return this.timeString(!1, t);
+      case "preciseTime":
+        return this.timeString(!0, t);
+      case "date":
+        return this.dateString();
+      case "preciseDate":
+        return `${this.dateString()} ${this.timeString(!0, t)}`;
+      case "dateTime":
+        return `${this.dateString()} ${this.timeString(!1, t)}`;
+      default:
+        return this.toISOString(t);
+    }
   }
   /**
    * @returns A new TimeStamp that is the remainder of the TimeStamp divided by the
@@ -814,11 +810,11 @@ class o extends F {
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(e) {
-    return ke(this, e);
+    return qe(this, e);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(p.DAY).equals(o.now().truncate(p.DAY));
+    return this.truncate(l.DAY).equals(u.now().truncate(l.DAY));
   }
   /**
    * Truncates the TimeStamp to the nearest multiple of the given span.
@@ -835,7 +831,7 @@ class o extends F {
    * JavaScript can do).
    */
   static now() {
-    return new o(/* @__PURE__ */ new Date());
+    return new u(/* @__PURE__ */ new Date());
   }
   /**
    * Finds the maximum timestamp among the provided timestamps.
@@ -844,9 +840,9 @@ class o extends F {
    * @returns The maximum (latest) timestamp from the input.
    */
   static max(...e) {
-    let t = o.MIN;
+    let t = u.MIN;
     for (const r of e) {
-      const i = new o(r);
+      const i = new u(r);
       i.after(t) && (t = i);
     }
     return t;
@@ -858,9 +854,9 @@ class o extends F {
    * @returns The minimum (earliest) timestamp from the input.
    */
   static min(...e) {
-    let t = o.MAX;
+    let t = u.MAX;
     for (const r of e) {
-      const i = new o(r);
+      const i = new u(r);
       i.before(t) && (t = i);
     }
     return t;
@@ -872,62 +868,62 @@ class o extends F {
    * @returns A TimeStamp representing the given number of nanoseconds.
    */
   static nanoseconds(e, t = "UTC") {
-    return new o(e, t);
+    return new u(e, t);
   }
   /** One nanosecond after the unix epoch */
-  static NANOSECOND = o.nanoseconds(1);
+  static NANOSECOND = u.nanoseconds(1);
   /** @returns a new TimeStamp n microseconds after the unix epoch */
   static microseconds(e, t = "UTC") {
-    return o.nanoseconds(e * 1e3, t);
+    return u.nanoseconds(e * 1e3, t);
   }
   /** One microsecond after the unix epoch */
-  static MICROSECOND = o.microseconds(1);
+  static MICROSECOND = u.microseconds(1);
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
   static milliseconds(e, t = "UTC") {
-    return o.microseconds(e * 1e3, t);
+    return u.microseconds(e * 1e3, t);
   }
   /** One millisecond after the unix epoch */
-  static MILLISECOND = o.milliseconds(1);
+  static MILLISECOND = u.milliseconds(1);
   /** @returns a new TimeStamp n seconds after the unix epoch */
   static seconds(e, t = "UTC") {
-    return o.milliseconds(e * 1e3, t);
+    return u.milliseconds(e * 1e3, t);
   }
   /** One second after the unix epoch */
-  static SECOND = o.seconds(1);
+  static SECOND = u.seconds(1);
   /** @returns a new TimeStamp n minutes after the unix epoch */
   static minutes(e, t = "UTC") {
-    return o.seconds(e * 60, t);
+    return u.seconds(e * 60, t);
   }
   /** One minute after the unix epoch */
-  static MINUTE = o.minutes(1);
+  static MINUTE = u.minutes(1);
   /** @returns a new TimeStamp n hours after the unix epoch */
   static hours(e, t = "UTC") {
-    return o.minutes(e * 60, t);
+    return u.minutes(e * 60, t);
   }
   /** One hour after the unix epoch */
-  static HOUR = o.hours(1);
+  static HOUR = u.hours(1);
   /** @returns a new TimeStamp n days after the unix epoch */
   static days(e, t = "UTC") {
-    return o.hours(e * 24, t);
+    return u.hours(e * 24, t);
   }
   /** One day after the unix epoch */
-  static DAY = o.days(1);
+  static DAY = u.days(1);
   /** The maximum possible value for a timestamp */
-  static MAX = new o((1n << 63n) - 1n);
+  static MAX = new u(ce);
   /** The minimum possible value for a timestamp */
-  static MIN = new o(0);
+  static MIN = new u(0);
   /** The unix epoch */
-  static ZERO = new o(0);
+  static ZERO = new u(0);
   /** A zod schema for validating timestamps */
   static z = s.union([
-    s.instanceof(o),
-    s.object({ value: s.bigint() }).transform((e) => new o(e.value)),
-    s.string().transform((e) => new o(BigInt(e))),
-    s.number().transform((e) => new o(e)),
-    s.bigint().transform((e) => new o(e)),
-    s.date().transform((e) => new o(e)),
-    s.custom((e) => e instanceof p).transform((e) => new o(e)),
-    qt.transform((e) => new o(e))
+    s.instanceof(u),
+    s.object({ value: s.bigint() }).transform((e) => new u(e.value)),
+    s.string().transform((e) => new u(BigInt(e))),
+    s.number().transform((e) => new u(e)),
+    s.bigint().transform((e) => new u(e)),
+    s.date().transform((e) => new u(e)),
+    s.custom((e) => e instanceof l).transform((e) => new u(e)),
+    Gt.transform((e) => new u(e))
   ]);
   /**
    * Sorts two timestamps.
@@ -941,9 +937,9 @@ class o extends F {
     return Number(e.valueOf() - t.valueOf());
   }
 }
-let p = class l extends F {
+class l extends Z {
   constructor(e) {
-    typeof e == "number" && (e = Math.trunc(e.valueOf())), E(e) && (e = e.value), super(BigInt(e.valueOf()));
+    typeof e == "number" && (e = Math.trunc(e.valueOf())), U(e) && (e = e.value), super(BigInt(e.valueOf()));
   }
   /**
    * Creates a TimeSpan representing the given number of seconds.
@@ -952,7 +948,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static fromSeconds(e) {
-    return e instanceof l ? e : e instanceof S ? e.period : e instanceof o ? new l(e) : (E(e) && (e = e.value), ["number", "bigint"].includes(typeof e) ? l.seconds(e) : new l(e));
+    return e instanceof l ? e : e instanceof E ? e.period : e instanceof u ? new l(e) : (U(e) && (e = e.value), ["number", "bigint"].includes(typeof e) ? l.seconds(e) : new l(e));
   }
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
@@ -961,7 +957,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static fromMilliseconds(e) {
-    return e instanceof l ? e : e instanceof S ? e.period : e instanceof o ? new l(e) : (E(e) && (e = e.value), ["number", "bigint"].includes(typeof e) ? l.milliseconds(e) : new l(e));
+    return e instanceof l ? e : e instanceof E ? e.period : e instanceof u ? new l(e) : (U(e) && (e = e.value), ["number", "bigint"].includes(typeof e) ? l.milliseconds(e) : new l(e));
   }
   /**
    * @returns the primitive value of the TimeSpan. Overrides standard JS valueOf()
@@ -1013,7 +1009,7 @@ let p = class l extends F {
    * @returns A new TimeSpan representing the remainder.
    */
   remainder(e) {
-    return ke(this, e);
+    return qe(this, e);
   }
   /**
    * Truncates the TimeSpan to the nearest multiple of the given span.
@@ -1029,12 +1025,72 @@ let p = class l extends F {
   /**
    * Returns a string representation of the TimeSpan.
    *
+   * @param format - Optional format for the string representation. Defaults to "full".
+   *   - "full": Shows all non-zero units with full precision (e.g., "2d 3h 45m 12s 500ms")
+   *   - "semantic": Shows 1-2 most significant units (e.g., "2d 3h")
    * @returns A string representation of the TimeSpan.
    */
-  toString() {
-    const e = this.truncate(l.DAY), t = this.truncate(l.HOUR), r = this.truncate(l.MINUTE), i = this.truncate(l.SECOND), a = this.truncate(l.MILLISECOND), c = this.truncate(l.MICROSECOND), g = this.truncate(l.NANOSECOND), y = e, f = t.sub(e), m = r.sub(t), b = i.sub(r), h = a.sub(i), T = c.sub(a), A = g.sub(c);
-    let C = "";
-    return y.isZero || (C += `${y.days}d `), f.isZero || (C += `${f.hours}h `), m.isZero || (C += `${m.minutes}m `), b.isZero || (C += `${b.seconds}s `), h.isZero || (C += `${h.milliseconds}ms `), T.isZero || (C += `${T.microseconds}µs `), A.isZero || (C += `${A.nanoseconds}ns`), C.trim();
+  toString(e = "full") {
+    if (e === "semantic") return this.toSemanticString();
+    const t = this.truncate(l.DAY), r = this.truncate(l.HOUR), i = this.truncate(l.MINUTE), a = this.truncate(l.SECOND), c = this.truncate(l.MILLISECOND), d = this.truncate(l.MICROSECOND), y = this.truncate(l.NANOSECOND), f = t, g = r.sub(t), w = i.sub(r), h = a.sub(i), T = c.sub(a), A = d.sub(c), M = y.sub(d);
+    let m = "";
+    return f.isZero || (m += `${f.days}d `), g.isZero || (m += `${g.hours}h `), w.isZero || (m += `${w.minutes}m `), h.isZero || (m += `${h.seconds}s `), T.isZero || (m += `${T.milliseconds}ms `), A.isZero || (m += `${A.microseconds}µs `), M.isZero || (m += `${M.nanoseconds}ns`), m.trim();
+  }
+  toSemanticString() {
+    const e = this.valueOf() < 0n ? -this.valueOf() : this.valueOf(), t = new l(e), r = this.valueOf() < 0n;
+    if (t.valueOf() === 0n) return "0s";
+    if (t.lessThan(l.SECOND)) return "< 1s";
+    const i = t.days, a = t.hours, c = t.minutes, d = t.seconds, y = Math.floor(i / xe), f = Math.floor(i / K), g = Math.floor(i / 7), w = Math.floor(i), h = Math.floor(a), T = Math.floor(c), A = Math.floor(d), M = r ? "-" : "";
+    if (y >= 1) {
+      let m = `${y}y`;
+      if (y < 2) {
+        const v = Math.floor(
+          i % xe / K
+        );
+        v > 0 && (m += ` ${v}mo`);
+      }
+      return M + m;
+    }
+    if (g >= 1 && i < K && i % 7 === 0) {
+      let m = `${g}w`;
+      const v = Math.floor(i % 7), L = Math.floor(a - g * 7 * 24);
+      return g < 2 && (v > 0 ? m += ` ${v}d` : L > 0 && L < 24 && (m += ` ${L}h`)), M + m;
+    }
+    if (f >= 1) {
+      let m = `${f}mo`;
+      if (f < 3) {
+        const v = Math.floor(i % K);
+        v > 0 && (m += ` ${v}d`);
+      }
+      return M + m;
+    }
+    if (g >= 1) {
+      let m = `${g}w`;
+      const v = Math.floor(i % 7), L = Math.floor(a - g * 7 * 24);
+      return g < 2 && (v > 0 ? m += ` ${v}d` : L > 0 && L < 24 && (m += ` ${L}h`)), M + m;
+    }
+    if (w >= 1) {
+      let m = `${w}d`;
+      const v = Math.floor(a - w * 24);
+      return w < 2 && v > 0 && (m += ` ${v}h`), M + m;
+    }
+    if (h >= 1) {
+      let m = `${h}h`;
+      if (h < 3) {
+        const v = Math.floor(c - h * 60);
+        v > 0 && (m += ` ${v}m`);
+      }
+      return M + m;
+    }
+    if (T >= 1) {
+      let m = `${T}m`;
+      if (T < 5) {
+        const v = Math.floor(d - T * 60);
+        v > 0 && (m += ` ${v}s`);
+      }
+      return M + m;
+    }
+    return `${M}${A}s`;
   }
   /**
    * Multiplies the TimeSpan by a scalar value.
@@ -1043,7 +1099,7 @@ let p = class l extends F {
    * @returns A new TimeSpan that is this TimeSpan multiplied by the provided value.
    */
   mult(e) {
-    return new l(M(this.valueOf(), e));
+    return new l(C(this.valueOf(), e));
   }
   /**
    * Divides the TimeSpan by a scalar value.
@@ -1052,7 +1108,7 @@ let p = class l extends F {
    * @returns A new TimeSpan that is this TimeSpan divided by the provided value.
    */
   div(e) {
-    return new l(ne(this.valueOf(), e));
+    return new l(se(this.valueOf(), e));
   }
   /** @returns the decimal number of days in the TimeSpan. */
   get days() {
@@ -1132,7 +1188,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of microseconds.
    */
   static microseconds(e = 1) {
-    return l.nanoseconds(M(e, 1e3));
+    return l.nanoseconds(C(e, 1e3));
   }
   /** A microsecond. */
   static MICROSECOND = l.microseconds(1);
@@ -1143,7 +1199,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static milliseconds(e = 1) {
-    return l.microseconds(M(e, 1e3));
+    return l.microseconds(C(e, 1e3));
   }
   /** A millisecond. */
   static MILLISECOND = l.milliseconds(1);
@@ -1154,7 +1210,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static seconds(e = 1) {
-    return l.milliseconds(M(e, 1e3));
+    return l.milliseconds(C(e, 1e3));
   }
   /** A second. */
   static SECOND = l.seconds(1);
@@ -1165,7 +1221,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of minutes.
    */
   static minutes(e = 1) {
-    return l.seconds(M(e, 60));
+    return l.seconds(C(e, 60));
   }
   /** A minute. */
   static MINUTE = l.minutes(1);
@@ -1176,7 +1232,7 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of hours.
    */
   static hours(e) {
-    return l.minutes(M(e, 60));
+    return l.minutes(C(e, 60));
   }
   /** Represents an hour. */
   static HOUR = l.hours(1);
@@ -1187,30 +1243,30 @@ let p = class l extends F {
    * @returns A TimeSpan representing the given number of days.
    */
   static days(e) {
-    return l.hours(M(e, 24));
+    return l.hours(C(e, 24));
   }
   /** Represents a day. */
   static DAY = l.days(1);
   /** The maximum possible value for a TimeSpan. */
-  static MAX = new l((1n << 63n) - 1n);
+  static MAX = new l(ce);
   /** The minimum possible value for a TimeSpan. */
   static MIN = new l(0);
   /** The zero value for a TimeSpan. */
   static ZERO = new l(0);
-  /** A zod schema for validating and transforming timespans */
+  /** A zod schema for validating and transforming time spans */
   static z = s.union([
     s.object({ value: s.bigint() }).transform((e) => new l(e.value)),
     s.string().transform((e) => new l(BigInt(e))),
     s.number().transform((e) => new l(e)),
     s.bigint().transform((e) => new l(e)),
     s.instanceof(l),
-    s.instanceof(o).transform((e) => new l(e)),
-    s.custom((e) => e instanceof S).transform((e) => new l(e))
+    s.instanceof(u).transform((e) => new l(e)),
+    s.custom((e) => e instanceof E).transform((e) => new l(e))
   ]);
-};
-class S extends F {
+}
+class E extends Z {
   constructor(e) {
-    E(e) && (e = e.value), super(e.valueOf());
+    U(e) && (e = e.value), super(e.valueOf());
   }
   /** @returns a pretty string representation of the rate in the format "X Hz". */
   toString() {
@@ -1218,7 +1274,7 @@ class S extends F {
   }
   /** @returns The number of seconds in the Rate. */
   equals(e) {
-    return this.valueOf() === new S(e).valueOf();
+    return this.valueOf() === new E(e).valueOf();
   }
   /**
    * Calculates the period of the Rate as a TimeSpan.
@@ -1226,7 +1282,7 @@ class S extends F {
    * @returns A TimeSpan representing the period of the Rate.
    */
   get period() {
-    return p.seconds(1 / this.valueOf());
+    return l.seconds(1 / this.valueOf());
   }
   /**
    * Calculates the number of samples in the given TimeSpan at this rate.
@@ -1235,7 +1291,7 @@ class S extends F {
    * @returns The number of samples in the given TimeSpan at this rate.
    */
   sampleCount(e) {
-    return new p(e).seconds * this.valueOf();
+    return new l(e).seconds * this.valueOf();
   }
   /**
    * Calculates the number of bytes in the given TimeSpan at this rate.
@@ -1254,7 +1310,7 @@ class S extends F {
    * @returns A TimeSpan that corresponds to the given number of samples.
    */
   span(e) {
-    return p.seconds(e / this.valueOf());
+    return l.seconds(e / this.valueOf());
   }
   /**
    * Calculates a TimeSpan given the number of bytes at this rate.
@@ -1273,7 +1329,7 @@ class S extends F {
    * @returns A new Rate representing the sum of the two rates.
    */
   add(e) {
-    return new S(te(this.valueOf(), new S(e).valueOf()));
+    return new E(re(this.valueOf(), new E(e).valueOf()));
   }
   /**
    * Subtracts another Rate from this Rate.
@@ -1282,7 +1338,7 @@ class S extends F {
    * @returns A new Rate representing the difference of the two rates.
    */
   sub(e) {
-    return new S(ee(this.valueOf(), new S(e).valueOf()));
+    return new E(ne(this.valueOf(), new E(e).valueOf()));
   }
   /**
    * Multiplies this Rate by a scalar value.
@@ -1291,7 +1347,7 @@ class S extends F {
    * @returns A new Rate representing this Rate multiplied by the value.
    */
   mult(e) {
-    return new S(M(this.valueOf(), e));
+    return new E(C(this.valueOf(), e));
   }
   /**
    * Divides this Rate by a scalar value.
@@ -1300,7 +1356,7 @@ class S extends F {
    * @returns A new Rate representing this Rate divided by the value.
    */
   div(e) {
-    return new S(ne(this.valueOf(), e));
+    return new E(se(this.valueOf(), e));
   }
   /**
    * Creates a Rate representing the given number of Hz.
@@ -1309,7 +1365,7 @@ class S extends F {
    * @returns A Rate representing the given number of Hz.
    */
   static hz(e) {
-    return new S(e);
+    return new E(e);
   }
   /**
    * Creates a Rate representing the given number of kHz.
@@ -1318,15 +1374,15 @@ class S extends F {
    * @returns A Rate representing the given number of kHz.
    */
   static khz(e) {
-    return S.hz(e * 1e3);
+    return E.hz(e * 1e3);
   }
   /** A zod schema for validating and transforming rates */
   static z = s.union([
-    s.number().transform((e) => new S(e)),
-    s.instanceof(S)
+    s.number().transform((e) => new E(e)),
+    s.instanceof(E)
   ]);
 }
-let I = class N extends F {
+let I = class N extends Z {
   /**
    * Creates a Density representing the given number of bytes per value.
    *
@@ -1335,7 +1391,7 @@ let I = class N extends F {
    * @returns A Density representing the given number of bytes per value.
    */
   constructor(e) {
-    E(e) && (e = e.value), super(e.valueOf());
+    U(e) && (e = e.value), super(e.valueOf());
   }
   /**
    * Calculates the number of values in the given Size.
@@ -1353,7 +1409,7 @@ let I = class N extends F {
    * @returns A Size representing the given number of values.
    */
   size(e) {
-    return new ue(e * this.valueOf());
+    return new he(e * this.valueOf());
   }
   /**
    * Adds another Density to this Density.
@@ -1362,7 +1418,7 @@ let I = class N extends F {
    * @returns A new Density representing the sum of the two densities.
    */
   add(e) {
-    return new N(te(this.valueOf(), new N(e).valueOf()));
+    return new N(re(this.valueOf(), new N(e).valueOf()));
   }
   /**
    * Subtracts another Density from this Density.
@@ -1371,7 +1427,7 @@ let I = class N extends F {
    * @returns A new Density representing the difference of the two densities.
    */
   sub(e) {
-    return new N(ee(this.valueOf(), new N(e).valueOf()));
+    return new N(ne(this.valueOf(), new N(e).valueOf()));
   }
   /**
    * Multiplies this Density by a scalar value.
@@ -1380,7 +1436,7 @@ let I = class N extends F {
    * @returns A new Density representing this Density multiplied by the value.
    */
   mult(e) {
-    return new N(M(this.valueOf(), e));
+    return new N(C(this.valueOf(), e));
   }
   /**
    * Divides this Density by a scalar value.
@@ -1389,7 +1445,7 @@ let I = class N extends F {
    * @returns A new Density representing this Density divided by the value.
    */
   div(e) {
-    return new N(ne(this.valueOf(), e));
+    return new N(se(this.valueOf(), e));
   }
   /** Unknown/Invalid Density. */
   static UNKNOWN = new N(0);
@@ -1408,7 +1464,8 @@ let I = class N extends F {
     s.number().transform((e) => new N(e)),
     s.instanceof(N)
   ]);
-}, W = class x {
+};
+class x {
   /**
    * The starting TimeStamp of the TimeRange.
    *
@@ -1434,11 +1491,11 @@ let I = class N extends F {
    * @param end - A TimeStamp representing the end of the range.
    */
   constructor(e, t) {
-    typeof e == "object" && "start" in e ? (this.start = new o(e.start), this.end = new o(e.end)) : (this.start = new o(e), this.end = new o(t));
+    typeof e == "object" && "start" in e ? (this.start = new u(e.start), this.end = new u(e.end)) : (this.start = new u(e), this.end = new u(t));
   }
   /** @returns The TimeSpan occupied by the TimeRange. */
   get span() {
-    return new p(this.end.valueOf() - this.start.valueOf());
+    return new l(this.end.valueOf() - this.start.valueOf());
   }
   /**
    * Checks if the timestamp is valid i.e. the start is before the end.
@@ -1457,12 +1514,12 @@ let I = class N extends F {
     return this.isValid ? this : this.swap();
   }
   /**
-   * Checks if the TimeRange has a zero span.
+   * Checks if the TimeRange is zero (both start and end are TimeStamp.ZERO).
    *
-   * @returns True if the TimeRange has a zero span.
+   * @returns True if both start and end are TimeStamp.ZERO, false otherwise.
    */
   get isZero() {
-    return this.span.isZero;
+    return this.start.isZero && this.end.isZero;
   }
   /**
    * @returns the TimeRange as a numeric object with start and end properties.
@@ -1490,7 +1547,7 @@ let I = class N extends F {
    * @param other - The TimeRange to compare to.
    * @returns True if the TimeRange is equal to the given TimeRange.
    */
-  equals(e, t = p.ZERO) {
+  equals(e, t = l.ZERO) {
     if (t.isZero)
       return this.start.equals(e.start) && this.end.equals(e.end);
     let r = this.start.sub(e.start).valueOf(), i = this.end.sub(e.end).valueOf();
@@ -1510,7 +1567,7 @@ let I = class N extends F {
    * @returns A pretty string representation of the TimeRange.
    */
   toPrettyString() {
-    return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
+    return `${this.start.toString("preciseDate")} - ${this.span.toString()}`;
   }
   /**
    * Checks if the two time ranges overlap. If the two time ranges are equal, returns
@@ -1523,13 +1580,13 @@ let I = class N extends F {
    * checking for overlap.
    * @returns True if the two TimeRanges overlap, false otherwise.
    */
-  overlapsWith(e, t = p.ZERO) {
+  overlapsWith(e, t = l.ZERO) {
     e = e.makeValid();
     const r = this.makeValid();
     if (this.equals(e)) return !0;
     if (e.end.equals(r.start) || r.end.equals(e.start)) return !1;
-    const i = o.max(r.start, e.start), a = o.min(r.end, e.end);
-    return a.before(i) ? !1 : new p(a.sub(i)).greaterThanOrEqual(t);
+    const i = u.max(r.start, e.start), a = u.min(r.end, e.end);
+    return a.before(i) ? !1 : new l(a.sub(i)).greaterThanOrEqual(t);
   }
   contains(e) {
     return e instanceof x ? this.contains(e.start) && this.contains(e.end) : this.start.beforeEq(e) && this.end.after(e);
@@ -1551,19 +1608,17 @@ let I = class N extends F {
   }
   static max(...e) {
     return new x(
-      o.min(...e.map((t) => t.start)),
-      o.max(...e.map((t) => t.end))
+      u.min(...e.map((t) => t.start)),
+      u.max(...e.map((t) => t.end))
     );
   }
   /** The maximum possible time range. */
-  static MAX = new x(o.MIN, o.MAX);
-  /** The minimum possible time range. */
-  static MIN = new x(o.MAX, o.MIN);
+  static MAX = new x(u.MIN, u.MAX);
   /** A time range whose start and end are both zero. */
-  static ZERO = new x(o.ZERO, o.ZERO);
+  static ZERO = new x(u.ZERO, u.ZERO);
   /** A zod schema for validating and transforming time ranges */
   static z = s.union([
-    s.object({ start: o.z, end: o.z }).transform((e) => new x(e.start, e.end)),
+    s.object({ start: u.z, end: u.z }).transform((e) => new x(e.start, e.end)),
     s.instanceof(x)
   ]);
   /**
@@ -1578,7 +1633,7 @@ let I = class N extends F {
    * equal.
    */
   static sort(e, t) {
-    return o.sort(e.start, t.start) || o.sort(e.end, t.end);
+    return u.sort(e.start, t.start) || u.sort(e.end, t.end);
   }
   /**
    * Simplify takes the list of `TimeRange`s, makes all of them valid, sorts them, and
@@ -1589,19 +1644,20 @@ let I = class N extends F {
    */
   static simplify(e) {
     return e.map((t) => t.makeValid()).sort((t, r) => x.sort(t, r)).reduce((t, r) => {
-      if (r.isZero) return t;
+      if (r.span.isZero) return t;
       if (t.length === 0)
         return t.push(r), t;
       const i = t[t.length - 1];
-      return i.overlapsWith(r) || i.end.equals(r.start) ? i.end = o.max(i.end, r.end) : t.push(r), t;
+      return i.overlapsWith(r) || i.end.equals(r.start) ? i.end = u.max(i.end, r.end) : t.push(r), t;
     }, []);
   }
-}, w = class u extends F {
+}
+let O = class o extends Z {
   constructor(e) {
-    if (E(e) && (e = e.value), e instanceof u || typeof e == "string" || typeof e.valueOf() == "string")
+    if (U(e) && (e = e.value), e instanceof o || typeof e == "string" || typeof e.valueOf() == "string")
       super(e.valueOf());
     else {
-      const t = u.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
+      const t = o.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
       if (t == null)
         throw new Error(`unable to find data type for ${e.toString()}`);
       super(t.valueOf());
@@ -1611,7 +1667,7 @@ let I = class N extends F {
    * @returns the TypedArray constructor for the DataType.
    */
   get Array() {
-    const e = u.ARRAY_CONSTRUCTORS.get(this.toString());
+    const e = o.ARRAY_CONSTRUCTORS.get(this.toString());
     if (e == null)
       throw new Error(`unable to find array constructor for ${this.valueOf()}`);
     return e;
@@ -1628,9 +1684,10 @@ let I = class N extends F {
   matches(...e) {
     return e.some((t) => this.equals(t));
   }
-  /** @returns a string representation of the DataType. */
-  toString() {
-    return this.valueOf();
+  /** @returns a string representation of the DataType. If short is true, a 1-4
+   * character representation (i64, str, etc.) is returned instead. */
+  toString(e = !1) {
+    return e ? o.SHORT_STRINGS.get(this.valueOf()) ?? this.valueOf() : this.valueOf();
   }
   /**
    * @returns true if the DataType has a variable density.
@@ -1638,7 +1695,7 @@ let I = class N extends F {
    * @example DataType.INT32.isVariable // false
    */
   get isVariable() {
-    return this.equals(u.JSON) || this.equals(u.STRING);
+    return this.equals(o.JSON) || this.equals(o.STRING);
   }
   /**
    * @returns true if the DataType is numeric.
@@ -1646,7 +1703,7 @@ let I = class N extends F {
    * @example DataType.STRING.isNumeric // false
    */
   get isNumeric() {
-    return !this.isVariable && !this.equals(u.UUID);
+    return !this.isVariable && !this.equals(o.UUID);
   }
   /**
    * @returns true if the DataType is an integer.
@@ -1671,7 +1728,7 @@ let I = class N extends F {
    * @example DataType.FLOAT32.density // Density.BIT32
    */
   get density() {
-    const e = u.DENSITIES.get(this.toString());
+    const e = o.DENSITIES.get(this.toString());
     if (e == null) throw new Error(`unable to find density for ${this.valueOf()}`);
     return e;
   }
@@ -1681,7 +1738,7 @@ let I = class N extends F {
    * @example DataType.INT32.isUnsigned // false
    */
   get isUnsignedInteger() {
-    return this.equals(u.UINT8) || this.equals(u.UINT16) || this.equals(u.UINT32) || this.equals(u.UINT64);
+    return this.equals(o.UINT8) || this.equals(o.UINT16) || this.equals(o.UINT32) || this.equals(o.UINT64);
   }
   /**
    * @returns true if the DataType is a signed integer.
@@ -1689,11 +1746,11 @@ let I = class N extends F {
    * @example DataType.UINT32.isSigned // false
    */
   get isSignedInteger() {
-    return this.equals(u.INT8) || this.equals(u.INT16) || this.equals(u.INT32) || this.equals(u.INT64);
+    return this.equals(o.INT8) || this.equals(o.INT16) || this.equals(o.INT32) || this.equals(o.INT64);
   }
   /** @returns true if the data type can be cast to the other data type without loss of precision. */
   canSafelyCastTo(e) {
-    return this.equals(e) ? !0 : !this.isNumeric || !e.isNumeric || this.isVariable || e.isVariable || this.isUnsignedInteger && e.isSignedInteger ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(u.INT32) && e.equals(u.FLOAT64) || this.equals(u.INT8) && e.equals(u.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsignedInteger === e.isUnsignedInteger : !1;
+    return this.equals(e) ? !0 : !this.isNumeric || !e.isNumeric || this.isVariable || e.isVariable || this.isUnsignedInteger && e.isSignedInteger ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(o.INT32) && e.equals(o.FLOAT64) || this.equals(o.INT8) && e.equals(o.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsignedInteger === e.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(e) {
@@ -1710,129 +1767,146 @@ let I = class N extends F {
   }
   /** @returns true if the data type uses bigints to store values. */
   get usesBigInt() {
-    return u.BIG_INT_TYPES.some((e) => e.equals(this));
+    return o.BIG_INT_TYPES.some((e) => e.equals(this));
   }
   /** Represents an Unknown/Invalid DataType. */
-  static UNKNOWN = new u("unknown");
+  static UNKNOWN = new o("unknown");
   /** Represents a 64-bit floating point value. */
-  static FLOAT64 = new u("float64");
+  static FLOAT64 = new o("float64");
   /** Represents a 32-bit floating point value. */
-  static FLOAT32 = new u("float32");
+  static FLOAT32 = new o("float32");
   /** Represents a 64-bit signed integer value. */
-  static INT64 = new u("int64");
+  static INT64 = new o("int64");
   /** Represents a 32-bit signed integer value. */
-  static INT32 = new u("int32");
+  static INT32 = new o("int32");
   /** Represents a 16-bit signed integer value. */
-  static INT16 = new u("int16");
+  static INT16 = new o("int16");
   /** Represents a 8-bit signed integer value. */
-  static INT8 = new u("int8");
+  static INT8 = new o("int8");
   /** Represents a 64-bit unsigned integer value. */
-  static UINT64 = new u("uint64");
+  static UINT64 = new o("uint64");
   /** Represents a 32-bit unsigned integer value. */
-  static UINT32 = new u("uint32");
+  static UINT32 = new o("uint32");
   /** Represents a 16-bit unsigned integer value. */
-  static UINT16 = new u("uint16");
+  static UINT16 = new o("uint16");
   /** Represents a 8-bit unsigned integer value. */
-  static UINT8 = new u("uint8");
-  /** Represents a boolean value. Alias for UINT8. */
-  static BOOLEAN = this.UINT8;
+  static UINT8 = new o("uint8");
+  /** Represents a boolean value. Stored as a 8-bit unsigned integer. */
+  static BOOLEAN = new o("boolean");
   /** Represents a 64-bit unix epoch. */
-  static TIMESTAMP = new u("timestamp");
-  /** Represents a UUID data type */
-  static UUID = new u("uuid");
+  static TIMESTAMP = new o("timestamp");
+  /** Represents a UUID data type. */
+  static UUID = new o("uuid");
   /** Represents a string data type. Strings have an unknown density, and are separate
    * by a newline character. */
-  static STRING = new u("string");
+  static STRING = new o("string");
   /** Represents a JSON data type. JSON has an unknown density, and is separated by a
    * newline character. */
-  static JSON = new u("json");
+  static JSON = new o("json");
   static ARRAY_CONSTRUCTORS = /* @__PURE__ */ new Map([
-    [u.UINT8.toString(), Uint8Array],
-    [u.UINT16.toString(), Uint16Array],
-    [u.UINT32.toString(), Uint32Array],
-    [u.UINT64.toString(), BigUint64Array],
-    [u.FLOAT32.toString(), Float32Array],
-    [u.FLOAT64.toString(), Float64Array],
-    [u.INT8.toString(), Int8Array],
-    [u.INT16.toString(), Int16Array],
-    [u.INT32.toString(), Int32Array],
-    [u.INT64.toString(), BigInt64Array],
-    [u.TIMESTAMP.toString(), BigInt64Array],
-    [u.STRING.toString(), Uint8Array],
-    [u.JSON.toString(), Uint8Array],
-    [u.UUID.toString(), Uint8Array]
+    [o.UINT8.toString(), Uint8Array],
+    [o.UINT16.toString(), Uint16Array],
+    [o.UINT32.toString(), Uint32Array],
+    [o.UINT64.toString(), BigUint64Array],
+    [o.FLOAT32.toString(), Float32Array],
+    [o.FLOAT64.toString(), Float64Array],
+    [o.INT8.toString(), Int8Array],
+    [o.INT16.toString(), Int16Array],
+    [o.INT32.toString(), Int32Array],
+    [o.INT64.toString(), BigInt64Array],
+    [o.TIMESTAMP.toString(), BigInt64Array],
+    [o.STRING.toString(), Uint8Array],
+    [o.JSON.toString(), Uint8Array],
+    [o.UUID.toString(), Uint8Array]
   ]);
   static ARRAY_CONSTRUCTOR_DATA_TYPES = /* @__PURE__ */ new Map([
-    [Uint8Array.name, u.UINT8],
-    [Uint16Array.name, u.UINT16],
-    [Uint32Array.name, u.UINT32],
-    [BigUint64Array.name, u.UINT64],
-    [Float32Array.name, u.FLOAT32],
-    [Float64Array.name, u.FLOAT64],
-    [Int8Array.name, u.INT8],
-    [Int16Array.name, u.INT16],
-    [Int32Array.name, u.INT32],
-    [BigInt64Array.name, u.INT64]
+    [Uint8Array.name, o.UINT8],
+    [Uint16Array.name, o.UINT16],
+    [Uint32Array.name, o.UINT32],
+    [BigUint64Array.name, o.UINT64],
+    [Float32Array.name, o.FLOAT32],
+    [Float64Array.name, o.FLOAT64],
+    [Int8Array.name, o.INT8],
+    [Int16Array.name, o.INT16],
+    [Int32Array.name, o.INT32],
+    [BigInt64Array.name, o.INT64]
   ]);
   static DENSITIES = /* @__PURE__ */ new Map([
-    [u.UINT8.toString(), I.BIT8],
-    [u.UINT16.toString(), I.BIT16],
-    [u.UINT32.toString(), I.BIT32],
-    [u.UINT64.toString(), I.BIT64],
-    [u.FLOAT32.toString(), I.BIT32],
-    [u.FLOAT64.toString(), I.BIT64],
-    [u.INT8.toString(), I.BIT8],
-    [u.INT16.toString(), I.BIT16],
-    [u.INT32.toString(), I.BIT32],
-    [u.INT64.toString(), I.BIT64],
-    [u.TIMESTAMP.toString(), I.BIT64],
-    [u.STRING.toString(), I.UNKNOWN],
-    [u.JSON.toString(), I.UNKNOWN],
-    [u.UUID.toString(), I.BIT128]
+    [o.UINT8.toString(), I.BIT8],
+    [o.UINT16.toString(), I.BIT16],
+    [o.UINT32.toString(), I.BIT32],
+    [o.UINT64.toString(), I.BIT64],
+    [o.FLOAT32.toString(), I.BIT32],
+    [o.FLOAT64.toString(), I.BIT64],
+    [o.INT8.toString(), I.BIT8],
+    [o.INT16.toString(), I.BIT16],
+    [o.INT32.toString(), I.BIT32],
+    [o.INT64.toString(), I.BIT64],
+    [o.TIMESTAMP.toString(), I.BIT64],
+    [o.STRING.toString(), I.UNKNOWN],
+    [o.JSON.toString(), I.UNKNOWN],
+    [o.UUID.toString(), I.BIT128]
   ]);
   /** All the data types. */
   static ALL = [
-    u.UNKNOWN,
-    u.FLOAT64,
-    u.FLOAT32,
-    u.INT64,
-    u.INT32,
-    u.INT16,
-    u.INT8,
-    u.UINT64,
-    u.UINT32,
-    u.UINT16,
-    u.UINT8,
-    u.TIMESTAMP,
-    u.UUID,
-    u.STRING,
-    u.JSON
+    o.UNKNOWN,
+    o.FLOAT64,
+    o.FLOAT32,
+    o.INT64,
+    o.INT32,
+    o.INT16,
+    o.INT8,
+    o.UINT64,
+    o.UINT32,
+    o.UINT16,
+    o.UINT8,
+    o.TIMESTAMP,
+    o.UUID,
+    o.STRING,
+    o.JSON
   ];
-  static BIG_INT_TYPES = [u.INT64, u.UINT64, u.TIMESTAMP];
+  static SHORT_STRINGS = /* @__PURE__ */ new Map([
+    [o.UINT8.toString(), "u8"],
+    [o.UINT16.toString(), "u16"],
+    [o.UINT32.toString(), "u32"],
+    [o.UINT64.toString(), "u64"],
+    [o.INT8.toString(), "i8"],
+    [o.INT16.toString(), "i16"],
+    [o.INT32.toString(), "i32"],
+    [o.INT64.toString(), "i64"],
+    [o.FLOAT32.toString(), "f32"],
+    [o.FLOAT64.toString(), "f64"],
+    [o.BOOLEAN.toString(), "bool"],
+    [o.TIMESTAMP.toString(), "ts"],
+    [o.UUID.toString(), "uuid"],
+    [o.STRING.toString(), "str"],
+    [o.JSON.toString(), "json"]
+  ]);
+  static BIG_INT_TYPES = [o.INT64, o.UINT64, o.TIMESTAMP];
   /** A zod schema for a DataType. */
   static z = s.union([
-    s.string().transform((e) => new u(e)),
-    s.instanceof(u)
+    s.string().transform((e) => new o(e)),
+    s.instanceof(o)
   ]);
-}, ue = class d extends F {
+}, he = class p extends Z {
   constructor(e) {
-    E(e) && (e = e.value), super(e.valueOf());
+    U(e) && (e = e.value), super(e.valueOf());
   }
   /** @returns true if the Size is larger than the other size. */
   largerThan(e) {
-    return E(e) && (e = e.value), this.valueOf() > e.valueOf();
+    return U(e) && (e = e.value), this.valueOf() > e.valueOf();
   }
   /** @returns true if the Size is smaller than the other size. */
   smallerThan(e) {
-    return E(e) && (e = e.value), this.valueOf() < e.valueOf();
+    return U(e) && (e = e.value), this.valueOf() < e.valueOf();
   }
   /** @returns a new Size representing the sum of the two Sizes. */
   add(e) {
-    return E(e) && (e = e.value), new d(te(this.valueOf(), e.valueOf()));
+    return U(e) && (e = e.value), new p(re(this.valueOf(), e.valueOf()));
   }
   /** @returns a new Size representing the difference of the two Sizes. */
   sub(e) {
-    return E(e) && (e = e.value), new d(ee(this.valueOf(), e.valueOf()));
+    return U(e) && (e = e.value), new p(ne(this.valueOf(), e.valueOf()));
   }
   /**
    * Multiplies this Size by a scalar value.
@@ -1841,7 +1915,7 @@ let I = class N extends F {
    * @returns A new Size representing this Size multiplied by the value.
    */
   mult(e) {
-    return new d(M(this.valueOf(), e));
+    return new p(C(this.valueOf(), e));
   }
   /**
    * Divides this Size by a scalar value.
@@ -1850,39 +1924,39 @@ let I = class N extends F {
    * @returns A new Size representing this Size divided by the value.
    */
   div(e) {
-    return new d(ne(this.valueOf(), e));
+    return new p(se(this.valueOf(), e));
   }
   /** @returns a new Size representing the truncated value of the Size. */
   truncate(e) {
-    return new d(
-      Math.trunc(this.valueOf() / new d(e).valueOf()) * new d(e).valueOf()
+    return new p(
+      Math.trunc(this.valueOf() / new p(e).valueOf()) * new p(e).valueOf()
     );
   }
   /** @returns a new Size representing the remainder of the Size. */
   remainder(e) {
-    return d.bytes(this.valueOf() % new d(e).valueOf());
+    return p.bytes(this.valueOf() % new p(e).valueOf());
   }
   /** @returns the number of gigabytes in the Size. */
   get gigabytes() {
-    return this.valueOf() / d.GIGABYTE.valueOf();
+    return this.valueOf() / p.GIGABYTE.valueOf();
   }
   /** @returns the number of megabytes in the Size. */
   get megabytes() {
-    return this.valueOf() / d.MEGABYTE.valueOf();
+    return this.valueOf() / p.MEGABYTE.valueOf();
   }
   /** @returns the number of kilobytes in the Size. */
   get kilobytes() {
-    return this.valueOf() / d.KILOBYTE.valueOf();
+    return this.valueOf() / p.KILOBYTE.valueOf();
   }
   /** @returns the number of terabytes in the Size. */
   get terabytes() {
-    return this.valueOf() / d.TERABYTE.valueOf();
+    return this.valueOf() / p.TERABYTE.valueOf();
   }
   /** @returns a nicely formatted string representation of the Size. */
   toString() {
-    const e = this.truncate(d.TERABYTE), t = this.truncate(d.GIGABYTE), r = this.truncate(d.MEGABYTE), i = this.truncate(d.KILOBYTE), a = this.truncate(d.BYTE), c = e, g = t.sub(e), y = r.sub(t), f = i.sub(r), m = a.sub(i);
-    let b = "";
-    return c.isZero || (b += `${c.terabytes}TB `), g.isZero || (b += `${g.gigabytes}GB `), y.isZero || (b += `${y.megabytes}MB `), f.isZero || (b += `${f.kilobytes}KB `), (!m.isZero || b === "") && (b += `${m.valueOf()}B`), b.trim();
+    const e = this.truncate(p.TERABYTE), t = this.truncate(p.GIGABYTE), r = this.truncate(p.MEGABYTE), i = this.truncate(p.KILOBYTE), a = this.truncate(p.BYTE), c = e, d = t.sub(e), y = r.sub(t), f = i.sub(r), g = a.sub(i);
+    let w = "";
+    return c.isZero || (w += `${c.terabytes}TB `), d.isZero || (w += `${d.gigabytes}GB `), y.isZero || (w += `${y.megabytes}MB `), f.isZero || (w += `${f.kilobytes}KB `), (!g.isZero || w === "") && (w += `${g.valueOf()}B`), w.trim();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -1891,10 +1965,10 @@ let I = class N extends F {
    * @returns A Size representing the given number of bytes.
    */
   static bytes(e = 1) {
-    return new d(e);
+    return new p(e);
   }
   /** A single byte */
-  static BYTE = new d(1);
+  static BYTE = new p(1);
   /**
    * Creates a Size from the given number if kilobytes.
    *
@@ -1902,10 +1976,10 @@ let I = class N extends F {
    * @returns A Size representing the given number of kilobytes.
    */
   static kilobytes(e = 1) {
-    return d.bytes(new d(e).valueOf() * 1e3);
+    return p.bytes(new p(e).valueOf() * 1e3);
   }
   /** A kilobyte */
-  static KILOBYTE = d.kilobytes(1);
+  static KILOBYTE = p.kilobytes(1);
   /**
    * Creates a Size from the given number of megabytes.
    *
@@ -1913,10 +1987,10 @@ let I = class N extends F {
    * @returns A Size representing the given number of megabytes.
    */
   static megabytes(e = 1) {
-    return d.kilobytes(new d(e).valueOf() * 1e3);
+    return p.kilobytes(new p(e).valueOf() * 1e3);
   }
   /** A megabyte */
-  static MEGABYTE = d.megabytes(1);
+  static MEGABYTE = p.megabytes(1);
   /**
    * Creates a Size from the given number of gigabytes.
    *
@@ -1924,10 +1998,10 @@ let I = class N extends F {
    * @returns A Size representing the given number of gigabytes.
    */
   static gigabytes(e = 1) {
-    return d.megabytes(new d(e).valueOf() * 1e3);
+    return p.megabytes(new p(e).valueOf() * 1e3);
   }
   /** A gigabyte */
-  static GIGABYTE = d.gigabytes(1);
+  static GIGABYTE = p.gigabytes(1);
   /**
    * Creates a Size from the given number of terabytes.
    *
@@ -1935,22 +2009,26 @@ let I = class N extends F {
    * @returns  A Size representing the given number of terabytes.
    */
   static terabytes(e) {
-    return d.gigabytes(new d(e).valueOf() * 1e3);
+    return p.gigabytes(new p(e).valueOf() * 1e3);
   }
   /** A terabyte. */
-  static TERABYTE = d.terabytes(1);
+  static TERABYTE = p.terabytes(1);
   /** The zero value for Size */
-  static ZERO = new d(0);
+  static ZERO = new p(0);
   /** A zod schema for a Size. */
   static z = s.union([
-    s.number().transform((e) => new d(e)),
-    s.instanceof(d)
+    s.number().transform((e) => new p(e)),
+    s.instanceof(p)
   ]);
   /** @returns true if the Size is zero. */
   get isZero() {
     return this.valueOf() === 0;
   }
 };
+s.object({
+  start: s.number(),
+  end: s.number()
+});
 s.union([
   s.instanceof(Uint8Array),
   s.instanceof(Uint16Array),
@@ -1963,37 +2041,37 @@ s.union([
   s.instanceof(Int32Array),
   s.instanceof(BigInt64Array)
 ]);
-const Pe = (n) => {
+const Fe = (n) => {
   const e = typeof n;
-  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || n instanceof o || n instanceof p || n instanceof Date;
-}, Ft = (n, e, t, r = 0) => n.usesBigInt && !e.usesBigInt ? Number(t) - Number(r) : !n.usesBigInt && e.usesBigInt ? BigInt(t.valueOf()) - BigInt(r.valueOf()) : X(t, -r), X = (n, e) => e == 0 ? n : n == 0 ? e : typeof n == "bigint" && typeof e == "bigint" || typeof n == "number" && typeof e == "number" ? n + e : Number(n) + Number(e), Wt = /^(?:[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 Zt(n) {
-  return typeof n == "string" && Wt.test(n);
+  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || n instanceof u || n instanceof l || n instanceof Date;
+}, zt = (n, e, t, r = 0) => n.usesBigInt && !e.usesBigInt ? Number(t) - Number(r) : !n.usesBigInt && e.usesBigInt ? BigInt(t.valueOf()) - BigInt(r.valueOf()) : Q(t, -r), Q = (n, e) => e == 0 ? n : n == 0 ? e : typeof n == "bigint" && typeof e == "bigint" || typeof n == "number" && typeof e == "number" ? n + e : Number(n) + Number(e), Vt = /^(?:[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 Ht(n) {
+  return typeof n == "string" && Vt.test(n);
 }
-const v = [];
+const S = [];
 for (let n = 0; n < 256; ++n)
-  v.push((n + 256).toString(16).slice(1));
-function Vt(n, e = 0) {
-  return (v[n[e + 0]] + v[n[e + 1]] + v[n[e + 2]] + v[n[e + 3]] + "-" + v[n[e + 4]] + v[n[e + 5]] + "-" + v[n[e + 6]] + v[n[e + 7]] + "-" + v[n[e + 8]] + v[n[e + 9]] + "-" + v[n[e + 10]] + v[n[e + 11]] + v[n[e + 12]] + v[n[e + 13]] + v[n[e + 14]] + v[n[e + 15]]).toLowerCase();
+  S.push((n + 256).toString(16).slice(1));
+function Jt(n, e = 0) {
+  return (S[n[e + 0]] + S[n[e + 1]] + S[n[e + 2]] + S[n[e + 3]] + "-" + S[n[e + 4]] + S[n[e + 5]] + "-" + S[n[e + 6]] + S[n[e + 7]] + "-" + S[n[e + 8]] + S[n[e + 9]] + "-" + S[n[e + 10]] + S[n[e + 11]] + S[n[e + 12]] + S[n[e + 13]] + S[n[e + 14]] + S[n[e + 15]]).toLowerCase();
 }
-function zt(n, e = 0) {
-  const t = Vt(n, e);
-  if (!Zt(t))
+function Kt(n, e = 0) {
+  const t = Jt(n, e);
+  if (!Ht(t))
     throw TypeError("Stringified UUID is invalid");
   return t;
 }
 typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const je = (n, e) => zt(n, e), $ = -1, Gt = s.string().transform(
+const We = (n, e) => Kt(n, e), R = -1, Xt = s.string().transform(
   (n) => new Uint8Array(
     atob(n).split("").map((e) => e.charCodeAt(0))
   ).buffer
-), Ht = s.union([s.null(), s.undefined()]).transform(() => new Uint8Array().buffer), le = 10, Jt = (n, e) => {
+), Qt = s.union([s.null(), s.undefined()]).transform(() => new Uint8Array().buffer), fe = 10, _t = (n, e) => {
   if (n === "number" && !e.isNumeric)
     throw new Error(`cannot convert series of type ${e.toString()} to number`);
   if (n === "bigint" && !e.usesBigInt)
     throw new Error(`cannot convert series of type ${e.toString()} to bigint`);
-}, Ye = "sy_x_telem_series";
-let qe = class B {
+}, Ze = "sy_x_telem_series";
+class B {
   /**
    * 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
@@ -2004,7 +2082,7 @@ let qe = class B {
    * A discriminator used for identifying instances of the series class even
    * when bundlers mangle the class name.
    */
-  discriminator = Ye;
+  discriminator = Ze;
   /** The data type of the series. */
   dataType;
   /**
@@ -2020,7 +2098,7 @@ let qe = class B {
   /** The underlying data. */
   _data;
   /** The time range occupied by the series' data. */
-  timeRange = W.ZERO;
+  timeRange = x.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.
@@ -2037,7 +2115,7 @@ let qe = class B {
   /** A cached maximum value. */
   cachedMax;
   /** The write position of the buffer. */
-  writePos = $;
+  writePos = R;
   /** Tracks the number of entities currently using this array. */
   _refCount = 0;
   /** Caches the length of the array for variable length data types. */
@@ -2049,16 +2127,16 @@ let qe = class B {
    * can be constructed into a series.
    */
   static crudeZ = s.object({
-    timeRange: W.z.optional(),
-    dataType: w.z,
+    timeRange: x.z.optional(),
+    dataType: O.z,
     alignment: s.coerce.bigint().optional(),
     data: s.union([
-      Gt,
-      Ht,
+      Xt,
+      Qt,
       s.instanceof(ArrayBuffer),
       s.instanceof(Uint8Array)
     ]),
-    glBufferUsage: Yt.optional().default("static").optional()
+    glBufferUsage: Wt.optional().default("static").optional()
   });
   /**
    * A zod schema that validates and constructs a series from it's crude
@@ -2139,61 +2217,61 @@ let qe = class B {
    * @throws Error if data type cannot be inferred from input
    */
   constructor(e) {
-    Xt(e) && (e = { data: e }), e.data ??= [];
+    en(e) && (e = { data: e }), e.data ??= [];
     const {
       dataType: t,
       timeRange: r,
       sampleOffset: i = 0,
       glBufferUsage: a = "static",
       alignment: c = 0n,
-      alignmentMultiple: g = 1n,
-      key: y = Pt(),
+      alignmentMultiple: d = 1n,
+      key: y = qt(),
       data: f
     } = e;
-    if (Kt(f)) {
+    if (tn(f)) {
       const h = f;
       this.key = h.key, this.dataType = h.dataType, this.sampleOffset = h.sampleOffset, this.gl = h.gl, this._data = h._data, this.timeRange = h.timeRange, this.alignment = h.alignment, this.alignmentMultiple = h.alignmentMultiple, this.cachedMin = h.cachedMin, this.cachedMax = h.cachedMax, this.writePos = h.writePos, this._refCount = h._refCount, this.cachedLength = h.cachedLength;
       return;
     }
-    const m = Pe(f), b = Array.isArray(f);
-    if (t != null) this.dataType = new w(t);
+    const g = Fe(f), w = Array.isArray(f);
+    if (t != null) this.dataType = new O(t);
     else {
       if (f instanceof ArrayBuffer)
         throw new Error(
           "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
         );
-      if (b || m) {
+      if (w || g) {
         let h = f;
-        if (!m) {
+        if (!g) {
           if (f.length === 0)
             throw new Error(
               "cannot infer data type from a zero length JS array when constructing a Series. Please provide a data type."
             );
           h = f[0];
         }
-        if (typeof h == "string") this.dataType = w.STRING;
-        else if (typeof h == "number") this.dataType = w.FLOAT64;
-        else if (typeof h == "bigint") this.dataType = w.INT64;
-        else if (typeof h == "boolean") this.dataType = w.BOOLEAN;
-        else if (h instanceof o || h instanceof Date || h instanceof o)
-          this.dataType = w.TIMESTAMP;
-        else if (typeof h == "object") this.dataType = w.JSON;
+        if (typeof h == "string") this.dataType = O.STRING;
+        else if (typeof h == "number") this.dataType = O.FLOAT64;
+        else if (typeof h == "bigint") this.dataType = O.INT64;
+        else if (typeof h == "boolean") this.dataType = O.BOOLEAN;
+        else if (h instanceof u || h instanceof Date || h instanceof u)
+          this.dataType = O.TIMESTAMP;
+        else if (typeof h == "object") this.dataType = O.JSON;
         else
           throw new Error(
             `cannot infer data type of ${typeof h} when constructing a Series from a JS array`
           );
-      } else this.dataType = new w(f);
+      } else this.dataType = new O(f);
     }
-    if (!b && !m) this._data = f;
-    else if (b && f.length === 0)
+    if (!w && !g) this._data = f;
+    else if (w && f.length === 0)
       this._data = new this.dataType.Array([]).buffer;
     else {
-      let h = m ? [f] : f;
+      let h = g ? [f] : f;
       const T = h[0];
-      (T instanceof o || T instanceof Date || T instanceof p) && (h = h.map((A) => new o(A).valueOf())), this.dataType.equals(w.STRING) ? (this.cachedLength = h.length, this._data = new TextEncoder().encode(`${h.join(`
+      (T instanceof u || T instanceof Date || T instanceof l) && (h = h.map((A) => new u(A).valueOf())), this.dataType.equals(O.STRING) ? (this.cachedLength = h.length, this._data = new TextEncoder().encode(`${h.join(`
 `)}
-`).buffer) : this.dataType.equals(w.JSON) ? (this.cachedLength = h.length, this._data = new TextEncoder().encode(
-        `${h.map((A) => oe.encodeString(A)).join(`
+`).buffer) : this.dataType.equals(O.JSON) ? (this.cachedLength = h.length, this._data = new TextEncoder().encode(
+        `${h.map((A) => le.encodeString(A)).join(`
 `)}
 `
       ).buffer) : this.dataType.usesBigInt && typeof T == "number" ? this._data = new this.dataType.Array(
@@ -2202,7 +2280,7 @@ let qe = class B {
         h.map(Number)
       ).buffer : this._data = new this.dataType.Array(h).buffer;
     }
-    this.key = y, this.alignment = c, this.alignmentMultiple = g, this.sampleOffset = i ?? 0, this.timeRange = r ?? W.ZERO, this.gl = {
+    this.key = y, this.alignment = c, this.alignmentMultiple = d, this.sampleOffset = i ?? 0, this.timeRange = r ?? x.ZERO, this.gl = {
       control: null,
       buffer: null,
       prevBuffer: 0,
@@ -2219,7 +2297,7 @@ let qe = class B {
   static alloc({ capacity: e, dataType: t, ...r }) {
     if (e === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
-    const i = new new w(t).Array(e), a = new B({ data: i.buffer, dataType: t, ...r });
+    const i = new new O(t).Array(e), a = new B({ data: i.buffer, dataType: t, ...r });
     return a.writePos = 0, a;
   }
   /**
@@ -2262,12 +2340,12 @@ let qe = class B {
     return this.dataType.isVariable ? this.writeVariable(e) : this.writeFixed(e);
   }
   writeVariable(e) {
-    if (this.writePos === $) return 0;
+    if (this.writePos === R) return 0;
     const t = this.byteCapacity.valueOf() - this.writePos, r = e.subBytes(0, t);
     return this.writeToUnderlyingData(r), this.writePos += r.byteLength.valueOf(), this.cachedLength != null && (this.cachedLength += r.length, this.calculateCachedLength()), r.length;
   }
   writeFixed(e) {
-    if (this.writePos === $) return 0;
+    if (this.writePos === R) return 0;
     const t = this.capacity - this.writePos, r = e.sub(0, t);
     return this.writeToUnderlyingData(r), this.cachedLength = void 0, this.maybeRecomputeMinMax(r), this.writePos += r.length, r.length;
   }
@@ -2290,7 +2368,7 @@ let qe = class B {
    * @returns A typed array containing the series data.
    */
   get data() {
-    return this.writePos === $ ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
+    return this.writePos === R ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
   }
   /**
    * Returns an array of the values in the series as strings.
@@ -2309,16 +2387,16 @@ let qe = class B {
    * @returns An array of values parsed from the JSON series.
    */
   parseJSON(e) {
-    if (!this.dataType.equals(w.JSON))
+    if (!this.dataType.equals(O.JSON))
       throw new Error("cannot parse non-JSON series as JSON");
-    return this.toStrings().map((t) => e.parse(oe.decodeString(t)));
+    return this.toStrings().map((t) => e.parse(le.decodeString(t)));
   }
   /**
    * Returns the capacity of the series in bytes.
    * @returns The size of the underlying buffer in bytes.
    */
   get byteCapacity() {
-    return new ue(this.underlyingData.byteLength);
+    return new he(this.underlyingData.byteLength);
   }
   /**
    * Returns the capacity of the series in samples.
@@ -2334,7 +2412,7 @@ let qe = class B {
    * @returns The size of the data in bytes.
    */
   get byteLength() {
-    return this.writePos === $ ? this.byteCapacity : this.dataType.isVariable ? new ue(this.writePos) : this.dataType.density.size(this.writePos);
+    return this.writePos === R ? this.byteCapacity : this.dataType.isVariable ? new he(this.writePos) : this.dataType.density.size(this.writePos);
   }
   /**
    * Returns the number of samples in this array.
@@ -2342,7 +2420,7 @@ let qe = class B {
    * @returns The number of samples in the series.
    */
   get length() {
-    return this.cachedLength != null ? this.cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === $ ? this.byteCapacity.valueOf() / this.dataType.density.valueOf() : this.writePos;
+    return this.cachedLength != null ? this.cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === R ? this.byteCapacity.valueOf() / this.dataType.density.valueOf() : this.writePos;
   }
   calculateCachedLength() {
     if (!this.dataType.isVariable)
@@ -2350,7 +2428,7 @@ let qe = class B {
     let e = 0;
     const t = [0];
     return this.data.forEach((r, i) => {
-      r === le && (e++, t.push(i + 1));
+      r === fe && (e++, t.push(i + 1));
     }), this._cachedIndexes = t, this.cachedLength = e, e;
   }
   /**
@@ -2366,7 +2444,7 @@ let qe = class B {
     if (this.dataType.equals(e)) return this;
     const r = new e.Array(this.length);
     for (let i = 0; i < this.length; i++)
-      r[i] = Ft(this.dataType, e, this.data[i], t);
+      r[i] = zt(this.dataType, e, this.data[i], t);
     return new B({
       data: r.buffer,
       dataType: e,
@@ -2378,7 +2456,7 @@ let qe = class B {
   }
   calcRawMax() {
     if (this.length === 0) return -1 / 0;
-    if (this.dataType.equals(w.TIMESTAMP))
+    if (this.dataType.equals(O.TIMESTAMP))
       this.cachedMax = this.data[this.data.length - 1];
     else if (this.dataType.usesBigInt) {
       const e = this.data;
@@ -2396,11 +2474,11 @@ let qe = class B {
   calcMax() {
     if (this.dataType.isVariable)
       throw new Error("cannot calculate maximum on a variable length data type");
-    return this.writePos === 0 ? -1 / 0 : (this.cachedMax ??= this.calcRawMax(), X(this.cachedMax, this.sampleOffset));
+    return this.writePos === 0 ? -1 / 0 : (this.cachedMax ??= this.calcRawMax(), Q(this.cachedMax, this.sampleOffset));
   }
   calcRawMin() {
     if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(w.TIMESTAMP)) this.cachedMin = this.data[0];
+    if (this.dataType.equals(O.TIMESTAMP)) this.cachedMin = this.data[0];
     else if (this.dataType.usesBigInt) {
       const e = this.data;
       this.cachedMin = e.reduce((t, r) => t < r ? t : r);
@@ -2417,11 +2495,11 @@ let qe = class B {
   calcMin() {
     if (this.dataType.isVariable)
       throw new Error("cannot calculate minimum on a variable length data type");
-    return this.writePos === 0 ? 1 / 0 : (this.cachedMin ??= this.calcRawMin(), X(this.cachedMin, this.sampleOffset));
+    return this.writePos === 0 ? 1 / 0 : (this.cachedMin ??= this.calcRawMin(), Q(this.cachedMin, this.sampleOffset));
   }
   /** @returns the bounds of the series. */
   get bounds() {
-    return D(Number(this.min), Number(this.max), { makeValid: !1 });
+    return P(Number(this.min), Number(this.max), { makeValid: !1 });
   }
   maybeRecomputeMinMax(e) {
     if (this.cachedMin != null) {
@@ -2443,18 +2521,18 @@ let qe = class B {
   }
   at(e, t = !1) {
     if (this.dataType.isVariable) return this.atVariable(e, t ?? !1);
-    if (this.dataType.equals(w.UUID)) return this.atUUID(e, t);
+    if (this.dataType.equals(O.UUID)) return this.atUUID(e, t);
     e < 0 && (e = this.length + e);
     const r = this.data[e];
     if (r == null) {
       if (t === !0) throw new Error(`[series] - no value at index ${e}`);
       return;
     }
-    return X(r, this.sampleOffset);
+    return Q(r, this.sampleOffset);
   }
   atUUID(e, t) {
     e < 0 && (e = this.length + e);
-    const r = je(
+    const r = We(
       new Uint8Array(this.buffer, e * this.dataType.density.valueOf())
     );
     if (r == null) {
@@ -2470,7 +2548,7 @@ let qe = class B {
     else {
       e < 0 && (e = this.length + e);
       for (let c = 0; c < this.data.length; c++)
-        if (this.data[c] === le) {
+        if (this.data[c] === fe) {
           if (e === 0) {
             i = c;
             break;
@@ -2483,7 +2561,7 @@ let qe = class B {
       }
     }
     const a = this.data.slice(r, i);
-    return this.dataType.equals(w.STRING) ? new TextDecoder().decode(a) : xe(JSON.parse(new TextDecoder().decode(a)));
+    return this.dataType.equals(O.STRING) ? new TextDecoder().decode(a) : $e(JSON.parse(new TextDecoder().decode(a)));
   }
   /**
    * @returns the index of the first sample that is greater than or equal to the given value.
@@ -2492,7 +2570,7 @@ let qe = class B {
    */
   binarySearch(e) {
     let t = 0, r = this.length - 1;
-    const i = it(e);
+    const i = ut(e);
     for (; t <= r; ) {
       const a = Math.floor((t + r) / 2), c = i(this.at(a, !0), e);
       if (c === 0) return a;
@@ -2508,11 +2586,11 @@ let qe = class B {
    * be the same buffer previously passed to {@method acquire} or {@method updateGLBuffer}.
    */
   updateGLBuffer(e) {
-    if (this.gl.control = e, !this.dataType.equals(w.FLOAT32) && !this.dataType.equals(w.UINT8))
+    if (this.gl.control = e, !this.dataType.equals(O.FLOAT32) && !this.dataType.equals(O.UINT8))
       throw new Error("Only FLOAT32 and UINT8 arrays can be used in WebGL");
     const { buffer: t, bufferUsage: r, prevBuffer: i } = this.gl;
     if (t == null && (this.gl.buffer = e.createBuffer()), this.writePos !== i)
-      if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== $) {
+      if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== R) {
         i === 0 && e.bufferData(e.ARRAY_BUFFER, this.byteCapacity.valueOf(), e.STATIC_DRAW);
         const a = this.dataType.density.size(i).valueOf(), c = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
         e.bufferSubData(e.ARRAY_BUFFER, a, c.buffer), this.gl.prevBuffer = this.writePos;
@@ -2521,10 +2599,10 @@ let qe = class B {
           e.ARRAY_BUFFER,
           this.buffer,
           r === "static" ? e.STATIC_DRAW : e.DYNAMIC_DRAW
-        ), this.gl.prevBuffer = $;
+        ), this.gl.prevBuffer = R;
   }
   as(e) {
-    return Jt(e, this.dataType), this;
+    return _t(e, this.dataType), this;
   }
   /** @returns a digest containing information about the series. */
   get digest() {
@@ -2533,8 +2611,8 @@ let qe = class B {
       dataType: this.dataType.toString(),
       sampleOffset: this.sampleOffset,
       alignment: {
-        lower: Se(this.alignmentBounds.lower),
-        upper: Se(this.alignmentBounds.upper),
+        lower: Ue(this.alignmentBounds.lower),
+        upper: Ue(this.alignmentBounds.upper),
         multiple: this.alignmentMultiple
       },
       timeRange: this.timeRange.toString(),
@@ -2552,7 +2630,7 @@ let qe = class B {
    * is exclusive.
    */
   get alignmentBounds() {
-    return D(
+    return P(
       this.alignment,
       this.alignment + BigInt(this.length) * this.alignmentMultiple
     );
@@ -2572,10 +2650,10 @@ let qe = class B {
   }
   [Symbol.iterator]() {
     if (this.dataType.isVariable) {
-      const e = new Qt(this);
-      return this.dataType.equals(w.JSON) ? new _t(e) : e;
+      const e = new nn(this);
+      return this.dataType.equals(O.JSON) ? new rn(e) : e;
     }
-    return this.dataType.equals(w.UUID) ? new en(this) : new tn(this);
+    return this.dataType.equals(O.UUID) ? new sn(this) : new an(this);
   }
   /**
    * Returns a slice of the series from start to end.
@@ -2602,7 +2680,7 @@ let qe = class B {
    * @returns An iterator over the specified range.
    */
   subIterator(e, t) {
-    return new Ne(this, e, t ?? this.length);
+    return new Ae(this, e, t ?? this.length);
   }
   /**
    * Returns an iterator over a portion of the series based on alignment.
@@ -2616,7 +2694,7 @@ let qe = class B {
     ), i = Math.ceil(
       Number(t - this.alignment) / Number(this.alignmentMultiple)
     );
-    return new Ne(this, r, i);
+    return new Ae(this, r, i);
   }
   subBytes(e, t) {
     if (e >= 0 && (t == null || t >= this.byteLength.valueOf())) return this;
@@ -2651,7 +2729,7 @@ let qe = class B {
     return new B({
       data: this.buffer,
       dataType: this.dataType,
-      timeRange: W.ZERO,
+      timeRange: x.ZERO,
       sampleOffset: this.sampleOffset,
       glBufferUsage: "static",
       alignment: e
@@ -2674,22 +2752,22 @@ let qe = class B {
     }
     return e += "])", e;
   }
-};
-const Xt = (n) => n == null ? !1 : Array.isArray(n) || n instanceof ArrayBuffer || ArrayBuffer.isView(n) && !(n instanceof DataView) || n instanceof qe ? !0 : Pe(n), Kt = jt(Ye, qe);
-let Ne = class {
+}
+const en = (n) => n == null ? !1 : Array.isArray(n) || n instanceof ArrayBuffer || ArrayBuffer.isView(n) && !(n instanceof DataView) || n instanceof B ? !0 : Fe(n), tn = Ft(Ze, B);
+class Ae {
   series;
   end;
   index;
   constructor(e, t, r) {
     this.series = e;
-    const i = D(0, e.length + 1);
-    this.end = Oe(i, r), this.index = Oe(i, t);
+    const i = P(0, e.length + 1);
+    this.end = Se(i, r), this.index = Se(i, t);
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
   }
-};
-class Qt {
+}
+class nn {
   series;
   index;
   decoder;
@@ -2702,12 +2780,12 @@ class Qt {
   }
   next() {
     const e = this.index, t = this.series.data;
-    for (; this.index < t.length && t[this.index] !== le; ) this.index++;
+    for (; this.index < t.length && t[this.index] !== fe; ) this.index++;
     const r = this.index;
     return e === r ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(e, r)) });
   }
 }
-let _t = class Fe {
+let rn = class Ge {
   wrapped;
   static schema = s.record(s.string(), s.unknown());
   constructor(e) {
@@ -2717,26 +2795,27 @@ let _t = class Fe {
     const e = this.wrapped.next();
     return e.done === !0 ? { done: !0, value: void 0 } : {
       done: !1,
-      value: oe.decodeString(e.value, Fe.schema)
+      value: le.decodeString(e.value, Ge.schema)
     };
   }
-}, en = class {
+};
+class sn {
   series;
   index;
   data;
   density;
   constructor(e) {
-    if (!e.dataType.equals(w.UUID))
+    if (!e.dataType.equals(O.UUID))
       throw new Error("cannot create a UUID series iterator for a non-UUID series");
-    this.series = e, this.index = 0, this.data = new Uint8Array(e.buffer), this.density = w.UUID.density.valueOf();
+    this.series = e, this.index = 0, this.data = new Uint8Array(e.buffer), this.density = O.UUID.density.valueOf();
   }
   next() {
     if (this.index >= this.series.length) return { done: !0, value: void 0 };
-    const e = je(this.data, this.index * this.density);
+    const e = We(this.data, this.index * this.density);
     return this.index++, { done: !1, value: e };
   }
-};
-class tn {
+}
+let an = class {
   series;
   index;
   constructor(e) {
@@ -2748,8 +2827,8 @@ class tn {
       value: this.series.at(this.index++, !0)
     };
   }
-}
-const Se = (n) => {
+};
+const Ue = (n) => {
   const e = n >> 32n, t = n & 0xffffffffn;
   return { domain: e, sample: t };
 };
@@ -2758,18 +2837,18 @@ s.record(
   s.union([s.number(), s.string(), s.symbol()]),
   s.unknown()
 );
-const nn = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser";
-nn();
-const rn = ["macOS", "Windows", "Linux"], sn = ["macos", "windows", "linux"], an = {
+const on = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser";
+on();
+const un = ["macOS", "Windows", "Linux"], ln = ["macos", "windows", "linux"], cn = {
   macos: "macOS",
   windows: "Windows",
   linux: "Linux"
 };
-s.enum(rn).or(
-  s.enum(sn).transform((n) => an[n])
+s.enum(un).or(
+  s.enum(ln).transform((n) => cn[n])
 );
-const on = (...n) => n.map(We).join(""), We = (n) => (n.endsWith("/") || (n += "/"), n.startsWith("/") && (n = n.slice(1)), n), un = (n) => n.endsWith("/") ? n.slice(0, -1) : n, ln = (n, e = "") => n === null ? "" : `?${Object.entries(n).filter(([, t]) => t == null ? !1 : Array.isArray(t) ? t.length > 0 : !0).map(([t, r]) => `${e}${t}=${r}`).join("&")}`;
-class V {
+const hn = (...n) => n.map(ze).join(""), ze = (n) => (n.endsWith("/") || (n += "/"), n.startsWith("/") && (n = n.slice(1)), n), fn = (n) => n.endsWith("/") ? n.slice(0, -1) : n, dn = (n, e = "") => n === null ? "" : `?${Object.entries(n).filter(([, t]) => t == null ? !1 : Array.isArray(t) ? t.length > 0 : !0).map(([t, r]) => `${e}${t}=${r}`).join("&")}`;
+class z {
   protocol;
   host;
   port;
@@ -2781,7 +2860,7 @@ class V {
    * @param pathPrefix - A path prefix to use for all requests. Defaults to "".
    */
   constructor({ host: e, port: t, protocol: r = "", pathPrefix: i = "" }) {
-    this.protocol = r, this.host = e, this.port = t, this.path = We(i);
+    this.protocol = r, this.host = e, this.port = t, this.path = ze(i);
   }
   /**
    * Replaces creates a new URL with the specified properties replaced.
@@ -2789,7 +2868,7 @@ class V {
    * @returns a new URL.
    */
   replace(e) {
-    return new V({
+    return new z({
       host: e.host ?? this.host,
       port: e.port ?? this.port,
       protocol: e.protocol ?? this.protocol,
@@ -2802,33 +2881,33 @@ class V {
    * @returns a new URL.
    */
   child(e) {
-    return new V({
+    return new z({
       ...this,
-      pathPrefix: on(this.path, e)
+      pathPrefix: hn(this.path, e)
     });
   }
   /** @returns a string representation of the url */
   toString() {
-    return un(
+    return fn(
       `${this.protocol}://${this.host}:${this.port}/${this.path}`
     );
   }
-  static UNKNOWN = new V({ host: "unknown", port: 0 });
+  static UNKNOWN = new z({ host: "unknown", port: 0 });
 }
-const cn = async (n) => await new Promise(
-  (e) => setTimeout(e, p.fromMilliseconds(n).milliseconds)
+const gn = async (n) => await new Promise(
+  (e) => setTimeout(e, l.fromMilliseconds(n).milliseconds)
 );
-class hn {
+class pn {
   config;
   retries;
   interval;
   constructor(e) {
     this.config = {
-      baseInterval: new p(e?.baseInterval ?? p.seconds(1)),
+      baseInterval: new l(e?.baseInterval ?? l.seconds(1)),
       maxRetries: e?.maxRetries ?? 5,
       scale: e?.scale ?? 1,
-      sleepFn: e?.sleepFn ?? cn
-    }, this.retries = 0, this.interval = new p(this.config.baseInterval);
+      sleepFn: e?.sleepFn ?? gn
+    }, this.retries = 0, this.interval = new l(this.config.baseInterval);
   }
   async wait() {
     const { maxRetries: e, scale: t, sleepFn: r } = this.config;
@@ -2841,159 +2920,165 @@ class hn {
     this.retries = 0, this.interval = this.config.baseInterval;
   }
 }
-const fn = s.object({
-  baseInterval: p.z.optional(),
+const mn = s.object({
+  baseInterval: l.z.optional(),
   maxRetries: s.number().optional(),
   scale: s.number().optional()
-}), dn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), yn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  Breaker: hn,
-  breakerConfigZ: fn
-}, Symbol.toStringTag, { value: "Module" })), gn = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i, Ze = s.string().regex(gn), P = s.number().min(0).max(255), Ve = s.number().min(0).max(1), ze = s.tuple([P, P, P, Ve]), pn = s.tuple([P, P, P]), mn = s.object({ rgba255: ze }), yn = s.number().min(0).max(360), wn = s.number().min(0).max(100), bn = s.number().min(0).max(100), On = s.tuple([yn, wn, bn, Ve]), ge = s.union([Ze, pn, ze, On, mn]), Tn = ge.transform((n) => pe(n)), pe = (n, e = 1) => {
-  if (n = ge.parse(n), typeof n == "string") return vn(n, e);
+  Breaker: pn,
+  breakerConfigZ: mn
+}, Symbol.toStringTag, { value: "Module" })), wn = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i, Ve = s.string().regex(wn), Y = s.number().min(0).max(255), He = s.number().min(0).max(1), Je = s.tuple([Y, Y, Y, He]), bn = s.tuple([Y, Y, Y]), On = s.object({ rgba255: Je }), Tn = s.number().min(0).max(360), vn = s.number().min(0).max(100), Sn = s.number().min(0).max(100), In = s.tuple([Tn, vn, Sn, He]), ye = s.union([Ve, bn, Je, In, On]), Nn = ye.transform((n) => we(n)), we = (n, e = 1) => {
+  if (n = ye.parse(n), typeof n == "string") return En(n, e);
   if (Array.isArray(n)) {
     if (n.length < 3 || n.length > 4)
       throw new Error(`Invalid color: [${n.join(", ")}]`);
     return n.length === 3 ? [...n, e] : n;
   }
   return n.rgba255;
-}, vn = (n, e = 1) => (n = Ze.parse(n), n = In(n), [
-  J(n, 0),
-  J(n, 2),
-  J(n, 4),
-  n.length === 8 ? J(n, 6) / 255 : e
-]), J = (n, e) => parseInt(n.slice(e, e + 2), 16), In = (n) => n.startsWith("#") ? n.slice(1) : n;
-pe("#000000");
-pe("#ffffff");
-const Nn = s.object({
+}, En = (n, e = 1) => (n = Ve.parse(n), n = xn(n), [
+  X(n, 0),
+  X(n, 2),
+  X(n, 4),
+  n.length === 8 ? X(n, 6) / 255 : e
+]), X = (n, e) => parseInt(n.slice(e, e + 2), 16), xn = (n) => n.startsWith("#") ? n.slice(1) : n;
+we("#000000");
+we("#ffffff");
+const An = s.object({
   key: s.string(),
-  color: ge,
+  color: ye,
   position: s.number(),
   switched: s.boolean().optional()
 });
-s.array(Nn);
-const Sn = s.object({
+s.array(An);
+const Un = s.object({
   key: s.string(),
   name: s.string(),
-  color: Tn
+  color: Nn
 });
 s.object({
   key: s.string(),
   name: s.string(),
-  swatches: s.array(Sn)
+  swatches: s.array(Un)
 });
 s.int().min(0).max(255);
 s.object({
   name: s.string(),
   key: s.string()
 });
-const En = (n) => Object.getOwnPropertySymbols(globalThis).includes(n), xn = (n, e) => {
+const Mn = (n) => Object.getOwnPropertySymbols(globalThis).includes(n), $n = (n, e) => {
   const t = Symbol.for(n);
-  if (!En(t)) {
+  if (!Mn(t)) {
     const r = e();
     Object.defineProperty(globalThis, t, { value: r });
   }
   return () => globalThis[t];
-}, Ge = "sy_x_error", An = (n) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.startsWith(n) : e instanceof Error ? e.message.startsWith(n) : typeof e != "string" ? !1 : e.startsWith(n), z = (n) => class Z extends Error {
-  static discriminator = Ge;
-  discriminator = Z.discriminator;
+}, Ke = "sy_x_error", Cn = (n) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.startsWith(n) : e instanceof Error ? e.message.startsWith(n) : typeof e != "string" ? !1 : e.startsWith(n), V = (n) => class G extends Error {
+  static discriminator = Ke;
+  discriminator = G.discriminator;
   static TYPE = n;
-  type = Z.TYPE;
-  static matches = An(n);
-  matches = Z.matches;
+  type = G.TYPE;
+  static matches = Cn(n);
+  matches = G.matches;
   constructor(t, r) {
-    super(t, r), this.name = Z.TYPE;
+    super(t, r), this.name = G.TYPE;
   }
   static sub(t) {
-    return z(`${n}.${t}`);
+    return V(`${n}.${t}`);
   }
-}, He = (n) => {
+}, Xe = (n) => {
   if (n == null || typeof n != "object") return !1;
   const e = n;
-  if (e.discriminator !== Ge) return !1;
+  if (e.discriminator !== Ke) return !1;
   if (!("type" in e))
     throw new Error(
       `X Error is missing its type property: ${JSON.stringify(e)}`
     );
   return !0;
-}, k = "unknown", ce = "nil";
-class Un {
+}, j = "unknown", de = "nil";
+class Bn {
   providers = [];
   register(e) {
     this.providers.push(e);
   }
   encode(e) {
-    if (e == null) return { type: ce, data: "" };
-    if (He(e))
+    if (e == null) return { type: de, data: "" };
+    if (Xe(e))
       for (const t of this.providers) {
         const r = t.encode(e);
         if (r != null) return r;
       }
-    if (e instanceof Error) return { type: k, data: e.message };
-    if (typeof e == "string") return { type: k, data: e };
+    if (e instanceof Error) return { type: j, data: e.message };
+    if (typeof e == "string") return { type: j, data: e };
     try {
-      return { type: k, data: JSON.stringify(e) };
+      return { type: j, data: JSON.stringify(e) };
     } catch {
-      return { type: k, data: "unable to encode error information" };
+      return { type: j, data: "unable to encode error information" };
     }
   }
   decode(e) {
-    if (e == null || e.type === ce) return null;
-    if (e.type === k) return new he(e.data);
+    if (e == null || e.type === de) return null;
+    if (e.type === j) return new ge(e.data);
     for (const t of this.providers) {
       const r = t.decode(e);
       if (r != null) return r;
     }
-    return new he(e.data);
+    return new ge(e.data);
   }
 }
-const me = xn("synnax-error-registry", () => new Un()), Mn = ({ encode: n, decode: e }) => me().register({ encode: n, decode: e }), Cn = (n) => me().encode(n), $n = (n) => n == null ? null : me().decode(n);
-class he extends z("unknown") {
+const be = $n("synnax-error-registry", () => new Bn()), Rn = ({ encode: n, decode: e }) => be().register({ encode: n, decode: e }), Dn = (n) => be().encode(n), Ln = (n) => n == null ? null : be().decode(n);
+class ge extends V("unknown") {
 }
-const Bn = s.object({ type: s.string(), data: s.string() });
-class Rn extends z("canceled") {
+const Pn = s.object({ type: s.string(), data: s.string() });
+class kn extends V("canceled") {
 }
-class Dn extends z("not_implemented") {
+class jn extends V("not_implemented") {
 }
-const R = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  Canceled: Rn,
-  NONE: ce,
-  NotImplemented: Dn,
-  UNKNOWN: k,
-  Unknown: he,
-  createTyped: z,
-  decode: $n,
-  encode: Cn,
-  isTyped: He,
-  payloadZ: Bn,
-  register: Mn
-}, Symbol.toStringTag, { value: "Module" })), Ln = O.object({
-  jsonrpc: O.literal("2.0"),
-  method: O.string(),
+  Canceled: kn,
+  NONE: de,
+  NotImplemented: jn,
+  UNKNOWN: j,
+  Unknown: ge,
+  createTyped: V,
+  decode: Ln,
+  encode: Dn,
+  isTyped: Xe,
+  payloadZ: Pn,
+  register: Rn
+}, Symbol.toStringTag, { value: "Module" })), Yn = b.object({
+  jsonrpc: b.literal("2.0"),
+  method: b.string(),
   // params should be z.union([z.record(z.string(), z.json()),
   // z.array(z.json())]).optional() but the VSCode JSON RPC implementation uses a looser
   // definition of params then in the JSON-RPC spec.
-  params: O.any().optional(),
-  id: O.union([O.string(), O.number(), O.null()]).optional()
-}), Je = O.object({
-  jsonrpc: O.literal("2.0"),
-  id: O.union([O.string(), O.number(), O.null()])
-}), kn = Je.extend({
-  result: O.json()
-}), Pn = Je.extend({
-  error: O.object({
-    code: O.number().int(),
+  params: b.any().optional(),
+  id: b.union([b.string(), b.number(), b.null()]).optional()
+}), Qe = b.object({
+  jsonrpc: b.literal("2.0"),
+  id: b.union([b.string(), b.number(), b.null()])
+}), qn = Qe.extend({
+  result: b.json()
+}), Fn = Qe.extend({
+  error: b.object({
+    code: b.number().int(),
     // This should be z.string(), but the VSCode JSON RPC implementation uses a looser
     // definition of error than the JSON-RPC spec.
-    message: O.string().optional(),
-    data: O.json().optional()
+    message: b.string().optional(),
+    data: b.json().optional()
   })
-}), jn = O.union([kn, Pn]);
-O.union([Ln, jn]);
+}), Wn = b.union([qn, Fn]);
+b.union([Yn, Wn]);
+const Zn = b.uuid();
+b.object({
+  key: Zn,
+  name: b.string().min(1),
+  color: b.string()
+});
 s.string().regex(/^\d+\.\d+\.\d+$/);
-const Yn = ["standard", "scientific", "engineering"];
-s.enum(Yn);
+const Gn = ["standard", "scientific", "engineering"];
+s.enum(Gn);
 s.enum([
   "success",
   "info",
@@ -3002,51 +3087,55 @@ s.enum([
   "loading",
   "disabled"
 ]);
-class G extends R.createTyped("freighter") {
+s.object({
+  stack: s.string(),
+  error: s.instanceof(Error)
+});
+class H extends D.createTyped("freighter") {
 }
-class j extends G.sub("eof") {
+class q extends H.sub("eof") {
   constructor() {
     super("EOF");
   }
 }
-class Y extends G.sub("stream_closed") {
+class F extends H.sub("stream_closed") {
   constructor() {
     super("StreamClosed");
   }
 }
-class q extends G.sub("unreachable") {
+class W extends H.sub("unreachable") {
   url;
   constructor(e = {}) {
-    const { message: t = "Unreachable", url: r = V.UNKNOWN } = e;
+    const { message: t = "Unreachable", url: r = z.UNKNOWN } = e;
     super(t), this.url = r;
   }
 }
-const qn = (n) => {
-  if (!n.type.startsWith(G.TYPE)) return null;
-  if (j.matches(n)) return { type: j.TYPE, data: "EOF" };
-  if (Y.matches(n))
-    return { type: Y.TYPE, data: "StreamClosed" };
-  if (q.matches(n))
-    return { type: q.TYPE, data: "Unreachable" };
+const zn = (n) => {
+  if (!n.type.startsWith(H.TYPE)) return null;
+  if (q.matches(n)) return { type: q.TYPE, data: "EOF" };
+  if (F.matches(n))
+    return { type: F.TYPE, data: "StreamClosed" };
+  if (W.matches(n))
+    return { type: W.TYPE, data: "Unreachable" };
   throw new Error(`Unknown error type: ${n.type}: ${n.message}`);
-}, Fn = (n) => {
-  if (!n.type.startsWith(G.TYPE)) return null;
+}, Vn = (n) => {
+  if (!n.type.startsWith(H.TYPE)) return null;
   switch (n.type) {
-    case j.TYPE:
-      return new j();
-    case Y.TYPE:
-      return new Y();
     case q.TYPE:
       return new q();
+    case F.TYPE:
+      return new F();
+    case W.TYPE:
+      return new W();
     default:
-      throw new R.Unknown(`Unknown error type: ${n.data}`);
+      throw new D.Unknown(`Unknown error type: ${n.data}`);
   }
 };
-R.register({
-  encode: qn,
-  decode: Fn
+D.register({
+  encode: zn,
+  decode: Vn
 });
-class Xe {
+class _e {
   middleware = [];
   /** Implements the Transport interface */
   use(...e) {
@@ -3071,24 +3160,24 @@ class Xe {
     return await i(e);
   }
 }
-const Ke = "Content-Type", Wn = /* @__PURE__ */ new Set([
+const et = "Content-Type", Hn = /* @__PURE__ */ new Set([
   "ECONNREFUSED",
   "ECONNRESET",
   "ETIMEDOUT",
   "EPIPE",
   "UND_ERR_CONNECT_TIMEOUT",
   "UND_ERR_SOCKET"
-]), Zn = (n) => {
+]), Jn = (n) => {
   const e = n?.cause?.code ?? n?.code ?? n?.errno;
-  if (typeof e == "string" && Wn.has(e)) return !0;
+  if (typeof e == "string" && Hn.has(e)) return !0;
   if (n.name === "TypeError") {
     const t = String(n.message || "").toLowerCase();
     if (/load failed|failed to fetch|networkerror|network error/.test(t))
       return typeof navigator < "u" && navigator.onLine === !1, !0;
   }
   return n?.name === "AbortError" || n?.code === "ABORT_ERR", !1;
-}, Vn = 400;
-class nr extends Xe {
+}, Kn = 400;
+class ar extends _e {
   endpoint;
   encoder;
   constructor(e, t, r = !1) {
@@ -3098,14 +3187,14 @@ class nr extends Xe {
   }
   get headers() {
     return {
-      [Ke]: this.encoder.contentType
+      [et]: this.encoder.contentType
     };
   }
   async send(e, t, r, i) {
     t = r?.parse(t);
     let a = null;
-    const c = this.endpoint.child(e), g = {};
-    g.method = "POST", g.body = this.encoder.encode(t ?? {});
+    const c = this.endpoint.child(e), d = {};
+    d.method = "POST", d.body = this.encoder.encode(t ?? {});
     const [, y] = await this.executeMiddleware(
       {
         target: c.toString(),
@@ -3114,31 +3203,31 @@ class nr extends Xe {
         role: "client"
       },
       async (f) => {
-        const m = { ...f, params: {} };
-        g.headers = {
+        const g = { ...f, params: {} };
+        d.headers = {
           ...this.headers,
           ...f.params
         };
-        let b;
+        let w;
         try {
-          b = await fetch(f.target, g);
+          w = await fetch(f.target, d);
         } catch (T) {
           if (!(T instanceof Error)) throw T;
-          return [m, Zn(T) ? new q({ url: c }) : T];
+          return [g, Jn(T) ? new W({ url: c }) : T];
         }
-        const h = await b.arrayBuffer();
-        if (b?.ok)
-          return i != null && (a = this.encoder.decode(h, i)), [m, null];
+        const h = await w.arrayBuffer();
+        if (w?.ok)
+          return i != null && (a = this.encoder.decode(h, i)), [g, null];
         try {
-          if (b.status !== Vn)
-            return [m, new Error(b.statusText)];
-          const T = this.encoder.decode(h, R.payloadZ), A = R.decode(T);
-          return [m, A];
+          if (w.status !== Kn)
+            return [g, new Error(w.statusText)];
+          const T = this.encoder.decode(h, D.payloadZ), A = D.decode(T);
+          return [g, A];
         } catch (T) {
           return [
-            m,
+            g,
             new Error(
-              `[freighter] - failed to decode error: ${b.statusText}: ${T.message}`
+              `[freighter] - failed to decode error: ${w.statusText}: ${T.message}`
             )
           ];
         }
@@ -3149,7 +3238,7 @@ class nr extends Xe {
     return [a, null];
   }
 }
-const rr = (n, e) => {
+const or = (n, e) => {
   class t {
     wrapped;
     constructor(i) {
@@ -3158,27 +3247,27 @@ const rr = (n, e) => {
     use(...i) {
       this.wrapped.use(...i);
     }
-    async send(i, a, c, g) {
-      const y = new dn.Breaker(e);
+    async send(i, a, c, d) {
+      const y = new yn.Breaker(e);
       do {
-        const [f, m] = await this.wrapped.send(i, a, c, g);
-        if (m == null) return [f, null];
-        if (!q.matches(m)) return [null, m];
-        if (console.warn(`[freighter] ${y.retryMessage}`, m), !await y.wait()) return [f, m];
+        const [f, g] = await this.wrapped.send(i, a, c, d);
+        if (g == null) return [f, null];
+        if (!W.matches(g)) return [null, g];
+        if (console.warn(`[freighter] ${y.retryMessage}`, g), !await y.wait()) return [f, g];
       } while (!0);
     }
   }
   return new t(n);
-}, sr = async (n, e, t, r, i) => {
+}, ur = async (n, e, t, r, i) => {
   const [a, c] = await n.send(e, t, r, i);
   if (c != null) throw c;
   return a;
-}, zn = s.object({
+}, Xn = s.object({
   type: s.enum(["data", "close", "open"]),
   payload: s.unknown(),
-  error: s.optional(R.payloadZ)
+  error: s.optional(D.payloadZ)
 });
-class Gn {
+class Qn {
   codec;
   reqSchema;
   resSchema;
@@ -3194,14 +3283,14 @@ class Gn {
     const e = await this.receiveMsg();
     if (e.type !== "open") {
       if (e.error == null) throw new Error("Message error must be defined");
-      return R.decode(e.error);
+      return D.decode(e.error);
     }
     return null;
   }
   /** Implements the Stream protocol */
   send(e) {
-    if (this.serverClosed != null) return new j();
-    if (this.sendClosed) throw new Y();
+    if (this.serverClosed != null) return new q();
+    if (this.sendClosed) throw new F();
     return this.ws.send(this.codec.encode({ type: "data", payload: e })), null;
   }
   /** Implements the Stream protocol */
@@ -3210,7 +3299,7 @@ class Gn {
     const e = await this.receiveMsg();
     if (e.type === "close") {
       if (e.error == null) throw new Error("Message error must be defined");
-      if (this.serverClosed = R.decode(e.error), this.serverClosed == null) throw new Error("Message error must be defined");
+      if (this.serverClosed = D.decode(e.error), this.serverClosed == null) throw new Error("Message error must be defined");
       return [null, this.serverClosed];
     }
     return [this.resSchema.parse(e.payload), null];
@@ -3243,20 +3332,20 @@ class Gn {
     this.ws.onmessage = this.onMessage.bind(this), this.ws.onclose = this.onClose.bind(this);
   }
   onMessage(e) {
-    this.addMessage(this.codec.decode(e.data, zn));
+    this.addMessage(this.codec.decode(e.data, Xn));
   }
   onClose(e) {
     this.addMessage({
       type: "close",
       error: {
-        type: e.code === Jn ? j.TYPE : Y.TYPE,
+        type: e.code === er ? q.TYPE : F.TYPE,
         data: ""
       }
     });
   }
 }
-const Hn = "freighterctx", Jn = 1e3;
-class fe extends Xe {
+const _n = "freighterctx", er = 1e3;
+class pe extends _e {
   baseUrl;
   encoder;
   secure;
@@ -3270,7 +3359,7 @@ class fe extends Xe {
     super(), this.secure = r, this.baseUrl = e.replace({ protocol: r ? "wss" : "ws" }), this.encoder = t;
   }
   withCodec(e) {
-    const t = new fe(this.baseUrl, e, this.secure);
+    const t = new pe(this.baseUrl, e, this.secure);
     return t.use(...this.middleware), t;
   }
   /** Implements the StreamClient interface. */
@@ -3279,9 +3368,9 @@ class fe extends Xe {
     const [, a] = await this.executeMiddleware(
       { target: e, protocol: "websocket", params: {}, role: "client" },
       async (c) => {
-        const g = new WebSocket(this.buildURL(e, c)), y = { ...c, params: {} };
-        g.binaryType = fe.MESSAGE_TYPE;
-        const f = await this.wrapSocket(g, t, r);
+        const d = new WebSocket(this.buildURL(e, c)), y = { ...c, params: {} };
+        d.binaryType = pe.MESSAGE_TYPE;
+        const f = await this.wrapSocket(d, t, r);
         return f instanceof Error ? [y, f] : (i = f, [y, null]);
       }
     );
@@ -3289,19 +3378,19 @@ class fe extends Xe {
     return i;
   }
   buildURL(e, t) {
-    const r = ln(
+    const r = dn(
       {
-        [Ke]: this.encoder.contentType,
+        [et]: this.encoder.contentType,
         ...t.params
       },
-      Hn
+      _n
     );
     return this.baseUrl.child(e).toString() + r;
   }
   async wrapSocket(e, t, r) {
     return await new Promise((i) => {
       e.onopen = () => {
-        const a = new Gn(e, this.encoder, t, r);
+        const a = new Qn(e, this.encoder, t, r);
         a.receiveOpenAck().then((c) => {
           c != null ? i(c) : i(a);
         }).catch((c) => i(c));
@@ -3313,11 +3402,11 @@ class fe extends Xe {
   }
 }
 export {
-  j as EOF,
-  nr as HTTPClient,
-  Y as StreamClosed,
-  q as Unreachable,
-  fe as WebSocketClient,
-  sr as sendRequired,
-  rr as unaryWithBreaker
+  q as EOF,
+  ar as HTTPClient,
+  F as StreamClosed,
+  W as Unreachable,
+  pe as WebSocketClient,
+  ur as sendRequired,
+  or as unaryWithBreaker
 };