buttplug 3.1.0 → 3.2.0

package/dist/web/buttplug.mjs

@@ -0,0 +1,2254 @@
+var nt = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function It(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var ot = { exports: {} };
+(function(r) {
+  var e = Object.prototype.hasOwnProperty, t = "~";
+  function n() {
+  }
+  Object.create && (n.prototype = /* @__PURE__ */ Object.create(null), new n().__proto__ || (t = !1));
+  function i(l, v, p) {
+    this.fn = l, this.context = v, this.once = p || !1;
+  }
+  function u(l, v, p, m, h) {
+    if (typeof p != "function")
+      throw new TypeError("The listener must be a function");
+    var R = new i(p, m || l, h), E = t ? t + v : v;
+    return l._events[E] ? l._events[E].fn ? l._events[E] = [l._events[E], R] : l._events[E].push(R) : (l._events[E] = R, l._eventsCount++), l;
+  }
+  function a(l, v) {
+    --l._eventsCount === 0 ? l._events = new n() : delete l._events[v];
+  }
+  function f() {
+    this._events = new n(), this._eventsCount = 0;
+  }
+  f.prototype.eventNames = function() {
+    var v = [], p, m;
+    if (this._eventsCount === 0)
+      return v;
+    for (m in p = this._events)
+      e.call(p, m) && v.push(t ? m.slice(1) : m);
+    return Object.getOwnPropertySymbols ? v.concat(Object.getOwnPropertySymbols(p)) : v;
+  }, f.prototype.listeners = function(v) {
+    var p = t ? t + v : v, m = this._events[p];
+    if (!m)
+      return [];
+    if (m.fn)
+      return [m.fn];
+    for (var h = 0, R = m.length, E = new Array(R); h < R; h++)
+      E[h] = m[h].fn;
+    return E;
+  }, f.prototype.listenerCount = function(v) {
+    var p = t ? t + v : v, m = this._events[p];
+    return m ? m.fn ? 1 : m.length : 0;
+  }, f.prototype.emit = function(v, p, m, h, R, E) {
+    var $ = t ? t + v : v;
+    if (!this._events[$])
+      return !1;
+    var g = this._events[$], I = arguments.length, O, S;
+    if (g.fn) {
+      switch (g.once && this.removeListener(v, g.fn, void 0, !0), I) {
+        case 1:
+          return g.fn.call(g.context), !0;
+        case 2:
+          return g.fn.call(g.context, p), !0;
+        case 3:
+          return g.fn.call(g.context, p, m), !0;
+        case 4:
+          return g.fn.call(g.context, p, m, h), !0;
+        case 5:
+          return g.fn.call(g.context, p, m, h, R), !0;
+        case 6:
+          return g.fn.call(g.context, p, m, h, R, E), !0;
+      }
+      for (S = 1, O = new Array(I - 1); S < I; S++)
+        O[S - 1] = arguments[S];
+      g.fn.apply(g.context, O);
+    } else {
+      var W = g.length, C;
+      for (S = 0; S < W; S++)
+        switch (g[S].once && this.removeListener(v, g[S].fn, void 0, !0), I) {
+          case 1:
+            g[S].fn.call(g[S].context);
+            break;
+          case 2:
+            g[S].fn.call(g[S].context, p);
+            break;
+          case 3:
+            g[S].fn.call(g[S].context, p, m);
+            break;
+          case 4:
+            g[S].fn.call(g[S].context, p, m, h);
+            break;
+          default:
+            if (!O)
+              for (C = 1, O = new Array(I - 1); C < I; C++)
+                O[C - 1] = arguments[C];
+            g[S].fn.apply(g[S].context, O);
+        }
+    }
+    return !0;
+  }, f.prototype.on = function(v, p, m) {
+    return u(this, v, p, m, !1);
+  }, f.prototype.once = function(v, p, m) {
+    return u(this, v, p, m, !0);
+  }, f.prototype.removeListener = function(v, p, m, h) {
+    var R = t ? t + v : v;
+    if (!this._events[R])
+      return this;
+    if (!p)
+      return a(this, R), this;
+    var E = this._events[R];
+    if (E.fn)
+      E.fn === p && (!h || E.once) && (!m || E.context === m) && a(this, R);
+    else {
+      for (var $ = 0, g = [], I = E.length; $ < I; $++)
+        (E[$].fn !== p || h && !E[$].once || m && E[$].context !== m) && g.push(E[$]);
+      g.length ? this._events[R] = g.length === 1 ? g[0] : g : a(this, R);
+    }
+    return this;
+  }, f.prototype.removeAllListeners = function(v) {
+    var p;
+    return v ? (p = t ? t + v : v, this._events[p] && a(this, p)) : (this._events = new n(), this._eventsCount = 0), this;
+  }, f.prototype.off = f.prototype.removeListener, f.prototype.addListener = f.prototype.on, f.prefixed = t, f.EventEmitter = f, r.exports = f;
+})(ot);
+var Rt = ot.exports;
+const ye = /* @__PURE__ */ It(Rt);
+/*!
+ * Buttplug JS Source Code File - Visit https://buttplug.io for more info about
+ * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the
+ * project root for full license information.
+ *
+ * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.
+ */
+var at = /* @__PURE__ */ ((r) => (r[r.Off = 0] = "Off", r[r.Error = 1] = "Error", r[r.Warn = 2] = "Warn", r[r.Info = 3] = "Info", r[r.Debug = 4] = "Debug", r[r.Trace = 5] = "Trace", r))(at || {});
+class Dt {
+  /**
+   * @param logMessage Log message.
+   * @param logLevel: Log severity level.
+   */
+  constructor(e, t) {
+    const n = /* @__PURE__ */ new Date(), i = n.getHours(), u = n.getMinutes(), a = n.getSeconds();
+    this.timestamp = `${i}:${u}:${a}`, this.logMessage = e, this.logLevel = t;
+  }
+  /**
+   * Returns the log message.
+   */
+  get Message() {
+    return this.logMessage;
+  }
+  /**
+   * Returns the log message level.
+   */
+  get LogLevel() {
+    return this.logLevel;
+  }
+  /**
+   * Returns the log message timestamp.
+   */
+  get Timestamp() {
+    return this.timestamp;
+  }
+  /**
+   * Returns a formatted string with timestamp, level, and message.
+   */
+  get FormattedMessage() {
+    return `${at[this.logLevel]} : ${this.timestamp} : ${this.logMessage}`;
+  }
+}
+const ct = class pe extends ye {
+  /**
+   * Constructor. Can only be called internally since we regulate ButtplugLogger
+   * ownership.
+   */
+  constructor() {
+    super(), this.maximumConsoleLogLevel = 0, this.maximumEventLogLevel = 0;
+  }
+  /**
+   * Returns the stored static instance of the logger, creating one if it
+   * doesn't currently exist.
+   */
+  static get Logger() {
+    return pe.sLogger === void 0 && (pe.sLogger = new pe()), this.sLogger;
+  }
+  /**
+   * Set the maximum log level to output to console.
+   */
+  get MaximumConsoleLogLevel() {
+    return this.maximumConsoleLogLevel;
+  }
+  /**
+   * Get the maximum log level to output to console.
+   */
+  set MaximumConsoleLogLevel(e) {
+    this.maximumConsoleLogLevel = e;
+  }
+  /**
+   * Set the global maximum log level
+   */
+  get MaximumEventLogLevel() {
+    return this.maximumEventLogLevel;
+  }
+  /**
+   * Get the global maximum log level
+   */
+  set MaximumEventLogLevel(e) {
+    this.maximumEventLogLevel = e;
+  }
+  /**
+   * Log new message at Error level.
+   */
+  Error(e) {
+    this.AddLogMessage(
+      e,
+      1
+      /* Error */
+    );
+  }
+  /**
+   * Log new message at Warn level.
+   */
+  Warn(e) {
+    this.AddLogMessage(
+      e,
+      2
+      /* Warn */
+    );
+  }
+  /**
+   * Log new message at Info level.
+   */
+  Info(e) {
+    this.AddLogMessage(
+      e,
+      3
+      /* Info */
+    );
+  }
+  /**
+   * Log new message at Debug level.
+   */
+  Debug(e) {
+    this.AddLogMessage(
+      e,
+      4
+      /* Debug */
+    );
+  }
+  /**
+   * Log new message at Trace level.
+   */
+  Trace(e) {
+    this.AddLogMessage(
+      e,
+      5
+      /* Trace */
+    );
+  }
+  /**
+   * Checks to see if message should be logged, and if so, adds message to the
+   * log buffer. May also print message and emit event.
+   */
+  AddLogMessage(e, t) {
+    if (t > this.maximumEventLogLevel && t > this.maximumConsoleLogLevel)
+      return;
+    const n = new Dt(e, t);
+    t <= this.maximumConsoleLogLevel && console.log(n.FormattedMessage), t <= this.maximumEventLogLevel && this.emit("log", n);
+  }
+};
+ct.sLogger = void 0;
+let Tt = ct;
+var b;
+(function(r) {
+  r[r.PLAIN_TO_CLASS = 0] = "PLAIN_TO_CLASS", r[r.CLASS_TO_PLAIN = 1] = "CLASS_TO_PLAIN", r[r.CLASS_TO_CLASS = 2] = "CLASS_TO_CLASS";
+})(b || (b = {}));
+var Nt = (
+  /** @class */
+  function() {
+    function r() {
+      this._typeMetadatas = /* @__PURE__ */ new Map(), this._transformMetadatas = /* @__PURE__ */ new Map(), this._exposeMetadatas = /* @__PURE__ */ new Map(), this._excludeMetadatas = /* @__PURE__ */ new Map(), this._ancestorsMap = /* @__PURE__ */ new Map();
+    }
+    return r.prototype.addTypeMetadata = function(e) {
+      this._typeMetadatas.has(e.target) || this._typeMetadatas.set(e.target, /* @__PURE__ */ new Map()), this._typeMetadatas.get(e.target).set(e.propertyName, e);
+    }, r.prototype.addTransformMetadata = function(e) {
+      this._transformMetadatas.has(e.target) || this._transformMetadatas.set(e.target, /* @__PURE__ */ new Map()), this._transformMetadatas.get(e.target).has(e.propertyName) || this._transformMetadatas.get(e.target).set(e.propertyName, []), this._transformMetadatas.get(e.target).get(e.propertyName).push(e);
+    }, r.prototype.addExposeMetadata = function(e) {
+      this._exposeMetadatas.has(e.target) || this._exposeMetadatas.set(e.target, /* @__PURE__ */ new Map()), this._exposeMetadatas.get(e.target).set(e.propertyName, e);
+    }, r.prototype.addExcludeMetadata = function(e) {
+      this._excludeMetadatas.has(e.target) || this._excludeMetadatas.set(e.target, /* @__PURE__ */ new Map()), this._excludeMetadatas.get(e.target).set(e.propertyName, e);
+    }, r.prototype.findTransformMetadatas = function(e, t, n) {
+      return this.findMetadatas(this._transformMetadatas, e, t).filter(function(i) {
+        return !i.options || i.options.toClassOnly === !0 && i.options.toPlainOnly === !0 ? !0 : i.options.toClassOnly === !0 ? n === b.CLASS_TO_CLASS || n === b.PLAIN_TO_CLASS : i.options.toPlainOnly === !0 ? n === b.CLASS_TO_PLAIN : !0;
+      });
+    }, r.prototype.findExcludeMetadata = function(e, t) {
+      return this.findMetadata(this._excludeMetadatas, e, t);
+    }, r.prototype.findExposeMetadata = function(e, t) {
+      return this.findMetadata(this._exposeMetadatas, e, t);
+    }, r.prototype.findExposeMetadataByCustomName = function(e, t) {
+      return this.getExposedMetadatas(e).find(function(n) {
+        return n.options && n.options.name === t;
+      });
+    }, r.prototype.findTypeMetadata = function(e, t) {
+      return this.findMetadata(this._typeMetadatas, e, t);
+    }, r.prototype.getStrategy = function(e) {
+      var t = this._excludeMetadatas.get(e), n = t && t.get(void 0), i = this._exposeMetadatas.get(e), u = i && i.get(void 0);
+      return n && u || !n && !u ? "none" : n ? "excludeAll" : "exposeAll";
+    }, r.prototype.getExposedMetadatas = function(e) {
+      return this.getMetadata(this._exposeMetadatas, e);
+    }, r.prototype.getExcludedMetadatas = function(e) {
+      return this.getMetadata(this._excludeMetadatas, e);
+    }, r.prototype.getExposedProperties = function(e, t) {
+      return this.getExposedMetadatas(e).filter(function(n) {
+        return !n.options || n.options.toClassOnly === !0 && n.options.toPlainOnly === !0 ? !0 : n.options.toClassOnly === !0 ? t === b.CLASS_TO_CLASS || t === b.PLAIN_TO_CLASS : n.options.toPlainOnly === !0 ? t === b.CLASS_TO_PLAIN : !0;
+      }).map(function(n) {
+        return n.propertyName;
+      });
+    }, r.prototype.getExcludedProperties = function(e, t) {
+      return this.getExcludedMetadatas(e).filter(function(n) {
+        return !n.options || n.options.toClassOnly === !0 && n.options.toPlainOnly === !0 ? !0 : n.options.toClassOnly === !0 ? t === b.CLASS_TO_CLASS || t === b.PLAIN_TO_CLASS : n.options.toPlainOnly === !0 ? t === b.CLASS_TO_PLAIN : !0;
+      }).map(function(n) {
+        return n.propertyName;
+      });
+    }, r.prototype.clear = function() {
+      this._typeMetadatas.clear(), this._exposeMetadatas.clear(), this._excludeMetadatas.clear(), this._ancestorsMap.clear();
+    }, r.prototype.getMetadata = function(e, t) {
+      var n = e.get(t), i;
+      n && (i = Array.from(n.values()).filter(function(m) {
+        return m.propertyName !== void 0;
+      }));
+      for (var u = [], a = 0, f = this.getAncestors(t); a < f.length; a++) {
+        var l = f[a], v = e.get(l);
+        if (v) {
+          var p = Array.from(v.values()).filter(function(m) {
+            return m.propertyName !== void 0;
+          });
+          u.push.apply(u, p);
+        }
+      }
+      return u.concat(i || []);
+    }, r.prototype.findMetadata = function(e, t, n) {
+      var i = e.get(t);
+      if (i) {
+        var u = i.get(n);
+        if (u)
+          return u;
+      }
+      for (var a = 0, f = this.getAncestors(t); a < f.length; a++) {
+        var l = f[a], v = e.get(l);
+        if (v) {
+          var p = v.get(n);
+          if (p)
+            return p;
+        }
+      }
+    }, r.prototype.findMetadatas = function(e, t, n) {
+      var i = e.get(t), u;
+      i && (u = i.get(n));
+      for (var a = [], f = 0, l = this.getAncestors(t); f < l.length; f++) {
+        var v = l[f], p = e.get(v);
+        p && p.has(n) && a.push.apply(a, p.get(n));
+      }
+      return a.slice().reverse().concat((u || []).slice().reverse());
+    }, r.prototype.getAncestors = function(e) {
+      if (!e)
+        return [];
+      if (!this._ancestorsMap.has(e)) {
+        for (var t = [], n = Object.getPrototypeOf(e.prototype.constructor); typeof n.prototype < "u"; n = Object.getPrototypeOf(n.prototype.constructor))
+          t.push(n);
+        this._ancestorsMap.set(e, t);
+      }
+      return this._ancestorsMap.get(e);
+    }, r;
+  }()
+), F = new Nt();
+function Pt() {
+  if (typeof globalThis < "u")
+    return globalThis;
+  if (typeof global < "u")
+    return global;
+  if (typeof window < "u")
+    return window;
+  if (typeof self < "u")
+    return self;
+}
+function kt(r) {
+  return r !== null && typeof r == "object" && typeof r.then == "function";
+}
+var rt = globalThis && globalThis.__spreadArray || function(r, e, t) {
+  if (t || arguments.length === 2)
+    for (var n = 0, i = e.length, u; n < i; n++)
+      (u || !(n in e)) && (u || (u = Array.prototype.slice.call(e, 0, n)), u[n] = e[n]);
+  return r.concat(u || Array.prototype.slice.call(e));
+};
+function jt(r) {
+  var e = new r();
+  return !(e instanceof Set) && !("push" in e) ? [] : e;
+}
+var ie = (
+  /** @class */
+  function() {
+    function r(e, t) {
+      this.transformationType = e, this.options = t, this.recursionStack = /* @__PURE__ */ new Set();
+    }
+    return r.prototype.transform = function(e, t, n, i, u, a) {
+      var f = this;
+      if (a === void 0 && (a = 0), Array.isArray(t) || t instanceof Set) {
+        var l = i && this.transformationType === b.PLAIN_TO_CLASS ? jt(i) : [];
+        return t.forEach(function(g, I) {
+          var O = e ? e[I] : void 0;
+          if (!f.options.enableCircularCheck || !f.isCircular(g)) {
+            var S = void 0;
+            if (typeof n != "function" && n && n.options && n.options.discriminator && n.options.discriminator.property && n.options.discriminator.subTypes) {
+              if (f.transformationType === b.PLAIN_TO_CLASS) {
+                S = n.options.discriminator.subTypes.find(function(Y) {
+                  return Y.name === g[n.options.discriminator.property];
+                });
+                var W = { newObject: l, object: g, property: void 0 }, C = n.typeFunction(W);
+                S === void 0 ? S = C : S = S.value, n.options.keepDiscriminatorProperty || delete g[n.options.discriminator.property];
+              }
+              f.transformationType === b.CLASS_TO_CLASS && (S = g.constructor), f.transformationType === b.CLASS_TO_PLAIN && (g[n.options.discriminator.property] = n.options.discriminator.subTypes.find(function(Y) {
+                return Y.value === g.constructor;
+              }).name);
+            } else
+              S = n;
+            var k = f.transform(O, g, S, void 0, g instanceof Map, a + 1);
+            l instanceof Set ? l.add(k) : l.push(k);
+          } else
+            f.transformationType === b.CLASS_TO_CLASS && (l instanceof Set ? l.add(g) : l.push(g));
+        }), l;
+      } else {
+        if (n === String && !u)
+          return t == null ? t : String(t);
+        if (n === Number && !u)
+          return t == null ? t : Number(t);
+        if (n === Boolean && !u)
+          return t == null ? t : !!t;
+        if ((n === Date || t instanceof Date) && !u)
+          return t instanceof Date ? new Date(t.valueOf()) : t == null ? t : new Date(t);
+        if (Pt().Buffer && (n === Buffer || t instanceof Buffer) && !u)
+          return t == null ? t : Buffer.from(t);
+        if (kt(t) && !u)
+          return new Promise(function(g, I) {
+            t.then(function(O) {
+              return g(f.transform(void 0, O, n, void 0, void 0, a + 1));
+            }, I);
+          });
+        if (!u && t !== null && typeof t == "object" && typeof t.then == "function")
+          return t;
+        if (typeof t == "object" && t !== null) {
+          !n && t.constructor !== Object && (!Array.isArray(t) && t.constructor === Array || (n = t.constructor)), !n && e && (n = e.constructor), this.options.enableCircularCheck && this.recursionStack.add(t);
+          var v = this.getKeys(n, t, u), p = e || {};
+          !e && (this.transformationType === b.PLAIN_TO_CLASS || this.transformationType === b.CLASS_TO_CLASS) && (u ? p = /* @__PURE__ */ new Map() : n ? p = new n() : p = {});
+          for (var m = function(g) {
+            if (g === "__proto__" || g === "constructor")
+              return "continue";
+            var I = g, O = g, S = g;
+            if (!h.options.ignoreDecorators && n) {
+              if (h.transformationType === b.PLAIN_TO_CLASS) {
+                var W = F.findExposeMetadataByCustomName(n, g);
+                W && (S = W.propertyName, O = W.propertyName);
+              } else if (h.transformationType === b.CLASS_TO_PLAIN || h.transformationType === b.CLASS_TO_CLASS) {
+                var W = F.findExposeMetadata(n, g);
+                W && W.options && W.options.name && (O = W.options.name);
+              }
+            }
+            var C = void 0;
+            h.transformationType === b.PLAIN_TO_CLASS ? C = t[I] : t instanceof Map ? C = t.get(I) : t[I] instanceof Function ? C = t[I]() : C = t[I];
+            var k = void 0, Y = C instanceof Map;
+            if (n && u)
+              k = n;
+            else if (n) {
+              var T = F.findTypeMetadata(n, S);
+              if (T) {
+                var Se = { newObject: p, object: t, property: S }, de = T.typeFunction ? T.typeFunction(Se) : T.reflectedType;
+                T.options && T.options.discriminator && T.options.discriminator.property && T.options.discriminator.subTypes ? t[I] instanceof Array ? k = T : (h.transformationType === b.PLAIN_TO_CLASS && (k = T.options.discriminator.subTypes.find(function(q) {
+                  if (C && C instanceof Object && T.options.discriminator.property in C)
+                    return q.name === C[T.options.discriminator.property];
+                }), k === void 0 ? k = de : k = k.value, T.options.keepDiscriminatorProperty || C && C instanceof Object && T.options.discriminator.property in C && delete C[T.options.discriminator.property]), h.transformationType === b.CLASS_TO_CLASS && (k = C.constructor), h.transformationType === b.CLASS_TO_PLAIN && C && (C[T.options.discriminator.property] = T.options.discriminator.subTypes.find(function(q) {
+                  return q.value === C.constructor;
+                }).name)) : k = de, Y = Y || T.reflectedType === Map;
+              } else if (h.options.targetMaps)
+                h.options.targetMaps.filter(function(q) {
+                  return q.target === n && !!q.properties[S];
+                }).forEach(function(q) {
+                  return k = q.properties[S];
+                });
+              else if (h.options.enableImplicitConversion && h.transformationType === b.PLAIN_TO_CLASS) {
+                var he = Reflect.getMetadata("design:type", n.prototype, S);
+                he && (k = he);
+              }
+            }
+            var K = Array.isArray(t[I]) ? h.getReflectedType(n, S) : void 0, ue = e ? e[I] : void 0;
+            if (p.constructor.prototype) {
+              var ne = Object.getOwnPropertyDescriptor(p.constructor.prototype, O);
+              if ((h.transformationType === b.PLAIN_TO_CLASS || h.transformationType === b.CLASS_TO_CLASS) && // eslint-disable-next-line @typescript-eslint/unbound-method
+              (ne && !ne.set || p[O] instanceof Function))
+                return "continue";
+            }
+            if (!h.options.enableCircularCheck || !h.isCircular(C)) {
+              var te = h.transformationType === b.PLAIN_TO_CLASS ? O : g, L = void 0;
+              h.transformationType === b.CLASS_TO_PLAIN ? (L = t[te], L = h.applyCustomTransformations(L, n, te, t, h.transformationType), L = t[te] === L ? C : L, L = h.transform(ue, L, k, K, Y, a + 1)) : C === void 0 && h.options.exposeDefaultValues ? L = p[O] : (L = h.transform(ue, C, k, K, Y, a + 1), L = h.applyCustomTransformations(L, n, te, t, h.transformationType)), (L !== void 0 || h.options.exposeUnsetFields) && (p instanceof Map ? p.set(O, L) : p[O] = L);
+            } else if (h.transformationType === b.CLASS_TO_CLASS) {
+              var L = C;
+              L = h.applyCustomTransformations(L, n, g, t, h.transformationType), (L !== void 0 || h.options.exposeUnsetFields) && (p instanceof Map ? p.set(O, L) : p[O] = L);
+            }
+          }, h = this, R = 0, E = v; R < E.length; R++) {
+            var $ = E[R];
+            m($);
+          }
+          return this.options.enableCircularCheck && this.recursionStack.delete(t), p;
+        } else
+          return t;
+      }
+    }, r.prototype.applyCustomTransformations = function(e, t, n, i, u) {
+      var a = this, f = F.findTransformMetadatas(t, n, this.transformationType);
+      return this.options.version !== void 0 && (f = f.filter(function(l) {
+        return l.options ? a.checkVersion(l.options.since, l.options.until) : !0;
+      })), this.options.groups && this.options.groups.length ? f = f.filter(function(l) {
+        return l.options ? a.checkGroups(l.options.groups) : !0;
+      }) : f = f.filter(function(l) {
+        return !l.options || !l.options.groups || !l.options.groups.length;
+      }), f.forEach(function(l) {
+        e = l.transformFn({ value: e, key: n, obj: i, type: u, options: a.options });
+      }), e;
+    }, r.prototype.isCircular = function(e) {
+      return this.recursionStack.has(e);
+    }, r.prototype.getReflectedType = function(e, t) {
+      if (e) {
+        var n = F.findTypeMetadata(e, t);
+        return n ? n.reflectedType : void 0;
+      }
+    }, r.prototype.getKeys = function(e, t, n) {
+      var i = this, u = F.getStrategy(e);
+      u === "none" && (u = this.options.strategy || "exposeAll");
+      var a = [];
+      if ((u === "exposeAll" || n) && (t instanceof Map ? a = Array.from(t.keys()) : a = Object.keys(t)), n)
+        return a;
+      if (this.options.ignoreDecorators && this.options.excludeExtraneousValues && e) {
+        var f = F.getExposedProperties(e, this.transformationType), l = F.getExcludedProperties(e, this.transformationType);
+        a = rt(rt([], f, !0), l, !0);
+      }
+      if (!this.options.ignoreDecorators && e) {
+        var f = F.getExposedProperties(e, this.transformationType);
+        this.transformationType === b.PLAIN_TO_CLASS && (f = f.map(function(m) {
+          var h = F.findExposeMetadata(e, m);
+          return h && h.options && h.options.name ? h.options.name : m;
+        })), this.options.excludeExtraneousValues ? a = f : a = a.concat(f);
+        var v = F.getExcludedProperties(e, this.transformationType);
+        v.length > 0 && (a = a.filter(function(m) {
+          return !v.includes(m);
+        })), this.options.version !== void 0 && (a = a.filter(function(m) {
+          var h = F.findExposeMetadata(e, m);
+          return !h || !h.options ? !0 : i.checkVersion(h.options.since, h.options.until);
+        })), this.options.groups && this.options.groups.length ? a = a.filter(function(m) {
+          var h = F.findExposeMetadata(e, m);
+          return !h || !h.options ? !0 : i.checkGroups(h.options.groups);
+        }) : a = a.filter(function(m) {
+          var h = F.findExposeMetadata(e, m);
+          return !h || !h.options || !h.options.groups || !h.options.groups.length;
+        });
+      }
+      return this.options.excludePrefixes && this.options.excludePrefixes.length && (a = a.filter(function(p) {
+        return i.options.excludePrefixes.every(function(m) {
+          return p.substr(0, m.length) !== m;
+        });
+      })), a = a.filter(function(p, m, h) {
+        return h.indexOf(p) === m;
+      }), a;
+    }, r.prototype.checkVersion = function(e, t) {
+      var n = !0;
+      return n && e && (n = this.options.version >= e), n && t && (n = this.options.version < t), n;
+    }, r.prototype.checkGroups = function(e) {
+      return e ? this.options.groups.some(function(t) {
+        return e.includes(t);
+      }) : !0;
+    }, r;
+  }()
+), oe = {
+  enableCircularCheck: !1,
+  enableImplicitConversion: !1,
+  excludeExtraneousValues: !1,
+  excludePrefixes: void 0,
+  exposeDefaultValues: !1,
+  exposeUnsetFields: !0,
+  groups: void 0,
+  ignoreDecorators: !1,
+  strategy: void 0,
+  targetMaps: void 0,
+  version: void 0
+}, G = globalThis && globalThis.__assign || function() {
+  return G = Object.assign || function(r) {
+    for (var e, t = 1, n = arguments.length; t < n; t++) {
+      e = arguments[t];
+      for (var i in e)
+        Object.prototype.hasOwnProperty.call(e, i) && (r[i] = e[i]);
+    }
+    return r;
+  }, G.apply(this, arguments);
+}, Bt = (
+  /** @class */
+  function() {
+    function r() {
+    }
+    return r.prototype.instanceToPlain = function(e, t) {
+      var n = new ie(b.CLASS_TO_PLAIN, G(G({}, oe), t));
+      return n.transform(void 0, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.classToPlainFromExist = function(e, t, n) {
+      var i = new ie(b.CLASS_TO_PLAIN, G(G({}, oe), n));
+      return i.transform(t, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.plainToInstance = function(e, t, n) {
+      var i = new ie(b.PLAIN_TO_CLASS, G(G({}, oe), n));
+      return i.transform(void 0, t, e, void 0, void 0, void 0);
+    }, r.prototype.plainToClassFromExist = function(e, t, n) {
+      var i = new ie(b.PLAIN_TO_CLASS, G(G({}, oe), n));
+      return i.transform(e, t, void 0, void 0, void 0, void 0);
+    }, r.prototype.instanceToInstance = function(e, t) {
+      var n = new ie(b.CLASS_TO_CLASS, G(G({}, oe), t));
+      return n.transform(void 0, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.classToClassFromExist = function(e, t, n) {
+      var i = new ie(b.CLASS_TO_CLASS, G(G({}, oe), n));
+      return i.transform(t, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.serialize = function(e, t) {
+      return JSON.stringify(this.instanceToPlain(e, t));
+    }, r.prototype.deserialize = function(e, t, n) {
+      var i = JSON.parse(t);
+      return this.plainToInstance(e, i, n);
+    }, r.prototype.deserializeArray = function(e, t, n) {
+      var i = JSON.parse(t);
+      return this.plainToInstance(e, i, n);
+    }, r;
+  }()
+);
+function Oe(r, e) {
+  return e === void 0 && (e = {}), function(t, n) {
+    var i = Reflect.getMetadata("design:type", t, n);
+    F.addTypeMetadata({
+      target: t.constructor,
+      propertyName: n,
+      reflectedType: i,
+      typeFunction: r,
+      options: e
+    });
+  };
+}
+var ut = new Bt();
+function $t(r, e) {
+  return ut.instanceToPlain(r, e);
+}
+function Ft(r, e, t) {
+  return ut.plainToInstance(r, e, t);
+}
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var st;
+(function(r) {
+  (function(e) {
+    var t = typeof nt == "object" ? nt : typeof self == "object" ? self : typeof this == "object" ? this : Function("return this;")(), n = i(r);
+    typeof t.Reflect > "u" ? t.Reflect = r : n = i(t.Reflect, n), e(n);
+    function i(u, a) {
+      return function(f, l) {
+        typeof u[f] != "function" && Object.defineProperty(u, f, { configurable: !0, writable: !0, value: l }), a && a(f, l);
+      };
+    }
+  })(function(e) {
+    var t = Object.prototype.hasOwnProperty, n = typeof Symbol == "function", i = n && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", u = n && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", a = typeof Object.create == "function", f = { __proto__: [] } instanceof Array, l = !a && !f, v = {
+      // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+      create: a ? function() {
+        return be(/* @__PURE__ */ Object.create(null));
+      } : f ? function() {
+        return be({ __proto__: null });
+      } : function() {
+        return be({});
+      },
+      has: l ? function(s, o) {
+        return t.call(s, o);
+      } : function(s, o) {
+        return o in s;
+      },
+      get: l ? function(s, o) {
+        return t.call(s, o) ? s[o] : void 0;
+      } : function(s, o) {
+        return s[o];
+      }
+    }, p = Object.getPrototypeOf(Function), m = typeof process == "object" && process.env && process.env.REFLECT_METADATA_USE_MAP_POLYFILL === "true", h = !m && typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : Et(), R = !m && typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : Ot(), E = !m && typeof WeakMap == "function" ? WeakMap : Lt(), $ = new E();
+    function g(s, o, c, d) {
+      if (N(c)) {
+        if (!Ke(s))
+          throw new TypeError();
+        if (!Ve(o))
+          throw new TypeError();
+        return de(s, o);
+      } else {
+        if (!Ke(s))
+          throw new TypeError();
+        if (!j(o))
+          throw new TypeError();
+        if (!j(d) && !N(d) && !re(d))
+          throw new TypeError();
+        return re(d) && (d = void 0), c = Z(c), he(s, o, c, d);
+      }
+    }
+    e("decorate", g);
+    function I(s, o) {
+      function c(d, y) {
+        if (!j(d))
+          throw new TypeError();
+        if (!N(y) && !Mt(y))
+          throw new TypeError();
+        q(s, o, d, y);
+      }
+      return c;
+    }
+    e("metadata", I);
+    function O(s, o, c, d) {
+      if (!j(c))
+        throw new TypeError();
+      return N(d) || (d = Z(d)), q(s, o, c, d);
+    }
+    e("defineMetadata", O);
+    function S(s, o, c) {
+      if (!j(o))
+        throw new TypeError();
+      return N(c) || (c = Z(c)), ue(s, o, c);
+    }
+    e("hasMetadata", S);
+    function W(s, o, c) {
+      if (!j(o))
+        throw new TypeError();
+      return N(c) || (c = Z(c)), ne(s, o, c);
+    }
+    e("hasOwnMetadata", W);
+    function C(s, o, c) {
+      if (!j(o))
+        throw new TypeError();
+      return N(c) || (c = Z(c)), te(s, o, c);
+    }
+    e("getMetadata", C);
+    function k(s, o, c) {
+      if (!j(o))
+        throw new TypeError();
+      return N(c) || (c = Z(c)), L(s, o, c);
+    }
+    e("getOwnMetadata", k);
+    function Y(s, o) {
+      if (!j(s))
+        throw new TypeError();
+      return N(o) || (o = Z(o)), Xe(s, o);
+    }
+    e("getMetadataKeys", Y);
+    function T(s, o) {
+      if (!j(s))
+        throw new TypeError();
+      return N(o) || (o = Z(o)), Ze(s, o);
+    }
+    e("getOwnMetadataKeys", T);
+    function Se(s, o, c) {
+      if (!j(o))
+        throw new TypeError();
+      N(c) || (c = Z(c));
+      var d = K(
+        o,
+        c,
+        /*Create*/
+        !1
+      );
+      if (N(d) || !d.delete(s))
+        return !1;
+      if (d.size > 0)
+        return !0;
+      var y = $.get(o);
+      return y.delete(c), y.size > 0 || $.delete(o), !0;
+    }
+    e("deleteMetadata", Se);
+    function de(s, o) {
+      for (var c = s.length - 1; c >= 0; --c) {
+        var d = s[c], y = d(o);
+        if (!N(y) && !re(y)) {
+          if (!Ve(y))
+            throw new TypeError();
+          o = y;
+        }
+      }
+      return o;
+    }
+    function he(s, o, c, d) {
+      for (var y = s.length - 1; y >= 0; --y) {
+        var B = s[y], _ = B(o, c, d);
+        if (!N(_) && !re(_)) {
+          if (!j(_))
+            throw new TypeError();
+          d = _;
+        }
+      }
+      return d;
+    }
+    function K(s, o, c) {
+      var d = $.get(s);
+      if (N(d)) {
+        if (!c)
+          return;
+        d = new h(), $.set(s, d);
+      }
+      var y = d.get(o);
+      if (N(y)) {
+        if (!c)
+          return;
+        y = new h(), d.set(o, y);
+      }
+      return y;
+    }
+    function ue(s, o, c) {
+      var d = ne(s, o, c);
+      if (d)
+        return !0;
+      var y = Me(o);
+      return re(y) ? !1 : ue(s, y, c);
+    }
+    function ne(s, o, c) {
+      var d = K(
+        o,
+        c,
+        /*Create*/
+        !1
+      );
+      return N(d) ? !1 : _t(d.has(s));
+    }
+    function te(s, o, c) {
+      var d = ne(s, o, c);
+      if (d)
+        return L(s, o, c);
+      var y = Me(o);
+      if (!re(y))
+        return te(s, y, c);
+    }
+    function L(s, o, c) {
+      var d = K(
+        o,
+        c,
+        /*Create*/
+        !1
+      );
+      if (!N(d))
+        return d.get(s);
+    }
+    function q(s, o, c, d) {
+      var y = K(
+        c,
+        d,
+        /*Create*/
+        !0
+      );
+      y.set(s, o);
+    }
+    function Xe(s, o) {
+      var c = Ze(s, o), d = Me(s);
+      if (d === null)
+        return c;
+      var y = Xe(d, o);
+      if (y.length <= 0)
+        return c;
+      if (c.length <= 0)
+        return y;
+      for (var B = new R(), _ = [], M = 0, w = c; M < w.length; M++) {
+        var x = w[M], A = B.has(x);
+        A || (B.add(x), _.push(x));
+      }
+      for (var V = 0, tt = y; V < tt.length; V++) {
+        var x = tt[V], A = B.has(x);
+        A || (B.add(x), _.push(x));
+      }
+      return _;
+    }
+    function Ze(s, o) {
+      var c = [], d = K(
+        s,
+        o,
+        /*Create*/
+        !1
+      );
+      if (N(d))
+        return c;
+      for (var y = d.keys(), B = bt(y), _ = 0; ; ) {
+        var M = xt(B);
+        if (!M)
+          return c.length = _, c;
+        var w = Ct(M);
+        try {
+          c[_] = w;
+        } catch (x) {
+          try {
+            At(B);
+          } finally {
+            throw x;
+          }
+        }
+        _++;
+      }
+    }
+    function Qe(s) {
+      if (s === null)
+        return 1;
+      switch (typeof s) {
+        case "undefined":
+          return 0;
+        case "boolean":
+          return 2;
+        case "string":
+          return 3;
+        case "symbol":
+          return 4;
+        case "number":
+          return 5;
+        case "object":
+          return s === null ? 1 : 6;
+        default:
+          return 6;
+      }
+    }
+    function N(s) {
+      return s === void 0;
+    }
+    function re(s) {
+      return s === null;
+    }
+    function yt(s) {
+      return typeof s == "symbol";
+    }
+    function j(s) {
+      return typeof s == "object" ? s !== null : typeof s == "function";
+    }
+    function vt(s, o) {
+      switch (Qe(s)) {
+        case 0:
+          return s;
+        case 1:
+          return s;
+        case 2:
+          return s;
+        case 3:
+          return s;
+        case 4:
+          return s;
+        case 5:
+          return s;
+      }
+      var c = o === 3 ? "string" : o === 5 ? "number" : "default", d = et(s, i);
+      if (d !== void 0) {
+        var y = d.call(s, c);
+        if (j(y))
+          throw new TypeError();
+        return y;
+      }
+      return wt(s, c === "default" ? "number" : c);
+    }
+    function wt(s, o) {
+      if (o === "string") {
+        var c = s.toString;
+        if (se(c)) {
+          var d = c.call(s);
+          if (!j(d))
+            return d;
+        }
+        var y = s.valueOf;
+        if (se(y)) {
+          var d = y.call(s);
+          if (!j(d))
+            return d;
+        }
+      } else {
+        var y = s.valueOf;
+        if (se(y)) {
+          var d = y.call(s);
+          if (!j(d))
+            return d;
+        }
+        var B = s.toString;
+        if (se(B)) {
+          var d = B.call(s);
+          if (!j(d))
+            return d;
+        }
+      }
+      throw new TypeError();
+    }
+    function _t(s) {
+      return !!s;
+    }
+    function St(s) {
+      return "" + s;
+    }
+    function Z(s) {
+      var o = vt(
+        s,
+        3
+        /* String */
+      );
+      return yt(o) ? o : St(o);
+    }
+    function Ke(s) {
+      return Array.isArray ? Array.isArray(s) : s instanceof Object ? s instanceof Array : Object.prototype.toString.call(s) === "[object Array]";
+    }
+    function se(s) {
+      return typeof s == "function";
+    }
+    function Ve(s) {
+      return typeof s == "function";
+    }
+    function Mt(s) {
+      switch (Qe(s)) {
+        case 3:
+          return !0;
+        case 4:
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function et(s, o) {
+      var c = s[o];
+      if (c != null) {
+        if (!se(c))
+          throw new TypeError();
+        return c;
+      }
+    }
+    function bt(s) {
+      var o = et(s, u);
+      if (!se(o))
+        throw new TypeError();
+      var c = o.call(s);
+      if (!j(c))
+        throw new TypeError();
+      return c;
+    }
+    function Ct(s) {
+      return s.value;
+    }
+    function xt(s) {
+      var o = s.next();
+      return o.done ? !1 : o;
+    }
+    function At(s) {
+      var o = s.return;
+      o && o.call(s);
+    }
+    function Me(s) {
+      var o = Object.getPrototypeOf(s);
+      if (typeof s != "function" || s === p || o !== p)
+        return o;
+      var c = s.prototype, d = c && Object.getPrototypeOf(c);
+      if (d == null || d === Object.prototype)
+        return o;
+      var y = d.constructor;
+      return typeof y != "function" || y === s ? o : y;
+    }
+    function Et() {
+      var s = {}, o = [], c = (
+        /** @class */
+        function() {
+          function _(M, w, x) {
+            this._index = 0, this._keys = M, this._values = w, this._selector = x;
+          }
+          return _.prototype["@@iterator"] = function() {
+            return this;
+          }, _.prototype[u] = function() {
+            return this;
+          }, _.prototype.next = function() {
+            var M = this._index;
+            if (M >= 0 && M < this._keys.length) {
+              var w = this._selector(this._keys[M], this._values[M]);
+              return M + 1 >= this._keys.length ? (this._index = -1, this._keys = o, this._values = o) : this._index++, { value: w, done: !1 };
+            }
+            return { value: void 0, done: !0 };
+          }, _.prototype.throw = function(M) {
+            throw this._index >= 0 && (this._index = -1, this._keys = o, this._values = o), M;
+          }, _.prototype.return = function(M) {
+            return this._index >= 0 && (this._index = -1, this._keys = o, this._values = o), { value: M, done: !0 };
+          }, _;
+        }()
+      );
+      return (
+        /** @class */
+        function() {
+          function _() {
+            this._keys = [], this._values = [], this._cacheKey = s, this._cacheIndex = -2;
+          }
+          return Object.defineProperty(_.prototype, "size", {
+            get: function() {
+              return this._keys.length;
+            },
+            enumerable: !0,
+            configurable: !0
+          }), _.prototype.has = function(M) {
+            return this._find(
+              M,
+              /*insert*/
+              !1
+            ) >= 0;
+          }, _.prototype.get = function(M) {
+            var w = this._find(
+              M,
+              /*insert*/
+              !1
+            );
+            return w >= 0 ? this._values[w] : void 0;
+          }, _.prototype.set = function(M, w) {
+            var x = this._find(
+              M,
+              /*insert*/
+              !0
+            );
+            return this._values[x] = w, this;
+          }, _.prototype.delete = function(M) {
+            var w = this._find(
+              M,
+              /*insert*/
+              !1
+            );
+            if (w >= 0) {
+              for (var x = this._keys.length, A = w + 1; A < x; A++)
+                this._keys[A - 1] = this._keys[A], this._values[A - 1] = this._values[A];
+              return this._keys.length--, this._values.length--, M === this._cacheKey && (this._cacheKey = s, this._cacheIndex = -2), !0;
+            }
+            return !1;
+          }, _.prototype.clear = function() {
+            this._keys.length = 0, this._values.length = 0, this._cacheKey = s, this._cacheIndex = -2;
+          }, _.prototype.keys = function() {
+            return new c(this._keys, this._values, d);
+          }, _.prototype.values = function() {
+            return new c(this._keys, this._values, y);
+          }, _.prototype.entries = function() {
+            return new c(this._keys, this._values, B);
+          }, _.prototype["@@iterator"] = function() {
+            return this.entries();
+          }, _.prototype[u] = function() {
+            return this.entries();
+          }, _.prototype._find = function(M, w) {
+            return this._cacheKey !== M && (this._cacheIndex = this._keys.indexOf(this._cacheKey = M)), this._cacheIndex < 0 && w && (this._cacheIndex = this._keys.length, this._keys.push(M), this._values.push(void 0)), this._cacheIndex;
+          }, _;
+        }()
+      );
+      function d(_, M) {
+        return _;
+      }
+      function y(_, M) {
+        return M;
+      }
+      function B(_, M) {
+        return [_, M];
+      }
+    }
+    function Ot() {
+      return (
+        /** @class */
+        function() {
+          function s() {
+            this._map = new h();
+          }
+          return Object.defineProperty(s.prototype, "size", {
+            get: function() {
+              return this._map.size;
+            },
+            enumerable: !0,
+            configurable: !0
+          }), s.prototype.has = function(o) {
+            return this._map.has(o);
+          }, s.prototype.add = function(o) {
+            return this._map.set(o, o), this;
+          }, s.prototype.delete = function(o) {
+            return this._map.delete(o);
+          }, s.prototype.clear = function() {
+            this._map.clear();
+          }, s.prototype.keys = function() {
+            return this._map.keys();
+          }, s.prototype.values = function() {
+            return this._map.values();
+          }, s.prototype.entries = function() {
+            return this._map.entries();
+          }, s.prototype["@@iterator"] = function() {
+            return this.keys();
+          }, s.prototype[u] = function() {
+            return this.keys();
+          }, s;
+        }()
+      );
+    }
+    function Lt() {
+      var s = 16, o = v.create(), c = d();
+      return (
+        /** @class */
+        function() {
+          function w() {
+            this._key = d();
+          }
+          return w.prototype.has = function(x) {
+            var A = y(
+              x,
+              /*create*/
+              !1
+            );
+            return A !== void 0 ? v.has(A, this._key) : !1;
+          }, w.prototype.get = function(x) {
+            var A = y(
+              x,
+              /*create*/
+              !1
+            );
+            return A !== void 0 ? v.get(A, this._key) : void 0;
+          }, w.prototype.set = function(x, A) {
+            var V = y(
+              x,
+              /*create*/
+              !0
+            );
+            return V[this._key] = A, this;
+          }, w.prototype.delete = function(x) {
+            var A = y(
+              x,
+              /*create*/
+              !1
+            );
+            return A !== void 0 ? delete A[this._key] : !1;
+          }, w.prototype.clear = function() {
+            this._key = d();
+          }, w;
+        }()
+      );
+      function d() {
+        var w;
+        do
+          w = "@@WeakMap@@" + M();
+        while (v.has(o, w));
+        return o[w] = !0, w;
+      }
+      function y(w, x) {
+        if (!t.call(w, c)) {
+          if (!x)
+            return;
+          Object.defineProperty(w, c, { value: v.create() });
+        }
+        return w[c];
+      }
+      function B(w, x) {
+        for (var A = 0; A < x; ++A)
+          w[A] = Math.random() * 255 | 0;
+        return w;
+      }
+      function _(w) {
+        return typeof Uint8Array == "function" ? typeof crypto < "u" ? crypto.getRandomValues(new Uint8Array(w)) : typeof msCrypto < "u" ? msCrypto.getRandomValues(new Uint8Array(w)) : B(new Uint8Array(w), w) : B(new Array(w), w);
+      }
+      function M() {
+        var w = _(s);
+        w[6] = w[6] & 79 | 64, w[8] = w[8] & 191 | 128;
+        for (var x = "", A = 0; A < s; ++A) {
+          var V = w[A];
+          (A === 4 || A === 6 || A === 8) && (x += "-"), V < 16 && (x += "0"), x += V.toString(16).toLowerCase();
+        }
+        return x;
+      }
+    }
+    function be(s) {
+      return s.__ = void 0, delete s.__, s;
+    }
+  });
+})(st || (st = {}));
+var Ut = Object.defineProperty, Wt = Object.getOwnPropertyDescriptor, Le = (r, e, t, n) => {
+  for (var i = n > 1 ? void 0 : n ? Wt(e, t) : e, u = r.length - 1, a; u >= 0; u--)
+    (a = r[u]) && (i = (n ? a(e, t, i) : a(i)) || i);
+  return n && i && Ut(e, t, i), i;
+};
+const X = 0, D = 1, Gt = 4294967295, le = 3;
+class Ie {
+  constructor(e) {
+    Object.assign(this, e);
+  }
+  update() {
+    var e, t, n, i, u;
+    (e = this.ScalarCmd) == null || e.forEach((a, f) => a.Index = f), (t = this.RotateCmd) == null || t.forEach((a, f) => a.Index = f), (n = this.LinearCmd) == null || n.forEach((a, f) => a.Index = f), (i = this.SensorReadCmd) == null || i.forEach((a, f) => a.Index = f), (u = this.SensorSubscribeCmd) == null || u.forEach((a, f) => a.Index = f);
+  }
+}
+var ae = /* @__PURE__ */ ((r) => (r.Unknown = "Unknown", r.Vibrate = "Vibrate", r.Rotate = "Rotate", r.Oscillate = "Oscillate", r.Constrict = "Constrict", r.Inflate = "Inflate", r.Position = "Position", r))(ae || {}), ee = /* @__PURE__ */ ((r) => (r.Unknown = "Unknown", r.Battery = "Battery", r.RSSI = "RSSI", r.Button = "Button", r.Pressure = "Pressure", r))(ee || {});
+class zt {
+  constructor(e) {
+    this.Index = 0, Object.assign(this, e);
+  }
+}
+class Jt {
+  constructor(e) {
+    this.Endpoints = e;
+  }
+}
+class qt {
+  constructor(e) {
+    this.Index = 0, Object.assign(this, e);
+  }
+}
+class H {
+  constructor(e) {
+    this.Id = e;
+  }
+  // tslint:disable-next-line:ban-types
+  get Type() {
+    return this.constructor;
+  }
+  toJSON() {
+    return JSON.stringify(this.toProtocolFormat());
+  }
+  toProtocolFormat() {
+    const e = {};
+    return e[this.constructor.Name] = $t(this), e;
+  }
+  update() {
+  }
+}
+class J extends H {
+  constructor(e, t) {
+    super(t), this.DeviceIndex = e, this.Id = t;
+  }
+}
+class ce extends H {
+  constructor(e = X) {
+    super(e), this.Id = e;
+  }
+}
+class ve extends ce {
+  constructor(e = D) {
+    super(e), this.Id = e;
+  }
+}
+ve.Name = "Ok";
+class ft extends H {
+  constructor(e = D) {
+    super(e), this.Id = e;
+  }
+}
+ft.Name = "Ping";
+var z = /* @__PURE__ */ ((r) => (r[r.ERROR_UNKNOWN = 0] = "ERROR_UNKNOWN", r[r.ERROR_INIT = 1] = "ERROR_INIT", r[r.ERROR_PING = 2] = "ERROR_PING", r[r.ERROR_MSG = 3] = "ERROR_MSG", r[r.ERROR_DEVICE = 4] = "ERROR_DEVICE", r))(z || {});
+let Q = class extends H {
+  constructor(e, t = 0, n = D) {
+    super(n), this.ErrorMessage = e, this.ErrorCode = t, this.Id = n;
+  }
+  get Schemversion() {
+    return 0;
+  }
+};
+Q.Name = "Error";
+class Re {
+  constructor(e) {
+    Object.assign(this, e);
+  }
+}
+Le([
+  Oe(() => Ie)
+], Re.prototype, "DeviceMessages", 2);
+class De extends H {
+  constructor(e, t = D) {
+    super(t), this.Devices = e, this.Id = t;
+  }
+  update() {
+    for (const e of this.Devices)
+      e.DeviceMessages.update();
+  }
+}
+De.Name = "DeviceList";
+Le([
+  Oe(() => Re)
+], De.prototype, "Devices", 2);
+class we extends ce {
+  constructor(e) {
+    super(), Object.assign(this, e);
+  }
+  update() {
+    this.DeviceMessages.update();
+  }
+}
+we.Name = "DeviceAdded";
+Le([
+  Oe(() => Ie)
+], we.prototype, "DeviceMessages", 2);
+class Te extends ce {
+  constructor(e) {
+    super(), this.DeviceIndex = e;
+  }
+}
+Te.Name = "DeviceRemoved";
+class Ne extends H {
+  constructor(e = D) {
+    super(e), this.Id = e;
+  }
+}
+Ne.Name = "RequestDeviceList";
+class Pe extends H {
+  constructor(e = D) {
+    super(e), this.Id = e;
+  }
+}
+Pe.Name = "StartScanning";
+class ke extends H {
+  constructor(e = D) {
+    super(e), this.Id = e;
+  }
+}
+ke.Name = "StopScanning";
+class je extends ce {
+  constructor() {
+    super();
+  }
+}
+je.Name = "ScanningFinished";
+class Be extends H {
+  constructor(e, t = 0, n = D) {
+    super(n), this.ClientName = e, this.MessageVersion = t, this.Id = n;
+  }
+}
+Be.Name = "RequestServerInfo";
+class $e extends ce {
+  constructor(e, t, n, i = D) {
+    super(), this.MessageVersion = e, this.MaxPingTime = t, this.ServerName = n, this.Id = i;
+  }
+}
+$e.Name = "ServerInfo";
+class Fe extends J {
+  constructor(e = -1, t = D) {
+    super(e, t), this.DeviceIndex = e, this.Id = t;
+  }
+}
+Fe.Name = "StopDeviceCmd";
+class Ue extends H {
+  constructor(e = D) {
+    super(e), this.Id = e;
+  }
+}
+Ue.Name = "StopAllDevices";
+class _e {
+  constructor(e) {
+    this.Index = e;
+  }
+}
+class Ce extends _e {
+  constructor(e, t, n) {
+    super(e), this.Scalar = t, this.ActuatorType = n;
+  }
+}
+class ge extends J {
+  constructor(e, t = -1, n = D) {
+    super(t, n), this.Scalars = e, this.DeviceIndex = t, this.Id = n;
+  }
+}
+ge.Name = "ScalarCmd";
+class dt extends _e {
+  constructor(e, t, n) {
+    super(e), this.Speed = t, this.Clockwise = n;
+  }
+}
+const ht = class pt extends J {
+  constructor(e, t = -1, n = D) {
+    super(t, n), this.Rotations = e, this.DeviceIndex = t, this.Id = n;
+  }
+  static Create(e, t) {
+    const n = new Array();
+    let i = 0;
+    for (const [u, a] of t)
+      n.push(new dt(i, u, a)), ++i;
+    return new pt(n, e);
+  }
+};
+ht.Name = "RotateCmd";
+let xe = ht;
+class lt extends _e {
+  constructor(e, t, n) {
+    super(e), this.Position = t, this.Duration = n;
+  }
+}
+const gt = class mt extends J {
+  constructor(e, t = -1, n = D) {
+    super(t, n), this.Vectors = e, this.DeviceIndex = t, this.Id = n;
+  }
+  static Create(e, t) {
+    const n = new Array();
+    let i = 0;
+    for (const u of t)
+      n.push(new lt(i, u[0], u[1])), ++i;
+    return new mt(n, e);
+  }
+};
+gt.Name = "LinearCmd";
+let Ae = gt;
+class We extends J {
+  constructor(e, t, n, i = D) {
+    super(e, i), this.DeviceIndex = e, this.SensorIndex = t, this.SensorType = n, this.Id = i;
+  }
+}
+We.Name = "SensorReadCmd";
+class Ge extends J {
+  constructor(e, t, n, i, u = D) {
+    super(e, u), this.DeviceIndex = e, this.SensorIndex = t, this.SensorType = n, this.Data = i, this.Id = u;
+  }
+}
+Ge.Name = "SensorReading";
+class ze extends J {
+  constructor(e, t, n, i, u = D) {
+    super(e, u), this.DeviceIndex = e, this.Endpoint = t, this.ExpectedLength = n, this.Timeout = i, this.Id = u;
+  }
+}
+ze.Name = "RawReadCmd";
+class Je extends J {
+  constructor(e, t, n, i, u = D) {
+    super(e, u), this.DeviceIndex = e, this.Endpoint = t, this.Data = n, this.WriteWithResponse = i, this.Id = u;
+  }
+}
+Je.Name = "RawWriteCmd";
+class qe extends J {
+  constructor(e, t, n = D) {
+    super(e, n), this.DeviceIndex = e, this.Endpoint = t, this.Id = n;
+  }
+}
+qe.Name = "RawSubscribeCmd";
+class He extends J {
+  constructor(e, t, n = D) {
+    super(e, n), this.DeviceIndex = e, this.Endpoint = t, this.Id = n;
+  }
+}
+He.Name = "RawUnsubscribeCmd";
+class Ye extends J {
+  constructor(e, t, n, i = D) {
+    super(e, i), this.DeviceIndex = e, this.Endpoint = t, this.Data = n, this.Id = i;
+  }
+}
+Ye.Name = "RawReading";
+const Ht = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ActuatorType: ae,
+  ButtplugDeviceMessage: J,
+  ButtplugMessage: H,
+  ButtplugSystemMessage: ce,
+  DEFAULT_MESSAGE_ID: D,
+  DeviceAdded: we,
+  DeviceInfo: Re,
+  DeviceList: De,
+  DeviceRemoved: Te,
+  Error: Q,
+  ErrorClass: z,
+  GenericDeviceMessageAttributes: zt,
+  GenericMessageSubcommand: _e,
+  LinearCmd: Ae,
+  MAX_ID: Gt,
+  MESSAGE_SPEC_VERSION: le,
+  MessageAttributes: Ie,
+  Ok: ve,
+  Ping: ft,
+  RawDeviceMessageAttributes: Jt,
+  RawReadCmd: ze,
+  RawReading: Ye,
+  RawSubscribeCmd: qe,
+  RawUnsubscribeCmd: He,
+  RawWriteCmd: Je,
+  RequestDeviceList: Ne,
+  RequestServerInfo: Be,
+  RotateCmd: xe,
+  RotateSubcommand: dt,
+  SYSTEM_MESSAGE_ID: X,
+  ScalarCmd: ge,
+  ScalarSubcommand: Ce,
+  ScanningFinished: je,
+  SensorDeviceMessageAttributes: qt,
+  SensorReadCmd: We,
+  SensorReading: Ge,
+  SensorType: ee,
+  ServerInfo: $e,
+  StartScanning: Pe,
+  StopAllDevices: Ue,
+  StopDeviceCmd: Fe,
+  StopScanning: ke,
+  VectorSubcommand: lt
+}, Symbol.toStringTag, { value: "Module" }));
+/*!
+ * Buttplug JS Source Code File - Visit https://buttplug.io for more info about
+ * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the
+ * project root for full license information.
+ *
+ * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.
+ */
+class U extends Error {
+  constructor(e, t, n = X, i) {
+    super(e), this.errorClass = z.ERROR_UNKNOWN, this.errorClass = t, this.innerError = i, this.messageId = n;
+  }
+  get ErrorClass() {
+    return this.errorClass;
+  }
+  get InnerError() {
+    return this.innerError;
+  }
+  get Id() {
+    return this.messageId;
+  }
+  get ErrorMessage() {
+    return new Q(this.message, this.ErrorClass, this.Id);
+  }
+  static LogAndError(e, t, n, i = X) {
+    return t.Error(n), new e(n, i);
+  }
+  static FromError(e) {
+    switch (e.ErrorCode) {
+      case z.ERROR_DEVICE:
+        return new P(e.ErrorMessage, e.Id);
+      case z.ERROR_INIT:
+        return new Ee(e.ErrorMessage, e.Id);
+      case z.ERROR_UNKNOWN:
+        return new Xt(e.ErrorMessage, e.Id);
+      case z.ERROR_PING:
+        return new Yt(e.ErrorMessage, e.Id);
+      case z.ERROR_MSG:
+        return new fe(e.ErrorMessage, e.Id);
+      default:
+        throw new Error(`Message type ${e.ErrorCode} not handled`);
+    }
+  }
+}
+class Ee extends U {
+  constructor(e, t = X) {
+    super(e, z.ERROR_INIT, t);
+  }
+}
+class P extends U {
+  constructor(e, t = X) {
+    super(e, z.ERROR_DEVICE, t);
+  }
+}
+class fe extends U {
+  constructor(e, t = X) {
+    super(e, z.ERROR_MSG, t);
+  }
+}
+class Yt extends U {
+  constructor(e, t = X) {
+    super(e, z.ERROR_PING, t);
+  }
+}
+class Xt extends U {
+  constructor(e, t = X) {
+    super(e, z.ERROR_UNKNOWN, t);
+  }
+}
+class me extends ye {
+  /**
+   * @param _index Index of the device, as created by the device manager.
+   * @param _name Name of the device.
+   * @param allowedMsgs Buttplug messages the device can receive.
+   */
+  constructor(e, t) {
+    super(), this._deviceInfo = e, this._sendClosure = t, this.allowedMsgs = /* @__PURE__ */ new Map(), e.DeviceMessages.update();
+  }
+  /**
+   * Return the name of the device.
+   */
+  get name() {
+    return this._deviceInfo.DeviceName;
+  }
+  /**
+   * Return the user set name of the device.
+   */
+  get displayName() {
+    return this._deviceInfo.DeviceDisplayName;
+  }
+  /**
+   * Return the index of the device.
+   */
+  get index() {
+    return this._deviceInfo.DeviceIndex;
+  }
+  /**
+   * Return the index of the device.
+   */
+  get messageTimingGap() {
+    return this._deviceInfo.DeviceMessageTimingGap;
+  }
+  /**
+   * Return a list of message types the device accepts.
+   */
+  get messageAttributes() {
+    return this._deviceInfo.DeviceMessages;
+  }
+  static fromMsg(e, t) {
+    return new me(e, t);
+  }
+  async send(e) {
+    return await this._sendClosure(this, e);
+  }
+  async sendExpectOk(e) {
+    const t = await this.send(e);
+    switch (t.constructor) {
+      case ve:
+        return;
+      case Q:
+        throw U.FromError(t);
+      default:
+        throw new fe(
+          `Message type ${t.constructor} not handled by SendMsgExpectOk`
+        );
+    }
+  }
+  async scalar(e) {
+    Array.isArray(e) ? await this.sendExpectOk(new ge(e, this.index)) : await this.sendExpectOk(new ge([e], this.index));
+  }
+  async scalarCommandBuilder(e, t) {
+    var u;
+    const n = (u = this.messageAttributes.ScalarCmd) == null ? void 0 : u.filter(
+      (a) => a.ActuatorType === t
+    );
+    if (!n || n.length === 0)
+      throw new P(
+        `Device ${this.name} has no ${t} capabilities`
+      );
+    const i = [];
+    if (typeof e == "number")
+      n.forEach(
+        (a) => i.push(new Ce(a.Index, e, t))
+      );
+    else if (Array.isArray(e)) {
+      if (e.length > n.length)
+        throw new P(
+          `${e.length} commands send to a device with ${n.length} vibrators`
+        );
+      n.forEach((a, f) => {
+        i.push(new Ce(a.Index, e[f], t));
+      });
+    } else
+      throw new P(
+        `${t} can only take numbers or arrays of numbers.`
+      );
+    await this.scalar(i);
+  }
+  get vibrateAttributes() {
+    var e;
+    return ((e = this.messageAttributes.ScalarCmd) == null ? void 0 : e.filter(
+      (t) => t.ActuatorType === ae.Vibrate
+    )) ?? [];
+  }
+  async vibrate(e) {
+    await this.scalarCommandBuilder(e, ae.Vibrate);
+  }
+  get oscillateAttributes() {
+    var e;
+    return ((e = this.messageAttributes.ScalarCmd) == null ? void 0 : e.filter(
+      (t) => t.ActuatorType === ae.Oscillate
+    )) ?? [];
+  }
+  async oscillate(e) {
+    await this.scalarCommandBuilder(e, ae.Oscillate);
+  }
+  get rotateAttributes() {
+    return this.messageAttributes.RotateCmd ?? [];
+  }
+  async rotate(e, t) {
+    const n = this.messageAttributes.RotateCmd;
+    if (!n || n.length === 0)
+      throw new P(
+        `Device ${this.name} has no Rotate capabilities`
+      );
+    let i;
+    if (typeof e == "number")
+      i = xe.Create(
+        this.index,
+        new Array(n.length).fill([e, t])
+      );
+    else if (Array.isArray(e))
+      i = xe.Create(this.index, e);
+    else
+      throw new P(
+        "SendRotateCmd can only take a number and boolean, or an array of number/boolean tuples"
+      );
+    await this.sendExpectOk(i);
+  }
+  get linearAttributes() {
+    return this.messageAttributes.LinearCmd ?? [];
+  }
+  async linear(e, t) {
+    const n = this.messageAttributes.LinearCmd;
+    if (!n || n.length === 0)
+      throw new P(
+        `Device ${this.name} has no Linear capabilities`
+      );
+    let i;
+    if (typeof e == "number")
+      i = Ae.Create(
+        this.index,
+        new Array(n.length).fill([e, t])
+      );
+    else if (Array.isArray(e))
+      i = Ae.Create(this.index, e);
+    else
+      throw new P(
+        "SendLinearCmd can only take a number and number, or an array of number/number tuples"
+      );
+    await this.sendExpectOk(i);
+  }
+  async sensorRead(e, t) {
+    const n = await this.send(
+      new We(this.index, e, t)
+    );
+    switch (n.constructor) {
+      case Ge:
+        return n.Data;
+      case Q:
+        throw U.FromError(n);
+      default:
+        throw new fe(
+          `Message type ${n.constructor} not handled by sensorRead`
+        );
+    }
+  }
+  get hasBattery() {
+    var t;
+    const e = (t = this.messageAttributes.SensorReadCmd) == null ? void 0 : t.filter(
+      (n) => n.SensorType === ee.Battery
+    );
+    return e !== void 0 && e.length > 0;
+  }
+  async battery() {
+    var n;
+    if (!this.hasBattery)
+      throw new P(
+        `Device ${this.name} has no Battery capabilities`
+      );
+    const e = (n = this.messageAttributes.SensorReadCmd) == null ? void 0 : n.filter(
+      (i) => i.SensorType === ee.Battery
+    );
+    return (await this.sensorRead(
+      e[0].Index,
+      ee.Battery
+    ))[0] / 100;
+  }
+  get hasRssi() {
+    var t;
+    const e = (t = this.messageAttributes.SensorReadCmd) == null ? void 0 : t.filter(
+      (n) => n.SensorType === ee.RSSI
+    );
+    return e !== void 0 && e.length === 0;
+  }
+  async rssi() {
+    var n;
+    if (!this.hasRssi)
+      throw new P(
+        `Device ${this.name} has no RSSI capabilities`
+      );
+    const e = (n = this.messageAttributes.SensorReadCmd) == null ? void 0 : n.filter(
+      (i) => i.SensorType === ee.RSSI
+    );
+    return (await this.sensorRead(
+      e[0].Index,
+      ee.RSSI
+    ))[0];
+  }
+  async rawRead(e, t, n) {
+    if (!this.messageAttributes.RawReadCmd)
+      throw new P(
+        `Device ${this.name} has no raw read capabilities`
+      );
+    if (this.messageAttributes.RawReadCmd.Endpoints.indexOf(e) === -1)
+      throw new P(
+        `Device ${this.name} has no raw readable endpoint ${e}`
+      );
+    const i = await this.send(
+      new ze(this.index, e, t, n)
+    );
+    switch (i.constructor) {
+      case Ye:
+        return new Uint8Array(i.Data);
+      case Q:
+        throw U.FromError(i);
+      default:
+        throw new fe(
+          `Message type ${i.constructor} not handled by rawRead`
+        );
+    }
+  }
+  async rawWrite(e, t, n) {
+    if (!this.messageAttributes.RawWriteCmd)
+      throw new P(
+        `Device ${this.name} has no raw write capabilities`
+      );
+    if (this.messageAttributes.RawWriteCmd.Endpoints.indexOf(e) === -1)
+      throw new P(
+        `Device ${this.name} has no raw writable endpoint ${e}`
+      );
+    await this.sendExpectOk(
+      new Je(this.index, e, t, n)
+    );
+  }
+  async rawSubscribe(e) {
+    if (!this.messageAttributes.RawSubscribeCmd)
+      throw new P(
+        `Device ${this.name} has no raw subscribe capabilities`
+      );
+    if (this.messageAttributes.RawSubscribeCmd.Endpoints.indexOf(e) === -1)
+      throw new P(
+        `Device ${this.name} has no raw subscribable endpoint ${e}`
+      );
+    await this.sendExpectOk(new qe(this.index, e));
+  }
+  async rawUnsubscribe(e) {
+    if (!this.messageAttributes.RawSubscribeCmd)
+      throw new P(
+        `Device ${this.name} has no raw unsubscribe capabilities`
+      );
+    if (this.messageAttributes.RawSubscribeCmd.Endpoints.indexOf(e) === -1)
+      throw new P(
+        `Device ${this.name} has no raw unsubscribable endpoint ${e}`
+      );
+    await this.sendExpectOk(
+      new He(this.index, e)
+    );
+  }
+  async stop() {
+    await this.sendExpectOk(new Fe(this.index));
+  }
+  emitDisconnected() {
+    this.emit("deviceremoved");
+  }
+}
+/*!
+ * Buttplug JS Source Code File - Visit https://buttplug.io for more info about
+ * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the
+ * project root for full license information.
+ *
+ * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.
+ */
+class Zt {
+  constructor(e) {
+    this._useCounter = e, this._counter = 1, this._waitingMsgs = /* @__PURE__ */ new Map();
+  }
+  // One of the places we should actually return a promise, as we need to store
+  // them while waiting for them to return across the line.
+  // tslint:disable:promise-function-async
+  PrepareOutgoingMessage(e) {
+    this._useCounter && (e.Id = this._counter, this._counter += 1);
+    let t, n;
+    const i = new Promise(
+      (u, a) => {
+        t = u, n = a;
+      }
+    );
+    return this._waitingMsgs.set(e.Id, [t, n]), i;
+  }
+  ParseIncomingMessages(e) {
+    const t = [];
+    for (const n of e)
+      if (n.Id !== X && this._waitingMsgs.has(n.Id)) {
+        const [i, u] = this._waitingMsgs.get(n.Id);
+        if (n.Type === Q) {
+          u(U.FromError(n));
+          continue;
+        }
+        i(n);
+        continue;
+      } else
+        t.push(n);
+    return t;
+  }
+}
+/*!
+ * Buttplug JS Source Code File - Visit https://buttplug.io for more info about
+ * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the
+ * project root for full license information.
+ *
+ * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.
+ */
+class Qt extends U {
+  constructor(e) {
+    super(e, z.ERROR_UNKNOWN);
+  }
+}
+class rn extends ye {
+  constructor(e = "Generic Buttplug Client") {
+    super(), this._pingTimer = null, this._connector = null, this._devices = /* @__PURE__ */ new Map(), this._logger = Tt.Logger, this._isScanning = !1, this._sorter = new Zt(!0), this.connect = async (t) => {
+      this._logger.Info(
+        `ButtplugClient: Connecting using ${t.constructor.name}`
+      ), await t.connect(), this._connector = t, this._connector.addListener("message", this.parseMessages), this._connector.addListener("disconnect", this.disconnectHandler), await this.initializeConnection();
+    }, this.disconnect = async () => {
+      this._logger.Debug("ButtplugClient: Disconnect called"), this.checkConnector(), await this.shutdownConnection(), await this._connector.disconnect();
+    }, this.startScanning = async () => {
+      this._logger.Debug("ButtplugClient: StartScanning called"), this._isScanning = !0, await this.sendMsgExpectOk(new Pe());
+    }, this.stopScanning = async () => {
+      this._logger.Debug("ButtplugClient: StopScanning called"), this._isScanning = !1, await this.sendMsgExpectOk(new ke());
+    }, this.stopAllDevices = async () => {
+      this._logger.Debug("ButtplugClient: StopAllDevices"), await this.sendMsgExpectOk(new Ue());
+    }, this.disconnectHandler = () => {
+      this._logger.Info("ButtplugClient: Disconnect event receieved."), this.emit("disconnect");
+    }, this.parseMessages = (t) => {
+      const n = this._sorter.ParseIncomingMessages(t);
+      for (const i of n)
+        switch (i.constructor) {
+          case we: {
+            const u = i, a = me.fromMsg(
+              u,
+              this.sendDeviceMessageClosure
+            );
+            this._devices.set(u.DeviceIndex, a), this.emit("deviceadded", a);
+            break;
+          }
+          case Te: {
+            const u = i;
+            if (this._devices.has(u.DeviceIndex)) {
+              const a = this._devices.get(u.DeviceIndex);
+              a == null || a.emitDisconnected(), this._devices.delete(u.DeviceIndex), this.emit("deviceremoved", a);
+            }
+            break;
+          }
+          case je:
+            this._isScanning = !1, this.emit("scanningfinished", i);
+            break;
+        }
+    }, this.initializeConnection = async () => {
+      this.checkConnector();
+      const t = await this.sendMessage(
+        new Be(
+          this._clientName,
+          le
+        )
+      );
+      switch (t.constructor) {
+        case $e: {
+          const n = t;
+          if (this._logger.Info(
+            `ButtplugClient: Connected to Server ${n.ServerName}`
+          ), n.MaxPingTime, n.MessageVersion < le)
+            throw await this._connector.disconnect(), U.LogAndError(
+              Ee,
+              this._logger,
+              `Server protocol version ${n.MessageVersion} is older than client protocol version ${le}. Please update server.`
+            );
+          return await this.requestDeviceList(), !0;
+        }
+        case Q: {
+          await this._connector.disconnect();
+          const n = t;
+          throw U.LogAndError(
+            Ee,
+            this._logger,
+            `Cannot connect to server. ${n.ErrorMessage}`
+          );
+        }
+      }
+      return !1;
+    }, this.requestDeviceList = async () => {
+      this.checkConnector(), this._logger.Debug("ButtplugClient: ReceiveDeviceList called"), (await this.sendMessage(
+        new Ne()
+      )).Devices.forEach((n) => {
+        if (this._devices.has(n.DeviceIndex))
+          this._logger.Debug(`ButtplugClient: Device already added: ${n}`);
+        else {
+          const i = me.fromMsg(
+            n,
+            this.sendDeviceMessageClosure
+          );
+          this._logger.Debug(`ButtplugClient: Adding Device: ${i}`), this._devices.set(n.DeviceIndex, i), this.emit("deviceadded", i);
+        }
+      });
+    }, this.shutdownConnection = async () => {
+      await this.stopAllDevices(), this._pingTimer !== null && (clearInterval(this._pingTimer), this._pingTimer = null);
+    }, this.sendMsgExpectOk = async (t) => {
+      const n = await this.sendMessage(t);
+      switch (n.constructor) {
+        case ve:
+          return;
+        case Q:
+          throw U.FromError(n);
+        default:
+          throw U.LogAndError(
+            fe,
+            this._logger,
+            `Message type ${n.constructor} not handled by SendMsgExpectOk`
+          );
+      }
+    }, this.sendDeviceMessageClosure = async (t, n) => await this.sendDeviceMessage(t, n), this._clientName = e, this._logger.Debug(`ButtplugClient: Client ${e} created.`);
+  }
+  get connected() {
+    return this._connector !== null && this._connector.Connected;
+  }
+  get devices() {
+    this.checkConnector();
+    const e = [];
+    return this._devices.forEach((t) => {
+      e.push(t);
+    }), e;
+  }
+  get isScanning() {
+    return this._isScanning;
+  }
+  async sendDeviceMessage(e, t) {
+    if (this.checkConnector(), this._devices.get(e.index) === void 0)
+      throw U.LogAndError(
+        P,
+        this._logger,
+        `Device ${e.index} not available.`
+      );
+    return t.DeviceIndex = e.index, await this.sendMessage(t);
+  }
+  async sendMessage(e) {
+    this.checkConnector();
+    const t = this._sorter.PrepareOutgoingMessage(e);
+    return await this._connector.send(e), await t;
+  }
+  checkConnector() {
+    if (!this.connected)
+      throw new Qt(
+        "ButtplugClient not connected"
+      );
+  }
+}
+function Kt(r) {
+  for (const e of Object.values(Ht))
+    if (typeof e == "function" && "Name" in e && e.Name === r)
+      return e;
+  return null;
+}
+function it(r) {
+  const e = JSON.parse(r), t = [];
+  for (const n of Array.from(e)) {
+    const i = Object.getOwnPropertyNames(n)[0], u = Kt(i);
+    if (u) {
+      const a = Ft(
+        u,
+        n[i]
+      );
+      a.update(), t.push(a);
+    }
+  }
+  return t;
+}
+class Vt extends ye {
+  constructor(e) {
+    super(), this._url = e, this._websocketConstructor = null, this.connect = async () => {
+      const t = new (this._websocketConstructor ?? WebSocket)(this._url);
+      let n, i;
+      const u = new Promise((f, l) => {
+        n = f, i = l;
+      }), a = () => i();
+      return t.addEventListener("open", async () => {
+        this._ws = t;
+        try {
+          await this.initialize(), this._ws.addEventListener("message", (f) => {
+            this.parseIncomingMessage(f);
+          }), this._ws.removeEventListener("close", a), this._ws.addEventListener("close", this.disconnect), n();
+        } catch (f) {
+          console.log(f), i();
+        }
+      }), t.addEventListener("close", a), u;
+    }, this.disconnect = async () => {
+      this.Connected && (this._ws.close(), this._ws = void 0, this.emit("disconnect"));
+    }, this.initialize = async () => Promise.resolve();
+  }
+  get Connected() {
+    return this._ws !== void 0;
+  }
+  sendMessage(e) {
+    if (!this.Connected)
+      throw new Error("ButtplugBrowserWebsocketConnector not connected");
+    this._ws.send("[" + e.toJSON() + "]");
+  }
+  parseIncomingMessage(e) {
+    if (typeof e.data == "string") {
+      const t = it(e.data);
+      this.emit("message", t);
+    } else
+      e.data instanceof Blob;
+  }
+  onReaderLoad(e) {
+    const t = it(e.target.result);
+    this.emit("message", t);
+  }
+}
+class en extends Vt {
+  constructor() {
+    super(...arguments), this.send = (e) => {
+      if (!this.Connected)
+        throw new Error("ButtplugClient not connected");
+      this.sendMessage(e);
+    };
+  }
+}
+var tn = function() {
+  throw new Error(
+    "ws does not work in the browser. Browser clients must use the native WebSocket object"
+  );
+};
+class sn extends en {
+  constructor() {
+    super(...arguments), this._websocketConstructor = tn.WebSocket;
+  }
+}
+export {
+  ae as ActuatorType,
+  en as ButtplugBrowserWebsocketClientConnector,
+  rn as ButtplugClient,
+  Qt as ButtplugClientConnectorException,
+  me as ButtplugClientDevice,
+  P as ButtplugDeviceError,
+  J as ButtplugDeviceMessage,
+  U as ButtplugError,
+  Ee as ButtplugInitError,
+  at as ButtplugLogLevel,
+  Tt as ButtplugLogger,
+  H as ButtplugMessage,
+  fe as ButtplugMessageError,
+  Zt as ButtplugMessageSorter,
+  sn as ButtplugNodeWebsocketClientConnector,
+  Yt as ButtplugPingError,
+  ce as ButtplugSystemMessage,
+  Xt as ButtplugUnknownError,
+  D as DEFAULT_MESSAGE_ID,
+  we as DeviceAdded,
+  Re as DeviceInfo,
+  De as DeviceList,
+  Te as DeviceRemoved,
+  Q as Error,
+  z as ErrorClass,
+  zt as GenericDeviceMessageAttributes,
+  _e as GenericMessageSubcommand,
+  Ae as LinearCmd,
+  Dt as LogMessage,
+  Gt as MAX_ID,
+  le as MESSAGE_SPEC_VERSION,
+  Ie as MessageAttributes,
+  ve as Ok,
+  ft as Ping,
+  Jt as RawDeviceMessageAttributes,
+  ze as RawReadCmd,
+  Ye as RawReading,
+  qe as RawSubscribeCmd,
+  He as RawUnsubscribeCmd,
+  Je as RawWriteCmd,
+  Ne as RequestDeviceList,
+  Be as RequestServerInfo,
+  xe as RotateCmd,
+  dt as RotateSubcommand,
+  X as SYSTEM_MESSAGE_ID,
+  ge as ScalarCmd,
+  Ce as ScalarSubcommand,
+  je as ScanningFinished,
+  qt as SensorDeviceMessageAttributes,
+  We as SensorReadCmd,
+  Ge as SensorReading,
+  ee as SensorType,
+  $e as ServerInfo,
+  Pe as StartScanning,
+  Ue as StopAllDevices,
+  Fe as StopDeviceCmd,
+  ke as StopScanning,
+  lt as VectorSubcommand,
+  it as fromJSON
+};