@synnaxlabs/freighter 0.30.0 → 0.32.0

package/dist/freighter.js

@@ -1,36 +1,36 @@
-var Ze = Object.defineProperty;
-var ze = (r, e, t) => e in r ? Ze(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var f = (r, e, t) => ze(r, typeof e != "symbol" ? e + "" : e, t);
-import { z as s } from "zod";
-const Ve = (r) => {
+var it = Object.defineProperty;
+var at = (r, e, t) => e in r ? it(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var p = (r, e, t) => at(r, typeof e != "symbol" ? e + "" : e, t);
+import { z as i } from "zod";
+const ot = (r) => {
   const e = r.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
   return e.length > 1 && e[0] === e[0].toUpperCase() && e[1] === e[1].toUpperCase() ? e : e[0].toLowerCase() + e.slice(1);
-}, Ee = (r) => {
-  const e = (t, n = oe) => {
+}, Le = (r) => {
+  const e = (t, n = de) => {
     if (typeof t == "string") return r(t);
     if (Array.isArray(t)) return t.map((c) => e(c, n));
-    if (!te(t)) return t;
-    n = Je(n);
-    const i = {}, a = t;
+    if (!ue(t)) return t;
+    n = lt(n);
+    const s = {}, a = t;
     return Object.keys(a).forEach((c) => {
-      let h = a[c];
-      const g = r(c);
-      n.recursive && (te(h) ? pe(h, n.keepTypesOnRecursion) || (h = e(h, n)) : n.recursiveInArray && fe(h) && (h = [...h].map((m) => {
-        let O = m;
-        return te(m) ? pe(O, n.keepTypesOnRecursion) || (O = e(m, n)) : fe(m) && (O = e({ key: m }, n).key), O;
-      }))), i[g] = h;
-    }), i;
+      let d = a[c];
+      const f = r(c);
+      n.recursive && (ue(d) ? Oe(d, n.keepTypesOnRecursion) || (d = e(d, n)) : n.recursiveInArray && Te(d) && (d = [...d].map((y) => {
+        let T = y;
+        return ue(y) ? Oe(T, n.keepTypesOnRecursion) || (T = e(y, n)) : Te(y) && (T = e({ key: y }, n).key), T;
+      }))), s[f] = d;
+    }), s;
   };
   return e;
-}, He = Ee(Ve), Ke = (r) => r.replace(/([a-z0-9])([A-Z])/g, (e, t, n) => `${t}_${n.toLowerCase()}`), Xe = Ee(Ke), oe = {
+}, Ye = Le(ot), ut = (r) => r.replace(/([a-z0-9])([A-Z])/g, (e, t, n) => `${t}_${n.toLowerCase()}`), ct = Le(ut), de = {
   recursive: !0,
   recursiveInArray: !0,
   keepTypesOnRecursion: [Number, String, Uint8Array]
-}, Je = (r = oe) => (r.recursive == null ? r = oe : r.recursiveInArray == null && (r.recursiveInArray = !1), r), fe = (r) => r != null && Array.isArray(r), te = (r) => r != null && typeof r == "object" && !Array.isArray(r), pe = (r, e) => (e || []).some((t) => r instanceof t), Ae = (r) => r != null && typeof r == "object" && !Array.isArray(r);
-var Qe = Object.defineProperty, _e = (r, e, t) => e in r ? Qe(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, q = (r, e, t) => _e(r, typeof e != "symbol" ? e + "" : e, t);
-let et = class {
+}, lt = (r = de) => (r.recursive == null ? r = de : r.recursiveInArray == null && (r.recursiveInArray = !1), r), Te = (r) => r != null && Array.isArray(r), ue = (r) => r != null && typeof r == "object" && !Array.isArray(r), Oe = (r, e) => (e || []).some((t) => r instanceof t), ke = (r) => r != null && typeof r == "object" && !Array.isArray(r);
+var ht = Object.defineProperty, dt = (r, e, t) => e in r ? ht(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, H = (r, e, t) => dt(r, typeof e != "symbol" ? e + "" : e, t);
+let ft = class {
   constructor() {
-    q(this, "contentType", "application/json"), q(this, "decoder"), q(this, "encoder"), this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
+    H(this, "contentType", "application/json"), H(this, "decoder"), H(this, "encoder"), this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
   }
   encode(e) {
     return this.encoder.encode(this.encodeString(e)).buffer;
@@ -39,18 +39,18 @@ let et = class {
     return this.decodeString(this.decoder.decode(e), t);
   }
   decodeString(e, t) {
-    const n = JSON.parse(e), i = He(n);
-    return t != null ? t.parse(i) : i;
+    const n = JSON.parse(e), s = Ye(n);
+    return t != null ? t.parse(s) : s;
   }
   encodeString(e) {
-    const t = Xe(e);
-    return JSON.stringify(t, (n, i) => ArrayBuffer.isView(i) ? Array.from(i) : Ae(i) && "encode_value" in i ? typeof i.value == "bigint" ? i.value.toString() : i.value : typeof i == "bigint" ? i.toString() : i);
+    const t = ct(e);
+    return JSON.stringify(t, (n, s) => ArrayBuffer.isView(s) ? Array.from(s) : ke(s) && "encode_value" in s ? typeof s.value == "bigint" ? s.value.toString() : s.value : typeof s == "bigint" ? s.toString() : s);
   }
   static registerCustomType() {
   }
-}, tt = class {
+}, gt = class {
   constructor() {
-    q(this, "contentType", "text/csv");
+    H(this, "contentType", "text/csv");
   }
   encode(e) {
     const t = this.encodeString(e);
@@ -61,28 +61,28 @@ let et = class {
     return this.decodeString(n, t);
   }
   encodeString(e) {
-    if (!Array.isArray(e) || e.length === 0 || !Ae(e[0]))
+    if (!Array.isArray(e) || e.length === 0 || !ke(e[0]))
       throw new Error("Payload must be an array of objects");
     const t = Object.keys(e[0]), n = [t.join(",")];
-    return e.forEach((i) => {
-      const a = t.map((c) => JSON.stringify(i[c] ?? ""));
+    return e.forEach((s) => {
+      const a = t.map((c) => JSON.stringify(s[c] ?? ""));
       n.push(a.join(","));
     }), n.join(`
 `);
   }
   decodeString(e, t) {
-    const [n, ...i] = e.trim().split(`
-`).map((h) => h.trim());
+    const [n, ...s] = e.trim().split(`
+`).map((d) => d.trim());
     if (n.length === 0)
       return t != null ? t.parse({}) : {};
-    const a = n.split(",").map((h) => h.trim()), c = {};
-    return a.forEach((h) => {
-      c[h] = [];
-    }), i.forEach((h) => {
-      const g = h.split(",").map((m) => m.trim());
-      a.forEach((m, O) => {
-        const w = this.parseValue(g[O]);
-        w != null && c[m].push(w);
+    const a = n.split(",").map((d) => d.trim()), c = {};
+    return a.forEach((d) => {
+      c[d] = [];
+    }), s.forEach((d) => {
+      const f = d.split(",").map((y) => y.trim());
+      a.forEach((y, T) => {
+        const l = this.parseValue(f[T]);
+        l != null && c[y].push(l);
       });
     }), t != null ? t.parse(c) : c;
   }
@@ -93,9 +93,9 @@ let et = class {
   }
   static registerCustomType() {
   }
-}, rt = class {
+}, pt = class {
   constructor() {
-    q(this, "contentType", "text/plain");
+    H(this, "contentType", "text/plain");
   }
   encode(e) {
     return new TextEncoder().encode(e).buffer;
@@ -105,125 +105,125 @@ let et = class {
     return t != null ? t.parse(n) : n;
   }
 };
-new et();
-new tt();
-new rt();
-const Q = s.tuple([s.number(), s.number()]);
-s.tuple([s.bigint(), s.bigint()]);
-const $e = s.object({ width: s.number(), height: s.number() }), nt = s.object({
-  signedWidth: s.number(),
-  signedHeight: s.number()
-}), st = ["width", "height"];
-s.enum(st);
-const it = ["start", "center", "end"], ot = ["signedWidth", "signedHeight"];
-s.enum(ot);
-const X = s.object({ x: s.number(), y: s.number() }), at = s.object({ clientX: s.number(), clientY: s.number() }), ut = ["x", "y"], xe = s.enum(ut), Ue = ["top", "right", "bottom", "left"];
-s.enum(Ue);
-const ct = ["left", "right"], Me = s.enum(ct), lt = ["top", "bottom"], Ce = s.enum(lt), Be = ["center"], ye = s.enum(Be), ht = [...Ue, ...Be], Re = s.enum(ht);
-s.enum(it);
-const dt = ["first", "last"];
-s.enum(dt);
-const ft = s.object({ lower: s.number(), upper: s.number() }), pt = s.object({ lower: s.bigint(), upper: s.bigint() });
-s.union([ft, Q]);
-s.union([pt, Q]);
-s.union([xe, Re]);
-s.union([xe, Re, s.instanceof(String)]);
-const re = (r, e) => {
+const _ = new ft();
+new gt();
+new pt();
+const ie = i.tuple([i.number(), i.number()]);
+i.tuple([i.bigint(), i.bigint()]);
+const je = i.object({ width: i.number(), height: i.number() }), yt = i.object({
+  signedWidth: i.number(),
+  signedHeight: i.number()
+}), mt = ["width", "height"];
+i.enum(mt);
+const wt = ["start", "center", "end"], bt = ["signedWidth", "signedHeight"];
+i.enum(bt);
+const ne = i.object({ x: i.number(), y: i.number() }), Tt = i.object({ clientX: i.number(), clientY: i.number() }), Ot = ["x", "y"], Fe = i.enum(Ot), Ge = ["top", "right", "bottom", "left"];
+i.enum(Ge);
+const vt = ["left", "right"], qe = i.enum(vt), St = ["top", "bottom"], We = i.enum(St), ze = ["center"], ve = i.enum(ze), It = [...Ge, ...ze], Ze = i.enum(It);
+i.enum(wt);
+const Nt = ["first", "last"];
+i.enum(Nt);
+const Et = i.object({ lower: i.number(), upper: i.number() }), At = i.object({ lower: i.bigint(), upper: i.bigint() });
+i.union([Et, ie]);
+i.union([At, ie]);
+i.union([Fe, Ze]);
+i.union([Fe, Ze, i.instanceof(String)]);
+const K = (r, e) => {
   const t = {};
   if (typeof r == "number" || typeof r == "bigint")
     e != null ? (t.lower = r, t.upper = e) : (t.lower = typeof r == "bigint" ? 0n : 0, t.upper = r);
   else if (Array.isArray(r)) {
     if (r.length !== 2) throw new Error("bounds: expected array of length 2");
     [t.lower, t.upper] = r;
-  } else return ge(r);
-  return ge(t);
-}, ge = (r) => r.lower > r.upper ? { lower: r.upper, upper: r.lower } : r;
-s.object({
-  x: Me.or(ye),
-  y: Ce.or(ye)
+  } else return Se(r);
+  return Se(t);
+}, Se = (r) => r.lower > r.upper ? { lower: r.upper, upper: r.lower } : r;
+i.object({
+  x: qe.or(ve),
+  y: We.or(ve)
 });
-const yt = s.object({ x: Me, y: Ce }), gt = Object.freeze({ x: "left", y: "top" }), mt = (r, e) => r.x === e.x && r.y === e.y, me = s.union([
-  s.number(),
-  X,
-  Q,
-  $e,
-  nt,
-  at
-]), wt = (r, e) => {
+const xt = i.object({ x: qe, y: We }), Mt = Object.freeze({ x: "left", y: "top" }), $t = (r, e) => r.x === e.x && r.y === e.y, Ie = i.union([
+  i.number(),
+  ne,
+  ie,
+  je,
+  yt,
+  Tt
+]), Rt = (r, e) => {
   if (typeof r == "string") {
     if (e === void 0) throw new Error("The y coordinate must be given.");
     return r === "x" ? { x: e, y: 0 } : { x: 0, y: e };
   }
   return typeof r == "number" ? { x: r, y: e ?? r } : Array.isArray(r) ? { x: r[0], y: r[1] } : "signedWidth" in r ? { x: r.signedWidth, y: r.signedHeight } : "clientX" in r ? { x: r.clientX, y: r.clientY } : "width" in r ? { x: r.width, y: r.height } : { x: r.x, y: r.y };
-}, we = Object.freeze({ x: 0, y: 0 }), Z = s.union([s.number(), s.string()]);
-s.object({
-  top: Z,
-  left: Z,
-  width: Z,
-  height: Z
+}, Ne = Object.freeze({ x: 0, y: 0 }), X = i.union([i.number(), i.string()]);
+i.object({
+  top: X,
+  left: X,
+  width: X,
+  height: X
 });
-s.object({
-  left: s.number(),
-  top: s.number(),
-  right: s.number(),
-  bottom: s.number()
+i.object({
+  left: i.number(),
+  top: i.number(),
+  right: i.number(),
+  bottom: i.number()
 });
-s.object({
-  one: X,
-  two: X,
-  root: yt
+i.object({
+  one: ne,
+  two: ne,
+  root: xt
 });
-const le = (r, e, t = 0, n = 0, i) => {
+const ye = (r, e, t = 0, n = 0, s) => {
   const a = {
-    one: { ...we },
-    two: { ...we },
-    root: i ?? gt
+    one: { ...Ne },
+    two: { ...Ne },
+    root: s ?? Mt
   };
   if (typeof r == "number") {
     if (typeof e != "number")
       throw new Error("Box constructor called with invalid arguments");
     return a.one = { x: r, y: e }, a.two = { x: a.one.x + t, y: a.one.y + n }, a;
   }
-  return "one" in r && "two" in r && "root" in r ? { ...r, root: i ?? r.root } : ("getBoundingClientRect" in r && (r = r.getBoundingClientRect()), "left" in r ? (a.one = { x: r.left, y: r.top }, a.two = { x: r.right, y: r.bottom }, a) : (a.one = r, e == null ? a.two = { x: a.one.x + t, y: a.one.y + n } : typeof e == "number" ? a.two = { x: a.one.x + e, y: a.one.y + t } : "width" in e ? a.two = {
+  return "one" in r && "two" in r && "root" in r ? { ...r, root: s ?? r.root } : ("getBoundingClientRect" in r && (r = r.getBoundingClientRect()), "left" in r ? (a.one = { x: r.left, y: r.top }, a.two = { x: r.right, y: r.bottom }, a) : (a.one = r, e == null ? a.two = { x: a.one.x + t, y: a.one.y + n } : typeof e == "number" ? a.two = { x: a.one.x + e, y: a.one.y + t } : "width" in e ? a.two = {
     x: a.one.x + e.width,
     y: a.one.y + e.height
   } : "signedWidth" in e ? a.two = {
     x: a.one.x + e.signedWidth,
     y: a.one.y + e.signedHeight
   } : a.two = e, a));
-}, ne = (r) => {
-  const e = le(r);
+}, ce = (r) => {
+  const e = ye(r);
   return { lower: e.one.x, upper: e.two.x };
-}, se = (r) => {
-  const e = le(r);
+}, le = (r) => {
+  const e = ye(r);
   return { lower: e.one.y, upper: e.two.y };
-}, Ot = (r) => typeof r != "object" || r == null ? !1 : "one" in r && "two" in r && "root" in r;
-var vt = Object.defineProperty, bt = (r, e, t) => e in r ? vt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, C = (r, e, t) => bt(r, typeof e != "symbol" ? e + "" : e, t);
-const Tt = (r, e, t) => e !== void 0 && r < e ? e : t !== void 0 && r > t ? t : r;
-s.object({ offset: me, scale: me });
-const St = (r) => (e, t, n, i) => t === "dimension" ? [e, n] : [
+}, Bt = (r) => typeof r != "object" || r == null ? !1 : "one" in r && "two" in r && "root" in r;
+var Ut = Object.defineProperty, Ct = (r, e, t) => e in r ? Ut(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, D = (r, e, t) => Ct(r, typeof e != "symbol" ? e + "" : e, t);
+const Dt = (r, e, t) => e !== void 0 && r < e ? e : t !== void 0 && r > t ? t : r;
+i.object({ offset: Ie, scale: Ie });
+const Pt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
   e,
-  i ? n - r : n + r
-], It = (r) => (e, t, n, i) => [
+  s ? n - r : n + r
+], Lt = (r) => (e, t, n, s) => [
   e,
-  i ? n / r : n * r
-], Nt = (r) => (e, t, n) => {
+  s ? n / r : n * r
+], Yt = (r) => (e, t, n) => {
   if (e === null) return [r, n];
-  const { lower: i, upper: a } = e, { lower: c, upper: h } = r, g = a - i, m = h - c;
-  if (t === "dimension") return [r, n * (m / g)];
-  const O = (n - i) * (m / g) + c;
-  return [r, O];
-}, Et = (r) => (e, t, n) => [r, n], At = () => (r, e, t) => {
+  const { lower: s, upper: a } = e, { lower: c, upper: d } = r, f = a - s, y = d - c;
+  if (t === "dimension") return [r, n * (y / f)];
+  const T = (n - s) * (y / f) + c;
+  return [r, T];
+}, kt = (r) => (e, t, n) => [r, n], jt = () => (r, e, t) => {
   if (r === null) throw new Error("cannot invert without bounds");
   if (e === "dimension") return [r, t];
-  const { lower: n, upper: i } = r;
-  return [r, i - (t - n)];
-}, $t = (r) => (e, t, n) => {
-  const { lower: i, upper: a } = r;
-  return n = Tt(n, i, a), [e, n];
-}, ae = class W {
+  const { lower: n, upper: s } = r;
+  return [r, s - (t - n)];
+}, Ft = (r) => (e, t, n) => {
+  const { lower: s, upper: a } = r;
+  return n = Dt(n, s, a), [e, n];
+}, fe = class W {
   constructor() {
-    C(this, "ops", []), C(this, "currBounds", null), C(this, "currType", null), C(this, "reversed", !1), this.ops = [];
+    D(this, "ops", []), D(this, "currBounds", null), D(this, "currType", null), D(this, "reversed", !1), this.ops = [];
   }
   static translate(e) {
     return new W().translate(e);
@@ -235,27 +235,27 @@ const St = (r) => (e, t, n, i) => t === "dimension" ? [e, n] : [
     return new W().scale(e, t);
   }
   translate(e) {
-    const t = this.new(), n = St(e);
+    const t = this.new(), n = Pt(e);
     return n.type = "translate", t.ops.push(n), t;
   }
   magnify(e) {
-    const t = this.new(), n = It(e);
+    const t = this.new(), n = Lt(e);
     return n.type = "magnify", t.ops.push(n), t;
   }
   scale(e, t) {
-    const n = re(e, t), i = this.new(), a = Nt(n);
-    return a.type = "scale", i.ops.push(a), i;
+    const n = K(e, t), s = this.new(), a = Yt(n);
+    return a.type = "scale", s.ops.push(a), s;
   }
   clamp(e, t) {
-    const n = re(e, t), i = this.new(), a = $t(n);
-    return a.type = "clamp", i.ops.push(a), i;
+    const n = K(e, t), s = this.new(), a = Ft(n);
+    return a.type = "clamp", s.ops.push(a), s;
   }
   reBound(e, t) {
-    const n = re(e, t), i = this.new(), a = Et(n);
-    return a.type = "re-bound", i.ops.push(a), i;
+    const n = K(e, t), s = this.new(), a = kt(n);
+    return a.type = "re-bound", s.ops.push(a), s;
   }
   invert() {
-    const e = At();
+    const e = jt();
     e.type = "invert";
     const t = this.new();
     return t.ops.push(e), t;
@@ -272,7 +272,7 @@ const St = (r) => (e, t, n, i) => t === "dimension" ? [e, n] : [
   }
   exec(e, t) {
     return this.currBounds = null, this.ops.reduce(
-      ([n, i], a) => a(n, e, i, this.reversed),
+      ([n, s], a) => a(n, e, s, this.reversed),
       [null, t]
     )[1];
   }
@@ -280,47 +280,47 @@ const St = (r) => (e, t, n, i) => t === "dimension" ? [e, n] : [
     const e = this.new();
     e.ops.reverse();
     const t = [];
-    return e.ops.forEach((n, i) => {
-      if (n.type === "scale" || t.some(([c, h]) => i >= c && i <= h))
+    return e.ops.forEach((n, s) => {
+      if (n.type === "scale" || t.some(([c, d]) => s >= c && s <= d))
         return;
-      const a = e.ops.findIndex((c, h) => c.type === "scale" && h > i);
-      a !== -1 && t.push([i, a]);
-    }), t.forEach(([n, i]) => {
-      const a = e.ops.slice(n, i);
-      a.unshift(e.ops[i]), e.ops.splice(n, i - n + 1, ...a);
+      const a = e.ops.findIndex((c, d) => c.type === "scale" && d > s);
+      a !== -1 && t.push([s, a]);
+    }), t.forEach(([n, s]) => {
+      const a = e.ops.slice(n, s);
+      a.unshift(e.ops[s]), e.ops.splice(n, s - n + 1, ...a);
     }), e.reversed = !e.reversed, e;
   }
 };
-C(ae, "IDENTITY", new ae());
-let Oe = ae;
-const ve = class M {
-  constructor(e = new Oe(), t = new Oe(), n = null) {
-    C(this, "x"), C(this, "y"), C(this, "currRoot"), this.x = e, this.y = t, this.currRoot = n;
+D(fe, "IDENTITY", new fe());
+let Ee = fe;
+const Ae = class U {
+  constructor(e = new Ee(), t = new Ee(), n = null) {
+    D(this, "x"), D(this, "y"), D(this, "currRoot"), this.x = e, this.y = t, this.currRoot = n;
   }
   static translate(e, t) {
-    return new M().translate(e, t);
+    return new U().translate(e, t);
   }
   static translateX(e) {
-    return new M().translateX(e);
+    return new U().translateX(e);
   }
   static translateY(e) {
-    return new M().translateY(e);
+    return new U().translateY(e);
   }
   static clamp(e) {
-    return new M().clamp(e);
+    return new U().clamp(e);
   }
   static magnify(e) {
-    return new M().magnify(e);
+    return new U().magnify(e);
   }
   static scale(e) {
-    return new M().scale(e);
+    return new U().scale(e);
   }
   static reBound(e) {
-    return new M().reBound(e);
+    return new U().reBound(e);
   }
   translate(e, t) {
-    const n = wt(e, t), i = this.copy();
-    return i.x = this.x.translate(n.x), i.y = this.y.translate(n.y), i;
+    const n = Rt(e, t), s = this.copy();
+    return s.x = this.x.translate(n.x), s.y = this.y.translate(n.y), s;
   }
   translateX(e) {
     const t = this.copy();
@@ -336,22 +336,22 @@ const ve = class M {
   }
   scale(e) {
     const t = this.copy();
-    if (Ot(e)) {
+    if (Bt(e)) {
       const n = this.currRoot;
-      return t.currRoot = e.root, n != null && !mt(n, e.root) && (n.x !== e.root.x && (t.x = t.x.invert()), n.y !== e.root.y && (t.y = t.y.invert())), t.x = t.x.scale(ne(e)), t.y = t.y.scale(se(e)), t;
+      return t.currRoot = e.root, n != null && !$t(n, e.root) && (n.x !== e.root.x && (t.x = t.x.invert()), n.y !== e.root.y && (t.y = t.y.invert())), t.x = t.x.scale(ce(e)), t.y = t.y.scale(le(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(ne(e)), t.y = this.y.reBound(se(e)), t;
+    return t.x = this.x.reBound(ce(e)), t.y = this.y.reBound(le(e)), t;
   }
   clamp(e) {
     const t = this.copy();
-    return t.x = this.x.clamp(ne(e)), t.y = this.y.clamp(se(e)), t;
+    return t.x = this.x.clamp(ce(e)), t.y = this.y.clamp(le(e)), t;
   }
   copy() {
-    const e = new M();
+    const e = new U();
     return e.currRoot = this.currRoot, e.x = this.x, e.y = this.y, e;
   }
   reverse() {
@@ -362,7 +362,7 @@ const ve = class M {
     return { x: this.x.pos(e.x), y: this.y.pos(e.y) };
   }
   box(e) {
-    return le(
+    return ye(
       this.pos(e.one),
       this.pos(e.two),
       0,
@@ -371,12 +371,45 @@ const ve = class M {
     );
   }
 };
-C(ve, "IDENTITY", new ve());
-const xt = s.object({ signedWidth: s.number(), signedHeight: s.number() });
-s.union([$e, xt, X, Q]);
-var Ut = Object.defineProperty, Mt = (r, e, t) => e in r ? Ut(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, u = (r, e, t) => Mt(r, typeof e != "symbol" ? e + "" : e, t);
-const De = (r, e) => {
-  const t = new T(e);
+D(Ae, "IDENTITY", new Ae());
+const Gt = (r) => r != null && typeof r == "object" && "toString" in r, qt = (r, e = !1) => {
+  const t = Gt(r) ? "stringer" : typeof r;
+  let n;
+  switch (t) {
+    case "string":
+      n = (s, a) => s.localeCompare(a);
+      break;
+    case "stringer":
+      n = (s, a) => s.toString().localeCompare(a.toString());
+      break;
+    case "number":
+      n = (s, a) => Number(s) - Number(a);
+      break;
+    case "bigint":
+      n = (s, a) => BigInt(s) - BigInt(a) > 0n ? 1 : -1;
+      break;
+    case "boolean":
+      n = (s, a) => Number(s) - Number(a);
+      break;
+    case "undefined":
+      n = () => 0;
+      break;
+    default:
+      return console.warn(`sortFunc: unknown type ${t}`), () => -1;
+  }
+  return e ? Wt(n) : n;
+}, Wt = (r) => (e, t) => r(t, e), zt = i.object({ signedWidth: i.number(), signedHeight: i.number() });
+i.union([je, zt, ne, ie]);
+const Zt = i.bigint().or(i.string().transform(BigInt));
+var Vt = Object.defineProperty, Jt = (r, e, t) => e in r ? Vt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, u = (r, e, t) => Jt(r, typeof e != "symbol" ? e + "" : e, t);
+let Ht = (r, e = 21) => (t = e) => {
+  let n = "", s = t;
+  for (; s--; )
+    n += r[Math.random() * r.length | 0];
+  return n;
+};
+const Kt = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", Xt = Ht(Kt, 11), Qt = i.enum(["static", "dynamic"]), Ve = (r, e) => {
+  const t = new O(e);
   if (![
     S.DAY,
     S.HOUR,
@@ -385,28 +418,28 @@ const De = (r, e) => {
     S.MILLISECOND,
     S.MICROSECOND,
     S.NANOSECOND
-  ].some((i) => i.equals(t)))
+  ].some((s) => s.equals(t)))
     throw new Error(
       "Invalid argument for remainder. Must be an even TimeSpan or Timestamp"
     );
   const n = r.valueOf() % t.valueOf();
-  return r instanceof T ? new T(n) : new S(n);
-}, p = class l {
+  return r instanceof O ? new O(n) : new S(n);
+}, m = class h {
   constructor(e, t = "UTC") {
-    if (u(this, "value"), u(this, "encodeValue", !0), e == null) this.value = l.now().valueOf();
+    if (u(this, "value"), u(this, "encodeValue", !0), e == null) this.value = h.now().valueOf();
     else if (e instanceof Date)
-      this.value = BigInt(e.getTime()) * l.MILLISECOND.valueOf();
+      this.value = BigInt(e.getTime()) * h.MILLISECOND.valueOf();
     else if (typeof e == "string")
-      this.value = l.parseDateTimeString(e, t).valueOf();
-    else if (Array.isArray(e)) this.value = l.parseDate(e);
+      this.value = h.parseDateTimeString(e, t).valueOf();
+    else if (Array.isArray(e)) this.value = h.parseDate(e);
     else {
       let n = BigInt(0);
-      e instanceof Number && (e = e.valueOf()), t === "local" && (n = l.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = l.MAX : e = l.MIN)), this.value = BigInt(e.valueOf()) + n;
+      e instanceof Number && (e = e.valueOf()), t === "local" && (n = h.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = h.MAX : e = h.MIN)), this.value = BigInt(e.valueOf()) + n;
     }
   }
   static parseDate([e = 1970, t = 1, n = 1]) {
-    const i = new Date(e, t - 1, n, 0, 0, 0, 0);
-    return new l(BigInt(i.getTime()) * l.MILLISECOND.valueOf()).truncate(l.DAY).valueOf();
+    const s = new Date(e, t - 1, n, 0, 0, 0, 0);
+    return new h(BigInt(s.getTime()) * h.MILLISECOND.valueOf()).truncate(h.DAY).valueOf();
   }
   encode() {
     return this.value.toString();
@@ -415,18 +448,18 @@ const De = (r, e) => {
     return this.value;
   }
   static parseTimeString(e, t = "UTC") {
-    const [n, i, a] = e.split(":");
-    let c = "00", h = "00";
-    a != null && ([c, h] = a.split("."));
-    let g = l.hours(parseInt(n ?? "00", 10)).add(l.minutes(parseInt(i ?? "00", 10))).add(l.seconds(parseInt(c ?? "00", 10))).add(l.milliseconds(parseInt(h ?? "00", 10)));
-    return t === "local" && (g = g.add(l.utcOffset)), g.valueOf();
+    const [n, s, a] = e.split(":");
+    let c = "00", d = "00";
+    a != null && ([c, d] = a.split("."));
+    let f = h.hours(parseInt(n ?? "00", 10)).add(h.minutes(parseInt(s ?? "00", 10))).add(h.seconds(parseInt(c ?? "00", 10))).add(h.milliseconds(parseInt(d ?? "00", 10)));
+    return t === "local" && (f = f.add(h.utcOffset)), f.valueOf();
   }
   static parseDateTimeString(e, t = "UTC") {
     if (!e.includes("/") && !e.includes("-"))
-      return l.parseTimeString(e, t);
+      return h.parseTimeString(e, t);
     const n = new Date(e);
-    return e.includes(":") || n.setUTCHours(0, 0, 0, 0), new l(
-      BigInt(n.getTime()) * l.MILLISECOND.valueOf(),
+    return e.includes(":") || n.setUTCHours(0, 0, 0, 0), new h(
+      BigInt(n.getTime()) * h.MILLISECOND.valueOf(),
       t
     ).valueOf();
   }
@@ -451,7 +484,7 @@ const De = (r, e) => {
     }
   }
   toISOString(e = "UTC") {
-    return e === "UTC" ? this.date().toISOString() : this.sub(l.utcOffset).date().toISOString();
+    return e === "UTC" ? this.date().toISOString() : this.sub(h.utcOffset).date().toISOString();
   }
   timeString(e = !1, t = "UTC") {
     const n = this.toISOString(t);
@@ -463,7 +496,7 @@ const De = (r, e) => {
   }
   static get utcOffset() {
     return new S(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * l.MINUTE.valueOf()
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * h.MINUTE.valueOf()
     );
   }
   /**
@@ -472,7 +505,7 @@ const De = (r, e) => {
    * @param other - The other timestamp.
    */
   static since(e) {
-    return new l().span(e);
+    return new h().span(e);
   }
   /** @returns A JavaScript Date object representing the TimeStamp. */
   date() {
@@ -485,7 +518,7 @@ const De = (r, e) => {
    * @returns True if the TimeStamps are equal, false otherwise.
    */
   equals(e) {
-    return this.valueOf() === new l(e).valueOf();
+    return this.valueOf() === new h(e).valueOf();
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -505,7 +538,7 @@ const De = (r, e) => {
    *   valid, regardless of the TimeStamp order.
    */
   range(e) {
-    return new Ct(this, e).makeValid();
+    return new me(this, e).makeValid();
   }
   /**
    * Creates a TimeRange starting at the TimeStamp and spanning the given
@@ -534,7 +567,7 @@ const De = (r, e) => {
    *   otherwise.
    */
   after(e) {
-    return this.valueOf() > new l(e).valueOf();
+    return this.valueOf() > new h(e).valueOf();
   }
   /**
    * Checks if the TimeStamp is after or equal to the given TimeStamp.
@@ -544,7 +577,7 @@ const De = (r, e) => {
    *   false otherwise.
    */
   afterEq(e) {
-    return this.valueOf() >= new l(e).valueOf();
+    return this.valueOf() >= new h(e).valueOf();
   }
   /**
    * Checks if the TimeStamp is before the given TimeStamp.
@@ -554,7 +587,7 @@ const De = (r, e) => {
    *   otherwise.
    */
   before(e) {
-    return this.valueOf() < new l(e).valueOf();
+    return this.valueOf() < new h(e).valueOf();
   }
   /**
    * Checks if TimeStamp is before or equal to the current timestamp.
@@ -564,7 +597,7 @@ const De = (r, e) => {
    *   false otherwise.
    */
   beforeEq(e) {
-    return this.valueOf() <= new l(e).valueOf();
+    return this.valueOf() <= new h(e).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeStamp.
@@ -574,7 +607,7 @@ const De = (r, e) => {
    *   TimeSpan.
    */
   add(e) {
-    return new l(this.valueOf() + BigInt(e.valueOf()));
+    return new h(this.valueOf() + BigInt(e.valueOf()));
   }
   /**
    * Subtracts a TimeSpan from the TimeStamp.
@@ -584,13 +617,13 @@ const De = (r, e) => {
    *   TimeSpan.
    */
   sub(e) {
-    return new l(this.valueOf() - BigInt(e.valueOf()));
+    return new h(this.valueOf() - BigInt(e.valueOf()));
   }
   /**
    * @returns The number of milliseconds since the unix epoch.
    */
   milliseconds() {
-    return Number(this.valueOf()) / Number(l.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(h.MILLISECOND.valueOf());
   }
   toString() {
     return this.date().toISOString();
@@ -607,11 +640,11 @@ const De = (r, e) => {
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(e) {
-    return De(this, e);
+    return Ve(this, e);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(S.DAY).equals(l.now().truncate(S.DAY));
+    return this.truncate(S.DAY).equals(h.now().truncate(S.DAY));
   }
   truncate(e) {
     return this.sub(this.remainder(e));
@@ -622,72 +655,72 @@ const De = (r, e) => {
    * JavaScript can do).
    */
   static now() {
-    return new l(/* @__PURE__ */ new Date());
+    return new h(/* @__PURE__ */ new Date());
   }
   static max(...e) {
-    let t = l.MIN;
+    let t = h.MIN;
     for (const n of e) {
-      const i = new l(n);
-      i.after(t) && (t = i);
+      const s = new h(n);
+      s.after(t) && (t = s);
     }
     return t;
   }
   static min(...e) {
-    let t = l.MAX;
+    let t = h.MAX;
     for (const n of e) {
-      const i = new l(n);
-      i.before(t) && (t = i);
+      const s = new h(n);
+      s.before(t) && (t = s);
     }
     return t;
   }
   /** @returns a new TimeStamp n nanoseconds after the unix epoch */
   static nanoseconds(e) {
-    return new l(e);
+    return new h(e);
   }
   /** @returns a new TimeStamp n microseconds after the unix epoch */
   static microseconds(e) {
-    return l.nanoseconds(e * 1e3);
+    return h.nanoseconds(e * 1e3);
   }
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
   static milliseconds(e) {
-    return l.microseconds(e * 1e3);
+    return h.microseconds(e * 1e3);
   }
   /** @returns a new TimeStamp n seconds after the unix epoch */
   static seconds(e) {
-    return l.milliseconds(e * 1e3);
+    return h.milliseconds(e * 1e3);
   }
   /** @returns a new TimeStamp n minutes after the unix epoch */
   static minutes(e) {
-    return l.seconds(e * 60);
+    return h.seconds(e * 60);
   }
   /** @returns a new TimeStamp n hours after the unix epoch */
   static hours(e) {
-    return l.minutes(e * 60);
+    return h.minutes(e * 60);
   }
   /** @returns a new TimeStamp n days after the unix epoch */
   static days(e) {
-    return l.hours(e * 24);
+    return h.hours(e * 24);
   }
 };
-u(p, "NANOSECOND", p.nanoseconds(1)), /** One microsecond after the unix epoch */
-u(p, "MICROSECOND", p.microseconds(1)), /** One millisecond after the unix epoch */
-u(p, "MILLISECOND", p.milliseconds(1)), /** One second after the unix epoch */
-u(p, "SECOND", p.seconds(1)), /** One minute after the unix epoch */
-u(p, "MINUTE", p.minutes(1)), /** One hour after the unix epoch */
-u(p, "HOUR", p.hours(1)), /** One day after the unix epoch */
-u(p, "DAY", p.days(1)), /** The maximum possible value for a timestamp */
-u(p, "MAX", new p((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
-u(p, "MIN", new p(0)), /** The unix epoch */
-u(p, "ZERO", new p(0)), /** A zod schema for validating timestamps */
-u(p, "z", s.union([
-  s.object({ value: s.bigint() }).transform((r) => new p(r.value)),
-  s.string().transform((r) => new p(BigInt(r))),
-  s.instanceof(Number).transform((r) => new p(r)),
-  s.number().transform((r) => new p(r)),
-  s.instanceof(p)
+u(m, "NANOSECOND", m.nanoseconds(1)), /** One microsecond after the unix epoch */
+u(m, "MICROSECOND", m.microseconds(1)), /** One millisecond after the unix epoch */
+u(m, "MILLISECOND", m.milliseconds(1)), /** One second after the unix epoch */
+u(m, "SECOND", m.seconds(1)), /** One minute after the unix epoch */
+u(m, "MINUTE", m.minutes(1)), /** One hour after the unix epoch */
+u(m, "HOUR", m.hours(1)), /** One day after the unix epoch */
+u(m, "DAY", m.days(1)), /** The maximum possible value for a timestamp */
+u(m, "MAX", new m((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
+u(m, "MIN", new m(0)), /** The unix epoch */
+u(m, "ZERO", new m(0)), /** A zod schema for validating timestamps */
+u(m, "z", i.union([
+  i.object({ value: i.bigint() }).transform((r) => new m(r.value)),
+  i.string().transform((r) => new m(BigInt(r))),
+  i.instanceof(Number).transform((r) => new m(r)),
+  i.number().transform((r) => new m(r)),
+  i.instanceof(m)
 ]));
-let T = p;
-const y = class d {
+let O = m;
+const w = class g {
   constructor(e) {
     u(this, "value"), u(this, "encodeValue", !0), typeof e == "number" && (e = Math.trunc(e.valueOf())), this.value = BigInt(e.valueOf());
   }
@@ -698,52 +731,52 @@ const y = class d {
     return this.value;
   }
   lessThan(e) {
-    return this.valueOf() < new d(e).valueOf();
+    return this.valueOf() < new g(e).valueOf();
   }
   greaterThan(e) {
-    return this.valueOf() > new d(e).valueOf();
+    return this.valueOf() > new g(e).valueOf();
   }
   lessThanOrEqual(e) {
-    return this.valueOf() <= new d(e).valueOf();
+    return this.valueOf() <= new g(e).valueOf();
   }
   greaterThanOrEqual(e) {
-    return this.valueOf() >= new d(e).valueOf();
+    return this.valueOf() >= new g(e).valueOf();
   }
   remainder(e) {
-    return De(this, e);
+    return Ve(this, e);
   }
   truncate(e) {
-    return new d(
+    return new g(
       BigInt(Math.trunc(Number(this.valueOf() / e.valueOf()))) * e.valueOf()
     );
   }
   toString() {
-    const e = this.truncate(d.DAY), t = this.truncate(d.HOUR), n = this.truncate(d.MINUTE), i = this.truncate(d.SECOND), a = this.truncate(d.MILLISECOND), c = this.truncate(d.MICROSECOND), h = this.truncate(d.NANOSECOND), g = e, m = t.sub(e), O = n.sub(t), w = i.sub(n), A = a.sub(i), k = c.sub(a), U = h.sub(c);
-    let E = "";
-    return g.isZero || (E += `${g.days}d `), m.isZero || (E += `${m.hours}h `), O.isZero || (E += `${O.minutes}m `), w.isZero || (E += `${w.seconds}s `), A.isZero || (E += `${A.milliseconds}ms `), k.isZero || (E += `${k.microseconds}µs `), U.isZero || (E += `${U.nanoseconds}ns`), E.trim();
+    const e = this.truncate(g.DAY), t = this.truncate(g.HOUR), n = this.truncate(g.MINUTE), s = this.truncate(g.SECOND), a = this.truncate(g.MILLISECOND), c = this.truncate(g.MICROSECOND), d = this.truncate(g.NANOSECOND), f = e, y = t.sub(e), T = n.sub(t), l = s.sub(n), E = a.sub(s), R = c.sub(a), B = d.sub(c);
+    let x = "";
+    return f.isZero || (x += `${f.days}d `), y.isZero || (x += `${y.hours}h `), T.isZero || (x += `${T.minutes}m `), l.isZero || (x += `${l.seconds}s `), E.isZero || (x += `${E.milliseconds}ms `), R.isZero || (x += `${R.microseconds}µs `), B.isZero || (x += `${B.nanoseconds}ns`), x.trim();
   }
   /** @returns the decimal number of days in the timespan */
   get days() {
-    return Number(this.valueOf()) / Number(d.DAY.valueOf());
+    return Number(this.valueOf()) / Number(g.DAY.valueOf());
   }
   /** @returns the decimal number of hours in the timespan */
   get hours() {
-    return Number(this.valueOf()) / Number(d.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(g.HOUR.valueOf());
   }
   /** @returns the decimal number of minutes in the timespan */
   get minutes() {
-    return Number(this.valueOf()) / Number(d.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(g.MINUTE.valueOf());
   }
   /** @returns The number of seconds in the TimeSpan. */
   get seconds() {
-    return Number(this.valueOf()) / Number(d.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(g.SECOND.valueOf());
   }
   /** @returns The number of milliseconds in the TimeSpan. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(d.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(g.MILLISECOND.valueOf());
   }
   get microseconds() {
-    return Number(this.valueOf()) / Number(d.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(g.MICROSECOND.valueOf());
   }
   get nanoseconds() {
     return Number(this.valueOf());
@@ -762,7 +795,7 @@ const y = class d {
    * @returns True if the TimeSpans are equal, false otherwise.
    */
   equals(e) {
-    return this.valueOf() === new d(e).valueOf();
+    return this.valueOf() === new g(e).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeSpan.
@@ -770,7 +803,7 @@ const y = class d {
    * @returns A new TimeSpan representing the sum of the two TimeSpans.
    */
   add(e) {
-    return new d(this.valueOf() + new d(e).valueOf());
+    return new g(this.valueOf() + new g(e).valueOf());
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -778,7 +811,7 @@ const y = class d {
    * @param other
    */
   sub(e) {
-    return new d(this.valueOf() - new d(e).valueOf());
+    return new g(this.valueOf() - new g(e).valueOf());
   }
   /**
    * Creates a TimeSpan representing the given number of nanoseconds.
@@ -787,7 +820,7 @@ const y = class d {
    * @returns A TimeSpan representing the given number of nanoseconds.
    */
   static nanoseconds(e = 1) {
-    return new d(e);
+    return new g(e);
   }
   /**
    * Creates a TimeSpan representing the given number of microseconds.
@@ -796,7 +829,7 @@ const y = class d {
    * @returns A TimeSpan representing the given number of microseconds.
    */
   static microseconds(e = 1) {
-    return d.nanoseconds(e * 1e3);
+    return g.nanoseconds(e * 1e3);
   }
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
@@ -805,7 +838,7 @@ const y = class d {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static milliseconds(e = 1) {
-    return d.microseconds(e * 1e3);
+    return g.microseconds(e * 1e3);
   }
   /**
    * Creates a TimeSpan representing the given number of seconds.
@@ -814,7 +847,7 @@ const y = class d {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static seconds(e = 1) {
-    return d.milliseconds(e * 1e3);
+    return g.milliseconds(e * 1e3);
   }
   /**
    * Creates a TimeSpan representing the given number of minutes.
@@ -823,7 +856,7 @@ const y = class d {
    * @returns A TimeSpan representing the given number of minutes.
    */
   static minutes(e) {
-    return d.seconds(e.valueOf() * 60);
+    return g.seconds(e.valueOf() * 60);
   }
   /**
    * Creates a TimeSpan representing the given number of hours.
@@ -832,7 +865,7 @@ const y = class d {
    * @returns A TimeSpan representing the given number of hours.
    */
   static hours(e) {
-    return d.minutes(e * 60);
+    return g.minutes(e * 60);
   }
   /**
    * Creates a TimeSpan representing the given number of days.
@@ -841,28 +874,28 @@ const y = class d {
    * @returns A TimeSpan representing the given number of days.
    */
   static days(e) {
-    return d.hours(e * 24);
+    return g.hours(e * 24);
   }
 };
-u(y, "NANOSECOND", y.nanoseconds(1)), /** A microsecond. */
-u(y, "MICROSECOND", y.microseconds(1)), /** A millisecond. */
-u(y, "MILLISECOND", y.milliseconds(1)), /** A second. */
-u(y, "SECOND", y.seconds(1)), /** A minute. */
-u(y, "MINUTE", y.minutes(1)), /** Represents an hour. */
-u(y, "HOUR", y.hours(1)), /** Represents a day. */
-u(y, "DAY", y.days(1)), /** The maximum possible value for a TimeSpan. */
-u(y, "MAX", new y((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-u(y, "MIN", new y(0)), /** The zero value for a TimeSpan. */
-u(y, "ZERO", new y(0)), /** A zod schema for validating and transforming timespans */
-u(y, "z", s.union([
-  s.object({ value: s.bigint() }).transform((r) => new y(r.value)),
-  s.string().transform((r) => new y(BigInt(r))),
-  s.instanceof(Number).transform((r) => new y(r)),
-  s.number().transform((r) => new y(r)),
-  s.instanceof(y)
+u(w, "NANOSECOND", w.nanoseconds(1)), /** A microsecond. */
+u(w, "MICROSECOND", w.microseconds(1)), /** A millisecond. */
+u(w, "MILLISECOND", w.milliseconds(1)), /** A second. */
+u(w, "SECOND", w.seconds(1)), /** A minute. */
+u(w, "MINUTE", w.minutes(1)), /** Represents an hour. */
+u(w, "HOUR", w.hours(1)), /** Represents a day. */
+u(w, "DAY", w.days(1)), /** The maximum possible value for a TimeSpan. */
+u(w, "MAX", new w((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
+u(w, "MIN", new w(0)), /** The zero value for a TimeSpan. */
+u(w, "ZERO", new w(0)), /** A zod schema for validating and transforming timespans */
+u(w, "z", i.union([
+  i.object({ value: i.bigint() }).transform((r) => new w(r.value)),
+  i.string().transform((r) => new w(BigInt(r))),
+  i.instanceof(Number).transform((r) => new w(r)),
+  i.number().transform((r) => new w(r)),
+  i.instanceof(w)
 ]));
-let S = y;
-const z = class V extends Number {
+let S = w;
+const Q = class ee extends Number {
   constructor(e) {
     e instanceof Number ? super(e.valueOf()) : super(e);
   }
@@ -872,7 +905,7 @@ const z = class V extends Number {
   }
   /** @returns The number of seconds in the Rate. */
   equals(e) {
-    return this.valueOf() === new V(e).valueOf();
+    return this.valueOf() === new ee(e).valueOf();
   }
   /**
    * Calculates the period of the Rate as a TimeSpan.
@@ -899,7 +932,7 @@ const z = class V extends Number {
    * @returns The number of bytes in the given TimeSpan at this rate.
    */
   byteCount(e, t) {
-    return this.sampleCount(e) * new N(t).valueOf();
+    return this.sampleCount(e) * new A(t).valueOf();
   }
   /**
    * Calculates a TimeSpan given the number of samples at this rate.
@@ -927,7 +960,7 @@ const z = class V extends Number {
    * @returns A Rate representing the given number of Hz.
    */
   static hz(e) {
-    return new V(e);
+    return new ee(e);
   }
   /**
    * Creates a Rate representing the given number of kHz.
@@ -936,15 +969,15 @@ const z = class V extends Number {
    * @returns A Rate representing the given number of kHz.
    */
   static khz(e) {
-    return V.hz(e * 1e3);
+    return ee.hz(e * 1e3);
   }
 };
-u(z, "z", s.union([
-  s.number().transform((r) => new z(r)),
-  s.instanceof(Number).transform((r) => new z(r)),
-  s.instanceof(z)
+u(Q, "z", i.union([
+  i.number().transform((r) => new Q(r)),
+  i.instanceof(Number).transform((r) => new Q(r)),
+  i.instanceof(Q)
 ]));
-const b = class extends Number {
+const I = class extends Number {
   /**
    * Creates a Density representing the given number of bytes per value.
    *
@@ -959,22 +992,22 @@ const b = class extends Number {
     return e.valueOf() / this.valueOf();
   }
   size(e) {
-    return new Bt(e * this.valueOf());
+    return new Je(e * this.valueOf());
   }
 };
-u(b, "UNKNOWN", new b(0)), /** 128 bits per value. */
-u(b, "BIT128", new b(16)), /** 64 bits per value. */
-u(b, "BIT64", new b(8)), /** 32 bits per value. */
-u(b, "BIT32", new b(4)), /** 16 bits per value. */
-u(b, "BIT16", new b(2)), /** 8 bits per value. */
-u(b, "BIT8", new b(1)), /** A zod schema for validating and transforming densities */
-u(b, "z", s.union([
-  s.number().transform((r) => new b(r)),
-  s.instanceof(Number).transform((r) => new b(r)),
-  s.instanceof(b)
+u(I, "UNKNOWN", new I(0)), /** 128 bits per value. */
+u(I, "BIT128", new I(16)), /** 64 bits per value. */
+u(I, "BIT64", new I(8)), /** 32 bits per value. */
+u(I, "BIT32", new I(4)), /** 16 bits per value. */
+u(I, "BIT16", new I(2)), /** 8 bits per value. */
+u(I, "BIT8", new I(1)), /** A zod schema for validating and transforming densities */
+u(I, "z", i.union([
+  i.number().transform((r) => new I(r)),
+  i.instanceof(Number).transform((r) => new I(r)),
+  i.instanceof(I)
 ]));
-let N = b;
-const $ = class H {
+let A = I;
+const M = class te {
   /**
    * Creates a TimeRange from the given start and end TimeStamps.
    *
@@ -982,7 +1015,7 @@ const $ = class H {
    * @param end - A TimeStamp representing the end of the range.
    */
   constructor(e, t) {
-    u(this, "start"), u(this, "end"), typeof e == "object" && "start" in e ? (this.start = new T(e.start), this.end = new T(e.end)) : (this.start = new T(e), this.end = new T(t));
+    u(this, "start"), u(this, "end"), 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));
   }
   /** @returns The TimeSpan occupied by the TimeRange. */
   get span() {
@@ -1024,7 +1057,7 @@ const $ = class H {
    * @returns A TimeRange with the start and end swapped.
    */
   swap() {
-    return new H(this.end, this.start);
+    return new te(this.end, this.start);
   }
   /**
    * Checks if the TimeRange is equal to the given TimeRange.
@@ -1054,48 +1087,48 @@ const $ = class H {
     const n = this.makeValid();
     if (this.equals(e)) return !0;
     if (e.end.equals(n.start) || n.end.equals(e.start)) return !1;
-    const i = T.max(n.start, e.start), a = T.min(n.end, e.end);
-    return a.before(i) ? !1 : new S(a.sub(i)).greaterThanOrEqual(t);
+    const s = O.max(n.start, e.start), a = O.min(n.end, e.end);
+    return a.before(s) ? !1 : new S(a.sub(s)).greaterThanOrEqual(t);
   }
   roughlyEquals(e, t) {
-    let n = this.start.sub(e.start).valueOf(), i = this.end.sub(e.end).valueOf();
-    return n < 0 && (n = -n), i < 0 && (i = -i), n <= t.valueOf() && i <= t.valueOf();
+    let n = this.start.sub(e.start).valueOf(), s = this.end.sub(e.end).valueOf();
+    return n < 0 && (n = -n), s < 0 && (s = -s), n <= t.valueOf() && s <= t.valueOf();
   }
   contains(e) {
-    return e instanceof H ? this.contains(e.start) && this.contains(e.end) : this.start.beforeEq(e) && this.end.after(e);
+    return e instanceof te ? this.contains(e.start) && this.contains(e.end) : this.start.beforeEq(e) && this.end.after(e);
   }
   boundBy(e) {
-    const t = new H(this.start, this.end);
+    const t = new te(this.start, this.end);
     return e.start.after(this.start) && (t.start = e.start), e.start.after(this.end) && (t.end = e.start), e.end.before(this.end) && (t.end = e.end), e.end.before(this.start) && (t.start = e.end), t;
   }
 };
-u($, "MAX", new $(T.MIN, T.MAX)), /** The minimum possible time range. */
-u($, "MIN", new $(T.MAX, T.MIN)), /** A zero time range. */
-u($, "ZERO", new $(T.ZERO, T.ZERO)), /** A zod schema for validating and transforming time ranges */
-u($, "z", s.union([
-  s.object({ start: T.z, end: T.z }).transform((r) => new $(r.start, r.end)),
-  s.instanceof($)
+u(M, "MAX", new M(O.MIN, O.MAX)), /** The minimum possible time range. */
+u(M, "MIN", new M(O.MAX, O.MIN)), /** A zero time range. */
+u(M, "ZERO", new M(O.ZERO, O.ZERO)), /** A zod schema for validating and transforming time ranges */
+u(M, "z", i.union([
+  i.object({ start: O.z, end: O.z }).transform((r) => new M(r.start, r.end)),
+  i.instanceof(M)
 ]));
-let Ct = $;
-const o = class x extends String {
+let me = M;
+const o = class $ extends String {
   constructor(e) {
-    if (e instanceof x || typeof e == "string" || typeof e.valueOf() == "string") {
+    if (e instanceof $ || typeof e == "string" || typeof e.valueOf() == "string") {
       super(e.valueOf());
       return;
     } else {
-      const t = x.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
+      const t = $.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
       if (t != null) {
         super(t.valueOf());
         return;
       }
     }
-    throw super(x.UNKNOWN.valueOf()), new Error(`unable to find data type for ${e.toString()}`);
+    throw super($.UNKNOWN.valueOf()), new Error(`unable to find data type for ${e.toString()}`);
   }
   /**
    * @returns the TypedArray constructor for the DataType.
    */
   get Array() {
-    const e = x.ARRAY_CONSTRUCTORS.get(this.toString());
+    const e = $.ARRAY_CONSTRUCTORS.get(this.toString());
     if (e == null)
       throw new Error(`unable to find array constructor for ${this.valueOf()}`);
     return e;
@@ -1117,10 +1150,10 @@ const o = class x extends String {
     return this.valueOf();
   }
   get isVariable() {
-    return this.equals(x.JSON) || this.equals(x.STRING);
+    return this.equals($.JSON) || this.equals($.STRING);
   }
   get isNumeric() {
-    return !this.isVariable && !this.equals(x.UUID);
+    return !this.isVariable && !this.equals($.UUID);
   }
   get isInteger() {
     return this.toString().startsWith("int");
@@ -1129,7 +1162,7 @@ const o = class x extends String {
     return this.toString().startsWith("float");
   }
   get density() {
-    const e = x.DENSITIES.get(this.toString());
+    const e = $.DENSITIES.get(this.toString());
     if (e == null) throw new Error(`unable to find density for ${this.valueOf()}`);
     return e;
   }
@@ -1154,7 +1187,7 @@ const o = class x extends String {
     return this.toString();
   }
   get usesBigInt() {
-    return x.BIG_INT_TYPES.some((e) => e.equals(this));
+    return $.BIG_INT_TYPES.some((e) => e.equals(this));
   }
 };
 u(o, "UNKNOWN", new o("unknown")), /** Represents a 64-bit floating point value. */
@@ -1201,20 +1234,20 @@ u(o, "JSON", new o("json")), u(o, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map(
   [Int32Array.name, o.INT32],
   [BigInt64Array.name, o.INT64]
 ])), u(o, "DENSITIES", /* @__PURE__ */ new Map([
-  [o.UINT8.toString(), N.BIT8],
-  [o.UINT16.toString(), N.BIT16],
-  [o.UINT32.toString(), N.BIT32],
-  [o.UINT64.toString(), N.BIT64],
-  [o.FLOAT32.toString(), N.BIT32],
-  [o.FLOAT64.toString(), N.BIT64],
-  [o.INT8.toString(), N.BIT8],
-  [o.INT16.toString(), N.BIT16],
-  [o.INT32.toString(), N.BIT32],
-  [o.INT64.toString(), N.BIT64],
-  [o.TIMESTAMP.toString(), N.BIT64],
-  [o.STRING.toString(), N.UNKNOWN],
-  [o.JSON.toString(), N.UNKNOWN],
-  [o.UUID.toString(), N.BIT128]
+  [o.UINT8.toString(), A.BIT8],
+  [o.UINT16.toString(), A.BIT16],
+  [o.UINT32.toString(), A.BIT32],
+  [o.UINT64.toString(), A.BIT64],
+  [o.FLOAT32.toString(), A.BIT32],
+  [o.FLOAT64.toString(), A.BIT64],
+  [o.INT8.toString(), A.BIT8],
+  [o.INT16.toString(), A.BIT16],
+  [o.INT32.toString(), A.BIT32],
+  [o.INT64.toString(), A.BIT64],
+  [o.TIMESTAMP.toString(), A.BIT64],
+  [o.STRING.toString(), A.UNKNOWN],
+  [o.JSON.toString(), A.UNKNOWN],
+  [o.UUID.toString(), A.BIT128]
 ])), /** All the data types. */
 u(o, "ALL", [
   o.UNKNOWN,
@@ -1233,11 +1266,12 @@ u(o, "ALL", [
   o.STRING,
   o.JSON
 ]), u(o, "BIG_INT_TYPES", [o.INT64, o.UINT64, o.TIMESTAMP]), /** A zod schema for a DataType. */
-u(o, "z", s.union([
-  s.string().transform((r) => new o(r)),
-  s.instanceof(o)
+u(o, "z", i.union([
+  i.string().transform((r) => new o(r)),
+  i.instanceof(o)
 ]));
-const I = class v extends Number {
+let b = o;
+const N = class v extends Number {
   constructor(e) {
     super(e.valueOf());
   }
@@ -1274,9 +1308,9 @@ const I = class v extends Number {
     return this.valueOf() / v.TERABYTE.valueOf();
   }
   toString() {
-    const e = this.truncate(v.TERABYTE), t = this.truncate(v.GIGABYTE), n = this.truncate(v.MEGABYTE), i = this.truncate(v.KILOBYTE), a = this.truncate(v.BYTE), c = e, h = t.sub(e), g = n.sub(t), m = i.sub(n), O = a.sub(i);
-    let w = "";
-    return c.isZero || (w += `${c.terabytes}TB `), h.isZero || (w += `${h.gigabytes}GB `), g.isZero || (w += `${g.megabytes}MB `), m.isZero || (w += `${m.kilobytes}KB `), (!O.isZero || w === "") && (w += `${O.valueOf()}B`), w.trim();
+    const e = this.truncate(v.TERABYTE), t = this.truncate(v.GIGABYTE), n = this.truncate(v.MEGABYTE), s = this.truncate(v.KILOBYTE), a = this.truncate(v.BYTE), c = e, d = t.sub(e), f = n.sub(t), y = s.sub(n), T = a.sub(s);
+    let l = "";
+    return c.isZero || (l += `${c.terabytes}TB `), d.isZero || (l += `${d.gigabytes}GB `), f.isZero || (l += `${f.megabytes}MB `), y.isZero || (l += `${y.kilobytes}KB `), (!T.isZero || l === "") && (l += `${T.valueOf()}B`), l.trim();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -1327,66 +1361,543 @@ const I = class v extends Number {
     return this.valueOf() === 0;
   }
 };
-u(I, "BYTE", new I(1)), /** A kilobyte */
-u(I, "KILOBYTE", I.kilobytes(1)), /** A megabyte */
-u(I, "MEGABYTE", I.megabytes(1)), /** A gigabyte */
-u(I, "GIGABYTE", I.gigabytes(1)), /** A terabyte. */
-u(I, "TERABYTE", I.terabytes(1)), /** The zero value for Size */
-u(I, "ZERO", new I(0)), /** A zod schema for a Size. */
-u(I, "z", s.union([
-  s.number().transform((r) => new I(r)),
-  s.instanceof(I)
+u(N, "BYTE", new N(1)), /** A kilobyte */
+u(N, "KILOBYTE", N.kilobytes(1)), /** A megabyte */
+u(N, "MEGABYTE", N.megabytes(1)), /** A gigabyte */
+u(N, "GIGABYTE", N.gigabytes(1)), /** A terabyte. */
+u(N, "TERABYTE", N.terabytes(1)), /** The zero value for Size */
+u(N, "ZERO", new N(0)), /** A zod schema for a Size. */
+u(N, "z", i.union([
+  i.number().transform((r) => new N(r)),
+  i.instanceof(N)
 ]));
-let Bt = I;
-s.union([
-  s.instanceof(Uint8Array),
-  s.instanceof(Uint16Array),
-  s.instanceof(Uint32Array),
-  s.instanceof(BigUint64Array),
-  s.instanceof(Float32Array),
-  s.instanceof(Float64Array),
-  s.instanceof(Int8Array),
-  s.instanceof(Int16Array),
-  s.instanceof(Int32Array),
-  s.instanceof(BigInt64Array)
+let Je = N;
+i.union([
+  i.instanceof(Uint8Array),
+  i.instanceof(Uint16Array),
+  i.instanceof(Uint32Array),
+  i.instanceof(BigUint64Array),
+  i.instanceof(Float32Array),
+  i.instanceof(Float64Array),
+  i.instanceof(Int8Array),
+  i.instanceof(Int16Array),
+  i.instanceof(Int32Array),
+  i.instanceof(BigInt64Array)
 ]);
-s.object({
-  key: s.string(),
-  value: s.string()
+const He = (r) => {
+  const e = typeof r;
+  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || r instanceof O || r instanceof S || r instanceof Date;
+}, _t = (r, e, t, n = 0) => r.usesBigInt && !e.usesBigInt ? Number(t) - Number(n) : !r.usesBigInt && e.usesBigInt ? BigInt(t) - BigInt(n) : Z(t, -n), er = (r) => r == null ? !1 : Array.isArray(r) || r instanceof ArrayBuffer || ArrayBuffer.isView(r) && !(r instanceof DataView) || r instanceof nr ? !0 : He(r), Y = -1, tr = i.string().transform(
+  (r) => new Uint8Array(
+    atob(r).split("").map((e) => e.charCodeAt(0))
+  ).buffer
+), rr = i.union([i.null(), i.undefined()]).transform(() => new Uint8Array().buffer), z = class C {
+  constructor(e) {
+    u(this, "key", ""), u(this, "isSynnaxSeries", !0), u(this, "dataType"), u(this, "sampleOffset"), u(this, "gl"), u(this, "_data"), u(this, "_timeRange"), u(this, "alignment", 0n), u(this, "_cachedMin"), u(this, "_cachedMax"), u(this, "writePos", Y), u(this, "_refCount", 0), u(this, "_cachedLength"), er(e) && (e = { data: e });
+    const {
+      dataType: t,
+      timeRange: n,
+      sampleOffset: s = 0,
+      glBufferUsage: a = "static",
+      alignment: c = 0n,
+      key: d = Xt()
+    } = e, f = e.data ?? [];
+    if (f instanceof C || typeof f == "object" && "isSynnaxSeries" in f && f.isSynnaxSeries === !0) {
+      const l = f;
+      this.key = l.key, this.dataType = l.dataType, this.sampleOffset = l.sampleOffset, this.gl = l.gl, this._data = l._data, this._timeRange = l._timeRange, this.alignment = l.alignment, this._cachedMin = l._cachedMin, this._cachedMax = l._cachedMax, this.writePos = l.writePos, this._refCount = l._refCount, this._cachedLength = l._cachedLength;
+      return;
+    }
+    const y = He(f), T = Array.isArray(f);
+    if (t != null) this.dataType = new b(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 (T || y) {
+        let l = f;
+        if (!y) {
+          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."
+            );
+          l = f[0];
+        }
+        if (typeof l == "string") this.dataType = b.STRING;
+        else if (typeof l == "number") this.dataType = b.FLOAT64;
+        else if (typeof l == "bigint") this.dataType = b.INT64;
+        else if (typeof l == "boolean") this.dataType = b.BOOLEAN;
+        else if (l instanceof O || l instanceof Date || l instanceof O)
+          this.dataType = b.TIMESTAMP;
+        else if (typeof l == "object") this.dataType = b.JSON;
+        else
+          throw new Error(
+            `cannot infer data type of ${typeof l} when constructing a Series from a JS array`
+          );
+      } else this.dataType = new b(f);
+    }
+    if (!T && !y) this._data = f;
+    else {
+      let l = y ? [f] : f;
+      const E = l[0];
+      (E instanceof O || E instanceof Date || E instanceof S) && (l = l.map((R) => new O(R).valueOf())), this.dataType.equals(b.STRING) ? (this._cachedLength = l.length, this._data = new TextEncoder().encode(l.join(`
+`) + `
+`)) : this.dataType.equals(b.JSON) ? (this._cachedLength = l.length, this._data = new TextEncoder().encode(
+        l.map((R) => _.encodeString(R)).join(`
+`) + `
+`
+      )) : this._data = new this.dataType.Array(l).buffer;
+    }
+    this.key = d, this.alignment = c, this.sampleOffset = s ?? 0, this._timeRange = n, this.gl = {
+      control: null,
+      buffer: null,
+      prevBuffer: 0,
+      bufferUsage: a
+    };
+  }
+  static alloc({ capacity: e, dataType: t, ...n }) {
+    if (e === 0)
+      throw new Error("[Series] - cannot allocate an array of length 0");
+    const s = new new b(t).Array(e), a = new C({
+      data: s.buffer,
+      dataType: t,
+      ...n
+    });
+    return a.writePos = 0, a;
+  }
+  static generateTimestamps(e, t, n) {
+    const s = n.spanRange(t.span(e)), a = new BigInt64Array(e);
+    for (let c = 0; c < e; c++)
+      a[c] = BigInt(n.add(t.span(c)).valueOf());
+    return new C({ data: a, dataType: b.TIMESTAMP, timeRange: s });
+  }
+  get refCount() {
+    return this._refCount;
+  }
+  static fromStrings(e, t) {
+    const n = new TextEncoder().encode(e.join(`
+`) + `
+`);
+    return new C({ data: n, dataType: b.STRING, timeRange: t });
+  }
+  static fromJSON(e, t) {
+    const n = new TextEncoder().encode(
+      e.map((s) => _.encodeString(s)).join(`
+`) + `
+`
+    );
+    return new C({ data: n, dataType: b.JSON, timeRange: t });
+  }
+  acquire(e) {
+    this._refCount++, e != null && this.updateGLBuffer(e);
+  }
+  release() {
+    if (this._refCount--, this._refCount === 0 && this.gl.control != null)
+      this.maybeGarbageCollectGLBuffer(this.gl.control);
+    else if (this._refCount < 0)
+      throw new Error("cannot release an array with a negative reference count");
+  }
+  /**
+   * Writes the given series to this series. If the series being written exceeds the
+   * remaining of series being written to, only the portion that fits will be written.
+   * @param other the series to write to this series. The data type of the series written
+   * must be the same as the data type of the series being written to.
+   * @returns the number of samples written. If the entire series fits, this value is
+   * equal to the length of the series being written.
+   */
+  write(e) {
+    if (!e.dataType.equals(this.dataType))
+      throw new Error("buffer must be of the same type as this array");
+    if (this.writePos === Y) return 0;
+    const t = this.capacity - this.writePos, n = t < e.length ? e.slice(0, t) : e;
+    return this.underlyingData.set(
+      n.data,
+      this.writePos
+    ), this.maybeRecomputeMinMax(n), this._cachedLength = void 0, this.writePos += n.length, n.length;
+  }
+  /** @returns the underlying buffer backing this array. */
+  get buffer() {
+    return this._data;
+  }
+  get underlyingData() {
+    return new this.dataType.Array(this._data);
+  }
+  /** @returns a native typed array with the proper data type. */
+  get data() {
+    return this.writePos === Y ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
+  }
+  toStrings() {
+    if (!this.dataType.matches(b.STRING, b.UUID))
+      throw new Error("cannot convert non-string series to strings");
+    return new TextDecoder().decode(this.buffer).split(`
+`).slice(0, -1);
+  }
+  toUUIDs() {
+    if (!this.dataType.equals(b.UUID))
+      throw new Error("cannot convert non-uuid series to uuids");
+    const e = b.UUID.density.valueOf(), t = Array(this.length);
+    for (let n = 0; n < this.length; n++) {
+      const s = this.buffer.slice(n * e, (n + 1) * e), a = Array.from(new Uint8Array(s), (c) => c.toString(16).padStart(2, "0")).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+      t[n] = a;
+    }
+    return t;
+  }
+  parseJSON(e) {
+    if (!this.dataType.equals(b.JSON))
+      throw new Error("cannot convert non-string series to strings");
+    return new TextDecoder().decode(this.buffer).split(`
+`).slice(0, -1).map((t) => e.parse(_.decodeString(t)));
+  }
+  /** @returns the time range of this array. */
+  get timeRange() {
+    if (this._timeRange == null) throw new Error("time range not set on series");
+    return this._timeRange;
+  }
+  /** @returns the capacity of the series in bytes. */
+  get byteCapacity() {
+    return new Je(this.buffer.byteLength);
+  }
+  /** @returns the capacity of the series in samples. */
+  get capacity() {
+    return this.dataType.density.length(this.byteCapacity);
+  }
+  /** @returns the length of the series in bytes. */
+  get byteLength() {
+    return this.writePos === Y ? this.byteCapacity : this.dataType.density.size(this.writePos);
+  }
+  /** @returns the number of samples in this array. */
+  get length() {
+    return this._cachedLength != null ? this._cachedLength : this.dataType.isVariable ? this.calculateCachedLength() : this.writePos === Y ? this.data.length : this.writePos;
+  }
+  calculateCachedLength() {
+    if (!this.dataType.isVariable)
+      throw new Error("cannot calculate length of a non-variable length data type");
+    let e = 0;
+    return this.data.forEach((t) => {
+      t === 10 && e++;
+    }), this._cachedLength = e, e;
+  }
+  /**
+   * Creates a new array with a different data type.
+   * @param target the data type to convert to.
+   * @param sampleOffset an offset to apply to each sample. This can help with precision
+   * issues when converting between data types.
+   *
+   * WARNING: This method is expensive and copies the entire underlying array. There
+   * also may be untimely precision issues when converting between data types.
+   */
+  convert(e, t = 0) {
+    if (this.dataType.equals(e)) return this;
+    const n = new e.Array(this.length);
+    for (let s = 0; s < this.length; s++)
+      n[s] = _t(this.dataType, e, this.data[s], t);
+    return new C({
+      data: n.buffer,
+      dataType: e,
+      timeRange: this._timeRange,
+      sampleOffset: t,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment
+    });
+  }
+  calcRawMax() {
+    if (this.length === 0) return -1 / 0;
+    if (this.dataType.equals(b.TIMESTAMP))
+      this._cachedMax = this.data[this.data.length - 1];
+    else if (this.dataType.usesBigInt) {
+      const e = this.data;
+      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
+    } else {
+      const e = this.data;
+      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
+    }
+    return this._cachedMax;
+  }
+  /** @returns the maximum value in the array */
+  get max() {
+    if (this.dataType.isVariable)
+      throw new Error("cannot calculate maximum on a variable length data type");
+    return this.writePos === 0 ? -1 / 0 : (this._cachedMax == null && (this._cachedMax = this.calcRawMax()), Z(this._cachedMax, this.sampleOffset));
+  }
+  calcRawMin() {
+    if (this.length === 0) return 1 / 0;
+    if (this.dataType.equals(b.TIMESTAMP))
+      this._cachedMin = this.data[0];
+    else if (this.dataType.usesBigInt) {
+      const e = this.data;
+      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
+    } else {
+      const e = this.data;
+      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
+    }
+    return this._cachedMin;
+  }
+  /** @returns the minimum value in the array */
+  get min() {
+    if (this.dataType.isVariable)
+      throw new Error("cannot calculate minimum on a variable length data type");
+    return this.writePos === 0 ? 1 / 0 : (this._cachedMin == null && (this._cachedMin = this.calcRawMin()), Z(this._cachedMin, this.sampleOffset));
+  }
+  /** @returns the bounds of this array. */
+  get bounds() {
+    return K(Number(this.min), Number(this.max));
+  }
+  maybeRecomputeMinMax(e) {
+    if (this._cachedMin != null) {
+      const t = e._cachedMin ?? e.calcRawMin();
+      t < this._cachedMin && (this._cachedMin = t);
+    }
+    if (this._cachedMax != null) {
+      const t = e._cachedMax ?? e.calcRawMax();
+      t > this._cachedMax && (this._cachedMax = t);
+    }
+  }
+  enrich() {
+    this.max, this.min;
+  }
+  get range() {
+    return Z(this.max, -this.min);
+  }
+  at(e, t) {
+    if (this.dataType.isVariable) return this.atVariable(e, t ?? !1);
+    e < 0 && (e = this.length + e);
+    const n = this.data[e];
+    if (n == null) {
+      if (t === !0) throw new Error(`[series] - no value at index ${e}`);
+      return;
+    }
+    return Z(n, this.sampleOffset);
+  }
+  atVariable(e, t) {
+    e < 0 && (e = this.length + e);
+    let n = 0, s = 0;
+    for (let c = 0; c < this.data.length; c++)
+      if (this.data[c] === 10) {
+        if (e === 0) {
+          s = c;
+          break;
+        }
+        n = c + 1, e--;
+      }
+    if (s === 0 && (s = this.data.length), n >= s || e > 0) {
+      if (t) throw new Error(`[series] - no value at index ${e}`);
+      return;
+    }
+    const a = this.data.slice(n, s);
+    return this.dataType.equals(b.STRING) ? new TextDecoder().decode(a) : Ye(
+      JSON.parse(new TextDecoder().decode(a))
+    );
+  }
+  /**
+   * @returns the index of the first sample that is greater than or equal to the given value.
+   * The underlying array must be sorted. If it is not, the behavior of this method is undefined.
+   * @param value the value to search for.
+   */
+  binarySearch(e) {
+    let t = 0, n = this.length - 1;
+    const s = qt(e);
+    for (; t <= n; ) {
+      const a = Math.floor((t + n) / 2), c = s(this.at(a, !0), e);
+      if (c === 0) return a;
+      c < 0 ? t = a + 1 : n = a - 1;
+    }
+    return t;
+  }
+  updateGLBuffer(e) {
+    if (this.gl.control = e, !this.dataType.equals(b.FLOAT32))
+      throw new Error("Only FLOAT32 arrays can be used in WebGL");
+    const { buffer: t, bufferUsage: n, prevBuffer: s } = this.gl;
+    if (t == null && (this.gl.buffer = e.createBuffer()), this.writePos !== s)
+      if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== Y) {
+        s === 0 && e.bufferData(e.ARRAY_BUFFER, this.byteCapacity.valueOf(), e.STATIC_DRAW);
+        const a = this.dataType.density.size(s).valueOf(), c = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
+        e.bufferSubData(e.ARRAY_BUFFER, a, c.buffer), this.gl.prevBuffer = this.writePos;
+      } else
+        e.bufferData(
+          e.ARRAY_BUFFER,
+          this.buffer,
+          n === "static" ? e.STATIC_DRAW : e.DYNAMIC_DRAW
+        ), this.gl.prevBuffer = Y;
+  }
+  as(e) {
+    if (e === "string") {
+      if (!this.dataType.equals(b.STRING))
+        throw new Error(
+          `cannot convert series of type ${this.dataType.toString()} to string`
+        );
+      return this;
+    }
+    if (e === "number") {
+      if (!this.dataType.isNumeric)
+        throw new Error(
+          `cannot convert series of type ${this.dataType.toString()} to number`
+        );
+      return this;
+    }
+    if (e === "bigint") {
+      if (!this.dataType.equals(b.INT64))
+        throw new Error(
+          `cannot convert series of type ${this.dataType.toString()} to bigint`
+        );
+      return this;
+    }
+    throw new Error(`cannot convert series to ${e}`);
+  }
+  get digest() {
+    var e;
+    return {
+      key: this.key,
+      dataType: this.dataType.toString(),
+      sampleOffset: this.sampleOffset,
+      alignment: this.alignmentBounds,
+      timeRange: (e = this._timeRange) == null ? void 0 : e.toString(),
+      length: this.length,
+      capacity: this.capacity
+    };
+  }
+  get memInfo() {
+    return {
+      key: this.key,
+      length: this.length,
+      byteLength: this.byteLength,
+      glBuffer: this.gl.buffer != null
+    };
+  }
+  get alignmentBounds() {
+    return K(this.alignment, this.alignment + BigInt(this.length));
+  }
+  maybeGarbageCollectGLBuffer(e) {
+    this.gl.buffer != null && (e.deleteBuffer(this.gl.buffer), this.gl.buffer = null, this.gl.prevBuffer = 0, this.gl.control = null);
+  }
+  get glBuffer() {
+    if (this.gl.buffer == null) throw new Error("gl buffer not initialized");
+    return this.gl.prevBuffer !== this.writePos && console.warn("buffer not updated"), this.gl.buffer;
+  }
+  [Symbol.iterator]() {
+    if (this.dataType.isVariable) {
+      const e = new sr(this);
+      return this.dataType.equals(b.JSON) ? new ir(e) : e;
+    }
+    return new ar(this);
+  }
+  slice(e, t) {
+    if (e <= 0 && (t == null || t >= this.length)) return this;
+    const n = this.data.slice(e, t);
+    return new C({
+      data: n,
+      dataType: this.dataType,
+      timeRange: this._timeRange,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: this.gl.bufferUsage,
+      alignment: this.alignment + BigInt(e)
+    });
+  }
+  reAlign(e) {
+    return new C({
+      data: this.buffer,
+      dataType: this.dataType,
+      timeRange: me.ZERO,
+      sampleOffset: this.sampleOffset,
+      glBufferUsage: "static",
+      alignment: e
+    });
+  }
+};
+u(z, "crudeZ", i.object({
+  timeRange: me.z.optional(),
+  dataType: b.z,
+  alignment: Zt.optional(),
+  data: i.union([tr, rr, i.instanceof(ArrayBuffer)]),
+  glBufferUsage: Qt.optional().default("static").optional()
+})), u(z, "z", z.crudeZ.transform((r) => new z(r)));
+let nr = z;
+class sr {
+  constructor(e) {
+    if (u(this, "series"), u(this, "index"), u(this, "decoder"), !e.dataType.isVariable)
+      throw new Error(
+        "cannot create a variable series iterator for a non-variable series"
+      );
+    this.series = e, this.index = 0, this.decoder = new TextDecoder();
+  }
+  next() {
+    const e = this.index, t = this.series.data;
+    for (; this.index < t.length && t[this.index] !== 10; ) this.index++;
+    const n = this.index;
+    return e === n ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(e, n)) });
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+var xe, Me;
+class ir {
+  constructor(e) {
+    u(this, "wrapped"), u(this, xe, "JSONSeriesIterator"), this.wrapped = e;
+  }
+  next() {
+    const e = this.wrapped.next();
+    return e.done === !0 ? { done: !0, value: void 0 } : {
+      done: !1,
+      value: _.decodeString(e.value)
+    };
+  }
+  [(Me = Symbol.iterator, xe = Symbol.toStringTag, Me)]() {
+    return this;
+  }
+}
+var $e, Re;
+class ar {
+  constructor(e) {
+    u(this, "series"), u(this, "index"), u(this, $e, "SeriesIterator"), this.series = e, this.index = 0;
+  }
+  next() {
+    return this.index >= this.series.length ? { done: !0, value: void 0 } : {
+      done: !1,
+      value: this.series.at(this.index++, !0)
+    };
+  }
+  [(Re = Symbol.iterator, $e = Symbol.toStringTag, Re)]() {
+    return this;
+  }
+}
+const Z = (r, e) => typeof r == "bigint" && typeof e == "bigint" || typeof r == "number" && typeof e == "number" ? r + e : e === 0 ? r : r === 0 ? e : Number(r) + Number(e);
+i.object({
+  key: i.string(),
+  value: i.string()
 });
-s.record(
-  s.union([s.number(), s.string(), s.symbol()]),
-  s.unknown()
+i.record(
+  i.union([i.number(), i.string(), i.symbol()]),
+  i.unknown()
 );
-const Ye = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", Rt = Ye(), Le = ["MacOS", "Windows", "Linux", "Docker"], Dt = s.enum(Le);
-let ie;
-const Yt = () => {
+const Ke = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", or = Ke(), Xe = ["MacOS", "Windows", "Linux", "Docker"], ur = i.enum(Xe);
+let he;
+const cr = () => {
   if (typeof window > "u") return;
   const r = window.navigator.userAgent.toLowerCase();
   if (r.includes("mac")) return "MacOS";
   if (r.includes("win")) return "Windows";
   if (r.includes("linux")) return "Linux";
-}, Lt = (r = {}) => {
+}, lr = (r = {}) => {
   const { force: e, default: t } = r;
-  return e ?? ie ?? (ie = Yt(), ie ?? t);
-}, Pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  return e ?? he ?? (he = cr(), he ?? t);
+}, Qe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  OPERATING_SYSTEMS: Le,
-  RUNTIME: Rt,
-  detect: Ye,
-  getOS: Lt,
-  osZ: Dt
+  OPERATING_SYSTEMS: Xe,
+  RUNTIME: or,
+  detect: Ke,
+  getOS: lr,
+  osZ: ur
 }, Symbol.toStringTag, { value: "Module" }));
-var Pt = Object.defineProperty, jt = (r, e, t) => e in r ? Pt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, F = (r, e, t) => jt(r, typeof e != "symbol" ? e + "" : e, t);
-const kt = (...r) => r.map(je).join(""), je = (r) => (r.endsWith("/") || (r += "/"), r.startsWith("/") && (r = r.slice(1)), r), Wt = (r) => r.endsWith("/") ? r.slice(0, -1) : r, Ft = (r, e = "") => r === null ? "" : "?" + Object.entries(r).filter(([, t]) => t == null ? !1 : Array.isArray(t) ? t.length > 0 : !0).map(([t, n]) => `${e}${t}=${n}`).join("&"), ue = class ce {
+var hr = Object.defineProperty, dr = (r, e, t) => e in r ? hr(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, V = (r, e, t) => dr(r, typeof e != "symbol" ? e + "" : e, t);
+const fr = (...r) => r.map(_e).join(""), _e = (r) => (r.endsWith("/") || (r += "/"), r.startsWith("/") && (r = r.slice(1)), r), gr = (r) => r.endsWith("/") ? r.slice(0, -1) : r, pr = (r, e = "") => r === null ? "" : "?" + Object.entries(r).filter(([, t]) => t == null ? !1 : Array.isArray(t) ? t.length > 0 : !0).map(([t, n]) => `${e}${t}=${n}`).join("&"), ge = class pe {
   /**
    * @param host - The hostname or IP address of the server.
    * @param port - The port number of the server.
    * @param protocol - The protocol to use for all requests. Defaults to "".
    * @param pathPrefix - A path prefix to use for all requests. Defaults to "".
    */
-  constructor({ host: e, port: t, protocol: n = "", pathPrefix: i = "" }) {
-    F(this, "protocol"), F(this, "host"), F(this, "port"), F(this, "path"), this.protocol = n, this.host = e, this.port = t, this.path = je(i);
+  constructor({ host: e, port: t, protocol: n = "", pathPrefix: s = "" }) {
+    V(this, "protocol"), V(this, "host"), V(this, "port"), V(this, "path"), this.protocol = n, this.host = e, this.port = t, this.path = _e(s);
   }
   /**
    * Replaces creates a new URL with the specified properties replaced.
@@ -1394,7 +1905,7 @@ const kt = (...r) => r.map(je).join(""), je = (r) => (r.endsWith("/") || (r += "
    * @returns a new URL.
    */
   replace(e) {
-    return new ce({
+    return new pe({
       host: e.host ?? this.host,
       port: e.port ?? this.port,
       protocol: e.protocol ?? this.protocol,
@@ -1407,54 +1918,54 @@ const kt = (...r) => r.map(je).join(""), je = (r) => (r.endsWith("/") || (r += "
    * @returns a new URL.
    */
   child(e) {
-    return new ce({
+    return new pe({
       ...this,
-      pathPrefix: kt(this.path, e)
+      pathPrefix: fr(this.path, e)
     });
   }
   /** @returns a string representation of the url */
   toString() {
-    return Wt(
+    return gr(
       `${this.protocol}://${this.host}:${this.port}/${this.path}`
     );
   }
 };
-F(ue, "UNKNOWN", new ue({ host: "unknown", port: 0 }));
-let Gt = ue;
-var qt = Object.defineProperty, Zt = (r, e, t) => e in r ? qt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, K = (r, e, t) => Zt(r, typeof e != "symbol" ? e + "" : e, t);
-const Y = class extends Number {
+V(ge, "UNKNOWN", new ge({ host: "unknown", port: 0 }));
+let yr = ge;
+var mr = Object.defineProperty, wr = (r, e, t) => e in r ? mr(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, re = (r, e, t) => wr(r, typeof e != "symbol" ? e + "" : e, t);
+const j = class extends Number {
 };
-K(Y, "Absolute", 255), K(Y, "Default", 1), K(Y, "z", s.union([
-  s.instanceof(Y),
-  s.number().int().min(0).max(255).transform((r) => new Y(r)),
-  s.instanceof(Number).transform((r) => new Y(r))
+re(j, "Absolute", 255), re(j, "Default", 1), re(j, "z", i.union([
+  i.instanceof(j),
+  i.number().int().min(0).max(255).transform((r) => new j(r)),
+  i.instanceof(Number).transform((r) => new j(r))
 ]));
-s.object({
-  name: s.string(),
-  key: s.string()
+i.object({
+  name: i.string(),
+  key: i.string()
 });
-const ke = class G extends Error {
+const et = class J extends Error {
   constructor() {
-    super(G.MESSAGE);
+    super(J.MESSAGE);
   }
   /** Returns true if the error or message is a cancellation error" */
   matches(e) {
-    return typeof e == "string" ? e.includes(G.MESSAGE) : e instanceof G || e.message.includes(G.MESSAGE);
+    return typeof e == "string" ? e.includes(J.MESSAGE) : e instanceof J || e.message.includes(J.MESSAGE);
   }
 };
-K(ke, "MESSAGE", "canceled");
-let zt = ke;
-new zt();
-s.string().regex(/^\d+\.\d+\.\d+$/);
-const he = (r) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.includes(r) : e instanceof Error ? e.message.includes(r) : typeof e != "string" ? !1 : e.includes(r);
-class _ extends Error {
+re(et, "MESSAGE", "canceled");
+let br = et;
+new br();
+i.string().regex(/^\d+\.\d+\.\d+$/);
+const we = (r) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.includes(r) : e instanceof Error ? e.message.includes(r) : typeof e != "string" ? !1 : e.includes(r);
+class ae extends Error {
   constructor(t) {
     super(t);
-    f(this, "discriminator", "FreighterError");
-    f(this, "type", "");
+    p(this, "discriminator", "FreighterError");
+    p(this, "type", "");
   }
 }
-const Vt = (r) => {
+const Tr = (r) => {
   if (r == null || typeof r != "object") return !1;
   const e = r;
   if (e.discriminator !== "FreighterError") return !1;
@@ -1463,98 +1974,98 @@ const Vt = (r) => {
       `Freighter error is missing its type property: ${JSON.stringify(e)}`
     );
   return !0;
-}, be = "unknown", Te = "nil", Ht = "freighter", We = s.object({ type: s.string(), data: s.string() });
-class Kt {
+}, Be = "unknown", Ue = "nil", Or = "freighter", tt = i.object({ type: i.string(), data: i.string() });
+class vr {
   constructor() {
-    f(this, "providers", []);
+    p(this, "providers", []);
   }
   register(e) {
     this.providers.push(e);
   }
   encode(e) {
-    if (e == null) return { type: Te, data: "" };
-    if (Vt(e))
+    if (e == null) return { type: Ue, data: "" };
+    if (Tr(e))
       for (const t of this.providers) {
         const n = t.encode(e);
         if (n != null) return n;
       }
-    return { type: be, data: JSON.stringify(e) };
+    return { type: Be, data: JSON.stringify(e) };
   }
   decode(e) {
-    if (e == null || e.type === Te) return null;
-    if (e.type === be) return new Se(e.data);
+    if (e == null || e.type === Ue) return null;
+    if (e.type === Be) return new Ce(e.data);
     for (const t of this.providers) {
       const n = t.decode(e);
       if (n != null) return n;
     }
-    return new Se(e.data);
+    return new Ce(e.data);
   }
 }
-const de = new Kt(), Xt = ({
+const be = new vr(), Sr = ({
   encode: r,
   decode: e
-}) => de.register({ encode: r, decode: e }), pr = (r) => de.encode(r), Fe = (r) => de.decode(r);
-class Se extends _ {
+}) => be.register({ encode: r, decode: e }), Fr = (r) => be.encode(r), rt = (r) => be.decode(r);
+class Ce extends ae {
   constructor(t) {
     super(t);
-    f(this, "type", "unknown");
+    p(this, "type", "unknown");
   }
 }
-const ee = "freighter.", L = class L extends _ {
+const oe = "freighter.", F = class F extends ae {
   constructor() {
     super("EOF");
-    f(this, "type", L.TYPE);
+    p(this, "type", F.TYPE);
   }
 };
-f(L, "TYPE", ee + "eof"), f(L, "matches", he(L.TYPE));
-let B = L;
-const P = class P extends _ {
+p(F, "TYPE", oe + "eof"), p(F, "matches", we(F.TYPE));
+let P = F;
+const G = class G extends ae {
   constructor() {
     super("StreamClosed");
-    f(this, "type", P.TYPE);
+    p(this, "type", G.TYPE);
   }
 };
-f(P, "TYPE", ee + "stream_closed"), f(P, "matches", he(P.TYPE));
-let R = P;
-const j = class j extends _ {
+p(G, "TYPE", oe + "stream_closed"), p(G, "matches", we(G.TYPE));
+let L = G;
+const q = class q extends ae {
   constructor(t = {}) {
-    const { message: n = "Unreachable", url: i = Gt.UNKNOWN } = t;
+    const { message: n = "Unreachable", url: s = yr.UNKNOWN } = t;
     super(n);
-    f(this, "type", j.TYPE);
-    f(this, "url");
-    this.url = i;
+    p(this, "type", q.TYPE);
+    p(this, "url");
+    this.url = s;
   }
 };
-f(j, "TYPE", ee + "unreachable"), f(j, "matches", he(j.TYPE));
-let D = j;
-const Jt = (r) => {
-  if (!r.type.startsWith(Ht)) return null;
-  if (B.matches(r)) return { type: B.TYPE, data: "EOF" };
-  if (R.matches(r))
-    return { type: R.TYPE, data: "StreamClosed" };
-  if (D.matches(r))
-    return { type: D.TYPE, data: "Unreachable" };
+p(q, "TYPE", oe + "unreachable"), p(q, "matches", we(q.TYPE));
+let k = q;
+const Ir = (r) => {
+  if (!r.type.startsWith(Or)) return null;
+  if (P.matches(r)) return { type: P.TYPE, data: "EOF" };
+  if (L.matches(r))
+    return { type: L.TYPE, data: "StreamClosed" };
+  if (k.matches(r))
+    return { type: k.TYPE, data: "Unreachable" };
   throw new Error(`Unknown error type: ${r.type}: ${r.message}`);
-}, Qt = (r) => {
-  if (!r.type.startsWith(ee)) return null;
+}, Nr = (r) => {
+  if (!r.type.startsWith(oe)) return null;
   switch (r.type) {
-    case B.TYPE:
-      return new B();
-    case R.TYPE:
-      return new R();
-    case D.TYPE:
-      return new D();
+    case P.TYPE:
+      return new P();
+    case L.TYPE:
+      return new L();
+    case k.TYPE:
+      return new k();
     default:
       throw new Error(`Unknown error type: ${r.data}`);
   }
 };
-Xt({
-  encode: Jt,
-  decode: Qt
+Sr({
+  encode: Ir,
+  decode: Nr
 });
-class Ge {
+class nt {
   constructor() {
-    f(this, "middleware", []);
+    p(this, "middleware", []);
   }
   /** Implements the Transport interface */
   use(...e) {
@@ -1571,106 +2082,106 @@ class Ge {
    */
   async executeMiddleware(e, t) {
     let n = 0;
-    const i = async (a) => {
+    const s = async (a) => {
       if (n === this.middleware.length) return await t(a);
       const c = this.middleware[n];
-      return n++, await c(a, i);
+      return n++, await c(a, s);
     };
-    return await i(e);
+    return await s(e);
   }
 }
-const qe = "Content-Type", Ie = (r) => {
-  if (Pe.RUNTIME !== "node") return fetch;
+const st = "Content-Type", De = (r) => {
+  if (Qe.RUNTIME !== "node") return fetch;
   const e = require("node-fetch");
   if (r === "http") return e;
   const t = require("https"), n = new t.Agent({ rejectUnauthorized: !1 });
-  return async (i, a) => await e(i, { ...a, agent: n });
+  return async (s, a) => await e(s, { ...a, agent: n });
 };
-class yr extends Ge {
-  constructor(t, n, i = !1) {
+class Gr extends nt {
+  constructor(t, n, s = !1) {
     super();
-    f(this, "endpoint");
-    f(this, "encoder");
-    f(this, "fetch");
-    return this.endpoint = t.replace({ protocol: i ? "https" : "http" }), this.encoder = n, this.fetch = Ie(this.endpoint.protocol), new Proxy(this, {
-      get: (a, c, h) => c === "endpoint" ? this.endpoint : Reflect.get(a, c, h)
+    p(this, "endpoint");
+    p(this, "encoder");
+    p(this, "fetch");
+    return this.endpoint = t.replace({ protocol: s ? "https" : "http" }), this.encoder = n, this.fetch = De(this.endpoint.protocol), new Proxy(this, {
+      get: (a, c, d) => c === "endpoint" ? this.endpoint : Reflect.get(a, c, d)
     });
   }
   get headers() {
     return {
-      [qe]: this.encoder.contentType
+      [st]: this.encoder.contentType
     };
   }
-  async send(t, n, i, a) {
-    n = i == null ? void 0 : i.parse(n);
+  async send(t, n, s, a) {
+    n = s == null ? void 0 : s.parse(n);
     let c = null;
-    const h = this.endpoint.child(t), g = {};
-    g.method = "POST", g.body = this.encoder.encode(n ?? {});
-    const [, m] = await this.executeMiddleware(
+    const d = this.endpoint.child(t), f = {};
+    f.method = "POST", f.body = this.encoder.encode(n ?? {});
+    const [, y] = await this.executeMiddleware(
       {
-        target: h.toString(),
+        target: d.toString(),
         protocol: this.endpoint.protocol,
         params: {},
         role: "client"
       },
-      async (O) => {
-        const w = { ...O, params: {} };
-        g.headers = {
+      async (T) => {
+        const l = { ...T, params: {} };
+        f.headers = {
           ...this.headers,
-          ...O.params
+          ...T.params
         };
-        let A;
+        let E;
         try {
-          A = await Ie(O.protocol)(O.target, g);
-        } catch (U) {
-          let E = U;
-          return E.message === "Load failed" && (E = new D({ url: h })), [w, E];
+          E = await De(T.protocol)(T.target, f);
+        } catch (B) {
+          let x = B;
+          return x.message === "Load failed" && (x = new k({ url: d })), [l, x];
         }
-        const k = await A.arrayBuffer();
-        if (A != null && A.ok)
-          return a != null && (c = this.encoder.decode(k, a)), [w, null];
+        const R = await E.arrayBuffer();
+        if (E != null && E.ok)
+          return a != null && (c = this.encoder.decode(R, a)), [l, null];
         try {
-          if (A.status !== 400) return [w, new Error(A.statusText)];
-          const U = this.encoder.decode(k, We), E = Fe(U);
-          return [w, E];
-        } catch (U) {
+          if (E.status !== 400) return [l, new Error(E.statusText)];
+          const B = this.encoder.decode(R, tt), x = rt(B);
+          return [l, x];
+        } catch (B) {
           return [
-            w,
+            l,
             new Error(
-              `[freighter] - failed to decode error: ${A.statusText}: ${U.message}`
+              `[freighter] - failed to decode error: ${E.statusText}: ${B.message}`
             )
           ];
         }
       }
     );
-    return [c, m];
+    return [c, y];
   }
 }
-const gr = async (r, e, t, n, i) => {
-  const [a, c] = await r.send(e, t, n, i);
+const qr = async (r, e, t, n, s) => {
+  const [a, c] = await r.send(e, t, n, s);
   if (c != null) throw c;
   return a;
-}, _t = () => Pe.RUNTIME !== "node" ? (r) => new WebSocket(r) : (r) => new (require("ws")).WebSocket(r, { rejectUnauthorized: !1 }), er = s.object({
-  type: s.union([s.literal("data"), s.literal("close")]),
-  payload: s.unknown().optional(),
-  error: s.optional(We)
+}, Er = () => Qe.RUNTIME !== "node" ? (r) => new WebSocket(r) : (r) => new (require("ws")).WebSocket(r, { rejectUnauthorized: !1 }), Ar = i.object({
+  type: i.union([i.literal("data"), i.literal("close")]),
+  payload: i.unknown().optional(),
+  error: i.optional(tt)
 });
-class tr {
-  constructor(e, t, n, i) {
-    f(this, "encoder");
-    f(this, "reqSchema");
-    f(this, "resSchema");
-    f(this, "ws");
-    f(this, "serverClosed");
-    f(this, "sendClosed");
-    f(this, "receiveDataQueue", []);
-    f(this, "receiveCallbacksQueue", []);
-    this.encoder = t, this.reqSchema = n, this.resSchema = i, this.ws = e, this.sendClosed = !1, this.serverClosed = null, this.listenForMessages();
+class xr {
+  constructor(e, t, n, s) {
+    p(this, "encoder");
+    p(this, "reqSchema");
+    p(this, "resSchema");
+    p(this, "ws");
+    p(this, "serverClosed");
+    p(this, "sendClosed");
+    p(this, "receiveDataQueue", []);
+    p(this, "receiveCallbacksQueue", []);
+    this.encoder = t, this.reqSchema = n, this.resSchema = s, this.ws = e, this.sendClosed = !1, this.serverClosed = null, this.listenForMessages();
   }
   /** Implements the Stream protocol */
   send(e) {
-    if (this.serverClosed != null) return new B();
-    if (this.sendClosed) throw new R();
+    if (this.serverClosed != null) return new P();
+    if (this.sendClosed) throw new L();
     return this.ws.send(this.encoder.encode({ type: "data", payload: e })), null;
   }
   /** Implements the Stream protocol */
@@ -1679,7 +2190,7 @@ class tr {
     const e = await this.receiveMsg();
     if (e.type === "close") {
       if (e.error == null) throw new Error("Message error must be defined");
-      return this.serverClosed = Fe(e.error), [null, this.serverClosed];
+      return this.serverClosed = rt(e.error), [null, this.serverClosed];
     }
     return [this.resSchema.parse(e.payload), null];
   }
@@ -1708,74 +2219,74 @@ class tr {
     t != null ? t.resolve(e) : this.receiveDataQueue.push(e);
   }
   listenForMessages() {
-    this.ws.onmessage = (e) => this.addMessage(this.encoder.decode(e.data, er)), this.ws.onclose = (e) => this.addMessage({
+    this.ws.onmessage = (e) => this.addMessage(this.encoder.decode(e.data, Ar)), this.ws.onclose = (e) => this.addMessage({
       type: "close",
-      error: { type: or(e) ? B.TYPE : R.TYPE, data: "" }
+      error: { type: Ur(e) ? P.TYPE : L.TYPE, data: "" }
     });
   }
 }
-const rr = "freighterctx", nr = 1e3, sr = 1001, ir = [nr, sr], or = (r) => ir.includes(r.code), J = class J extends Ge {
+const Mr = "freighterctx", $r = 1e3, Rr = 1001, Br = [$r, Rr], Ur = (r) => Br.includes(r.code), se = class se extends nt {
   /**
    * @param encoder - The encoder to use for encoding messages and decoding
    *   responses.
    * @param baseEndpoint - A base url to use as a prefix for all requests.
    */
-  constructor(t, n, i = !1) {
+  constructor(t, n, s = !1) {
     super();
-    f(this, "baseUrl");
-    f(this, "encoder");
-    this.baseUrl = t.replace({ protocol: i ? "wss" : "ws" }), this.encoder = n;
+    p(this, "baseUrl");
+    p(this, "encoder");
+    this.baseUrl = t.replace({ protocol: s ? "wss" : "ws" }), this.encoder = n;
   }
   /** Implements the StreamClient interface. */
-  async stream(t, n, i) {
-    const a = _t();
+  async stream(t, n, s) {
+    const a = Er();
     let c;
-    const [, h] = await this.executeMiddleware(
+    const [, d] = await this.executeMiddleware(
       { target: t, protocol: "websocket", params: {}, role: "client" },
-      async (g) => {
-        const m = a(this.buildURL(t, g)), O = { ...g, params: {} };
-        m.binaryType = J.MESSAGE_TYPE;
-        const w = await this.wrapSocket(m, n, i);
-        return w instanceof Error ? [O, w] : (c = w, [O, null]);
+      async (f) => {
+        const y = a(this.buildURL(t, f)), T = { ...f, params: {} };
+        y.binaryType = se.MESSAGE_TYPE;
+        const l = await this.wrapSocket(y, n, s);
+        return l instanceof Error ? [T, l] : (c = l, [T, null]);
       }
     );
-    if (h != null) throw h;
+    if (d != null) throw d;
     return c;
   }
   buildURL(t, n) {
-    const i = Ft(
+    const s = pr(
       {
-        [qe]: this.encoder.contentType,
+        [st]: this.encoder.contentType,
         ...n.params
       },
-      rr
+      Mr
     );
-    return this.baseUrl.child(t).toString() + i;
+    return this.baseUrl.child(t).toString() + s;
   }
-  async wrapSocket(t, n, i) {
+  async wrapSocket(t, n, s) {
     return await new Promise((a) => {
       t.onopen = () => {
-        a(new tr(t, this.encoder, n, i));
+        a(new xr(t, this.encoder, n, s));
       }, t.onerror = (c) => {
-        const h = c;
-        a(new Error(h.message));
+        const d = c;
+        a(new Error(d.message));
       };
     });
   }
 };
-f(J, "MESSAGE_TYPE", "arraybuffer");
-let Ne = J;
+p(se, "MESSAGE_TYPE", "arraybuffer");
+let Pe = se;
 export {
-  _ as BaseTypedError,
-  B as EOF,
-  yr as HTTPClient,
-  R as StreamClosed,
-  D as Unreachable,
-  Ne as WebSocketClient,
-  Fe as decodeError,
-  pr as encodeError,
-  he as errorMatcher,
-  We as errorZ,
-  Xt as registerError,
-  gr as sendRequired
+  ae as BaseTypedError,
+  P as EOF,
+  Gr as HTTPClient,
+  L as StreamClosed,
+  k as Unreachable,
+  Pe as WebSocketClient,
+  rt as decodeError,
+  Fr as encodeError,
+  we as errorMatcher,
+  tt as errorZ,
+  Sr as registerError,
+  qr as sendRequired
 };