@kbve/droid 0.0.1 → 0.0.2

package/main-BYzQVPCs.js

@@ -0,0 +1,1455 @@
+import { z as T } from "./index-DSyyyiLP.js";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const lt = Symbol("Comlink.proxy"), At = Symbol("Comlink.endpoint"), Ut = Symbol("Comlink.releaseProxy"), z = Symbol("Comlink.finalizer"), H = Symbol("Comlink.thrown"), ut = (t) => typeof t == "object" && t !== null || typeof t == "function", Dt = {
+  canHandle: (t) => ut(t) && t[lt],
+  serialize(t) {
+    const { port1: e, port2: i } = new MessageChannel();
+    return pt(t, e), [i, [i]];
+  },
+  deserialize(t) {
+    return t.start(), V(t);
+  }
+}, Wt = {
+  canHandle: (t) => ut(t) && H in t,
+  serialize({ value: t }) {
+    let e;
+    return t instanceof Error ? e = {
+      isError: !0,
+      value: {
+        message: t.message,
+        name: t.name,
+        stack: t.stack
+      }
+    } : e = { isError: !1, value: t }, [e, []];
+  },
+  deserialize(t) {
+    throw t.isError ? Object.assign(new Error(t.value.message), t.value) : t.value;
+  }
+}, dt = /* @__PURE__ */ new Map([
+  ["proxy", Dt],
+  ["throw", Wt]
+]);
+function Ct(t, e) {
+  for (const i of t)
+    if (e === i || i === "*" || i instanceof RegExp && i.test(e))
+      return !0;
+  return !1;
+}
+function pt(t, e = globalThis, i = ["*"]) {
+  e.addEventListener("message", function n(s) {
+    if (!s || !s.data)
+      return;
+    if (!Ct(i, s.origin)) {
+      console.warn(`Invalid origin '${s.origin}' for comlink proxy`);
+      return;
+    }
+    const { id: r, type: o, path: u } = Object.assign({ path: [] }, s.data), l = (s.data.argumentList || []).map(R);
+    let d;
+    try {
+      const a = u.slice(0, -1).reduce((h, w) => h[w], t), c = u.reduce((h, w) => h[w], t);
+      switch (o) {
+        case "GET":
+          d = c;
+          break;
+        case "SET":
+          a[u.slice(-1)[0]] = R(s.data.value), d = !0;
+          break;
+        case "APPLY":
+          d = c.apply(a, l);
+          break;
+        case "CONSTRUCT":
+          {
+            const h = new c(...l);
+            d = Et(h);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: h, port2: w } = new MessageChannel();
+            pt(t, w), d = Tt(h, [h]);
+          }
+          break;
+        case "RELEASE":
+          d = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (a) {
+      d = { value: a, [H]: 0 };
+    }
+    Promise.resolve(d).catch((a) => ({ value: a, [H]: 0 })).then((a) => {
+      const [c, h] = M(a);
+      e.postMessage(Object.assign(Object.assign({}, c), { id: r }), h), o === "RELEASE" && (e.removeEventListener("message", n), wt(e), z in t && typeof t[z] == "function" && t[z]());
+    }).catch((a) => {
+      const [c, h] = M({
+        value: new TypeError("Unserializable return value"),
+        [H]: 0
+      });
+      e.postMessage(Object.assign(Object.assign({}, c), { id: r }), h);
+    });
+  }), e.start && e.start();
+}
+function Vt(t) {
+  return t.constructor.name === "MessagePort";
+}
+function wt(t) {
+  Vt(t) && t.close();
+}
+function V(t, e) {
+  const i = /* @__PURE__ */ new Map();
+  return t.addEventListener("message", function(s) {
+    const { data: r } = s;
+    if (!r || !r.id)
+      return;
+    const o = i.get(r.id);
+    if (o)
+      try {
+        o(r);
+      } finally {
+        i.delete(r.id);
+      }
+  }), J(t, i, [], e);
+}
+function B(t) {
+  if (t)
+    throw new Error("Proxy has been released and is not useable");
+}
+function yt(t) {
+  return U(t, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    wt(t);
+  });
+}
+const x = /* @__PURE__ */ new WeakMap(), j = "FinalizationRegistry" in globalThis && new FinalizationRegistry((t) => {
+  const e = (x.get(t) || 0) - 1;
+  x.set(t, e), e === 0 && yt(t);
+});
+function _t(t, e) {
+  const i = (x.get(e) || 0) + 1;
+  x.set(e, i), j && j.register(t, e, t);
+}
+function Bt(t) {
+  j && j.unregister(t);
+}
+function J(t, e, i = [], n = function() {
+}) {
+  let s = !1;
+  const r = new Proxy(n, {
+    get(o, u) {
+      if (B(s), u === Ut)
+        return () => {
+          Bt(r), yt(t), e.clear(), s = !0;
+        };
+      if (u === "then") {
+        if (i.length === 0)
+          return { then: () => r };
+        const l = U(t, e, {
+          type: "GET",
+          path: i.map((d) => d.toString())
+        }).then(R);
+        return l.then.bind(l);
+      }
+      return J(t, e, [...i, u]);
+    },
+    set(o, u, l) {
+      B(s);
+      const [d, a] = M(l);
+      return U(t, e, {
+        type: "SET",
+        path: [...i, u].map((c) => c.toString()),
+        value: d
+      }, a).then(R);
+    },
+    apply(o, u, l) {
+      B(s);
+      const d = i[i.length - 1];
+      if (d === At)
+        return U(t, e, {
+          type: "ENDPOINT"
+        }).then(R);
+      if (d === "bind")
+        return J(t, e, i.slice(0, -1));
+      const [a, c] = it(l);
+      return U(t, e, {
+        type: "APPLY",
+        path: i.map((h) => h.toString()),
+        argumentList: a
+      }, c).then(R);
+    },
+    construct(o, u) {
+      B(s);
+      const [l, d] = it(u);
+      return U(t, e, {
+        type: "CONSTRUCT",
+        path: i.map((a) => a.toString()),
+        argumentList: l
+      }, d).then(R);
+    }
+  });
+  return _t(r, t), r;
+}
+function Pt(t) {
+  return Array.prototype.concat.apply([], t);
+}
+function it(t) {
+  const e = t.map(M);
+  return [e.map((i) => i[0]), Pt(e.map((i) => i[1]))];
+}
+const gt = /* @__PURE__ */ new WeakMap();
+function Tt(t, e) {
+  return gt.set(t, e), t;
+}
+function Et(t) {
+  return Object.assign(t, { [lt]: !0 });
+}
+function M(t) {
+  for (const [e, i] of dt)
+    if (i.canHandle(t)) {
+      const [n, s] = i.serialize(t);
+      return [
+        {
+          type: "HANDLER",
+          name: e,
+          value: n
+        },
+        s
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: t
+    },
+    gt.get(t) || []
+  ];
+}
+function R(t) {
+  switch (t.type) {
+    case "HANDLER":
+      return dt.get(t.name).deserialize(t.value);
+    case "RAW":
+      return t.value;
+  }
+}
+function U(t, e, i, n) {
+  return new Promise((s) => {
+    const r = Ft();
+    e.set(r, s), t.start && t.start(), t.postMessage(Object.assign({ id: r }, i), n);
+  });
+}
+function Ft() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+let q = Symbol("clean"), E = [], Ht = (t, e) => {
+  let i = [], n = {
+    get() {
+      return n.lc || n.listen(() => {
+      })(), n.value;
+    },
+    l: e || 0,
+    lc: 0,
+    listen(s, r) {
+      return n.lc = i.push(s, r || n.l) / 2, () => {
+        let o = i.indexOf(s);
+        ~o && (i.splice(o, 2), --n.lc || n.off());
+      };
+    },
+    notify(s) {
+      let r = !E.length;
+      for (let o = 0; o < i.length; o += 2)
+        E.push(
+          i[o],
+          i[o + 1],
+          n.value,
+          s
+        );
+      if (r) {
+        for (let o = 0; o < E.length; o += 4) {
+          let u;
+          for (let l = o + 1; !u && (l += 4) < E.length; )
+            E[l] < E[o + 1] && (u = E.push(
+              E[o],
+              E[o + 1],
+              E[o + 2],
+              E[o + 3]
+            ));
+          u || E[o](E[o + 2], E[o + 3]);
+        }
+        E.length = 0;
+      }
+    },
+    off() {
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    set(s) {
+      n.value !== s && (n.value = s, n.notify());
+    },
+    subscribe(s, r) {
+      let o = n.listen(s, r);
+      return s(n.value), o;
+    },
+    value: t
+  };
+  return process.env.NODE_ENV !== "production" && (n[q] = () => {
+    i = [], n.lc = 0, n.off();
+  }), n;
+};
+const xt = 5, v = 6, P = 10;
+let jt = (t, e, i, n) => (t.events = t.events || {}, t.events[i + P] || (t.events[i + P] = n((s) => {
+  t.events[i].reduceRight((r, o) => (o(r), r), {
+    shared: {},
+    ...s
+  });
+})), t.events[i] = t.events[i] || [], t.events[i].push(e), () => {
+  let s = t.events[i], r = s.indexOf(e);
+  s.splice(r, 1), s.length || (delete t.events[i], t.events[i + P](), delete t.events[i + P]);
+}), Mt = 1e3, Kt = (t, e) => jt(t, (n) => {
+  let s = e(n);
+  s && t.events[v].push(s);
+}, xt, (n) => {
+  let s = t.listen;
+  t.listen = (...o) => (!t.lc && !t.active && (t.active = !0, n()), s(...o));
+  let r = t.off;
+  if (t.events[v] = [], t.off = () => {
+    r(), setTimeout(() => {
+      if (t.active && !t.lc) {
+        t.active = !1;
+        for (let o of t.events[v]) o();
+        t.events[v] = [];
+      }
+    }, Mt);
+  }, process.env.NODE_ENV !== "production") {
+    let o = t[q];
+    t[q] = () => {
+      for (let u of t.events[v]) u();
+      t.events[v] = [], t.active = !1, o();
+    };
+  }
+  return () => {
+    t.listen = s, t.off = r;
+  };
+}), Gt = (t = {}) => {
+  let e = Ht(t);
+  return e.setKey = function(i, n) {
+    typeof n > "u" ? i in e.value && (e.value = { ...e.value }, delete e.value[i], e.notify(i)) : e.value[i] !== n && (e.value = {
+      ...e.value,
+      [i]: n
+    }, e.notify(i));
+  }, e;
+}, nt = (t) => t, W = {}, N = { addEventListener() {
+}, removeEventListener() {
+} };
+function zt() {
+  try {
+    return typeof localStorage < "u";
+  } catch {
+    return !1;
+  }
+}
+zt() && (W = localStorage);
+let Yt = {
+  addEventListener(t, e, i) {
+    window.addEventListener("storage", e), window.addEventListener("pageshow", i);
+  },
+  removeEventListener(t, e, i) {
+    window.removeEventListener("storage", e), window.removeEventListener("pageshow", i);
+  }
+};
+typeof window < "u" && (N = Yt);
+function Ot(t, e = {}, i = {}) {
+  let n = i.encode || nt, s = i.decode || nt, r = Gt(), o = r.setKey;
+  r.setKey = (a, c) => {
+    typeof c > "u" ? (i.listen !== !1 && N.perKey && N.removeEventListener(t + a, l, d), delete W[t + a]) : (i.listen !== !1 && N.perKey && !(a in r.value) && N.addEventListener(t + a, l, d), W[t + a] = n(c)), o(a, c);
+  };
+  let u = r.set;
+  r.set = function(a) {
+    for (let c in a)
+      r.setKey(c, a[c]);
+    for (let c in r.value)
+      c in a || r.setKey(c);
+  };
+  function l(a) {
+    a.key ? a.key.startsWith(t) && (a.newValue === null ? o(a.key.slice(t.length), void 0) : o(a.key.slice(t.length), s(a.newValue))) : u({});
+  }
+  function d() {
+    let a = { ...e };
+    for (let c in W)
+      c.startsWith(t) && (a[c.slice(t.length)] = s(W[c]));
+    r.set(a);
+  }
+  return Kt(r, () => {
+    if (d(), i.listen !== !1)
+      return N.addEventListener(t, l, d), () => {
+        N.removeEventListener(t, l, d);
+        for (let a in r.value)
+          N.removeEventListener(t + a, l, d);
+      };
+  }), r;
+}
+async function $t(t, {
+  version: e,
+  i18nPath: i = "https://discord.sh/i18n/db.json",
+  locale: n = "en",
+  defaults: s = {
+    welcome: "Welcome to the app!"
+  }
+}) {
+  console.log("[init-worker] Initializing database...");
+  try {
+    await t.loadI18nFromJSON(i), console.log(`[init-worker] i18n loaded from ${i}`), await t.dbSet("locale", n);
+    for (const [r, o] of Object.entries(s))
+      await t.dbSet(r, o);
+    await t.setVersion(e), t.loadServersFromJSON(), console.log(`[init-worker] DB initialized to version ${e}`);
+  } catch (r) {
+    console.error("[init-worker] Initialization failed:", r);
+  }
+}
+let F = null;
+async function Xt() {
+  if (F) return F;
+  const t = {};
+  async function e(r) {
+    const o = new Worker(r, { type: "module" }), u = V(o), l = await u.getMeta?.() ?? {
+      name: "unknown",
+      version: "0.0.1"
+    }, d = `${l.name}@${l.version}`;
+    console.log(`[mod-manager] ${d} is loaded.`);
+    const a = { id: d, worker: o, instance: u, meta: l, url: r };
+    return t[d] = a, a;
+  }
+  function i(r) {
+    t[r] && (t[r].worker.terminate(), delete t[r]);
+  }
+  function n() {
+    return Object.values(t).map((r) => r.meta);
+  }
+  async function s(r) {
+    const o = t[r];
+    if (!o) throw new Error(`Mod "${r}" not found`);
+    return i(r), e(o.url);
+  }
+  return F = {
+    registry: t,
+    load: e,
+    unload: i,
+    list: n,
+    reload: s
+  }, F;
+}
+var b = /* @__PURE__ */ ((t) => (t[t.PAYLOAD_UNKNOWN = 0] = "PAYLOAD_UNKNOWN", t[t.JSON = 1] = "JSON", t[t.FLEX = 2] = "FLEX", t[t.PROTOBUF = 3] = "PROTOBUF", t[t.FLATBUFFER = 4] = "FLATBUFFER", t))(b || {}), O = /* @__PURE__ */ ((t) => (t[t.UNKNOWN = 0] = "UNKNOWN", t[t.ADD = 1] = "ADD", t[t.READ = 2] = "READ", t[t.GET = 4] = "GET", t[t.SET = 8] = "SET", t[t.DEL = 16] = "DEL", t[t.STREAM = 32] = "STREAM", t[t.GROUP = 64] = "GROUP", t[t.LIST = 128] = "LIST", t[t.ACTION = 256] = "ACTION", t[t.MESSAGE = 512] = "MESSAGE", t[t.INFO = 1024] = "INFO", t[t.DEBUG = 2048] = "DEBUG", t[t.ERROR = 4096] = "ERROR", t[t.AUTH = 8192] = "AUTH", t[t.HEARTBEAT = 16384] = "HEARTBEAT", t[t.CONFIG_UPDATE = 32768] = "CONFIG_UPDATE", t[t.REDIS = 65536] = "REDIS", t[t.SUPABASE = 131072] = "SUPABASE", t[t.FILESYSTEM = 262144] = "FILESYSTEM", t[t.WEBSOCKET = 524288] = "WEBSOCKET", t[t.HTTP_API = 1048576] = "HTTP_API", t[t.LOCAL_CACHE = 2097152] = "LOCAL_CACHE", t[t.AI = 4194304] = "AI", t))(O || {}), p = /* @__PURE__ */ ((t) => (t[t.WIDTH8 = 0] = "WIDTH8", t[t.WIDTH16 = 1] = "WIDTH16", t[t.WIDTH32 = 2] = "WIDTH32", t[t.WIDTH64 = 3] = "WIDTH64", t))(p || {});
+function Jt(t) {
+  return 1 << t;
+}
+function qt(t) {
+  return t >= -128 && t <= 127 ? p.WIDTH8 : t >= -32768 && t <= 32767 ? p.WIDTH16 : t >= -2147483648 && t <= 2147483647 ? p.WIDTH32 : p.WIDTH64;
+}
+function Qt(t) {
+  return t === Math.fround(t) ? p.WIDTH32 : p.WIDTH64;
+}
+function C(t) {
+  return t <= 255 ? p.WIDTH8 : t <= 65535 ? p.WIDTH16 : t <= 4294967295 ? p.WIDTH32 : p.WIDTH64;
+}
+function g(t) {
+  return t === 1 ? p.WIDTH8 : t === 2 ? p.WIDTH16 : t === 4 ? p.WIDTH32 : p.WIDTH64;
+}
+function It(t, e) {
+  return ~t + 1 & e - 1;
+}
+function mt(t) {
+  return new TextDecoder().decode(t);
+}
+function Q(t) {
+  return new TextEncoder().encode(t);
+}
+var f = /* @__PURE__ */ ((t) => (t[t.NULL = 0] = "NULL", t[t.INT = 1] = "INT", t[t.UINT = 2] = "UINT", t[t.FLOAT = 3] = "FLOAT", t[t.KEY = 4] = "KEY", t[t.STRING = 5] = "STRING", t[t.INDIRECT_INT = 6] = "INDIRECT_INT", t[t.INDIRECT_UINT = 7] = "INDIRECT_UINT", t[t.INDIRECT_FLOAT = 8] = "INDIRECT_FLOAT", t[t.MAP = 9] = "MAP", t[t.VECTOR = 10] = "VECTOR", t[t.VECTOR_INT = 11] = "VECTOR_INT", t[t.VECTOR_UINT = 12] = "VECTOR_UINT", t[t.VECTOR_FLOAT = 13] = "VECTOR_FLOAT", t[t.VECTOR_KEY = 14] = "VECTOR_KEY", t[t.VECTOR_STRING_DEPRECATED = 15] = "VECTOR_STRING_DEPRECATED", t[t.VECTOR_INT2 = 16] = "VECTOR_INT2", t[t.VECTOR_UINT2 = 17] = "VECTOR_UINT2", t[t.VECTOR_FLOAT2 = 18] = "VECTOR_FLOAT2", t[t.VECTOR_INT3 = 19] = "VECTOR_INT3", t[t.VECTOR_UINT3 = 20] = "VECTOR_UINT3", t[t.VECTOR_FLOAT3 = 21] = "VECTOR_FLOAT3", t[t.VECTOR_INT4 = 22] = "VECTOR_INT4", t[t.VECTOR_UINT4 = 23] = "VECTOR_UINT4", t[t.VECTOR_FLOAT4 = 24] = "VECTOR_FLOAT4", t[t.BLOB = 25] = "BLOB", t[t.BOOL = 26] = "BOOL", t[t.VECTOR_BOOL = 36] = "VECTOR_BOOL", t))(f || {});
+function Y(t) {
+  return t === f.BOOL || t <= f.FLOAT;
+}
+function kt(t) {
+  return t >= f.INT && t <= f.FLOAT;
+}
+function Zt(t) {
+  return t >= f.INDIRECT_INT && t <= f.INDIRECT_FLOAT;
+}
+function te(t) {
+  return t === f.BOOL || t >= f.INT && t <= f.STRING;
+}
+function bt(t) {
+  return t === f.VECTOR_BOOL || t >= f.VECTOR_INT && t <= f.VECTOR_STRING_DEPRECATED;
+}
+function Z(t) {
+  return t >= f.VECTOR_INT2 && t <= f.VECTOR_FLOAT4;
+}
+function $(t) {
+  return bt(t) || Z(t) || t === f.VECTOR;
+}
+function ee(t, e) {
+  if (e === 0) return t - f.INT + f.VECTOR_INT;
+  if (e === 2) return t - f.INT + f.VECTOR_INT2;
+  if (e === 3) return t - f.INT + f.VECTOR_INT3;
+  if (e === 4) return t - f.INT + f.VECTOR_INT4;
+  throw "Unexpected length " + e;
+}
+function ie(t) {
+  return t - f.VECTOR_INT + f.INT;
+}
+function ne(t) {
+  return (t - f.VECTOR_INT2) % 3 + f.INT;
+}
+function se(t) {
+  return ((t - f.VECTOR_INT2) / 3 >> 0) + 2;
+}
+function tt(t, e) {
+  return e | t << 2;
+}
+class L {
+  constructor(e, i, n, s = null, r = 0) {
+    this.builder = e, this.type = i, this.width = n, this.value = s, this.offset = r;
+  }
+  elementWidth(e, i) {
+    if (Y(this.type)) return this.width;
+    for (let n = 0; n < 4; n++) {
+      const s = 1 << n, o = e + It(e, s) + i * s - this.offset, u = C(o);
+      if (1 << u === s)
+        return u;
+    }
+    throw `Element is unknown. Size: ${e} at index: ${i}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`;
+  }
+  writeToBuffer(e) {
+    const i = this.builder.computeOffset(e);
+    if (this.type === f.FLOAT)
+      this.width === p.WIDTH32 ? this.builder.view.setFloat32(this.builder.offset, this.value, !0) : this.builder.view.setFloat64(this.builder.offset, this.value, !0);
+    else if (this.type === f.INT) {
+      const n = g(e);
+      this.builder.pushInt(this.value, n);
+    } else if (this.type === f.UINT) {
+      const n = g(e);
+      this.builder.pushUInt(this.value, n);
+    } else if (this.type === f.NULL)
+      this.builder.pushInt(0, this.width);
+    else if (this.type === f.BOOL)
+      this.builder.pushInt(this.value ? 1 : 0, this.width);
+    else
+      throw `Unexpected type: ${this.type}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`;
+    this.offset = i;
+  }
+  storedWidth(e = p.WIDTH8) {
+    return Y(this.type) ? Math.max(e, this.width) : this.width;
+  }
+  storedPackedType(e = p.WIDTH8) {
+    return tt(this.type, this.storedWidth(e));
+  }
+  isOffset() {
+    return !Y(this.type);
+  }
+}
+class re {
+  constructor(e = 2048, i = !0, n = !0, s = !0) {
+    this.dedupStrings = i, this.dedupKeys = n, this.dedupKeyVectors = s, this.stack = [], this.stackPointers = [], this.offset = 0, this.finished = !1, this.stringLookup = {}, this.keyLookup = {}, this.keyVectorLookup = {}, this.indirectIntLookup = {}, this.indirectUIntLookup = {}, this.indirectFloatLookup = {}, this.buffer = new ArrayBuffer(e > 0 ? e : 2048), this.view = new DataView(this.buffer);
+  }
+  align(e) {
+    const i = Jt(e);
+    return this.offset += It(this.offset, i), i;
+  }
+  computeOffset(e) {
+    const i = this.offset + e;
+    let n = this.buffer.byteLength;
+    const s = n;
+    for (; n < i; )
+      n <<= 1;
+    if (s < n) {
+      const r = this.buffer;
+      this.buffer = new ArrayBuffer(n), this.view = new DataView(this.buffer), new Uint8Array(this.buffer).set(new Uint8Array(r), 0);
+    }
+    return i;
+  }
+  pushInt(e, i) {
+    if (i === p.WIDTH8)
+      this.view.setInt8(this.offset, e);
+    else if (i === p.WIDTH16)
+      this.view.setInt16(this.offset, e, !0);
+    else if (i === p.WIDTH32)
+      this.view.setInt32(this.offset, e, !0);
+    else if (i === p.WIDTH64)
+      this.view.setBigInt64(this.offset, BigInt(e), !0);
+    else
+      throw `Unexpected width: ${i} for value: ${e}`;
+  }
+  pushUInt(e, i) {
+    if (i === p.WIDTH8)
+      this.view.setUint8(this.offset, e);
+    else if (i === p.WIDTH16)
+      this.view.setUint16(this.offset, e, !0);
+    else if (i === p.WIDTH32)
+      this.view.setUint32(this.offset, e, !0);
+    else if (i === p.WIDTH64)
+      this.view.setBigUint64(this.offset, BigInt(e), !0);
+    else
+      throw `Unexpected width: ${i} for value: ${e}`;
+  }
+  writeInt(e, i) {
+    const n = this.computeOffset(i);
+    this.pushInt(e, g(i)), this.offset = n;
+  }
+  writeUInt(e, i) {
+    const n = this.computeOffset(i);
+    this.pushUInt(e, g(i)), this.offset = n;
+  }
+  writeBlob(e) {
+    const i = e.byteLength, n = C(i), s = this.align(n);
+    this.writeUInt(i, s);
+    const r = this.offset, o = this.computeOffset(i);
+    new Uint8Array(this.buffer).set(new Uint8Array(e), r), this.stack.push(this.offsetStackValue(r, f.BLOB, n)), this.offset = o;
+  }
+  writeString(e) {
+    if (this.dedupStrings && Object.prototype.hasOwnProperty.call(this.stringLookup, e)) {
+      this.stack.push(this.stringLookup[e]);
+      return;
+    }
+    const i = Q(e), n = i.length, s = C(n), r = this.align(s);
+    this.writeUInt(n, r);
+    const o = this.offset, u = this.computeOffset(n + 1);
+    new Uint8Array(this.buffer).set(i, o);
+    const l = this.offsetStackValue(o, f.STRING, s);
+    this.stack.push(l), this.dedupStrings && (this.stringLookup[e] = l), this.offset = u;
+  }
+  writeKey(e) {
+    if (this.dedupKeys && Object.prototype.hasOwnProperty.call(this.keyLookup, e)) {
+      this.stack.push(this.keyLookup[e]);
+      return;
+    }
+    const i = Q(e), n = i.length, s = this.computeOffset(n + 1);
+    new Uint8Array(this.buffer).set(i, this.offset);
+    const r = this.offsetStackValue(this.offset, f.KEY, p.WIDTH8);
+    this.stack.push(r), this.dedupKeys && (this.keyLookup[e] = r), this.offset = s;
+  }
+  writeStackValue(e, i) {
+    const n = this.computeOffset(i);
+    if (e.isOffset()) {
+      const s = this.offset - e.offset;
+      if (i === 8 || BigInt(s) < BigInt(1) << BigInt(i * 8))
+        this.writeUInt(s, i);
+      else
+        throw `Unexpected size ${i}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`;
+    } else
+      e.writeToBuffer(i);
+    this.offset = n;
+  }
+  integrityCheckOnValueAddition() {
+    if (this.finished)
+      throw "Adding values after finish is prohibited";
+    if (this.stackPointers.length !== 0 && this.stackPointers[this.stackPointers.length - 1].isVector === !1 && this.stack[this.stack.length - 1].type !== f.KEY)
+      throw "Adding value to a map before adding a key is prohibited";
+  }
+  integrityCheckOnKeyAddition() {
+    if (this.finished)
+      throw "Adding values after finish is prohibited";
+    if (this.stackPointers.length === 0 || this.stackPointers[this.stackPointers.length - 1].isVector)
+      throw "Adding key before starting a map is prohibited";
+  }
+  startVector() {
+    this.stackPointers.push({ stackPosition: this.stack.length, isVector: !0 });
+  }
+  startMap(e = !1) {
+    this.stackPointers.push({ stackPosition: this.stack.length, isVector: !1, presorted: e });
+  }
+  endVector(e) {
+    const i = this.stack.length - e.stackPosition, n = this.createVector(e.stackPosition, i, 1);
+    this.stack.splice(e.stackPosition, i), this.stack.push(n);
+  }
+  endMap(e) {
+    e.presorted || this.sort(e);
+    let i = "";
+    for (let o = e.stackPosition; o < this.stack.length; o += 2)
+      i += `,${this.stack[o].offset}`;
+    const n = this.stack.length - e.stackPosition >> 1;
+    this.dedupKeyVectors && !Object.prototype.hasOwnProperty.call(this.keyVectorLookup, i) && (this.keyVectorLookup[i] = this.createVector(e.stackPosition, n, 2));
+    const s = this.dedupKeyVectors ? this.keyVectorLookup[i] : this.createVector(e.stackPosition, n, 2), r = this.createVector(e.stackPosition + 1, n, 2, s);
+    this.stack.splice(e.stackPosition, n << 1), this.stack.push(r);
+  }
+  sort(e) {
+    const i = this.view, n = this.stack;
+    function s(a, c) {
+      if (a.type !== f.KEY || c.type !== f.KEY)
+        throw `Stack values are not keys ${a} | ${c}. Check if you combined [addKey] with add... method calls properly.`;
+      let h, w, y = 0;
+      do {
+        if (h = i.getUint8(a.offset + y), w = i.getUint8(c.offset + y), w < h) return !0;
+        if (h < w) return !1;
+        y += 1;
+      } while (h !== 0 && w !== 0);
+      return !1;
+    }
+    function r(a, c, h) {
+      if (c === h) return;
+      const w = a[c], y = a[c + 1];
+      a[c] = a[h], a[c + 1] = a[h + 1], a[h] = w, a[h + 1] = y;
+    }
+    function o() {
+      for (let a = e.stackPosition; a < n.length; a += 2) {
+        let c = a;
+        for (let h = a + 2; h < n.length; h += 2)
+          s(n[c], n[h]) && (c = h);
+        c !== a && r(n, c, a);
+      }
+    }
+    function u(a, c) {
+      if (a.type !== f.KEY || c.type !== f.KEY)
+        throw `Stack values are not keys ${a} | ${c}. Check if you combined [addKey] with add... method calls properly.`;
+      if (a.offset === c.offset)
+        return !1;
+      let h, w, y = 0;
+      do {
+        if (h = i.getUint8(a.offset + y), w = i.getUint8(c.offset + y), h < w) return !0;
+        if (w < h) return !1;
+        y += 1;
+      } while (h !== 0 && w !== 0);
+      return !1;
+    }
+    function l(a, c) {
+      if (a < c) {
+        const h = a + (c - a >> 2) * 2, w = n[h];
+        let y = a, S = c;
+        do {
+          for (; u(n[y], w); )
+            y += 2;
+          for (; u(w, n[S]); )
+            S -= 2;
+          y <= S && (r(n, y, S), y += 2, S -= 2);
+        } while (y <= S);
+        l(a, S), l(y, c);
+      }
+    }
+    let d = !0;
+    for (let a = e.stackPosition; a < this.stack.length - 2; a += 2)
+      if (s(this.stack[a], this.stack[a + 2])) {
+        d = !1;
+        break;
+      }
+    d || (this.stack.length - e.stackPosition > 40 ? l(e.stackPosition, this.stack.length - 2) : o());
+  }
+  end() {
+    if (this.stackPointers.length < 1) return;
+    const e = this.stackPointers.pop();
+    e.isVector ? this.endVector(e) : this.endMap(e);
+  }
+  createVector(e, i, n, s = null) {
+    let r = C(i), o = 1;
+    if (s !== null) {
+      const h = s.elementWidth(this.offset, 0);
+      h > r && (r = h), o += 2;
+    }
+    let u = f.KEY, l = s === null;
+    for (let h = e; h < this.stack.length; h += n) {
+      const w = this.stack[h].elementWidth(this.offset, h + o);
+      w > r && (r = w), h === e ? (u = this.stack[h].type, l = l && te(u)) : u !== this.stack[h].type && (l = !1);
+    }
+    const d = this.align(r), a = l && kt(u) && i >= 2 && i <= 4;
+    s !== null && (this.writeStackValue(s, d), this.writeUInt(1 << s.width, d)), a || this.writeUInt(i, d);
+    const c = this.offset;
+    for (let h = e; h < this.stack.length; h += n)
+      this.writeStackValue(this.stack[h], d);
+    if (!l)
+      for (let h = e; h < this.stack.length; h += n)
+        this.writeUInt(this.stack[h].storedPackedType(), 1);
+    if (s !== null)
+      return this.offsetStackValue(c, f.MAP, r);
+    if (l) {
+      const h = ee(u, a ? i : 0);
+      return this.offsetStackValue(c, h, r);
+    }
+    return this.offsetStackValue(c, f.VECTOR, r);
+  }
+  nullStackValue() {
+    return new L(this, f.NULL, p.WIDTH8);
+  }
+  boolStackValue(e) {
+    return new L(this, f.BOOL, p.WIDTH8, e);
+  }
+  intStackValue(e) {
+    return new L(this, f.INT, qt(e), e);
+  }
+  uintStackValue(e) {
+    return new L(this, f.UINT, C(e), e);
+  }
+  floatStackValue(e) {
+    return new L(this, f.FLOAT, Qt(e), e);
+  }
+  offsetStackValue(e, i, n) {
+    return new L(this, i, n, null, e);
+  }
+  finishBuffer() {
+    if (this.stack.length !== 1)
+      throw `Stack has to be exactly 1, but it is ${this.stack.length}. You have to end all started vectors and maps before calling [finish]`;
+    const e = this.stack[0], i = this.align(e.elementWidth(this.offset, 0));
+    this.writeStackValue(e, i), this.writeUInt(e.storedPackedType(), 1), this.writeUInt(i, 1), this.finished = !0;
+  }
+  add(e) {
+    if (this.integrityCheckOnValueAddition(), typeof e > "u")
+      throw "You need to provide a value";
+    if (e === null)
+      this.stack.push(this.nullStackValue());
+    else if (typeof e == "boolean")
+      this.stack.push(this.boolStackValue(e));
+    else if (typeof e == "bigint")
+      this.stack.push(this.intStackValue(e));
+    else if (typeof e == "number")
+      Number.isInteger(e) ? this.stack.push(this.intStackValue(e)) : this.stack.push(this.floatStackValue(e));
+    else if (ArrayBuffer.isView(e))
+      this.writeBlob(e.buffer);
+    else if (typeof e == "string" || e instanceof String)
+      this.writeString(e);
+    else if (Array.isArray(e)) {
+      this.startVector();
+      for (let i = 0; i < e.length; i++)
+        this.add(e[i]);
+      this.end();
+    } else if (typeof e == "object") {
+      const i = Object.getOwnPropertyNames(e).sort();
+      this.startMap(!0);
+      for (let n = 0; n < i.length; n++) {
+        const s = i[n];
+        this.addKey(s), this.add(e[s]);
+      }
+      this.end();
+    } else
+      throw `Unexpected value input ${e}`;
+  }
+  finish() {
+    this.finished || this.finishBuffer();
+    const e = this.buffer.slice(0, this.offset);
+    return new Uint8Array(e);
+  }
+  isFinished() {
+    return this.finished;
+  }
+  addKey(e) {
+    this.integrityCheckOnKeyAddition(), this.writeKey(e);
+  }
+  addInt(e, i = !1, n = !1) {
+    if (this.integrityCheckOnValueAddition(), !i) {
+      this.stack.push(this.intStackValue(e));
+      return;
+    }
+    if (n && Object.prototype.hasOwnProperty.call(this.indirectIntLookup, e)) {
+      this.stack.push(this.indirectIntLookup[e]);
+      return;
+    }
+    const s = this.intStackValue(e), r = this.align(s.width), o = this.computeOffset(r), u = this.offset;
+    s.writeToBuffer(r);
+    const l = this.offsetStackValue(u, f.INDIRECT_INT, s.width);
+    this.stack.push(l), this.offset = o, n && (this.indirectIntLookup[e] = l);
+  }
+  addUInt(e, i = !1, n = !1) {
+    if (this.integrityCheckOnValueAddition(), !i) {
+      this.stack.push(this.uintStackValue(e));
+      return;
+    }
+    if (n && Object.prototype.hasOwnProperty.call(this.indirectUIntLookup, e)) {
+      this.stack.push(this.indirectUIntLookup[e]);
+      return;
+    }
+    const s = this.uintStackValue(e), r = this.align(s.width), o = this.computeOffset(r), u = this.offset;
+    s.writeToBuffer(r);
+    const l = this.offsetStackValue(u, f.INDIRECT_UINT, s.width);
+    this.stack.push(l), this.offset = o, n && (this.indirectUIntLookup[e] = l);
+  }
+  addFloat(e, i = !1, n = !1) {
+    if (this.integrityCheckOnValueAddition(), !i) {
+      this.stack.push(this.floatStackValue(e));
+      return;
+    }
+    if (n && Object.prototype.hasOwnProperty.call(this.indirectFloatLookup, e)) {
+      this.stack.push(this.indirectFloatLookup[e]);
+      return;
+    }
+    const s = this.floatStackValue(e), r = this.align(s.width), o = this.computeOffset(r), u = this.offset;
+    s.writeToBuffer(r);
+    const l = this.offsetStackValue(u, f.INDIRECT_FLOAT, s.width);
+    this.stack.push(l), this.offset = o, n && (this.indirectFloatLookup[e] = l);
+  }
+}
+function X(t, e, i) {
+  return i < 2 ? i < 1 ? t.getInt8(e) : t.getInt16(e, !0) : i < 3 ? t.getInt32(e, !0) : t.setBigInt64 === void 0 ? BigInt(t.getUint32(e, !0)) + (BigInt(t.getUint32(e + 4, !0)) << BigInt(32)) : t.getBigInt64(e, !0);
+}
+function k(t, e, i) {
+  return i < 2 ? i < 1 ? t.getUint8(e) : t.getUint16(e, !0) : i < 3 ? t.getUint32(e, !0) : t.getBigUint64 === void 0 ? BigInt(t.getUint32(e, !0)) + (BigInt(t.getUint32(e + 4, !0)) << BigInt(32)) : t.getBigUint64(e, !0);
+}
+function st(t, e, i) {
+  if (i < p.WIDTH32)
+    throw "Bad width: " + i;
+  return i === p.WIDTH32 ? t.getFloat32(e, !0) : t.getFloat64(e, !0);
+}
+function m(t, e, i) {
+  const n = k(t, e, i);
+  return e - n;
+}
+function oe(t, e, i, n, s, r) {
+  const o = Q(t), u = m(e, i, n) - s * 3, l = g(s), d = u - Number(k(e, u, l)), a = Number(k(e, u + s, l));
+  let c = 0, h = r - 1;
+  for (; c <= h; ) {
+    const w = h + c >> 1, y = ae(o, w, e, d, a);
+    if (y === 0) return w;
+    y < 0 ? h = w - 1 : c = w + 1;
+  }
+  return null;
+}
+function ae(t, e, i, n, s) {
+  const r = n + e * s, o = r - Number(k(i, r, g(s)));
+  for (let u = 0; u < t.length; u++) {
+    const l = t[u] - i.getUint8(o + u);
+    if (l !== 0)
+      return l;
+  }
+  return i.getUint8(o + t.length) === 0 ? 0 : -1;
+}
+function fe(t, e, i, n, s) {
+  const r = m(e, i, n) - s * 3, o = g(s), u = r - Number(k(e, r, o)), l = Number(k(e, r + s, o)), d = u + t * l, a = d - Number(k(e, d, g(l)));
+  let c = 0;
+  for (; e.getUint8(a + c) !== 0; )
+    c++;
+  return mt(new Uint8Array(e.buffer, a, c));
+}
+function et(t) {
+  const e = t.byteLength;
+  if (e < 3)
+    throw "Buffer needs to be bigger than 3";
+  const i = new DataView(t), n = i.getUint8(e - 1), s = i.getUint8(e - 2), r = g(n), o = e - n - 2;
+  return new G(i, o, r, s, "/");
+}
+function rt(t, e, i, n, s, r, o, u) {
+  const l = m(i, n, s), d = l + t * r, a = i.getUint8(l + o * r + t);
+  return new G(i, d, g(r), a, `${u}/${e}`);
+}
+class G {
+  constructor(e, i, n, s, r) {
+    this.dataView = e, this.offset = i, this.parentWidth = n, this.packedType = s, this.path = r, this._length = -1, this.byteWidth = 1 << (s & 3), this.valueType = s >> 2;
+  }
+  isNull() {
+    return this.valueType === f.NULL;
+  }
+  isNumber() {
+    return kt(this.valueType) || Zt(this.valueType);
+  }
+  isFloat() {
+    return f.FLOAT === this.valueType || f.INDIRECT_FLOAT === this.valueType;
+  }
+  isInt() {
+    return this.isNumber() && !this.isFloat();
+  }
+  isString() {
+    return f.STRING === this.valueType || f.KEY === this.valueType;
+  }
+  isBool() {
+    return f.BOOL === this.valueType;
+  }
+  isBlob() {
+    return f.BLOB === this.valueType;
+  }
+  isVector() {
+    return $(this.valueType);
+  }
+  isMap() {
+    return f.MAP === this.valueType;
+  }
+  boolValue() {
+    return this.isBool() ? X(this.dataView, this.offset, this.parentWidth) > 0 : null;
+  }
+  intValue() {
+    return this.valueType === f.INT ? X(this.dataView, this.offset, this.parentWidth) : this.valueType === f.UINT ? k(this.dataView, this.offset, this.parentWidth) : this.valueType === f.INDIRECT_INT ? X(this.dataView, m(this.dataView, this.offset, this.parentWidth), g(this.byteWidth)) : this.valueType === f.INDIRECT_UINT ? k(this.dataView, m(this.dataView, this.offset, this.parentWidth), g(this.byteWidth)) : null;
+  }
+  floatValue() {
+    return this.valueType === f.FLOAT ? st(this.dataView, this.offset, this.parentWidth) : this.valueType === f.INDIRECT_FLOAT ? st(this.dataView, m(this.dataView, this.offset, this.parentWidth), g(this.byteWidth)) : null;
+  }
+  numericValue() {
+    return this.floatValue() || this.intValue();
+  }
+  stringValue() {
+    if (this.valueType === f.STRING || this.valueType === f.KEY) {
+      const e = m(this.dataView, this.offset, this.parentWidth);
+      return mt(new Uint8Array(this.dataView.buffer, e, this.length()));
+    }
+    return null;
+  }
+  blobValue() {
+    if (this.isBlob()) {
+      const e = m(this.dataView, this.offset, this.parentWidth);
+      return new Uint8Array(this.dataView.buffer, e, this.length());
+    }
+    return null;
+  }
+  get(e) {
+    const i = this.length();
+    if (Number.isInteger(e) && $(this.valueType)) {
+      if (e >= i || e < 0)
+        throw `Key: [${e}] is not applicable on ${this.path} of ${this.valueType} length: ${i}`;
+      const n = m(this.dataView, this.offset, this.parentWidth), s = n + e * this.byteWidth;
+      let r = this.dataView.getUint8(n + i * this.byteWidth + e);
+      if (bt(this.valueType)) {
+        const o = ie(this.valueType);
+        r = tt(o, p.WIDTH8);
+      } else if (Z(this.valueType)) {
+        const o = ne(this.valueType);
+        r = tt(o, p.WIDTH8);
+      }
+      return new G(this.dataView, s, g(this.byteWidth), r, `${this.path}[${e}]`);
+    }
+    if (typeof e == "string") {
+      const n = oe(e, this.dataView, this.offset, this.parentWidth, this.byteWidth, i);
+      if (n !== null)
+        return rt(n, e, this.dataView, this.offset, this.parentWidth, this.byteWidth, i, this.path);
+    }
+    throw `Key [${e}] is not applicable on ${this.path} of ${this.valueType}`;
+  }
+  length() {
+    let e;
+    if (this._length > -1)
+      return this._length;
+    if (Z(this.valueType))
+      this._length = se(this.valueType);
+    else if (this.valueType === f.BLOB || this.valueType === f.MAP || $(this.valueType))
+      this._length = k(this.dataView, m(this.dataView, this.offset, this.parentWidth) - this.byteWidth, g(this.byteWidth));
+    else if (this.valueType === f.NULL)
+      this._length = 0;
+    else if (this.valueType === f.STRING) {
+      const i = m(this.dataView, this.offset, this.parentWidth);
+      let n = this.byteWidth;
+      for (e = k(this.dataView, i - n, g(this.byteWidth)); this.dataView.getInt8(i + e) !== 0; )
+        n <<= 1, e = k(this.dataView, i - n, g(this.byteWidth));
+      this._length = e;
+    } else if (this.valueType === f.KEY) {
+      const i = m(this.dataView, this.offset, this.parentWidth);
+      for (e = 1; this.dataView.getInt8(i + e) !== 0; )
+        e++;
+      this._length = e;
+    } else
+      this._length = 1;
+    return Number(this._length);
+  }
+  toObject() {
+    const e = this.length();
+    if (this.isVector()) {
+      const i = [];
+      for (let n = 0; n < e; n++)
+        i.push(this.get(n).toObject());
+      return i;
+    }
+    if (this.isMap()) {
+      const i = {};
+      for (let n = 0; n < e; n++) {
+        const s = fe(n, this.dataView, this.offset, this.parentWidth, this.byteWidth);
+        i[s] = rt(n, s, this.dataView, this.offset, this.parentWidth, this.byteWidth, e, this.path).toObject();
+      }
+      return i;
+    }
+    return this.isNull() ? null : this.isBool() ? this.boolValue() : this.isNumber() ? this.numericValue() : this.blobValue() || this.stringValue();
+  }
+}
+function K() {
+  return new re();
+}
+function ce(t) {
+  const e = K();
+  e.startMap();
+  for (const [i, n] of Object.entries(t))
+    e.addKey(i), e.add(n);
+  return e.end(), e.finish();
+}
+function _(t, e, i, n, s = 1) {
+  let r;
+  if (i === b.FLEX)
+    r = ce(t);
+  else if (i === b.JSON)
+    r = new TextEncoder().encode(JSON.stringify(t));
+  else
+    throw new Error("Unsupported format for wrapEnvelope");
+  const o = K();
+  return o.startMap(), o.addKey("version"), o.add(s), o.addKey("kind"), o.add(e), o.addKey("format"), o.add(i), o.addKey("payload"), o.add(r), o.addKey("metadata"), o.add(n ?? new Uint8Array()), o.end(), o.finish();
+}
+function Nt(t) {
+  const e = t instanceof Uint8Array ? t : new Uint8Array(t), i = et(e.buffer).toObject();
+  if (typeof i.version != "number" || typeof i.kind != "number" || typeof i.format != "number" || !i.payload)
+    throw console.error("[unwrapEnvelope] Bad root:", i), new Error("[unwrapEnvelope] Invalid envelope structure");
+  const n = {
+    version: i.version,
+    kind: i.kind,
+    format: i.format,
+    payload: new Uint8Array(i.payload),
+    metadata: i.metadata ? new Uint8Array(i.metadata) : void 0
+  };
+  let s;
+  if (n.format === b.FLEX)
+    s = et(n.payload.buffer).toObject();
+  else if (n.format === b.JSON)
+    s = JSON.parse(new TextDecoder().decode(n.payload));
+  else
+    throw new Error(`[unwrapEnvelope] Unsupported format: ${n.format}`);
+  return { envelope: n, payload: s };
+}
+function St(t) {
+  return et(t.buffer).toObject();
+}
+function he(t) {
+  try {
+    const e = t instanceof Uint8Array ? t : new Uint8Array(t), i = St(e);
+    console.log("[FlexObject]", JSON.stringify(i, null, 2));
+  } catch (e) {
+    console.error("[Flex Decode Error]", e);
+  }
+}
+function Rt(t, e) {
+  return (t & e) === e;
+}
+function le(t, e) {
+  return _(
+    { key: t, value: e },
+    O.SET | O.REDIS,
+    b.FLEX
+  );
+}
+function ue(t) {
+  return _(
+    { key: t },
+    O.GET | O.REDIS,
+    b.FLEX
+  );
+}
+function de(t) {
+  return _(
+    { key: t },
+    O.DEL | O.REDIS,
+    b.FLEX
+  );
+}
+function pe(t) {
+  const e = Nt(t);
+  if (!Rt(e.envelope.kind, O.REDIS))
+    throw new Error("[Redis] Not a Redis envelope");
+  return e;
+}
+function we(t, e, i = "*") {
+  return _(
+    { stream: t, id: i, fields: e },
+    O.ADD | O.STREAM | O.REDIS,
+    b.FLEX
+  );
+}
+function ye(t, e, i) {
+  const n = K();
+  n.startMap(), n.addKey("streams"), n.startVector();
+  for (const { stream: o, id: u } of t)
+    n.startMap(), n.addKey("stream"), n.add(o), n.addKey("id"), n.add(u), n.end();
+  n.end(), e !== void 0 && (n.addKey("count"), n.add(e)), i !== void 0 && (n.addKey("block"), n.add(i)), n.end();
+  const s = n.finish(), r = K();
+  return r.startMap(), r.addKey("version"), r.add(1), r.addKey("kind"), r.add(O.READ | O.STREAM | O.REDIS), r.addKey("format"), r.add(b.FLEX), r.addKey("payload"), r.add(s), r.addKey("metadata"), r.add(new Uint8Array()), r.end(), r.finish();
+}
+const ge = {
+  wrapEnvelope: _,
+  unwrapEnvelope: Nt,
+  MessageKind: O,
+  PayloadFormat: b,
+  unwrapFlexToJson: St,
+  inspectFlex: he,
+  hasKind: Rt,
+  redis: {
+    wrapRedisSet: le,
+    wrapRedisGet: ue,
+    wrapRedisDel: de,
+    wrapRedisXAdd: we,
+    wrapRedisXRead: ye,
+    parseRedisPayload: pe
+  }
+};
+function vt(t) {
+  typeof queueMicrotask == "function" ? queueMicrotask(t) : setTimeout(t, 0);
+}
+function Lt(t) {
+  const e = document.createElement(t.tag);
+  if (t.class && (e.className = t.class), t.attrs)
+    for (const [i, n] of Object.entries(t.attrs))
+      if (typeof n == "function" && i.startsWith("on"))
+        e.addEventListener(i.slice(2).toLowerCase(), n);
+      else if (i === "style" && typeof n == "object")
+        Object.assign(e.style, n);
+      else if (i === "dataset" && typeof n == "object")
+        for (const [s, r] of Object.entries(n))
+          e.dataset[s] = String(r);
+      else
+        try {
+          e.setAttribute(i, String(n));
+        } catch {
+        }
+  if (t.style && Object.assign(e.style, t.style), t.children)
+    for (const i of t.children) {
+      const n = typeof i == "string" ? document.createTextNode(i) : Lt(i);
+      e.appendChild(n);
+    }
+  return e;
+}
+const Te = T.enum(["top", "right", "bottom", "left"]), Ee = T.object({
+  width: T.number(),
+  height: T.number(),
+  mode: T.enum(["static", "animated", "dynamic"]).optional()
+});
+T.object({
+  rawHtml: T.string().optional(),
+  needsCanvas: T.boolean().optional(),
+  canvasOptions: Ee.optional()
+});
+const Oe = T.object({
+  name: T.string(),
+  version: T.string().optional()
+}), Ie = T.object({
+  meta: Oe.optional(),
+  timestamp: T.number()
+}), ot = T.object({
+  id: Te,
+  payload: T.any().optional()
+}), me = T.object({
+  timestamp: T.number()
+}), ke = {
+  "droid-ready": me,
+  "droid-mod-ready": Ie,
+  "panel-open": ot,
+  "panel-close": ot
+};
+class be {
+  listeners = /* @__PURE__ */ new Map();
+  on(e, i) {
+    let n = this.listeners.get(e);
+    n || (n = /* @__PURE__ */ new Set(), this.listeners.set(e, n)), n.add(i);
+  }
+  off(e, i) {
+    this.listeners.get(e)?.delete(i);
+  }
+  emit(e, i) {
+    const n = ke[e];
+    if (n)
+      try {
+        n.parse(i);
+      } catch (s) {
+        console.error(`[DroidEventBus] Invalid payload for ${e}:`, s);
+        return;
+      }
+    window.dispatchEvent(new CustomEvent(e, { detail: i }));
+    for (const s of this.listeners.get(e) ?? [])
+      s(i);
+  }
+  wait(e) {
+    return new Promise((i) => {
+      const n = (s) => {
+        this.off(e, n), i(s);
+      };
+      this.on(e, n);
+    });
+  }
+}
+const Ne = new be(), at = "1.0.3";
+async function Se() {
+  const t = new SharedWorker(new URL(
+    /* @vite-ignore */
+    "/assets/ws-worker-FssAQgaD.js",
+    import.meta.url
+  ), {
+    type: "module"
+  });
+  return t.port.start(), V(t.port);
+}
+const I = Ot(
+  "uiux-state",
+  {
+    panelManager: {
+      top: { open: !1 },
+      right: { open: !1 },
+      bottom: { open: !1 },
+      left: { open: !1 }
+    },
+    themeManager: { theme: "auto" },
+    toastManager: {},
+    scrollY: 0
+  },
+  {
+    encode: JSON.stringify,
+    decode: JSON.parse
+  }
+), Re = V(
+  new Worker(new URL(
+    /* @vite-ignore */
+    "/assets/canvas-worker-DbsoY2Xv.js",
+    import.meta.url
+  ), { type: "module" })
+), ft = {
+  state: I,
+  worker: Re,
+  openPanel(t, e) {
+    const i = { ...I.get().panelManager };
+    i[t] = { open: !0, payload: e }, I.setKey("panelManager", i);
+  },
+  closePanel(t) {
+    const e = { ...I.get().panelManager };
+    e[t] = { open: !1, payload: void 0 }, I.setKey("panelManager", e);
+  },
+  togglePanel(t, e) {
+    const i = { ...I.get().panelManager }, n = i[t]?.open ?? !1;
+    i[t] = { open: !n, payload: n ? void 0 : e }, I.setKey("panelManager", i);
+  },
+  setTheme(t) {
+    I.setKey("themeManager", { theme: t });
+  },
+  addToast(t, e) {
+    const i = { ...I.get().toastManager, [t]: e };
+    I.setKey("toastManager", i);
+  },
+  removeToast(t) {
+    const e = { ...I.get().toastManager };
+    delete e[t], I.setKey("toastManager", e);
+  },
+  async dispatchCanvasRequest(t, e, i = "animated") {
+    const n = e.transferControlToOffscreen();
+    await this.worker.bindCanvas(t, n, i);
+  },
+  closeAllPanels() {
+    const t = { ...I.get().panelManager };
+    console.log("error panel is closing");
+    for (const e of Object.keys(t))
+      t[e] = { open: !1, payload: void 0 };
+    I.setKey("panelManager", t);
+  },
+  emitFromWorker(t) {
+    t.type === "injectVNode" && t.vnode && vt(() => {
+      const e = document.getElementById("bento-grid-inject");
+      if (!e) {
+        console.warn(
+          "[KBVE] No injection target found: #bento-grid-inject"
+        );
+        return;
+      }
+      const i = Lt(t.vnode);
+      if (i.classList.add("animate-fade-in"), t.vnode.id) {
+        const n = document.getElementById(t.vnode.id);
+        n && n.remove();
+      }
+      e.appendChild(i);
+    });
+  }
+}, A = Ot(
+  "i18n-cache",
+  {},
+  {
+    encode: JSON.stringify,
+    decode: JSON.parse
+  }
+), D = {
+  store: A,
+  api: null,
+  ready: Promise.resolve(),
+  get(t) {
+    return A.get()[t] ?? `[${t}]`;
+  },
+  async getAsync(t) {
+    const e = A.get()[t];
+    if (e !== void 0) return e;
+    if (!this.api) return `[${t}]`;
+    const i = await this.api.getTranslation(t);
+    return i !== null ? (A.setKey(t, i), i) : `[${t}]`;
+  },
+  set(t, e) {
+    A.setKey(t, e);
+  },
+  async hydrate(t, e) {
+    this.api = t;
+    for (const i of e) {
+      const n = await t.getTranslation(i);
+      n !== null && A.setKey(i, n);
+    }
+  },
+  async hydrateLocale(t = "en") {
+    if (!this.api) return;
+    const i = (await this.api.getAllI18nKeys()).filter(
+      (s) => s.startsWith(`${t}:`)
+    ), n = await this.api.getTranslations(i);
+    for (const [s, r] of Object.entries(n))
+      console.log(`[i18n.setKey] ${s} = ${r}`), this.store.setKey(s, r);
+  }
+};
+function ct() {
+  if (!navigator.serviceWorker?.controller) return;
+  const t = new MessageChannel();
+  navigator.serviceWorker.controller.postMessage(t.port2, [
+    t.port2
+  ]), t.port1.start();
+}
+async function ve() {
+  const t = new SharedWorker(new URL(
+    /* @vite-ignore */
+    "/assets/db-worker-CjXS52DQ.js",
+    import.meta.url
+  ), {
+    type: "module"
+  });
+  t.port.start();
+  const e = V(t.port);
+  return await e.getVersion() !== at && await $t(e, {
+    version: at,
+    i18nPath: "https://discord.sh/i18n/db.json",
+    locale: "en",
+    defaults: { welcome: "Welcome!", theme: "dark" }
+  }), e;
+}
+let ht = !1;
+function Le(t, e) {
+  const i = Et(async (n) => {
+    vt(() => {
+      const s = `ws:${Date.now()}`;
+      e.storeWsMessage(s, n);
+    });
+  });
+  t.onMessage(Tt(i, [0]));
+}
+async function Ue() {
+  if (ht || (ht = !0, navigator.serviceWorker?.controller ? ct() : navigator.serviceWorker?.addEventListener(
+    "controllerchange",
+    ct
+  )), !window.kbve?.api || !window.kbve?.i18n || !window.kbve?.uiux) {
+    const e = await ve(), i = await Se(), n = await Xt(), s = Ne;
+    for (const o of Object.values(n.registry))
+      typeof o.instance.init == "function" && await o.instance.init({
+        emitFromWorker: ft.emitFromWorker
+      }), console.log("[Event] -> Fire Mod Ready"), s.emit("droid-mod-ready", {
+        meta: o.meta,
+        timestamp: Date.now()
+      });
+    Le(i, e);
+    const r = ge;
+    D.api = e, D.ready = D.hydrateLocale("en"), window.kbve = {
+      ...window.kbve || {},
+      api: e,
+      i18n: D,
+      uiux: ft,
+      ws: i,
+      data: r,
+      mod: n,
+      events: s
+    }, await D.ready, window.kbve.events.emit("droid-ready", {
+      timestamp: Date.now()
+    }), document.addEventListener("astro:page-load", () => {
+      console.debug("[KBVE] Re-dispatched droid-ready after astro:page-load"), window.kbve?.events.emit("droid-ready", {
+        timestamp: Date.now()
+      });
+    }), console.log("[KBVE] Global API ready");
+  } else
+    console.log("[KBVE] Already initialized");
+}
+export {
+  Le as bridgeWsToDb,
+  D as i18n,
+  Ue as main,
+  ft as uiux
+};