@asgard-js/core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1626 @@
+var qe = Object.defineProperty;
+var Ve = (t, n, e) => n in t ? qe(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var E = (t, n, e) => Ve(t, typeof n != "symbol" ? n + "" : n, e);
+var C = /* @__PURE__ */ ((t) => (t.RESET_CHANNEL = "RESET_CHANNEL", t.NONE = "NONE", t))(C || {}), Ye = /* @__PURE__ */ ((t) => (t.INIT = "asgard.run.init", t.MESSAGE_START = "asgard.message.start", t.MESSAGE_DELTA = "asgard.message.delta", t.MESSAGE_COMPLETE = "asgard.message.complete", t.DONE = "asgard.run.done", t))(Ye || {}), Be = /* @__PURE__ */ ((t) => (t.TEXT = "TEXT", t.HINT = "HINT", t.BUTTON = "BUTTON", t.IMAGE = "IMAGE", t.VIDEO = "VIDEO", t.AUDIO = "AUDIO", t.LOCATION = "LOCATION", t.CAROUSEL = "CAROUSEL", t))(Be || {});
+function Ke(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var J = { exports: {} }, I = typeof Reflect == "object" ? Reflect : null, Z = I && typeof I.apply == "function" ? I.apply : function(n, e, r) {
+  return Function.prototype.apply.call(n, e, r);
+}, U;
+I && typeof I.ownKeys == "function" ? U = I.ownKeys : Object.getOwnPropertySymbols ? U = function(n) {
+  return Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n));
+} : U = function(n) {
+  return Object.getOwnPropertyNames(n);
+};
+function ze(t) {
+  console && console.warn && console.warn(t);
+}
+var le = Number.isNaN || function(n) {
+  return n !== n;
+};
+function d() {
+  d.init.call(this);
+}
+J.exports = d;
+J.exports.once = Ze;
+d.EventEmitter = d;
+d.prototype._events = void 0;
+d.prototype._eventsCount = 0;
+d.prototype._maxListeners = void 0;
+var ee = 10;
+function G(t) {
+  if (typeof t != "function")
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof t);
+}
+Object.defineProperty(d, "defaultMaxListeners", {
+  enumerable: !0,
+  get: function() {
+    return ee;
+  },
+  set: function(t) {
+    if (typeof t != "number" || t < 0 || le(t))
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + t + ".");
+    ee = t;
+  }
+});
+d.init = function() {
+  (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+};
+d.prototype.setMaxListeners = function(n) {
+  if (typeof n != "number" || n < 0 || le(n))
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+  return this._maxListeners = n, this;
+};
+function de(t) {
+  return t._maxListeners === void 0 ? d.defaultMaxListeners : t._maxListeners;
+}
+d.prototype.getMaxListeners = function() {
+  return de(this);
+};
+d.prototype.emit = function(n) {
+  for (var e = [], r = 1; r < arguments.length; r++) e.push(arguments[r]);
+  var i = n === "error", o = this._events;
+  if (o !== void 0)
+    i = i && o.error === void 0;
+  else if (!i)
+    return !1;
+  if (i) {
+    var u;
+    if (e.length > 0 && (u = e[0]), u instanceof Error)
+      throw u;
+    var s = new Error("Unhandled error." + (u ? " (" + u.message + ")" : ""));
+    throw s.context = u, s;
+  }
+  var f = o[n];
+  if (f === void 0)
+    return !1;
+  if (typeof f == "function")
+    Z(f, this, e);
+  else
+    for (var a = f.length, l = be(f, a), r = 0; r < a; ++r)
+      Z(l[r], this, e);
+  return !0;
+};
+function he(t, n, e, r) {
+  var i, o, u;
+  if (G(e), o = t._events, o === void 0 ? (o = t._events = /* @__PURE__ */ Object.create(null), t._eventsCount = 0) : (o.newListener !== void 0 && (t.emit(
+    "newListener",
+    n,
+    e.listener ? e.listener : e
+  ), o = t._events), u = o[n]), u === void 0)
+    u = o[n] = e, ++t._eventsCount;
+  else if (typeof u == "function" ? u = o[n] = r ? [e, u] : [u, e] : r ? u.unshift(e) : u.push(e), i = de(t), i > 0 && u.length > i && !u.warned) {
+    u.warned = !0;
+    var s = new Error("Possible EventEmitter memory leak detected. " + u.length + " " + String(n) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+    s.name = "MaxListenersExceededWarning", s.emitter = t, s.type = n, s.count = u.length, ze(s);
+  }
+  return t;
+}
+d.prototype.addListener = function(n, e) {
+  return he(this, n, e, !1);
+};
+d.prototype.on = d.prototype.addListener;
+d.prototype.prependListener = function(n, e) {
+  return he(this, n, e, !0);
+};
+function Je() {
+  if (!this.fired)
+    return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+}
+function ve(t, n, e) {
+  var r = { fired: !1, wrapFn: void 0, target: t, type: n, listener: e }, i = Je.bind(r);
+  return i.listener = e, r.wrapFn = i, i;
+}
+d.prototype.once = function(n, e) {
+  return G(e), this.on(n, ve(this, n, e)), this;
+};
+d.prototype.prependOnceListener = function(n, e) {
+  return G(e), this.prependListener(n, ve(this, n, e)), this;
+};
+d.prototype.removeListener = function(n, e) {
+  var r, i, o, u, s;
+  if (G(e), i = this._events, i === void 0)
+    return this;
+  if (r = i[n], r === void 0)
+    return this;
+  if (r === e || r.listener === e)
+    --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i[n], i.removeListener && this.emit("removeListener", n, r.listener || e));
+  else if (typeof r != "function") {
+    for (o = -1, u = r.length - 1; u >= 0; u--)
+      if (r[u] === e || r[u].listener === e) {
+        s = r[u].listener, o = u;
+        break;
+      }
+    if (o < 0)
+      return this;
+    o === 0 ? r.shift() : Xe(r, o), r.length === 1 && (i[n] = r[0]), i.removeListener !== void 0 && this.emit("removeListener", n, s || e);
+  }
+  return this;
+};
+d.prototype.off = d.prototype.removeListener;
+d.prototype.removeAllListeners = function(n) {
+  var e, r, i;
+  if (r = this._events, r === void 0)
+    return this;
+  if (r.removeListener === void 0)
+    return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : r[n] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete r[n]), this;
+  if (arguments.length === 0) {
+    var o = Object.keys(r), u;
+    for (i = 0; i < o.length; ++i)
+      u = o[i], u !== "removeListener" && this.removeAllListeners(u);
+    return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+  }
+  if (e = r[n], typeof e == "function")
+    this.removeListener(n, e);
+  else if (e !== void 0)
+    for (i = e.length - 1; i >= 0; i--)
+      this.removeListener(n, e[i]);
+  return this;
+};
+function pe(t, n, e) {
+  var r = t._events;
+  if (r === void 0)
+    return [];
+  var i = r[n];
+  return i === void 0 ? [] : typeof i == "function" ? e ? [i.listener || i] : [i] : e ? Qe(i) : be(i, i.length);
+}
+d.prototype.listeners = function(n) {
+  return pe(this, n, !0);
+};
+d.prototype.rawListeners = function(n) {
+  return pe(this, n, !1);
+};
+d.listenerCount = function(t, n) {
+  return typeof t.listenerCount == "function" ? t.listenerCount(n) : ye.call(t, n);
+};
+d.prototype.listenerCount = ye;
+function ye(t) {
+  var n = this._events;
+  if (n !== void 0) {
+    var e = n[t];
+    if (typeof e == "function")
+      return 1;
+    if (e !== void 0)
+      return e.length;
+  }
+  return 0;
+}
+d.prototype.eventNames = function() {
+  return this._eventsCount > 0 ? U(this._events) : [];
+};
+function be(t, n) {
+  for (var e = new Array(n), r = 0; r < n; ++r)
+    e[r] = t[r];
+  return e;
+}
+function Xe(t, n) {
+  for (; n + 1 < t.length; n++)
+    t[n] = t[n + 1];
+  t.pop();
+}
+function Qe(t) {
+  for (var n = new Array(t.length), e = 0; e < n.length; ++e)
+    n[e] = t[e].listener || t[e];
+  return n;
+}
+function Ze(t, n) {
+  return new Promise(function(e, r) {
+    function i(u) {
+      t.removeListener(n, o), r(u);
+    }
+    function o() {
+      typeof t.removeListener == "function" && t.removeListener("error", i), e([].slice.call(arguments));
+    }
+    me(t, n, o, { once: !0 }), n !== "error" && et(t, i, { once: !0 });
+  });
+}
+function et(t, n, e) {
+  typeof t.on == "function" && me(t, "error", n, e);
+}
+function me(t, n, e, r) {
+  if (typeof t.on == "function")
+    r.once ? t.once(n, e) : t.on(n, e);
+  else if (typeof t.addEventListener == "function")
+    t.addEventListener(n, function i(o) {
+      r.once && t.removeEventListener(n, i), e(o);
+    });
+  else
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof t);
+}
+var tt = J.exports;
+const nt = /* @__PURE__ */ Ke(tt);
+var Y = function(t, n) {
+  return Y = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, r) {
+    e.__proto__ = r;
+  } || function(e, r) {
+    for (var i in r) Object.prototype.hasOwnProperty.call(r, i) && (e[i] = r[i]);
+  }, Y(t, n);
+};
+function S(t, n) {
+  if (typeof n != "function" && n !== null)
+    throw new TypeError("Class extends value " + String(n) + " is not a constructor or null");
+  Y(t, n);
+  function e() {
+    this.constructor = t;
+  }
+  t.prototype = n === null ? Object.create(n) : (e.prototype = n.prototype, new e());
+}
+function rt(t, n, e, r) {
+  function i(o) {
+    return o instanceof e ? o : new e(function(u) {
+      u(o);
+    });
+  }
+  return new (e || (e = Promise))(function(o, u) {
+    function s(l) {
+      try {
+        a(r.next(l));
+      } catch (y) {
+        u(y);
+      }
+    }
+    function f(l) {
+      try {
+        a(r.throw(l));
+      } catch (y) {
+        u(y);
+      }
+    }
+    function a(l) {
+      l.done ? o(l.value) : i(l.value).then(s, f);
+    }
+    a((r = r.apply(t, n || [])).next());
+  });
+}
+function we(t, n) {
+  var e = { label: 0, sent: function() {
+    if (o[0] & 1) throw o[1];
+    return o[1];
+  }, trys: [], ops: [] }, r, i, o, u = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return u.next = s(0), u.throw = s(1), u.return = s(2), typeof Symbol == "function" && (u[Symbol.iterator] = function() {
+    return this;
+  }), u;
+  function s(a) {
+    return function(l) {
+      return f([a, l]);
+    };
+  }
+  function f(a) {
+    if (r) throw new TypeError("Generator is already executing.");
+    for (; u && (u = 0, a[0] && (e = 0)), e; ) try {
+      if (r = 1, i && (o = a[0] & 2 ? i.return : a[0] ? i.throw || ((o = i.return) && o.call(i), 0) : i.next) && !(o = o.call(i, a[1])).done) return o;
+      switch (i = 0, o && (a = [a[0] & 2, o.value]), a[0]) {
+        case 0:
+        case 1:
+          o = a;
+          break;
+        case 4:
+          return e.label++, { value: a[1], done: !1 };
+        case 5:
+          e.label++, i = a[1], a = [0];
+          continue;
+        case 7:
+          a = e.ops.pop(), e.trys.pop();
+          continue;
+        default:
+          if (o = e.trys, !(o = o.length > 0 && o[o.length - 1]) && (a[0] === 6 || a[0] === 2)) {
+            e = 0;
+            continue;
+          }
+          if (a[0] === 3 && (!o || a[1] > o[0] && a[1] < o[3])) {
+            e.label = a[1];
+            break;
+          }
+          if (a[0] === 6 && e.label < o[1]) {
+            e.label = o[1], o = a;
+            break;
+          }
+          if (o && e.label < o[2]) {
+            e.label = o[2], e.ops.push(a);
+            break;
+          }
+          o[2] && e.ops.pop(), e.trys.pop();
+          continue;
+      }
+      a = n.call(t, e);
+    } catch (l) {
+      a = [6, l], i = 0;
+    } finally {
+      r = o = 0;
+    }
+    if (a[0] & 5) throw a[1];
+    return { value: a[0] ? a[1] : void 0, done: !0 };
+  }
+}
+function T(t) {
+  var n = typeof Symbol == "function" && Symbol.iterator, e = n && t[n], r = 0;
+  if (e) return e.call(t);
+  if (t && typeof t.length == "number") return {
+    next: function() {
+      return t && r >= t.length && (t = void 0), { value: t && t[r++], done: !t };
+    }
+  };
+  throw new TypeError(n ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function $(t, n) {
+  var e = typeof Symbol == "function" && t[Symbol.iterator];
+  if (!e) return t;
+  var r = e.call(t), i, o = [], u;
+  try {
+    for (; (n === void 0 || n-- > 0) && !(i = r.next()).done; ) o.push(i.value);
+  } catch (s) {
+    u = { error: s };
+  } finally {
+    try {
+      i && !i.done && (e = r.return) && e.call(r);
+    } finally {
+      if (u) throw u.error;
+    }
+  }
+  return o;
+}
+function D(t, n, e) {
+  if (e || arguments.length === 2) for (var r = 0, i = n.length, o; r < i; r++)
+    (o || !(r in n)) && (o || (o = Array.prototype.slice.call(n, 0, r)), o[r] = n[r]);
+  return t.concat(o || Array.prototype.slice.call(n));
+}
+function k(t) {
+  return this instanceof k ? (this.v = t, this) : new k(t);
+}
+function it(t, n, e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var r = e.apply(t, n || []), i, o = [];
+  return i = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), s("next"), s("throw"), s("return", u), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function u(c) {
+    return function(p) {
+      return Promise.resolve(p).then(c, y);
+    };
+  }
+  function s(c, p) {
+    r[c] && (i[c] = function(h) {
+      return new Promise(function(O, w) {
+        o.push([c, h, O, w]) > 1 || f(c, h);
+      });
+    }, p && (i[c] = p(i[c])));
+  }
+  function f(c, p) {
+    try {
+      a(r[c](p));
+    } catch (h) {
+      m(o[0][3], h);
+    }
+  }
+  function a(c) {
+    c.value instanceof k ? Promise.resolve(c.value.v).then(l, y) : m(o[0][2], c);
+  }
+  function l(c) {
+    f("next", c);
+  }
+  function y(c) {
+    f("throw", c);
+  }
+  function m(c, p) {
+    c(p), o.shift(), o.length && f(o[0][0], o[0][1]);
+  }
+}
+function ot(t) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = t[Symbol.asyncIterator], e;
+  return n ? n.call(t) : (t = typeof T == "function" ? T(t) : t[Symbol.iterator](), e = {}, r("next"), r("throw"), r("return"), e[Symbol.asyncIterator] = function() {
+    return this;
+  }, e);
+  function r(o) {
+    e[o] = t[o] && function(u) {
+      return new Promise(function(s, f) {
+        u = t[o](u), i(s, f, u.done, u.value);
+      });
+    };
+  }
+  function i(o, u, s, f) {
+    Promise.resolve(f).then(function(a) {
+      o({ value: a, done: s });
+    }, u);
+  }
+}
+function v(t) {
+  return typeof t == "function";
+}
+function ge(t) {
+  var n = function(r) {
+    Error.call(r), r.stack = new Error().stack;
+  }, e = t(n);
+  return e.prototype = Object.create(Error.prototype), e.prototype.constructor = e, e;
+}
+var V = ge(function(t) {
+  return function(e) {
+    t(this), this.message = e ? e.length + ` errors occurred during unsubscription:
+` + e.map(function(r, i) {
+      return i + 1 + ") " + r.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = e;
+  };
+});
+function F(t, n) {
+  if (t) {
+    var e = t.indexOf(n);
+    0 <= e && t.splice(e, 1);
+  }
+}
+var N = function() {
+  function t(n) {
+    this.initialTeardown = n, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return t.prototype.unsubscribe = function() {
+    var n, e, r, i, o;
+    if (!this.closed) {
+      this.closed = !0;
+      var u = this._parentage;
+      if (u)
+        if (this._parentage = null, Array.isArray(u))
+          try {
+            for (var s = T(u), f = s.next(); !f.done; f = s.next()) {
+              var a = f.value;
+              a.remove(this);
+            }
+          } catch (h) {
+            n = { error: h };
+          } finally {
+            try {
+              f && !f.done && (e = s.return) && e.call(s);
+            } finally {
+              if (n) throw n.error;
+            }
+          }
+        else
+          u.remove(this);
+      var l = this.initialTeardown;
+      if (v(l))
+        try {
+          l();
+        } catch (h) {
+          o = h instanceof V ? h.errors : [h];
+        }
+      var y = this._finalizers;
+      if (y) {
+        this._finalizers = null;
+        try {
+          for (var m = T(y), c = m.next(); !c.done; c = m.next()) {
+            var p = c.value;
+            try {
+              te(p);
+            } catch (h) {
+              o = o ?? [], h instanceof V ? o = D(D([], $(o)), $(h.errors)) : o.push(h);
+            }
+          }
+        } catch (h) {
+          r = { error: h };
+        } finally {
+          try {
+            c && !c.done && (i = m.return) && i.call(m);
+          } finally {
+            if (r) throw r.error;
+          }
+        }
+      }
+      if (o)
+        throw new V(o);
+    }
+  }, t.prototype.add = function(n) {
+    var e;
+    if (n && n !== this)
+      if (this.closed)
+        te(n);
+      else {
+        if (n instanceof t) {
+          if (n.closed || n._hasParent(this))
+            return;
+          n._addParent(this);
+        }
+        (this._finalizers = (e = this._finalizers) !== null && e !== void 0 ? e : []).push(n);
+      }
+  }, t.prototype._hasParent = function(n) {
+    var e = this._parentage;
+    return e === n || Array.isArray(e) && e.includes(n);
+  }, t.prototype._addParent = function(n) {
+    var e = this._parentage;
+    this._parentage = Array.isArray(e) ? (e.push(n), e) : e ? [e, n] : n;
+  }, t.prototype._removeParent = function(n) {
+    var e = this._parentage;
+    e === n ? this._parentage = null : Array.isArray(e) && F(e, n);
+  }, t.prototype.remove = function(n) {
+    var e = this._finalizers;
+    e && F(e, n), n instanceof t && n._removeParent(this);
+  }, t.EMPTY = function() {
+    var n = new t();
+    return n.closed = !0, n;
+  }(), t;
+}(), Ee = N.EMPTY;
+function Se(t) {
+  return t instanceof N || t && "closed" in t && v(t.remove) && v(t.add) && v(t.unsubscribe);
+}
+function te(t) {
+  v(t) ? t() : t.unsubscribe();
+}
+var ut = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, Oe = {
+  setTimeout: function(t, n) {
+    for (var e = [], r = 2; r < arguments.length; r++)
+      e[r - 2] = arguments[r];
+    return setTimeout.apply(void 0, D([t, n], $(e)));
+  },
+  clearTimeout: function(t) {
+    var n = Oe.delegate;
+    return ((n == null ? void 0 : n.clearTimeout) || clearTimeout)(t);
+  },
+  delegate: void 0
+};
+function _e(t) {
+  Oe.setTimeout(function() {
+    throw t;
+  });
+}
+function B() {
+}
+function M(t) {
+  t();
+}
+var X = function(t) {
+  S(n, t);
+  function n(e) {
+    var r = t.call(this) || this;
+    return r.isStopped = !1, e ? (r.destination = e, Se(e) && e.add(r)) : r.destination = ft, r;
+  }
+  return n.create = function(e, r, i) {
+    return new K(e, r, i);
+  }, n.prototype.next = function(e) {
+    this.isStopped || this._next(e);
+  }, n.prototype.error = function(e) {
+    this.isStopped || (this.isStopped = !0, this._error(e));
+  }, n.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, n.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, t.prototype.unsubscribe.call(this), this.destination = null);
+  }, n.prototype._next = function(e) {
+    this.destination.next(e);
+  }, n.prototype._error = function(e) {
+    try {
+      this.destination.error(e);
+    } finally {
+      this.unsubscribe();
+    }
+  }, n.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, n;
+}(N), st = function() {
+  function t(n) {
+    this.partialObserver = n;
+  }
+  return t.prototype.next = function(n) {
+    var e = this.partialObserver;
+    if (e.next)
+      try {
+        e.next(n);
+      } catch (r) {
+        R(r);
+      }
+  }, t.prototype.error = function(n) {
+    var e = this.partialObserver;
+    if (e.error)
+      try {
+        e.error(n);
+      } catch (r) {
+        R(r);
+      }
+    else
+      R(n);
+  }, t.prototype.complete = function() {
+    var n = this.partialObserver;
+    if (n.complete)
+      try {
+        n.complete();
+      } catch (e) {
+        R(e);
+      }
+  }, t;
+}(), K = function(t) {
+  S(n, t);
+  function n(e, r, i) {
+    var o = t.call(this) || this, u;
+    return v(e) || !e ? u = {
+      next: e ?? void 0,
+      error: r ?? void 0,
+      complete: i ?? void 0
+    } : u = e, o.destination = new st(u), o;
+  }
+  return n;
+}(X);
+function R(t) {
+  _e(t);
+}
+function at(t) {
+  throw t;
+}
+var ft = {
+  closed: !0,
+  next: B,
+  error: at,
+  complete: B
+}, Q = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function ct(t) {
+  return t;
+}
+function lt(t) {
+  return t.length === 0 ? ct : t.length === 1 ? t[0] : function(e) {
+    return t.reduce(function(r, i) {
+      return i(r);
+    }, e);
+  };
+}
+var b = function() {
+  function t(n) {
+    n && (this._subscribe = n);
+  }
+  return t.prototype.lift = function(n) {
+    var e = new t();
+    return e.source = this, e.operator = n, e;
+  }, t.prototype.subscribe = function(n, e, r) {
+    var i = this, o = ht(n) ? n : new K(n, e, r);
+    return M(function() {
+      var u = i, s = u.operator, f = u.source;
+      o.add(s ? s.call(o, f) : f ? i._subscribe(o) : i._trySubscribe(o));
+    }), o;
+  }, t.prototype._trySubscribe = function(n) {
+    try {
+      return this._subscribe(n);
+    } catch (e) {
+      n.error(e);
+    }
+  }, t.prototype.forEach = function(n, e) {
+    var r = this;
+    return e = ne(e), new e(function(i, o) {
+      var u = new K({
+        next: function(s) {
+          try {
+            n(s);
+          } catch (f) {
+            o(f), u.unsubscribe();
+          }
+        },
+        error: o,
+        complete: i
+      });
+      r.subscribe(u);
+    });
+  }, t.prototype._subscribe = function(n) {
+    var e;
+    return (e = this.source) === null || e === void 0 ? void 0 : e.subscribe(n);
+  }, t.prototype[Q] = function() {
+    return this;
+  }, t.prototype.pipe = function() {
+    for (var n = [], e = 0; e < arguments.length; e++)
+      n[e] = arguments[e];
+    return lt(n)(this);
+  }, t.prototype.toPromise = function(n) {
+    var e = this;
+    return n = ne(n), new n(function(r, i) {
+      var o;
+      e.subscribe(function(u) {
+        return o = u;
+      }, function(u) {
+        return i(u);
+      }, function() {
+        return r(o);
+      });
+    });
+  }, t.create = function(n) {
+    return new t(n);
+  }, t;
+}();
+function ne(t) {
+  var n;
+  return (n = t ?? ut.Promise) !== null && n !== void 0 ? n : Promise;
+}
+function dt(t) {
+  return t && v(t.next) && v(t.error) && v(t.complete);
+}
+function ht(t) {
+  return t && t instanceof X || dt(t) && Se(t);
+}
+function vt(t) {
+  return v(t == null ? void 0 : t.lift);
+}
+function L(t) {
+  return function(n) {
+    if (vt(n))
+      return n.lift(function(e) {
+        try {
+          return t(e, this);
+        } catch (r) {
+          this.error(r);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function P(t, n, e, r, i) {
+  return new pt(t, n, e, r, i);
+}
+var pt = function(t) {
+  S(n, t);
+  function n(e, r, i, o, u, s) {
+    var f = t.call(this, e) || this;
+    return f.onFinalize = u, f.shouldUnsubscribe = s, f._next = r ? function(a) {
+      try {
+        r(a);
+      } catch (l) {
+        e.error(l);
+      }
+    } : t.prototype._next, f._error = o ? function(a) {
+      try {
+        o(a);
+      } catch (l) {
+        e.error(l);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._error, f._complete = i ? function() {
+      try {
+        i();
+      } catch (a) {
+        e.error(a);
+      } finally {
+        this.unsubscribe();
+      }
+    } : t.prototype._complete, f;
+  }
+  return n.prototype.unsubscribe = function() {
+    var e;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var r = this.closed;
+      t.prototype.unsubscribe.call(this), !r && ((e = this.onFinalize) === null || e === void 0 || e.call(this));
+    }
+  }, n;
+}(X), yt = ge(function(t) {
+  return function() {
+    t(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), xe = function(t) {
+  S(n, t);
+  function n() {
+    var e = t.call(this) || this;
+    return e.closed = !1, e.currentObservers = null, e.observers = [], e.isStopped = !1, e.hasError = !1, e.thrownError = null, e;
+  }
+  return n.prototype.lift = function(e) {
+    var r = new re(this, this);
+    return r.operator = e, r;
+  }, n.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new yt();
+  }, n.prototype.next = function(e) {
+    var r = this;
+    M(function() {
+      var i, o;
+      if (r._throwIfClosed(), !r.isStopped) {
+        r.currentObservers || (r.currentObservers = Array.from(r.observers));
+        try {
+          for (var u = T(r.currentObservers), s = u.next(); !s.done; s = u.next()) {
+            var f = s.value;
+            f.next(e);
+          }
+        } catch (a) {
+          i = { error: a };
+        } finally {
+          try {
+            s && !s.done && (o = u.return) && o.call(u);
+          } finally {
+            if (i) throw i.error;
+          }
+        }
+      }
+    });
+  }, n.prototype.error = function(e) {
+    var r = this;
+    M(function() {
+      if (r._throwIfClosed(), !r.isStopped) {
+        r.hasError = r.isStopped = !0, r.thrownError = e;
+        for (var i = r.observers; i.length; )
+          i.shift().error(e);
+      }
+    });
+  }, n.prototype.complete = function() {
+    var e = this;
+    M(function() {
+      if (e._throwIfClosed(), !e.isStopped) {
+        e.isStopped = !0;
+        for (var r = e.observers; r.length; )
+          r.shift().complete();
+      }
+    });
+  }, n.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(n.prototype, "observed", {
+    get: function() {
+      var e;
+      return ((e = this.observers) === null || e === void 0 ? void 0 : e.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), n.prototype._trySubscribe = function(e) {
+    return this._throwIfClosed(), t.prototype._trySubscribe.call(this, e);
+  }, n.prototype._subscribe = function(e) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(e), this._innerSubscribe(e);
+  }, n.prototype._innerSubscribe = function(e) {
+    var r = this, i = this, o = i.hasError, u = i.isStopped, s = i.observers;
+    return o || u ? Ee : (this.currentObservers = null, s.push(e), new N(function() {
+      r.currentObservers = null, F(s, e);
+    }));
+  }, n.prototype._checkFinalizedStatuses = function(e) {
+    var r = this, i = r.hasError, o = r.thrownError, u = r.isStopped;
+    i ? e.error(o) : u && e.complete();
+  }, n.prototype.asObservable = function() {
+    var e = new b();
+    return e.source = this, e;
+  }, n.create = function(e, r) {
+    return new re(e, r);
+  }, n;
+}(b), re = function(t) {
+  S(n, t);
+  function n(e, r) {
+    var i = t.call(this) || this;
+    return i.destination = e, i.source = r, i;
+  }
+  return n.prototype.next = function(e) {
+    var r, i;
+    (i = (r = this.destination) === null || r === void 0 ? void 0 : r.next) === null || i === void 0 || i.call(r, e);
+  }, n.prototype.error = function(e) {
+    var r, i;
+    (i = (r = this.destination) === null || r === void 0 ? void 0 : r.error) === null || i === void 0 || i.call(r, e);
+  }, n.prototype.complete = function() {
+    var e, r;
+    (r = (e = this.destination) === null || e === void 0 ? void 0 : e.complete) === null || r === void 0 || r.call(e);
+  }, n.prototype._subscribe = function(e) {
+    var r, i;
+    return (i = (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(e)) !== null && i !== void 0 ? i : Ee;
+  }, n;
+}(xe), bt = {
+  now: function() {
+    return Date.now();
+  },
+  delegate: void 0
+}, mt = function(t) {
+  S(n, t);
+  function n(e, r) {
+    return t.call(this) || this;
+  }
+  return n.prototype.schedule = function(e, r) {
+    return this;
+  }, n;
+}(N), ie = {
+  setInterval: function(t, n) {
+    for (var e = [], r = 2; r < arguments.length; r++)
+      e[r - 2] = arguments[r];
+    return setInterval.apply(void 0, D([t, n], $(e)));
+  },
+  clearInterval: function(t) {
+    return clearInterval(t);
+  },
+  delegate: void 0
+}, wt = function(t) {
+  S(n, t);
+  function n(e, r) {
+    var i = t.call(this, e, r) || this;
+    return i.scheduler = e, i.work = r, i.pending = !1, i;
+  }
+  return n.prototype.schedule = function(e, r) {
+    var i;
+    if (r === void 0 && (r = 0), this.closed)
+      return this;
+    this.state = e;
+    var o = this.id, u = this.scheduler;
+    return o != null && (this.id = this.recycleAsyncId(u, o, r)), this.pending = !0, this.delay = r, this.id = (i = this.id) !== null && i !== void 0 ? i : this.requestAsyncId(u, this.id, r), this;
+  }, n.prototype.requestAsyncId = function(e, r, i) {
+    return i === void 0 && (i = 0), ie.setInterval(e.flush.bind(e, this), i);
+  }, n.prototype.recycleAsyncId = function(e, r, i) {
+    if (i === void 0 && (i = 0), i != null && this.delay === i && this.pending === !1)
+      return r;
+    r != null && ie.clearInterval(r);
+  }, n.prototype.execute = function(e, r) {
+    if (this.closed)
+      return new Error("executing a cancelled action");
+    this.pending = !1;
+    var i = this._execute(e, r);
+    if (i)
+      return i;
+    this.pending === !1 && this.id != null && (this.id = this.recycleAsyncId(this.scheduler, this.id, null));
+  }, n.prototype._execute = function(e, r) {
+    var i = !1, o;
+    try {
+      this.work(e);
+    } catch (u) {
+      i = !0, o = u || new Error("Scheduled action threw falsy error");
+    }
+    if (i)
+      return this.unsubscribe(), o;
+  }, n.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      var e = this, r = e.id, i = e.scheduler, o = i.actions;
+      this.work = this.state = this.scheduler = null, this.pending = !1, F(o, this), r != null && (this.id = this.recycleAsyncId(i, r, null)), this.delay = null, t.prototype.unsubscribe.call(this);
+    }
+  }, n;
+}(mt), oe = function() {
+  function t(n, e) {
+    e === void 0 && (e = t.now), this.schedulerActionCtor = n, this.now = e;
+  }
+  return t.prototype.schedule = function(n, e, r) {
+    return e === void 0 && (e = 0), new this.schedulerActionCtor(this, n).schedule(r, e);
+  }, t.now = bt.now, t;
+}(), gt = function(t) {
+  S(n, t);
+  function n(e, r) {
+    r === void 0 && (r = oe.now);
+    var i = t.call(this, e, r) || this;
+    return i.actions = [], i._active = !1, i;
+  }
+  return n.prototype.flush = function(e) {
+    var r = this.actions;
+    if (this._active) {
+      r.push(e);
+      return;
+    }
+    var i;
+    this._active = !0;
+    do
+      if (i = e.execute(e.state, e.delay))
+        break;
+    while (e = r.shift());
+    if (this._active = !1, i) {
+      for (; e = r.shift(); )
+        e.unsubscribe();
+      throw i;
+    }
+  }, n;
+}(oe), Le = new gt(wt), Et = Le, St = new b(function(t) {
+  return t.complete();
+});
+function Ae(t) {
+  return t && v(t.schedule);
+}
+function Ot(t) {
+  return t[t.length - 1];
+}
+function _t(t) {
+  return Ae(Ot(t)) ? t.pop() : void 0;
+}
+var Ie = function(t) {
+  return t && typeof t.length == "number" && typeof t != "function";
+};
+function ke(t) {
+  return v(t == null ? void 0 : t.then);
+}
+function Te(t) {
+  return v(t[Q]);
+}
+function Pe(t) {
+  return Symbol.asyncIterator && v(t == null ? void 0 : t[Symbol.asyncIterator]);
+}
+function Ce(t) {
+  return new TypeError("You provided " + (t !== null && typeof t == "object" ? "an invalid object" : "'" + t + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function xt() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var Ne = xt();
+function je(t) {
+  return v(t == null ? void 0 : t[Ne]);
+}
+function Re(t) {
+  return it(this, arguments, function() {
+    var e, r, i, o;
+    return we(this, function(u) {
+      switch (u.label) {
+        case 0:
+          e = t.getReader(), u.label = 1;
+        case 1:
+          u.trys.push([1, , 9, 10]), u.label = 2;
+        case 2:
+          return [4, k(e.read())];
+        case 3:
+          return r = u.sent(), i = r.value, o = r.done, o ? [4, k(void 0)] : [3, 5];
+        case 4:
+          return [2, u.sent()];
+        case 5:
+          return [4, k(i)];
+        case 6:
+          return [4, u.sent()];
+        case 7:
+          return u.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return e.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function Ue(t) {
+  return v(t == null ? void 0 : t.getReader);
+}
+function A(t) {
+  if (t instanceof b)
+    return t;
+  if (t != null) {
+    if (Te(t))
+      return Lt(t);
+    if (Ie(t))
+      return At(t);
+    if (ke(t))
+      return It(t);
+    if (Pe(t))
+      return Me(t);
+    if (je(t))
+      return kt(t);
+    if (Ue(t))
+      return Tt(t);
+  }
+  throw Ce(t);
+}
+function Lt(t) {
+  return new b(function(n) {
+    var e = t[Q]();
+    if (v(e.subscribe))
+      return e.subscribe(n);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function At(t) {
+  return new b(function(n) {
+    for (var e = 0; e < t.length && !n.closed; e++)
+      n.next(t[e]);
+    n.complete();
+  });
+}
+function It(t) {
+  return new b(function(n) {
+    t.then(function(e) {
+      n.closed || (n.next(e), n.complete());
+    }, function(e) {
+      return n.error(e);
+    }).then(null, _e);
+  });
+}
+function kt(t) {
+  return new b(function(n) {
+    var e, r;
+    try {
+      for (var i = T(t), o = i.next(); !o.done; o = i.next()) {
+        var u = o.value;
+        if (n.next(u), n.closed)
+          return;
+      }
+    } catch (s) {
+      e = { error: s };
+    } finally {
+      try {
+        o && !o.done && (r = i.return) && r.call(i);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    n.complete();
+  });
+}
+function Me(t) {
+  return new b(function(n) {
+    Pt(t, n).catch(function(e) {
+      return n.error(e);
+    });
+  });
+}
+function Tt(t) {
+  return Me(Re(t));
+}
+function Pt(t, n) {
+  var e, r, i, o;
+  return rt(this, void 0, void 0, function() {
+    var u, s;
+    return we(this, function(f) {
+      switch (f.label) {
+        case 0:
+          f.trys.push([0, 5, 6, 11]), e = ot(t), f.label = 1;
+        case 1:
+          return [4, e.next()];
+        case 2:
+          if (r = f.sent(), !!r.done) return [3, 4];
+          if (u = r.value, n.next(u), n.closed)
+            return [2];
+          f.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return s = f.sent(), i = { error: s }, [3, 11];
+        case 6:
+          return f.trys.push([6, , 9, 10]), r && !r.done && (o = e.return) ? [4, o.call(e)] : [3, 8];
+        case 7:
+          f.sent(), f.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (i) throw i.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return n.complete(), [2];
+      }
+    });
+  });
+}
+function x(t, n, e, r, i) {
+  r === void 0 && (r = 0), i === void 0 && (i = !1);
+  var o = n.schedule(function() {
+    e(), i ? t.add(this.schedule(null, r)) : this.unsubscribe();
+  }, r);
+  if (t.add(o), !i)
+    return o;
+}
+function $e(t, n) {
+  return n === void 0 && (n = 0), L(function(e, r) {
+    e.subscribe(P(r, function(i) {
+      return x(r, t, function() {
+        return r.next(i);
+      }, n);
+    }, function() {
+      return x(r, t, function() {
+        return r.complete();
+      }, n);
+    }, function(i) {
+      return x(r, t, function() {
+        return r.error(i);
+      }, n);
+    }));
+  });
+}
+function De(t, n) {
+  return n === void 0 && (n = 0), L(function(e, r) {
+    r.add(t.schedule(function() {
+      return e.subscribe(r);
+    }, n));
+  });
+}
+function Ct(t, n) {
+  return A(t).pipe(De(n), $e(n));
+}
+function Nt(t, n) {
+  return A(t).pipe(De(n), $e(n));
+}
+function jt(t, n) {
+  return new b(function(e) {
+    var r = 0;
+    return n.schedule(function() {
+      r === t.length ? e.complete() : (e.next(t[r++]), e.closed || this.schedule());
+    });
+  });
+}
+function Rt(t, n) {
+  return new b(function(e) {
+    var r;
+    return x(e, n, function() {
+      r = t[Ne](), x(e, n, function() {
+        var i, o, u;
+        try {
+          i = r.next(), o = i.value, u = i.done;
+        } catch (s) {
+          e.error(s);
+          return;
+        }
+        u ? e.complete() : e.next(o);
+      }, 0, !0);
+    }), function() {
+      return v(r == null ? void 0 : r.return) && r.return();
+    };
+  });
+}
+function Fe(t, n) {
+  if (!t)
+    throw new Error("Iterable cannot be null");
+  return new b(function(e) {
+    x(e, n, function() {
+      var r = t[Symbol.asyncIterator]();
+      x(e, n, function() {
+        r.next().then(function(i) {
+          i.done ? e.complete() : e.next(i.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function Ut(t, n) {
+  return Fe(Re(t), n);
+}
+function Mt(t, n) {
+  if (t != null) {
+    if (Te(t))
+      return Ct(t, n);
+    if (Ie(t))
+      return jt(t, n);
+    if (ke(t))
+      return Nt(t, n);
+    if (Pe(t))
+      return Fe(t, n);
+    if (je(t))
+      return Rt(t, n);
+    if (Ue(t))
+      return Ut(t, n);
+  }
+  throw Ce(t);
+}
+function $t(t, n) {
+  return n ? Mt(t, n) : A(t);
+}
+function Dt() {
+  for (var t = [], n = 0; n < arguments.length; n++)
+    t[n] = arguments[n];
+  var e = _t(t);
+  return $t(t, e);
+}
+function Ft(t) {
+  return t instanceof Date && !isNaN(t);
+}
+function He(t, n) {
+  return L(function(e, r) {
+    var i = 0;
+    e.subscribe(P(r, function(o) {
+      r.next(t.call(n, o, i++));
+    }));
+  });
+}
+function Ht(t, n, e, r, i, o, u, s) {
+  var f = [], a = 0, l = 0, y = !1, m = function() {
+    y && !f.length && !a && n.complete();
+  }, c = function(h) {
+    return a < r ? p(h) : f.push(h);
+  }, p = function(h) {
+    a++;
+    var O = !1;
+    A(e(h, l++)).subscribe(P(n, function(w) {
+      n.next(w);
+    }, function() {
+      O = !0;
+    }, void 0, function() {
+      if (O)
+        try {
+          a--;
+          for (var w = function() {
+            var _ = f.shift();
+            u || p(_);
+          }; f.length && a < r; )
+            w();
+          m();
+        } catch (_) {
+          n.error(_);
+        }
+    }));
+  };
+  return t.subscribe(P(n, c, function() {
+    y = !0, m();
+  })), function() {
+  };
+}
+function H(t, n, e) {
+  return e === void 0 && (e = 1 / 0), v(n) ? H(function(r, i) {
+    return He(function(o, u) {
+      return n(r, o, i, u);
+    })(A(t(r, i)));
+  }, e) : (typeof n == "number" && (e = n), L(function(r, i) {
+    return Ht(r, i, t, e);
+  }));
+}
+function Gt(t, n, e) {
+  t === void 0 && (t = 0), e === void 0 && (e = Et);
+  var r = -1;
+  return n != null && (Ae(n) ? e = n : r = n), new b(function(i) {
+    var o = Ft(t) ? +t - e.now() : t;
+    o < 0 && (o = 0);
+    var u = 0;
+    return e.schedule(function() {
+      i.closed || (i.next(u++), 0 <= r ? this.schedule(void 0, r) : i.complete());
+    }, o);
+  });
+}
+function Wt(t, n) {
+  return v(n) ? H(t, n, 1) : H(t, 1);
+}
+function qt(t) {
+  return t <= 0 ? function() {
+    return St;
+  } : L(function(n, e) {
+    var r = 0;
+    n.subscribe(P(e, function(i) {
+      ++r <= t && (e.next(i), t <= r && e.complete());
+    }));
+  });
+}
+function Vt(t) {
+  return He(function() {
+    return t;
+  });
+}
+function Yt(t, n) {
+  return H(function(e, r) {
+    return A(t(e, r)).pipe(qt(1), Vt(e));
+  });
+}
+function Bt(t, n) {
+  n === void 0 && (n = Le);
+  var e = Gt(t, n);
+  return Yt(function() {
+    return e;
+  });
+}
+function ue(t) {
+  return L(function(n, e) {
+    try {
+      n.subscribe(e);
+    } finally {
+      e.add(t);
+    }
+  });
+}
+function se(t) {
+  return L(function(n, e) {
+    A(t).subscribe(P(e, function() {
+      return e.complete();
+    }, B)), !e.closed && n.subscribe(e);
+  });
+}
+async function Kt(t, n) {
+  const e = t.getReader();
+  let r;
+  for (; !(r = await e.read()).done; )
+    n(r.value);
+}
+function zt(t) {
+  let n, e, r, i = !1;
+  return function(u) {
+    n === void 0 ? (n = u, e = 0, r = -1) : n = Xt(n, u);
+    const s = n.length;
+    let f = 0;
+    for (; e < s; ) {
+      i && (n[e] === 10 && (f = ++e), i = !1);
+      let a = -1;
+      for (; e < s && a === -1; ++e)
+        switch (n[e]) {
+          case 58:
+            r === -1 && (r = e - f);
+            break;
+          case 13:
+            i = !0;
+          case 10:
+            a = e;
+            break;
+        }
+      if (a === -1)
+        break;
+      t(n.subarray(f, a), r), f = e, r = -1;
+    }
+    f === s ? n = void 0 : f !== 0 && (n = n.subarray(f), e -= f);
+  };
+}
+function Jt(t, n, e) {
+  let r = ae();
+  const i = new TextDecoder();
+  return function(u, s) {
+    if (u.length === 0)
+      e == null || e(r), r = ae();
+    else if (s > 0) {
+      const f = i.decode(u.subarray(0, s)), a = s + (u[s + 1] === 32 ? 2 : 1), l = i.decode(u.subarray(a));
+      switch (f) {
+        case "data":
+          r.data = r.data ? r.data + `
+` + l : l;
+          break;
+        case "event":
+          r.event = l;
+          break;
+        case "id":
+          t(r.id = l);
+          break;
+        case "retry":
+          const y = parseInt(l, 10);
+          isNaN(y) || n(r.retry = y);
+          break;
+      }
+    }
+  };
+}
+function Xt(t, n) {
+  const e = new Uint8Array(t.length + n.length);
+  return e.set(t), e.set(n, t.length), e;
+}
+function ae() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+var Qt = function(t, n) {
+  var e = {};
+  for (var r in t) Object.prototype.hasOwnProperty.call(t, r) && n.indexOf(r) < 0 && (e[r] = t[r]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, r = Object.getOwnPropertySymbols(t); i < r.length; i++)
+      n.indexOf(r[i]) < 0 && Object.prototype.propertyIsEnumerable.call(t, r[i]) && (e[r[i]] = t[r[i]]);
+  return e;
+};
+const z = "text/event-stream", Zt = 1e3, fe = "last-event-id";
+function en(t, n) {
+  var { signal: e, headers: r, onopen: i, onmessage: o, onclose: u, onerror: s, openWhenHidden: f, fetch: a } = n, l = Qt(n, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((y, m) => {
+    const c = Object.assign({}, r);
+    c.accept || (c.accept = z);
+    let p;
+    function h() {
+      p.abort(), document.hidden || W();
+    }
+    f || document.addEventListener("visibilitychange", h);
+    let O = Zt, w = 0;
+    function _() {
+      document.removeEventListener("visibilitychange", h), window.clearTimeout(w), p.abort();
+    }
+    e == null || e.addEventListener("abort", () => {
+      _(), y();
+    });
+    const Ge = a ?? window.fetch, We = i ?? tn;
+    async function W() {
+      var q;
+      p = new AbortController();
+      try {
+        const j = await Ge(t, Object.assign(Object.assign({}, l), { headers: c, signal: p.signal }));
+        await We(j), await Kt(j.body, zt(Jt((g) => {
+          g ? c[fe] = g : delete c[fe];
+        }, (g) => {
+          O = g;
+        }, o))), u == null || u(), _(), y();
+      } catch (j) {
+        if (!p.signal.aborted)
+          try {
+            const g = (q = s == null ? void 0 : s(j)) !== null && q !== void 0 ? q : O;
+            window.clearTimeout(w), w = window.setTimeout(W, g);
+          } catch (g) {
+            _(), m(g);
+          }
+      }
+    }
+    W();
+  });
+}
+function tn(t) {
+  const n = t.headers.get("content-type");
+  if (!(n != null && n.startsWith(z)))
+    throw new Error(`Expected content-type to be ${z}, Actual: ${n}`);
+}
+function ce(t) {
+  const { endpoint: n, webhookToken: e, payload: r } = t;
+  return new b((i) => {
+    const o = new AbortController();
+    return en(n, {
+      method: "POST",
+      headers: {
+        "X-Asgard-Webhook-Token": e,
+        "Content-Type": "application/json"
+      },
+      body: r ? JSON.stringify(r) : void 0,
+      signal: o.signal,
+      onopen: async (u) => {
+        u.ok || (i.error(u), o.abort());
+      },
+      onmessage: (u) => {
+        i.next(u);
+      },
+      onclose: () => {
+        i.complete();
+      },
+      onerror: (u) => {
+        i.error(u), o.abort();
+      }
+    }), () => {
+      o.abort();
+    };
+  });
+}
+class rn {
+  constructor(n) {
+    E(this, "baseUrl");
+    E(this, "namespace");
+    E(this, "botProviderName");
+    E(this, "endpoint");
+    E(this, "webhookToken");
+    E(this, "eventEmitter");
+    E(this, "destroy$", new xe());
+    if (!n.baseUrl)
+      throw new Error("baseUrl must be required");
+    if (!n.namespace)
+      throw new Error("namespace must be required");
+    if (!n.botProviderName)
+      throw new Error("botProviderName must be required");
+    if (!n.webhookToken)
+      throw new Error("webhookToken must be required");
+    this.baseUrl = n.baseUrl, this.namespace = n.namespace, this.botProviderName = n.botProviderName, this.webhookToken = n.webhookToken, this.endpoint = `${this.baseUrl}/generic/ns/${this.namespace}/bot-provider/${this.botProviderName}/message/sse`, this.eventEmitter = new nt();
+  }
+  on(n, e, r) {
+    const i = `${n}:${e}`;
+    this.eventEmitter.listeners(i).length > 0 && this.eventEmitter.removeAllListeners(i), this.eventEmitter.on(i, r);
+  }
+  setChannel(n, e) {
+    var r;
+    return (r = e == null ? void 0 : e.onStart) == null || r.call(e), ce({
+      endpoint: this.endpoint,
+      webhookToken: this.webhookToken,
+      payload: Object.assign({ action: C.RESET_CHANNEL }, n)
+    }).pipe(
+      se(this.destroy$),
+      ue(() => {
+        var i;
+        return (i = e == null ? void 0 : e.onCompleted) == null ? void 0 : i.call(e);
+      })
+    ).subscribe({
+      next: (i) => {
+        this.eventEmitter.emit(
+          `${C.RESET_CHANNEL}:${i.event}`,
+          JSON.parse(i.data)
+        );
+      }
+    });
+  }
+  sendMessage(n, e) {
+    var r;
+    return (r = e == null ? void 0 : e.onStart) == null || r.call(e), ce({
+      endpoint: this.endpoint,
+      webhookToken: this.webhookToken,
+      payload: Object.assign({ action: C.NONE }, n)
+    }).pipe(
+      Wt((i) => Dt(i).pipe(Bt((e == null ? void 0 : e.delayTime) ?? 50))),
+      se(this.destroy$),
+      ue(() => {
+        var i;
+        return (i = e == null ? void 0 : e.onCompleted) == null ? void 0 : i.call(e);
+      })
+    ).subscribe({
+      next: (i) => {
+        this.eventEmitter.emit(
+          `${C.NONE}:${i.event}`,
+          JSON.parse(i.data)
+        );
+      }
+    });
+  }
+  close() {
+    this.destroy$.next(), this.destroy$.complete();
+  }
+}
+export {
+  rn as AsgardServiceClient,
+  Ye as EventType,
+  C as FetchSSEAction,
+  Be as MessageTemplateType
+};
+//# sourceMappingURL=index.mjs.map