nsd-ble 0.1.0

package/dist/standee-ble.js

@@ -0,0 +1,1452 @@
+var U = {}, L = {}, lt;
+function H() {
+  if (lt) return L;
+  lt = 1, Object.defineProperty(L, "__esModule", { value: !0 }), L.BaseEvent = void 0;
+  var t = (
+    /** @class */
+    (function() {
+      function e() {
+      }
+      return e.prototype.attach = function(n, r) {
+        return this._attach(n, r, !1);
+      }, e.prototype.once = function(n, r) {
+        return this._attach(n, r, !0);
+      }, e.prototype._attach = function(n, r, f) {
+        var l = this, u, i, a, h;
+        if (typeof n == "function")
+          i = n, h = function() {
+            return l.detach(i);
+          };
+        else if (!r && typeof n.post == "function")
+          a = n, h = function() {
+            return l.detach(a);
+          };
+        else {
+          if (typeof n != "object" || n === void 0)
+            throw new Error("Expect a function or object as first argument");
+          if (typeof r != "function")
+            throw new Error("Expect a function as second argument");
+          u = n, i = r, h = function() {
+            return l.detach(u, i);
+          };
+        }
+        return this._listeners ? this._listeners = this._listeners.slice() : this._listeners = [], this._listeners.push({
+          deleted: !1,
+          boundTo: u,
+          handler: i,
+          event: a,
+          once: f
+        }), h;
+      }, e.prototype.detach = function() {
+        for (var n = [], r = 0; r < arguments.length; r++)
+          n[r] = arguments[r];
+        this._detach.apply(this, n);
+      }, e.prototype._detach = function() {
+        for (var n = [], r = 0; r < arguments.length; r++)
+          n[r] = arguments[r];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          var f, l, u;
+          n.length >= 1 && (typeof n[0] == "function" ? l = n[0] : n.length === 1 && typeof n[0].post == "function" ? u = n[0] : f = n[0]), n.length >= 2 && (l = n[1]), this._listeners = this._listeners.filter(function(i) {
+            return (typeof l > "u" || i.handler === l) && (typeof u > "u" || i.event === u) && (typeof f > "u" || i.boundTo === f) ? (i.deleted = !0, !1) : !0;
+          }), this._listeners.length === 0 && delete this._listeners;
+        }
+      }, e.prototype.post = function(n) {
+        throw new Error("abstract");
+      }, e.prototype.listenerCount = function() {
+        return this._listeners ? this._listeners.length : 0;
+      }, e.prototype._call = function(n, r) {
+        this._listeners && (n.deleted || (n.once && (n.deleted = !0, this._listeners = this._listeners.filter(function(f) {
+          return f !== n;
+        }), this._listeners.length === 0 && delete this._listeners), n.event ? n.event.post.apply(n.event, r) : n.handler && n.handler.apply(typeof n.boundTo == "object" ? n.boundTo : this, r)));
+      }, e;
+    })()
+  );
+  return L.BaseEvent = t, L;
+}
+var E = {}, ft;
+function x() {
+  if (ft) return E;
+  ft = 1;
+  var t = E && E.__extends || /* @__PURE__ */ (function() {
+    var l = function(u, i) {
+      return l = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(a, h) {
+        a.__proto__ = h;
+      } || function(a, h) {
+        for (var o in h) h.hasOwnProperty(o) && (a[o] = h[o]);
+      }, l(u, i);
+    };
+    return function(u, i) {
+      l(u, i);
+      function a() {
+        this.constructor = u;
+      }
+      u.prototype = i === null ? Object.create(i) : (a.prototype = i.prototype, new a());
+    };
+  })();
+  Object.defineProperty(E, "__esModule", { value: !0 }), E.ErrorSyncEvent = E.VoidSyncEvent = E.SyncEvent = void 0;
+  var e = H(), n = (
+    /** @class */
+    (function(l) {
+      t(u, l);
+      function u() {
+        var i = l !== null && l.apply(this, arguments) || this;
+        return i._recursion = 0, i;
+      }
+      return Object.defineProperty(u.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new r()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), u.prototype.post = function() {
+        for (var i = [], a = 0; a < arguments.length; a++)
+          i[a] = arguments[a];
+        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 h = this._listeners, o = 0; o < h.length; ++o) {
+            var s = h[o];
+            this._call(s, i);
+          }
+          this._recursion--;
+        }
+      }, u.prototype._attach = function(i, a, h) {
+        var o, s, c, d, v = (s = (o = this._listeners) === null || o === void 0 ? void 0 : o.length) !== null && s !== void 0 ? s : 0, y = l.prototype._attach.call(this, i, a, h);
+        return this.evtListenersChanged && v !== ((d = (c = this._listeners) === null || c === void 0 ? void 0 : c.length) !== null && d !== void 0 ? d : 0) && this.evtListenersChanged.post(), y;
+      }, u.prototype._detach = function() {
+        for (var i, a, h, o, s = [], c = 0; c < arguments.length; c++)
+          s[c] = arguments[c];
+        var d = (a = (i = this._listeners) === null || i === void 0 ? void 0 : i.length) !== null && a !== void 0 ? a : 0, v = l.prototype._detach.apply(this, s);
+        return this.evtListenersChanged && d !== ((o = (h = this._listeners) === null || h === void 0 ? void 0 : h.length) !== null && o !== void 0 ? o : 0) && this.evtListenersChanged.post(), v;
+      }, u.MAX_RECURSION_DEPTH = 10, u;
+    })(e.BaseEvent)
+  );
+  E.SyncEvent = n;
+  var r = (
+    /** @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;
+    })(n)
+  );
+  E.VoidSyncEvent = r;
+  var f = (
+    /** @class */
+    (function(l) {
+      t(u, l);
+      function u() {
+        return l !== null && l.apply(this, arguments) || this;
+      }
+      return u.prototype.post = function(i) {
+        if (this.listenerCount() === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + i.message);
+        l.prototype.post.call(this, i);
+      }, u;
+    })(n)
+  );
+  return E.ErrorSyncEvent = f, E;
+}
+var w = {}, j = {}, dt;
+function z() {
+  if (dt) return j;
+  dt = 1, Object.defineProperty(j, "__esModule", { value: !0 });
+  var t = x(), e = (
+    /** @class */
+    (function() {
+      function n() {
+        this.evtFilled = new t.SyncEvent(), this.evtDrained = new t.SyncEvent(), this._queue = [], this._flushing = !1;
+      }
+      return n.global = function() {
+        return n._instance || n.resetGlobal(), n._instance;
+      }, n.resetGlobal = function() {
+        n._instance = new n();
+      }, n.prototype.empty = function() {
+        return this._queue.length === 0;
+      }, n.prototype.add = function(r) {
+        this._queue.push(r), this._queue.length === 1 && !this._flushing && this.evtFilled.post(this);
+      }, n.prototype.flushOnce = function() {
+        var r = this._queue.length === 0, f = 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 = f, !r && !f && this._queue.length === 0 && this.evtDrained.post(this);
+        }
+      }, n.prototype.flush = function(r) {
+        r === void 0 && (r = 10);
+        var f = this._queue.length === 0, l = this._flushing;
+        this._flushing = !0;
+        try {
+          for (var u = 0; this._queue.length > 0; ) {
+            if (typeof r == "number" && u >= r)
+              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, !f && !l && this._queue.length === 0 && this.evtDrained.post(this);
+        }
+      }, n;
+    })()
+  );
+  return j.default = e, j;
+}
+var vt;
+function Ct() {
+  if (vt) return w;
+  vt = 1;
+  var t = w && w.__extends || /* @__PURE__ */ (function() {
+    var i = function(a, h) {
+      return i = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(o, s) {
+        o.__proto__ = s;
+      } || function(o, s) {
+        for (var c in s) s.hasOwnProperty(c) && (o[c] = s[c]);
+      }, i(a, h);
+    };
+    return function(a, h) {
+      i(a, h);
+      function o() {
+        this.constructor = a;
+      }
+      a.prototype = h === null ? Object.create(h) : (o.prototype = h.prototype, new o());
+    };
+  })();
+  Object.defineProperty(w, "__esModule", { value: !0 }), w.ErrorQueuedEvent = w.VoidQueuedEvent = w.QueuedEvent = void 0;
+  var e = H(), n = z(), r = x(), f = (
+    /** @class */
+    (function(i) {
+      t(a, i);
+      function a(h) {
+        h === void 0 && (h = {});
+        var o = i.call(this) || this;
+        return o._queued = !1, o.options = h, typeof h.condensed == "boolean" ? o._condensed = h.condensed : o._condensed = !1, typeof h.queue == "object" && h.queue !== null && (o._queue = h.queue), o;
+      }
+      return Object.defineProperty(a.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new r.VoidSyncEvent()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), a.prototype.post = function() {
+        for (var h = this, o = [], s = 0; s < arguments.length; s++)
+          o[s] = arguments[s];
+        if (!(!this._listeners || this._listeners.length === 0)) {
+          var c = this._queue ? this._queue : n.default.global();
+          if (this._condensed) {
+            if (this._queuedData = o, this._queuedListeners = this._listeners, this._queued)
+              return;
+            this._queued = !0, c.add(function() {
+              h._queued = !1;
+              for (var v = h._queuedData, y = h._queuedListeners, g = 0; g < y.length; ++g) {
+                var p = y[g];
+                h._call(p, v);
+              }
+            });
+          } else {
+            var d = this._listeners;
+            c.add(function() {
+              for (var v = 0; v < d.length; ++v) {
+                var y = d[v];
+                h._call(y, o);
+              }
+            });
+          }
+        }
+      }, a.prototype._attach = function(h, o, s) {
+        var c, d, v, y, g = (d = (c = this._listeners) === null || c === void 0 ? void 0 : c.length) !== null && d !== void 0 ? d : 0, p = i.prototype._attach.call(this, h, o, s);
+        return this.evtListenersChanged && g !== ((y = (v = this._listeners) === null || v === void 0 ? void 0 : v.length) !== null && y !== void 0 ? y : 0) && this.evtListenersChanged.post(), p;
+      }, a.prototype._detach = function() {
+        for (var h, o, s, c, d = [], v = 0; v < arguments.length; v++)
+          d[v] = arguments[v];
+        var y = (o = (h = this._listeners) === null || h === void 0 ? void 0 : h.length) !== null && o !== void 0 ? o : 0, g = i.prototype._detach.apply(this, d);
+        return this.evtListenersChanged && y !== ((c = (s = this._listeners) === null || s === void 0 ? void 0 : s.length) !== null && c !== void 0 ? c : 0) && this.evtListenersChanged.post(), g;
+      }, a;
+    })(e.BaseEvent)
+  );
+  w.QueuedEvent = f;
+  var l = (
+    /** @class */
+    (function(i) {
+      t(a, i);
+      function a() {
+        return i !== null && i.apply(this, arguments) || this;
+      }
+      return a.prototype.post = function() {
+        i.prototype.post.call(this, void 0);
+      }, a;
+    })(f)
+  );
+  w.VoidQueuedEvent = l;
+  var u = (
+    /** @class */
+    (function(i) {
+      t(a, i);
+      function a() {
+        return i !== null && i.apply(this, arguments) || this;
+      }
+      return a.prototype.post = function(h) {
+        if (!this._listeners || this._listeners.length === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + h.message);
+        i.prototype.post.call(this, h);
+      }, a;
+    })(f)
+  );
+  return w.ErrorQueuedEvent = u, w;
+}
+var A = {}, yt;
+function St() {
+  if (yt) return A;
+  yt = 1;
+  var t = A && A.__extends || /* @__PURE__ */ (function() {
+    var u = function(i, a) {
+      return u = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(h, o) {
+        h.__proto__ = o;
+      } || function(h, o) {
+        for (var s in o) o.hasOwnProperty(s) && (h[s] = o[s]);
+      }, u(i, a);
+    };
+    return function(i, a) {
+      u(i, a);
+      function h() {
+        this.constructor = i;
+      }
+      i.prototype = a === null ? Object.create(a) : (h.prototype = a.prototype, new h());
+    };
+  })();
+  Object.defineProperty(A, "__esModule", { value: !0 }), A.ErrorAsyncEvent = A.VoidAsyncEvent = A.AsyncEvent = void 0;
+  var e = H(), n = x(), r = (
+    /** @class */
+    (function(u) {
+      t(i, u);
+      function i(a) {
+        a === void 0 && (a = {});
+        var h = u.call(this) || this;
+        return h._queued = !1, h.options = a, typeof a.condensed == "boolean" ? h._condensed = a.condensed : h._condensed = !1, h;
+      }
+      return Object.defineProperty(i.prototype, "evtListenersChanged", {
+        /**
+         * Sent when someone attaches or detaches
+         */
+        get: function() {
+          return this._listenersChanged || (this._listenersChanged = new n.VoidSyncEvent()), this._listenersChanged;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), i.defaultScheduler = function(a) {
+        typeof window < "u" ? setTimeout(a, 0) : setImmediate(a);
+      }, i.setScheduler = function(a) {
+        i._scheduler = a;
+      }, i.prototype.post = function() {
+        for (var a = this, h = [], o = 0; o < arguments.length; o++)
+          h[o] = arguments[o];
+        if (!(!this._listeners || this._listeners.length === 0))
+          if (this._condensed) {
+            if (this._queuedData = h, this._queuedListeners = this._listeners, this._queued)
+              return;
+            this._queued = !0, i._scheduler(function() {
+              a._queued = !1;
+              for (var c = a._queuedData, d = a._queuedListeners, v = 0; v < d.length; ++v) {
+                var y = d[v];
+                a._call(y, c);
+              }
+            });
+          } else {
+            var s = this._listeners;
+            i._scheduler(function() {
+              for (var c = 0; c < s.length; ++c) {
+                var d = s[c];
+                a._call(d, h);
+              }
+            });
+          }
+      }, i.prototype._call = function(a, h) {
+        a.event && a.event instanceof i ? a.event._postDirect(h) : u.prototype._call.call(this, a, h);
+      }, i.prototype._postDirect = function(a) {
+        if (!(!this._listeners || this._listeners.length === 0))
+          for (var h = this._listeners, o = 0; o < h.length; ++o) {
+            var s = h[o];
+            this._call(s, a);
+          }
+      }, i.prototype._attach = function(a, h, o) {
+        var s, c, d, v, y = (c = (s = this._listeners) === null || s === void 0 ? void 0 : s.length) !== null && c !== void 0 ? c : 0, g = u.prototype._attach.call(this, a, h, o);
+        return this.evtListenersChanged && y !== ((v = (d = this._listeners) === null || d === void 0 ? void 0 : d.length) !== null && v !== void 0 ? v : 0) && this.evtListenersChanged.post(), g;
+      }, i.prototype._detach = function() {
+        for (var a, h, o, s, c = [], d = 0; d < arguments.length; d++)
+          c[d] = arguments[d];
+        var v = (h = (a = this._listeners) === null || a === void 0 ? void 0 : a.length) !== null && h !== void 0 ? h : 0, y = u.prototype._detach.apply(this, c);
+        return this.evtListenersChanged && v !== ((s = (o = this._listeners) === null || o === void 0 ? void 0 : o.length) !== null && s !== void 0 ? s : 0) && this.evtListenersChanged.post(), y;
+      }, i._scheduler = i.defaultScheduler, i;
+    })(e.BaseEvent)
+  );
+  A.AsyncEvent = r;
+  var f = (
+    /** @class */
+    (function(u) {
+      t(i, u);
+      function i() {
+        return u !== null && u.apply(this, arguments) || this;
+      }
+      return i.prototype.post = function() {
+        u.prototype.post.call(this, void 0);
+      }, i;
+    })(r)
+  );
+  A.VoidAsyncEvent = f;
+  var l = (
+    /** @class */
+    (function(u) {
+      t(i, u);
+      function i() {
+        return u !== null && u.apply(this, arguments) || this;
+      }
+      return i.prototype.post = function(a) {
+        if (this.listenerCount() === 0)
+          throw new Error("error event posted while no listeners attached. Error: " + a.message);
+        u.prototype.post.call(this, a);
+      }, i;
+    })(r)
+  );
+  return A.ErrorAsyncEvent = l, A;
+}
+var I = {}, M = {}, gt;
+function xt() {
+  if (gt) return M;
+  gt = 1, Object.defineProperty(M, "__esModule", { value: !0 }), M.shallowEquals = void 0;
+  function t(e, n) {
+    if (e === n)
+      return !0;
+    if (typeof e != typeof n)
+      return !1;
+    switch (typeof e) {
+      case "boolean":
+      case "number":
+      case "string":
+      case "function":
+      case "symbol":
+      case "undefined":
+        return !1;
+      case "object":
+        if (e === null || n === null)
+          return !1;
+        if (Array.isArray(e) || Array.isArray(n)) {
+          if (!Array.isArray(e) || !Array.isArray(n) || e.length !== n.length)
+            return !1;
+          for (var r = 0; r < e.length; ++r)
+            if (e[r] !== n[r])
+              return !1;
+          return !0;
+        }
+        var f = [], l = [];
+        for (var u in e)
+          e.hasOwnProperty(u) && f.push(u);
+        for (var i in n)
+          n.hasOwnProperty(i) && l.push(i);
+        if (f.sort(), l.sort(), f.join(",") !== l.join(","))
+          return !1;
+        for (var r = 0; r < f.length; ++r)
+          if (e[f[r]] !== n[f[r]])
+            return !1;
+        return !0;
+      default:
+        return !1;
+    }
+  }
+  return M.shallowEquals = t, M;
+}
+var pt;
+function jt() {
+  return pt || (pt = 1, (function(t) {
+    var e = I && I.__extends || /* @__PURE__ */ (function() {
+      var o = function(s, c) {
+        return o = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, v) {
+          d.__proto__ = v;
+        } || function(d, v) {
+          for (var y in v) v.hasOwnProperty(y) && (d[y] = v[y]);
+        }, o(s, c);
+      };
+      return function(s, c) {
+        o(s, c);
+        function d() {
+          this.constructor = s;
+        }
+        s.prototype = c === null ? Object.create(c) : (d.prototype = c.prototype, new d());
+      };
+    })();
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.ErrorAnyEvent = t.VoidAnyEvent = t.AnyEvent = t.EventType = void 0;
+    var n = xt(), r = x(), f = St(), l = Ct(), u;
+    (function(o) {
+      o[o.Sync = 0] = "Sync", o[o.Async = 1] = "Async", o[o.Queued = 2] = "Queued";
+    })(u = t.EventType || (t.EventType = {}));
+    var i = (
+      /** @class */
+      (function() {
+        function o(s) {
+          this._events = [], s && s.monitorAttach && (this.evtFirstAttached = new a(), this.evtLastDetached = new 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.prototype.attach = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          var d = u.Sync;
+          s.length > 0 && typeof s[0] == "number" && (d = s.shift());
+          var v = this, y, g, p;
+          return typeof s[0] == "function" || s[0] && typeof s[0] == "object" && typeof s[0].post == "function" ? (typeof s[0] == "function" ? y = s[0] : p = s[0], g = s[1]) : (v = s[0], y = s[1], g = s[2]), this._attach(d, v, y, p, g, !1);
+        }, o.prototype.once = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          var d = u.Sync;
+          s.length > 0 && typeof s[0] == "number" && (d = s.shift());
+          var v = this, y, g, p;
+          return typeof s[0] == "function" || s[0] && typeof s[0] == "object" && typeof s[0].post == "function" ? (typeof s[0] == "function" ? y = s[0] : p = s[0], g = s[1]) : (v = s[0], y = s[1], g = s[2]), this._attach(d, v, y, p, g, !0);
+        }, o.prototype._attach = function(s, c, d, v, y, g) {
+          var p = this, ot = this.evtFirstAttached ? this.listenerCount() : 0, _;
+          switch (s) {
+            case u.Sync:
+              {
+                for (var W = 0, at = this._events; W < at.length; W++) {
+                  var C = at[W];
+                  C instanceof r.SyncEvent && (_ = C);
+                }
+                _ || (_ = new r.SyncEvent(), this._events.push(_));
+              }
+              break;
+            case u.Async:
+              {
+                for (var F = 0, ut = this._events; F < ut.length; F++) {
+                  var C = ut[F];
+                  C instanceof f.AsyncEvent && n.shallowEquals(C.options, y) && (_ = C);
+                }
+                _ || (_ = new f.AsyncEvent(y), this._events.push(_));
+              }
+              break;
+            case u.Queued:
+              {
+                for (var X = 0, ct = this._events; X < ct.length; X++) {
+                  var C = ct[X];
+                  C instanceof l.QueuedEvent && n.shallowEquals(C.options, y) && (_ = C);
+                }
+                _ || (_ = new l.QueuedEvent(y), this._events.push(_));
+              }
+              break;
+            default:
+              throw new Error("unknown EventType");
+          }
+          var P;
+          return g ? v ? P = _.once(v) : P = _.once(c, d) : v ? P = _.attach(v) : P = _.attach(c, d), this.evtFirstAttached && ot === 0 && this.evtFirstAttached.post(), this.evtListenersChanged && ot !== this.listenerCount() && this.evtListenersChanged.post(), function() {
+            var ht = p.evtLastDetached ? p.listenerCount() : 0;
+            P(), p.evtLastDetached && ht > 0 && p.listenerCount() === 0 && p.evtLastDetached.post(), p.evtListenersChanged && ht !== p.listenerCount() && p.evtListenersChanged.post();
+          };
+        }, o.prototype.attachSync = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          return s.unshift(u.Sync), this.attach.apply(this, s);
+        }, o.prototype.onceSync = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          return s.unshift(u.Sync), this.once.apply(this, s);
+        }, o.prototype.attachAsync = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          return s.unshift(u.Async), this.attach.apply(this, s);
+        }, o.prototype.onceAsync = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          return s.unshift(u.Async), this.once.apply(this, s);
+        }, o.prototype.attachQueued = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          return s.unshift(u.Queued), this.attach.apply(this, s);
+        }, o.prototype.onceQueued = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          return s.unshift(u.Queued), this.once.apply(this, s);
+        }, o.prototype.detach = function() {
+          for (var s = [], c = 0; c < arguments.length; c++)
+            s[c] = arguments[c];
+          for (var d = this.listenerCount(), v = 0; v < this._events.length; ++v)
+            this._events[v].detach.apply(this._events[v], s);
+          this.evtListenersChanged && d !== this.listenerCount() && this.evtListenersChanged.post(), this.evtLastDetached && d > 0 && this.listenerCount() === 0 && this.evtLastDetached.post();
+        }, o.prototype.post = function(s) {
+          for (var c = [], d = 0; d < this._events.length; ++d)
+            c.push(this._events[d]);
+          for (var d = 0; d < c.length; ++d)
+            c[d].post(s);
+        }, o.prototype.listenerCount = function() {
+          for (var s = 0, c = 0; c < this._events.length; ++c)
+            s += this._events[c].listenerCount();
+          return s;
+        }, o;
+      })()
+    );
+    t.AnyEvent = i;
+    var a = (
+      /** @class */
+      (function(o) {
+        e(s, o);
+        function s() {
+          return o !== null && o.apply(this, arguments) || this;
+        }
+        return s.prototype.post = function() {
+          o.prototype.post.call(this, void 0);
+        }, s;
+      })(i)
+    );
+    t.VoidAnyEvent = a;
+    var h = (
+      /** @class */
+      (function(o) {
+        e(s, o);
+        function s() {
+          return o !== null && o.apply(this, arguments) || this;
+        }
+        return s.prototype.post = function(c) {
+          if (this.listenerCount() === 0)
+            throw new Error("error event posted while no listeners attached. Error: " + c.message);
+          o.prototype.post.call(this, c);
+        }, s;
+      })(i)
+    );
+    t.ErrorAnyEvent = h;
+  })(I)), I;
+}
+var _t;
+function Qt() {
+  return _t || (_t = 1, (function(t) {
+    var e = U && U.__createBinding || (Object.create ? (function(a, h, o, s) {
+      s === void 0 && (s = o), Object.defineProperty(a, s, { enumerable: !0, get: function() {
+        return h[o];
+      } });
+    }) : (function(a, h, o, s) {
+      s === void 0 && (s = o), a[s] = h[o];
+    })), n = U && U.__exportStar || function(a, h) {
+      for (var o in a) o !== "default" && !h.hasOwnProperty(o) && e(h, a, o);
+    };
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.flush = t.flushOnce = t.queue = void 0, n(H(), t), n(x(), t), n(Ct(), t), n(St(), t), n(jt(), t);
+    var r = z(), f = z();
+    Object.defineProperty(t, "EventQueue", { enumerable: !0, get: function() {
+      return f.default;
+    } });
+    function l() {
+      return r.default.global();
+    }
+    t.queue = l;
+    function u() {
+      r.default.global().flushOnce();
+    }
+    t.flushOnce = u;
+    function i(a) {
+      a === void 0 && (a = 10), r.default.global().flush(a);
+    }
+    t.flush = i;
+  })(U)), U;
+}
+var D = Qt();
+class Vt {
+  id;
+  elements = [];
+  onPlus = new D.SyncEvent();
+  onMin = new D.SyncEvent();
+  constructor(e) {
+    this.id = e;
+  }
+  name() {
+    return this.id.toString(16).padStart(2, "0");
+  }
+}
+let J = !1, $ = [], Q, bt, V = /* @__PURE__ */ new Map();
+async function $t(t) {
+  try {
+    if (Q = await navigator.bluetooth.requestDevice(t), Q.gatt === void 0)
+      throw new Error("Device does not support GATT");
+    bt = await Q.gatt.connect(), Q.addEventListener("gattserverdisconnected", Ht), J = !0;
+  } catch (e) {
+    throw e;
+  }
+}
+function Ht() {
+  V.clear(), J = !1, $.forEach((t) => t());
+}
+function kt(t) {
+  $.push(t);
+}
+function Gt(t) {
+  $ = $.filter((e) => e !== t);
+}
+async function tt(t, e) {
+  if (V.has(e)) {
+    const f = V.get(e);
+    if (f === void 0)
+      throw new Error("Characteristic not found");
+    return f;
+  }
+  const r = await (await bt.getPrimaryService(t)).getCharacteristic(e);
+  return V.set(e, r), r;
+}
+async function Wt(t, e) {
+  return await (await tt(t, e)).readValue();
+}
+async function Ft(t, e, n) {
+  const r = new DataView(new ArrayBuffer(n.length));
+  r.setUint8(0, n[0]), await (await tt(t, e)).writeValue(r);
+}
+async function Xt(t, e, n) {
+  const r = await tt(t, e);
+  r.addEventListener(
+    "characteristicvaluechanged",
+    (f) => {
+      let l = f.target.value;
+      l === void 0 && (l = new DataView(new ArrayBuffer(0))), n(l);
+    }
+  ), await r.startNotifications();
+}
+function k() {
+  return {
+    connected: J,
+    connect: $t,
+    readCharacteristic: Wt,
+    writeCharacteristic: Ft,
+    subscribe: Xt,
+    setDisconnectCallback: kt,
+    removeDisconnectCallback: Gt
+  };
+}
+const Tt = "19b10000-e8f2-537e-4f6c-d104768a1214", Yt = "6b061bdc-9bc1-4952-a96f-c6ed551b2c3e", Kt = "998ff920-81af-42a9-a915-f88025f9647d", zt = {
+  filters: [{ namePrefix: "BLE-STANDEE" }],
+  optionalServices: [Tt]
+};
+function G() {
+  return {
+    serviceUuid: Tt,
+    messageCharUuid: Yt,
+    handshakeCharUuid: Kt,
+    options: zt
+  };
+}
+class Et {
+  static CONNECT = 0;
+  static DISCONNECT = 1;
+}
+class S {
+  static UPLOAD = 0;
+  static DRAW_IMAGE = 1;
+  static DRAW_RECTANGLE = 2;
+  static BUTTON_PRESS = 3;
+  static DRAW_TEXT = 4;
+  static ALL = 5;
+  static CLEAR_GRAPHICS = 6;
+  static ACTIONS = 7;
+  static CLEAR_SCREEN = 8;
+  static MESSAGE_DONE = 9;
+}
+class q {
+  static ID = 0;
+  static CACHE = 1;
+  static TTL = 2;
+  static POSITION = 3;
+  static DATA_SIZE = 4;
+  static TYPE = 5;
+  static DATA = 6;
+}
+class Y {
+  static MINUS = 0;
+  static PLUS = 1;
+  static EITHER = 2;
+}
+class m {
+  static INCREMENT = 0;
+  static DECREMENT = 1;
+  static SHOW = 2;
+  static HIDE = 3;
+  static SET = 4;
+  static BROADCAST = 5;
+  static TIMER = 6;
+  static CONDITION = 7;
+  static BREAK = 8;
+  static MAP = 9;
+}
+class O {
+  static STRING = 0;
+  static NUMBER = 1;
+  static ELEMENT = 2;
+}
+const { serviceUuid: Zt, handshakeCharUuid: Jt } = G(), Dt = new D.SyncEvent(), Ut = new D.SyncEvent();
+function te() {
+  return new Promise((t, e) => {
+    k().subscribe(Zt, Jt, ee).then(() => t()).catch((n) => e(n));
+  });
+}
+function ee(t) {
+  t.getUint8(q.TYPE) === Et.CONNECT && Dt.post(t), t.getUint8(q.TYPE) === Et.DISCONNECT && Ut.post(t);
+}
+function et() {
+  return { subscribe: te, onConnected: Dt, onDisconnected: Ut };
+}
+class ne {
+  id;
+  data;
+  constructor(e, n) {
+    this.id = e, this.data = n;
+  }
+}
+const { serviceUuid: re, messageCharUuid: se } = G(), Ot = new D.SyncEvent(), qt = new D.SyncEvent(), Pt = new D.SyncEvent(), Lt = new D.SyncEvent();
+function ie() {
+  return new Promise((t, e) => {
+    k().subscribe(re, se, oe).then(() => t()).catch((n) => e(n));
+  });
+}
+function oe(t) {
+  t !== void 0 && (t.getUint8(q.TYPE) === S.BUTTON_PRESS && ae(t), t.getUint8(q.TYPE) === S.MESSAGE_DONE && Lt.post(t.getUint8(q.DATA)));
+}
+function ae(t) {
+  const e = t.getUint8(q.DATA), n = new ne(
+    t.getUint8(q.ID),
+    ue(t)
+  );
+  e === Y.MINUS && qt.post(n), e === Y.PLUS && Ot.post(n), e === Y.EITHER && Pt.post(n);
+}
+function ue(t) {
+  const e = t.buffer, n = 7, r = t.byteLength - 7;
+  return Array.from(new Uint8Array(e, n, r)).map((f) => String.fromCharCode(f)).join("").replace(/\0/g, "").trim();
+}
+function It() {
+  return { subscribe: ie, onPlus: Ot, onMin: qt, onEither: Pt, onMessageDone: Lt };
+}
+const { onConnected: ce } = et(), { onDisconnected: he } = et();
+function le() {
+  return new Promise((t, e) => {
+    k().connect(G().options).then(
+      () => Promise.all([
+        et().subscribe(),
+        It().subscribe()
+      ]).then(() => {
+        t();
+      })
+    ).catch((n) => e(n));
+  });
+}
+function fe() {
+  return {
+    connect: le,
+    onConnected: ce,
+    onDisconnected: he
+  };
+}
+const N = [];
+function de() {
+  let t = Math.floor(Math.random() * 256);
+  for (; N.includes(t); ) t = Math.floor(Math.random() * 256);
+  return t;
+}
+function ve(t) {
+  N.push(t), ye();
+}
+function ye() {
+  N.length <= 20 || N.splice(0, N.length - 20);
+}
+function ge() {
+  const t = de();
+  return ve(t), t;
+}
+function pe() {
+  return {
+    create: ge
+  };
+}
+const { serviceUuid: _e, messageCharUuid: Ee } = G(), { onMessageDone: we } = It(), Ae = k(), wt = 10, At = 15, Mt = [], Z = /* @__PURE__ */ new Map();
+let R = !1;
+we.attach(Se);
+function me(t, e, n) {
+  const r = pe().create();
+  return Ce(r, t, e, n).forEach((l) => Mt.push(l)), new Promise((l) => {
+    Z.set(r, l), R || nt();
+  });
+}
+function Ce(t, e, n, r) {
+  if (r == null)
+    return [new Uint8Array([n, t, wt, 0, 2, e, 0])];
+  const f = new Uint8Array(2 + r.length), l = r.length + 2, u = [];
+  f.set([e, l], 0), f.set(r, 2);
+  for (let i = 0; i < l; i += At) {
+    const a = Math.min(At, l - i), h = new Uint8Array(a), o = [n, t, wt, i, l];
+    h.set(f.subarray(i, i + a), 0), u.push(new Uint8Array([...o, ...h]));
+  }
+  return u;
+}
+function nt() {
+  if (R)
+    return;
+  const t = Mt.shift();
+  if (t == null) {
+    R = !1;
+    return;
+  }
+  R = !0, Ae.writeCharacteristic(_e, Ee, t).catch((e) => console.log(e)).finally(() => {
+    R = !1, nt();
+  });
+}
+function Se(t) {
+  Z.get(t)?.(), Z.delete(t), nt();
+}
+function rt() {
+  return { write: me };
+}
+const { write: mt } = rt();
+function ln(t) {
+  return {
+    upload: (e, n) => {
+      const r = new Uint8Array(n.length + 1);
+      return r.set([e], 0), r.set(n, 1), mt(S.UPLOAD, t, r);
+    },
+    clear: () => mt(S.CLEAR_GRAPHICS, t)
+  };
+}
+const { onConnected: be, onDisconnected: Te } = fe();
+be.attach(De);
+Te.attach(Ue);
+const B = [];
+function De(t) {
+  const e = new Uint8Array(t.buffer, 6);
+  for (const n of e)
+    Oe(n);
+}
+function Ue(t) {
+  const e = t.getUint8(2);
+  qe(e);
+}
+function Oe(t) {
+  B.some((e) => e.id === t) || B.push(new Vt(t));
+}
+function qe(t) {
+  const e = B.findIndex((n) => n.id === t);
+  e !== -1 && B.splice(e, 1);
+}
+function fn() {
+  return { standees: B };
+}
+class st {
+  id = 0;
+  dirty = !0;
+  _show = !0;
+  _x;
+  _y;
+  _colorBlack = !1;
+  constructor(e, n, r = !0, f = !1) {
+    this._x = e, this._y = n, this._show = r, this._colorBlack = f;
+  }
+  get x() {
+    return this._x;
+  }
+  get y() {
+    return this._y;
+  }
+  set x(e) {
+    this._x = e, this.dirty = !0;
+  }
+  set y(e) {
+    this._y = e, this.dirty = !0;
+  }
+  set show(e) {
+    this._show = e, this.dirty = !0;
+  }
+  get show() {
+    return this._show;
+  }
+  set colorBlack(e) {
+    this._colorBlack = e, this.dirty = !0;
+  }
+  get colorBlack() {
+    return this._colorBlack;
+  }
+}
+class Pe extends st {
+  _width;
+  _height;
+  _radius;
+  _fill;
+  constructor(e, n, r, f, l = 0, u = !1, i = !0, a = !1) {
+    super(e, n, i, a), this._width = r, this._height = f, this._radius = l, this._fill = u;
+  }
+  set width(e) {
+    this._width = e, this.dirty = !0;
+  }
+  set height(e) {
+    this._height = e, this.dirty = !0;
+  }
+  set radius(e) {
+    this._radius = e, this.dirty = !0;
+  }
+  set fill(e) {
+    this._fill = e, this.dirty = !0;
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  get radius() {
+    return this._radius;
+  }
+  get fill() {
+    return this._fill;
+  }
+}
+let Le = class extends st {
+  _width;
+  _height;
+  _data;
+  constructor(e, n, r, f, l, u = !0, i = !1) {
+    super(e, n, u, i), this._width = r, this._height = f, this._data = l;
+  }
+  set width(e) {
+    this._width = e, this.dirty = !0;
+  }
+  set height(e) {
+    this._height = e, this.dirty = !0;
+  }
+  set data(e) {
+    this._data = e, this.dirty = !0;
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  get data() {
+    return this._data;
+  }
+};
+class Ie extends st {
+  _text;
+  _font;
+  _center;
+  constructor(e, n, r, f, l = !1, u = !0, i = !1) {
+    super(e, n, u, i), this._text = r, this._font = f, this._center = l;
+  }
+  set text(e) {
+    this._text = e, this.dirty = !0;
+  }
+  set font(e) {
+    this._font = e, this.dirty = !0;
+  }
+  get text() {
+    return this._text;
+  }
+  get font() {
+    return this._font;
+  }
+  get center() {
+    return this._center;
+  }
+  set center(e) {
+    this._center = e, this.dirty = !0;
+  }
+}
+function Me(t) {
+  const e = () => {
+    let r = Math.floor(Math.random() * 256);
+    return n(r) ? e() : r;
+  }, n = (r) => t.some((f) => f.id === r);
+  return { generate: e };
+}
+function vn(t) {
+  return { add: (r) => (r.id = Me(t.elements).generate(), t.elements.push(r), r), remove: (r) => {
+    t.elements = t.elements.filter(
+      (f) => f.id !== r
+    );
+  } };
+}
+const { write: Rt } = rt();
+function Re(t) {
+  return Rt(S.CLEAR_SCREEN, t.id);
+}
+function Ne(t) {
+  let e = new Uint8Array();
+  for (const n of t.elements)
+    n.dirty !== !1 && (n instanceof Le && (e = K(e, Be(n))), n instanceof Pe && (e = K(e, xe(n))), n instanceof Ie && (e = K(e, je(n))), n.dirty = !1);
+  return Rt(S.ALL, t.id, e);
+}
+function K(t, e) {
+  const n = new Uint8Array(t.length + e.length);
+  return n.set(t, 0), n.set(e, t.length), n;
+}
+function Be(t) {
+  return new Uint8Array([
+    S.DRAW_IMAGE,
+    7,
+    t.id,
+    t.show ? 1 : 0,
+    t.x,
+    t.y,
+    t.width,
+    t.height,
+    t.data
+  ]);
+}
+function xe(t) {
+  return new Uint8Array([
+    S.DRAW_RECTANGLE,
+    9,
+    t.id,
+    t.show ? 1 : 0,
+    t.x,
+    t.y,
+    t.width,
+    t.height,
+    t.radius,
+    t.fill ? 1 : 0,
+    t.colorBlack ? 0 : 1
+  ]);
+}
+function je(t) {
+  const e = new TextEncoder().encode(t.text), n = new Uint8Array(9 + e.length);
+  return n.set(
+    [
+      S.DRAW_TEXT,
+      7 + e.length,
+      t.id,
+      t.show ? 1 : 0,
+      t.x,
+      t.y,
+      t.font,
+      t.colorBlack ? 0 : 1,
+      t.center ? 1 : 0
+    ],
+    0
+  ), n.set(e, 9), n;
+}
+function yn() {
+  return { clear: Re, draw: Ne };
+}
+function Qe(t, e) {
+  const n = Math.ceil(t.length / e), r = Math.ceil(e / 8), f = new Uint8Array(r * n);
+  for (let l = 0; l < n; l++)
+    for (let u = 0; u < r; u++) {
+      let i = 0;
+      for (let a = 0; a < 8; a++) {
+        const h = u * 8 + a, o = l * e + h;
+        h < e && o < t.length && t[o] && (i |= 1 << 7 - a);
+      }
+      f[l * r + u] = Nt(i);
+    }
+  return f;
+}
+function Nt(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 Ve(t) {
+  const e = t.reduce((f, l) => f + l.length, 0), n = new Uint8Array(e);
+  let r = 0;
+  for (const f of t)
+    n.set(f, r), r += f.length;
+  return n;
+}
+function it() {
+  return {
+    pixelsToBytes: Qe,
+    bitswap: Nt,
+    flattenUint8Arrays: Ve
+  };
+}
+const { flattenUint8Arrays: Bt } = it();
+class T {
+  element_id;
+  property;
+  constructor(e, n) {
+    this.element_id = e, this.property = n;
+  }
+}
+class b {
+  target;
+  constructor(e) {
+    this.target = e;
+  }
+  format() {
+    return new Uint8Array();
+  }
+}
+class $e extends b {
+  format() {
+    return new Uint8Array([
+      m.INCREMENT,
+      2,
+      this.target.element_id,
+      this.target.property
+    ]);
+  }
+}
+class He extends b {
+  format() {
+    return new Uint8Array([
+      m.DECREMENT,
+      2,
+      this.target.element_id,
+      this.target.property
+    ]);
+  }
+}
+class ke extends b {
+  format() {
+    return new Uint8Array([m.SHOW, 1, this.target.element_id]);
+  }
+}
+class Ge extends b {
+  format() {
+    return new Uint8Array([m.HIDE, 1, this.target.element_id]);
+  }
+}
+class We extends b {
+  value;
+  constructor(e, n) {
+    super(e), this.value = n;
+  }
+  format() {
+    const e = this.dataType(), n = this.convertValue(e), r = new Uint8Array(5 + n.length), f = [
+      m.SET,
+      n.length + 3,
+      e,
+      this.target.element_id,
+      this.target.property
+    ];
+    return r.set(f, 0), r.set(n, 5), r;
+  }
+  dataType() {
+    return typeof this.value === "string" ? O.STRING : O.NUMBER;
+  }
+  convertValue(e) {
+    return e === O.STRING ? new TextEncoder().encode(this.value) : e === O.NUMBER ? new Uint8Array([this.value]) : new Uint8Array();
+  }
+}
+class Fe extends b {
+  format() {
+    return this.target.element_id !== 0 && this.target.property !== 0 ? new Uint8Array([
+      m.BROADCAST,
+      2,
+      this.target.element_id,
+      this.target.property
+    ]) : new Uint8Array([m.BROADCAST, 0]);
+  }
+}
+class Xe extends b {
+  format() {
+    return new Uint8Array([m.BREAK, 0]);
+  }
+}
+let Ye = class extends b {
+  fromLow;
+  fromHigh;
+  toLow;
+  toHigh;
+  value;
+  constructor(e, n, r, f, l, u) {
+    super(u), this.value = e, this.fromLow = n, this.fromHigh = r, this.toLow = f, this.toHigh = l;
+  }
+  format() {
+    return new Uint8Array([
+      m.MAP,
+      8,
+      this.value.element_id,
+      this.value.property,
+      this.fromLow,
+      this.fromHigh,
+      this.toLow,
+      this.toHigh,
+      this.target.element_id,
+      this.target.property
+    ]);
+  }
+};
+class Ke extends b {
+  deciseconds;
+  resetable;
+  onComplete;
+  constructor(e, n, r) {
+    super(new T(0, 0)), this.deciseconds = e, this.resetable = n, this.onComplete = r;
+  }
+  format() {
+    const e = Bt(
+      this.onComplete.map((f) => f.format())
+    ), n = new Uint8Array(4 + e.length), r = [
+      m.TIMER,
+      e.length + 2,
+      this.resetable ? 1 : 0,
+      this.deciseconds
+    ];
+    return n.set(r, 0), e.forEach(
+      (f, l) => n.set([f], l + 4)
+    ), n;
+  }
+}
+class ze extends b {
+  left;
+  operator;
+  right;
+  actions;
+  constructor(e, n, r, f) {
+    super(new T(0, 0)), this.actions = f, this.left = e, this.operator = n, this.right = r;
+  }
+  convertValue(e) {
+    if (typeof e == "number")
+      return new Uint8Array([O.NUMBER, 1, e]);
+    if (typeof e == "string") {
+      const n = new TextEncoder().encode(e);
+      return new Uint8Array([
+        O.STRING,
+        n.length,
+        ...n
+      ]);
+    }
+    return e instanceof T ? new Uint8Array([
+      O.ELEMENT,
+      2,
+      e.element_id,
+      e.property
+    ]) : new Uint8Array();
+  }
+  format() {
+    const e = Bt(
+      this.actions.map((i) => i.format())
+    ), n = this.convertValue(this.left), r = this.convertValue(this.right), f = 4 + n.length + r.length + e.length, l = new Uint8Array(f), u = [
+      m.CONDITION,
+      f - 2,
+      n.length + r.length + 1
+    ];
+    return l.set(u, 0), l.set([this.operator], 3), l.set(n, 4), l.set(r, 4 + n.length), l.set(e, 4 + n.length + r.length), l;
+  }
+}
+function pn() {
+  return {
+    target(t, e) {
+      return new T(t, e);
+    },
+    increment(t) {
+      return new $e(t);
+    },
+    decrement(t) {
+      return new He(t);
+    },
+    show(t) {
+      return new ke(new T(t, 0));
+    },
+    hide(t) {
+      return new Ge(new T(t, 0));
+    },
+    set(t, e) {
+      return new We(t, e);
+    },
+    broadcast(t) {
+      return new Fe(t || new T(0, 0));
+    },
+    timer(t, e, n) {
+      return new Ke(t, e, n);
+    },
+    stop() {
+      return new Xe(new T(0, 0));
+    },
+    condition(t, e, n, r) {
+      return new ze(t, e, n, r);
+    },
+    map(t, e, n, r, f, l) {
+      return new Ye(t, e, n, r, f, l);
+    }
+  };
+}
+const { write: Ze } = rt(), { flattenUint8Arrays: Je } = it();
+function _n(t) {
+  return {
+    setButton(e, n) {
+      const r = Je(
+        n.map((l) => l.format())
+      ), f = new Uint8Array(1 + r.length);
+      return f.set([e], 0), r.forEach(
+        (l, u) => f.set([l], u + 1)
+      ), Ze(S.ACTIONS, t.id, f);
+    }
+  };
+}
+function tn(t) {
+  return new Promise((e, n) => {
+    const r = new Image();
+    r.onload = () => e(r), r.onerror = n, r.src = t;
+  });
+}
+function en(t) {
+  const e = document.createElement("canvas"), n = e.getContext("2d");
+  if (e.width = t.width, e.height = t.height, !n)
+    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 nn(t) {
+  const e = [], n = t.data, r = t.width, f = t.height;
+  for (let l = 0; l < f; l++)
+    for (let u = 0; u < r; u++) {
+      const i = (l * r + u) * 4, a = n[i], h = n[i + 1], o = n[i + 2], s = 0.2126 * a + 0.7152 * h + 0.0722 * o;
+      e.push(s < 128 ? 0 : 1);
+    }
+  return {
+    width: r,
+    height: f,
+    pixels: e
+  };
+}
+function rn() {
+  return {
+    createImage: tn,
+    getImageData: en,
+    imageDataToPixels: nn
+  };
+}
+const { createImage: sn, getImageData: on, imageDataToPixels: an } = rn(), { pixelsToBytes: un } = it();
+function cn(t) {
+  return new Promise((e, n) => {
+    sn(t).then((r) => on(r)).then((r) => an(r)).then((r) => un(r.pixels, r.width)).then((r) => e(r)).catch((r) => n(r));
+  });
+}
+function En() {
+  return {
+    imageToBytes: cn
+  };
+}
+function hn(t, e, n, r, f) {
+  return (t - e) / (n - e) * (f - r) + r;
+}
+function wn() {
+  return { map: hn };
+}
+export {
+  Vt as Standee,
+  pn as useActions,
+  it as useBinary,
+  _n as useButtons,
+  En as useConverter,
+  yn as useDisplay,
+  rn as useImage,
+  fe as useMesh,
+  ln as useMeshUpload,
+  rt as useMeshWriter,
+  vn as useStandeeElements,
+  fn as useStandees,
+  wn as useUtils
+};