@synnaxlabs/freighter 0.41.0 → 0.42.1

package/dist/freighter.js

@@ -1,97 +1,1041 @@
-var ht = Object.defineProperty;
-var ft = (r, e, t) => e in r ? ht(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var y = (r, e, t) => ft(r, typeof e != "symbol" ? e + "" : e, t);
-import { z as i } from "zod";
-const dt = (r) => {
-  const e = r.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
+var Lt = Object.defineProperty;
+var kt = (s, e, t) => e in s ? Lt(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var S = (s, e, t) => kt(s, typeof e != "symbol" ? e + "" : e, t);
+import Y, { z as i } from "zod";
+const Pt = (s) => {
+  const e = s.replace(/_[a-z]/g, (t) => t[1].toUpperCase());
   return e.length > 1 && e[0] === e[0].toUpperCase() && e[1] === e[1].toUpperCase() || e.length === 0 ? e : e[0].toLowerCase() + e.slice(1);
-}, Ve = (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 (!ce(t)) return t;
-    n = yt(n);
-    const s = {}, a = t;
-    return Object.keys(a).forEach((c) => {
-      let f = a[c];
-      const d = r(c);
-      n.recursive && (ce(f) ? Ne(f, n.keepTypesOnRecursion) || (f = e(f, n)) : n.recursiveInArray && Ie(f) && (f = [...f].map((p) => {
-        let m = p;
-        return ce(p) ? Ne(m, n.keepTypesOnRecursion) || (m = e(p, n)) : Ie(p) && (m = e({ key: p }, n).key), m;
-      }))), s[d] = f;
-    }), s;
+}, ot = (s) => {
+  const e = (t, r = Ie) => {
+    if (typeof t == "string") return s(t);
+    if (Array.isArray(t)) return t.map((o) => e(o, r));
+    if (!be(t)) return t;
+    r = Ft(r);
+    const n = {}, a = t;
+    return Object.keys(a).forEach((o) => {
+      let c = a[o];
+      const d = s(o);
+      r.recursive && (be(c) ? We(c, r.keepTypesOnRecursion) || (c = e(c, r)) : r.recursiveInArray && Ye(c) && (c = [...c].map((p) => {
+        let y = p;
+        return be(p) ? We(y, r.keepTypesOnRecursion) || (y = e(p, r)) : Ye(p) && (y = e({ key: p }, r).key), y;
+      }))), n[d] = c;
+    }), n;
   };
   return e;
-}, ze = Ve(dt), gt = (r) => (
+}, De = ot(Pt), jt = (s) => (
   // Don't convert the first character and don't convert a character that is after a
   // non-alphanumeric character
-  r.replace(
+  s.replace(
     /([a-z0-9])([A-Z])/g,
-    (e, t, n) => `${t}_${n.toLowerCase()}`
+    (e, t, r) => `${t}_${r.toLowerCase()}`
   )
-), pt = Ve(gt), de = {
+), ht = ot(jt), Ie = {
   recursive: !0,
   recursiveInArray: !0,
   keepTypesOnRecursion: [Number, String, Uint8Array]
-}, yt = (r = de) => (r.recursive == null ? r = de : r.recursiveInArray ?? (r.recursiveInArray = !1), r), Ie = (r) => r != null && Array.isArray(r), ce = (r) => r != null && typeof r == "object" && !Array.isArray(r), Ne = (r, e) => (e || []).some((t) => r instanceof t), Ze = (r) => r != null && typeof r == "object" && !Array.isArray(r);
-var mt = Object.defineProperty, wt = (r, e, t) => e in r ? mt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, _ = (r, e, t) => wt(r, typeof e != "symbol" ? e + "" : e, t);
-let bt = class {
+}, Ft = (s = Ie) => (s.recursive == null ? s = Ie : s.recursiveInArray ?? (s.recursiveInArray = !1), s), Ye = (s) => s != null && Array.isArray(s), be = (s) => s != null && typeof s == "object" && !Array.isArray(s), We = (s, e) => (e || []).some((t) => s instanceof t), Le = (s) => s != null && typeof s == "object" && !Array.isArray(s);
+var zt = Object.defineProperty, Yt = (s, e, t) => e in s ? zt(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, V = (s, e, t) => Yt(s, typeof e != "symbol" ? e + "" : e, t);
+function Wt(s) {
+  const e = s.length;
+  let t = 0, r = 0;
+  for (; r < e; ) {
+    let n = s.charCodeAt(r++);
+    if ((n & 4294967168) === 0) {
+      t++;
+      continue;
+    } else if ((n & 4294965248) === 0)
+      t += 2;
+    else {
+      if (n >= 55296 && n <= 56319 && r < e) {
+        const a = s.charCodeAt(r);
+        (a & 64512) === 56320 && (++r, n = ((n & 1023) << 10) + (a & 1023) + 65536);
+      }
+      (n & 4294901760) === 0 ? t += 3 : t += 4;
+    }
+  }
+  return t;
+}
+function qt(s, e, t) {
+  const r = s.length;
+  let n = t, a = 0;
+  for (; a < r; ) {
+    let o = s.charCodeAt(a++);
+    if ((o & 4294967168) === 0) {
+      e[n++] = o;
+      continue;
+    } else if ((o & 4294965248) === 0)
+      e[n++] = o >> 6 & 31 | 192;
+    else {
+      if (o >= 55296 && o <= 56319 && a < r) {
+        const c = s.charCodeAt(a);
+        (c & 64512) === 56320 && (++a, o = ((o & 1023) << 10) + (c & 1023) + 65536);
+      }
+      (o & 4294901760) === 0 ? (e[n++] = o >> 12 & 15 | 224, e[n++] = o >> 6 & 63 | 128) : (e[n++] = o >> 18 & 7 | 240, e[n++] = o >> 12 & 63 | 128, e[n++] = o >> 6 & 63 | 128);
+    }
+    e[n++] = o & 63 | 128;
+  }
+}
+const Vt = new TextEncoder(), Ht = 50;
+function Zt(s, e, t) {
+  Vt.encodeInto(s, e.subarray(t));
+}
+function Gt(s, e, t) {
+  s.length > Ht ? Zt(s, e, t) : qt(s, e, t);
+}
+const Kt = 4096;
+function ut(s, e, t) {
+  let r = e;
+  const n = r + t, a = [];
+  let o = "";
+  for (; r < n; ) {
+    const c = s[r++];
+    if ((c & 128) === 0)
+      a.push(c);
+    else if ((c & 224) === 192) {
+      const d = s[r++] & 63;
+      a.push((c & 31) << 6 | d);
+    } else if ((c & 240) === 224) {
+      const d = s[r++] & 63, p = s[r++] & 63;
+      a.push((c & 31) << 12 | d << 6 | p);
+    } else if ((c & 248) === 240) {
+      const d = s[r++] & 63, p = s[r++] & 63, y = s[r++] & 63;
+      let l = (c & 7) << 18 | d << 12 | p << 6 | y;
+      l > 65535 && (l -= 65536, a.push(l >>> 10 & 1023 | 55296), l = 56320 | l & 1023), a.push(l);
+    } else
+      a.push(c);
+    a.length >= Kt && (o += String.fromCharCode(...a), a.length = 0);
+  }
+  return a.length > 0 && (o += String.fromCharCode(...a)), o;
+}
+const Jt = new TextDecoder(), Xt = 200;
+function Qt(s, e, t) {
+  const r = s.subarray(e, e + t);
+  return Jt.decode(r);
+}
+function _t(s, e, t) {
+  return t > Xt ? Qt(s, e, t) : ut(s, e, t);
+}
+let ce = class {
+  constructor(e, t) {
+    this.type = e, this.data = t;
+  }
+}, C = class Ue extends Error {
+  constructor(e) {
+    super(e);
+    const t = Object.create(Ue.prototype);
+    Object.setPrototypeOf(this, t), Object.defineProperty(this, "name", {
+      configurable: !0,
+      enumerable: !1,
+      value: Ue.name
+    });
+  }
+};
+const J = 4294967295;
+function es(s, e, t) {
+  const r = t / 4294967296, n = t;
+  s.setUint32(e, r), s.setUint32(e + 4, n);
+}
+function ct(s, e, t) {
+  const r = Math.floor(t / 4294967296), n = t;
+  s.setUint32(e, r), s.setUint32(e + 4, n);
+}
+function lt(s, e) {
+  const t = s.getInt32(e), r = s.getUint32(e + 4);
+  return t * 4294967296 + r;
+}
+function ts(s, e) {
+  const t = s.getUint32(e), r = s.getUint32(e + 4);
+  return t * 4294967296 + r;
+}
+const ss = -1, rs = 4294967296 - 1, ns = 17179869184 - 1;
+function is({ sec: s, nsec: e }) {
+  if (s >= 0 && e >= 0 && s <= ns)
+    if (e === 0 && s <= rs) {
+      const t = new Uint8Array(4);
+      return new DataView(t.buffer).setUint32(0, s), t;
+    } else {
+      const t = s / 4294967296, r = s & 4294967295, n = new Uint8Array(8), a = new DataView(n.buffer);
+      return a.setUint32(0, e << 2 | t & 3), a.setUint32(4, r), n;
+    }
+  else {
+    const t = new Uint8Array(12), r = new DataView(t.buffer);
+    return r.setUint32(0, e), ct(r, 4, s), t;
+  }
+}
+function as(s) {
+  const e = s.getTime(), t = Math.floor(e / 1e3), r = (e - t * 1e3) * 1e6, n = Math.floor(r / 1e9);
+  return {
+    sec: t + n,
+    nsec: r - n * 1e9
+  };
+}
+function os(s) {
+  if (s instanceof Date) {
+    const e = as(s);
+    return is(e);
+  } else
+    return null;
+}
+function hs(s) {
+  const e = new DataView(s.buffer, s.byteOffset, s.byteLength);
+  switch (s.byteLength) {
+    case 4:
+      return { sec: e.getUint32(0), nsec: 0 };
+    case 8: {
+      const t = e.getUint32(0), r = e.getUint32(4), n = (t & 3) * 4294967296 + r, a = t >>> 2;
+      return { sec: n, nsec: a };
+    }
+    case 12: {
+      const t = lt(e, 4), r = e.getUint32(0);
+      return { sec: t, nsec: r };
+    }
+    default:
+      throw new C(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${s.length}`);
+  }
+}
+function us(s) {
+  const e = hs(s);
+  return new Date(e.sec * 1e3 + e.nsec / 1e6);
+}
+const cs = {
+  type: ss,
+  encode: os,
+  decode: us
+};
+let he = class {
   constructor() {
-    _(this, "contentType", "application/json"), _(this, "decoder"), _(this, "encoder"), this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
+    this.builtInEncoders = [], this.builtInDecoders = [], this.encoders = [], this.decoders = [], this.register(cs);
+  }
+  register({ type: e, encode: t, decode: r }) {
+    if (e >= 0)
+      this.encoders[e] = t, this.decoders[e] = r;
+    else {
+      const n = -1 - e;
+      this.builtInEncoders[n] = t, this.builtInDecoders[n] = r;
+    }
+  }
+  tryToEncode(e, t) {
+    for (let r = 0; r < this.builtInEncoders.length; r++) {
+      const n = this.builtInEncoders[r];
+      if (n != null) {
+        const a = n(e, t);
+        if (a != null) {
+          const o = -1 - r;
+          return new ce(o, a);
+        }
+      }
+    }
+    for (let r = 0; r < this.encoders.length; r++) {
+      const n = this.encoders[r];
+      if (n != null) {
+        const a = n(e, t);
+        if (a != null) {
+          const o = r;
+          return new ce(o, a);
+        }
+      }
+    }
+    return e instanceof ce ? e : null;
+  }
+  decode(e, t, r) {
+    const n = t < 0 ? this.builtInDecoders[-1 - t] : this.decoders[t];
+    return n ? n(e, t, r) : new ce(t, e);
+  }
+};
+he.defaultCodec = new he();
+function ls(s) {
+  return s instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && s instanceof SharedArrayBuffer;
+}
+function xe(s) {
+  return s instanceof Uint8Array ? s : ArrayBuffer.isView(s) ? new Uint8Array(s.buffer, s.byteOffset, s.byteLength) : ls(s) ? new Uint8Array(s) : Uint8Array.from(s);
+}
+const ds = 100, fs = 2048;
+let gs = class dt {
+  constructor(e) {
+    this.entered = !1, this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? he.defaultCodec, this.context = e == null ? void 0 : e.context, this.useBigInt64 = (e == null ? void 0 : e.useBigInt64) ?? !1, this.maxDepth = (e == null ? void 0 : e.maxDepth) ?? ds, this.initialBufferSize = (e == null ? void 0 : e.initialBufferSize) ?? fs, this.sortKeys = (e == null ? void 0 : e.sortKeys) ?? !1, this.forceFloat32 = (e == null ? void 0 : e.forceFloat32) ?? !1, this.ignoreUndefined = (e == null ? void 0 : e.ignoreUndefined) ?? !1, this.forceIntegerToFloat = (e == null ? void 0 : e.forceIntegerToFloat) ?? !1, this.pos = 0, this.view = new DataView(new ArrayBuffer(this.initialBufferSize)), this.bytes = new Uint8Array(this.view.buffer);
+  }
+  clone() {
+    return new dt({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      maxDepth: this.maxDepth,
+      initialBufferSize: this.initialBufferSize,
+      sortKeys: this.sortKeys,
+      forceFloat32: this.forceFloat32,
+      ignoreUndefined: this.ignoreUndefined,
+      forceIntegerToFloat: this.forceIntegerToFloat
+    });
   }
+  reinitializeState() {
+    this.pos = 0;
+  }
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  encodeSharedRef(e) {
+    if (this.entered)
+      return this.clone().encodeSharedRef(e);
+    try {
+      return this.entered = !0, this.reinitializeState(), this.doEncode(e, 1), this.bytes.subarray(0, this.pos);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
   encode(e) {
-    return this.encoder.encode(this.encodeString(e)).buffer;
+    if (this.entered)
+      return this.clone().encode(e);
+    try {
+      return this.entered = !0, this.reinitializeState(), this.doEncode(e, 1), this.bytes.slice(0, this.pos);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  doEncode(e, t) {
+    if (t > this.maxDepth)
+      throw new Error(`Too deep objects in depth ${t}`);
+    e == null ? this.encodeNil() : typeof e == "boolean" ? this.encodeBoolean(e) : typeof e == "number" ? this.forceIntegerToFloat ? this.encodeNumberAsFloat(e) : this.encodeNumber(e) : typeof e == "string" ? this.encodeString(e) : this.useBigInt64 && typeof e == "bigint" ? this.encodeBigInt64(e) : this.encodeObject(e, t);
+  }
+  ensureBufferSizeToWrite(e) {
+    const t = this.pos + e;
+    this.view.byteLength < t && this.resizeBuffer(t * 2);
+  }
+  resizeBuffer(e) {
+    const t = new ArrayBuffer(e), r = new Uint8Array(t), n = new DataView(t);
+    r.set(this.bytes), this.view = n, this.bytes = r;
+  }
+  encodeNil() {
+    this.writeU8(192);
+  }
+  encodeBoolean(e) {
+    e === !1 ? this.writeU8(194) : this.writeU8(195);
+  }
+  encodeNumber(e) {
+    !this.forceIntegerToFloat && Number.isSafeInteger(e) ? e >= 0 ? e < 128 ? this.writeU8(e) : e < 256 ? (this.writeU8(204), this.writeU8(e)) : e < 65536 ? (this.writeU8(205), this.writeU16(e)) : e < 4294967296 ? (this.writeU8(206), this.writeU32(e)) : this.useBigInt64 ? this.encodeNumberAsFloat(e) : (this.writeU8(207), this.writeU64(e)) : e >= -32 ? this.writeU8(224 | e + 32) : e >= -128 ? (this.writeU8(208), this.writeI8(e)) : e >= -32768 ? (this.writeU8(209), this.writeI16(e)) : e >= -2147483648 ? (this.writeU8(210), this.writeI32(e)) : this.useBigInt64 ? this.encodeNumberAsFloat(e) : (this.writeU8(211), this.writeI64(e)) : this.encodeNumberAsFloat(e);
+  }
+  encodeNumberAsFloat(e) {
+    this.forceFloat32 ? (this.writeU8(202), this.writeF32(e)) : (this.writeU8(203), this.writeF64(e));
+  }
+  encodeBigInt64(e) {
+    e >= BigInt(0) ? (this.writeU8(207), this.writeBigUint64(e)) : (this.writeU8(211), this.writeBigInt64(e));
+  }
+  writeStringHeader(e) {
+    if (e < 32)
+      this.writeU8(160 + e);
+    else if (e < 256)
+      this.writeU8(217), this.writeU8(e);
+    else if (e < 65536)
+      this.writeU8(218), this.writeU16(e);
+    else if (e < 4294967296)
+      this.writeU8(219), this.writeU32(e);
+    else
+      throw new Error(`Too long string: ${e} bytes in UTF-8`);
+  }
+  encodeString(e) {
+    const t = Wt(e);
+    this.ensureBufferSizeToWrite(5 + t), this.writeStringHeader(t), Gt(e, this.bytes, this.pos), this.pos += t;
+  }
+  encodeObject(e, t) {
+    const r = this.extensionCodec.tryToEncode(e, this.context);
+    if (r != null)
+      this.encodeExtension(r);
+    else if (Array.isArray(e))
+      this.encodeArray(e, t);
+    else if (ArrayBuffer.isView(e))
+      this.encodeBinary(e);
+    else if (typeof e == "object")
+      this.encodeMap(e, t);
+    else
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(e)}`);
+  }
+  encodeBinary(e) {
+    const t = e.byteLength;
+    if (t < 256)
+      this.writeU8(196), this.writeU8(t);
+    else if (t < 65536)
+      this.writeU8(197), this.writeU16(t);
+    else if (t < 4294967296)
+      this.writeU8(198), this.writeU32(t);
+    else
+      throw new Error(`Too large binary: ${t}`);
+    const r = xe(e);
+    this.writeU8a(r);
+  }
+  encodeArray(e, t) {
+    const r = e.length;
+    if (r < 16)
+      this.writeU8(144 + r);
+    else if (r < 65536)
+      this.writeU8(220), this.writeU16(r);
+    else if (r < 4294967296)
+      this.writeU8(221), this.writeU32(r);
+    else
+      throw new Error(`Too large array: ${r}`);
+    for (const n of e)
+      this.doEncode(n, t + 1);
+  }
+  countWithoutUndefined(e, t) {
+    let r = 0;
+    for (const n of t)
+      e[n] !== void 0 && r++;
+    return r;
+  }
+  encodeMap(e, t) {
+    const r = Object.keys(e);
+    this.sortKeys && r.sort();
+    const n = this.ignoreUndefined ? this.countWithoutUndefined(e, r) : r.length;
+    if (n < 16)
+      this.writeU8(128 + n);
+    else if (n < 65536)
+      this.writeU8(222), this.writeU16(n);
+    else if (n < 4294967296)
+      this.writeU8(223), this.writeU32(n);
+    else
+      throw new Error(`Too large map object: ${n}`);
+    for (const a of r) {
+      const o = e[a];
+      this.ignoreUndefined && o === void 0 || (this.encodeString(a), this.doEncode(o, t + 1));
+    }
+  }
+  encodeExtension(e) {
+    if (typeof e.data == "function") {
+      const r = e.data(this.pos + 6), n = r.length;
+      if (n >= 4294967296)
+        throw new Error(`Too large extension object: ${n}`);
+      this.writeU8(201), this.writeU32(n), this.writeI8(e.type), this.writeU8a(r);
+      return;
+    }
+    const t = e.data.length;
+    if (t === 1)
+      this.writeU8(212);
+    else if (t === 2)
+      this.writeU8(213);
+    else if (t === 4)
+      this.writeU8(214);
+    else if (t === 8)
+      this.writeU8(215);
+    else if (t === 16)
+      this.writeU8(216);
+    else if (t < 256)
+      this.writeU8(199), this.writeU8(t);
+    else if (t < 65536)
+      this.writeU8(200), this.writeU16(t);
+    else if (t < 4294967296)
+      this.writeU8(201), this.writeU32(t);
+    else
+      throw new Error(`Too large extension object: ${t}`);
+    this.writeI8(e.type), this.writeU8a(e.data);
+  }
+  writeU8(e) {
+    this.ensureBufferSizeToWrite(1), this.view.setUint8(this.pos, e), this.pos++;
+  }
+  writeU8a(e) {
+    const t = e.length;
+    this.ensureBufferSizeToWrite(t), this.bytes.set(e, this.pos), this.pos += t;
+  }
+  writeI8(e) {
+    this.ensureBufferSizeToWrite(1), this.view.setInt8(this.pos, e), this.pos++;
+  }
+  writeU16(e) {
+    this.ensureBufferSizeToWrite(2), this.view.setUint16(this.pos, e), this.pos += 2;
+  }
+  writeI16(e) {
+    this.ensureBufferSizeToWrite(2), this.view.setInt16(this.pos, e), this.pos += 2;
+  }
+  writeU32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setUint32(this.pos, e), this.pos += 4;
+  }
+  writeI32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setInt32(this.pos, e), this.pos += 4;
+  }
+  writeF32(e) {
+    this.ensureBufferSizeToWrite(4), this.view.setFloat32(this.pos, e), this.pos += 4;
+  }
+  writeF64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setFloat64(this.pos, e), this.pos += 8;
+  }
+  writeU64(e) {
+    this.ensureBufferSizeToWrite(8), es(this.view, this.pos, e), this.pos += 8;
+  }
+  writeI64(e) {
+    this.ensureBufferSizeToWrite(8), ct(this.view, this.pos, e), this.pos += 8;
+  }
+  writeBigUint64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setBigUint64(this.pos, e), this.pos += 8;
+  }
+  writeBigInt64(e) {
+    this.ensureBufferSizeToWrite(8), this.view.setBigInt64(this.pos, e), this.pos += 8;
+  }
+};
+function Q(s, e) {
+  return new gs(e).encodeSharedRef(s);
+}
+function ve(s) {
+  return `${s < 0 ? "-" : ""}0x${Math.abs(s).toString(16).padStart(2, "0")}`;
+}
+const ps = 16, ys = 16;
+class ws {
+  constructor(e = ps, t = ys) {
+    this.hit = 0, this.miss = 0, this.maxKeyLength = e, this.maxLengthPerKey = t, this.caches = [];
+    for (let r = 0; r < this.maxKeyLength; r++)
+      this.caches.push([]);
+  }
+  canBeCached(e) {
+    return e > 0 && e <= this.maxKeyLength;
+  }
+  find(e, t, r) {
+    const n = this.caches[r - 1];
+    e: for (const a of n) {
+      const o = a.bytes;
+      for (let c = 0; c < r; c++)
+        if (o[c] !== e[t + c])
+          continue e;
+      return a.str;
+    }
+    return null;
+  }
+  store(e, t) {
+    const r = this.caches[e.length - 1], n = { bytes: e, str: t };
+    r.length >= this.maxLengthPerKey ? r[Math.random() * r.length | 0] = n : r.push(n);
+  }
+  decode(e, t, r) {
+    const n = this.find(e, t, r);
+    if (n != null)
+      return this.hit++, n;
+    this.miss++;
+    const a = ut(e, t, r), o = Uint8Array.prototype.slice.call(e, t, t + r);
+    return this.store(o, a), a;
+  }
+}
+const Ne = "array", ie = "map_key", ft = "map_value", ms = (s) => {
+  if (typeof s == "string" || typeof s == "number")
+    return s;
+  throw new C("The type of key must be string or number but " + typeof s);
+};
+class bs {
+  constructor() {
+    this.stack = [], this.stackHeadPosition = -1;
+  }
+  get length() {
+    return this.stackHeadPosition + 1;
+  }
+  top() {
+    return this.stack[this.stackHeadPosition];
+  }
+  pushArrayState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = Ne, t.position = 0, t.size = e, t.array = new Array(e);
+  }
+  pushMapState(e) {
+    const t = this.getUninitializedStateFromPool();
+    t.type = ie, t.readCount = 0, t.size = e, t.map = {};
+  }
+  getUninitializedStateFromPool() {
+    if (this.stackHeadPosition++, this.stackHeadPosition === this.stack.length) {
+      const e = {
+        type: void 0,
+        size: 0,
+        array: void 0,
+        position: 0,
+        readCount: 0,
+        map: void 0,
+        key: null
+      };
+      this.stack.push(e);
+    }
+    return this.stack[this.stackHeadPosition];
+  }
+  release(e) {
+    if (this.stack[this.stackHeadPosition] !== e)
+      throw new Error("Invalid stack state. Released state is not on top of the stack.");
+    if (e.type === Ne) {
+      const t = e;
+      t.size = 0, t.array = void 0, t.position = 0, t.type = void 0;
+    }
+    if (e.type === ie || e.type === ft) {
+      const t = e;
+      t.size = 0, t.map = void 0, t.readCount = 0, t.type = void 0;
+    }
+    this.stackHeadPosition--;
+  }
+  reset() {
+    this.stack.length = 0, this.stackHeadPosition = -1;
+  }
+}
+const X = -1, ke = new DataView(new ArrayBuffer(0)), vs = new Uint8Array(ke.buffer);
+try {
+  ke.getInt8(0);
+} catch (s) {
+  if (!(s instanceof RangeError))
+    throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+}
+const qe = new RangeError("Insufficient data"), Ts = new ws();
+let Os = class gt {
+  constructor(e) {
+    this.totalPos = 0, this.pos = 0, this.view = ke, this.bytes = vs, this.headByte = X, this.stack = new bs(), this.entered = !1, this.extensionCodec = (e == null ? void 0 : e.extensionCodec) ?? he.defaultCodec, this.context = e == null ? void 0 : e.context, this.useBigInt64 = (e == null ? void 0 : e.useBigInt64) ?? !1, this.rawStrings = (e == null ? void 0 : e.rawStrings) ?? !1, this.maxStrLength = (e == null ? void 0 : e.maxStrLength) ?? J, this.maxBinLength = (e == null ? void 0 : e.maxBinLength) ?? J, this.maxArrayLength = (e == null ? void 0 : e.maxArrayLength) ?? J, this.maxMapLength = (e == null ? void 0 : e.maxMapLength) ?? J, this.maxExtLength = (e == null ? void 0 : e.maxExtLength) ?? J, this.keyDecoder = (e == null ? void 0 : e.keyDecoder) !== void 0 ? e.keyDecoder : Ts, this.mapKeyConverter = (e == null ? void 0 : e.mapKeyConverter) ?? ms;
+  }
+  clone() {
+    return new gt({
+      extensionCodec: this.extensionCodec,
+      context: this.context,
+      useBigInt64: this.useBigInt64,
+      rawStrings: this.rawStrings,
+      maxStrLength: this.maxStrLength,
+      maxBinLength: this.maxBinLength,
+      maxArrayLength: this.maxArrayLength,
+      maxMapLength: this.maxMapLength,
+      maxExtLength: this.maxExtLength,
+      keyDecoder: this.keyDecoder
+    });
+  }
+  reinitializeState() {
+    this.totalPos = 0, this.headByte = X, this.stack.reset();
+  }
+  setBuffer(e) {
+    const t = xe(e);
+    this.bytes = t, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength), this.pos = 0;
+  }
+  appendBuffer(e) {
+    if (this.headByte === X && !this.hasRemaining(1))
+      this.setBuffer(e);
+    else {
+      const t = this.bytes.subarray(this.pos), r = xe(e), n = new Uint8Array(t.length + r.length);
+      n.set(t), n.set(r, t.length), this.setBuffer(n);
+    }
+  }
+  hasRemaining(e) {
+    return this.view.byteLength - this.pos >= e;
+  }
+  createExtraByteError(e) {
+    const { view: t, pos: r } = this;
+    return new RangeError(`Extra ${t.byteLength - r} of ${t.byteLength} byte(s) found at buffer[${e}]`);
+  }
+  /**
+   * @throws {@link DecodeError}
+   * @throws {@link RangeError}
+   */
+  decode(e) {
+    if (this.entered)
+      return this.clone().decode(e);
+    try {
+      this.entered = !0, this.reinitializeState(), this.setBuffer(e);
+      const t = this.doDecodeSync();
+      if (this.hasRemaining(1))
+        throw this.createExtraByteError(this.pos);
+      return t;
+    } finally {
+      this.entered = !1;
+    }
+  }
+  *decodeMulti(e) {
+    if (this.entered) {
+      yield* this.clone().decodeMulti(e);
+      return;
+    }
+    try {
+      for (this.entered = !0, this.reinitializeState(), this.setBuffer(e); this.hasRemaining(1); )
+        yield this.doDecodeSync();
+    } finally {
+      this.entered = !1;
+    }
+  }
+  async decodeAsync(e) {
+    if (this.entered)
+      return this.clone().decodeAsync(e);
+    try {
+      this.entered = !0;
+      let t = !1, r;
+      for await (const c of e) {
+        if (t)
+          throw this.entered = !1, this.createExtraByteError(this.totalPos);
+        this.appendBuffer(c);
+        try {
+          r = this.doDecodeSync(), t = !0;
+        } catch (d) {
+          if (!(d instanceof RangeError))
+            throw d;
+        }
+        this.totalPos += this.pos;
+      }
+      if (t) {
+        if (this.hasRemaining(1))
+          throw this.createExtraByteError(this.totalPos);
+        return r;
+      }
+      const { headByte: n, pos: a, totalPos: o } = this;
+      throw new RangeError(`Insufficient data in parsing ${ve(n)} at ${o} (${a} in the current buffer)`);
+    } finally {
+      this.entered = !1;
+    }
+  }
+  decodeArrayStream(e) {
+    return this.decodeMultiAsync(e, !0);
+  }
+  decodeStream(e) {
+    return this.decodeMultiAsync(e, !1);
+  }
+  async *decodeMultiAsync(e, t) {
+    if (this.entered) {
+      yield* this.clone().decodeMultiAsync(e, t);
+      return;
+    }
+    try {
+      this.entered = !0;
+      let r = t, n = -1;
+      for await (const a of e) {
+        if (t && n === 0)
+          throw this.createExtraByteError(this.totalPos);
+        this.appendBuffer(a), r && (n = this.readArraySize(), r = !1, this.complete());
+        try {
+          for (; yield this.doDecodeSync(), --n !== 0; )
+            ;
+        } catch (o) {
+          if (!(o instanceof RangeError))
+            throw o;
+        }
+        this.totalPos += this.pos;
+      }
+    } finally {
+      this.entered = !1;
+    }
+  }
+  doDecodeSync() {
+    e: for (; ; ) {
+      const e = this.readHeadByte();
+      let t;
+      if (e >= 224)
+        t = e - 256;
+      else if (e < 192)
+        if (e < 128)
+          t = e;
+        else if (e < 144) {
+          const n = e - 128;
+          if (n !== 0) {
+            this.pushMapState(n), this.complete();
+            continue e;
+          } else
+            t = {};
+        } else if (e < 160) {
+          const n = e - 144;
+          if (n !== 0) {
+            this.pushArrayState(n), this.complete();
+            continue e;
+          } else
+            t = [];
+        } else {
+          const n = e - 160;
+          t = this.decodeString(n, 0);
+        }
+      else if (e === 192)
+        t = null;
+      else if (e === 194)
+        t = !1;
+      else if (e === 195)
+        t = !0;
+      else if (e === 202)
+        t = this.readF32();
+      else if (e === 203)
+        t = this.readF64();
+      else if (e === 204)
+        t = this.readU8();
+      else if (e === 205)
+        t = this.readU16();
+      else if (e === 206)
+        t = this.readU32();
+      else if (e === 207)
+        this.useBigInt64 ? t = this.readU64AsBigInt() : t = this.readU64();
+      else if (e === 208)
+        t = this.readI8();
+      else if (e === 209)
+        t = this.readI16();
+      else if (e === 210)
+        t = this.readI32();
+      else if (e === 211)
+        this.useBigInt64 ? t = this.readI64AsBigInt() : t = this.readI64();
+      else if (e === 217) {
+        const n = this.lookU8();
+        t = this.decodeString(n, 1);
+      } else if (e === 218) {
+        const n = this.lookU16();
+        t = this.decodeString(n, 2);
+      } else if (e === 219) {
+        const n = this.lookU32();
+        t = this.decodeString(n, 4);
+      } else if (e === 220) {
+        const n = this.readU16();
+        if (n !== 0) {
+          this.pushArrayState(n), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 221) {
+        const n = this.readU32();
+        if (n !== 0) {
+          this.pushArrayState(n), this.complete();
+          continue e;
+        } else
+          t = [];
+      } else if (e === 222) {
+        const n = this.readU16();
+        if (n !== 0) {
+          this.pushMapState(n), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 223) {
+        const n = this.readU32();
+        if (n !== 0) {
+          this.pushMapState(n), this.complete();
+          continue e;
+        } else
+          t = {};
+      } else if (e === 196) {
+        const n = this.lookU8();
+        t = this.decodeBinary(n, 1);
+      } else if (e === 197) {
+        const n = this.lookU16();
+        t = this.decodeBinary(n, 2);
+      } else if (e === 198) {
+        const n = this.lookU32();
+        t = this.decodeBinary(n, 4);
+      } else if (e === 212)
+        t = this.decodeExtension(1, 0);
+      else if (e === 213)
+        t = this.decodeExtension(2, 0);
+      else if (e === 214)
+        t = this.decodeExtension(4, 0);
+      else if (e === 215)
+        t = this.decodeExtension(8, 0);
+      else if (e === 216)
+        t = this.decodeExtension(16, 0);
+      else if (e === 199) {
+        const n = this.lookU8();
+        t = this.decodeExtension(n, 1);
+      } else if (e === 200) {
+        const n = this.lookU16();
+        t = this.decodeExtension(n, 2);
+      } else if (e === 201) {
+        const n = this.lookU32();
+        t = this.decodeExtension(n, 4);
+      } else
+        throw new C(`Unrecognized type byte: ${ve(e)}`);
+      this.complete();
+      const r = this.stack;
+      for (; r.length > 0; ) {
+        const n = r.top();
+        if (n.type === Ne)
+          if (n.array[n.position] = t, n.position++, n.position === n.size)
+            t = n.array, r.release(n);
+          else
+            continue e;
+        else if (n.type === ie) {
+          if (t === "__proto__")
+            throw new C("The key __proto__ is not allowed");
+          n.key = this.mapKeyConverter(t), n.type = ft;
+          continue e;
+        } else if (n.map[n.key] = t, n.readCount++, n.readCount === n.size)
+          t = n.map, r.release(n);
+        else {
+          n.key = null, n.type = ie;
+          continue e;
+        }
+      }
+      return t;
+    }
+  }
+  readHeadByte() {
+    return this.headByte === X && (this.headByte = this.readU8()), this.headByte;
+  }
+  complete() {
+    this.headByte = X;
+  }
+  readArraySize() {
+    const e = this.readHeadByte();
+    switch (e) {
+      case 220:
+        return this.readU16();
+      case 221:
+        return this.readU32();
+      default: {
+        if (e < 160)
+          return e - 144;
+        throw new C(`Unrecognized array type byte: ${ve(e)}`);
+      }
+    }
+  }
+  pushMapState(e) {
+    if (e > this.maxMapLength)
+      throw new C(`Max length exceeded: map length (${e}) > maxMapLengthLength (${this.maxMapLength})`);
+    this.stack.pushMapState(e);
+  }
+  pushArrayState(e) {
+    if (e > this.maxArrayLength)
+      throw new C(`Max length exceeded: array length (${e}) > maxArrayLength (${this.maxArrayLength})`);
+    this.stack.pushArrayState(e);
+  }
+  decodeString(e, t) {
+    return !this.rawStrings || this.stateIsMapKey() ? this.decodeUtf8String(e, t) : this.decodeBinary(e, t);
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeUtf8String(e, t) {
+    var r;
+    if (e > this.maxStrLength)
+      throw new C(`Max length exceeded: UTF-8 byte length (${e}) > maxStrLength (${this.maxStrLength})`);
+    if (this.bytes.byteLength < this.pos + t + e)
+      throw qe;
+    const n = this.pos + t;
+    let a;
+    return this.stateIsMapKey() && (r = this.keyDecoder) != null && r.canBeCached(e) ? a = this.keyDecoder.decode(this.bytes, n, e) : a = _t(this.bytes, n, e), this.pos += t + e, a;
+  }
+  stateIsMapKey() {
+    return this.stack.length > 0 ? this.stack.top().type === ie : !1;
+  }
+  /**
+   * @throws {@link RangeError}
+   */
+  decodeBinary(e, t) {
+    if (e > this.maxBinLength)
+      throw new C(`Max length exceeded: bin length (${e}) > maxBinLength (${this.maxBinLength})`);
+    if (!this.hasRemaining(e + t))
+      throw qe;
+    const r = this.pos + t, n = this.bytes.subarray(r, r + e);
+    return this.pos += t + e, n;
+  }
+  decodeExtension(e, t) {
+    if (e > this.maxExtLength)
+      throw new C(`Max length exceeded: ext length (${e}) > maxExtLength (${this.maxExtLength})`);
+    const r = this.view.getInt8(this.pos + t), n = this.decodeBinary(
+      e,
+      t + 1
+      /* extType */
+    );
+    return this.extensionCodec.decode(n, r, this.context);
+  }
+  lookU8() {
+    return this.view.getUint8(this.pos);
+  }
+  lookU16() {
+    return this.view.getUint16(this.pos);
+  }
+  lookU32() {
+    return this.view.getUint32(this.pos);
+  }
+  readU8() {
+    const e = this.view.getUint8(this.pos);
+    return this.pos++, e;
+  }
+  readI8() {
+    const e = this.view.getInt8(this.pos);
+    return this.pos++, e;
+  }
+  readU16() {
+    const e = this.view.getUint16(this.pos);
+    return this.pos += 2, e;
+  }
+  readI16() {
+    const e = this.view.getInt16(this.pos);
+    return this.pos += 2, e;
+  }
+  readU32() {
+    const e = this.view.getUint32(this.pos);
+    return this.pos += 4, e;
+  }
+  readI32() {
+    const e = this.view.getInt32(this.pos);
+    return this.pos += 4, e;
+  }
+  readU64() {
+    const e = ts(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readI64() {
+    const e = lt(this.view, this.pos);
+    return this.pos += 8, e;
+  }
+  readU64AsBigInt() {
+    const e = this.view.getBigUint64(this.pos);
+    return this.pos += 8, e;
+  }
+  readI64AsBigInt() {
+    const e = this.view.getBigInt64(this.pos);
+    return this.pos += 8, e;
+  }
+  readF32() {
+    const e = this.view.getFloat32(this.pos);
+    return this.pos += 4, e;
+  }
+  readF64() {
+    const e = this.view.getFloat64(this.pos);
+    return this.pos += 8, e;
+  }
+};
+function pt(s, e) {
+  return new Os(e).decode(s);
+}
+let Ss = class {
+  constructor() {
+    V(this, "contentType", "application/json"), V(this, "decoder"), V(this, "encoder"), this.decoder = new TextDecoder(), this.encoder = new TextEncoder();
+  }
+  encode(e) {
+    return this.encoder.encode(this.encodeString(e));
   }
   decode(e, t) {
     return this.decodeString(this.decoder.decode(e), t);
   }
   decodeString(e, t) {
-    const n = JSON.parse(e), s = ze(n);
-    return t != null ? t.parse(s) : s;
+    const r = JSON.parse(e), n = De(r);
+    return t != null ? t.parse(n) : n;
   }
   encodeString(e) {
-    const t = pt(e);
-    return JSON.stringify(t, (n, s) => ArrayBuffer.isView(s) ? Array.from(s) : Ze(s) && "encode_value" in s ? typeof s.value == "bigint" ? s.value.toString() : s.value : typeof s == "bigint" ? s.toString() : s);
+    const t = ht(e);
+    return JSON.stringify(t, (r, n) => ArrayBuffer.isView(n) ? Array.from(n) : Le(n) && "encode_value" in n ? typeof n.value == "bigint" ? n.value.toString() : n.value : typeof n == "bigint" ? n.toString() : n);
   }
   static registerCustomType() {
   }
-}, Ot = class {
+}, Is = class {
   constructor() {
-    _(this, "contentType", "text/csv");
+    V(this, "contentType", "text/csv");
   }
   encode(e) {
     const t = this.encodeString(e);
-    return new TextEncoder().encode(t).buffer;
+    return new TextEncoder().encode(t);
   }
   decode(e, t) {
-    const n = new TextDecoder().decode(e);
-    return this.decodeString(n, t);
+    const r = new TextDecoder().decode(e);
+    return this.decodeString(r, t);
   }
   encodeString(e) {
-    if (!Array.isArray(e) || e.length === 0 || !Ze(e[0]))
+    if (!Array.isArray(e) || e.length === 0 || !Le(e[0]))
       throw new Error("Payload must be an array of objects");
-    const t = Object.keys(e[0]), n = [t.join(",")];
-    return e.forEach((s) => {
-      const a = t.map((c) => JSON.stringify(s[c] ?? ""));
-      n.push(a.join(","));
-    }), n.join(`
+    const t = Object.keys(e[0]), r = [t.join(",")];
+    return e.forEach((n) => {
+      const a = t.map((o) => JSON.stringify(n[o] ?? ""));
+      r.push(a.join(","));
+    }), r.join(`
 `);
   }
   decodeString(e, t) {
-    const [n, ...s] = e.trim().split(`
-`).map((f) => f.trim());
-    if (n.length === 0)
+    const [r, ...n] = e.trim().split(`
+`).map((c) => c.trim());
+    if (r.length === 0)
       return t != null ? t.parse({}) : {};
-    const a = n.split(",").map((f) => f.trim()), c = {};
-    return a.forEach((f) => {
-      c[f] = [];
-    }), s.forEach((f) => {
-      const d = f.split(",").map((p) => p.trim());
-      a.forEach((p, m) => {
-        const l = this.parseValue(d[m]);
-        l != null && c[p].push(l);
+    const a = r.split(",").map((c) => c.trim()), o = {};
+    return a.forEach((c) => {
+      o[c] = [];
+    }), n.forEach((c) => {
+      const d = c.split(",").map((p) => p.trim());
+      a.forEach((p, y) => {
+        const l = this.parseValue(d[y]);
+        l != null && o[p].push(l);
       });
-    }), t != null ? t.parse(c) : c;
+    }), t != null ? t.parse(o) : o;
   }
   parseValue(e) {
     if (e == null || e.length === 0) return null;
@@ -100,103 +1044,131 @@ let bt = class {
   }
   static registerCustomType() {
   }
-}, Tt = class {
+}, Us = class {
+  constructor() {
+    V(this, "contentType", "text/plain");
+  }
+  encode(e) {
+    return new TextEncoder().encode(e);
+  }
+  decode(e, t) {
+    const r = new TextDecoder().decode(e);
+    return t != null ? t.parse(r) : r;
+  }
+};
+const j = new he();
+j.register({
+  type: 0,
+  encode: (s) => {
+    if (ArrayBuffer.isView(s)) {
+      const e = Array.from(s);
+      return Q(e, { extensionCodec: j });
+    }
+    return Le(s) && "encode_value" in s ? typeof s.value == "bigint" ? Q(s.value.toString(), { extensionCodec: j }) : Q(s.value, { extensionCodec: j }) : typeof s == "bigint" ? Q(s.toString(), { extensionCodec: j }) : null;
+  },
+  decode: (s) => pt(s, { extensionCodec: j })
+});
+let xs = class {
   constructor() {
-    _(this, "contentType", "text/plain");
+    V(this, "contentType", "application/msgpack");
   }
   encode(e) {
-    return new TextEncoder().encode(e).buffer;
+    const t = ht(e);
+    return Q(t, { extensionCodec: j }).slice();
   }
   decode(e, t) {
-    const n = new TextDecoder().decode(e);
+    const r = pt(e, { extensionCodec: j }), n = De(r);
     return t != null ? t.parse(n) : n;
   }
+  static registerCustomType() {
+  }
 };
-const te = new bt();
-new Ot();
-new Tt();
-const vt = (r) => r != null && typeof r == "object" && "toString" in r, St = (r, e = !1) => {
-  const t = vt(r) ? "stringer" : typeof r;
-  let n;
+const fe = new Ss();
+new Is();
+new Us();
+new xs();
+const Ns = (s) => s != null && typeof s == "object" && "toString" in s, Es = (s, e = !1) => {
+  const t = Ns(s) ? "stringer" : typeof s;
+  let r;
   switch (t) {
     case "string":
-      n = (s, a) => s.localeCompare(a);
+      r = (n, a) => n.localeCompare(a);
       break;
     case "stringer":
-      n = (s, a) => s.toString().localeCompare(a.toString());
+      r = (n, a) => n.toString().localeCompare(a.toString());
       break;
     case "number":
-      n = (s, a) => Number(s) - Number(a);
+      r = (n, a) => Number(n) - Number(a);
       break;
     case "bigint":
-      n = (s, a) => BigInt(s) - BigInt(a) > 0n ? 1 : -1;
+      r = (n, a) => BigInt(n) - BigInt(a) > 0n ? 1 : -1;
       break;
     case "boolean":
-      n = (s, a) => Number(s) - Number(a);
+      r = (n, a) => Number(n) - Number(a);
       break;
     case "undefined":
-      n = () => 0;
+      r = () => 0;
       break;
     default:
       return console.warn(`sortFunc: unknown type ${t}`), () => -1;
   }
-  return e ? It(n) : n;
-}, It = (r) => (e, t) => r(t, e), ae = i.tuple([i.number(), i.number()]);
+  return e ? As(r) : r;
+}, As = (s) => (e, t) => s(t, e), we = i.tuple([i.number(), i.number()]);
 i.tuple([i.bigint(), i.bigint()]);
-const Je = i.object({ width: i.number(), height: i.number() }), Nt = i.object({
+const yt = i.object({ width: i.number(), height: i.number() }), Bs = i.object({
   signedWidth: i.number(),
   signedHeight: i.number()
-}), Et = ["width", "height"];
-i.enum(Et);
-const At = ["start", "center", "end"], xt = ["signedWidth", "signedHeight"];
-i.enum(xt);
-const se = i.object({ x: i.number(), y: i.number() }), Mt = i.object({ clientX: i.number(), clientY: i.number() }), $t = ["x", "y"], He = i.enum($t), Ke = ["top", "right", "bottom", "left"];
-i.enum(Ke);
-const Ut = ["left", "right"], Xe = i.enum(Ut), Bt = ["top", "bottom"], Qe = i.enum(Bt), _e = ["center"], Ee = i.enum(_e), Rt = [...Ke, ..._e], et = i.enum(Rt);
-i.enum(At);
-const Ct = ["first", "last"];
-i.enum(Ct);
-const Dt = i.object({ lower: i.number(), upper: i.number() }), Lt = i.object({ lower: i.bigint(), upper: i.bigint() });
-i.union([Dt, ae]);
-i.union([Lt, ae]);
-i.enum([...He.options, ...et.options]);
-i.union([He, et, i.instanceof(String)]);
-const Pt = (r) => typeof r == "bigint" || r instanceof BigInt, F = (r, e) => Pt(r) ? r.valueOf() * BigInt(e.valueOf()) : r.valueOf() * Number(e.valueOf()), q = (r, e) => {
+}), $s = ["width", "height"];
+i.enum($s);
+const Ms = ["start", "center", "end"], Cs = ["signedWidth", "signedHeight"];
+i.enum(Cs);
+const pe = i.object({ x: i.number(), y: i.number() }), Rs = i.object({ clientX: i.number(), clientY: i.number() }), Ds = ["x", "y"], wt = i.enum(Ds), mt = ["top", "right", "bottom", "left"];
+i.enum(mt);
+const Ls = ["left", "right"], bt = i.enum(Ls), ks = ["top", "bottom"], vt = i.enum(ks), Tt = ["center"], Ve = i.enum(Tt), Ps = [...mt, ...Tt], Ot = i.enum(Ps);
+i.enum(Ms);
+const js = ["first", "last"];
+i.enum(js);
+const Fs = i.object({ lower: i.number(), upper: i.number() }), zs = i.object({ lower: i.bigint(), upper: i.bigint() });
+i.union([Fs, we]);
+i.union([zs, we]);
+i.enum([...wt.options, ...Ot.options]);
+i.union([wt, Ot, i.instanceof(String)]);
+const Ys = (s) => typeof s == "bigint" || s instanceof BigInt, W = (s, e) => Ys(s) ? s.valueOf() * BigInt(e.valueOf()) : s.valueOf() * Number(e.valueOf()), z = (s, 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 Ae(r);
-  return Ae(t);
-}, Ae = (r) => r.lower > r.upper ? { lower: r.upper, upper: r.lower } : r, xe = (r, e) => {
-  const t = q(r);
+  if (typeof s == "number" || typeof s == "bigint")
+    e != null ? (t.lower = s, t.upper = e) : (t.lower = typeof s == "bigint" ? 0n : 0, t.upper = s);
+  else if (Array.isArray(s)) {
+    if (s.length !== 2) throw new Error("bounds: expected array of length 2");
+    [t.lower, t.upper] = s;
+  } else return He(s);
+  return He(t);
+}, He = (s) => s.lower > s.upper ? { lower: s.upper, upper: s.lower } : s, Ze = (s, e) => {
+  const t = z(s);
   return e < t.lower ? t.lower : e >= t.upper ? t.upper - (typeof t.upper == "number" ? 1 : 1n) : e;
 };
 i.object({
-  x: Xe.or(Ee),
-  y: Qe.or(Ee)
+  x: bt.or(Ve),
+  y: vt.or(Ve)
 });
-const Yt = i.object({ x: Xe, y: Qe }), kt = Object.freeze({ x: "left", y: "top" }), jt = (r, e) => r.x === e.x && r.y === e.y, Me = i.union([
+const Ws = i.object({ x: bt, y: vt }), qs = Object.freeze({ x: "left", y: "top" }), Vs = (s, e) => s.x === e.x && s.y === e.y, Ge = i.union([
   i.number(),
-  se,
-  ae,
-  Je,
-  Nt,
-  Mt
-]), qt = (r, e) => {
-  if (typeof r == "string") {
+  pe,
+  we,
+  yt,
+  Bs,
+  Rs
+]), Hs = (s, e) => {
+  if (typeof s == "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 s === "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 };
-}, $e = Object.freeze({ x: 0, y: 0 }), ee = i.union([i.number(), i.string()]);
+  return typeof s == "number" ? { x: s, y: e ?? s } : Array.isArray(s) ? { x: s[0], y: s[1] } : "signedWidth" in s ? { x: s.signedWidth, y: s.signedHeight } : "clientX" in s ? { x: s.clientX, y: s.clientY } : "width" in s ? { x: s.width, y: s.height } : { x: s.x, y: s.y };
+}, Ke = Object.freeze({ x: 0, y: 0 }), le = i.union([i.number(), i.string()]);
 i.object({
-  top: ee,
-  left: ee,
-  width: ee,
-  height: ee
+  top: le,
+  left: le,
+  width: le,
+  height: le
 });
 i.object({
   left: i.number(),
@@ -205,63 +1177,63 @@ i.object({
   bottom: i.number()
 });
 i.object({
-  one: se,
-  two: se,
-  root: Yt
+  one: pe,
+  two: pe,
+  root: Ws
 });
-const Oe = (r, e, t = 0, n = 0, s) => {
+const Pe = (s, e, t = 0, r = 0, n) => {
   const a = {
-    one: { ...$e },
-    two: { ...$e },
-    root: s ?? kt
+    one: { ...Ke },
+    two: { ...Ke },
+    root: n ?? qs
   };
-  if (typeof r == "number") {
+  if (typeof s == "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 a.one = { x: s, y: e }, a.two = { x: a.one.x + t, y: a.one.y + r }, a;
   }
-  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 = {
+  return "one" in s && "two" in s && "root" in s ? { ...s, root: n ?? s.root } : ("getBoundingClientRect" in s && (s = s.getBoundingClientRect()), "left" in s ? (a.one = { x: s.left, y: s.top }, a.two = { x: s.right, y: s.bottom }, a) : (a.one = s, e == null ? a.two = { x: a.one.x + t, y: a.one.y + r } : 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));
-}, le = (r) => {
-  const e = Oe(r);
+}, Te = (s) => {
+  const e = Pe(s);
   return { lower: e.one.x, upper: e.two.x };
-}, he = (r) => {
-  const e = Oe(r);
+}, Oe = (s) => {
+  const e = Pe(s);
   return { lower: e.one.y, upper: e.two.y };
-}, Ft = (r) => typeof r != "object" || r == null ? !1 : "one" in r && "two" in r && "root" in r, Gt = i.object({ signedWidth: i.number(), signedHeight: i.number() });
-i.union([Je, Gt, se, ae]);
-var Wt = Object.defineProperty, Vt = (r, e, t) => e in r ? Wt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, L = (r, e, t) => Vt(r, typeof e != "symbol" ? e + "" : e, t);
-const zt = (r, e, t) => e !== void 0 && r < e ? e : t !== void 0 && r > t ? t : r;
-i.object({ offset: Me, scale: Me });
+}, Zs = (s) => typeof s != "object" || s == null ? !1 : "one" in s && "two" in s && "root" in s, Gs = i.object({ signedWidth: i.number(), signedHeight: i.number() });
+i.union([yt, Gs, pe, we]);
+var Ks = Object.defineProperty, Js = (s, e, t) => e in s ? Ks(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, k = (s, e, t) => Js(s, typeof e != "symbol" ? e + "" : e, t);
+const Xs = (s, e, t) => e !== void 0 && s < e ? e : t !== void 0 && s > t ? t : s;
+i.object({ offset: Ge, scale: Ge });
 i.object({ offset: i.number(), scale: i.number() });
-const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
+const Qs = (s) => (e, t, r, n) => t === "dimension" ? [e, r] : [
   e,
-  s ? n - r : n + r
-], Jt = (r) => (e, t, n, s) => [
+  n ? r - s : r + s
+], _s = (s) => (e, t, r, n) => [
   e,
-  s ? n / r : n * r
-], Ht = (r) => (e, t, n) => {
-  if (e === null) return [r, n];
-  const { lower: s, upper: a } = e, { lower: c, upper: f } = r, d = a - s, p = f - c;
-  if (t === "dimension") return [r, n * (p / d)];
-  const m = (n - s) * (p / d) + c;
-  return [r, m];
-}, Kt = (r) => (e, t, n) => [r, n], Xt = () => (r, e, t) => {
-  if (r === null) throw new Error("cannot invert without bounds");
-  if (e === "dimension") return [r, t];
-  const { lower: n, upper: s } = r;
-  return [r, s - (t - n)];
-}, Qt = (r) => (e, t, n) => {
-  const { lower: s, upper: a } = r;
-  return n = zt(n, s, a), [e, n];
-}, ge = class z {
+  n ? r / s : r * s
+], er = (s) => (e, t, r) => {
+  if (e === null) return [s, r];
+  const { lower: n, upper: a } = e, { lower: o, upper: c } = s, d = a - n, p = c - o;
+  if (t === "dimension") return [s, r * (p / d)];
+  const y = (r - n) * (p / d) + o;
+  return [s, y];
+}, tr = (s) => (e, t, r) => [s, r], sr = () => (s, e, t) => {
+  if (s === null) throw new Error("cannot invert without bounds");
+  if (e === "dimension") return [s, t];
+  const { lower: r, upper: n } = s;
+  return [s, n - (t - r)];
+}, rr = (s) => (e, t, r) => {
+  const { lower: n, upper: a } = s;
+  return r = Xs(r, n, a), [e, r];
+}, Ee = class _ {
   constructor() {
-    L(this, "ops", []), L(this, "currBounds", null), L(this, "currType", null), L(this, "reversed", !1), this.ops = [];
+    k(this, "ops", []), k(this, "currBounds", null), k(this, "currType", null), k(this, "reversed", !1), this.ops = [];
   }
   /**
    * @returns a new scale with a translation as its first operation. Any number provided
@@ -269,7 +1241,7 @@ const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
    * @param value - The amount to translate by.
    */
   static translate(e) {
-    return new z().translate(e);
+    return new _().translate(e);
   }
   /**
    * @returns a new scale with a magnification as its first operation. Any number provided
@@ -277,10 +1249,10 @@ const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
    * @param value - The amount to translate by.
    */
   static magnify(e) {
-    return new z().magnify(e);
+    return new _().magnify(e);
   }
   static scale(e, t) {
-    return new z().scale(e, t);
+    return new _().scale(e, t);
   }
   /**
    * @returns a copy of the scale with a translation as its next operation. Any
@@ -289,8 +1261,8 @@ const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
    * @param value - The amount to translate by.
    */
   translate(e) {
-    const t = this.new(), n = Zt(e);
-    return n.type = "translate", t.ops.push(n), t;
+    const t = this.new(), r = Qs(e);
+    return r.type = "translate", t.ops.push(r), t;
   }
   /**
    * @returns a copy of the scale with a translation as its next operation. Any number
@@ -299,23 +1271,23 @@ const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
    * @param value - The amount to magnify by.
    */
   magnify(e) {
-    const t = this.new(), n = Jt(e);
-    return n.type = "magnify", t.ops.push(n), t;
+    const t = this.new(), r = _s(e);
+    return r.type = "magnify", t.ops.push(r), t;
   }
   scale(e, t) {
-    const n = q(e, t), s = this.new(), a = Ht(n);
-    return a.type = "scale", s.ops.push(a), s;
+    const r = z(e, t), n = this.new(), a = er(r);
+    return a.type = "scale", n.ops.push(a), n;
   }
   clamp(e, t) {
-    const n = q(e, t), s = this.new(), a = Qt(n);
-    return a.type = "clamp", s.ops.push(a), s;
+    const r = z(e, t), n = this.new(), a = rr(r);
+    return a.type = "clamp", n.ops.push(a), n;
   }
   reBound(e, t) {
-    const n = q(e, t), s = this.new(), a = Kt(n);
-    return a.type = "re-bound", s.ops.push(a), s;
+    const r = z(e, t), n = this.new(), a = tr(r);
+    return a.type = "re-bound", n.ops.push(a), n;
   }
   invert() {
-    const e = Xt();
+    const e = sr();
     e.type = "invert";
     const t = this.new();
     return t.ops.push(e), t;
@@ -327,12 +1299,12 @@ const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
     return this.exec("dimension", e);
   }
   new() {
-    const e = new z();
+    const e = new _();
     return e.ops = this.ops.slice(), e.reversed = this.reversed, e;
   }
   exec(e, t) {
     return this.currBounds = null, this.ops.reduce(
-      ([n, s], a) => a(n, e, s, this.reversed),
+      ([r, n], a) => a(r, e, n, this.reversed),
       [null, t]
     )[1];
   }
@@ -340,50 +1312,50 @@ const Zt = (r) => (e, t, n, s) => t === "dimension" ? [e, n] : [
     const e = this.new();
     e.ops.reverse();
     const t = [];
-    return e.ops.forEach((n, s) => {
-      if (n.type === "scale" || t.some(([c, f]) => s >= c && s <= f))
+    return e.ops.forEach((r, n) => {
+      if (r.type === "scale" || t.some(([o, c]) => n >= o && n <= c))
         return;
-      const a = e.ops.findIndex((c, f) => c.type === "scale" && f > 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);
+      const a = e.ops.findIndex((o, c) => o.type === "scale" && c > n);
+      a !== -1 && t.push([n, a]);
+    }), t.forEach(([r, n]) => {
+      const a = e.ops.slice(r, n);
+      a.unshift(e.ops[n]), e.ops.splice(r, n - r + 1, ...a);
     }), e.reversed = !e.reversed, e;
   }
   get transform() {
     return { scale: this.dim(1), offset: this.pos(0) };
   }
 };
-L(ge, "IDENTITY", new ge());
-let Ue = ge;
-const Be = class D {
-  constructor(e = new Ue(), t = new Ue(), n = null) {
-    L(this, "x"), L(this, "y"), L(this, "currRoot"), this.x = e, this.y = t, this.currRoot = n;
+k(Ee, "IDENTITY", new Ee());
+let Je = Ee;
+const Xe = class L {
+  constructor(e = new Je(), t = new Je(), r = null) {
+    k(this, "x"), k(this, "y"), k(this, "currRoot"), this.x = e, this.y = t, this.currRoot = r;
   }
   static translate(e, t) {
-    return new D().translate(e, t);
+    return new L().translate(e, t);
   }
   static translateX(e) {
-    return new D().translateX(e);
+    return new L().translateX(e);
   }
   static translateY(e) {
-    return new D().translateY(e);
+    return new L().translateY(e);
   }
   static clamp(e) {
-    return new D().clamp(e);
+    return new L().clamp(e);
   }
   static magnify(e) {
-    return new D().magnify(e);
+    return new L().magnify(e);
   }
   static scale(e) {
-    return new D().scale(e);
+    return new L().scale(e);
   }
   static reBound(e) {
-    return new D().reBound(e);
+    return new L().reBound(e);
   }
   translate(e, t) {
-    const n = qt(e, t), s = this.copy();
-    return s.x = this.x.translate(n.x), s.y = this.y.translate(n.y), s;
+    const r = Hs(e, t), n = this.copy();
+    return n.x = this.x.translate(r.x), n.y = this.y.translate(r.y), n;
   }
   translateX(e) {
     const t = this.copy();
@@ -399,22 +1371,22 @@ const Be = class D {
   }
   scale(e) {
     const t = this.copy();
-    if (Ft(e)) {
-      const n = this.currRoot;
-      return t.currRoot = e.root, n != null && !jt(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(le(e)), t.y = t.y.scale(he(e)), t;
+    if (Zs(e)) {
+      const r = this.currRoot;
+      return t.currRoot = e.root, r != null && !Vs(r, e.root) && (r.x !== e.root.x && (t.x = t.x.invert()), r.y !== e.root.y && (t.y = t.y.invert())), t.x = t.x.scale(Te(e)), t.y = t.y.scale(Oe(e)), t;
     }
     return t.x = t.x.scale(e.width), t.y = t.y.scale(e.height), t;
   }
   reBound(e) {
     const t = this.copy();
-    return t.x = this.x.reBound(le(e)), t.y = this.y.reBound(he(e)), t;
+    return t.x = this.x.reBound(Te(e)), t.y = this.y.reBound(Oe(e)), t;
   }
   clamp(e) {
     const t = this.copy();
-    return t.x = this.x.clamp(le(e)), t.y = this.y.clamp(he(e)), t;
+    return t.x = this.x.clamp(Te(e)), t.y = this.y.clamp(Oe(e)), t;
   }
   copy() {
-    const e = new D();
+    const e = new L();
     return e.currRoot = this.currRoot, e.x = this.x, e.y = this.y, e;
   }
   reverse() {
@@ -428,7 +1400,7 @@ const Be = class D {
     return { x: this.x.dim(e.x), y: this.y.dim(e.y) };
   }
   box(e) {
-    return Oe(
+    return Pe(
       this.pos(e.one),
       this.pos(e.two),
       0,
@@ -443,66 +1415,63 @@ const Be = class D {
     };
   }
 };
-L(Be, "IDENTITY", new Be());
-var _t = Object.defineProperty, er = (r, e, t) => e in r ? _t(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, u = (r, e, t) => er(r, typeof e != "symbol" ? e + "" : e, t);
-let tr = (r, e = 21) => (t = e) => {
-  let n = "", s = t | 0;
-  for (; s--; )
-    n += r[Math.random() * r.length | 0];
-  return n;
+k(Xe, "IDENTITY", new Xe());
+var nr = Object.defineProperty, ir = (s, e, t) => e in s ? nr(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, h = (s, e, t) => ir(s, typeof e != "symbol" ? e + "" : e, t);
+let ar = (s, e = 21) => (t = e) => {
+  let r = "", n = t | 0;
+  for (; n--; )
+    r += s[Math.random() * s.length | 0];
+  return r;
 };
-const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr = tr(rr, 11), sr = () => nr(), ir = i.enum(["static", "dynamic"]), tt = (r, e) => {
-  const t = new v(e);
+const or = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", hr = ar(or, 11), ur = () => hr(), cr = i.enum(["static", "dynamic"]), St = (s, e) => {
+  const t = new T(e);
   if (![
-    O.DAY,
-    O.HOUR,
-    O.MINUTE,
-    O.SECOND,
-    O.MILLISECOND,
-    O.MICROSECOND,
-    O.NANOSECOND
-  ].some((s) => s.equals(t)))
+    w.DAY,
+    w.HOUR,
+    w.MINUTE,
+    w.SECOND,
+    w.MILLISECOND,
+    w.MICROSECOND,
+    w.NANOSECOND
+  ].some((n) => n.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 v ? new v(n) : new O(n);
-}, w = class h {
+  const r = s.valueOf() % t.valueOf();
+  return s instanceof T ? new T(r) : new w(r);
+}, m = class f {
   constructor(e, t = "UTC") {
-    if (u(this, "value"), u(this, "encodeValue", !0), e == null) this.value = h.now().valueOf();
+    if (h(this, "value"), h(this, "encodeValue", !0), e == null) this.value = f.now().valueOf();
     else if (e instanceof Date)
-      this.value = BigInt(e.getTime()) * h.MILLISECOND.valueOf();
+      this.value = BigInt(e.getTime()) * f.MILLISECOND.valueOf();
     else if (typeof e == "string")
-      this.value = h.parseDateTimeString(e, t).valueOf();
-    else if (Array.isArray(e)) this.value = h.parseDate(e);
+      this.value = f.parseDateTimeString(e, t).valueOf();
+    else if (Array.isArray(e)) this.value = f.parseDate(e);
     else {
-      let n = BigInt(0);
-      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;
+      let r = BigInt(0);
+      e instanceof Number && (e = e.valueOf()), t === "local" && (r = f.utcOffset.valueOf()), typeof e == "number" && (isFinite(e) ? e = Math.trunc(e) : (isNaN(e) && (e = 0), e === 1 / 0 ? e = f.MAX : e = f.MIN)), this.value = BigInt(e.valueOf()) + r;
     }
   }
-  static parseDate([e = 1970, t = 1, n = 1]) {
-    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();
+  static parseDate([e = 1970, t = 1, r = 1]) {
+    const n = new Date(e, t - 1, r, 0, 0, 0, 0);
+    return new f(BigInt(n.getTime()) * f.MILLISECOND.valueOf()).truncate(f.DAY).valueOf();
   }
   valueOf() {
     return this.value;
   }
   static parseTimeString(e, t = "UTC") {
-    const [n, s, a] = e.split(":");
-    let c = "00", f = "00";
-    a != null && ([c, f] = a.split("."));
-    let d = h.hours(parseInt(n ?? "00")).add(h.minutes(parseInt(s ?? "00"))).add(h.seconds(parseInt(c ?? "00"))).add(h.milliseconds(parseInt(f ?? "00")));
-    return t === "local" && (d = d.add(h.utcOffset)), d.valueOf();
+    const [r, n, a] = e.split(":");
+    let o = "00", c = "00";
+    a != null && ([o, c] = a.split("."));
+    let d = f.hours(parseInt(r ?? "00")).add(f.minutes(parseInt(n ?? "00"))).add(f.seconds(parseInt(o ?? "00"))).add(f.milliseconds(parseInt(c ?? "00")));
+    return t === "local" && (d = d.add(f.utcOffset)), d.valueOf();
   }
   static parseDateTimeString(e, t = "UTC") {
     if (!e.includes("/") && !e.includes("-"))
-      return h.parseTimeString(e, t);
-    const n = new Date(e);
-    return e.includes(":") || n.setUTCHours(0, 0, 0, 0), new h(
-      BigInt(n.getTime()) * h.MILLISECOND.valueOf(),
+      return f.parseTimeString(e, t);
+    const r = new Date(e);
+    return e.includes(":") || r.setUTCHours(0, 0, 0, 0), new f(
+      BigInt(r.getTime()) * f.MILLISECOND.valueOf(),
       t
     ).valueOf();
   }
@@ -527,19 +1496,19 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
     }
   }
   toISOString(e = "UTC") {
-    return e === "UTC" ? this.date().toISOString() : this.sub(h.utcOffset).date().toISOString();
+    return e === "UTC" ? this.date().toISOString() : this.sub(f.utcOffset).date().toISOString();
   }
   timeString(e = !1, t = "UTC") {
-    const n = this.toISOString(t);
-    return e ? n.slice(11, 23) : n.slice(11, 19);
+    const r = this.toISOString(t);
+    return e ? r.slice(11, 23) : r.slice(11, 19);
   }
   dateString() {
-    const e = this.date(), t = e.toLocaleString("default", { month: "short" }), n = e.toLocaleString("default", { day: "numeric" });
-    return `${t} ${n}`;
+    const e = this.date(), t = e.toLocaleString("default", { month: "short" }), r = e.toLocaleString("default", { day: "numeric" });
+    return `${t} ${r}`;
   }
   static get utcOffset() {
-    return new O(
-      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * h.MINUTE.valueOf()
+    return new w(
+      BigInt((/* @__PURE__ */ new Date()).getTimezoneOffset()) * f.MINUTE.valueOf()
     );
   }
   /**
@@ -548,7 +1517,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    * @param other - The other timestamp.
    */
   static since(e) {
-    return new h().span(e);
+    return new f().span(e);
   }
   /** @returns A JavaScript Date object representing the TimeStamp. */
   date() {
@@ -561,7 +1530,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    * @returns True if the TimeStamps are equal, false otherwise.
    */
   equals(e) {
-    return this.valueOf() === new h(e).valueOf();
+    return this.valueOf() === new f(e).valueOf();
   }
   /**
    * Creates a TimeSpan representing the duration between the two timestamps.
@@ -581,7 +1550,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   valid, regardless of the TimeStamp order.
    */
   range(e) {
-    return new Te(this, e).makeValid();
+    return new ae(this, e).makeValid();
   }
   /**
    * Creates a TimeRange starting at the TimeStamp and spanning the given
@@ -610,7 +1579,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   otherwise.
    */
   after(e) {
-    return this.valueOf() > new h(e).valueOf();
+    return this.valueOf() > new f(e).valueOf();
   }
   /**
    * Checks if the TimeStamp is after or equal to the given TimeStamp.
@@ -620,7 +1589,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   false otherwise.
    */
   afterEq(e) {
-    return this.valueOf() >= new h(e).valueOf();
+    return this.valueOf() >= new f(e).valueOf();
   }
   /**
    * Checks if the TimeStamp is before the given TimeStamp.
@@ -630,7 +1599,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   otherwise.
    */
   before(e) {
-    return this.valueOf() < new h(e).valueOf();
+    return this.valueOf() < new f(e).valueOf();
   }
   /**
    * Checks if TimeStamp is before or equal to the current timestamp.
@@ -640,7 +1609,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   false otherwise.
    */
   beforeEq(e) {
-    return this.valueOf() <= new h(e).valueOf();
+    return this.valueOf() <= new f(e).valueOf();
   }
   /**
    * Adds a TimeSpan to the TimeStamp.
@@ -650,7 +1619,7 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   TimeSpan.
    */
   add(e) {
-    return new h(this.valueOf() + BigInt(e.valueOf()));
+    return new f(this.valueOf() + BigInt(e.valueOf()));
   }
   /**
    * Subtracts a TimeSpan from the TimeStamp.
@@ -660,45 +1629,49 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    *   TimeSpan.
    */
   sub(e) {
-    return new h(this.valueOf() - BigInt(e.valueOf()));
+    return new f(this.valueOf() - BigInt(e.valueOf()));
   }
   /**
    * @returns the floating point number of hours since the unix epoch to the timestamp
    * value.
    */
   get hours() {
-    return Number(this.valueOf()) / Number(O.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(w.HOUR.valueOf());
   }
   /**
    * @returns the floating point number of minutes since the unix epoch to the timestamp
    * value.
    */
   get minutes() {
-    return Number(this.valueOf()) / Number(O.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(w.MINUTE.valueOf());
   }
   /**
    * @returns the floating point number of days since the unix epoch to the timestamp
    * value.
    */
   get days() {
-    return Number(this.valueOf()) / Number(O.DAY.valueOf());
+    return Number(this.valueOf()) / Number(w.DAY.valueOf());
   }
   /**
    * @returns the floating point number of seconds since the unix epoch to the timestamp
    * value.
    */
   get seconds() {
-    return Number(this.valueOf()) / Number(O.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(w.SECOND.valueOf());
   }
-  /**
-   * @returns The number of milliseconds since the unix epoch.
-   */
+  /** @returns the floating point number of milliseconds since the unix epoch. */
   get milliseconds() {
-    return Number(this.valueOf()) / Number(h.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(f.MILLISECOND.valueOf());
   }
+  /** @returns the floating point number of microseconds since the unix epoch */
   get microseconds() {
-    return Number(this.valueOf()) / Number(h.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(f.MICROSECOND.valueOf());
   }
+  /**
+   * @returns the floating point number of nanoseconds since the unix epoch.
+   * Note that since we're converting to float64, this reduces the resolution
+   * to a quarter of a microsecond.
+   */
   get nanoseconds() {
     return Number(this.valueOf());
   }
@@ -706,63 +1679,102 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
   get year() {
     return this.date().getFullYear();
   }
+  /**
+   * @returns a copy of the timestamp with the year changed.
+   * @param year the value to set the year to.
+   */
   setYear(e) {
     const t = this.date();
-    return t.setFullYear(e), new h(t);
+    return t.setFullYear(e), new f(t);
   }
   /** @returns the integer month that the timestamp corresponds to with its year. */
   get month() {
-    return this.date().getMonth();
+    return this.date().getUTCMonth();
   }
+  /**
+   * @returns a copy of the timestamp with the month changed.
+   * @param month the value to set the month to.
+   */
   setMonth(e) {
     const t = this.date();
-    return t.setMonth(e), new h(t);
+    return t.setUTCMonth(e), new f(t);
   }
   /** @returns the integer day that the timestamp corresponds to within its month. */
   get day() {
-    return this.date().getDate();
+    return this.date().getUTCDate();
   }
+  /**
+   * @returns a copy of the timestamp with the day changed.
+   * @param day the value the set the day to.
+   */
   setDay(e) {
     const t = this.date();
-    return t.setDate(e), new h(t);
+    return t.setUTCDate(e), new f(t);
   }
-  /** @returns the integer hour that the timestamp corresponds to within its day. */
+  /**
+   * @returns the integer hour that the timestamp corresponds to within its day.
+   */
   get hour() {
-    return this.date().getHours();
+    return this.date().getUTCHours();
   }
+  /**
+   * @returns a copy of the timestamp with the hour changed.
+   * @param hour the value to set the hour to.
+   */
   setHour(e) {
     const t = this.date();
-    return t.setHours(e), new h(t);
+    return t.setUTCHours(e), new f(t, "UTC");
   }
   /** @returns the integer minute that the timestamp corresponds to within its hour. */
   get minute() {
     return this.date().getMinutes();
   }
+  /**
+   * @returns a copy of the timestamp with the minute changed.
+   * @param minute the value to set the minute to.
+   */
   setMinute(e) {
     const t = this.date();
-    return t.setMinutes(e), new h(t);
+    return t.setUTCMinutes(e), new f(t);
   }
+  /**
+   * @returns the integer second that the timestamp corresponds to within its
+   * minute.
+   */
   get second() {
     return this.date().getSeconds();
   }
+  /**
+   * @returns a copy of the timestamp with the second changed.
+   * @param second the value to set the second to.
+   */
   setSecond(e) {
     const t = this.date();
-    return t.setSeconds(e), new h(t);
+    return t.setUTCSeconds(e), new f(t);
   }
+  /**
+   * @reutrns the integer millisecond that the timestamp corresponds to within
+   * its second.
+   */
   get millisecond() {
     return this.date().getMilliseconds();
   }
+  /**
+   * @returns a copy of the timestamp with the milliseconds changed.
+   * @param millisecond the value to set the millisecond to.
+   */
   setMillisecond(e) {
     const t = this.date();
-    return t.setMilliseconds(e), new h(t);
+    return t.setMilliseconds(e), new f(t);
   }
+  /** @returns the time stamp formatted as an ISO string. */
   toString() {
     return this.date().toISOString();
   }
   /**
    * @returns A new TimeStamp that is the remainder of the TimeStamp divided by the
    * given span. This is useful in cases where you want only part of a TimeStamp's value
-   * i.e. the hours, minutes, seconds, milliseconds, microseconds, and nanoseconds but
+   * i.e., the hours, minutes, seconds, milliseconds, microseconds, and nanoseconds but
    * not the days, years, etc.
    *
    * @param divisor - The TimeSpan to divide by. Must be an even TimeSpan or TimeStamp. Even
@@ -771,11 +1783,11 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    * @example TimeStamp.now().remainder(TimeStamp.DAY) // => TimeStamp representing the current day
    */
   remainder(e) {
-    return tt(this, e);
+    return St(this, e);
   }
   /** @returns true if the day portion TimeStamp is today, false otherwise. */
   get isToday() {
-    return this.truncate(O.DAY).equals(h.now().truncate(O.DAY));
+    return this.truncate(w.DAY).equals(f.now().truncate(w.DAY));
   }
   truncate(e) {
     return this.sub(this.remainder(e));
@@ -786,80 +1798,82 @@ const rr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", nr
    * JavaScript can do).
    */
   static now() {
-    return new h(/* @__PURE__ */ new Date());
+    return new f(/* @__PURE__ */ new Date());
   }
+  /** @returns the maximum value of all the timestamps. */
   static max(...e) {
-    let t = h.MIN;
-    for (const n of e) {
-      const s = new h(n);
-      s.after(t) && (t = s);
+    let t = f.MIN;
+    for (const r of e) {
+      const n = new f(r);
+      n.after(t) && (t = n);
     }
     return t;
   }
+  /** @returns the minimum value of all the timestamps. */
   static min(...e) {
-    let t = h.MAX;
-    for (const n of e) {
-      const s = new h(n);
-      s.before(t) && (t = s);
+    let t = f.MAX;
+    for (const r of e) {
+      const n = new f(r);
+      n.before(t) && (t = n);
     }
     return t;
   }
   /** @returns a new TimeStamp n nanoseconds after the unix epoch */
-  static nanoseconds(e) {
-    return new h(e);
+  static nanoseconds(e, t = "UTC") {
+    return new f(e, t);
   }
   /** @returns a new TimeStamp n microseconds after the unix epoch */
-  static microseconds(e) {
-    return h.nanoseconds(e * 1e3);
+  static microseconds(e, t = "UTC") {
+    return f.nanoseconds(e * 1e3, t);
   }
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
-  static milliseconds(e) {
-    return h.microseconds(e * 1e3);
+  static milliseconds(e, t = "UTC") {
+    return f.microseconds(e * 1e3, t);
   }
   /** @returns a new TimeStamp n seconds after the unix epoch */
-  static seconds(e) {
-    return h.milliseconds(e * 1e3);
+  static seconds(e, t = "UTC") {
+    return f.milliseconds(e * 1e3, t);
   }
   /** @returns a new TimeStamp n minutes after the unix epoch */
-  static minutes(e) {
-    return h.seconds(e * 60);
+  static minutes(e, t = "UTC") {
+    return f.seconds(e * 60, t);
   }
   /** @returns a new TimeStamp n hours after the unix epoch */
-  static hours(e) {
-    return h.minutes(e * 60);
+  static hours(e, t = "UTC") {
+    return f.minutes(e * 60, t);
   }
   /** @returns a new TimeStamp n days after the unix epoch */
-  static days(e) {
-    return h.hours(e * 24);
+  static days(e, t = "UTC") {
+    return f.hours(e * 24, t);
   }
 };
-u(w, "NANOSECOND", w.nanoseconds(1)), /** One microsecond after the unix epoch */
-u(w, "MICROSECOND", w.microseconds(1)), /** One millisecond after the unix epoch */
-u(w, "MILLISECOND", w.milliseconds(1)), /** One second after the unix epoch */
-u(w, "SECOND", w.seconds(1)), /** One minute after the unix epoch */
-u(w, "MINUTE", w.minutes(1)), /** One hour after the unix epoch */
-u(w, "HOUR", w.hours(1)), /** One day after the unix epoch */
-u(w, "DAY", w.days(1)), /** The maximum possible value for a timestamp */
-u(w, "MAX", new w((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
-u(w, "MIN", new w(0)), /** The unix epoch */
-u(w, "ZERO", new w(0)), /** A zod schema for validating timestamps */
-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)
+h(m, "NANOSECOND", m.nanoseconds(1)), /** One microsecond after the unix epoch */
+h(m, "MICROSECOND", m.microseconds(1)), /** One millisecond after the unix epoch */
+h(m, "MILLISECOND", m.milliseconds(1)), /** One second after the unix epoch */
+h(m, "SECOND", m.seconds(1)), /** One minute after the unix epoch */
+h(m, "MINUTE", m.minutes(1)), /** One hour after the unix epoch */
+h(m, "HOUR", m.hours(1)), /** One day after the unix epoch */
+h(m, "DAY", m.days(1)), /** The maximum possible value for a timestamp */
+h(m, "MAX", new m((1n << 63n) - 1n)), /** The minimum possible value for a timestamp */
+h(m, "MIN", new m(0)), /** The unix epoch */
+h(m, "ZERO", new m(0)), /** A zod schema for validating timestamps */
+h(m, "z", i.union([
+  i.object({ value: i.bigint() }).transform((s) => new m(s.value)),
+  i.string().transform((s) => new m(BigInt(s))),
+  i.instanceof(Number).transform((s) => new m(s)),
+  i.number().transform((s) => new m(s)),
+  i.instanceof(m)
 ]));
-let v = w;
+let T = m;
 const b = class g {
   constructor(e) {
-    u(this, "value"), u(this, "encodeValue", !0), typeof e == "number" && (e = Math.trunc(e.valueOf())), this.value = BigInt(e.valueOf());
+    h(this, "value"), h(this, "encodeValue", !0), typeof e == "number" && (e = Math.trunc(e.valueOf())), this.value = BigInt(e.valueOf());
   }
   static fromSeconds(e) {
-    return e instanceof g ? e : e instanceof Re ? e.period : e instanceof v ? new g(e) : ["number", "bigint"].includes(typeof e) ? g.seconds(e) : new g(e);
+    return e instanceof g ? e : e instanceof Qe ? e.period : e instanceof T ? new g(e) : ["number", "bigint"].includes(typeof e) ? g.seconds(e) : new g(e);
   }
   static fromMilliseconds(e) {
-    return e instanceof g ? e : e instanceof Re ? e.period : e instanceof v ? new g(e) : ["number", "bigint"].includes(typeof e) ? g.milliseconds(e) : new g(e);
+    return e instanceof g ? e : e instanceof Qe ? e.period : e instanceof T ? new g(e) : ["number", "bigint"].includes(typeof e) ? g.milliseconds(e) : new g(e);
   }
   encode() {
     return this.value.toString();
@@ -880,7 +1894,7 @@ const b = class g {
     return this.valueOf() >= new g(e).valueOf();
   }
   remainder(e) {
-    return tt(this, e);
+    return St(this, e);
   }
   truncate(e) {
     return new g(
@@ -888,9 +1902,9 @@ const b = class g {
     );
   }
   toString() {
-    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), f = this.truncate(g.NANOSECOND), d = e, p = t.sub(e), m = n.sub(t), l = s.sub(n), N = a.sub(s), $ = c.sub(a), R = f.sub(c);
-    let M = "";
-    return d.isZero || (M += `${d.days}d `), p.isZero || (M += `${p.hours}h `), m.isZero || (M += `${m.minutes}m `), l.isZero || (M += `${l.seconds}s `), N.isZero || (M += `${N.milliseconds}ms `), $.isZero || (M += `${$.microseconds}µs `), R.isZero || (M += `${R.nanoseconds}ns`), M.trim();
+    const e = this.truncate(g.DAY), t = this.truncate(g.HOUR), r = this.truncate(g.MINUTE), n = this.truncate(g.SECOND), a = this.truncate(g.MILLISECOND), o = this.truncate(g.MICROSECOND), c = this.truncate(g.NANOSECOND), d = e, p = t.sub(e), y = r.sub(t), l = n.sub(r), U = a.sub(n), B = o.sub(a), D = c.sub(o);
+    let A = "";
+    return d.isZero || (A += `${d.days}d `), p.isZero || (A += `${p.hours}h `), y.isZero || (A += `${y.minutes}m `), l.isZero || (A += `${l.seconds}s `), U.isZero || (A += `${U.milliseconds}ms `), B.isZero || (A += `${B.microseconds}µs `), D.isZero || (A += `${D.nanoseconds}ns`), A.trim();
   }
   mult(e) {
     return new g(this.valueOf() * BigInt(e));
@@ -969,7 +1983,7 @@ const b = class g {
    * @returns A TimeSpan representing the given number of microseconds.
    */
   static microseconds(e = 1) {
-    return g.nanoseconds(F(e, 1e3));
+    return g.nanoseconds(W(e, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of milliseconds.
@@ -978,7 +1992,7 @@ const b = class g {
    * @returns A TimeSpan representing the given number of milliseconds.
    */
   static milliseconds(e = 1) {
-    return g.microseconds(F(e, 1e3));
+    return g.microseconds(W(e, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of seconds.
@@ -987,7 +2001,7 @@ const b = class g {
    * @returns A TimeSpan representing the given number of seconds.
    */
   static seconds(e = 1) {
-    return g.milliseconds(F(e, 1e3));
+    return g.milliseconds(W(e, 1e3));
   }
   /**
    * Creates a TimeSpan representing the given number of minutes.
@@ -996,7 +2010,7 @@ const b = class g {
    * @returns A TimeSpan representing the given number of minutes.
    */
   static minutes(e = 1) {
-    return g.seconds(F(e, 60));
+    return g.seconds(W(e, 60));
   }
   /**
    * Creates a TimeSpan representing the given number of hours.
@@ -1005,7 +2019,7 @@ const b = class g {
    * @returns A TimeSpan representing the given number of hours.
    */
   static hours(e) {
-    return g.minutes(F(e, 60));
+    return g.minutes(W(e, 60));
   }
   /**
    * Creates a TimeSpan representing the given number of days.
@@ -1014,28 +2028,28 @@ const b = class g {
    * @returns A TimeSpan representing the given number of days.
    */
   static days(e) {
-    return g.hours(F(e, 24));
+    return g.hours(W(e, 24));
   }
 };
-u(b, "NANOSECOND", b.nanoseconds(1)), /** A microsecond. */
-u(b, "MICROSECOND", b.microseconds(1)), /** A millisecond. */
-u(b, "MILLISECOND", b.milliseconds(1)), /** A second. */
-u(b, "SECOND", b.seconds(1)), /** A minute. */
-u(b, "MINUTE", b.minutes(1)), /** Represents an hour. */
-u(b, "HOUR", b.hours(1)), /** Represents a day. */
-u(b, "DAY", b.days(1)), /** The maximum possible value for a TimeSpan. */
-u(b, "MAX", new b((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
-u(b, "MIN", new b(0)), /** The zero value for a TimeSpan. */
-u(b, "ZERO", new b(0)), /** A zod schema for validating and transforming timespans */
-u(b, "z", i.union([
-  i.object({ value: i.bigint() }).transform((r) => new b(r.value)),
-  i.string().transform((r) => new b(BigInt(r))),
-  i.instanceof(Number).transform((r) => new b(r)),
-  i.number().transform((r) => new b(r)),
+h(b, "NANOSECOND", b.nanoseconds(1)), /** A microsecond. */
+h(b, "MICROSECOND", b.microseconds(1)), /** A millisecond. */
+h(b, "MILLISECOND", b.milliseconds(1)), /** A second. */
+h(b, "SECOND", b.seconds(1)), /** A minute. */
+h(b, "MINUTE", b.minutes(1)), /** Represents an hour. */
+h(b, "HOUR", b.hours(1)), /** Represents a day. */
+h(b, "DAY", b.days(1)), /** The maximum possible value for a TimeSpan. */
+h(b, "MAX", new b((1n << 63n) - 1n)), /** The minimum possible value for a TimeSpan. */
+h(b, "MIN", new b(0)), /** The zero value for a TimeSpan. */
+h(b, "ZERO", new b(0)), /** A zod schema for validating and transforming timespans */
+h(b, "z", i.union([
+  i.object({ value: i.bigint() }).transform((s) => new b(s.value)),
+  i.string().transform((s) => new b(BigInt(s))),
+  i.instanceof(Number).transform((s) => new b(s)),
+  i.number().transform((s) => new b(s)),
   i.instanceof(b)
 ]));
-let O = b;
-const Z = class re extends Number {
+let w = b;
+const ee = class ge extends Number {
   constructor(e) {
     e instanceof Number ? super(e.valueOf()) : super(e);
   }
@@ -1045,7 +2059,7 @@ const Z = class re extends Number {
   }
   /** @returns The number of seconds in the Rate. */
   equals(e) {
-    return this.valueOf() === new re(e).valueOf();
+    return this.valueOf() === new ge(e).valueOf();
   }
   /**
    * Calculates the period of the Rate as a TimeSpan.
@@ -1053,7 +2067,7 @@ const Z = class re extends Number {
    * @returns A TimeSpan representing the period of the Rate.
    */
   get period() {
-    return O.seconds(1 / this.valueOf());
+    return w.seconds(1 / this.valueOf());
   }
   /**
    * Calculates the number of samples in the given TimeSpan at this rate.
@@ -1062,7 +2076,7 @@ const Z = class re extends Number {
    * @returns The number of samples in the given TimeSpan at this rate.
    */
   sampleCount(e) {
-    return new O(e).seconds * this.valueOf();
+    return new w(e).seconds * this.valueOf();
   }
   /**
    * Calculates the number of bytes in the given TimeSpan at this rate.
@@ -1072,7 +2086,7 @@ const Z = class re extends Number {
    * @returns The number of bytes in the given TimeSpan at this rate.
    */
   byteCount(e, t) {
-    return this.sampleCount(e) * new x(t).valueOf();
+    return this.sampleCount(e) * new E(t).valueOf();
   }
   /**
    * Calculates a TimeSpan given the number of samples at this rate.
@@ -1081,7 +2095,7 @@ const Z = class re extends Number {
    * @returns A TimeSpan that corresponds to the given number of samples.
    */
   span(e) {
-    return O.seconds(e / this.valueOf());
+    return w.seconds(e / this.valueOf());
   }
   /**
    * Calculates a TimeSpan given the number of bytes at this rate.
@@ -1100,7 +2114,7 @@ const Z = class re extends Number {
    * @returns A Rate representing the given number of Hz.
    */
   static hz(e) {
-    return new re(e);
+    return new ge(e);
   }
   /**
    * Creates a Rate representing the given number of kHz.
@@ -1109,16 +2123,16 @@ const Z = class re extends Number {
    * @returns A Rate representing the given number of kHz.
    */
   static khz(e) {
-    return re.hz(e * 1e3);
+    return ge.hz(e * 1e3);
   }
 };
-u(Z, "z", i.union([
-  i.number().transform((r) => new Z(r)),
-  i.instanceof(Number).transform((r) => new Z(r)),
-  i.instanceof(Z)
+h(ee, "z", i.union([
+  i.number().transform((s) => new ee(s)),
+  i.instanceof(Number).transform((s) => new ee(s)),
+  i.instanceof(ee)
 ]));
-let Re = Z;
-const E = class extends Number {
+let Qe = ee;
+const x = class extends Number {
   /**
    * Creates a Density representing the given number of bytes per value.
    *
@@ -1133,22 +2147,22 @@ const E = class extends Number {
     return e.valueOf() / this.valueOf();
   }
   size(e) {
-    return new pe(e * this.valueOf());
+    return new Ae(e * this.valueOf());
   }
 };
-u(E, "UNKNOWN", new E(0)), /** 128 bits per value. */
-u(E, "BIT128", new E(16)), /** 64 bits per value. */
-u(E, "BIT64", new E(8)), /** 32 bits per value. */
-u(E, "BIT32", new E(4)), /** 16 bits per value. */
-u(E, "BIT16", new E(2)), /** 8 bits per value. */
-u(E, "BIT8", new E(1)), /** A zod schema for validating and transforming densities */
-u(E, "z", i.union([
-  i.number().transform((r) => new E(r)),
-  i.instanceof(Number).transform((r) => new E(r)),
-  i.instanceof(E)
+h(x, "UNKNOWN", new x(0)), /** 128 bits per value. */
+h(x, "BIT128", new x(16)), /** 64 bits per value. */
+h(x, "BIT64", new x(8)), /** 32 bits per value. */
+h(x, "BIT32", new x(4)), /** 16 bits per value. */
+h(x, "BIT16", new x(2)), /** 8 bits per value. */
+h(x, "BIT8", new x(1)), /** A zod schema for validating and transforming densities */
+h(x, "z", i.union([
+  i.number().transform((s) => new x(s)),
+  i.instanceof(Number).transform((s) => new x(s)),
+  i.instanceof(x)
 ]));
-let x = E;
-const U = class ne {
+let E = x;
+const $ = class te {
   /**
    * Creates a TimeRange from the given start and end TimeStamps.
    *
@@ -1156,11 +2170,11 @@ const U = class ne {
    * @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 v(e.start), this.end = new v(e.end)) : (this.start = new v(e), this.end = new v(t));
+    h(this, "start"), h(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));
   }
   /** @returns The TimeSpan occupied by the TimeRange. */
   get span() {
-    return new O(this.end.valueOf() - this.start.valueOf());
+    return new w(this.end.valueOf() - this.start.valueOf());
   }
   /**
    * Checks if the timestamp is valid i.e. the start is before the end.
@@ -1198,7 +2212,13 @@ const U = class ne {
    * @returns A TimeRange with the start and end swapped.
    */
   swap() {
-    return new ne(this.end, this.start);
+    return new te(this.end, this.start);
+  }
+  get numericBounds() {
+    return {
+      lower: Number(this.start.valueOf()),
+      upper: Number(this.end.valueOf())
+    };
   }
   /**
    * Checks if the TimeRange is equal to the given TimeRange.
@@ -1206,8 +2226,11 @@ const U = class ne {
    * @param other - The TimeRange to compare to.
    * @returns True if the TimeRange is equal to the given TimeRange.
    */
-  equals(e) {
-    return this.start.equals(e.start) && this.end.equals(e.end);
+  equals(e, t = w.ZERO) {
+    if (t.isZero)
+      return this.start.equals(e.start) && this.end.equals(e.end);
+    let r = this.start.sub(e.start).valueOf(), n = this.end.sub(e.end).valueOf();
+    return r < 0 && (r = -r), n < 0 && (n = -n), r <= t.valueOf() && n <= t.valueOf();
   }
   toString() {
     return `${this.start.toString()} - ${this.end.toString()}`;
@@ -1216,59 +2239,67 @@ const U = class ne {
     return `${this.start.fString("preciseDate")} - ${this.span.toString()}`;
   }
   /**
-   * Checks if if the two time ranges overlap. If the two time ranges are equal, returns
-   * true.  If the start of one range is equal to the end of the other, returns false.
-   * Just follow the rule [start, end) i.e. start is inclusive and end is exclusive.
+   * Checks if the two time ranges overlap. If the two time ranges are equal, returns
+   * true.  If the start of one range is equal to the end of the other, it returns false.
+   * Just follow the rule [start, end), i.e., start is inclusive, and the end is exclusive.
    *
    * @param other - The other TimeRange to compare to.
+   * @param delta - A TimeSpan representing the minimum amount of overlap for
+   * overlap to return true. This allows for a slight amount of leeway when
+   * checking for overlap.
    * @returns True if the two TimeRanges overlap, false otherwise.
    */
-  overlapsWith(e, t = O.ZERO) {
+  overlapsWith(e, t = w.ZERO) {
     e = e.makeValid();
-    const n = this.makeValid();
+    const r = this.makeValid();
     if (this.equals(e)) return !0;
-    if (e.end.equals(n.start) || n.end.equals(e.start)) return !1;
-    const s = v.max(n.start, e.start), a = v.min(n.end, e.end);
-    return a.before(s) ? !1 : new O(a.sub(s)).greaterThanOrEqual(t);
-  }
-  roughlyEquals(e, t) {
-    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();
+    if (e.end.equals(r.start) || r.end.equals(e.start)) return !1;
+    const n = T.max(r.start, e.start), a = T.min(r.end, e.end);
+    return a.before(n) ? !1 : new w(a.sub(n)).greaterThanOrEqual(t);
   }
   contains(e) {
-    return e instanceof ne ? 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 ne(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;
   }
+  static max(...e) {
+    return new te(
+      T.min(...e.map((t) => t.start)),
+      T.max(...e.map((t) => t.end))
+    );
+  }
 };
-u(U, "MAX", new U(v.MIN, v.MAX)), /** The minimum possible time range. */
-u(U, "MIN", new U(v.MAX, v.MIN)), /** A zero time range. */
-u(U, "ZERO", new U(v.ZERO, v.ZERO)), /** A zod schema for validating and transforming time ranges */
-u(U, "z", i.union([
-  i.object({ start: v.z, end: v.z }).transform((r) => new U(r.start, r.end)),
-  i.instanceof(U)
+h($, "MAX", new $(T.MIN, T.MAX)), /** The minimum possible time range. */
+h($, "MIN", new $(T.MAX, T.MIN)), /** A time range whose start and end are both zero. */
+h($, "ZERO", new $(T.ZERO, T.ZERO)), /** A zod schema for validating and transforming time ranges */
+h($, "z", i.union([
+  i.object({ start: T.z, end: T.z }).transform((s) => new $(s.start, s.end)),
+  i.instanceof($)
 ]));
-let Te = U;
-const o = class S extends String {
+let ae = $;
+const u = class O {
   constructor(e) {
-    if (e instanceof S || typeof e == "string" || typeof e.valueOf() == "string") {
-      super(e.valueOf());
+    if (h(this, "value"), h(this, "encodeValue", !0), e instanceof O || typeof e == "string" || typeof e.valueOf() == "string") {
+      this.value = e.valueOf();
       return;
     }
-    const t = S.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
+    const t = O.ARRAY_CONSTRUCTOR_DATA_TYPES.get(e.constructor.name);
     if (t != null) {
-      super(t.valueOf());
+      this.value = t.valueOf();
       return;
     }
-    throw super(S.UNKNOWN.valueOf()), new Error(`unable to find data type for ${e.toString()}`);
+    throw this.value = O.UNKNOWN.valueOf(), new Error(`unable to find data type for ${e.toString()}`);
+  }
+  valueOf() {
+    return this.value;
   }
   /**
    * @returns the TypedArray constructor for the DataType.
    */
   get Array() {
-    const e = S.ARRAY_CONSTRUCTORS.get(this.toString());
+    const e = O.ARRAY_CONSTRUCTORS.get(this.toString());
     if (e == null)
       throw new Error(`unable to find array constructor for ${this.valueOf()}`);
     return e;
@@ -1290,10 +2321,10 @@ const o = class S extends String {
     return this.valueOf();
   }
   get isVariable() {
-    return this.equals(S.JSON) || this.equals(S.STRING);
+    return this.equals(O.JSON) || this.equals(O.STRING);
   }
   get isNumeric() {
-    return !this.isVariable && !this.equals(S.UUID);
+    return !this.isVariable && !this.equals(O.UUID);
   }
   get isInteger() {
     const e = this.toString();
@@ -1303,122 +2334,115 @@ const o = class S extends String {
     return this.toString().startsWith("float");
   }
   get density() {
-    const e = S.DENSITIES.get(this.toString());
+    const e = O.DENSITIES.get(this.toString());
     if (e == null) throw new Error(`unable to find density for ${this.valueOf()}`);
     return e;
   }
+  /** @returns ture if the data type is an unsigned numeric integer type */
   get isUnsigned() {
-    return this.equals(S.UINT8) || this.equals(S.UINT16) || this.equals(S.UINT32) || this.equals(S.UINT64);
+    return this.equals(O.UINT8) || this.equals(O.UINT16) || this.equals(O.UINT32) || this.equals(O.UINT64);
   }
+  /** @returns true if the data type is a signed numeric integer type */
   get isSigned() {
-    return this.equals(S.INT8) || this.equals(S.INT16) || this.equals(S.INT32) || this.equals(S.INT64);
+    return this.equals(O.INT8) || this.equals(O.INT16) || this.equals(O.INT32) || this.equals(O.INT64);
   }
   /** @returns true if the data type can be cast to the other data type without loss of precision. */
   canSafelyCastTo(e) {
-    return this.equals(e) ? !0 : !this.isNumeric || !e.isNumeric || this.isVariable || e.isVariable || this.isUnsigned && e.isSigned ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(S.INT32) && e.equals(S.FLOAT64) || this.equals(S.INT8) && e.equals(S.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsigned === e.isUnsigned : !1;
+    return this.equals(e) ? !0 : !this.isNumeric || !e.isNumeric || this.isVariable || e.isVariable || this.isUnsigned && e.isSigned ? !1 : this.isFloat ? e.isFloat && this.density.valueOf() <= e.density.valueOf() : this.equals(O.INT32) && e.equals(O.FLOAT64) || this.equals(O.INT8) && e.equals(O.FLOAT32) ? !0 : this.isInteger && e.isInteger ? this.density.valueOf() <= e.density.valueOf() && this.isUnsigned === e.isUnsigned : !1;
   }
   /** @returns true if the data type can be cast to the other data type, even if there is a loss of precision. */
   canCastTo(e) {
     return this.isNumeric && e.isNumeric ? !0 : this.equals(e);
   }
-  /**
-   * Checks whether the given TypedArray is of the same type as the DataType.
-   *
-   * @param array - The TypedArray to check.
-   * @returns True if the TypedArray is of the same type as the DataType.
-   */
-  checkArray(e) {
-    return e.constructor === this.Array;
-  }
   toJSON() {
     return this.toString();
   }
   get usesBigInt() {
-    return S.BIG_INT_TYPES.some((e) => e.equals(this));
+    return O.BIG_INT_TYPES.some((e) => e.equals(this));
   }
 };
-u(o, "UNKNOWN", new o("unknown")), /** Represents a 64-bit floating point value. */
-u(o, "FLOAT64", new o("float64")), /** Represents a 32-bit floating point value. */
-u(o, "FLOAT32", new o("float32")), /** Represents a 64-bit signed integer value. */
-u(o, "INT64", new o("int64")), /** Represents a 32-bit signed integer value. */
-u(o, "INT32", new o("int32")), /** Represents a 16-bit signed integer value. */
-u(o, "INT16", new o("int16")), /** Represents a 8-bit signed integer value. */
-u(o, "INT8", new o("int8")), /** Represents a 64-bit unsigned integer value. */
-u(o, "UINT64", new o("uint64")), /** Represents a 32-bit unsigned integer value. */
-u(o, "UINT32", new o("uint32")), /** Represents a 16-bit unsigned integer value. */
-u(o, "UINT16", new o("uint16")), /** Represents a 8-bit unsigned integer value. */
-u(o, "UINT8", new o("uint8")), /** Represents a boolean value. Alias for UINT8. */
-u(o, "BOOLEAN", o.UINT8), /** Represents a 64-bit unix epoch. */
-u(o, "TIMESTAMP", new o("timestamp")), /** Represents a UUID data type */
-u(o, "UUID", new o("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
+h(u, "UNKNOWN", new u("unknown")), /** Represents a 64-bit floating point value. */
+h(u, "FLOAT64", new u("float64")), /** Represents a 32-bit floating point value. */
+h(u, "FLOAT32", new u("float32")), /** Represents a 64-bit signed integer value. */
+h(u, "INT64", new u("int64")), /** Represents a 32-bit signed integer value. */
+h(u, "INT32", new u("int32")), /** Represents a 16-bit signed integer value. */
+h(u, "INT16", new u("int16")), /** Represents a 8-bit signed integer value. */
+h(u, "INT8", new u("int8")), /** Represents a 64-bit unsigned integer value. */
+h(u, "UINT64", new u("uint64")), /** Represents a 32-bit unsigned integer value. */
+h(u, "UINT32", new u("uint32")), /** Represents a 16-bit unsigned integer value. */
+h(u, "UINT16", new u("uint16")), /** Represents a 8-bit unsigned integer value. */
+h(u, "UINT8", new u("uint8")), /** Represents a boolean value. Alias for UINT8. */
+h(u, "BOOLEAN", u.UINT8), /** Represents a 64-bit unix epoch. */
+h(u, "TIMESTAMP", new u("timestamp")), /** Represents a UUID data type */
+h(u, "UUID", new u("uuid")), /** Represents a string data type. Strings have an unknown density, and are separate
 * by a newline character. */
-u(o, "STRING", new o("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
+h(u, "STRING", new u("string")), /** Represents a JSON data type. JSON has an unknown density, and is separated by a
 * newline character. */
-u(o, "JSON", new o("json")), u(o, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
-  [o.UINT8.toString(), Uint8Array],
-  [o.UINT16.toString(), Uint16Array],
-  [o.UINT32.toString(), Uint32Array],
-  [o.UINT64.toString(), BigUint64Array],
-  [o.FLOAT32.toString(), Float32Array],
-  [o.FLOAT64.toString(), Float64Array],
-  [o.INT8.toString(), Int8Array],
-  [o.INT16.toString(), Int16Array],
-  [o.INT32.toString(), Int32Array],
-  [o.INT64.toString(), BigInt64Array],
-  [o.TIMESTAMP.toString(), BigInt64Array],
-  [o.STRING.toString(), Uint8Array],
-  [o.JSON.toString(), Uint8Array],
-  [o.UUID.toString(), Uint8Array]
-])), u(o, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
-  [Uint8Array.name, o.UINT8],
-  [Uint16Array.name, o.UINT16],
-  [Uint32Array.name, o.UINT32],
-  [BigUint64Array.name, o.UINT64],
-  [Float32Array.name, o.FLOAT32],
-  [Float64Array.name, o.FLOAT64],
-  [Int8Array.name, o.INT8],
-  [Int16Array.name, o.INT16],
-  [Int32Array.name, o.INT32],
-  [BigInt64Array.name, o.INT64]
-])), u(o, "DENSITIES", /* @__PURE__ */ new Map([
-  [o.UINT8.toString(), x.BIT8],
-  [o.UINT16.toString(), x.BIT16],
-  [o.UINT32.toString(), x.BIT32],
-  [o.UINT64.toString(), x.BIT64],
-  [o.FLOAT32.toString(), x.BIT32],
-  [o.FLOAT64.toString(), x.BIT64],
-  [o.INT8.toString(), x.BIT8],
-  [o.INT16.toString(), x.BIT16],
-  [o.INT32.toString(), x.BIT32],
-  [o.INT64.toString(), x.BIT64],
-  [o.TIMESTAMP.toString(), x.BIT64],
-  [o.STRING.toString(), x.UNKNOWN],
-  [o.JSON.toString(), x.UNKNOWN],
-  [o.UUID.toString(), x.BIT128]
+h(u, "JSON", new u("json")), h(u, "ARRAY_CONSTRUCTORS", /* @__PURE__ */ new Map([
+  [u.UINT8.toString(), Uint8Array],
+  [u.UINT16.toString(), Uint16Array],
+  [u.UINT32.toString(), Uint32Array],
+  [u.UINT64.toString(), BigUint64Array],
+  [u.FLOAT32.toString(), Float32Array],
+  [u.FLOAT64.toString(), Float64Array],
+  [u.INT8.toString(), Int8Array],
+  [u.INT16.toString(), Int16Array],
+  [u.INT32.toString(), Int32Array],
+  [u.INT64.toString(), BigInt64Array],
+  [u.TIMESTAMP.toString(), BigInt64Array],
+  [u.STRING.toString(), Uint8Array],
+  [u.JSON.toString(), Uint8Array],
+  [u.UUID.toString(), Uint8Array]
+])), h(u, "ARRAY_CONSTRUCTOR_DATA_TYPES", /* @__PURE__ */ new Map([
+  [Uint8Array.name, u.UINT8],
+  [Uint16Array.name, u.UINT16],
+  [Uint32Array.name, u.UINT32],
+  [BigUint64Array.name, u.UINT64],
+  [Float32Array.name, u.FLOAT32],
+  [Float64Array.name, u.FLOAT64],
+  [Int8Array.name, u.INT8],
+  [Int16Array.name, u.INT16],
+  [Int32Array.name, u.INT32],
+  [BigInt64Array.name, u.INT64]
+])), h(u, "DENSITIES", /* @__PURE__ */ new Map([
+  [u.UINT8.toString(), E.BIT8],
+  [u.UINT16.toString(), E.BIT16],
+  [u.UINT32.toString(), E.BIT32],
+  [u.UINT64.toString(), E.BIT64],
+  [u.FLOAT32.toString(), E.BIT32],
+  [u.FLOAT64.toString(), E.BIT64],
+  [u.INT8.toString(), E.BIT8],
+  [u.INT16.toString(), E.BIT16],
+  [u.INT32.toString(), E.BIT32],
+  [u.INT64.toString(), E.BIT64],
+  [u.TIMESTAMP.toString(), E.BIT64],
+  [u.STRING.toString(), E.UNKNOWN],
+  [u.JSON.toString(), E.UNKNOWN],
+  [u.UUID.toString(), E.BIT128]
 ])), /** All the data types. */
-u(o, "ALL", [
-  o.UNKNOWN,
-  o.FLOAT64,
-  o.FLOAT32,
-  o.INT64,
-  o.INT32,
-  o.INT16,
-  o.INT8,
-  o.UINT64,
-  o.UINT32,
-  o.UINT16,
-  o.UINT8,
-  o.TIMESTAMP,
-  o.UUID,
-  o.STRING,
-  o.JSON
-]), u(o, "BIG_INT_TYPES", [o.INT64, o.UINT64, o.TIMESTAMP]), /** A zod schema for a DataType. */
-u(o, "z", i.union([
-  i.string().transform((r) => new o(r)),
-  i.instanceof(o)
+h(u, "ALL", [
+  u.UNKNOWN,
+  u.FLOAT64,
+  u.FLOAT32,
+  u.INT64,
+  u.INT32,
+  u.INT16,
+  u.INT8,
+  u.UINT64,
+  u.UINT32,
+  u.UINT16,
+  u.UINT8,
+  u.TIMESTAMP,
+  u.UUID,
+  u.STRING,
+  u.JSON
+]), h(u, "BIG_INT_TYPES", [u.INT64, u.UINT64, u.TIMESTAMP]), /** A zod schema for a DataType. */
+h(u, "z", i.union([
+  i.string().transform((s) => new u(s)),
+  i.instanceof(u)
 ]));
-let T = o;
-const A = class I extends Number {
+let v = u;
+const N = class I extends Number {
   constructor(e) {
     super(e.valueOf());
   }
@@ -1426,7 +2450,7 @@ const A = class I extends Number {
   largerThan(e) {
     return this.valueOf() > e.valueOf();
   }
-  /** @returns true if the Size is smaller than the other sisze. */
+  /** @returns true if the Size is smaller than the other size. */
   smallerThan(e) {
     return this.valueOf() < e.valueOf();
   }
@@ -1455,9 +2479,9 @@ const A = class I extends Number {
     return this.valueOf() / I.TERABYTE.valueOf();
   }
   toString() {
-    const e = this.truncate(I.TERABYTE), t = this.truncate(I.GIGABYTE), n = this.truncate(I.MEGABYTE), s = this.truncate(I.KILOBYTE), a = this.truncate(I.BYTE), c = e, f = t.sub(e), d = n.sub(t), p = s.sub(n), m = a.sub(s);
+    const e = this.truncate(I.TERABYTE), t = this.truncate(I.GIGABYTE), r = this.truncate(I.MEGABYTE), n = this.truncate(I.KILOBYTE), a = this.truncate(I.BYTE), o = e, c = t.sub(e), d = r.sub(t), p = n.sub(r), y = a.sub(n);
     let l = "";
-    return c.isZero || (l += `${c.terabytes}TB `), f.isZero || (l += `${f.gigabytes}GB `), d.isZero || (l += `${d.megabytes}MB `), p.isZero || (l += `${p.kilobytes}KB `), (!m.isZero || l === "") && (l += `${m.valueOf()}B`), l.trim();
+    return o.isZero || (l += `${o.terabytes}TB `), c.isZero || (l += `${c.gigabytes}GB `), d.isZero || (l += `${d.megabytes}MB `), p.isZero || (l += `${p.kilobytes}KB `), (!y.isZero || l === "") && (l += `${y.valueOf()}B`), l.trim();
   }
   /**
    * Creates a Size from the given number of bytes.
@@ -1508,17 +2532,17 @@ const A = class I extends Number {
     return this.valueOf() === 0;
   }
 };
-u(A, "BYTE", new A(1)), /** A kilobyte */
-u(A, "KILOBYTE", A.kilobytes(1)), /** A megabyte */
-u(A, "MEGABYTE", A.megabytes(1)), /** A gigabyte */
-u(A, "GIGABYTE", A.gigabytes(1)), /** A terabyte. */
-u(A, "TERABYTE", A.terabytes(1)), /** The zero value for Size */
-u(A, "ZERO", new A(0)), /** A zod schema for a Size. */
-u(A, "z", i.union([
-  i.number().transform((r) => new A(r)),
-  i.instanceof(A)
+h(N, "BYTE", new N(1)), /** A kilobyte */
+h(N, "KILOBYTE", N.kilobytes(1)), /** A megabyte */
+h(N, "MEGABYTE", N.megabytes(1)), /** A gigabyte */
+h(N, "GIGABYTE", N.gigabytes(1)), /** A terabyte. */
+h(N, "TERABYTE", N.terabytes(1)), /** The zero value for Size */
+h(N, "ZERO", new N(0)), /** A zod schema for a Size. */
+h(N, "z", i.union([
+  i.number().transform((s) => new N(s)),
+  i.instanceof(N)
 ]));
-let pe = A;
+let Ae = N;
 i.union([
   i.instanceof(Uint8Array),
   i.instanceof(Uint16Array),
@@ -1531,44 +2555,44 @@ i.union([
   i.instanceof(Int32Array),
   i.instanceof(BigInt64Array)
 ]);
-const rt = (r) => {
-  const e = typeof r;
-  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || r instanceof v || r instanceof O || r instanceof Date;
-}, ar = (r, e, t, n = 0) => r.usesBigInt && !e.usesBigInt ? Number(t) - Number(n) : !r.usesBigInt && e.usesBigInt ? BigInt(t.valueOf()) - BigInt(n.valueOf()) : J(t, -n).valueOf(), J = (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), or = (r) => r == null ? !1 : Array.isArray(r) || r instanceof ArrayBuffer || ArrayBuffer.isView(r) && !(r instanceof DataView) || r instanceof hr ? !0 : rt(r), P = -1, ur = i.string().transform(
-  (r) => new Uint8Array(
-    atob(r).split("").map((e) => e.charCodeAt(0))
+const It = (s) => {
+  const e = typeof s;
+  return e === "string" || e === "number" || e === "boolean" || e === "bigint" || s instanceof T || s instanceof w || s instanceof Date;
+}, lr = (s, e, t, r = 0) => s.usesBigInt && !e.usesBigInt ? Number(t) - Number(r) : !s.usesBigInt && e.usesBigInt ? BigInt(t.valueOf()) - BigInt(r.valueOf()) : se(t, -r).valueOf(), se = (s, e) => e == 0 ? s : s == 0 ? e : typeof s == "bigint" && typeof e == "bigint" || typeof s == "number" && typeof e == "number" ? s + e : Number(s) + Number(e), dr = (s) => s == null ? !1 : Array.isArray(s) || s instanceof ArrayBuffer || ArrayBuffer.isView(s) && !(s instanceof DataView) || s instanceof yr ? !0 : It(s), P = -1, fr = i.string().transform(
+  (s) => new Uint8Array(
+    atob(s).split("").map((e) => e.charCodeAt(0))
   ).buffer
-), cr = i.union([i.null(), i.undefined()]).transform(() => new Uint8Array().buffer), ye = 10, lr = (r, e) => {
-  if (r === "string" && !e.isVariable)
+), gr = i.union([i.null(), i.undefined()]).transform(() => new Uint8Array().buffer), Be = 10, pr = (s, e) => {
+  if (s === "string" && !e.isVariable)
     throw new Error(`cannot convert series of type ${e.toString()} to string`);
-  if (r === "number" && !e.isNumeric)
+  if (s === "number" && !e.isNumeric)
     throw new Error(`cannot convert series of type ${e.toString()} to number`);
-  if (r === "bigint" && !e.usesBigInt)
+  if (s === "bigint" && !e.usesBigInt)
     throw new Error(`cannot convert series of type ${e.toString()} to bigint`);
-}, H = class B {
+}, re = class M {
   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", P), u(this, "_refCount", 0), u(this, "_cachedLength"), u(this, "_cachedIndexes"), or(e) && (e = { data: e });
+    h(this, "key", ""), h(this, "isSynnaxSeries", !0), h(this, "dataType"), h(this, "sampleOffset"), h(this, "gl"), h(this, "_data"), h(this, "timeRange", ae.ZERO), h(this, "alignment", 0n), h(this, "_cachedMin"), h(this, "_cachedMax"), h(this, "writePos", P), h(this, "_refCount", 0), h(this, "_cachedLength"), h(this, "_cachedIndexes"), dr(e) && (e = { data: e });
     const {
       dataType: t,
-      timeRange: n,
-      sampleOffset: s = 0,
+      timeRange: r,
+      sampleOffset: n = 0,
       glBufferUsage: a = "static",
-      alignment: c = 0n,
-      key: f = sr()
+      alignment: o = 0n,
+      key: c = ur()
     } = e, d = e.data ?? [];
-    if (d instanceof B || typeof d == "object" && "isSynnaxSeries" in d && d.isSynnaxSeries === !0) {
+    if (d instanceof M || typeof d == "object" && "isSynnaxSeries" in d && d.isSynnaxSeries === !0) {
       const l = d;
-      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;
+      this.key = l.key, this.dataType = l.dataType, this.sampleOffset = l.sampleOffset, this.gl = l.gl, this._data = l._data, this.timeRange = l.timeRange, this.alignment = l.alignment, this._cachedMin = l._cachedMin, this._cachedMax = l._cachedMax, this.writePos = l.writePos, this._refCount = l._refCount, this._cachedLength = l._cachedLength;
       return;
     }
-    const p = rt(d), m = Array.isArray(d);
-    if (t != null) this.dataType = new T(t);
+    const p = It(d), y = Array.isArray(d);
+    if (t != null) this.dataType = new v(t);
     else {
       if (d instanceof ArrayBuffer)
         throw new Error(
           "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type."
         );
-      if (m || p) {
+      if (y || p) {
         let l = d;
         if (!p) {
           if (d.length === 0)
@@ -1577,85 +2601,86 @@ const rt = (r) => {
             );
           l = d[0];
         }
-        if (typeof l == "string") this.dataType = T.STRING;
-        else if (typeof l == "number") this.dataType = T.FLOAT64;
-        else if (typeof l == "bigint") this.dataType = T.INT64;
-        else if (typeof l == "boolean") this.dataType = T.BOOLEAN;
-        else if (l instanceof v || l instanceof Date || l instanceof v)
-          this.dataType = T.TIMESTAMP;
-        else if (typeof l == "object") this.dataType = T.JSON;
+        if (typeof l == "string") this.dataType = v.STRING;
+        else if (typeof l == "number") this.dataType = v.FLOAT64;
+        else if (typeof l == "bigint") this.dataType = v.INT64;
+        else if (typeof l == "boolean") this.dataType = v.BOOLEAN;
+        else if (l instanceof T || l instanceof Date || l instanceof T)
+          this.dataType = v.TIMESTAMP;
+        else if (typeof l == "object") this.dataType = v.JSON;
         else
           throw new Error(
             `cannot infer data type of ${typeof l} when constructing a Series from a JS array`
           );
-      } else this.dataType = new T(d);
+      } else this.dataType = new v(d);
     }
-    if (!m && !p) this._data = d;
+    if (!y && !p) this._data = d;
     else {
       let l = p ? [d] : d;
-      const N = l[0];
-      (N instanceof v || N instanceof Date || N instanceof O) && (l = l.map(($) => new v($).valueOf())), this.dataType.equals(T.STRING) ? (this._cachedLength = l.length, this._data = new TextEncoder().encode(`${l.join(`
+      const U = l[0];
+      (U instanceof T || U instanceof Date || U instanceof w) && (l = l.map((B) => new T(B).valueOf())), this.dataType.equals(v.STRING) ? (this._cachedLength = l.length, this._data = new TextEncoder().encode(`${l.join(`
 `)}
-`).buffer) : this.dataType.equals(T.JSON) ? (this._cachedLength = l.length, this._data = new TextEncoder().encode(
-        `${l.map(($) => te.encodeString($)).join(`
+`).buffer) : this.dataType.equals(v.JSON) ? (this._cachedLength = l.length, this._data = new TextEncoder().encode(
+        `${l.map((B) => fe.encodeString(B)).join(`
 `)}
 `
-      ).buffer) : this.dataType.usesBigInt && typeof N == "number" ? this._data = new this.dataType.Array(
-        l.map(($) => BigInt(Math.round($)))
-      ).buffer : !this.dataType.usesBigInt && typeof N == "bigint" ? this._data = new this.dataType.Array(
-        l.map(($) => Number($))
+      ).buffer) : this.dataType.usesBigInt && typeof U == "number" ? this._data = new this.dataType.Array(
+        l.map((B) => BigInt(Math.round(B)))
+      ).buffer : !this.dataType.usesBigInt && typeof U == "bigint" ? this._data = new this.dataType.Array(
+        l.map((B) => Number(B))
       ).buffer : this._data = new this.dataType.Array(l).buffer;
     }
-    this.key = f, this.alignment = c, this.sampleOffset = s ?? 0, this._timeRange = n, this.gl = {
+    this.key = c, this.alignment = o, this.sampleOffset = n ?? 0, this.timeRange = r ?? ae.ZERO, this.gl = {
       control: null,
       buffer: null,
       prevBuffer: 0,
       bufferUsage: a
     };
   }
-  static alloc({ capacity: e, dataType: t, ...n }) {
+  static alloc({ capacity: e, dataType: t, ...r }) {
     if (e === 0)
       throw new Error("[Series] - cannot allocate an array of length 0");
-    const s = new new T(t).Array(e), a = new B({
-      data: s.buffer,
+    const n = new new v(t).Array(e), a = new M({
+      data: n.buffer,
       dataType: t,
-      ...n
+      ...r
     });
     return a.writePos = 0, a;
   }
-  static createTimestamps(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 B({ data: a, dataType: T.TIMESTAMP, timeRange: s });
+  static createTimestamps(e, t, r) {
+    const n = r.spanRange(t.span(e)), a = new BigInt64Array(e);
+    for (let o = 0; o < e; o++)
+      a[o] = BigInt(r.add(t.span(o)).valueOf());
+    return new M({ data: a, dataType: v.TIMESTAMP, timeRange: n });
   }
   get refCount() {
     return this._refCount;
   }
   static fromStrings(e, t) {
-    const n = new TextEncoder().encode(
+    const r = new TextEncoder().encode(
       `${e.join(`
 `)}
 `
     );
-    return new B({ data: n, dataType: T.STRING, timeRange: t });
+    return new M({ data: r, dataType: v.STRING, timeRange: t });
   }
   static fromJSON(e, t) {
-    const n = new TextEncoder().encode(
-      `${e.map((s) => te.encodeString(s)).join(`
+    const r = new TextEncoder().encode(
+      `${e.map((n) => fe.encodeString(n)).join(`
 `)}
 `
     );
-    return new B({ data: n, dataType: T.JSON, timeRange: t });
+    return new M({ data: r, dataType: v.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");
+    if (this._refCount <= 0) {
+      console.warn("attempted to release a series with a negative reference count");
+      return;
+    }
+    this._refCount--, this._refCount === 0 && this.gl.control != null && this.maybeGarbageCollectGLBuffer(this.gl.control);
   }
   /**
    * Writes the given series to this series. If the series being written exceeds the
@@ -1672,13 +2697,13 @@ const rt = (r) => {
   }
   writeVariable(e) {
     if (this.writePos === P) return 0;
-    const t = this.byteCapacity.valueOf() - this.writePos, n = e.subBytes(0, t);
-    return this.writeToUnderlyingData(n), this.writePos += n.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += n.length, this.calculateCachedLength()), n.length;
+    const t = this.byteCapacity.valueOf() - this.writePos, r = e.subBytes(0, t);
+    return this.writeToUnderlyingData(r), this.writePos += r.byteLength.valueOf(), this._cachedLength != null && (this._cachedLength += r.length, this.calculateCachedLength()), r.length;
   }
   writeFixed(e) {
     if (this.writePos === P) return 0;
-    const t = this.capacity - this.writePos, n = e.sub(0, t);
-    return this.writeToUnderlyingData(n), this._cachedLength = void 0, this.maybeRecomputeMinMax(n), this.writePos += n.length, n.length;
+    const t = this.capacity - this.writePos, r = e.sub(0, t);
+    return this.writeToUnderlyingData(r), this._cachedLength = void 0, this.maybeRecomputeMinMax(r), this.writePos += r.length, r.length;
   }
   writeToUnderlyingData(e) {
     this.underlyingData.set(
@@ -1698,38 +2723,33 @@ const rt = (r) => {
     return this.writePos === P ? this.underlyingData : new this.dataType.Array(this._data, 0, this.writePos);
   }
   toStrings() {
-    if (!this.dataType.matches(T.STRING, T.UUID))
+    if (!this.dataType.matches(v.STRING, v.UUID))
       throw new Error("cannot convert non-string series to strings");
     return new TextDecoder().decode(this.underlyingData).split(`
 `).slice(0, -1);
   }
   toUUIDs() {
-    if (!this.dataType.equals(T.UUID))
+    if (!this.dataType.equals(v.UUID))
       throw new Error("cannot convert non-uuid series to uuids");
-    const e = T.UUID.density.valueOf(), t = Array(this.length);
-    for (let n = 0; n < this.length; n++) {
-      const s = this.underlyingData.slice(n * e, (n + 1) * e), a = Array.from(
-        new Uint8Array(s.buffer),
-        (c) => c.toString(16).padStart(2, "0")
+    const e = v.UUID.density.valueOf(), t = Array(this.length);
+    for (let r = 0; r < this.length; r++) {
+      const n = this.underlyingData.slice(r * e, (r + 1) * e), a = Array.from(
+        new Uint8Array(n.buffer),
+        (o) => o.toString(16).padStart(2, "0")
       ).join("").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
-      t[n] = a;
+      t[r] = a;
     }
     return t;
   }
   parseJSON(e) {
-    if (!this.dataType.equals(T.JSON))
+    if (!this.dataType.equals(v.JSON))
       throw new Error("cannot parse non-JSON series as JSON");
     return new TextDecoder().decode(this.underlyingData).split(`
-`).slice(0, -1).map((t) => e.parse(te.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;
+`).slice(0, -1).map((t) => e.parse(fe.decodeString(t)));
   }
   /** @returns the capacity of the series in bytes. */
   get byteCapacity() {
-    return new pe(this.underlyingData.byteLength);
+    return new Ae(this.underlyingData.byteLength);
   }
   /** @returns the capacity of the series in samples. */
   get capacity() {
@@ -1737,7 +2757,7 @@ const rt = (r) => {
   }
   /** @returns the length of the series in bytes. */
   get byteLength() {
-    return this.writePos === P ? this.byteCapacity : this.dataType.isVariable ? new pe(this.writePos) : this.dataType.density.size(this.writePos);
+    return this.writePos === P ? this.byteCapacity : this.dataType.isVariable ? new Ae(this.writePos) : this.dataType.density.size(this.writePos);
   }
   /** @returns the number of samples in this array. */
   get length() {
@@ -1748,8 +2768,8 @@ const rt = (r) => {
       throw new Error("cannot calculate length of a non-variable length data type");
     let e = 0;
     const t = [0];
-    return this.data.forEach((n, s) => {
-      n === ye && (e++, t.push(s + 1));
+    return this.data.forEach((r, n) => {
+      r === Be && (e++, t.push(n + 1));
     }), this._cachedIndexes = t, this._cachedLength = e, e;
   }
   /**
@@ -1763,13 +2783,13 @@ const rt = (r) => {
    */
   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] = ar(this.dataType, e, this.data[s], t);
-    return new B({
-      data: n.buffer,
+    const r = new e.Array(this.length);
+    for (let n = 0; n < this.length; n++)
+      r[n] = lr(this.dataType, e, this.data[n], t);
+    return new M({
+      data: r.buffer,
       dataType: e,
-      timeRange: this._timeRange,
+      timeRange: this.timeRange,
       sampleOffset: t,
       glBufferUsage: this.gl.bufferUsage,
       alignment: this.alignment
@@ -1777,14 +2797,14 @@ const rt = (r) => {
   }
   calcRawMax() {
     if (this.length === 0) return -1 / 0;
-    if (this.dataType.equals(T.TIMESTAMP))
+    if (this.dataType.equals(v.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);
+      this._cachedMax = e.reduce((t, r) => t > r ? t : r);
     } else {
       const e = this.data;
-      this._cachedMax = e.reduce((t, n) => t > n ? t : n);
+      this._cachedMax = e.reduce((t, r) => t > r ? t : r);
     }
     return this._cachedMax;
   }
@@ -1792,17 +2812,17 @@ const rt = (r) => {
   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 ?? (this._cachedMax = this.calcRawMax()), J(this._cachedMax, this.sampleOffset));
+    return this.writePos === 0 ? -1 / 0 : (this._cachedMax ?? (this._cachedMax = this.calcRawMax()), se(this._cachedMax, this.sampleOffset));
   }
   calcRawMin() {
     if (this.length === 0) return 1 / 0;
-    if (this.dataType.equals(T.TIMESTAMP)) this._cachedMin = this.data[0];
+    if (this.dataType.equals(v.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);
+      this._cachedMin = e.reduce((t, r) => t < r ? t : r);
     } else {
       const e = this.data;
-      this._cachedMin = e.reduce((t, n) => t < n ? t : n);
+      this._cachedMin = e.reduce((t, r) => t < r ? t : r);
     }
     return this._cachedMin;
   }
@@ -1810,11 +2830,11 @@ const rt = (r) => {
   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 ?? (this._cachedMin = this.calcRawMin()), J(this._cachedMin, this.sampleOffset));
+    return this.writePos === 0 ? 1 / 0 : (this._cachedMin ?? (this._cachedMin = this.calcRawMin()), se(this._cachedMin, this.sampleOffset));
   }
   /** @returns the bounds of this array. */
   get bounds() {
-    return q(Number(this.min), Number(this.max));
+    return z(Number(this.min), Number(this.max));
   }
   maybeRecomputeMinMax(e) {
     if (this._cachedMin != null) {
@@ -1830,47 +2850,47 @@ const rt = (r) => {
     this.max, this.min;
   }
   get range() {
-    return J(this.max, -this.min);
+    return se(this.max, -this.min);
   }
   atAlignment(e, t) {
-    const n = Number(e - this.alignment);
-    if (n < 0 || n >= this.length) {
-      if (t === !0) throw new Error(`[series] - no value at index ${n}`);
+    const r = Number(e - this.alignment);
+    if (r < 0 || r >= this.length) {
+      if (t === !0) throw new Error(`[series] - no value at index ${r}`);
       return;
     }
-    return this.at(n, t);
+    return this.at(r, t);
   }
   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) {
+    const r = this.data[e];
+    if (r == null) {
       if (t === !0) throw new Error(`[series] - no value at index ${e}`);
       return;
     }
-    return J(n, this.sampleOffset);
+    return se(r, this.sampleOffset);
   }
   atVariable(e, t) {
-    let n = 0, s = 0;
+    let r = 0, n = 0;
     if (this._cachedIndexes != null)
-      n = this._cachedIndexes[e], s = this._cachedIndexes[e + 1] - 1;
+      r = this._cachedIndexes[e], n = this._cachedIndexes[e + 1] - 1;
     else {
       e < 0 && (e = this.length + e);
-      for (let c = 0; c < this.data.length; c++)
-        if (this.data[c] === ye) {
+      for (let o = 0; o < this.data.length; o++)
+        if (this.data[o] === Be) {
           if (e === 0) {
-            s = c;
+            n = o;
             break;
           }
-          n = c + 1, e--;
+          r = o + 1, e--;
         }
-      if (s === 0 && (s = this.data.length), n >= s || e > 0) {
+      if (n === 0 && (n = this.data.length), r >= n || 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(T.STRING) ? new TextDecoder().decode(a) : ze(JSON.parse(new TextDecoder().decode(a)));
+    const a = this.data.slice(r, n);
+    return this.dataType.equals(v.STRING) ? new TextDecoder().decode(a) : De(JSON.parse(new TextDecoder().decode(a)));
   }
   /**
    * @returns the index of the first sample that is greater than or equal to the given value.
@@ -1878,33 +2898,33 @@ const rt = (r) => {
    * @param value the value to search for.
    */
   binarySearch(e) {
-    let t = 0, n = this.length - 1;
-    const s = St(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;
+    let t = 0, r = this.length - 1;
+    const n = Es(e);
+    for (; t <= r; ) {
+      const a = Math.floor((t + r) / 2), o = n(this.at(a, !0), e);
+      if (o === 0) return a;
+      o < 0 ? t = a + 1 : r = a - 1;
     }
     return t;
   }
   updateGLBuffer(e) {
-    if (this.gl.control = e, !this.dataType.equals(T.FLOAT32) && !this.dataType.equals(T.UINT8))
+    if (this.gl.control = e, !this.dataType.equals(v.FLOAT32) && !this.dataType.equals(v.UINT8))
       throw new Error("Only FLOAT32 and UINT8 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)
+    const { buffer: t, bufferUsage: r, prevBuffer: n } = this.gl;
+    if (t == null && (this.gl.buffer = e.createBuffer()), this.writePos !== n)
       if (e.bindBuffer(e.ARRAY_BUFFER, this.gl.buffer), this.writePos !== P) {
-        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;
+        n === 0 && e.bufferData(e.ARRAY_BUFFER, this.byteCapacity.valueOf(), e.STATIC_DRAW);
+        const a = this.dataType.density.size(n).valueOf(), o = this.underlyingData.slice(this.gl.prevBuffer, this.writePos);
+        e.bufferSubData(e.ARRAY_BUFFER, a, o.buffer), this.gl.prevBuffer = this.writePos;
       } else
         e.bufferData(
           e.ARRAY_BUFFER,
           this.buffer,
-          n === "static" ? e.STATIC_DRAW : e.DYNAMIC_DRAW
+          r === "static" ? e.STATIC_DRAW : e.DYNAMIC_DRAW
         ), this.gl.prevBuffer = P;
   }
   as(e) {
-    return lr(e, this.dataType), this;
+    return pr(e, this.dataType), this;
   }
   get digest() {
     var e;
@@ -1913,10 +2933,10 @@ const rt = (r) => {
       dataType: this.dataType.toString(),
       sampleOffset: this.sampleOffset,
       alignment: {
-        lower: ke(this.alignmentBounds.lower),
-        upper: ke(this.alignmentBounds.upper)
+        lower: nt(this.alignmentBounds.lower),
+        upper: nt(this.alignmentBounds.upper)
       },
-      timeRange: (e = this._timeRange) == null ? void 0 : e.toString(),
+      timeRange: (e = this.timeRange) == null ? void 0 : e.toString(),
       length: this.length,
       capacity: this.capacity
     };
@@ -1930,7 +2950,7 @@ const rt = (r) => {
     };
   }
   get alignmentBounds() {
-    return q(this.alignment, this.alignment + BigInt(this.length));
+    return z(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);
@@ -1941,10 +2961,10 @@ const rt = (r) => {
   }
   [Symbol.iterator]() {
     if (this.dataType.isVariable) {
-      const e = new fr(this);
-      return this.dataType.equals(T.JSON) ? new dr(e) : e;
+      const e = new wr(this);
+      return this.dataType.equals(v.JSON) ? new mr(e) : e;
     }
-    return new gr(this);
+    return new br(this);
   }
   slice(e, t) {
     return this.sliceSub(!1, e, t);
@@ -1953,10 +2973,10 @@ const rt = (r) => {
     return this.sliceSub(!0, e, t);
   }
   subIterator(e, t) {
-    return new Ce(this, e, t ?? this.length);
+    return new _e(this, e, t ?? this.length);
   }
   subAlignmentIterator(e, t) {
-    return new Ce(
+    return new _e(
       this,
       Number(e - this.alignment),
       Number(t - this.alignment)
@@ -1964,57 +2984,69 @@ const rt = (r) => {
   }
   subBytes(e, t) {
     if (e >= 0 && (t == null || t >= this.byteLength.valueOf())) return this;
-    const n = this.data.subarray(e, t);
-    return new B({
-      data: n,
+    const r = this.data.subarray(e, t);
+    return new M({
+      data: r,
       dataType: this.dataType,
-      timeRange: this._timeRange,
+      timeRange: this.timeRange,
       sampleOffset: this.sampleOffset,
       glBufferUsage: this.gl.bufferUsage,
       alignment: this.alignment + BigInt(e)
     });
   }
-  sliceSub(e, t, n) {
-    if (t <= 0 && (n == null || n >= this.length)) return this;
-    let s;
-    return e ? s = this.data.subarray(t, n) : s = this.data.slice(t, n), new B({
-      data: s,
+  sliceSub(e, t, r) {
+    if (t <= 0 && (r == null || r >= this.length)) return this;
+    let n;
+    return e ? n = this.data.subarray(t, r) : n = this.data.slice(t, r), new M({
+      data: n,
       dataType: this.dataType,
-      timeRange: this._timeRange,
+      timeRange: this.timeRange,
       sampleOffset: this.sampleOffset,
       glBufferUsage: this.gl.bufferUsage,
       alignment: this.alignment + BigInt(t)
     });
   }
   reAlign(e) {
-    return new B({
+    return new M({
       data: this.buffer,
       dataType: this.dataType,
-      timeRange: Te.ZERO,
+      timeRange: ae.ZERO,
       sampleOffset: this.sampleOffset,
       glBufferUsage: "static",
       alignment: e
     });
   }
+  toString() {
+    var e, t;
+    let r = `${this.dataType.toString()} ${this.length} [`;
+    if (this.length <= 10) r += Array.from(this).map((n) => n.toString());
+    else {
+      for (let n = 0; n < 5; n++)
+        r += `${(e = this.at(n)) == null ? void 0 : e.toString()}`, n < 4 && (r += ",");
+      r += "...";
+      for (let n = -5; n < 0; n++)
+        r += (t = this.at(n)) == null ? void 0 : t.toString(), n < -1 && (r += ",");
+    }
+    return r += "]", r;
+  }
 };
-u(H, "crudeZ", i.object({
-  timeRange: Te.z.optional(),
-  dataType: T.z,
+h(re, "crudeZ", i.object({
+  timeRange: ae.z.optional(),
+  dataType: v.z,
   alignment: i.coerce.bigint().optional(),
   data: i.union([
-    ur,
-    cr,
+    fr,
+    gr,
     i.instanceof(ArrayBuffer),
     i.instanceof(Uint8Array)
   ]),
-  glBufferUsage: ir.optional().default("static").optional()
-})), u(H, "z", H.crudeZ.transform((r) => new H(r)));
-let hr = H;
-class Ce {
-  constructor(e, t, n) {
-    u(this, "series"), u(this, "end"), u(this, "index"), this.series = e;
-    const s = q(0, e.length);
-    this.end = xe(s, n), this.index = xe(s, t);
+  glBufferUsage: cr.optional().default("static").optional()
+})), h(re, "z", re.crudeZ.transform((s) => new re(s)));
+let yr = re, _e = class {
+  constructor(e, t, r) {
+    h(this, "series"), h(this, "end"), h(this, "index"), this.series = e;
+    const n = z(0, e.length);
+    this.end = Ze(n, r), this.index = Ze(n, t);
   }
   next() {
     return this.index >= this.end ? { done: !0, value: void 0 } : { done: !1, value: this.series.at(this.index++, !0) };
@@ -2022,10 +3054,10 @@ class Ce {
   [Symbol.iterator]() {
     return this;
   }
-}
-class fr {
+};
+class wr {
   constructor(e) {
-    if (u(this, "series"), u(this, "index"), u(this, "decoder"), !e.dataType.isVariable)
+    if (h(this, "series"), h(this, "index"), h(this, "decoder"), !e.dataType.isVariable)
       throw new Error(
         "cannot create a variable series iterator for a non-variable series"
       );
@@ -2033,34 +3065,36 @@ class fr {
   }
   next() {
     const e = this.index, t = this.series.data;
-    for (; this.index < t.length && t[this.index] !== ye; ) 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)) });
+    for (; this.index < t.length && t[this.index] !== Be; ) this.index++;
+    const r = this.index;
+    return e === r ? { done: !0, value: void 0 } : (this.index++, { done: !1, value: this.decoder.decode(this.series.buffer.slice(e, r)) });
   }
   [Symbol.iterator]() {
     return this;
   }
 }
-var De, Le;
-class dr {
+var et, tt;
+const Ut = class xt {
   constructor(e) {
-    u(this, "wrapped"), u(this, De, "JSONSeriesIterator"), this.wrapped = e;
+    h(this, "wrapped"), h(this, et, "JSONSeriesIterator"), this.wrapped = e;
   }
   next() {
     const e = this.wrapped.next();
     return e.done === !0 ? { done: !0, value: void 0 } : {
       done: !1,
-      value: te.decodeString(e.value)
+      value: fe.decodeString(e.value, xt.SCHEMA)
     };
   }
-  [(Le = Symbol.iterator, De = Symbol.toStringTag, Le)]() {
+  [(tt = Symbol.iterator, et = Symbol.toStringTag, tt)]() {
     return this;
   }
-}
-var Pe, Ye;
-class gr {
+};
+h(Ut, "SCHEMA", i.record(i.string(), i.unknown()));
+let mr = Ut;
+var st, rt;
+class br {
   constructor(e) {
-    u(this, "series"), u(this, "index"), u(this, Pe, "SeriesIterator"), this.series = e, this.index = 0;
+    h(this, "series"), h(this, "index"), h(this, st, "SeriesIterator"), this.series = e, this.index = 0;
   }
   next() {
     return this.index >= this.series.length ? { done: !0, value: void 0 } : {
@@ -2068,12 +3102,12 @@ class gr {
       value: this.series.at(this.index++, !0)
     };
   }
-  [(Ye = Symbol.iterator, Pe = Symbol.toStringTag, Ye)]() {
+  [(rt = Symbol.iterator, st = Symbol.toStringTag, rt)]() {
     return this;
   }
 }
-const ke = (r) => {
-  const e = r >> 32n, t = r & 0xffffffffn;
+const nt = (s) => {
+  const e = s >> 32n, t = s & 0xffffffffn;
   return { domain: e, sample: t };
 };
 i.object({ key: i.string(), value: i.string() });
@@ -2081,41 +3115,41 @@ i.record(
   i.union([i.number(), i.string(), i.symbol()]),
   i.unknown()
 );
-const nt = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", pr = nt(), st = ["macOS", "Windows", "Linux"], yr = ["macos", "windows", "linux"], mr = {
+const Nt = () => typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : typeof window > "u" || window.document === void 0 ? "webworker" : "browser", vr = Nt(), Et = ["macOS", "Windows", "Linux"], Tr = ["macos", "windows", "linux"], Or = {
   macos: "macOS",
   windows: "Windows",
   linux: "Linux"
-}, wr = i.enum(st).or(
-  i.enum(yr).transform((r) => mr[r])
-), br = () => {
+}, Sr = i.enum(Et).or(
+  i.enum(Tr).transform((s) => Or[s])
+), Ir = () => {
   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";
+  const s = window.navigator.userAgent.toLowerCase();
+  if (s.includes("mac")) return "macOS";
+  if (s.includes("win")) return "Windows";
+  if (s.includes("linux")) return "Linux";
 };
-let fe;
-const Or = (r = {}) => {
-  const { force: e, default: t } = r;
-  return e ?? fe ?? (fe = br(), fe ?? t);
-}, it = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+let Se;
+const Ur = (s = {}) => {
+  const { force: e, default: t } = s;
+  return e ?? Se ?? (Se = Ir(), Se ?? t);
+}, At = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  OPERATING_SYSTEMS: st,
-  RUNTIME: pr,
-  detect: nt,
-  getOS: Or,
-  osZ: wr
+  OPERATING_SYSTEMS: Et,
+  RUNTIME: vr,
+  detect: Nt,
+  getOS: Ur,
+  osZ: Sr
 }, Symbol.toStringTag, { value: "Module" }));
-var Tr = Object.defineProperty, vr = (r, e, t) => e in r ? Tr(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, K = (r, e, t) => vr(r, typeof e != "symbol" ? e + "" : e, t);
-const Sr = (...r) => r.map(at).join(""), at = (r) => (r.endsWith("/") || (r += "/"), r.startsWith("/") && (r = r.slice(1)), r), Ir = (r) => r.endsWith("/") ? r.slice(0, -1) : r, Nr = (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("&")}`, me = class we {
+var xr = Object.defineProperty, Nr = (s, e, t) => e in s ? xr(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, ne = (s, e, t) => Nr(s, typeof e != "symbol" ? e + "" : e, t);
+const Er = (...s) => s.map(Bt).join(""), Bt = (s) => (s.endsWith("/") || (s += "/"), s.startsWith("/") && (s = s.slice(1)), s), Ar = (s) => s.endsWith("/") ? s.slice(0, -1) : s, Br = (s, e = "") => s === null ? "" : `?${Object.entries(s).filter(([, t]) => t == null ? !1 : Array.isArray(t) ? t.length > 0 : !0).map(([t, r]) => `${e}${t}=${r}`).join("&")}`, $e = class Me {
   /**
    * @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: s = "" }) {
-    K(this, "protocol"), K(this, "host"), K(this, "port"), K(this, "path"), this.protocol = n, this.host = e, this.port = t, this.path = at(s);
+  constructor({ host: e, port: t, protocol: r = "", pathPrefix: n = "" }) {
+    ne(this, "protocol"), ne(this, "host"), ne(this, "port"), ne(this, "path"), this.protocol = r, this.host = e, this.port = t, this.path = Bt(n);
   }
   /**
    * Replaces creates a new URL with the specified properties replaced.
@@ -2123,7 +3157,7 @@ const Sr = (...r) => r.map(at).join(""), at = (r) => (r.endsWith("/") || (r += "
    * @returns a new URL.
    */
   replace(e) {
-    return new we({
+    return new Me({
       host: e.host ?? this.host,
       port: e.port ?? this.port,
       protocol: e.protocol ?? this.protocol,
@@ -2136,190 +3170,262 @@ const Sr = (...r) => r.map(at).join(""), at = (r) => (r.endsWith("/") || (r += "
    * @returns a new URL.
    */
   child(e) {
-    return new we({
+    return new Me({
       ...this,
-      pathPrefix: Sr(this.path, e)
+      pathPrefix: Er(this.path, e)
     });
   }
   /** @returns a string representation of the url */
   toString() {
-    return Ir(
+    return Ar(
       `${this.protocol}://${this.host}:${this.port}/${this.path}`
     );
   }
 };
-K(me, "UNKNOWN", new me({ host: "unknown", port: 0 }));
-let Er = me;
-const Ar = -128, xr = 127;
-i.number().int().min(Ar).max(xr);
-const Mr = -32768, $r = 32767;
-i.number().int().min(Mr).max($r);
-const Ur = -2147483648, Br = 2147483647;
-i.number().int().min(Ur).max(Br);
-const Rr = -9223372036854775808n, Cr = 9223372036854775807n;
-i.bigint().min(Rr).max(Cr);
-const Dr = 255;
-i.number().int().min(0).max(Dr);
-const Lr = 65535;
-i.number().int().min(0).max(Lr);
-const Pr = 4294967295;
-i.number().int().min(0).max(Pr);
-const Yr = 18446744073709551615n;
-i.bigint().min(0n).max(Yr);
-var kr = Object.defineProperty, jr = (r, e, t) => e in r ? kr(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, X = (r, e, t) => jr(r, typeof e != "symbol" ? e + "" : e, t);
-const qr = async (r) => await new Promise(
-  (e) => setTimeout(e, O.fromMilliseconds(r).milliseconds)
-), Fr = i.object({
-  interval: O.z.optional(),
+ne($e, "UNKNOWN", new $e({ host: "unknown", port: 0 }));
+let $r = $e;
+const Mr = -128, Cr = 127;
+i.number().int().min(Mr).max(Cr);
+const Rr = -32768, Dr = 32767;
+i.number().int().min(Rr).max(Dr);
+const Lr = -2147483648, kr = 2147483647;
+i.number().int().min(Lr).max(kr);
+const Pr = -9223372036854775808n, jr = 9223372036854775807n;
+i.bigint().min(Pr).max(jr);
+const Fr = 255;
+i.number().int().min(0).max(Fr);
+const zr = 65535;
+i.number().int().min(0).max(zr);
+const Yr = 4294967295;
+i.number().int().min(0).max(Yr);
+const Wr = 18446744073709551615n;
+i.bigint().min(0n).max(Wr);
+var qr = Object.defineProperty, Vr = (s, e, t) => e in s ? qr(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, R = (s, e, t) => Vr(s, typeof e != "symbol" ? e + "" : e, t);
+const Hr = async (s) => await new Promise(
+  (e) => setTimeout(e, w.fromMilliseconds(s).milliseconds)
+);
+class Zr {
+  constructor(e) {
+    R(this, "config"), R(this, "retries"), R(this, "interval"), this.config = {
+      baseInterval: new w((e == null ? void 0 : e.baseInterval) ?? w.seconds(1)),
+      maxRetries: (e == null ? void 0 : e.maxRetries) ?? 5,
+      scale: (e == null ? void 0 : e.scale) ?? 1,
+      sleepFn: (e == null ? void 0 : e.sleepFn) ?? Hr
+    }, this.retries = 0, this.interval = new w(this.config.baseInterval);
+  }
+  async wait() {
+    const { maxRetries: e, scale: t, sleepFn: r } = this.config;
+    return this.retries >= e ? !1 : (await r(this.interval), this.interval = this.interval.mult(t), this.retries++, !0);
+  }
+  reset() {
+    this.retries = 0, this.interval = this.config.baseInterval;
+  }
+}
+const Gr = i.object({
+  baseInterval: w.z.optional(),
   maxRetries: i.number().optional(),
   scale: i.number().optional()
-}), Gr = (r = {}) => {
-  const e = r.sleepFn || qr, t = r.maxRetries ?? 5, n = r.scale ?? 1;
-  let s = 0, a = new O(r.interval ?? O.milliseconds(1));
-  return async () => s >= t ? !1 : (await e(a), a = a.mult(n), s++, !0);
-}, Wr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), Kr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  breakerConfig: Fr,
-  create: Gr
-}, Symbol.toStringTag, { value: "Module" })), C = class extends Number {
-};
-X(C, "ABSOLUTE", 255), X(C, "MINIMUM", 0), X(C, "BOUNDS", {
-  lower: C.MINIMUM,
-  // upper bound is exclusive, so we add 1
-  upper: C.ABSOLUTE + 1
-}), X(C, "z", i.union([
-  i.instanceof(C),
-  i.number().int().min(0).max(255).transform((r) => new C(r)),
-  i.instanceof(Number).transform((r) => new C(r))
-]));
+  Breaker: Zr,
+  breakerConfig: Gr
+}, Symbol.toStringTag, { value: "Module" })), Jr = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i, je = i.string().regex(Jr), H = i.number().min(0).max(255), Xr = i.number().min(0).max(1), $t = i.tuple([H, H, H, Xr]), Mt = i.tuple([H, H, H]), Fe = (s, e = 1) => {
+  if (typeof s == "string") return _r(s, e);
+  if (Array.isArray(s)) {
+    if (s.length < 3 || s.length > 4)
+      throw new Error(`Invalid color: [${s.join(", ")}]`);
+    return s.length === 3 ? [...s, e] : s;
+  }
+  throw new Error(`Invalid color: ${JSON.stringify(s)}`);
+}, Qr = i.union([je, $t, Mt]).transform((s) => Fe(s)), _r = (s, e = 1) => {
+  if (!je.safeParse(s).success) throw new Error(`Invalid hex color: ${s}`);
+  return s = en(s), [
+    de(s, 0),
+    de(s, 2),
+    de(s, 4),
+    s.length === 8 ? de(s, 6) / 255 : e
+  ];
+}, de = (s, e) => parseInt(s.slice(e, e + 2), 16), en = (s) => s.startsWith("#") ? s.slice(1) : s, tn = i.union([je, $t, i.string(), Mt]);
+Fe("#000000");
+Fe("#ffffff");
+const sn = i.object({
+  key: i.string(),
+  color: tn,
+  position: i.number(),
+  switched: i.boolean().optional()
+});
+i.array(sn);
+const rn = i.object({
+  key: i.string(),
+  name: i.string(),
+  color: Qr
+});
 i.object({
+  key: i.string(),
+  name: i.string(),
+  swatches: i.array(rn)
+});
+const nn = i.number().int().min(0).max(255), an = i.object({
   name: i.string(),
   key: i.string()
+}), ye = (s) => i.object({
+  subject: an,
+  resource: s,
+  authority: nn
+}), on = i.object({
+  from: ye(i.any()),
+  to: i.null()
+}), hn = i.object({
+  from: i.null(),
+  to: ye(i.any())
 });
-const ot = class Q extends Error {
-  constructor() {
-    super(Q.MESSAGE);
-  }
-  /** Returns true if the error or message is a cancellation error" */
-  matches(e) {
-    return typeof e == "string" ? e.includes(Q.MESSAGE) : e instanceof Q || e.message.includes(Q.MESSAGE);
-  }
-};
-X(ot, "MESSAGE", "canceled");
-let Vr = ot;
-new Vr();
-i.string().regex(/^\d+\.\d+\.\d+$/);
-const zr = ["standard", "scientific", "engineering"];
-i.enum(zr);
-const ve = (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 oe extends Error {
-  constructor() {
-    super(...arguments);
-    y(this, "discriminator", "FreighterError");
-    y(this, "type", "");
-  }
-}
-const Zr = (r) => {
-  if (r == null || typeof r != "object") return !1;
-  const e = r;
+i.union([
+  on,
+  hn,
+  i.object({
+    from: ye(i.any()),
+    to: ye(i.any())
+  })
+]);
+const un = (s) => Object.getOwnPropertySymbols(globalThis).includes(s), cn = (s, e) => {
+  const t = Symbol.for(s);
+  if (!un(t)) {
+    const r = e();
+    Object.defineProperty(globalThis, t, { value: r });
+  }
+  return () => globalThis[t];
+}, ln = (s) => (e) => e != null && typeof e == "object" && "type" in e && typeof e.type == "string" ? e.type.startsWith(s) : e instanceof Error ? e.message.startsWith(s) : typeof e != "string" ? !1 : e.startsWith(s), me = (s) => {
+  var e;
+  return e = class extends Error {
+    constructor(t, r) {
+      super(t, r), R(this, "discriminator", e.discriminator), R(this, "type", e.TYPE), R(this, "matches", e.matches), this.name = e.TYPE;
+    }
+    static sub(t) {
+      return me(`${s}.${t}`);
+    }
+  }, R(e, "discriminator", "FreighterError"), R(e, "TYPE", s), R(e, "matches", ln(s)), e;
+}, Ct = (s) => {
+  if (s == null || typeof s != "object") return !1;
+  const e = s;
   if (e.discriminator !== "FreighterError") return !1;
   if (!("type" in e))
     throw new Error(
       `Freighter error is missing its type property: ${JSON.stringify(e)}`
     );
   return !0;
-}, je = "unknown", qe = "nil", Jr = "freighter", ut = i.object({ type: i.string(), data: i.string() });
-class Hr {
+}, q = "unknown", Ce = "nil";
+class dn {
   constructor() {
-    y(this, "providers", []);
+    R(this, "providers", []);
   }
   register(e) {
     this.providers.push(e);
   }
   encode(e) {
-    if (e == null) return { type: qe, data: "" };
-    if (Zr(e))
+    if (e == null) return { type: Ce, data: "" };
+    if (Ct(e))
       for (const t of this.providers) {
-        const n = t.encode(e);
-        if (n != null) return n;
+        const r = t.encode(e);
+        if (r != null) return r;
       }
-    return { type: je, data: JSON.stringify(e) };
+    if (e instanceof Error) return { type: q, data: e.message };
+    if (typeof e == "string") return { type: q, data: e };
+    try {
+      return { type: q, data: JSON.stringify(e) };
+    } catch {
+      return { type: q, data: "unable to encode error information" };
+    }
   }
   decode(e) {
-    if (e == null || e.type === qe) return null;
-    if (e.type === je) return new Fe(e.data);
+    if (e == null || e.type === Ce) return null;
+    if (e.type === q) return new Re(e.data);
     for (const t of this.providers) {
-      const n = t.decode(e);
-      if (n != null) return n;
+      const r = t.decode(e);
+      if (r != null) return r;
     }
-    return new Fe(e.data);
+    return new Re(e.data);
   }
 }
-const Se = new Hr(), Kr = ({
-  encode: r,
+const ze = cn("synnax-error-registry", () => new dn()), fn = ({
+  encode: s,
   decode: e
-}) => Se.register({ encode: r, decode: e }), pn = (r) => Se.encode(r), be = (r) => Se.decode(r);
-class Fe extends oe {
-  constructor() {
-    super(...arguments);
-    y(this, "type", "unknown");
-  }
+}) => ze().register({ encode: s, decode: e }), gn = (s) => ze().encode(s), pn = (s) => s == null ? null : ze().decode(s);
+class Re extends me("unknown") {
+}
+const yn = i.object({ type: i.string(), data: i.string() });
+class wn extends me("canceled") {
 }
-const ue = "freighter.", G = class G extends oe {
+const F = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Canceled: wn,
+  NONE: Ce,
+  UNKNOWN: q,
+  Unknown: Re,
+  createTyped: me,
+  decode: pn,
+  encode: gn,
+  isTyped: Ct,
+  payloadZ: yn,
+  register: fn
+}, Symbol.toStringTag, { value: "Module" }));
+Y.object({
+  jsonrpc: Y.string(),
+  id: Y.number().optional(),
+  method: Y.string().optional(),
+  params: Y.unknown().optional(),
+  result: Y.unknown().optional()
+});
+i.string().regex(/^\d+\.\d+\.\d+$/);
+const mn = ["standard", "scientific", "engineering"];
+i.enum(mn);
+class ue extends F.createTyped("freighter") {
+}
+class Z extends ue.sub("eof") {
   constructor() {
     super("EOF");
-    y(this, "type", G.TYPE);
   }
-};
-y(G, "TYPE", `${ue}eof`), y(G, "matches", ve(G.TYPE));
-let Y = G;
-const W = class W extends oe {
+}
+class G extends ue.sub("stream_closed") {
   constructor() {
     super("StreamClosed");
-    y(this, "type", W.TYPE);
   }
-};
-y(W, "TYPE", `${ue}stream_closed`), y(W, "matches", ve(W.TYPE));
-let k = W;
-const V = class V extends oe {
+}
+class K extends ue.sub("unreachable") {
   constructor(t = {}) {
-    const { message: n = "Unreachable", url: s = Er.UNKNOWN } = t;
-    super(n);
-    y(this, "type", V.TYPE);
-    y(this, "url");
-    this.url = s;
+    const { message: r = "Unreachable", url: n = $r.UNKNOWN } = t;
+    super(r);
+    S(this, "url");
+    this.url = n;
   }
-};
-y(V, "TYPE", `${ue}unreachable`), y(V, "matches", ve(V.TYPE));
-let j = V;
-const Xr = (r) => {
-  if (!r.type.startsWith(Jr)) return null;
-  if (Y.matches(r)) return { type: Y.TYPE, data: "EOF" };
-  if (k.matches(r))
-    return { type: k.TYPE, data: "StreamClosed" };
-  if (j.matches(r))
-    return { type: j.TYPE, data: "Unreachable" };
-  throw new Error(`Unknown error type: ${r.type}: ${r.message}`);
-}, Qr = (r) => {
-  if (!r.type.startsWith(ue)) return null;
-  switch (r.type) {
-    case Y.TYPE:
-      return new Y();
-    case k.TYPE:
-      return new k();
-    case j.TYPE:
-      return new j();
+}
+const bn = (s) => {
+  if (!s.type.startsWith(ue.TYPE)) return null;
+  if (Z.matches(s)) return { type: Z.TYPE, data: "EOF" };
+  if (G.matches(s))
+    return { type: G.TYPE, data: "StreamClosed" };
+  if (K.matches(s))
+    return { type: K.TYPE, data: "Unreachable" };
+  throw new Error(`Unknown error type: ${s.type}: ${s.message}`);
+}, vn = (s) => {
+  if (!s.type.startsWith(ue.TYPE)) return null;
+  switch (s.type) {
+    case Z.TYPE:
+      return new Z();
+    case G.TYPE:
+      return new G();
+    case K.TYPE:
+      return new K();
     default:
-      throw new Error(`Unknown error type: ${r.data}`);
+      throw new F.Unknown(`Unknown error type: ${s.data}`);
   }
 };
-Kr({
-  encode: Xr,
-  decode: Qr
+F.register({
+  encode: bn,
+  decode: vn
 });
-class ct {
+class Rt {
   constructor() {
-    y(this, "middleware", []);
+    S(this, "middleware", []);
   }
   /** Implements the Transport interface */
   use(...e) {
@@ -2335,135 +3441,137 @@ class ct {
    * @returns An error if one was encountered, otherwise undefined.
    */
   async executeMiddleware(e, t) {
-    let n = 0;
-    const s = async (a) => {
-      if (n === this.middleware.length) return await t(a);
-      const c = this.middleware[n];
-      return n++, await c(a, s);
+    let r = 0;
+    const n = async (a) => {
+      if (r === this.middleware.length) return await t(a);
+      const o = this.middleware[r];
+      return r++, await o(a, n);
     };
-    return await s(e);
+    return await n(e);
   }
 }
-const lt = "Content-Type", Ge = (r) => {
-  if (it.RUNTIME !== "node") return fetch;
+const Dt = "Content-Type", it = (s) => {
+  if (At.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 (s, a) => await e(s, { ...a, agent: n });
-};
-class yn extends ct {
-  constructor(t, n, s = !1) {
+  if (s === "http") return e;
+  const t = require("https"), r = new t.Agent({ rejectUnauthorized: !1 });
+  return async (n, a) => await e(n, { ...a, agent: r });
+}, Tn = (s) => "code" in s && s.code === "ECONNREFUSED" || s.message.toLowerCase().includes("load failed"), On = 400;
+class Pn extends Rt {
+  constructor(t, r, n = !1) {
     super();
-    y(this, "endpoint");
-    y(this, "encoder");
-    y(this, "fetch");
-    return this.endpoint = t.replace({ protocol: s ? "https" : "http" }), this.encoder = n, this.fetch = Ge(this.endpoint.protocol), new Proxy(this, {
-      get: (a, c, f) => c === "endpoint" ? this.endpoint : Reflect.get(a, c, f)
+    S(this, "endpoint");
+    S(this, "encoder");
+    S(this, "fetch");
+    return this.endpoint = t.replace({ protocol: n ? "https" : "http" }), this.encoder = r, this.fetch = it(this.endpoint.protocol), new Proxy(this, {
+      get: (a, o, c) => o === "endpoint" ? this.endpoint : Reflect.get(a, o, c)
     });
   }
   get headers() {
     return {
-      [lt]: this.encoder.contentType
+      [Dt]: this.encoder.contentType
     };
   }
-  async send(t, n, s, a) {
-    n = s == null ? void 0 : s.parse(n);
-    let c = null;
-    const f = this.endpoint.child(t), d = {};
-    d.method = "POST", d.body = this.encoder.encode(n ?? {});
+  async send(t, r, n, a) {
+    r = n == null ? void 0 : n.parse(r);
+    let o = null;
+    const c = this.endpoint.child(t), d = {};
+    d.method = "POST", d.body = this.encoder.encode(r ?? {});
     const [, p] = await this.executeMiddleware(
       {
-        target: f.toString(),
+        target: c.toString(),
         protocol: this.endpoint.protocol,
         params: {},
         role: "client"
       },
-      async (m) => {
-        const l = { ...m, params: {} };
+      async (y) => {
+        const l = { ...y, params: {} };
         d.headers = {
           ...this.headers,
-          ...m.params
+          ...y.params
         };
-        let N;
+        let U;
         try {
-          N = await Ge(m.protocol)(m.target, d);
-        } catch (R) {
-          let M = R;
-          return M.message === "Load failed" && (M = new j({ url: f })), [l, M];
+          U = await it(y.protocol)(y.target, d);
+        } catch (D) {
+          let A = D;
+          return Tn(A) && (A = new K({ url: c })), [l, A];
         }
-        const $ = await N.arrayBuffer();
-        if (N != null && N.ok)
-          return a != null && (c = this.encoder.decode($, a)), [l, null];
+        const B = new Uint8Array(await (await U.blob()).arrayBuffer());
+        if (U != null && U.ok)
+          return a != null && (o = this.encoder.decode(B, a)), [l, null];
         try {
-          if (N.status !== 400) return [l, new Error(N.statusText)];
-          const R = this.encoder.decode($, ut), M = be(R);
-          return [l, M];
-        } catch (R) {
+          if (U.status !== On)
+            return [l, new Error(U.statusText)];
+          const D = this.encoder.decode(B, F.payloadZ), A = F.decode(D);
+          return [l, A];
+        } catch (D) {
           return [
             l,
             new Error(
-              `[freighter] - failed to decode error: ${N.statusText}: ${R.message}`
+              `[freighter] - failed to decode error: ${U.statusText}: ${D.message}`
             )
           ];
         }
       }
     );
-    return [c, p];
+    return p != null ? [null, p] : [o, null];
   }
 }
-const mn = (r, e) => {
+const jn = (s, e) => {
   class t {
-    constructor(s) {
-      y(this, "wrapped");
-      this.wrapped = s;
+    constructor(n) {
+      S(this, "wrapped");
+      this.wrapped = n;
     }
-    use(...s) {
-      this.wrapped.use(...s);
+    use(...n) {
+      this.wrapped.use(...n);
     }
-    async send(s, a, c, f) {
-      const d = Wr.create(e);
+    async send(n, a, o, c) {
+      const d = new Kr.Breaker(e);
       do {
-        const [p, m] = await this.wrapped.send(s, a, c, f);
-        if (m == null || !j.matches(m)) return [p, m];
-        if (!await d()) return [p, m];
+        const [p, y] = await this.wrapped.send(n, a, o, c);
+        if (y == null) return [p, null];
+        if (!K.matches(y)) return [null, y];
+        if (!await d.wait()) return [p, y];
       } while (!0);
     }
   }
-  return new t(r);
-}, wn = async (r, e, t, n, s) => {
-  const [a, c] = await r.send(e, t, n, s);
-  if (c != null) throw c;
+  return new t(s);
+}, Fn = async (s, e, t, r, n) => {
+  const [a, o] = await s.send(e, t, r, n);
+  if (o != null) throw o;
   return a;
-}, _r = () => it.RUNTIME !== "node" ? (r) => new WebSocket(r) : (r) => new (require("ws")).WebSocket(r, { rejectUnauthorized: !1 }), en = i.object({
+}, Sn = () => At.RUNTIME !== "node" ? (s) => new WebSocket(s) : (s) => new (require("ws")).WebSocket(s, { rejectUnauthorized: !1 }), In = i.object({
   type: i.enum(["data", "close", "open"]),
-  payload: i.unknown().optional(),
-  error: i.optional(ut)
+  payload: i.unknown(),
+  error: i.optional(F.payloadZ)
 });
-class tn {
-  constructor(e, t, n, s) {
-    y(this, "encoder");
-    y(this, "reqSchema");
-    y(this, "resSchema");
-    y(this, "ws");
-    y(this, "serverClosed");
-    y(this, "sendClosed");
-    y(this, "receiveDataQueue", []);
-    y(this, "receiveCallbacksQueue", []);
-    this.encoder = t, this.reqSchema = n, this.resSchema = s, this.ws = e, this.sendClosed = !1, this.serverClosed = null, this.listenForMessages();
+class Un {
+  constructor(e, t, r, n) {
+    S(this, "codec");
+    S(this, "reqSchema");
+    S(this, "resSchema");
+    S(this, "ws");
+    S(this, "serverClosed");
+    S(this, "sendClosed");
+    S(this, "receiveDataQueue", []);
+    S(this, "receiveCallbacksQueue", []);
+    this.codec = t, this.reqSchema = r, this.resSchema = n, this.ws = e, this.sendClosed = !1, this.serverClosed = null, this.listenForMessages();
   }
   async receiveOpenAck() {
     const e = await this.receiveMsg();
     if (e.type !== "open") {
       if (e.error == null) throw new Error("Message error must be defined");
-      return be(e.error);
+      return F.decode(e.error);
     }
     return null;
   }
   /** Implements the Stream protocol */
   send(e) {
-    if (this.serverClosed != null) return new Y();
-    if (this.sendClosed) throw new k();
-    return this.ws.send(this.encoder.encode({ type: "data", payload: e })), null;
+    if (this.serverClosed != null) return new Z();
+    if (this.sendClosed) throw new G();
+    return this.ws.send(this.codec.encode({ type: "data", payload: e })), null;
   }
   /** Implements the Stream protocol */
   async receive() {
@@ -2471,7 +3579,7 @@ class tn {
     const e = await this.receiveMsg();
     if (e.type === "close") {
       if (e.error == null) throw new Error("Message error must be defined");
-      return this.serverClosed = be(e.error), [null, this.serverClosed];
+      return this.serverClosed = F.decode(e.error), [null, this.serverClosed];
     }
     return [this.resSchema.parse(e.payload), null];
   }
@@ -2484,7 +3592,7 @@ class tn {
     if (this.sendClosed || this.serverClosed != null) return;
     const e = { type: "close" };
     try {
-      this.ws.send(this.encoder.encode(e));
+      this.ws.send(this.codec.encode(e));
     } finally {
       this.sendClosed = !0;
     }
@@ -2492,7 +3600,7 @@ class tn {
   async receiveMsg() {
     const e = this.receiveDataQueue.shift();
     return e ?? await new Promise(
-      (t, n) => this.receiveCallbacksQueue.push({ resolve: t, reject: n })
+      (t, r) => this.receiveCallbacksQueue.push({ resolve: t, reject: r })
     );
   }
   addMessage(e) {
@@ -2500,78 +3608,86 @@ class tn {
     t != null ? t.resolve(e) : this.receiveDataQueue.push(e);
   }
   listenForMessages() {
-    this.ws.onmessage = (e) => this.addMessage(this.encoder.decode(e.data, en)), this.ws.onclose = (e) => this.addMessage({
+    this.ws.onmessage = this.onMessage.bind(this), this.ws.onclose = this.onClose.bind(this);
+  }
+  onMessage(e) {
+    this.addMessage(this.codec.decode(e.data, In));
+  }
+  onClose(e) {
+    this.addMessage({
       type: "close",
-      error: { type: on(e) ? Y.TYPE : k.TYPE, data: "" }
+      error: {
+        type: e.code === Nn ? Z.TYPE : G.TYPE,
+        data: ""
+      }
     });
   }
 }
-const rn = "freighterctx", nn = 1e3, sn = 1001, an = [nn, sn], on = (r) => an.includes(r.code), ie = class ie extends ct {
+const xn = "freighterctx", Nn = 1e3, oe = class oe extends Rt {
   /**
    * @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, s = !1) {
+  constructor(t, r, n = !1) {
     super();
-    y(this, "baseUrl");
-    y(this, "encoder");
-    this.baseUrl = t.replace({ protocol: s ? "wss" : "ws" }), this.encoder = n;
+    S(this, "baseUrl");
+    S(this, "encoder");
+    S(this, "secure");
+    this.secure = n, this.baseUrl = t.replace({ protocol: n ? "wss" : "ws" }), this.encoder = r;
+  }
+  withCodec(t) {
+    const r = new oe(this.baseUrl, t, this.secure);
+    return r.use(...this.middleware), r;
   }
   /** Implements the StreamClient interface. */
-  async stream(t, n, s) {
-    const a = _r();
-    let c;
-    const [, f] = await this.executeMiddleware(
+  async stream(t, r, n) {
+    const a = Sn();
+    let o;
+    const [, c] = await this.executeMiddleware(
       { target: t, protocol: "websocket", params: {}, role: "client" },
       async (d) => {
-        const p = a(this.buildURL(t, d)), m = { ...d, params: {} };
-        p.binaryType = ie.MESSAGE_TYPE;
-        const l = await this.wrapSocket(p, n, s);
-        return l instanceof Error ? [m, l] : (c = l, [m, null]);
+        const p = a(this.buildURL(t, d)), y = { ...d, params: {} };
+        p.binaryType = oe.MESSAGE_TYPE;
+        const l = await this.wrapSocket(p, r, n);
+        return l instanceof Error ? [y, l] : (o = l, [y, null]);
       }
     );
-    if (f != null) throw f;
-    return c;
+    if (c != null) throw c;
+    return o;
   }
-  buildURL(t, n) {
-    const s = Nr(
+  buildURL(t, r) {
+    const n = Br(
       {
-        [lt]: this.encoder.contentType,
-        ...n.params
+        [Dt]: this.encoder.contentType,
+        ...r.params
       },
-      rn
+      xn
     );
-    return this.baseUrl.child(t).toString() + s;
+    return this.baseUrl.child(t).toString() + n;
   }
-  async wrapSocket(t, n, s) {
+  async wrapSocket(t, r, n) {
     return await new Promise((a) => {
       t.onopen = () => {
-        const c = new tn(t, this.encoder, n, s);
-        c.receiveOpenAck().then((f) => {
-          f != null ? a(f) : a(c);
-        }).catch((f) => a(f));
-      }, t.onerror = (c) => {
-        const f = c;
-        a(new Error(f.message));
+        const o = new Un(t, this.encoder, r, n);
+        o.receiveOpenAck().then((c) => {
+          c != null ? a(c) : a(o);
+        }).catch((c) => a(c));
+      }, t.onerror = (o) => {
+        const c = o;
+        a(new Error(c.message));
       };
     });
   }
 };
-y(ie, "MESSAGE_TYPE", "arraybuffer");
-let We = ie;
+S(oe, "MESSAGE_TYPE", "arraybuffer");
+let at = oe;
 export {
-  oe as BaseTypedError,
-  Y as EOF,
-  yn as HTTPClient,
-  k as StreamClosed,
-  j as Unreachable,
-  We as WebSocketClient,
-  be as decodeError,
-  pn as encodeError,
-  ve as errorMatcher,
-  ut as errorZ,
-  Kr as registerError,
-  wn as sendRequired,
-  mn as unaryWithBreaker
+  Z as EOF,
+  Pn as HTTPClient,
+  G as StreamClosed,
+  K as Unreachable,
+  at as WebSocketClient,
+  Fn as sendRequired,
+  jn as unaryWithBreaker
 };