nsd-ble 0.2.1 → 0.2.2

package/dist/Objects-RyXOt964.js

@@ -0,0 +1,867 @@
+import { Data as L, DataType as J, Button as k } from "./enums.js";
+let H = !1, B = [], M, ce, U = /* @__PURE__ */ new Map();
+async function we(t) {
+  try {
+    if (M = await navigator.bluetooth.requestDevice(t), M.gatt === void 0)
+      throw new Error("Device does not support GATT");
+    ce = await M.gatt.connect(), M.addEventListener("gattserverdisconnected", me), H = !0;
+  } catch (c) {
+    throw c;
+  }
+}
+function me() {
+  U.clear(), H = !1, B.forEach((t) => t());
+}
+function Ce(t) {
+  B.push(t);
+}
+function Ae(t) {
+  B = B.filter((c) => c !== t);
+}
+async function X(t, c) {
+  if (U.has(c)) {
+    const d = U.get(c);
+    if (d === void 0)
+      throw new Error("Characteristic not found");
+    return d;
+  }
+  const h = await (await ce.getPrimaryService(t)).getCharacteristic(c);
+  return U.set(c, h), h;
+}
+async function be(t, c) {
+  return await (await X(t, c)).readValue();
+}
+async function Se(t, c, r) {
+  const h = new DataView(new ArrayBuffer(r.length));
+  for (let l = 0; l < r.length; l++)
+    h.setUint8(l, r[l]);
+  await (await X(t, c)).writeValue(h);
+}
+async function qe(t, c, r) {
+  const h = await X(t, c);
+  h.addEventListener(
+    "characteristicvaluechanged",
+    (d) => {
+      let l = d.target.value;
+      l === void 0 && (l = new DataView(new ArrayBuffer(0))), r(l);
+    }
+  ), await h.startNotifications();
+}
+function he() {
+  return {
+    connected: H,
+    connect: we,
+    readCharacteristic: be,
+    writeCharacteristic: Se,
+    subscribe: qe,
+    setDisconnectCallback: Ce,
+    removeDisconnectCallback: Ae
+  };
+}
+const le = "19b10000-e8f2-537e-4f6c-d104768a1214", Oe = "6b061bdc-9bc1-4952-a96f-c6ed551b2c3e", Pe = "998ff920-81af-42a9-a915-f88025f9647d", De = {
+  filters: [{ namePrefix: "BLE-STANDEE" }],
+  optionalServices: [le]
+};
+function fe() {
+  return {
+    serviceUuid: le,
+    messageCharUuid: Oe,
+    handshakeCharUuid: Pe,
+    options: De
+  };
+}
+var A = {}, q = {}, x;
+function V() {
+  if (x) return q;
+  x = 1, Object.defineProperty(q, "__esModule", { value: !0 }), q.BaseEvent = void 0;
+  var t = (
+    /** @class */
+    (function() {
+      function c() {
+      }
+      return c.prototype.attach = function(r, h) {
+        return this._attach(r, h, !1);
+      }, c.prototype.once = function(r, h) {
+        return this._attach(r, h, !0);
+      }, c.prototype._attach = function(r, h, d) {
+        var l = this, u, o, i, a;
+        if (typeof r == "function")
+          o = r, a = function() {
+            return l.detach(o);
+          };
+        else if (!h && typeof r.post == "function")
+          i = r, a = function() {
+            return l.detach(i);
+          };
+        else {
+          if (typeof r != "object" || r === void 0)
+            throw new Error("Expect a function or object as first argument");
+          if (typeof h != "function")
+            throw new Error("Expect a function as second argument");
+          u = r, o = h, a = function() {
+            return l.detach(u, o);
+          };
+        }
+        return this._listeners ? this._listeners = this._listeners.slice() : this._listeners = [], this._listeners.push({
+          deleted: !1,
+          boundTo: u,
+          handler: o,
+          event: i,
+          once: d
+        }), a;
+      }, c.prototype.detach = function() {
+        for (var r = [], h = 0; h < arguments.length; h++)
+          r[h] = arguments[h];
+        this._detach.apply(this, r);
+      }, c.prototype._detach = function() {
+        for (var r = [], h = 0; h < arguments.length; h++)
+          r[h] = arguments[h];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          var d, l, u;
+          r.length >= 1 && (typeof r[0] == "function" ? l = r[0] : r.length === 1 && typeof r[0].post == "function" ? u = r[0] : d = r[0]), r.length >= 2 && (l = r[1]), this._listeners = this._listeners.filter(function(o) {
+            return (typeof l > "u" || o.handler === l) && (typeof u > "u" || o.event === u) && (typeof d > "u" || o.boundTo === d) ? (o.deleted = !0, !1) : !0;
+          }), this._listeners.length === 0 && delete this._listeners;
+        }
+      }, c.prototype.post = function(r) {
+        throw new Error("abstract");
+      }, c.prototype.listenerCount = function() {
+        return this._listeners ? this._listeners.length : 0;
+      }, c.prototype._call = function(r, h) {
+        this._listeners && (r.deleted || (r.once && (r.deleted = !0, this._listeners = this._listeners.filter(function(d) {
+          return d !== r;
+        }), this._listeners.length === 0 && delete this._listeners), r.event ? r.event.post.apply(r.event, h) : r.handler && r.handler.apply(typeof r.boundTo == "object" ? r.boundTo : this, h)));
+      }, c;
+    })()
+  );
+  return q.BaseEvent = t, q;
+}
+var E = {}, ee;
+function Q() {
+  if (ee) return E;
+  ee = 1;
+  var t = E && E.__extends || /* @__PURE__ */ (function() {
+    var l = function(u, o) {
+      return l = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(i, a) {
+        i.__proto__ = a;
+      } || function(i, a) {
+        for (var n in a) a.hasOwnProperty(n) && (i[n] = a[n]);
+      }, l(u, o);
+    };
+    return function(u, o) {
+      l(u, o);
+      function i() {
+        this.constructor = u;
+      }
+      u.prototype = o === null ? Object.create(o) : (i.prototype = o.prototype, new i());
+    };
+  })();
+  Object.defineProperty(E, "__esModule", { value: !0 }), E.ErrorSyncEvent = E.VoidSyncEvent = E.SyncEvent = void 0;
+  var c = V(), r = (
+    /** @class */
+    (function(l) {
+      t(u, l);
+      function u() {
+        var o = l !== null && l.apply(this, arguments) || this;
+        return o._recursion = 0, o;
+      }
+      return Object.defineProperty(u.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new h()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), u.prototype.post = function() {
+        for (var o = [], i = 0; i < arguments.length; i++)
+          o[i] = arguments[i];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          if (this._recursion++, typeof u.MAX_RECURSION_DEPTH == "number" && Number.isInteger(u.MAX_RECURSION_DEPTH) && u.MAX_RECURSION_DEPTH > 0 && this._recursion > u.MAX_RECURSION_DEPTH)
+            throw new Error("event fired recursively");
+          for (var a = this._listeners, n = 0; n < a.length; ++n) {
+            var e = a[n];
+            this._call(e, o);
+          }
+          this._recursion--;
+        }
+      }, u.prototype._attach = function(o, i, a) {
+        var n, e, s, f, v = (e = (n = this._listeners) === null || n === void 0 ? void 0 : n.length) !== null && e !== void 0 ? e : 0, y = l.prototype._attach.call(this, o, i, a);
+        return this.evtListenersChanged && v !== ((f = (s = this._listeners) === null || s === void 0 ? void 0 : s.length) !== null && f !== void 0 ? f : 0) && this.evtListenersChanged.post(), y;
+      }, u.prototype._detach = function() {
+        for (var o, i, a, n, e = [], s = 0; s < arguments.length; s++)
+          e[s] = arguments[s];
+        var f = (i = (o = this._listeners) === null || o === void 0 ? void 0 : o.length) !== null && i !== void 0 ? i : 0, v = l.prototype._detach.apply(this, e);
+        return this.evtListenersChanged && f !== ((n = (a = this._listeners) === null || a === void 0 ? void 0 : a.length) !== null && n !== void 0 ? n : 0) && this.evtListenersChanged.post(), v;
+      }, u.MAX_RECURSION_DEPTH = 10, u;
+    })(c.BaseEvent)
+  );
+  E.SyncEvent = r;
+  var h = (
+    /** @class */
+    (function(l) {
+      t(u, l);
+      function u() {
+        return l !== null && l.apply(this, arguments) || this;
+      }
+      return u.prototype.post = function() {
+        l.prototype.post.call(this, void 0);
+      }, u;
+    })(r)
+  );
+  E.VoidSyncEvent = h;
+  var d = (
+    /** @class */
+    (function(l) {
+      t(u, l);
+      function u() {
+        return l !== null && l.apply(this, arguments) || this;
+      }
+      return u.prototype.post = function(o) {
+        if (this.listenerCount() === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + o.message);
+        l.prototype.post.call(this, o);
+      }, u;
+    })(r)
+  );
+  return E.ErrorSyncEvent = d, E;
+}
+var w = {}, T = {}, te;
+function $() {
+  if (te) return T;
+  te = 1, Object.defineProperty(T, "__esModule", { value: !0 });
+  var t = Q(), c = (
+    /** @class */
+    (function() {
+      function r() {
+        this.evtFilled = new t.SyncEvent(), this.evtDrained = new t.SyncEvent(), this._queue = [], this._flushing = !1;
+      }
+      return r.global = function() {
+        return r._instance || r.resetGlobal(), r._instance;
+      }, r.resetGlobal = function() {
+        r._instance = new r();
+      }, r.prototype.empty = function() {
+        return this._queue.length === 0;
+      }, r.prototype.add = function(h) {
+        this._queue.push(h), this._queue.length === 1 && !this._flushing && this.evtFilled.post(this);
+      }, r.prototype.flushOnce = function() {
+        var h = this._queue.length === 0, d = this._flushing;
+        this._flushing = !0;
+        try {
+          var l = this._queue;
+          this._queue = [];
+          for (var u = 0; u < l.length; ++u)
+            l[u]();
+        } finally {
+          this._flushing = d, !h && !d && this._queue.length === 0 && this.evtDrained.post(this);
+        }
+      }, r.prototype.flush = function(h) {
+        h === void 0 && (h = 10);
+        var d = this._queue.length === 0, l = this._flushing;
+        this._flushing = !0;
+        try {
+          for (var u = 0; this._queue.length > 0; ) {
+            if (typeof h == "number" && u >= h)
+              throw this._queue = [], new Error("unable to flush the queue due to recursively added event. Clearing queue now");
+            this.flushOnce(), ++u;
+          }
+        } finally {
+          this._flushing = l, !d && !l && this._queue.length === 0 && this.evtDrained.post(this);
+        }
+      }, r;
+    })()
+  );
+  return T.default = c, T;
+}
+var ne;
+function ve() {
+  if (ne) return w;
+  ne = 1;
+  var t = w && w.__extends || /* @__PURE__ */ (function() {
+    var o = function(i, a) {
+      return o = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(n, e) {
+        n.__proto__ = e;
+      } || function(n, e) {
+        for (var s in e) e.hasOwnProperty(s) && (n[s] = e[s]);
+      }, o(i, a);
+    };
+    return function(i, a) {
+      o(i, a);
+      function n() {
+        this.constructor = i;
+      }
+      i.prototype = a === null ? Object.create(a) : (n.prototype = a.prototype, new n());
+    };
+  })();
+  Object.defineProperty(w, "__esModule", { value: !0 }), w.ErrorQueuedEvent = w.VoidQueuedEvent = w.QueuedEvent = void 0;
+  var c = V(), r = $(), h = Q(), d = (
+    /** @class */
+    (function(o) {
+      t(i, o);
+      function i(a) {
+        a === void 0 && (a = {});
+        var n = o.call(this) || this;
+        return n._queued = !1, n.options = a, typeof a.condensed == "boolean" ? n._condensed = a.condensed : n._condensed = !1, typeof a.queue == "object" && a.queue !== null && (n._queue = a.queue), n;
+      }
+      return Object.defineProperty(i.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new h.VoidSyncEvent()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), i.prototype.post = function() {
+        for (var a = this, n = [], e = 0; e < arguments.length; e++)
+          n[e] = arguments[e];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          var s = this._queue ? this._queue : r.default.global();
+          if (this._condensed) {
+            if (this._queuedData = n, this._queuedListeners = this._listeners, this._queued)
+              return;
+            this._queued = !0, s.add(function() {
+              a._queued = !1;
+              for (var v = a._queuedData, y = a._queuedListeners, p = 0; p < y.length; ++p) {
+                var g = y[p];
+                a._call(g, v);
+              }
+            });
+          } else {
+            var f = this._listeners;
+            s.add(function() {
+              for (var v = 0; v < f.length; ++v) {
+                var y = f[v];
+                a._call(y, n);
+              }
+            });
+          }
+        }
+      }, i.prototype._attach = function(a, n, e) {
+        var s, f, v, y, p = (f = (s = this._listeners) === null || s === void 0 ? void 0 : s.length) !== null && f !== void 0 ? f : 0, g = o.prototype._attach.call(this, a, n, e);
+        return this.evtListenersChanged && p !== ((y = (v = this._listeners) === null || v === void 0 ? void 0 : v.length) !== null && y !== void 0 ? y : 0) && this.evtListenersChanged.post(), g;
+      }, i.prototype._detach = function() {
+        for (var a, n, e, s, f = [], v = 0; v < arguments.length; v++)
+          f[v] = arguments[v];
+        var y = (n = (a = this._listeners) === null || a === void 0 ? void 0 : a.length) !== null && n !== void 0 ? n : 0, p = o.prototype._detach.apply(this, f);
+        return this.evtListenersChanged && y !== ((s = (e = this._listeners) === null || e === void 0 ? void 0 : e.length) !== null && s !== void 0 ? s : 0) && this.evtListenersChanged.post(), p;
+      }, i;
+    })(c.BaseEvent)
+  );
+  w.QueuedEvent = d;
+  var l = (
+    /** @class */
+    (function(o) {
+      t(i, o);
+      function i() {
+        return o !== null && o.apply(this, arguments) || this;
+      }
+      return i.prototype.post = function() {
+        o.prototype.post.call(this, void 0);
+      }, i;
+    })(d)
+  );
+  w.VoidQueuedEvent = l;
+  var u = (
+    /** @class */
+    (function(o) {
+      t(i, o);
+      function i() {
+        return o !== null && o.apply(this, arguments) || this;
+      }
+      return i.prototype.post = function(a) {
+        if (!this._listeners || this._listeners.length === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + a.message);
+        o.prototype.post.call(this, a);
+      }, i;
+    })(d)
+  );
+  return w.ErrorQueuedEvent = u, w;
+}
+var m = {}, re;
+function de() {
+  if (re) return m;
+  re = 1;
+  var t = m && m.__extends || /* @__PURE__ */ (function() {
+    var u = function(o, i) {
+      return u = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(a, n) {
+        a.__proto__ = n;
+      } || function(a, n) {
+        for (var e in n) n.hasOwnProperty(e) && (a[e] = n[e]);
+      }, u(o, i);
+    };
+    return function(o, i) {
+      u(o, i);
+      function a() {
+        this.constructor = o;
+      }
+      o.prototype = i === null ? Object.create(i) : (a.prototype = i.prototype, new a());
+    };
+  })();
+  Object.defineProperty(m, "__esModule", { value: !0 }), m.ErrorAsyncEvent = m.VoidAsyncEvent = m.AsyncEvent = void 0;
+  var c = V(), r = Q(), h = (
+    /** @class */
+    (function(u) {
+      t(o, u);
+      function o(i) {
+        i === void 0 && (i = {});
+        var a = u.call(this) || this;
+        return a._queued = !1, a.options = i, typeof i.condensed == "boolean" ? a._condensed = i.condensed : a._condensed = !1, a;
+      }
+      return Object.defineProperty(o.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new r.VoidSyncEvent()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), o.defaultScheduler = function(i) {
+        typeof window < "u" ? setTimeout(i, 0) : setImmediate(i);
+      }, o.setScheduler = function(i) {
+        o._scheduler = i;
+      }, o.prototype.post = function() {
+        for (var i = this, a = [], n = 0; n < arguments.length; n++)
+          a[n] = arguments[n];
+        if (!(!this._listeners || this._listeners.length === 0))
+          if (this._condensed) {
+            if (this._queuedData = a, this._queuedListeners = this._listeners, this._queued)
+              return;
+            this._queued = !0, o._scheduler(function() {
+              i._queued = !1;
+              for (var s = i._queuedData, f = i._queuedListeners, v = 0; v < f.length; ++v) {
+                var y = f[v];
+                i._call(y, s);
+              }
+            });
+          } else {
+            var e = this._listeners;
+            o._scheduler(function() {
+              for (var s = 0; s < e.length; ++s) {
+                var f = e[s];
+                i._call(f, a);
+              }
+            });
+          }
+      }, o.prototype._call = function(i, a) {
+        i.event && i.event instanceof o ? i.event._postDirect(a) : u.prototype._call.call(this, i, a);
+      }, o.prototype._postDirect = function(i) {
+        if (!(!this._listeners || this._listeners.length === 0))
+          for (var a = this._listeners, n = 0; n < a.length; ++n) {
+            var e = a[n];
+            this._call(e, i);
+          }
+      }, o.prototype._attach = function(i, a, n) {
+        var e, s, f, v, y = (s = (e = this._listeners) === null || e === void 0 ? void 0 : e.length) !== null && s !== void 0 ? s : 0, p = u.prototype._attach.call(this, i, a, n);
+        return this.evtListenersChanged && y !== ((v = (f = this._listeners) === null || f === void 0 ? void 0 : f.length) !== null && v !== void 0 ? v : 0) && this.evtListenersChanged.post(), p;
+      }, o.prototype._detach = function() {
+        for (var i, a, n, e, s = [], f = 0; f < arguments.length; f++)
+          s[f] = arguments[f];
+        var v = (a = (i = this._listeners) === null || i === void 0 ? void 0 : i.length) !== null && a !== void 0 ? a : 0, y = u.prototype._detach.apply(this, s);
+        return this.evtListenersChanged && v !== ((e = (n = this._listeners) === null || n === void 0 ? void 0 : n.length) !== null && e !== void 0 ? e : 0) && this.evtListenersChanged.post(), y;
+      }, o._scheduler = o.defaultScheduler, o;
+    })(c.BaseEvent)
+  );
+  m.AsyncEvent = h;
+  var d = (
+    /** @class */
+    (function(u) {
+      t(o, u);
+      function o() {
+        return u !== null && u.apply(this, arguments) || this;
+      }
+      return o.prototype.post = function() {
+        u.prototype.post.call(this, void 0);
+      }, o;
+    })(h)
+  );
+  m.VoidAsyncEvent = d;
+  var l = (
+    /** @class */
+    (function(u) {
+      t(o, u);
+      function o() {
+        return u !== null && u.apply(this, arguments) || this;
+      }
+      return o.prototype.post = function(i) {
+        if (this.listenerCount() === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + i.message);
+        u.prototype.post.call(this, i);
+      }, o;
+    })(h)
+  );
+  return m.ErrorAsyncEvent = l, m;
+}
+var O = {}, P = {}, se;
+function Le() {
+  if (se) return P;
+  se = 1, Object.defineProperty(P, "__esModule", { value: !0 }), P.shallowEquals = void 0;
+  function t(c, r) {
+    if (c === r)
+      return !0;
+    if (typeof c != typeof r)
+      return !1;
+    switch (typeof c) {
+      case "boolean":
+      case "number":
+      case "string":
+      case "function":
+      case "symbol":
+      case "undefined":
+        return !1;
+      case "object":
+        if (c === null || r === null)
+          return !1;
+        if (Array.isArray(c) || Array.isArray(r)) {
+          if (!Array.isArray(c) || !Array.isArray(r) || c.length !== r.length)
+            return !1;
+          for (var h = 0; h < c.length; ++h)
+            if (c[h] !== r[h])
+              return !1;
+          return !0;
+        }
+        var d = [], l = [];
+        for (var u in c)
+          c.hasOwnProperty(u) && d.push(u);
+        for (var o in r)
+          r.hasOwnProperty(o) && l.push(o);
+        if (d.sort(), l.sort(), d.join(",") !== l.join(","))
+          return !1;
+        for (var h = 0; h < d.length; ++h)
+          if (c[d[h]] !== r[d[h]])
+            return !1;
+        return !0;
+      default:
+        return !1;
+    }
+  }
+  return P.shallowEquals = t, P;
+}
+var ie;
+function je() {
+  return ie || (ie = 1, (function(t) {
+    var c = O && O.__extends || /* @__PURE__ */ (function() {
+      var n = function(e, s) {
+        return n = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(f, v) {
+          f.__proto__ = v;
+        } || function(f, v) {
+          for (var y in v) v.hasOwnProperty(y) && (f[y] = v[y]);
+        }, n(e, s);
+      };
+      return function(e, s) {
+        n(e, s);
+        function f() {
+          this.constructor = e;
+        }
+        e.prototype = s === null ? Object.create(s) : (f.prototype = s.prototype, new f());
+      };
+    })();
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.ErrorAnyEvent = t.VoidAnyEvent = t.AnyEvent = t.EventType = void 0;
+    var r = Le(), h = Q(), d = de(), l = ve(), u;
+    (function(n) {
+      n[n.Sync = 0] = "Sync", n[n.Async = 1] = "Async", n[n.Queued = 2] = "Queued";
+    })(u = t.EventType || (t.EventType = {}));
+    var o = (
+      /** @class */
+      (function() {
+        function n(e) {
+          this._events = [], e && e.monitorAttach && (this.evtFirstAttached = new i(), this.evtLastDetached = new i());
+        }
+        return Object.defineProperty(n.prototype, "evtListenersChanged", {
+          /**
+           * Sent when someone attaches or detaches
+           */
+          get: function() {
+            return this._listenersChanged || (this._listenersChanged = new h.VoidSyncEvent()), this._listenersChanged;
+          },
+          enumerable: !1,
+          configurable: !0
+        }), n.prototype.attach = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          var f = u.Sync;
+          e.length > 0 && typeof e[0] == "number" && (f = e.shift());
+          var v = this, y, p, g;
+          return typeof e[0] == "function" || e[0] && typeof e[0] == "object" && typeof e[0].post == "function" ? (typeof e[0] == "function" ? y = e[0] : g = e[0], p = e[1]) : (v = e[0], y = e[1], p = e[2]), this._attach(f, v, y, g, p, !1);
+        }, n.prototype.once = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          var f = u.Sync;
+          e.length > 0 && typeof e[0] == "number" && (f = e.shift());
+          var v = this, y, p, g;
+          return typeof e[0] == "function" || e[0] && typeof e[0] == "object" && typeof e[0].post == "function" ? (typeof e[0] == "function" ? y = e[0] : g = e[0], p = e[1]) : (v = e[0], y = e[1], p = e[2]), this._attach(f, v, y, g, p, !0);
+        }, n.prototype._attach = function(e, s, f, v, y, p) {
+          var g = this, Y = this.evtFirstAttached ? this.listenerCount() : 0, _;
+          switch (e) {
+            case u.Sync:
+              {
+                for (var R = 0, z = this._events; R < z.length; R++) {
+                  var C = z[R];
+                  C instanceof h.SyncEvent && (_ = C);
+                }
+                _ || (_ = new h.SyncEvent(), this._events.push(_));
+              }
+              break;
+            case u.Async:
+              {
+                for (var I = 0, K = this._events; I < K.length; I++) {
+                  var C = K[I];
+                  C instanceof d.AsyncEvent && r.shallowEquals(C.options, y) && (_ = C);
+                }
+                _ || (_ = new d.AsyncEvent(y), this._events.push(_));
+              }
+              break;
+            case u.Queued:
+              {
+                for (var N = 0, W = this._events; N < W.length; N++) {
+                  var C = W[N];
+                  C instanceof l.QueuedEvent && r.shallowEquals(C.options, y) && (_ = C);
+                }
+                _ || (_ = new l.QueuedEvent(y), this._events.push(_));
+              }
+              break;
+            default:
+              throw new Error("unknown EventType");
+          }
+          var S;
+          return p ? v ? S = _.once(v) : S = _.once(s, f) : v ? S = _.attach(v) : S = _.attach(s, f), this.evtFirstAttached && Y === 0 && this.evtFirstAttached.post(), this.evtListenersChanged && Y !== this.listenerCount() && this.evtListenersChanged.post(), function() {
+            var Z = g.evtLastDetached ? g.listenerCount() : 0;
+            S(), g.evtLastDetached && Z > 0 && g.listenerCount() === 0 && g.evtLastDetached.post(), g.evtListenersChanged && Z !== g.listenerCount() && g.evtListenersChanged.post();
+          };
+        }, n.prototype.attachSync = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          return e.unshift(u.Sync), this.attach.apply(this, e);
+        }, n.prototype.onceSync = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          return e.unshift(u.Sync), this.once.apply(this, e);
+        }, n.prototype.attachAsync = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          return e.unshift(u.Async), this.attach.apply(this, e);
+        }, n.prototype.onceAsync = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          return e.unshift(u.Async), this.once.apply(this, e);
+        }, n.prototype.attachQueued = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          return e.unshift(u.Queued), this.attach.apply(this, e);
+        }, n.prototype.onceQueued = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          return e.unshift(u.Queued), this.once.apply(this, e);
+        }, n.prototype.detach = function() {
+          for (var e = [], s = 0; s < arguments.length; s++)
+            e[s] = arguments[s];
+          for (var f = this.listenerCount(), v = 0; v < this._events.length; ++v)
+            this._events[v].detach.apply(this._events[v], e);
+          this.evtListenersChanged && f !== this.listenerCount() && this.evtListenersChanged.post(), this.evtLastDetached && f > 0 && this.listenerCount() === 0 && this.evtLastDetached.post();
+        }, n.prototype.post = function(e) {
+          for (var s = [], f = 0; f < this._events.length; ++f)
+            s.push(this._events[f]);
+          for (var f = 0; f < s.length; ++f)
+            s[f].post(e);
+        }, n.prototype.listenerCount = function() {
+          for (var e = 0, s = 0; s < this._events.length; ++s)
+            e += this._events[s].listenerCount();
+          return e;
+        }, n;
+      })()
+    );
+    t.AnyEvent = o;
+    var i = (
+      /** @class */
+      (function(n) {
+        c(e, n);
+        function e() {
+          return n !== null && n.apply(this, arguments) || this;
+        }
+        return e.prototype.post = function() {
+          n.prototype.post.call(this, void 0);
+        }, e;
+      })(o)
+    );
+    t.VoidAnyEvent = i;
+    var a = (
+      /** @class */
+      (function(n) {
+        c(e, n);
+        function e() {
+          return n !== null && n.apply(this, arguments) || this;
+        }
+        return e.prototype.post = function(s) {
+          if (this.listenerCount() === 0)
+            throw new Error("error event posted while no listeners attached. Error: " + s.message);
+          n.prototype.post.call(this, s);
+        }, e;
+      })(o)
+    );
+    t.ErrorAnyEvent = a;
+  })(O)), O;
+}
+var oe;
+function Qe() {
+  return oe || (oe = 1, (function(t) {
+    var c = A && A.__createBinding || (Object.create ? (function(i, a, n, e) {
+      e === void 0 && (e = n), Object.defineProperty(i, e, { enumerable: !0, get: function() {
+        return a[n];
+      } });
+    }) : (function(i, a, n, e) {
+      e === void 0 && (e = n), i[e] = a[n];
+    })), r = A && A.__exportStar || function(i, a) {
+      for (var n in i) n !== "default" && !a.hasOwnProperty(n) && c(a, i, n);
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.flush = t.flushOnce = t.queue = void 0, r(V(), t), r(Q(), t), r(ve(), t), r(de(), t), r(je(), t);
+    var h = $(), d = $();
+    Object.defineProperty(t, "EventQueue", { enumerable: !0, get: function() {
+      return d.default;
+    } });
+    function l() {
+      return h.default.global();
+    }
+    t.queue = l;
+    function u() {
+      h.default.global().flushOnce();
+    }
+    t.flushOnce = u;
+    function o(i) {
+      i === void 0 && (i = 10), h.default.global().flush(i);
+    }
+    t.flush = o;
+  })(A)), A;
+}
+var b = Qe();
+class Me {
+  id;
+  data;
+  constructor(c, r) {
+    this.id = c, this.data = r;
+  }
+}
+const { serviceUuid: Te, messageCharUuid: Ue } = fe(), ye = new b.SyncEvent(), pe = new b.SyncEvent(), ge = new b.SyncEvent(), _e = new b.SyncEvent();
+function Be() {
+  return new Promise((t, c) => {
+    he().subscribe(Te, Ue, Ve).then(() => t()).catch((r) => c(r));
+  });
+}
+function Ve(t) {
+  t !== void 0 && (t.getUint8(L.TYPE) === J.BUTTON_PRESS && Re(t), t.getUint8(L.TYPE) === J.MESSAGE_DONE && _e.post(t.getUint8(L.DATA)));
+}
+function Re(t) {
+  const c = t.getUint8(L.DATA), r = new Me(
+    t.getUint8(L.ID),
+    Ie(t)
+  );
+  c === k.MINUS && pe.post(r), c === k.PLUS && ye.post(r), c === k.EITHER && ge.post(r);
+}
+function Ie(t) {
+  const c = t.buffer, r = 7, h = t.byteLength - 7;
+  return Array.from(new Uint8Array(c, r, h)).map((d) => String.fromCharCode(d)).join("").replace(/\0/g, "").trim();
+}
+function Ne() {
+  return {
+    subscribe: Be,
+    onPlusButton: ye,
+    onMinButton: pe,
+    onEitherButton: ge,
+    onMessageDone: _e
+  };
+}
+const j = [];
+function ke() {
+  let t = Math.floor(Math.random() * 256);
+  for (; j.includes(t); ) t = Math.floor(Math.random() * 256);
+  return t;
+}
+function $e(t) {
+  j.push(t), Fe();
+}
+function Fe() {
+  j.length <= 20 || j.splice(0, j.length - 20);
+}
+function He() {
+  const t = ke();
+  return $e(t), t;
+}
+function Xe() {
+  return {
+    create: He
+  };
+}
+const { serviceUuid: Ge, messageCharUuid: Ye } = fe(), { onMessageDone: ze } = Ne(), Ke = he(), Ee = [], F = /* @__PURE__ */ new Map();
+let D = !1;
+ze.attach(Ze);
+function We(t) {
+  return t.packets.forEach((c) => Ee.push(c)), new Promise((c) => {
+    F.set(t.cache, c), D || G();
+  });
+}
+function G() {
+  if (D)
+    return;
+  const t = Ee.shift();
+  if (t == null) {
+    D = !1;
+    return;
+  }
+  D = !0, Ke.writeCharacteristic(Ge, Ye, t).catch((c) => console.log(c)).finally(() => {
+    D = !1, G();
+  });
+}
+function Ze(t) {
+  F.get(t)?.(), F.delete(t), G();
+}
+function Je() {
+  return { write: We };
+}
+const ae = 10, ue = 15;
+function xe(t) {
+  if (t.data == null) {
+    let d = [t.id, t.cache, ae, 0, 2, t.type, 0];
+    return [new Uint8Array(d)];
+  }
+  const c = new Uint8Array(2 + t.data.length), r = t.data.length + 2, h = [];
+  c.set([t.type, r], 0), c.set(t.data, 2);
+  for (let d = 0; d < r; d += ue) {
+    const l = Math.min(ue, r - d), u = new Uint8Array(l), o = [t.id, t.cache, ae, d, r];
+    u.set(c.subarray(d, d + l), 0), h.push(new Uint8Array([...o, ...u]));
+  }
+  return h;
+}
+class tt {
+  cache = Xe().create();
+  type;
+  id;
+  data;
+  packets = [];
+  constructor(c, r, h) {
+    this.type = c, this.id = r, this.data = h, this.packets = xe(this);
+  }
+  send() {
+    return Je().write(this);
+  }
+}
+class nt {
+  id;
+  elements = [];
+  onPlus = new b.SyncEvent();
+  onMin = new b.SyncEvent();
+  constructor(c) {
+    this.id = c;
+  }
+  name() {
+    return this.id.toString(16).padStart(2, "0");
+  }
+}
+export {
+  tt as B,
+  nt as S,
+  fe as a,
+  Ne as b,
+  Me as c,
+  b as l,
+  he as u
+};