nsd-ble 0.3.3 → 0.4.1

package/dist/main.js

@@ -1,192 +1,234 @@
-import { l as x, u as I, a as N, b as D, c as B, B as p, S as P } from "./Objects-C2BH61j-.js";
-import { Data as A, DataType as f, ActionType as c, ActionDataType as l } from "./enums.js";
-import { Image as $, Rectangle as k, Text as H } from "./elements.js";
-class O {
+import { l as I, u as x, a as O, b as Z, c as Q, d as tt, B, S as mt, s as et } from "./Objects-ulh5Kfet.js";
+import { Data as i, DataType as f, ActionType as A, ActionDataType as U, FloodTypes as v, Button as G } from "./enums.js";
+import { Image as yt, Rectangle as Et, Text as Tt } from "./elements.js";
+class Dt {
   data = [];
   size = 0;
   total = 0;
 }
-const T = 7, w = /* @__PURE__ */ new Map();
-function z(t) {
-  return w.get(t);
+const j = 7, _ = /* @__PURE__ */ new Map();
+function It(t) {
+  return _.get(t);
 }
-function G(t) {
-  w.delete(t);
+function Ut(t) {
+  _.delete(t);
 }
-function V(t) {
-  const e = t.getUint8(A.CACHE), n = t.getUint16(A.DATA_SIZE, !0), r = t.getUint16(A.POSITION, !0), o = t.byteLength - T;
-  if (!w.has(e)) {
-    const i = new O();
-    i.size = n, w.set(e, i);
+function Ct(t) {
+  const e = t.getUint8(i.CACHE), o = t.getUint16(i.DATA_SIZE, !0), n = t.getUint16(i.POSITION, !0), r = t.byteLength - j;
+  if (!_.has(e)) {
+    const a = new Dt();
+    a.size = o, _.set(e, a);
   }
-  const s = w.get(e);
-  for (let i = 0; i < o; i++)
-    s.data[i + r] = t.getUint8(T + i);
-  s.total += o;
+  const s = _.get(e);
+  for (let a = 0; a < r; a++)
+    s.data[a + n] = t.getUint8(j + a);
+  s.total += r;
 }
-function F(t) {
-  const e = w.get(t);
+function St(t) {
+  const e = _.get(t);
   return e.total == e.size || e.size == 0;
 }
-function W() {
-  return { add: V, get: z, remove: G, isDone: F };
+function bt() {
+  return { add: Ct, get: It, remove: Ut, isDone: St };
 }
-const { serviceUuid: Z, handshakeCharUuid: K } = N(), C = new x.SyncEvent(), { add: X, get: j, remove: q, isDone: J } = W();
-function Q() {
+const { serviceUuid: _t, handshakeCharUuid: Nt } = O(), nt = new I.SyncEvent(), { add: Rt, get: xt, remove: Bt, isDone: Pt } = bt();
+function Lt() {
   return new Promise((t, e) => {
-    I().subscribe(Z, K, Y).then(() => t()).catch((n) => e(n));
+    x().subscribe(_t, Nt, Mt).then(() => t()).catch((o) => e(o));
   });
 }
-function Y(t) {
+function Mt(t) {
   console.log(t, t.buffer.byteLength);
-  const e = t.getUint8(A.CACHE);
-  X(t), J(e) && (C.post(tt(e)), q(e));
-}
-function tt(t) {
-  const e = j(t), n = /* @__PURE__ */ new Map();
-  let r = 1;
-  for (; r < e.size; ) {
-    const o = e.data[r++], s = e.data[r++], i = [];
-    for (let a = 0; a < s; a++)
-      i.push(e.data[r++]);
-    n.set(o, i);
+  const e = t.getUint8(i.CACHE);
+  Rt(t), Pt(e) && (nt.post(Ot(e)), Bt(e));
+}
+function Ot(t) {
+  const e = xt(t), o = /* @__PURE__ */ new Map();
+  let n = 1;
+  for (; n < e.size; ) {
+    const r = e.data[n++], s = e.data[n++], a = [];
+    for (let c = 0; c < s; c++)
+      a.push(e.data[n++]);
+    o.set(r, a);
   }
-  return n;
-}
-function S() {
-  return { subscribe: Q, onNodes: C };
+  return o;
 }
-const { onNodes: et } = S(), { onMessageDone: nt, onNode: rt, onNodeLost: ot } = D(), { onPlusButton: st, onMinButton: it, onEitherButton: at } = B(), {
-  connect: ct,
-  reconnect: ut,
-  onConnect: ht,
-  onDisconnect: ft
-} = I();
-function dt() {
-  return new Promise((t, e) => {
-    ct(N().options).then(() => _(t)).catch((n) => e(n));
+function ot() {
+  return { subscribe: Lt, onNodes: nt };
+}
+const { onNodes: vt } = ot(), { onMessageDone: kt, onNode: $t, onNodeLost: zt } = Z(), { onPlusButton: Ht, onMinButton: Ft, onEitherButton: Gt } = Q(), {
+  connect: Wt,
+  reconnect: rt,
+  onConnect: Vt,
+  onDisconnect: st
+} = x(), it = new I.SyncEvent(), at = new I.SyncEvent();
+let k = !1, b = !1, N = !1;
+st.attach(() => {
+  k && !b && (tt().abortAll(new Error("BLE disconnected")), Kt());
+});
+async function Zt() {
+  N = !0, await Wt(O().options), await Y(), k = !0;
+}
+async function Yt() {
+  N = !0, await rt(), await Y(), k = !0;
+}
+function Y() {
+  return Promise.all([
+    ot().subscribe(),
+    Q().subscribe(),
+    Z().subscribe()
+  ]).then(() => {
   });
 }
-function lt() {
-  return new Promise((t, e) => {
-    ut().then(() => _(t)).catch((n) => e(n));
-  });
+async function Kt() {
+  const { RECONNECT_DELAY: t, RECONNECT_MAX_RETRIES: e } = O();
+  b = !0, N = !1;
+  for (let o = 1; o <= e; o++) {
+    const n = Math.min(
+      t * Math.pow(2, o - 1),
+      3e4
+    );
+    if (it.post({ attempt: o, maxRetries: e, delay: n }), await qt(n), N) {
+      b = !1, N = !1;
+      return;
+    }
+    try {
+      await rt(), await Y(), b = !1;
+      return;
+    } catch (r) {
+      console.warn(
+        `Auto-reconnect attempt ${o}/${e} failed:`,
+        r
+      );
+    }
+  }
+  b = !1, at.post();
+}
+function qt(t) {
+  return new Promise((e) => setTimeout(e, t));
 }
-function _(t) {
-  Promise.all([
-    S().subscribe(),
-    B().subscribe(),
-    D().subscribe()
-  ]).then(t);
+function Xt() {
+  k = !1, b = !1, N = !1;
 }
-function gt() {
+function jt() {
   return {
-    connect: dt,
-    onConnect: ht,
-    onDisconnect: ft,
-    reconnect: lt,
-    onNodes: et,
-    onNode: rt,
-    onNodeLost: ot,
-    onPlusButton: st,
-    onMinButton: it,
-    onEitherButton: at,
-    onMessageDone: nt
+    connect: Zt,
+    onConnect: Vt,
+    onDisconnect: st,
+    onReconnecting: it,
+    onReconnectFailed: at,
+    reconnect: Yt,
+    onNodes: vt,
+    onNode: $t,
+    onNodeLost: zt,
+    onPlusButton: Ht,
+    onMinButton: Ft,
+    onEitherButton: Gt,
+    onMessageDone: kt,
+    _resetForTesting: Xt
   };
 }
-function ee(t) {
+function hn(t) {
   return {
-    upload: (e, n) => {
-      const r = new Uint8Array(n.length + 1);
-      return r.set([e], 0), r.set(n, 1), new p(f.UPLOAD, t.id, r);
+    upload: (e, o) => {
+      const n = new Uint8Array(o.length + 1);
+      return n.set([e], 0), n.set(o, 1), new B(f.UPLOAD, t.id, n);
     },
-    clear: () => new p(f.CLEAR_GRAPHICS, t.id)
+    clear: () => new B(f.CLEAR_GRAPHICS, t.id)
   };
 }
-class wt {
+class Jt {
   id;
   buffers;
   totalPackets = 0;
-  onProgress = new x.SyncEvent();
-  constructor(e, n) {
-    this.id = n, this.buffers = e, this.buffers.forEach((r) => {
-      this.totalPackets += r.packets.length;
+  onProgress = new I.SyncEvent();
+  onError = new I.SyncEvent();
+  constructor(e, o) {
+    this.id = o, this.buffers = e, this.buffers.forEach((n) => {
+      this.totalPackets += n.packets.length;
     });
   }
   async send() {
-    const e = this.totalPackets & 255, n = this.totalPackets >> 8 & 255, r = new Uint8Array([e, n]), o = new p(f.LOADER, this.id, r), s = this.buffers.length;
-    let i = 0;
-    await o.send();
-    for (const a of this.buffers)
-      await a.send(), i++, this.onProgress.post({
-        current: i,
-        total: s,
-        percentage: i / s
-      });
+    const e = this.totalPackets & 255, o = this.totalPackets >> 8 & 255, n = new Uint8Array([e, o]), r = new B(f.LOADER, this.id, n), s = this.buffers.length;
+    let a = 0;
+    try {
+      await r.send();
+      for (const c of this.buffers)
+        await c.send(), a++, this.onProgress.post({
+          current: a,
+          total: s,
+          percentage: a / s
+        });
+    } catch (c) {
+      throw this.onError.post({
+        buffer: a,
+        error: c
+      }), c;
+    }
   }
 }
-function ne(t) {
+function gn(t) {
   return {
-    load: (e) => new wt(e, t.id)
+    load: (e) => new Jt(e, t.id)
   };
 }
-const { onNodes: pt, onNode: yt, onNodeLost: mt } = gt();
-pt.attach(At);
-yt.attach(Et);
-mt.attach(Ut);
-const u = [], E = new x.SyncEvent();
-function At(t) {
+const { onNodes: Qt, onNode: te, onNodeLost: ee } = jt();
+Qt.attach(ne);
+te.attach(oe);
+ee.attach(re);
+const w = [], $ = new I.SyncEvent();
+function ne(t) {
   console.log("standees", t);
-  for (const [e, n] of t)
-    v(e), u.find((r) => r.id === e).neighbors = n;
-  E.post(u);
+  for (const [e, o] of t)
+    ct(e), w.find((n) => n.id === e).neighbors = o;
+  $.post(w);
 }
-function Et(t) {
+function oe(t) {
   console.log("nodes", t);
-  const e = t.keys().next().value, n = t.get(e);
-  v(e), u.find((r) => r.id === e).neighbors = n, E.post(u);
+  const e = t.keys().next().value, o = t.get(e);
+  ct(e), w.find((n) => n.id === e).neighbors = o, $.post(w);
 }
-function Ut(t) {
-  xt(t), E.post(u);
+function re(t) {
+  se(t), $.post(w);
 }
-function v(t) {
-  u.some((e) => e.id === t) || u.push(new P(t));
+function ct(t) {
+  w.some((e) => e.id === t) || w.push(new mt(t));
 }
-function xt(t) {
-  const e = u.findIndex((n) => n.id === t);
-  e !== -1 && u.splice(e, 1);
+function se(t) {
+  const e = w.findIndex((o) => o.id === t);
+  e !== -1 && w.splice(e, 1);
 }
-function re() {
-  return { standees: u, onChange: E };
+function An() {
+  return { standees: w, onChange: $ };
 }
-function bt(t) {
+function ie(t) {
   const e = () => {
-    let r = Math.floor(Math.random() * 256);
-    return n(r) ? e() : r;
-  }, n = (r) => t.some((o) => o.id === r);
+    let n = Math.floor(Math.random() * 256);
+    return o(n) ? e() : n;
+  }, o = (n) => t.some((r) => r.id === n);
   return { generate: e };
 }
-function oe(t) {
-  return { add: (r) => (r.id = bt(t.elements).generate(), t.elements.push(r), r), remove: (r) => {
+function wn(t) {
+  return { add: (n) => (n.id = ie(t.elements).generate(), t.elements.push(n), n), remove: (n) => {
     t.elements = t.elements.filter(
-      (o) => o.id !== r
+      (r) => r.id !== n
     );
   } };
 }
-function Tt(t) {
-  return new p(f.CLEAR_SCREEN, t.id);
+function ae(t) {
+  return new B(f.CLEAR_SCREEN, t.id);
 }
-function It(t) {
+function ce(t) {
   let e = new Uint8Array();
-  for (const n of t.elements)
-    n.dirty !== !1 && (n instanceof $ && (e = U(e, Nt(n))), n instanceof k && (e = U(e, Dt(n))), n instanceof H && (e = U(e, Bt(n))), n.dirty = !1);
-  return new p(f.ALL, t.id, e);
+  for (const o of t.elements)
+    o.dirty !== !1 && (o instanceof yt && (e = W(e, ue(o))), o instanceof Et && (e = W(e, fe(o))), o instanceof Tt && (e = W(e, le(o))), o.dirty = !1);
+  return new B(f.ALL, t.id, e);
 }
-function U(t, e) {
-  const n = new Uint8Array(t.length + e.length);
-  return n.set(t, 0), n.set(e, t.length), n;
+function W(t, e) {
+  const o = new Uint8Array(t.length + e.length);
+  return o.set(t, 0), o.set(e, t.length), o;
 }
-function Nt(t) {
+function ue(t) {
   return new Uint8Array([
     f.DRAW_IMAGE,
     7,
@@ -199,7 +241,7 @@ function Nt(t) {
     t.data
   ]);
 }
-function Dt(t) {
+function fe(t) {
   return new Uint8Array([
     f.DRAW_RECTANGLE,
     9,
@@ -214,9 +256,9 @@ function Dt(t) {
     t.colorBlack ? 0 : 1
   ]);
 }
-function Bt(t) {
-  const e = new TextEncoder().encode(t.text), n = new Uint8Array(9 + e.length);
-  return n.set(
+function le(t) {
+  const e = new TextEncoder().encode(t.text), o = new Uint8Array(9 + e.length);
+  return o.set(
     [
       f.DRAW_TEXT,
       7 + e.length,
@@ -229,50 +271,50 @@ function Bt(t) {
       t.center ? 1 : 0
     ],
     0
-  ), n.set(e, 9), n;
-}
-function se() {
-  return { clear: Tt, draw: It };
-}
-function Ct(t, e) {
-  const n = Math.ceil(t.length / e), r = Math.ceil(e / 8), o = new Uint8Array(r * n);
-  for (let s = 0; s < n; s++)
-    for (let i = 0; i < r; i++) {
-      let a = 0;
-      for (let g = 0; g < 8; g++) {
-        const y = i * 8 + g, m = s * e + y;
-        y < e && m < t.length && t[m] && (a |= 1 << 7 - g);
+  ), o.set(e, 9), o;
+}
+function pn() {
+  return { clear: ae, draw: ce };
+}
+function de(t, e) {
+  const o = Math.ceil(t.length / e), n = Math.ceil(e / 8), r = new Uint8Array(n * o);
+  for (let s = 0; s < o; s++)
+    for (let a = 0; a < n; a++) {
+      let c = 0;
+      for (let u = 0; u < 8; u++) {
+        const l = a * 8 + u, E = s * e + l;
+        l < e && E < t.length && t[E] && (c |= 1 << 7 - u);
       }
-      o[s * r + i] = R(a);
+      r[s * n + a] = ut(c);
     }
-  return o;
+  return r;
 }
-function R(t) {
+function ut(t) {
   return t = (t & 240) >> 4 | (t & 15) << 4, t = (t & 204) >> 2 | (t & 51) << 2, t = (t & 170) >> 1 | (t & 85) << 1, t;
 }
-function St(t) {
-  const e = t.reduce((o, s) => o + s.length, 0), n = new Uint8Array(e);
-  let r = 0;
-  for (const o of t)
-    n.set(o, r), r += o.length;
-  return n;
+function he(t) {
+  const e = t.reduce((r, s) => r + s.length, 0), o = new Uint8Array(e);
+  let n = 0;
+  for (const r of t)
+    o.set(r, n), n += r.length;
+  return o;
 }
-function b() {
+function K() {
   return {
-    pixelsToBytes: Ct,
-    bitswap: R,
-    flattenUint8Arrays: St
+    pixelsToBytes: de,
+    bitswap: ut,
+    flattenUint8Arrays: he
   };
 }
-const { flattenUint8Arrays: L } = b();
-class d {
+const { flattenUint8Arrays: ft } = K();
+class T {
   element_id;
   property;
-  constructor(e, n) {
-    this.element_id = e, this.property = n;
+  constructor(e, o) {
+    this.element_id = e, this.property = o;
   }
 }
-class h {
+class p {
   target;
   constructor(e) {
     this.target = e;
@@ -281,85 +323,85 @@ class h {
     return new Uint8Array();
   }
 }
-class _t extends h {
+class ge extends p {
   format() {
     return new Uint8Array([
-      c.INCREMENT,
+      A.INCREMENT,
       2,
       this.target.element_id,
       this.target.property
     ]);
   }
 }
-class vt extends h {
+class Ae extends p {
   format() {
     return new Uint8Array([
-      c.DECREMENT,
+      A.DECREMENT,
       2,
       this.target.element_id,
       this.target.property
     ]);
   }
 }
-class Rt extends h {
+class we extends p {
   format() {
-    return new Uint8Array([c.SHOW, 1, this.target.element_id]);
+    return new Uint8Array([A.SHOW, 1, this.target.element_id]);
   }
 }
-class Lt extends h {
+class pe extends p {
   format() {
-    return new Uint8Array([c.HIDE, 1, this.target.element_id]);
+    return new Uint8Array([A.HIDE, 1, this.target.element_id]);
   }
 }
-class Mt extends h {
+let me = class extends p {
   value;
-  constructor(e, n) {
-    super(e), this.value = n;
+  constructor(e, o) {
+    super(e), this.value = o;
   }
   format() {
-    const e = this.dataType(), n = this.convertValue(e), r = new Uint8Array(5 + n.length), o = [
-      c.SET,
-      n.length + 3,
+    const e = this.dataType(), o = this.convertValue(e), n = new Uint8Array(5 + o.length), r = [
+      A.SET,
+      o.length + 3,
       e,
       this.target.element_id,
       this.target.property
     ];
-    return r.set(o, 0), r.set(n, 5), r;
+    return n.set(r, 0), n.set(o, 5), n;
   }
   dataType() {
-    return typeof this.value === "string" ? l.STRING : l.NUMBER;
+    return typeof this.value === "string" ? U.STRING : U.NUMBER;
   }
   convertValue(e) {
-    return e === l.STRING ? new TextEncoder().encode(this.value) : e === l.NUMBER ? new Uint8Array([this.value]) : new Uint8Array();
+    return e === U.STRING ? new TextEncoder().encode(this.value) : e === U.NUMBER ? new Uint8Array([this.value]) : new Uint8Array();
   }
-}
-class Pt extends h {
+};
+class ye extends p {
   format() {
     return this.target.element_id !== 0 && this.target.property !== 0 ? new Uint8Array([
-      c.BROADCAST,
+      A.BROADCAST,
       2,
       this.target.element_id,
       this.target.property
-    ]) : new Uint8Array([c.BROADCAST, 0]);
+    ]) : new Uint8Array([A.BROADCAST, 0]);
   }
 }
-class $t extends h {
+class Ee extends p {
   format() {
-    return new Uint8Array([c.BREAK, 0]);
+    return new Uint8Array([A.BREAK, 0]);
   }
 }
-let kt = class extends h {
+let Te = class extends p {
   fromLow;
   fromHigh;
   toLow;
   toHigh;
   value;
-  constructor(e, n, r, o, s, i) {
-    super(i), this.value = e, this.fromLow = n, this.fromHigh = r, this.toLow = o, this.toHigh = s;
+  constructor(e, o, n, r, s, a) {
+    super(a), this.value = e, this.fromLow = o, this.fromHigh = n, this.toLow = r, this.toHigh = s;
   }
   format() {
     return new Uint8Array([
-      c.MAP,
+      A.MAP,
       8,
       this.value.element_id,
       this.value.property,
@@ -372,174 +414,486 @@ let kt = class extends h {
     ]);
   }
 };
-class Ht extends h {
+class De extends p {
   deciseconds;
   resetable;
   onComplete;
-  constructor(e, n, r) {
-    super(new d(0, 0)), this.deciseconds = e, this.resetable = n, this.onComplete = r;
+  constructor(e, o, n) {
+    super(new T(0, 0)), this.deciseconds = e, this.resetable = o, this.onComplete = n;
   }
   format() {
-    const e = L(
-      this.onComplete.map((o) => o.format())
-    ), n = new Uint8Array(4 + e.length), r = [
-      c.TIMER,
+    const e = ft(
+      this.onComplete.map((r) => r.format())
+    ), o = new Uint8Array(4 + e.length), n = [
+      A.TIMER,
       e.length + 2,
       this.resetable ? 1 : 0,
       this.deciseconds
     ];
-    return n.set(r, 0), e.forEach(
-      (o, s) => n.set([o], s + 4)
-    ), n;
+    return o.set(n, 0), e.forEach(
+      (r, s) => o.set([r], s + 4)
+    ), o;
   }
 }
-class Ot extends h {
+class Ie extends p {
   left;
   operator;
   right;
   actions;
-  constructor(e, n, r, o) {
-    super(new d(0, 0)), this.actions = o, this.left = e, this.operator = n, this.right = r;
+  constructor(e, o, n, r) {
+    super(new T(0, 0)), this.actions = r, this.left = e, this.operator = o, this.right = n;
   }
   convertValue(e) {
     if (typeof e == "number")
-      return new Uint8Array([l.NUMBER, 1, e]);
+      return new Uint8Array([U.NUMBER, 1, e]);
     if (typeof e == "string") {
-      const n = new TextEncoder().encode(e);
+      const o = new TextEncoder().encode(e);
       return new Uint8Array([
-        l.STRING,
-        n.length,
-        ...n
+        U.STRING,
+        o.length,
+        ...o
       ]);
     }
-    return e instanceof d ? new Uint8Array([
-      l.ELEMENT,
+    return e instanceof T ? new Uint8Array([
+      U.ELEMENT,
       2,
       e.element_id,
       e.property
     ]) : new Uint8Array();
   }
   format() {
-    const e = L(
-      this.actions.map((a) => a.format())
-    ), n = this.convertValue(this.left), r = this.convertValue(this.right), o = 4 + n.length + r.length + e.length, s = new Uint8Array(o), i = [
-      c.CONDITION,
-      o - 2,
-      n.length + r.length + 1
+    const e = ft(
+      this.actions.map((c) => c.format())
+    ), o = this.convertValue(this.left), n = this.convertValue(this.right), r = 4 + o.length + n.length + e.length, s = new Uint8Array(r), a = [
+      A.CONDITION,
+      r - 2,
+      o.length + n.length + 1
     ];
-    return s.set(i, 0), s.set([this.operator], 3), s.set(n, 4), s.set(r, 4 + n.length), s.set(e, 4 + n.length + r.length), s;
+    return s.set(a, 0), s.set([this.operator], 3), s.set(o, 4), s.set(n, 4 + o.length), s.set(e, 4 + o.length + n.length), s;
   }
 }
-function ae() {
+function En() {
   return {
     target(t, e) {
-      return new d(t, e);
+      return new T(t, e);
     },
     increment(t) {
-      return new _t(t);
+      return new ge(t);
     },
     decrement(t) {
-      return new vt(t);
+      return new Ae(t);
     },
     show(t) {
-      return new Rt(new d(t, 0));
+      return new we(new T(t, 0));
     },
     hide(t) {
-      return new Lt(new d(t, 0));
+      return new pe(new T(t, 0));
     },
     set(t, e) {
-      return new Mt(t, e);
+      return new me(t, e);
     },
     broadcast(t) {
-      return new Pt(t || new d(0, 0));
+      return new ye(t || new T(0, 0));
     },
-    timer(t, e, n) {
-      return new Ht(t, e, n);
+    timer(t, e, o) {
+      return new De(t, e, o);
     },
     stop() {
-      return new $t(new d(0, 0));
+      return new Ee(new T(0, 0));
     },
-    condition(t, e, n, r) {
-      return new Ot(t, e, n, r);
+    condition(t, e, o, n) {
+      return new Ie(t, e, o, n);
     },
-    map(t, e, n, r, o, s) {
-      return new kt(t, e, n, r, o, s);
+    map(t, e, o, n, r, s) {
+      return new Te(t, e, o, n, r, s);
     }
   };
 }
-const { flattenUint8Arrays: zt } = b();
-function ce(t) {
+const { flattenUint8Arrays: Ue } = K();
+function Tn(t) {
   return {
-    setButton(e, n) {
-      const r = zt(
-        n.map((s) => s.format())
-      ), o = new Uint8Array(1 + r.length);
-      return o.set([e], 0), r.forEach(
-        (s, i) => o.set([s], i + 1)
-      ), new p(f.ACTIONS, t.id, o);
+    setButton(e, o) {
+      const n = Ue(
+        o.map((s) => s.format())
+      ), r = new Uint8Array(1 + n.length);
+      return r.set([e], 0), n.forEach(
+        (s, a) => r.set([s], a + 1)
+      ), new B(f.ACTIONS, t.id, r);
     }
   };
 }
-function Gt(t) {
-  return new Promise((e, n) => {
-    const r = new Image();
-    r.onload = () => e(r), r.onerror = n, r.src = t;
+function Ce(t) {
+  return new Promise((e, o) => {
+    const n = new Image();
+    n.onload = () => e(n), n.onerror = o, n.src = t;
   });
 }
-function Vt(t) {
-  const e = document.createElement("canvas"), n = e.getContext("2d");
-  if (e.width = t.width, e.height = t.height, !n)
+function Se(t) {
+  const e = document.createElement("canvas"), o = e.getContext("2d");
+  if (e.width = t.width, e.height = t.height, !o)
     throw new Error("Failed to get 2D context for image data.");
-  return n.drawImage(t, 0, 0), n.getImageData(0, 0, t.width, t.height);
-}
-function Ft(t) {
-  const e = [], n = t.data, r = t.width, o = t.height;
-  for (let s = 0; s < o; s++)
-    for (let i = 0; i < r; i++) {
-      const a = (s * r + i) * 4, g = n[a], y = n[a + 1], m = n[a + 2], M = 0.2126 * g + 0.7152 * y + 0.0722 * m;
-      e.push(M < 128 ? 0 : 1);
+  return o.drawImage(t, 0, 0), o.getImageData(0, 0, t.width, t.height);
+}
+function be(t) {
+  const e = [], o = t.data, n = t.width, r = t.height;
+  for (let s = 0; s < r; s++)
+    for (let a = 0; a < n; a++) {
+      const c = (s * n + a) * 4, u = o[c], l = o[c + 1], E = o[c + 2], F = 0.2126 * u + 0.7152 * l + 0.0722 * E;
+      e.push(F < 128 ? 0 : 1);
     }
   return {
-    width: r,
-    height: o,
+    width: n,
+    height: r,
     pixels: e
   };
 }
-function Wt() {
+function _e() {
   return {
-    createImage: Gt,
-    getImageData: Vt,
-    imageDataToPixels: Ft
+    createImage: Ce,
+    getImageData: Se,
+    imageDataToPixels: be
   };
 }
-const { createImage: Zt, getImageData: Kt, imageDataToPixels: Xt } = Wt(), { pixelsToBytes: jt } = b();
-function qt(t) {
-  return new Promise((e, n) => {
-    Zt(t).then((r) => Kt(r)).then((r) => Xt(r)).then((r) => jt(r.pixels, r.width)).then((r) => e(r)).catch((r) => n(r));
+const { createImage: Ne, getImageData: Re, imageDataToPixels: xe } = _e(), { pixelsToBytes: Be } = K();
+function Pe(t) {
+  return new Promise((e, o) => {
+    Ne(t).then((n) => Re(n)).then((n) => xe(n)).then((n) => Be(n.pixels, n.width)).then((n) => e(n)).catch((n) => o(n));
+  });
+}
+function Dn() {
+  return {
+    imageToBytes: Pe
+  };
+}
+function Le(t, e, o, n, r) {
+  return (t - e) / (o - e) * (r - n) + n;
+}
+function In() {
+  return { map: Le };
+}
+let d = !1;
+const C = [], y = /* @__PURE__ */ new Map();
+let P = 500, V = !1;
+const lt = new I.SyncEvent(), L = new I.SyncEvent(), dt = /* @__PURE__ */ new Map([
+  [f.UPLOAD, "UPLOAD"],
+  [f.DRAW_IMAGE, "DRAW_IMAGE"],
+  [f.DRAW_RECTANGLE, "DRAW_RECTANGLE"],
+  [f.BUTTON_PRESS, "BUTTON_PRESS"],
+  [f.DRAW_TEXT, "DRAW_TEXT"],
+  [f.ALL, "ALL"],
+  [f.CLEAR_GRAPHICS, "CLEAR_GRAPHICS"],
+  [f.ACTIONS, "ACTIONS"],
+  [f.CLEAR_SCREEN, "CLEAR_SCREEN"],
+  [f.LOADER, "LOADER"]
+]);
+function Me() {
+  d = !0, V || (Ve(), V = !0);
+}
+function Oe() {
+  d = !1;
+}
+function ve() {
+  return d;
+}
+function ke(t) {
+  P = t, ht();
+}
+function $e() {
+  return C;
+}
+function ze() {
+  return Array.from(y.values());
+}
+function He(t) {
+  return y.get(t);
+}
+function Fe() {
+  C.length = 0, y.clear();
+}
+function Ge(t) {
+  const e = t.length > i.TYPE ? t[i.TYPE] : 0;
+  return {
+    cacheId: t[i.CACHE],
+    targetId: t[i.ID],
+    ttl: t[i.TTL],
+    position: t.length > 4 ? t[i.POSITION] | t[i.POSITION + 1] << 8 : 0,
+    dataSize: t.length > 6 ? t[i.DATA_SIZE] | t[i.DATA_SIZE + 1] << 8 : 0,
+    typeName: dt.get(e) ?? `UNKNOWN(${e})`,
+    typeValue: e,
+    payloadBytes: Math.max(0, t.length - i.DATA),
+    raw: Array.from(t)
+  };
+}
+function g(t, e) {
+  if (!d) return;
+  const o = {
+    type: t,
+    timestamp: Date.now(),
+    data: e
+  };
+  C.push(o), ht(), lt.post(o);
+}
+function ht() {
+  C.length > P && C.splice(0, C.length - P);
+}
+function We(t, e) {
+  if (!d) return;
+  const o = y.get(t);
+  o && (Object.assign(o, e), o.completedAt && o.queuedAt && (o.latencyMs = o.completedAt - o.queuedAt), L.post(o));
+}
+function Ve() {
+  const t = tt(), e = Z(), o = x();
+  t.onMessageQueued.attach((n) => {
+    d && (y.set(n.cacheId, {
+      cacheId: n.cacheId,
+      queuedAt: n.timestamp,
+      firstPacketAt: null,
+      completedAt: null,
+      latencyMs: null,
+      retransmitCount: 0,
+      timeoutCount: 0,
+      packetsSent: 0,
+      totalPackets: n.packetCount
+    }), g("message_queued", {
+      cacheId: n.cacheId,
+      typeName: dt.get(n.type) ?? `UNKNOWN(${n.type})`,
+      targetId: n.targetId,
+      packetCount: n.packetCount,
+      totalBytes: n.totalBytes
+    }));
+  }), t.onPacketSent.attach((n) => {
+    if (!d) return;
+    const r = y.get(n.cacheId);
+    r && (r.packetsSent++, r.firstPacketAt === null && (r.firstPacketAt = n.timestamp)), g("packet_sent", {
+      cacheId: n.cacheId,
+      position: n.position,
+      dataSize: n.dataSize,
+      batchIndex: n.batchIndex
+    });
+  }), t.onRetransmit.attach((n) => {
+    if (!d) return;
+    const r = y.get(n.cacheId);
+    r && (r.retransmitCount++, L.post(r)), g("retransmit", {
+      cacheId: n.cacheId,
+      packetCount: n.packetCount,
+      reason: n.reason
+    });
+  }), t.onTimeout.attach((n) => {
+    if (!d) return;
+    const r = y.get(n.cacheId);
+    r && (r.timeoutCount++, L.post(r)), g("timeout", {
+      cacheId: n.cacheId,
+      retryCount: n.retryCount,
+      maxRetries: n.maxRetries,
+      willRetry: n.willRetry
+    });
+  }), t.onMessageComplete.attach((n) => {
+    d && (We(n.cacheId, {
+      completedAt: n.timestamp
+    }), g("message_complete", {
+      cacheId: n.cacheId
+    }));
+  }), e.onMessageDone.attach((n) => {
+    d && g("message_done", { cacheId: n });
+  }), e.onReceivedPackets.attach((n) => {
+    d && g("received_packets", {
+      incompleteCaches: n.filter((r) => r !== 0)
+    });
+  }), e.onNode.attach((n) => {
+    if (d)
+      for (const [r, s] of n)
+        g("node_discovered", { nodeId: r, neighbors: s });
+  }), e.onNodeLost.attach((n) => {
+    d && g("node_lost", { nodeId: n });
+  }), o.onConnect.attach(() => {
+    d && g("connected", {});
+  }), o.onDisconnect.attach(() => {
+    d && g("disconnected", {});
   });
 }
-function ue() {
+function Ze() {
+  d = !1, C.length = 0, y.clear(), V = !1, P = 500;
+}
+function Un() {
   return {
-    imageToBytes: qt
+    enable: Me,
+    disable: Oe,
+    isEnabled: ve,
+    clear: Fe,
+    getLog: $e,
+    getTimings: ze,
+    getTimingForCache: He,
+    setMaxLogSize: ke,
+    decodePacket: Ge,
+    onDebugEvent: lt,
+    onTimingUpdate: L,
+    _resetForTesting: Ze
   };
 }
-function Jt(t, e, n, r, o) {
-  return (t - e) / (n - e) * (o - r) + r;
+const { messageCharUuid: gt, messageFloodCharUuid: z, handshakeCharUuid: At, BATCH_SIZE: Ye, PACKET_SIZE: M } = O();
+let q = !1, R = !1, H = !0, h = { standees: [] };
+const m = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map();
+let S = 0;
+const J = 7;
+function Ke(t) {
+  h = {
+    responseDelay: 10,
+    dropRate: 0,
+    partialDelivery: !1,
+    ...t
+  }, q = !0, R = !1, H = !0, m.clear(), D.clear(), S = 0, et(rn);
+}
+function wt() {
+  q = !1, R = !1, H = !0, m.clear(), D.clear(), S = 0, et(null);
+}
+function qe() {
+  return q;
+}
+function Xe() {
+  return h;
+}
+function je(t) {
+  h = { ...h, ...t };
+}
+function Je(t, e, o) {
+  const n = m.get(gt);
+  if (!n) return;
+  const r = e === "plus" ? G.PLUS : e === "minus" ? G.MINUS : G.EITHER, s = o ? new TextEncoder().encode(o) : new Uint8Array(0), a = i.DATA + 1 + s.length, c = new ArrayBuffer(a), u = new DataView(c);
+  u.setUint8(i.ID, t), u.setUint8(i.TYPE, f.BUTTON_PRESS), u.setUint8(i.DATA, r);
+  for (let l = 0; l < s.length; l++)
+    u.setUint8(i.DATA + 1 + l, s[l]);
+  n(u);
+}
+function Qe(t) {
+  const e = m.get(z);
+  if (!e) return;
+  const o = new ArrayBuffer(i.DATA + 1), n = new DataView(o);
+  n.setUint8(i.ID, t), n.setUint8(i.TYPE, v.LOST_NODE), n.setUint8(i.DATA, t), e(n);
+}
+function tn(t) {
+  const e = m.get(z);
+  e && e(cn(t));
+}
+function en() {
+  R = !1, m.clear(), D.clear(), S = 0, x().onDisconnect.post();
+}
+function nn(t) {
+  H = t;
+}
+function on() {
+  wt();
+}
+const rn = {
+  async connect(t) {
+    R = !0, x().onConnect.post();
+  },
+  async reconnect() {
+    if (!H)
+      throw new Error("No devices found");
+    R = !0, x().onConnect.post();
+  },
+  async readCharacteristic(t, e) {
+  },
+  async writeCharacteristic(t, e, o) {
+    if (!R || e !== gt || h.dropRate !== void 0 && h.dropRate > 0 && Math.random() < h.dropRate)
+      return;
+    const n = o[i.CACHE], r = o[i.POSITION] | o[i.POSITION + 1] << 8, s = o[i.DATA_SIZE] | o[i.DATA_SIZE + 1] << 8;
+    D.has(n) || D.set(n, {
+      received: /* @__PURE__ */ new Set(),
+      dataSize: s
+    });
+    const a = D.get(n);
+    a.received.add(r), S++;
+    const c = Math.ceil(s / M);
+    if (a.received.size >= c) {
+      const l = h.responseDelay ?? 10;
+      setTimeout(() => {
+        sn(n);
+      }, l);
+      return;
+    }
+    if (h.partialDelivery && S >= Ye) {
+      S = 0;
+      const l = h.responseDelay ?? 10;
+      setTimeout(() => {
+        const E = [];
+        for (const [F, X] of D) {
+          const pt = Math.ceil(X.dataSize / M);
+          X.received.size < pt && E.push(F);
+        }
+        E.length > 0 && an(E);
+      }, l);
+    }
+  },
+  async subscribe(t, e, o) {
+    m.set(e, o), e === At && un();
+  }
+};
+function sn(t) {
+  const e = m.get(z);
+  if (!e) return;
+  const o = new ArrayBuffer(i.DATA + 1), n = new DataView(o);
+  n.setUint8(i.TYPE, v.MESSAGE_DONE), n.setUint8(i.DATA, t), D.delete(t), S = 0, e(n);
+}
+function an(t) {
+  const e = m.get(z);
+  if (!e) return;
+  const o = new ArrayBuffer(i.DATA + t.length), n = new DataView(o);
+  n.setUint8(i.TYPE, v.DATA_FEEDBACK);
+  for (let r = 0; r < t.length; r++)
+    n.setUint8(i.DATA + r, t[r]);
+  e(n);
+}
+function cn(t) {
+  const e = i.DATA + 1 + t.neighbors.length, o = new ArrayBuffer(e), n = new DataView(o);
+  n.setUint8(i.TYPE, v.NODES), n.setUint8(i.DATA, t.id);
+  for (let r = 0; r < t.neighbors.length; r++)
+    n.setUint8(i.DATA + 1 + r, t.neighbors[r]);
+  return n;
 }
-function he() {
-  return { map: Jt };
+function un() {
+  const t = m.get(At);
+  if (!t || h.standees.length === 0) return;
+  const e = [h.standees.length];
+  for (const r of h.standees)
+    e.push(r.id, r.neighbors.length, ...r.neighbors);
+  const o = 200, n = e.length;
+  for (let r = 0; r < n; r += M) {
+    const s = Math.min(M, n - r), a = J + s, c = new ArrayBuffer(a), u = new DataView(c);
+    u.setUint8(i.ID, 0), u.setUint8(i.CACHE, o), u.setUint8(i.TTL, 10), u.setUint16(i.POSITION, r, !0), u.setUint16(i.DATA_SIZE, n, !0);
+    for (let l = 0; l < s; l++)
+      u.setUint8(J + l, e[r + l]);
+    t(u);
+  }
+}
+function Cn() {
+  return {
+    activate: Ke,
+    deactivate: wt,
+    isActive: qe,
+    getConfig: Xe,
+    updateConfig: je,
+    pressButton: Je,
+    simulateNodeLost: Qe,
+    simulateNodeJoin: tn,
+    disconnect: en,
+    reconnectable: nn,
+    _resetForTesting: on
+  };
 }
 export {
-  ae as useActions,
-  b as useBinary,
-  ce as useButtons,
-  ue as useConverter,
-  se as useDisplay,
-  ee as useGraphics,
-  Wt as useImage,
-  ne as useLoader,
-  gt as useMesh,
-  oe as useStandeeElements,
-  re as useStandees,
-  he as useUtils
+  En as useActions,
+  K as useBinary,
+  Tn as useButtons,
+  Dn as useConverter,
+  Un as useDebug,
+  pn as useDisplay,
+  hn as useGraphics,
+  _e as useImage,
+  gn as useLoader,
+  jt as useMesh,
+  Cn as useMockBluetooth,
+  wn as useStandeeElements,
+  An as useStandees,
+  In as useUtils
 };