@kbve/droid 0.0.2 → 0.0.4

package/workers/main.js

@@ -0,0 +1,1091 @@
+import { w as b, p as Z, t as tt } from "../comlink.js";
+import { i as P, u as T, V as d, B as O, f as N, p as et, a as Y, t as it, b as j, c as st, d as ot, e as nt, g as rt, h as at, j as C } from "../reference.js";
+import { z as k } from "../index.js";
+let F = Symbol("clean"), y = [], lt = (e, t) => {
+  let i = [], s = {
+    get() {
+      return s.lc || s.listen(() => {
+      })(), s.value;
+    },
+    l: 0,
+    lc: 0,
+    listen(o, n) {
+      return s.lc = i.push(o, n || s.l) / 2, () => {
+        let r = i.indexOf(o);
+        ~r && (i.splice(r, 2), --s.lc || s.off());
+      };
+    },
+    notify(o) {
+      let n = !y.length;
+      for (let r = 0; r < i.length; r += 2)
+        y.push(
+          i[r],
+          i[r + 1],
+          s.value,
+          o
+        );
+      if (n) {
+        for (let r = 0; r < y.length; r += 4) {
+          let h;
+          for (let c = r + 1; !h && (c += 4) < y.length; )
+            y[c] < y[r + 1] && (h = y.push(
+              y[r],
+              y[r + 1],
+              y[r + 2],
+              y[r + 3]
+            ));
+          h || y[r](y[r + 2], y[r + 3]);
+        }
+        y.length = 0;
+      }
+    },
+    off() {
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    set(o) {
+      s.value !== o && (s.value = o, s.notify());
+    },
+    subscribe(o, n) {
+      let r = s.listen(o, n);
+      return o(s.value), r;
+    },
+    value: e
+  };
+  return process.env.NODE_ENV !== "production" && (s[F] = () => {
+    i = [], s.lc = 0, s.off();
+  }), s;
+};
+const ft = 5, S = 6, V = 10;
+let ct = (e, t, i, s) => (e.events = e.events || {}, e.events[i + V] || (e.events[i + V] = s((o) => {
+  e.events[i].reduceRight((n, r) => (r(n), n), {
+    shared: {},
+    ...o
+  });
+})), e.events[i] = e.events[i] || [], e.events[i].push(t), () => {
+  let o = e.events[i], n = o.indexOf(t);
+  o.splice(n, 1), o.length || (delete e.events[i], e.events[i + V](), delete e.events[i + V]);
+}), ht = 1e3, dt = (e, t) => ct(e, (s) => {
+  let o = t(s);
+  o && e.events[S].push(o);
+}, ft, (s) => {
+  let o = e.listen;
+  e.listen = (...r) => (!e.lc && !e.active && (e.active = !0, s()), o(...r));
+  let n = e.off;
+  if (e.events[S] = [], e.off = () => {
+    n(), setTimeout(() => {
+      if (e.active && !e.lc) {
+        e.active = !1;
+        for (let r of e.events[S]) r();
+        e.events[S] = [];
+      }
+    }, ht);
+  }, process.env.NODE_ENV !== "production") {
+    let r = e[F];
+    e[F] = () => {
+      for (let h of e.events[S]) h();
+      e.events[S] = [], e.active = !1, r();
+    };
+  }
+  return () => {
+    e.listen = o, e.off = n;
+  };
+}), ut = (e = {}) => {
+  let t = lt(e);
+  return t.setKey = function(i, s) {
+    typeof s > "u" ? i in t.value && (t.value = { ...t.value }, delete t.value[i], t.notify(i)) : t.value[i] !== s && (t.value = {
+      ...t.value,
+      [i]: s
+    }, t.notify(i));
+  }, t;
+}, H = (e) => e, U = {}, v = { addEventListener() {
+}, removeEventListener() {
+} };
+function wt() {
+  try {
+    return typeof localStorage < "u";
+  } catch {
+    return !1;
+  }
+}
+wt() && (U = localStorage);
+let pt = {
+  addEventListener(e, t, i) {
+    window.addEventListener("storage", t), window.addEventListener("pageshow", i);
+  },
+  removeEventListener(e, t, i) {
+    window.removeEventListener("storage", t), window.removeEventListener("pageshow", i);
+  }
+};
+typeof window < "u" && (v = pt);
+function G(e, t = {}, i = {}) {
+  let s = i.encode || H, o = i.decode || H, n = ut(), r = n.setKey;
+  n.setKey = (a, l) => {
+    typeof l > "u" ? (i.listen !== !1 && v.perKey && v.removeEventListener(e + a, c, u), delete U[e + a]) : (i.listen !== !1 && v.perKey && !(a in n.value) && v.addEventListener(e + a, c, u), U[e + a] = s(l)), r(a, l);
+  };
+  let h = n.set;
+  n.set = function(a) {
+    for (let l in a)
+      n.setKey(l, a[l]);
+    for (let l in n.value)
+      l in a || n.setKey(l);
+  };
+  function c(a) {
+    a.key ? a.key.startsWith(e) && (a.newValue === null ? r(a.key.slice(e.length), void 0) : r(a.key.slice(e.length), o(a.newValue))) : h({});
+  }
+  function u() {
+    let a = { ...t };
+    for (let l in U)
+      l.startsWith(e) && (a[l.slice(e.length)] = o(U[l]));
+    n.set(a);
+  }
+  return dt(n, () => {
+    if (u(), i.listen !== !1)
+      return v.addEventListener(e, c, u), () => {
+        v.removeEventListener(e, c, u);
+        for (let a in n.value)
+          v.removeEventListener(e + a, c, u);
+      };
+  }), n;
+}
+async function kt(e, {
+  version: t,
+  i18nPath: i = "https://discord.sh/i18n/db.json",
+  locale: s = "en",
+  defaults: o = {
+    welcome: "Welcome to the app!"
+  }
+}) {
+  console.log("[init-worker] Initializing database...");
+  try {
+    await e.loadI18nFromJSON(i), console.log(`[init-worker] i18n loaded from ${i}`), await e.dbSet("locale", s);
+    for (const [n, r] of Object.entries(o))
+      await e.dbSet(n, r);
+    await e.setVersion(t), e.loadServersFromJSON(), console.log(`[init-worker] DB initialized to version ${t}`);
+  } catch (n) {
+    console.error("[init-worker] Initialization failed:", n);
+  }
+}
+let W = null;
+async function yt(e) {
+  if (W) return W;
+  const t = {};
+  async function i(r) {
+    const h = e?.(r) ?? r, c = new Worker(h, { type: "module" }), u = b(c), a = await u.getMeta?.() ?? {
+      name: "unknown",
+      version: "0.0.1"
+    }, l = `${a.name}@${a.version}`;
+    console.log(`[mod-manager] ${l} is loaded.`);
+    const f = { id: l, worker: c, instance: u, meta: a, url: r };
+    return t[l] = f, f;
+  }
+  function s(r) {
+    t[r] && (t[r].worker.terminate(), delete t[r]);
+  }
+  function o() {
+    return Object.values(t).map((r) => r.meta);
+  }
+  async function n(r) {
+    const h = t[r];
+    if (!h) throw new Error(`Mod "${r}" not found`);
+    return s(r), i(h.url);
+  }
+  return W = {
+    registry: t,
+    load: i,
+    unload: s,
+    list: o,
+    reload: n
+  }, W;
+}
+var E = /* @__PURE__ */ ((e) => (e[e.PAYLOAD_UNKNOWN = 0] = "PAYLOAD_UNKNOWN", e[e.JSON = 1] = "JSON", e[e.FLEX = 2] = "FLEX", e[e.PROTOBUF = 3] = "PROTOBUF", e[e.FLATBUFFER = 4] = "FLATBUFFER", e))(E || {}), m = /* @__PURE__ */ ((e) => (e[e.UNKNOWN = 0] = "UNKNOWN", e[e.ADD = 1] = "ADD", e[e.READ = 2] = "READ", e[e.GET = 4] = "GET", e[e.SET = 8] = "SET", e[e.DEL = 16] = "DEL", e[e.STREAM = 32] = "STREAM", e[e.GROUP = 64] = "GROUP", e[e.LIST = 128] = "LIST", e[e.ACTION = 256] = "ACTION", e[e.MESSAGE = 512] = "MESSAGE", e[e.INFO = 1024] = "INFO", e[e.DEBUG = 2048] = "DEBUG", e[e.ERROR = 4096] = "ERROR", e[e.AUTH = 8192] = "AUTH", e[e.HEARTBEAT = 16384] = "HEARTBEAT", e[e.CONFIG_UPDATE = 32768] = "CONFIG_UPDATE", e[e.REDIS = 65536] = "REDIS", e[e.SUPABASE = 131072] = "SUPABASE", e[e.FILESYSTEM = 262144] = "FILESYSTEM", e[e.WEBSOCKET = 524288] = "WEBSOCKET", e[e.HTTP_API = 1048576] = "HTTP_API", e[e.LOCAL_CACHE = 2097152] = "LOCAL_CACHE", e[e.AI = 4194304] = "AI", e))(m || {});
+class R {
+  constructor(t, i, s, o = null, n = 0) {
+    this.builder = t, this.type = i, this.width = s, this.value = o, this.offset = n;
+  }
+  elementWidth(t, i) {
+    if (P(this.type)) return this.width;
+    for (let s = 0; s < 4; s++) {
+      const o = 1 << s, r = t + Y(t, o) + i * o - this.offset, h = T(r);
+      if (1 << h === o)
+        return h;
+    }
+    throw `Element is unknown. Size: ${t} at index: ${i}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`;
+  }
+  writeToBuffer(t) {
+    const i = this.builder.computeOffset(t);
+    if (this.type === d.FLOAT)
+      this.width === O.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 === d.INT) {
+      const s = N(t);
+      this.builder.pushInt(this.value, s);
+    } else if (this.type === d.UINT) {
+      const s = N(t);
+      this.builder.pushUInt(this.value, s);
+    } else if (this.type === d.NULL)
+      this.builder.pushInt(0, this.width);
+    else if (this.type === d.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(t = O.WIDTH8) {
+    return P(this.type) ? Math.max(t, this.width) : this.width;
+  }
+  storedPackedType(t = O.WIDTH8) {
+    return et(this.type, this.storedWidth(t));
+  }
+  isOffset() {
+    return !P(this.type);
+  }
+}
+class mt {
+  constructor(t = 2048, i = !0, s = !0, o = !0) {
+    this.dedupStrings = i, this.dedupKeys = s, this.dedupKeyVectors = o, 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(t > 0 ? t : 2048), this.view = new DataView(this.buffer);
+  }
+  align(t) {
+    const i = it(t);
+    return this.offset += Y(this.offset, i), i;
+  }
+  computeOffset(t) {
+    const i = this.offset + t;
+    let s = this.buffer.byteLength;
+    const o = s;
+    for (; s < i; )
+      s <<= 1;
+    if (o < s) {
+      const n = this.buffer;
+      this.buffer = new ArrayBuffer(s), this.view = new DataView(this.buffer), new Uint8Array(this.buffer).set(new Uint8Array(n), 0);
+    }
+    return i;
+  }
+  pushInt(t, i) {
+    if (i === O.WIDTH8)
+      this.view.setInt8(this.offset, t);
+    else if (i === O.WIDTH16)
+      this.view.setInt16(this.offset, t, !0);
+    else if (i === O.WIDTH32)
+      this.view.setInt32(this.offset, t, !0);
+    else if (i === O.WIDTH64)
+      this.view.setBigInt64(this.offset, BigInt(t), !0);
+    else
+      throw `Unexpected width: ${i} for value: ${t}`;
+  }
+  pushUInt(t, i) {
+    if (i === O.WIDTH8)
+      this.view.setUint8(this.offset, t);
+    else if (i === O.WIDTH16)
+      this.view.setUint16(this.offset, t, !0);
+    else if (i === O.WIDTH32)
+      this.view.setUint32(this.offset, t, !0);
+    else if (i === O.WIDTH64)
+      this.view.setBigUint64(this.offset, BigInt(t), !0);
+    else
+      throw `Unexpected width: ${i} for value: ${t}`;
+  }
+  writeInt(t, i) {
+    const s = this.computeOffset(i);
+    this.pushInt(t, N(i)), this.offset = s;
+  }
+  writeUInt(t, i) {
+    const s = this.computeOffset(i);
+    this.pushUInt(t, N(i)), this.offset = s;
+  }
+  writeBlob(t) {
+    const i = t.byteLength, s = T(i), o = this.align(s);
+    this.writeUInt(i, o);
+    const n = this.offset, r = this.computeOffset(i);
+    new Uint8Array(this.buffer).set(new Uint8Array(t), n), this.stack.push(this.offsetStackValue(n, d.BLOB, s)), this.offset = r;
+  }
+  writeString(t) {
+    if (this.dedupStrings && Object.prototype.hasOwnProperty.call(this.stringLookup, t)) {
+      this.stack.push(this.stringLookup[t]);
+      return;
+    }
+    const i = j(t), s = i.length, o = T(s), n = this.align(o);
+    this.writeUInt(s, n);
+    const r = this.offset, h = this.computeOffset(s + 1);
+    new Uint8Array(this.buffer).set(i, r);
+    const c = this.offsetStackValue(r, d.STRING, o);
+    this.stack.push(c), this.dedupStrings && (this.stringLookup[t] = c), this.offset = h;
+  }
+  writeKey(t) {
+    if (this.dedupKeys && Object.prototype.hasOwnProperty.call(this.keyLookup, t)) {
+      this.stack.push(this.keyLookup[t]);
+      return;
+    }
+    const i = j(t), s = i.length, o = this.computeOffset(s + 1);
+    new Uint8Array(this.buffer).set(i, this.offset);
+    const n = this.offsetStackValue(this.offset, d.KEY, O.WIDTH8);
+    this.stack.push(n), this.dedupKeys && (this.keyLookup[t] = n), this.offset = o;
+  }
+  writeStackValue(t, i) {
+    const s = this.computeOffset(i);
+    if (t.isOffset()) {
+      const o = this.offset - t.offset;
+      if (i === 8 || BigInt(o) < BigInt(1) << BigInt(i * 8))
+        this.writeUInt(o, i);
+      else
+        throw `Unexpected size ${i}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`;
+    } else
+      t.writeToBuffer(i);
+    this.offset = s;
+  }
+  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 !== d.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(t = !1) {
+    this.stackPointers.push({ stackPosition: this.stack.length, isVector: !1, presorted: t });
+  }
+  endVector(t) {
+    const i = this.stack.length - t.stackPosition, s = this.createVector(t.stackPosition, i, 1);
+    this.stack.splice(t.stackPosition, i), this.stack.push(s);
+  }
+  endMap(t) {
+    t.presorted || this.sort(t);
+    let i = "";
+    for (let r = t.stackPosition; r < this.stack.length; r += 2)
+      i += `,${this.stack[r].offset}`;
+    const s = this.stack.length - t.stackPosition >> 1;
+    this.dedupKeyVectors && !Object.prototype.hasOwnProperty.call(this.keyVectorLookup, i) && (this.keyVectorLookup[i] = this.createVector(t.stackPosition, s, 2));
+    const o = this.dedupKeyVectors ? this.keyVectorLookup[i] : this.createVector(t.stackPosition, s, 2), n = this.createVector(t.stackPosition + 1, s, 2, o);
+    this.stack.splice(t.stackPosition, s << 1), this.stack.push(n);
+  }
+  sort(t) {
+    const i = this.view, s = this.stack;
+    function o(a, l) {
+      if (a.type !== d.KEY || l.type !== d.KEY)
+        throw `Stack values are not keys ${a} | ${l}. Check if you combined [addKey] with add... method calls properly.`;
+      let f, w, p = 0;
+      do {
+        if (f = i.getUint8(a.offset + p), w = i.getUint8(l.offset + p), w < f) return !0;
+        if (f < w) return !1;
+        p += 1;
+      } while (f !== 0 && w !== 0);
+      return !1;
+    }
+    function n(a, l, f) {
+      if (l === f) return;
+      const w = a[l], p = a[l + 1];
+      a[l] = a[f], a[l + 1] = a[f + 1], a[f] = w, a[f + 1] = p;
+    }
+    function r() {
+      for (let a = t.stackPosition; a < s.length; a += 2) {
+        let l = a;
+        for (let f = a + 2; f < s.length; f += 2)
+          o(s[l], s[f]) && (l = f);
+        l !== a && n(s, l, a);
+      }
+    }
+    function h(a, l) {
+      if (a.type !== d.KEY || l.type !== d.KEY)
+        throw `Stack values are not keys ${a} | ${l}. Check if you combined [addKey] with add... method calls properly.`;
+      if (a.offset === l.offset)
+        return !1;
+      let f, w, p = 0;
+      do {
+        if (f = i.getUint8(a.offset + p), w = i.getUint8(l.offset + p), f < w) return !0;
+        if (w < f) return !1;
+        p += 1;
+      } while (f !== 0 && w !== 0);
+      return !1;
+    }
+    function c(a, l) {
+      if (a < l) {
+        const f = a + (l - a >> 2) * 2, w = s[f];
+        let p = a, I = l;
+        do {
+          for (; h(s[p], w); )
+            p += 2;
+          for (; h(w, s[I]); )
+            I -= 2;
+          p <= I && (n(s, p, I), p += 2, I -= 2);
+        } while (p <= I);
+        c(a, I), c(p, l);
+      }
+    }
+    let u = !0;
+    for (let a = t.stackPosition; a < this.stack.length - 2; a += 2)
+      if (o(this.stack[a], this.stack[a + 2])) {
+        u = !1;
+        break;
+      }
+    u || (this.stack.length - t.stackPosition > 40 ? c(t.stackPosition, this.stack.length - 2) : r());
+  }
+  end() {
+    if (this.stackPointers.length < 1) return;
+    const t = this.stackPointers.pop();
+    t.isVector ? this.endVector(t) : this.endMap(t);
+  }
+  createVector(t, i, s, o = null) {
+    let n = T(i), r = 1;
+    if (o !== null) {
+      const f = o.elementWidth(this.offset, 0);
+      f > n && (n = f), r += 2;
+    }
+    let h = d.KEY, c = o === null;
+    for (let f = t; f < this.stack.length; f += s) {
+      const w = this.stack[f].elementWidth(this.offset, f + r);
+      w > n && (n = w), f === t ? (h = this.stack[f].type, c = c && st(h)) : h !== this.stack[f].type && (c = !1);
+    }
+    const u = this.align(n), a = c && ot(h) && i >= 2 && i <= 4;
+    o !== null && (this.writeStackValue(o, u), this.writeUInt(1 << o.width, u)), a || this.writeUInt(i, u);
+    const l = this.offset;
+    for (let f = t; f < this.stack.length; f += s)
+      this.writeStackValue(this.stack[f], u);
+    if (!c)
+      for (let f = t; f < this.stack.length; f += s)
+        this.writeUInt(this.stack[f].storedPackedType(), 1);
+    if (o !== null)
+      return this.offsetStackValue(l, d.MAP, n);
+    if (c) {
+      const f = nt(h, a ? i : 0);
+      return this.offsetStackValue(l, f, n);
+    }
+    return this.offsetStackValue(l, d.VECTOR, n);
+  }
+  nullStackValue() {
+    return new R(this, d.NULL, O.WIDTH8);
+  }
+  boolStackValue(t) {
+    return new R(this, d.BOOL, O.WIDTH8, t);
+  }
+  intStackValue(t) {
+    return new R(this, d.INT, rt(t), t);
+  }
+  uintStackValue(t) {
+    return new R(this, d.UINT, T(t), t);
+  }
+  floatStackValue(t) {
+    return new R(this, d.FLOAT, at(t), t);
+  }
+  offsetStackValue(t, i, s) {
+    return new R(this, i, s, null, t);
+  }
+  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 t = this.stack[0], i = this.align(t.elementWidth(this.offset, 0));
+    this.writeStackValue(t, i), this.writeUInt(t.storedPackedType(), 1), this.writeUInt(i, 1), this.finished = !0;
+  }
+  add(t) {
+    if (this.integrityCheckOnValueAddition(), typeof t > "u")
+      throw "You need to provide a value";
+    if (t === null)
+      this.stack.push(this.nullStackValue());
+    else if (typeof t == "boolean")
+      this.stack.push(this.boolStackValue(t));
+    else if (typeof t == "bigint")
+      this.stack.push(this.intStackValue(t));
+    else if (typeof t == "number")
+      Number.isInteger(t) ? this.stack.push(this.intStackValue(t)) : this.stack.push(this.floatStackValue(t));
+    else if (ArrayBuffer.isView(t))
+      this.writeBlob(t.buffer);
+    else if (typeof t == "string" || t instanceof String)
+      this.writeString(t);
+    else if (Array.isArray(t)) {
+      this.startVector();
+      for (let i = 0; i < t.length; i++)
+        this.add(t[i]);
+      this.end();
+    } else if (typeof t == "object") {
+      const i = Object.getOwnPropertyNames(t).sort();
+      this.startMap(!0);
+      for (let s = 0; s < i.length; s++) {
+        const o = i[s];
+        this.addKey(o), this.add(t[o]);
+      }
+      this.end();
+    } else
+      throw `Unexpected value input ${t}`;
+  }
+  finish() {
+    this.finished || this.finishBuffer();
+    const t = this.buffer.slice(0, this.offset);
+    return new Uint8Array(t);
+  }
+  isFinished() {
+    return this.finished;
+  }
+  addKey(t) {
+    this.integrityCheckOnKeyAddition(), this.writeKey(t);
+  }
+  addInt(t, i = !1, s = !1) {
+    if (this.integrityCheckOnValueAddition(), !i) {
+      this.stack.push(this.intStackValue(t));
+      return;
+    }
+    if (s && Object.prototype.hasOwnProperty.call(this.indirectIntLookup, t)) {
+      this.stack.push(this.indirectIntLookup[t]);
+      return;
+    }
+    const o = this.intStackValue(t), n = this.align(o.width), r = this.computeOffset(n), h = this.offset;
+    o.writeToBuffer(n);
+    const c = this.offsetStackValue(h, d.INDIRECT_INT, o.width);
+    this.stack.push(c), this.offset = r, s && (this.indirectIntLookup[t] = c);
+  }
+  addUInt(t, i = !1, s = !1) {
+    if (this.integrityCheckOnValueAddition(), !i) {
+      this.stack.push(this.uintStackValue(t));
+      return;
+    }
+    if (s && Object.prototype.hasOwnProperty.call(this.indirectUIntLookup, t)) {
+      this.stack.push(this.indirectUIntLookup[t]);
+      return;
+    }
+    const o = this.uintStackValue(t), n = this.align(o.width), r = this.computeOffset(n), h = this.offset;
+    o.writeToBuffer(n);
+    const c = this.offsetStackValue(h, d.INDIRECT_UINT, o.width);
+    this.stack.push(c), this.offset = r, s && (this.indirectUIntLookup[t] = c);
+  }
+  addFloat(t, i = !1, s = !1) {
+    if (this.integrityCheckOnValueAddition(), !i) {
+      this.stack.push(this.floatStackValue(t));
+      return;
+    }
+    if (s && Object.prototype.hasOwnProperty.call(this.indirectFloatLookup, t)) {
+      this.stack.push(this.indirectFloatLookup[t]);
+      return;
+    }
+    const o = this.floatStackValue(t), n = this.align(o.width), r = this.computeOffset(n), h = this.offset;
+    o.writeToBuffer(n);
+    const c = this.offsetStackValue(h, d.INDIRECT_FLOAT, o.width);
+    this.stack.push(c), this.offset = r, s && (this.indirectFloatLookup[t] = c);
+  }
+}
+function B() {
+  return new mt();
+}
+function gt(e) {
+  const t = B();
+  t.startMap();
+  for (const [i, s] of Object.entries(e))
+    t.addKey(i), t.add(s);
+  return t.end(), t.finish();
+}
+function A(e, t, i, s, o = 1) {
+  let n;
+  if (i === E.FLEX)
+    n = gt(e);
+  else if (i === E.JSON)
+    n = new TextEncoder().encode(JSON.stringify(e));
+  else
+    throw new Error("Unsupported format for wrapEnvelope");
+  const r = B();
+  return r.startMap(), r.addKey("version"), r.add(o), r.addKey("kind"), r.add(t), r.addKey("format"), r.add(i), r.addKey("payload"), r.add(n), r.addKey("metadata"), r.add(s ?? new Uint8Array()), r.end(), r.finish();
+}
+function J(e) {
+  const t = e instanceof Uint8Array ? e : new Uint8Array(e), i = C(t.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 s = {
+    version: i.version,
+    kind: i.kind,
+    format: i.format,
+    payload: new Uint8Array(i.payload),
+    metadata: i.metadata ? new Uint8Array(i.metadata) : void 0
+  };
+  let o;
+  if (s.format === E.FLEX)
+    o = C(s.payload.buffer).toObject();
+  else if (s.format === E.JSON)
+    o = JSON.parse(new TextDecoder().decode(s.payload));
+  else
+    throw new Error(`[unwrapEnvelope] Unsupported format: ${s.format}`);
+  return { envelope: s, payload: o };
+}
+function X(e) {
+  return C(e.buffer).toObject();
+}
+function Ot(e) {
+  try {
+    const t = e instanceof Uint8Array ? e : new Uint8Array(e), i = X(t);
+    console.log("[FlexObject]", JSON.stringify(i, null, 2));
+  } catch (t) {
+    console.error("[Flex Decode Error]", t);
+  }
+}
+function $(e, t) {
+  return (e & t) === t;
+}
+function bt(e, t) {
+  return A(
+    { key: e, value: t },
+    m.SET | m.REDIS,
+    E.FLEX
+  );
+}
+function Et(e) {
+  return A(
+    { key: e },
+    m.GET | m.REDIS,
+    E.FLEX
+  );
+}
+function vt(e) {
+  return A(
+    { key: e },
+    m.DEL | m.REDIS,
+    E.FLEX
+  );
+}
+function It(e) {
+  const t = J(e);
+  if (!$(t.envelope.kind, m.REDIS))
+    throw new Error("[Redis] Not a Redis envelope");
+  return t;
+}
+function St(e, t, i = "*") {
+  return A(
+    { stream: e, id: i, fields: t },
+    m.ADD | m.STREAM | m.REDIS,
+    E.FLEX
+  );
+}
+function Rt(e, t, i) {
+  const s = B();
+  s.startMap(), s.addKey("streams"), s.startVector();
+  for (const { stream: r, id: h } of e)
+    s.startMap(), s.addKey("stream"), s.add(r), s.addKey("id"), s.add(h), s.end();
+  s.end(), t !== void 0 && (s.addKey("count"), s.add(t)), i !== void 0 && (s.addKey("block"), s.add(i)), s.end();
+  const o = s.finish(), n = B();
+  return n.startMap(), n.addKey("version"), n.add(1), n.addKey("kind"), n.add(m.READ | m.STREAM | m.REDIS), n.addKey("format"), n.add(E.FLEX), n.addKey("payload"), n.add(o), n.addKey("metadata"), n.add(new Uint8Array()), n.end(), n.finish();
+}
+const Dt = {
+  wrapEnvelope: A,
+  unwrapEnvelope: J,
+  MessageKind: m,
+  PayloadFormat: E,
+  unwrapFlexToJson: X,
+  inspectFlex: Ot,
+  hasKind: $,
+  redis: {
+    wrapRedisSet: bt,
+    wrapRedisGet: Et,
+    wrapRedisDel: vt,
+    wrapRedisXAdd: St,
+    wrapRedisXRead: Rt,
+    parseRedisPayload: It
+  }
+};
+function q(e) {
+  typeof queueMicrotask == "function" ? queueMicrotask(e) : setTimeout(e, 0);
+}
+function Q(e) {
+  const t = document.createElement(e.tag);
+  if (e.class && (t.className = e.class), e.attrs)
+    for (const [i, s] of Object.entries(e.attrs))
+      if (typeof s == "function" && i.startsWith("on"))
+        t.addEventListener(i.slice(2).toLowerCase(), s);
+      else if (i === "style" && typeof s == "object")
+        Object.assign(t.style, s);
+      else if (i === "dataset" && typeof s == "object")
+        for (const [o, n] of Object.entries(s))
+          t.dataset[o] = String(n);
+      else
+        try {
+          t.setAttribute(i, String(s));
+        } catch {
+        }
+  if (e.style && Object.assign(t.style, e.style), e.children)
+    for (const i of e.children) {
+      const s = typeof i == "string" ? document.createTextNode(i) : Q(i);
+      t.appendChild(s);
+    }
+  return t;
+}
+const Lt = k.enum(["top", "right", "bottom", "left"]), Tt = k.object({
+  width: k.number(),
+  height: k.number(),
+  mode: k.enum(["static", "animated", "dynamic"]).optional()
+});
+k.object({
+  rawHtml: k.string().optional(),
+  needsCanvas: k.boolean().optional(),
+  canvasOptions: Tt.optional()
+});
+const Ut = k.object({
+  name: k.string(),
+  version: k.string().optional()
+}), At = k.object({
+  meta: Ut.optional(),
+  timestamp: k.number()
+}), _ = k.object({
+  id: Lt,
+  payload: k.any().optional()
+}), Vt = k.object({
+  timestamp: k.number()
+}), Wt = {
+  "droid-ready": Vt,
+  "droid-mod-ready": At,
+  "panel-open": _,
+  "panel-close": _
+};
+class Nt {
+  listeners = /* @__PURE__ */ new Map();
+  on(t, i) {
+    let s = this.listeners.get(t);
+    s || (s = /* @__PURE__ */ new Set(), this.listeners.set(t, s)), s.add(i);
+  }
+  off(t, i) {
+    this.listeners.get(t)?.delete(i);
+  }
+  emit(t, i) {
+    const s = Wt[t];
+    if (s)
+      try {
+        s.parse(i);
+      } catch (o) {
+        console.error(`[DroidEventBus] Invalid payload for ${t}:`, o);
+        return;
+      }
+    window.dispatchEvent(new CustomEvent(t, { detail: i }));
+    for (const o of this.listeners.get(t) ?? [])
+      o(i);
+  }
+  wait(t) {
+    return new Promise((i) => {
+      const s = (o) => {
+        this.off(t, s), i(o);
+      };
+      this.on(t, s);
+    });
+  }
+}
+const Bt = new Nt(), M = "1.0.3";
+let x = !1;
+function xt(e, t) {
+  if (!e)
+    throw new Error("[resolveWorkerURL] Worker name must be defined");
+  if (typeof window < "u") {
+    const i = window.kbveWorkerURLs;
+    if (i?.[e]) return i[e];
+  }
+  return t ?? `/workers/${e}`;
+}
+async function Pt(e) {
+  let t = null;
+  try {
+    const i = new SharedWorker(new URL(
+      /* @vite-ignore */
+      "/lib/workers/ws-worker.js",
+      import.meta.url
+    ), {
+      type: "module"
+    });
+    i.port.start(), t = b(i.port);
+  } catch (i) {
+    console.warn("[DROID] ws-worker import.meta fallback failed:", i);
+  }
+  if (!t)
+    try {
+      const i = new SharedWorker("/ws-worker.js", { type: "module" });
+      i.port.start(), t = b(i.port);
+    } catch (i) {
+      console.warn("[DROID] ws-worker hardcoded fallback failed:", i);
+    }
+  if (!t && e?.workerRef)
+    try {
+      e.workerRef.port.start(), t = b(e.workerRef.port);
+    } catch (i) {
+      console.warn("[DROID] ws-worker workerRef failed:", i);
+    }
+  if (!t && e?.workerURL)
+    try {
+      const i = new SharedWorker(e.workerURL, { type: "module" });
+      i.port.start(), t = b(i.port);
+    } catch (i) {
+      console.warn("[DROID] ws-worker workerURL failed:", i);
+    }
+  if (!t)
+    throw console.error("[DROID] No WS Worker Comlink Initialized"), new Error("[DROID] Failed to initialize ws-worker");
+  return t;
+}
+const g = G(
+  "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
+  }
+);
+async function Ct(e) {
+  try {
+    const t = new Worker(
+      new URL(
+        /* @vite-ignore */
+        "/lib/workers/canvas-worker.js",
+        import.meta.url
+      ),
+      { type: "module" }
+    );
+    return b(t);
+  } catch (t) {
+    console.warn("[DROID] Vite-style canvas-worker import failed:", t);
+  }
+  try {
+    const t = new Worker("./canvas-worker.js", { type: "module" });
+    return b(t);
+  } catch (t) {
+    console.warn("[DROID] Fallback /canvas-worker.js failed:", t);
+  }
+  if (e?.workerRef)
+    try {
+      return b(e.workerRef);
+    } catch (t) {
+      console.warn("[DROID] Provided workerRef failed:", t);
+    }
+  if (e?.workerURL)
+    try {
+      const t = new Worker(e.workerURL, { type: "module" });
+      return b(t);
+    } catch (t) {
+      console.warn("[DROID] Provided workerURL failed:", t);
+    }
+  throw console.error("[DROID] No Canvas Comlink Initialized"), new Error("[DROID] Failed to initialize canvas worker");
+}
+const z = {
+  state: g,
+  openPanel(e, t) {
+    const i = { ...g.get().panelManager };
+    i[e] = { open: !0, payload: t }, g.setKey("panelManager", i);
+  },
+  closePanel(e) {
+    const t = { ...g.get().panelManager };
+    t[e] = { open: !1, payload: void 0 }, g.setKey("panelManager", t);
+  },
+  togglePanel(e, t) {
+    const i = { ...g.get().panelManager }, s = i[e]?.open ?? !1;
+    i[e] = { open: !s, payload: s ? void 0 : t }, g.setKey("panelManager", i);
+  },
+  setTheme(e) {
+    g.setKey("themeManager", { theme: e });
+  },
+  addToast(e, t) {
+    const i = { ...g.get().toastManager, [e]: t };
+    g.setKey("toastManager", i);
+  },
+  removeToast(e) {
+    const t = { ...g.get().toastManager };
+    delete t[e], g.setKey("toastManager", t);
+  },
+  async dispatchCanvasRequest(e, t, i = "animated") {
+    const s = t.transferControlToOffscreen();
+    await window.kbve?.uiux?.worker?.bindCanvas(e, s, i);
+  },
+  closeAllPanels() {
+    const e = { ...g.get().panelManager };
+    console.log("error panel is closing");
+    for (const t of Object.keys(e))
+      e[t] = { open: !1, payload: void 0 };
+    g.setKey("panelManager", e);
+  },
+  emitFromWorker(e) {
+    e.type === "injectVNode" && e.vnode && q(() => {
+      const t = document.getElementById("bento-grid-inject");
+      if (!t) {
+        console.warn(
+          "[KBVE] No injection target found: #bento-grid-inject"
+        );
+        return;
+      }
+      const i = Q(e.vnode);
+      if (i.classList.add("animate-fade-in"), e.vnode.id) {
+        const s = document.getElementById(e.vnode.id);
+        s && s.remove();
+      }
+      t.appendChild(i);
+    });
+  }
+}, D = G(
+  "i18n-cache",
+  {},
+  {
+    encode: JSON.stringify,
+    decode: JSON.parse
+  }
+), L = {
+  store: D,
+  api: null,
+  ready: Promise.resolve(),
+  get(e) {
+    return D.get()[e] ?? `[${e}]`;
+  },
+  async getAsync(e) {
+    const t = D.get()[e];
+    if (t !== void 0) return t;
+    if (!this.api) return `[${e}]`;
+    const i = await this.api.getTranslation(e);
+    return i !== null ? (D.setKey(e, i), i) : `[${e}]`;
+  },
+  set(e, t) {
+    D.setKey(e, t);
+  },
+  async hydrate(e, t) {
+    this.api = e;
+    for (const i of t) {
+      const s = await e.getTranslation(i);
+      s !== null && D.setKey(i, s);
+    }
+  },
+  async hydrateLocale(e = "en") {
+    if (!this.api) return;
+    const i = (await this.api.getAllI18nKeys()).filter(
+      (o) => o.startsWith(`${e}:`)
+    ), s = await this.api.getTranslations(i);
+    for (const [o, n] of Object.entries(s))
+      console.log(`[i18n.setKey] ${o} = ${n}`), this.store.setKey(o, n);
+  }
+};
+function K() {
+  if (!navigator.serviceWorker?.controller) return;
+  const e = new MessageChannel();
+  navigator.serviceWorker.controller.postMessage(e.port2, [
+    e.port2
+  ]), e.port1.start();
+}
+async function Ft(e) {
+  let t = null;
+  try {
+    const s = new SharedWorker(
+      new URL(
+        /* @vite-ignore */
+        "/lib/workers/db-worker.js",
+        import.meta.url
+      ),
+      {
+        type: "module"
+      }
+    );
+    s.port.start(), t = b(s.port);
+  } catch (s) {
+    console.warn("[DROID] db-worker import.meta fallback failed:", s);
+  }
+  if (!t)
+    try {
+      const s = new SharedWorker("/db-worker.js", {
+        type: "module"
+      });
+      s.port.start(), t = b(s.port);
+    } catch (s) {
+      console.warn("[DROID] db-worker hardcoded fallback failed:", s);
+    }
+  if (!t && e?.workerRef)
+    try {
+      e.workerRef.port.start(), t = b(e.workerRef.port);
+    } catch (s) {
+      console.warn("[DROID] db-worker workerRef failed:", s);
+    }
+  if (!t && e?.workerURL)
+    try {
+      const s = new SharedWorker(e.workerURL, { type: "module" });
+      s.port.start(), t = b(s.port);
+    } catch (s) {
+      console.warn("[DROID] db-worker workerURL failed:", s);
+    }
+  if (!t)
+    throw console.error("[DROID] No DB Worker Comlink Initialized"), new Error("[DROID] Failed to initialize db-worker");
+  return await t.getVersion() !== M && await kt(t, {
+    version: M,
+    i18nPath: "https://discord.sh/i18n/db.json",
+    locale: "en",
+    defaults: { welcome: "Welcome!", theme: "dark" }
+  }), t;
+}
+function jt(e, t) {
+  const i = Z(async (s) => {
+    q(() => {
+      const o = `ws:${Date.now()}`;
+      t.storeWsMessage(o, s);
+    });
+  });
+  e.onMessage(tt(i, [0]));
+}
+async function zt(e) {
+  if (console.log("[DROID]: Main<T>"), x || (x = !0, navigator.serviceWorker?.controller ? K() : navigator.serviceWorker?.addEventListener(
+    "controllerchange",
+    K
+  )), console.log("[DROID] Main<T> => Worker URLs", e?.workerURLs), !window.kbve?.api || !window.kbve?.i18n || !window.kbve?.uiux)
+    try {
+      console.log("[DROID] Main<T> => Worker => CanvasComlink");
+      const i = await Ct({
+        workerRef: e?.workerRefs?.canvasWorker,
+        workerURL: e?.workerURLs?.canvasWorker
+      });
+      console.log("[DROID] Main<T> => Worker => StorageComlink");
+      const s = await Ft({
+        workerURL: typeof e?.workerURLs?.dbWorker == "string" ? e.workerURLs.dbWorker : void 0,
+        workerRef: e?.workerRefs?.dbWorker
+      });
+      console.log("[DROID] Main<T> => Worker => WsComlink");
+      const o = await Pt({
+        workerRef: e?.workerRefs?.wsWorker,
+        workerURL: e?.workerURLs?.wsWorker
+      });
+      console.log("[DROID] Main<T> => Worker => ModManager");
+      const n = await yt(
+        (c) => e?.workerURLs?.[c] ?? c
+      ), r = Bt;
+      for (const c of Object.values(n.registry))
+        typeof c.instance.init == "function" && await c.instance.init({
+          emitFromWorker: z.emitFromWorker
+        }), console.log("[Event] -> Fire Mod Ready"), r.emit("droid-mod-ready", {
+          meta: c.meta,
+          timestamp: Date.now()
+        });
+      jt(o, s);
+      const h = Dt;
+      L.api = s, L.ready = L.hydrateLocale("en"), window.kbve = {
+        ...window.kbve || {},
+        api: s,
+        i18n: L,
+        uiux: { ...z, worker: i },
+        ws: o,
+        data: h,
+        mod: n,
+        events: r
+      }, await L.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");
+    } catch (i) {
+      throw console.error("[DROID] Initialization error:", i), i;
+    }
+  else
+    console.log("[KBVE] Already initialized");
+}
+export {
+  jt as bridgeWsToDb,
+  L as i18n,
+  zt as main,
+  xt as resolveWorkerURL,
+  z as uiux
+};