nsd-ble 0.3.3 → 0.4.1

package/dist/Objects-ulh5Kfet.js

@@ -0,0 +1,1043 @@
+import { Data as g, DataType as Ve, Button as x, FloodTypes as $ } from "./enums.js";
+var O = {}, B = {}, ve;
+function K() {
+  if (ve) return B;
+  ve = 1, Object.defineProperty(B, "__esModule", { value: !0 }), B.BaseEvent = void 0;
+  var e = (
+    /** @class */
+    (function() {
+      function r() {
+      }
+      return r.prototype.attach = function(t, l) {
+        return this._attach(t, l, !1);
+      }, r.prototype.once = function(t, l) {
+        return this._attach(t, l, !0);
+      }, r.prototype._attach = function(t, l, h) {
+        var v = this, u, a, i, c;
+        if (typeof t == "function")
+          a = t, c = function() {
+            return v.detach(a);
+          };
+        else if (!l && typeof t.post == "function")
+          i = t, c = function() {
+            return v.detach(i);
+          };
+        else {
+          if (typeof t != "object" || t === void 0)
+            throw new Error("Expect a function or object as first argument");
+          if (typeof l != "function")
+            throw new Error("Expect a function as second argument");
+          u = t, a = l, c = function() {
+            return v.detach(u, a);
+          };
+        }
+        return this._listeners ? this._listeners = this._listeners.slice() : this._listeners = [], this._listeners.push({
+          deleted: !1,
+          boundTo: u,
+          handler: a,
+          event: i,
+          once: h
+        }), c;
+      }, r.prototype.detach = function() {
+        for (var t = [], l = 0; l < arguments.length; l++)
+          t[l] = arguments[l];
+        this._detach.apply(this, t);
+      }, r.prototype._detach = function() {
+        for (var t = [], l = 0; l < arguments.length; l++)
+          t[l] = arguments[l];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          var h, v, u;
+          t.length >= 1 && (typeof t[0] == "function" ? v = t[0] : t.length === 1 && typeof t[0].post == "function" ? u = t[0] : h = t[0]), t.length >= 2 && (v = t[1]), this._listeners = this._listeners.filter(function(a) {
+            return (typeof v > "u" || a.handler === v) && (typeof u > "u" || a.event === u) && (typeof h > "u" || a.boundTo === h) ? (a.deleted = !0, !1) : !0;
+          }), this._listeners.length === 0 && delete this._listeners;
+        }
+      }, r.prototype.post = function(t) {
+        throw new Error("abstract");
+      }, r.prototype.listenerCount = function() {
+        return this._listeners ? this._listeners.length : 0;
+      }, r.prototype._call = function(t, l) {
+        this._listeners && (t.deleted || (t.once && (t.deleted = !0, this._listeners = this._listeners.filter(function(h) {
+          return h !== t;
+        }), this._listeners.length === 0 && delete this._listeners), t.event ? t.event.post.apply(t.event, l) : t.handler && t.handler.apply(typeof t.boundTo == "object" ? t.boundTo : this, l)));
+      }, r;
+    })()
+  );
+  return B.BaseEvent = e, B;
+}
+var m = {}, de;
+function N() {
+  if (de) return m;
+  de = 1;
+  var e = m && m.__extends || /* @__PURE__ */ (function() {
+    var v = function(u, a) {
+      return v = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(i, c) {
+        i.__proto__ = c;
+      } || function(i, c) {
+        for (var s in c) c.hasOwnProperty(s) && (i[s] = c[s]);
+      }, v(u, a);
+    };
+    return function(u, a) {
+      v(u, a);
+      function i() {
+        this.constructor = u;
+      }
+      u.prototype = a === null ? Object.create(a) : (i.prototype = a.prototype, new i());
+    };
+  })();
+  Object.defineProperty(m, "__esModule", { value: !0 }), m.ErrorSyncEvent = m.VoidSyncEvent = m.SyncEvent = void 0;
+  var r = K(), t = (
+    /** @class */
+    (function(v) {
+      e(u, v);
+      function u() {
+        var a = v !== null && v.apply(this, arguments) || this;
+        return a._recursion = 0, a;
+      }
+      return Object.defineProperty(u.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new l()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), u.prototype.post = function() {
+        for (var a = [], i = 0; i < arguments.length; i++)
+          a[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 c = this._listeners, s = 0; s < c.length; ++s) {
+            var n = c[s];
+            this._call(n, a);
+          }
+          this._recursion--;
+        }
+      }, u.prototype._attach = function(a, i, c) {
+        var s, n, o, f, d = (n = (s = this._listeners) === null || s === void 0 ? void 0 : s.length) !== null && n !== void 0 ? n : 0, p = v.prototype._attach.call(this, a, i, c);
+        return this.evtListenersChanged && d !== ((f = (o = this._listeners) === null || o === void 0 ? void 0 : o.length) !== null && f !== void 0 ? f : 0) && this.evtListenersChanged.post(), p;
+      }, u.prototype._detach = function() {
+        for (var a, i, c, s, n = [], o = 0; o < arguments.length; o++)
+          n[o] = arguments[o];
+        var f = (i = (a = this._listeners) === null || a === void 0 ? void 0 : a.length) !== null && i !== void 0 ? i : 0, d = v.prototype._detach.apply(this, n);
+        return this.evtListenersChanged && f !== ((s = (c = this._listeners) === null || c === void 0 ? void 0 : c.length) !== null && s !== void 0 ? s : 0) && this.evtListenersChanged.post(), d;
+      }, u.MAX_RECURSION_DEPTH = 10, u;
+    })(r.BaseEvent)
+  );
+  m.SyncEvent = t;
+  var l = (
+    /** @class */
+    (function(v) {
+      e(u, v);
+      function u() {
+        return v !== null && v.apply(this, arguments) || this;
+      }
+      return u.prototype.post = function() {
+        v.prototype.post.call(this, void 0);
+      }, u;
+    })(t)
+  );
+  m.VoidSyncEvent = l;
+  var h = (
+    /** @class */
+    (function(v) {
+      e(u, v);
+      function u() {
+        return v !== null && v.apply(this, arguments) || this;
+      }
+      return u.prototype.post = function(a) {
+        if (this.listenerCount() === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + a.message);
+        v.prototype.post.call(this, a);
+      }, u;
+    })(t)
+  );
+  return m.ErrorSyncEvent = h, m;
+}
+var C = {}, F = {}, pe;
+function ee() {
+  if (pe) return F;
+  pe = 1, Object.defineProperty(F, "__esModule", { value: !0 });
+  var e = N(), r = (
+    /** @class */
+    (function() {
+      function t() {
+        this.evtFilled = new e.SyncEvent(), this.evtDrained = new e.SyncEvent(), this._queue = [], this._flushing = !1;
+      }
+      return t.global = function() {
+        return t._instance || t.resetGlobal(), t._instance;
+      }, t.resetGlobal = function() {
+        t._instance = new t();
+      }, t.prototype.empty = function() {
+        return this._queue.length === 0;
+      }, t.prototype.add = function(l) {
+        this._queue.push(l), this._queue.length === 1 && !this._flushing && this.evtFilled.post(this);
+      }, t.prototype.flushOnce = function() {
+        var l = this._queue.length === 0, h = this._flushing;
+        this._flushing = !0;
+        try {
+          var v = this._queue;
+          this._queue = [];
+          for (var u = 0; u < v.length; ++u)
+            v[u]();
+        } finally {
+          this._flushing = h, !l && !h && this._queue.length === 0 && this.evtDrained.post(this);
+        }
+      }, t.prototype.flush = function(l) {
+        l === void 0 && (l = 10);
+        var h = this._queue.length === 0, v = this._flushing;
+        this._flushing = !0;
+        try {
+          for (var u = 0; this._queue.length > 0; ) {
+            if (typeof l == "number" && u >= l)
+              throw this._queue = [], new Error("unable to flush the queue due to recursively added event. Clearing queue now");
+            this.flushOnce(), ++u;
+          }
+        } finally {
+          this._flushing = v, !h && !v && this._queue.length === 0 && this.evtDrained.post(this);
+        }
+      }, t;
+    })()
+  );
+  return F.default = r, F;
+}
+var ye;
+function Ae() {
+  if (ye) return C;
+  ye = 1;
+  var e = C && C.__extends || /* @__PURE__ */ (function() {
+    var a = function(i, c) {
+      return a = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(s, n) {
+        s.__proto__ = n;
+      } || function(s, n) {
+        for (var o in n) n.hasOwnProperty(o) && (s[o] = n[o]);
+      }, a(i, c);
+    };
+    return function(i, c) {
+      a(i, c);
+      function s() {
+        this.constructor = i;
+      }
+      i.prototype = c === null ? Object.create(c) : (s.prototype = c.prototype, new s());
+    };
+  })();
+  Object.defineProperty(C, "__esModule", { value: !0 }), C.ErrorQueuedEvent = C.VoidQueuedEvent = C.QueuedEvent = void 0;
+  var r = K(), t = ee(), l = N(), h = (
+    /** @class */
+    (function(a) {
+      e(i, a);
+      function i(c) {
+        c === void 0 && (c = {});
+        var s = a.call(this) || this;
+        return s._queued = !1, s.options = c, typeof c.condensed == "boolean" ? s._condensed = c.condensed : s._condensed = !1, typeof c.queue == "object" && c.queue !== null && (s._queue = c.queue), s;
+      }
+      return Object.defineProperty(i.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new l.VoidSyncEvent()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), i.prototype.post = function() {
+        for (var c = this, s = [], n = 0; n < arguments.length; n++)
+          s[n] = arguments[n];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          var o = this._queue ? this._queue : t.default.global();
+          if (this._condensed) {
+            if (this._queuedData = s, this._queuedListeners = this._listeners, this._queued)
+              return;
+            this._queued = !0, o.add(function() {
+              c._queued = !1;
+              for (var d = c._queuedData, p = c._queuedListeners, y = 0; y < p.length; ++y) {
+                var _ = p[y];
+                c._call(_, d);
+              }
+            });
+          } else {
+            var f = this._listeners;
+            o.add(function() {
+              for (var d = 0; d < f.length; ++d) {
+                var p = f[d];
+                c._call(p, s);
+              }
+            });
+          }
+        }
+      }, i.prototype._attach = function(c, s, n) {
+        var o, f, d, p, y = (f = (o = this._listeners) === null || o === void 0 ? void 0 : o.length) !== null && f !== void 0 ? f : 0, _ = a.prototype._attach.call(this, c, s, n);
+        return this.evtListenersChanged && y !== ((p = (d = this._listeners) === null || d === void 0 ? void 0 : d.length) !== null && p !== void 0 ? p : 0) && this.evtListenersChanged.post(), _;
+      }, i.prototype._detach = function() {
+        for (var c, s, n, o, f = [], d = 0; d < arguments.length; d++)
+          f[d] = arguments[d];
+        var p = (s = (c = this._listeners) === null || c === void 0 ? void 0 : c.length) !== null && s !== void 0 ? s : 0, y = a.prototype._detach.apply(this, f);
+        return this.evtListenersChanged && p !== ((o = (n = this._listeners) === null || n === void 0 ? void 0 : n.length) !== null && o !== void 0 ? o : 0) && this.evtListenersChanged.post(), y;
+      }, i;
+    })(r.BaseEvent)
+  );
+  C.QueuedEvent = h;
+  var v = (
+    /** @class */
+    (function(a) {
+      e(i, a);
+      function i() {
+        return a !== null && a.apply(this, arguments) || this;
+      }
+      return i.prototype.post = function() {
+        a.prototype.post.call(this, void 0);
+      }, i;
+    })(h)
+  );
+  C.VoidQueuedEvent = v;
+  var u = (
+    /** @class */
+    (function(a) {
+      e(i, a);
+      function i() {
+        return a !== null && a.apply(this, arguments) || this;
+      }
+      return i.prototype.post = function(c) {
+        if (!this._listeners || this._listeners.length === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + c.message);
+        a.prototype.post.call(this, c);
+      }, i;
+    })(h)
+  );
+  return C.ErrorQueuedEvent = u, C;
+}
+var A = {}, ge;
+function Se() {
+  if (ge) return A;
+  ge = 1;
+  var e = A && A.__extends || /* @__PURE__ */ (function() {
+    var u = function(a, i) {
+      return u = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(c, s) {
+        c.__proto__ = s;
+      } || function(c, s) {
+        for (var n in s) s.hasOwnProperty(n) && (c[n] = s[n]);
+      }, u(a, i);
+    };
+    return function(a, i) {
+      u(a, i);
+      function c() {
+        this.constructor = a;
+      }
+      a.prototype = i === null ? Object.create(i) : (c.prototype = i.prototype, new c());
+    };
+  })();
+  Object.defineProperty(A, "__esModule", { value: !0 }), A.ErrorAsyncEvent = A.VoidAsyncEvent = A.AsyncEvent = void 0;
+  var r = K(), t = N(), l = (
+    /** @class */
+    (function(u) {
+      e(a, u);
+      function a(i) {
+        i === void 0 && (i = {});
+        var c = u.call(this) || this;
+        return c._queued = !1, c.options = i, typeof i.condensed == "boolean" ? c._condensed = i.condensed : c._condensed = !1, c;
+      }
+      return Object.defineProperty(a.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new t.VoidSyncEvent()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), a.defaultScheduler = function(i) {
+        typeof window < "u" ? setTimeout(i, 0) : setImmediate(i);
+      }, a.setScheduler = function(i) {
+        a._scheduler = i;
+      }, a.prototype.post = function() {
+        for (var i = this, c = [], s = 0; s < arguments.length; s++)
+          c[s] = arguments[s];
+        if (!(!this._listeners || this._listeners.length === 0))
+          if (this._condensed) {
+            if (this._queuedData = c, this._queuedListeners = this._listeners, this._queued)
+              return;
+            this._queued = !0, a._scheduler(function() {
+              i._queued = !1;
+              for (var o = i._queuedData, f = i._queuedListeners, d = 0; d < f.length; ++d) {
+                var p = f[d];
+                i._call(p, o);
+              }
+            });
+          } else {
+            var n = this._listeners;
+            a._scheduler(function() {
+              for (var o = 0; o < n.length; ++o) {
+                var f = n[o];
+                i._call(f, c);
+              }
+            });
+          }
+      }, a.prototype._call = function(i, c) {
+        i.event && i.event instanceof a ? i.event._postDirect(c) : u.prototype._call.call(this, i, c);
+      }, a.prototype._postDirect = function(i) {
+        if (!(!this._listeners || this._listeners.length === 0))
+          for (var c = this._listeners, s = 0; s < c.length; ++s) {
+            var n = c[s];
+            this._call(n, i);
+          }
+      }, a.prototype._attach = function(i, c, s) {
+        var n, o, f, d, p = (o = (n = this._listeners) === null || n === void 0 ? void 0 : n.length) !== null && o !== void 0 ? o : 0, y = u.prototype._attach.call(this, i, c, s);
+        return this.evtListenersChanged && p !== ((d = (f = this._listeners) === null || f === void 0 ? void 0 : f.length) !== null && d !== void 0 ? d : 0) && this.evtListenersChanged.post(), y;
+      }, a.prototype._detach = function() {
+        for (var i, c, s, n, o = [], f = 0; f < arguments.length; f++)
+          o[f] = arguments[f];
+        var d = (c = (i = this._listeners) === null || i === void 0 ? void 0 : i.length) !== null && c !== void 0 ? c : 0, p = u.prototype._detach.apply(this, o);
+        return this.evtListenersChanged && d !== ((n = (s = this._listeners) === null || s === void 0 ? void 0 : s.length) !== null && n !== void 0 ? n : 0) && this.evtListenersChanged.post(), p;
+      }, a._scheduler = a.defaultScheduler, a;
+    })(r.BaseEvent)
+  );
+  A.AsyncEvent = l;
+  var h = (
+    /** @class */
+    (function(u) {
+      e(a, u);
+      function a() {
+        return u !== null && u.apply(this, arguments) || this;
+      }
+      return a.prototype.post = function() {
+        u.prototype.post.call(this, void 0);
+      }, a;
+    })(l)
+  );
+  A.VoidAsyncEvent = h;
+  var v = (
+    /** @class */
+    (function(u) {
+      e(a, u);
+      function a() {
+        return u !== null && u.apply(this, arguments) || this;
+      }
+      return a.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);
+      }, a;
+    })(l)
+  );
+  return A.ErrorAsyncEvent = v, A;
+}
+var Q = {}, R = {}, _e;
+function $e() {
+  if (_e) return R;
+  _e = 1, Object.defineProperty(R, "__esModule", { value: !0 }), R.shallowEquals = void 0;
+  function e(r, t) {
+    if (r === t)
+      return !0;
+    if (typeof r != typeof t)
+      return !1;
+    switch (typeof r) {
+      case "boolean":
+      case "number":
+      case "string":
+      case "function":
+      case "symbol":
+      case "undefined":
+        return !1;
+      case "object":
+        if (r === null || t === null)
+          return !1;
+        if (Array.isArray(r) || Array.isArray(t)) {
+          if (!Array.isArray(r) || !Array.isArray(t) || r.length !== t.length)
+            return !1;
+          for (var l = 0; l < r.length; ++l)
+            if (r[l] !== t[l])
+              return !1;
+          return !0;
+        }
+        var h = [], v = [];
+        for (var u in r)
+          r.hasOwnProperty(u) && h.push(u);
+        for (var a in t)
+          t.hasOwnProperty(a) && v.push(a);
+        if (h.sort(), v.sort(), h.join(",") !== v.join(","))
+          return !1;
+        for (var l = 0; l < h.length; ++l)
+          if (r[h[l]] !== t[h[l]])
+            return !1;
+        return !0;
+      default:
+        return !1;
+    }
+  }
+  return R.shallowEquals = e, R;
+}
+var Ee;
+function Fe() {
+  return Ee || (Ee = 1, (function(e) {
+    var r = Q && Q.__extends || /* @__PURE__ */ (function() {
+      var s = function(n, o) {
+        return s = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(f, d) {
+          f.__proto__ = d;
+        } || function(f, d) {
+          for (var p in d) d.hasOwnProperty(p) && (f[p] = d[p]);
+        }, s(n, o);
+      };
+      return function(n, o) {
+        s(n, o);
+        function f() {
+          this.constructor = n;
+        }
+        n.prototype = o === null ? Object.create(o) : (f.prototype = o.prototype, new f());
+      };
+    })();
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.ErrorAnyEvent = e.VoidAnyEvent = e.AnyEvent = e.EventType = void 0;
+    var t = $e(), l = N(), h = Se(), v = Ae(), u;
+    (function(s) {
+      s[s.Sync = 0] = "Sync", s[s.Async = 1] = "Async", s[s.Queued = 2] = "Queued";
+    })(u = e.EventType || (e.EventType = {}));
+    var a = (
+      /** @class */
+      (function() {
+        function s(n) {
+          this._events = [], n && n.monitorAttach && (this.evtFirstAttached = new i(), this.evtLastDetached = new i());
+        }
+        return Object.defineProperty(s.prototype, "evtListenersChanged", {
+          /**
+           * Sent when someone attaches or detaches
+           */
+          get: function() {
+            return this._listenersChanged || (this._listenersChanged = new l.VoidSyncEvent()), this._listenersChanged;
+          },
+          enumerable: !1,
+          configurable: !0
+        }), s.prototype.attach = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          var f = u.Sync;
+          n.length > 0 && typeof n[0] == "number" && (f = n.shift());
+          var d = this, p, y, _;
+          return typeof n[0] == "function" || n[0] && typeof n[0] == "object" && typeof n[0].post == "function" ? (typeof n[0] == "function" ? p = n[0] : _ = n[0], y = n[1]) : (d = n[0], p = n[1], y = n[2]), this._attach(f, d, p, _, y, !1);
+        }, s.prototype.once = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          var f = u.Sync;
+          n.length > 0 && typeof n[0] == "number" && (f = n.shift());
+          var d = this, p, y, _;
+          return typeof n[0] == "function" || n[0] && typeof n[0] == "object" && typeof n[0].post == "function" ? (typeof n[0] == "function" ? p = n[0] : _ = n[0], y = n[1]) : (d = n[0], p = n[1], y = n[2]), this._attach(f, d, p, _, y, !0);
+        }, s.prototype._attach = function(n, o, f, d, p, y) {
+          var _ = this, ue = this.evtFirstAttached ? this.listenerCount() : 0, E;
+          switch (n) {
+            case u.Sync:
+              {
+                for (var z = 0, ce = this._events; z < ce.length; z++) {
+                  var S = ce[z];
+                  S instanceof l.SyncEvent && (E = S);
+                }
+                E || (E = new l.SyncEvent(), this._events.push(E));
+              }
+              break;
+            case u.Async:
+              {
+                for (var W = 0, le = this._events; W < le.length; W++) {
+                  var S = le[W];
+                  S instanceof h.AsyncEvent && t.shallowEquals(S.options, p) && (E = S);
+                }
+                E || (E = new h.AsyncEvent(p), this._events.push(E));
+              }
+              break;
+            case u.Queued:
+              {
+                for (var J = 0, he = this._events; J < he.length; J++) {
+                  var S = he[J];
+                  S instanceof v.QueuedEvent && t.shallowEquals(S.options, p) && (E = S);
+                }
+                E || (E = new v.QueuedEvent(p), this._events.push(E));
+              }
+              break;
+            default:
+              throw new Error("unknown EventType");
+          }
+          var U;
+          return y ? d ? U = E.once(d) : U = E.once(o, f) : d ? U = E.attach(d) : U = E.attach(o, f), this.evtFirstAttached && ue === 0 && this.evtFirstAttached.post(), this.evtListenersChanged && ue !== this.listenerCount() && this.evtListenersChanged.post(), function() {
+            var fe = _.evtLastDetached ? _.listenerCount() : 0;
+            U(), _.evtLastDetached && fe > 0 && _.listenerCount() === 0 && _.evtLastDetached.post(), _.evtListenersChanged && fe !== _.listenerCount() && _.evtListenersChanged.post();
+          };
+        }, s.prototype.attachSync = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          return n.unshift(u.Sync), this.attach.apply(this, n);
+        }, s.prototype.onceSync = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          return n.unshift(u.Sync), this.once.apply(this, n);
+        }, s.prototype.attachAsync = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          return n.unshift(u.Async), this.attach.apply(this, n);
+        }, s.prototype.onceAsync = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          return n.unshift(u.Async), this.once.apply(this, n);
+        }, s.prototype.attachQueued = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          return n.unshift(u.Queued), this.attach.apply(this, n);
+        }, s.prototype.onceQueued = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          return n.unshift(u.Queued), this.once.apply(this, n);
+        }, s.prototype.detach = function() {
+          for (var n = [], o = 0; o < arguments.length; o++)
+            n[o] = arguments[o];
+          for (var f = this.listenerCount(), d = 0; d < this._events.length; ++d)
+            this._events[d].detach.apply(this._events[d], n);
+          this.evtListenersChanged && f !== this.listenerCount() && this.evtListenersChanged.post(), this.evtLastDetached && f > 0 && this.listenerCount() === 0 && this.evtLastDetached.post();
+        }, s.prototype.post = function(n) {
+          for (var o = [], f = 0; f < this._events.length; ++f)
+            o.push(this._events[f]);
+          for (var f = 0; f < o.length; ++f)
+            o[f].post(n);
+        }, s.prototype.listenerCount = function() {
+          for (var n = 0, o = 0; o < this._events.length; ++o)
+            n += this._events[o].listenerCount();
+          return n;
+        }, s;
+      })()
+    );
+    e.AnyEvent = a;
+    var i = (
+      /** @class */
+      (function(s) {
+        r(n, s);
+        function n() {
+          return s !== null && s.apply(this, arguments) || this;
+        }
+        return n.prototype.post = function() {
+          s.prototype.post.call(this, void 0);
+        }, n;
+      })(a)
+    );
+    e.VoidAnyEvent = i;
+    var c = (
+      /** @class */
+      (function(s) {
+        r(n, s);
+        function n() {
+          return s !== null && s.apply(this, arguments) || this;
+        }
+        return n.prototype.post = function(o) {
+          if (this.listenerCount() === 0)
+            throw new Error("error event posted while no listeners attached. Error: " + o.message);
+          s.prototype.post.call(this, o);
+        }, n;
+      })(a)
+    );
+    e.ErrorAnyEvent = c;
+  })(Q)), Q;
+}
+var we;
+function He() {
+  return we || (we = 1, (function(e) {
+    var r = O && O.__createBinding || (Object.create ? (function(i, c, s, n) {
+      n === void 0 && (n = s), Object.defineProperty(i, n, { enumerable: !0, get: function() {
+        return c[s];
+      } });
+    }) : (function(i, c, s, n) {
+      n === void 0 && (n = s), i[n] = c[s];
+    })), t = O && O.__exportStar || function(i, c) {
+      for (var s in i) s !== "default" && !c.hasOwnProperty(s) && r(c, i, s);
+    };
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.flush = e.flushOnce = e.queue = void 0, t(K(), e), t(N(), e), t(Ae(), e), t(Se(), e), t(Fe(), e);
+    var l = ee(), h = ee();
+    Object.defineProperty(e, "EventQueue", { enumerable: !0, get: function() {
+      return h.default;
+    } });
+    function v() {
+      return l.default.global();
+    }
+    e.queue = v;
+    function u() {
+      l.default.global().flushOnce();
+    }
+    e.flushOnce = u;
+    function a(i) {
+      i === void 0 && (i = 10), l.default.global().flush(i);
+    }
+    e.flush = a;
+  })(O)), O;
+}
+var w = He();
+let be = null;
+function Nt(e) {
+  be = e;
+}
+function V() {
+  return be;
+}
+let Z = !1, b, ne;
+const X = /* @__PURE__ */ new Map(), re = new w.SyncEvent(), Te = new w.SyncEvent();
+async function Xe(e) {
+  const r = V();
+  if (r) return r.connect(e);
+  try {
+    if (b = await navigator.bluetooth.requestDevice(e), b.gatt === void 0)
+      throw new Error("Device does not support GATT");
+    ne = await b.gatt.connect(), b.addEventListener("gattserverdisconnected", te), Z = !0, re.post();
+  } catch (t) {
+    throw t;
+  }
+}
+async function Ze() {
+  const e = V();
+  if (e) return e.reconnect();
+  if (Z)
+    return;
+  const r = await navigator.bluetooth.getDevices();
+  if (r.length === 0)
+    throw new Error("No devices found");
+  if (b = r[0], b.gatt === void 0)
+    throw new Error("Device does not support GATT");
+  ne = await b.gatt.connect(), b.removeEventListener("gattserverdisconnected", te), b.addEventListener("gattserverdisconnected", te), Z = !0, re.post();
+}
+function te() {
+  X.clear(), Z = !1, Te.post();
+}
+async function se(e, r) {
+  if (X.has(r)) {
+    const h = X.get(r);
+    if (h === void 0)
+      throw new Error("Characteristic not found");
+    return h;
+  }
+  const l = await (await ne.getPrimaryService(e)).getCharacteristic(r);
+  return X.set(r, l), l;
+}
+async function Ke(e, r) {
+  const t = V();
+  return t ? t.readCharacteristic(e, r) : await (await se(e, r)).readValue();
+}
+async function Ye(e, r, t) {
+  const l = V();
+  if (l) return l.writeCharacteristic(e, r, t);
+  const h = new DataView(new ArrayBuffer(t.length));
+  for (let u = 0; u < t.length; u++)
+    h.setUint8(u, t[u]);
+  await (await se(e, r)).writeValue(h);
+}
+async function Ge(e, r, t) {
+  const l = V();
+  if (l) return l.subscribe(e, r, t);
+  const h = await se(e, r);
+  h.addEventListener(
+    "characteristicvaluechanged",
+    (v) => {
+      let u = v.target.value;
+      u === void 0 && (u = new DataView(new ArrayBuffer(0))), t(u);
+    }
+  ), await h.startNotifications();
+}
+function oe() {
+  return {
+    onConnect: re,
+    onDisconnect: Te,
+    reconnect: Ze,
+    connect: Xe,
+    readCharacteristic: Ke,
+    writeCharacteristic: Ye,
+    subscribe: Ge
+  };
+}
+const qe = "19b10000-e8f2-537e-4f6c-d104768a1214", ze = "6b061bdc-9bc1-4952-a96f-c6ed551b2c3e", We = "6357e3bb-874c-4f35-b31e-2bcdf59d5419", Je = "998ff920-81af-42a9-a915-f88025f9647d", xe = {
+  filters: [{ namePrefix: "BLE-STANDEE" }],
+  optionalServices: [qe]
+}, et = 10, tt = 13, nt = 20, rt = 5e3, st = 3, ot = 2e3, it = 5;
+function Y() {
+  return {
+    serviceUuid: qe,
+    messageCharUuid: ze,
+    handshakeCharUuid: Je,
+    messageFloodCharUuid: We,
+    options: xe,
+    TTL: et,
+    PACKET_SIZE: tt,
+    BATCH_SIZE: nt,
+    ACK_TIMEOUT: rt,
+    MAX_RETRIES: st,
+    RECONNECT_DELAY: ot,
+    RECONNECT_MAX_RETRIES: it
+  };
+}
+class at {
+  id;
+  data;
+  constructor(r, t) {
+    this.id = r, this.data = t;
+  }
+}
+const { serviceUuid: ut, messageCharUuid: ct } = Y(), Oe = new w.SyncEvent(), De = new w.SyncEvent(), Pe = new w.SyncEvent();
+function lt() {
+  return new Promise((e, r) => {
+    oe().subscribe(ut, ct, ht).then(() => e()).catch((t) => r(t));
+  });
+}
+function ht(e) {
+  console.log(e), e !== void 0 && e.getUint8(g.TYPE) === Ve.BUTTON_PRESS && ft(e);
+}
+function ft(e) {
+  const r = e.getUint8(g.DATA), t = new at(
+    e.getUint8(g.ID),
+    vt(e)
+  );
+  r === x.MINUS && De.post(t), r === x.PLUS && Oe.post(t), r === x.EITHER && Pe.post(t);
+}
+function vt(e) {
+  const r = e.buffer, t = g.DATA + 1, l = e.byteLength - t;
+  return Array.from(new Uint8Array(r, t, l)).map((h) => String.fromCharCode(h)).join("").replace(/\0/g, "").trim();
+}
+function Vt() {
+  return {
+    subscribe: lt,
+    onPlusButton: Oe,
+    onMinButton: De,
+    onEitherButton: Pe
+  };
+}
+const { serviceUuid: dt, messageFloodCharUuid: pt } = Y(), Le = new w.SyncEvent(), Me = new w.SyncEvent(), je = new w.SyncEvent(), Ue = new w.SyncEvent();
+function yt() {
+  return new Promise((e, r) => {
+    oe().subscribe(dt, pt, gt).then(() => e()).catch((t) => r(t));
+  });
+}
+function gt(e) {
+  if (console.log(e), e !== void 0 && (e.getUint8(g.TYPE) === $.NODES && Me.post(_t(e)), e.getUint8(g.TYPE) === $.LOST_NODE && je.post(e.getUint8(g.ID)), e.getUint8(g.TYPE) === $.MESSAGE_DONE && Le.post(e.getUint8(g.DATA)), e.getUint8(g.TYPE) === $.DATA_FEEDBACK)) {
+    const r = [];
+    for (let t = g.DATA; t < e.byteLength; t++)
+      r.push(e.getUint8(t));
+    console.log("received packets"), console.log(r), Ue.post(r);
+  }
+}
+function _t(e) {
+  const r = e.getUint8(g.DATA), t = e.buffer.byteLength, l = [];
+  for (let h = g.DATA + 1; h < t; h++)
+    l.push(e.getUint8(h));
+  return /* @__PURE__ */ new Map([[r, l]]);
+}
+function Et() {
+  return {
+    subscribe: yt,
+    onMessageDone: Le,
+    onReceivedPackets: Ue,
+    onNode: Me,
+    onNodeLost: je
+  };
+}
+const k = [];
+function wt() {
+  let e = Math.floor(Math.random() * 256);
+  for (; k.includes(e); ) e = Math.floor(Math.random() * 256);
+  return e;
+}
+function mt(e) {
+  k.push(e), Ct();
+}
+function Ct() {
+  k.length <= 20 || k.splice(0, k.length - 20);
+}
+function At() {
+  const e = wt();
+  return mt(e), e;
+}
+function St() {
+  return {
+    create: At
+  };
+}
+const { TTL: me, PACKET_SIZE: Ce } = Y();
+function bt(e) {
+  if (e.data == null) {
+    let h = [e.id, e.cache, me, 0, 0, 2, 0, e.type, 0];
+    return [new Uint8Array(h)];
+  }
+  const r = new Uint8Array(2 + e.data.length), t = e.data.length + 2, l = [];
+  r.set([e.type, t], 0), r.set(e.data, 2);
+  for (let h = 0; h < t; h += Ce) {
+    const v = Math.min(Ce, t - h), u = new Uint8Array(v), a = [
+      e.id,
+      e.cache,
+      me,
+      h & 255,
+      h >> 8 & 255,
+      t & 255,
+      t >> 8 & 255
+    ];
+    u.set(r.subarray(h, h + v), 0), l.push(new Uint8Array([...a, ...u]));
+  }
+  return l;
+}
+class $t {
+  cache = St().create();
+  type;
+  id;
+  data;
+  packets = [];
+  resolve;
+  constructor(r, t, l) {
+    this.type = r, this.id = t, this.data = l, this.packets = bt(this);
+  }
+  send() {
+    return kt().write(this);
+  }
+  then(r) {
+    return this.resolve = r, this;
+  }
+}
+const { serviceUuid: Tt, messageCharUuid: qt, BATCH_SIZE: Ot, ACK_TIMEOUT: Be, MAX_RETRIES: H } = Y(), { onMessageDone: Dt, onReceivedPackets: Pt } = Et(), Lt = oe(), T = [], G = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), q = /* @__PURE__ */ new Map();
+let M = !1, D = 0, L = !1;
+const Qe = new w.SyncEvent(), Re = new w.SyncEvent(), ie = new w.SyncEvent(), ke = new w.SyncEvent(), Ie = new w.SyncEvent();
+Dt.attach(jt);
+Pt.attach(Ut);
+function Mt(e) {
+  return P.set(e.cache, e), e.packets.forEach((r) => T.push(r)), Re.post({
+    cacheId: e.cache,
+    type: e.type,
+    targetId: e.id,
+    packetCount: e.packets.length,
+    totalBytes: e.data?.length ?? 0,
+    timestamp: Date.now()
+  }), new Promise((r, t) => {
+    G.set(e.cache, () => {
+      e.resolve?.(), r();
+    }), I.set(e.cache, t), q.set(e.cache, { timer: 0, retries: 0 }), !M && !L && j();
+  });
+}
+function j() {
+  if (M || L)
+    return;
+  if (D >= Ot) {
+    L = !0;
+    return;
+  }
+  const e = T.shift();
+  if (e == null) {
+    M = !1;
+    return;
+  }
+  const r = e[g.CACHE];
+  if (!P.has(r)) {
+    j();
+    return;
+  }
+  M = !0, ae(r), Qe.post({
+    cacheId: r,
+    position: e[g.POSITION] | e[g.POSITION + 1] << 8,
+    dataSize: e[g.DATA_SIZE] | e[g.DATA_SIZE + 1] << 8,
+    packetBytes: e.length,
+    batchIndex: D,
+    timestamp: Date.now()
+  }), Lt.writeCharacteristic(Tt, qt, e).catch((t) => console.log(t)).finally(() => {
+    M = !1, D++, j();
+  });
+}
+function jt(e) {
+  Ie.post({
+    cacheId: e,
+    timestamp: Date.now()
+  }), G.get(e)?.(), Ne(e), L = !1, D = 0, j();
+}
+function Ut(e) {
+  D = 0, L = !1;
+  const r = /* @__PURE__ */ new Set();
+  for (const t of e) {
+    if (t === 0 || r.has(t)) continue;
+    r.add(t);
+    const l = P.get(t);
+    if (l == null) continue;
+    const h = q.get(t);
+    h != null && (h.retries = 0, ae(t)), ie.post({
+      cacheId: t,
+      packetCount: l.packets.length,
+      reason: "feedback",
+      timestamp: Date.now()
+    }), l.packets.forEach((v) => T.unshift(v));
+  }
+  j();
+}
+function ae(e) {
+  const r = q.get(e);
+  r != null && (clearTimeout(r.timer), r.timer = setTimeout(() => {
+    Qt(e);
+  }, Be));
+}
+function Bt(e) {
+  const r = q.get(e);
+  r != null && (clearTimeout(r.timer), q.delete(e));
+}
+function Qt(e) {
+  if (!P.has(e)) return;
+  const r = q.get(e);
+  if (r == null) return;
+  if (r.retries++, ke.post({
+    cacheId: e,
+    retryCount: r.retries,
+    maxRetries: H,
+    willRetry: r.retries <= H,
+    timestamp: Date.now()
+  }), r.retries > H) {
+    I.get(e)?.(new Error(
+      `Buffer ${e} timed out after ${H} retries (${Be}ms timeout)`
+    )), Ne(e);
+    return;
+  }
+  const t = P.get(e);
+  t != null && (ie.post({
+    cacheId: e,
+    packetCount: t.packets.length,
+    reason: "timeout",
+    timestamp: Date.now()
+  }), t.packets.forEach((l) => T.unshift(l))), ae(e), L = !1, D = 0, j();
+}
+function Ne(e) {
+  G.delete(e), I.delete(e), P.delete(e), Bt(e);
+  for (let r = T.length - 1; r >= 0; r--)
+    T[r][g.CACHE] === e && T.splice(r, 1);
+}
+function Rt(e) {
+  for (const [, r] of I)
+    r(e);
+  G.clear(), I.clear();
+  for (const r of q.values())
+    clearTimeout(r.timer);
+  q.clear(), P.clear(), T.length = 0, M = !1, D = 0, L = !1;
+}
+function kt() {
+  return {
+    write: Mt,
+    abortAll: Rt,
+    onPacketSent: Qe,
+    onMessageQueued: Re,
+    onRetransmit: ie,
+    onTimeout: ke,
+    onMessageComplete: Ie
+  };
+}
+class Ft {
+  id;
+  elements = [];
+  onPlus = new w.SyncEvent();
+  onMin = new w.SyncEvent();
+  neighbors = [];
+  constructor(r) {
+    this.id = r;
+  }
+  name() {
+    return this.id.toString(16).padStart(2, "0");
+  }
+}
+export {
+  $t as B,
+  Ft as S,
+  Y as a,
+  Et as b,
+  Vt as c,
+  kt as d,
+  at as e,
+  w as l,
+  Nt as s,
+  oe as u
+};