@antcde/vue-utils 0.0.4

package/dist/index.js

@@ -0,0 +1,1362 @@
+import { useColorMode as _t, objectPick as It, objectOmit as nt, useMagicKeys as Et, whenever as Ot, useAsyncState as At, watchDebounced as Pt } from "@vueuse/core";
+import { computed as S, ref as g, watch as z, onBeforeUnmount as ot, inject as jt, unref as Tt, watchEffect as Ct } from "vue";
+import { useI18n as H } from "vue-i18n";
+import { newCommsClient as kt, newCommsHost as Lt } from "@antcde/connect-ts";
+function Ue(e, r) {
+  const t = _t(r), n = S(() => e.context.value.darkMode), o = S(() => {
+    switch (n.value) {
+      case null:
+        return "auto";
+      case !0:
+        return "dark";
+      case !1:
+        return "light";
+      default:
+        return t.value;
+    }
+  }), i = S(() => {
+    switch (o.value) {
+      case "light":
+      case "auto":
+        return !1;
+      case "dark":
+        return !0;
+    }
+  });
+  return Object.assign(
+    o,
+    { host: n, isDark: i },
+    It(t, ["state", "system", "store"])
+  );
+}
+function Re(e, r) {
+  const t = g(H(r));
+  return z(
+    e.locales.value,
+    ({ locale: n }) => t.value = H({ ...r, locale: n })
+  ), Object.keys(t.value).reduce(
+    (n, o) => Object.defineProperty(n, o, {
+      get: () => t.value[o],
+      enumerable: !0
+    }),
+    {}
+  );
+}
+var G = function(e, r) {
+  return G = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, n) {
+    t.__proto__ = n;
+  } || function(t, n) {
+    for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
+  }, G(e, r);
+};
+function x(e, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+  G(e, r);
+  function t() {
+    this.constructor = e;
+  }
+  e.prototype = r === null ? Object.create(r) : (t.prototype = r.prototype, new t());
+}
+function Ut(e, r, t, n) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(u) {
+      u(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, u) {
+    function c(l) {
+      try {
+        s(n.next(l));
+      } catch (p) {
+        u(p);
+      }
+    }
+    function a(l) {
+      try {
+        s(n.throw(l));
+      } catch (p) {
+        u(p);
+      }
+    }
+    function s(l) {
+      l.done ? i(l.value) : o(l.value).then(c, a);
+    }
+    s((n = n.apply(e, r || [])).next());
+  });
+}
+function it(e, r) {
+  var t = { label: 0, sent: function() {
+    if (i[0] & 1) throw i[1];
+    return i[1];
+  }, trys: [], ops: [] }, n, o, i, u = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return u.next = c(0), u.throw = c(1), u.return = c(2), typeof Symbol == "function" && (u[Symbol.iterator] = function() {
+    return this;
+  }), u;
+  function c(s) {
+    return function(l) {
+      return a([s, l]);
+    };
+  }
+  function a(s) {
+    if (n) throw new TypeError("Generator is already executing.");
+    for (; u && (u = 0, s[0] && (t = 0)), t; ) try {
+      if (n = 1, o && (i = s[0] & 2 ? o.return : s[0] ? o.throw || ((i = o.return) && i.call(o), 0) : o.next) && !(i = i.call(o, s[1])).done) return i;
+      switch (o = 0, i && (s = [s[0] & 2, i.value]), s[0]) {
+        case 0:
+        case 1:
+          i = s;
+          break;
+        case 4:
+          return t.label++, { value: s[1], done: !1 };
+        case 5:
+          t.label++, o = s[1], s = [0];
+          continue;
+        case 7:
+          s = t.ops.pop(), t.trys.pop();
+          continue;
+        default:
+          if (i = t.trys, !(i = i.length > 0 && i[i.length - 1]) && (s[0] === 6 || s[0] === 2)) {
+            t = 0;
+            continue;
+          }
+          if (s[0] === 3 && (!i || s[1] > i[0] && s[1] < i[3])) {
+            t.label = s[1];
+            break;
+          }
+          if (s[0] === 6 && t.label < i[1]) {
+            t.label = i[1], i = s;
+            break;
+          }
+          if (i && t.label < i[2]) {
+            t.label = i[2], t.ops.push(s);
+            break;
+          }
+          i[2] && t.ops.pop(), t.trys.pop();
+          continue;
+      }
+      s = r.call(e, t);
+    } catch (l) {
+      s = [6, l], o = 0;
+    } finally {
+      n = i = 0;
+    }
+    if (s[0] & 5) throw s[1];
+    return { value: s[0] ? s[1] : void 0, done: !0 };
+  }
+}
+function P(e) {
+  var r = typeof Symbol == "function" && Symbol.iterator, t = r && e[r], n = 0;
+  if (t) return t.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(r ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function R(e, r) {
+  var t = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!t) return e;
+  var n = t.call(e), o, i = [], u;
+  try {
+    for (; (r === void 0 || r-- > 0) && !(o = n.next()).done; ) i.push(o.value);
+  } catch (c) {
+    u = { error: c };
+  } finally {
+    try {
+      o && !o.done && (t = n.return) && t.call(n);
+    } finally {
+      if (u) throw u.error;
+    }
+  }
+  return i;
+}
+function F(e, r, t) {
+  if (t || arguments.length === 2) for (var n = 0, o = r.length, i; n < o; n++)
+    (i || !(n in r)) && (i || (i = Array.prototype.slice.call(r, 0, n)), i[n] = r[n]);
+  return e.concat(i || Array.prototype.slice.call(r));
+}
+function A(e) {
+  return this instanceof A ? (this.v = e, this) : new A(e);
+}
+function Rt(e, r, t) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = t.apply(e, r || []), o, i = [];
+  return o = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), c("next"), c("throw"), c("return", u), o[Symbol.asyncIterator] = function() {
+    return this;
+  }, o;
+  function u(h) {
+    return function(b) {
+      return Promise.resolve(b).then(h, p);
+    };
+  }
+  function c(h, b) {
+    n[h] && (o[h] = function(v) {
+      return new Promise(function(O, f) {
+        i.push([h, v, O, f]) > 1 || a(h, v);
+      });
+    }, b && (o[h] = b(o[h])));
+  }
+  function a(h, b) {
+    try {
+      s(n[h](b));
+    } catch (v) {
+      y(i[0][3], v);
+    }
+  }
+  function s(h) {
+    h.value instanceof A ? Promise.resolve(h.value.v).then(l, p) : y(i[0][2], h);
+  }
+  function l(h) {
+    a("next", h);
+  }
+  function p(h) {
+    a("throw", h);
+  }
+  function y(h, b) {
+    h(b), i.shift(), i.length && a(i[0][0], i[0][1]);
+  }
+}
+function Ft(e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var r = e[Symbol.asyncIterator], t;
+  return r ? r.call(e) : (e = typeof P == "function" ? P(e) : e[Symbol.iterator](), t = {}, n("next"), n("throw"), n("return"), t[Symbol.asyncIterator] = function() {
+    return this;
+  }, t);
+  function n(i) {
+    t[i] = e[i] && function(u) {
+      return new Promise(function(c, a) {
+        u = e[i](u), o(c, a, u.done, u.value);
+      });
+    };
+  }
+  function o(i, u, c, a) {
+    Promise.resolve(a).then(function(s) {
+      i({ value: s, done: c });
+    }, u);
+  }
+}
+function d(e) {
+  return typeof e == "function";
+}
+function ut(e) {
+  var r = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, t = e(r);
+  return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+var D = ut(function(e) {
+  return function(t) {
+    e(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(n, o) {
+      return o + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function M(e, r) {
+  if (e) {
+    var t = e.indexOf(r);
+    0 <= t && e.splice(t, 1);
+  }
+}
+var j = function() {
+  function e(r) {
+    this.initialTeardown = r, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var r, t, n, o, i;
+    if (!this.closed) {
+      this.closed = !0;
+      var u = this._parentage;
+      if (u)
+        if (this._parentage = null, Array.isArray(u))
+          try {
+            for (var c = P(u), a = c.next(); !a.done; a = c.next()) {
+              var s = a.value;
+              s.remove(this);
+            }
+          } catch (v) {
+            r = { error: v };
+          } finally {
+            try {
+              a && !a.done && (t = c.return) && t.call(c);
+            } finally {
+              if (r) throw r.error;
+            }
+          }
+        else
+          u.remove(this);
+      var l = this.initialTeardown;
+      if (d(l))
+        try {
+          l();
+        } catch (v) {
+          i = v instanceof D ? v.errors : [v];
+        }
+      var p = this._finalizers;
+      if (p) {
+        this._finalizers = null;
+        try {
+          for (var y = P(p), h = y.next(); !h.done; h = y.next()) {
+            var b = h.value;
+            try {
+              Q(b);
+            } catch (v) {
+              i = i ?? [], v instanceof D ? i = F(F([], R(i)), R(v.errors)) : i.push(v);
+            }
+          }
+        } catch (v) {
+          n = { error: v };
+        } finally {
+          try {
+            h && !h.done && (o = y.return) && o.call(y);
+          } finally {
+            if (n) throw n.error;
+          }
+        }
+      }
+      if (i)
+        throw new D(i);
+    }
+  }, e.prototype.add = function(r) {
+    var t;
+    if (r && r !== this)
+      if (this.closed)
+        Q(r);
+      else {
+        if (r instanceof e) {
+          if (r.closed || r._hasParent(this))
+            return;
+          r._addParent(this);
+        }
+        (this._finalizers = (t = this._finalizers) !== null && t !== void 0 ? t : []).push(r);
+      }
+  }, e.prototype._hasParent = function(r) {
+    var t = this._parentage;
+    return t === r || Array.isArray(t) && t.includes(r);
+  }, e.prototype._addParent = function(r) {
+    var t = this._parentage;
+    this._parentage = Array.isArray(t) ? (t.push(r), t) : t ? [t, r] : r;
+  }, e.prototype._removeParent = function(r) {
+    var t = this._parentage;
+    t === r ? this._parentage = null : Array.isArray(t) && M(t, r);
+  }, e.prototype.remove = function(r) {
+    var t = this._finalizers;
+    t && M(t, r), r instanceof e && r._removeParent(this);
+  }, e.EMPTY = function() {
+    var r = new e();
+    return r.closed = !0, r;
+  }(), e;
+}(), st = j.EMPTY;
+function ct(e) {
+  return e instanceof j || e && "closed" in e && d(e.remove) && d(e.add) && d(e.unsubscribe);
+}
+function Q(e) {
+  d(e) ? e() : e.unsubscribe();
+}
+var Mt = {
+  Promise: void 0
+}, Vt = {
+  setTimeout: function(e, r) {
+    for (var t = [], n = 2; n < arguments.length; n++)
+      t[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, F([e, r], R(t)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function at(e) {
+  Vt.setTimeout(function() {
+    throw e;
+  });
+}
+function X() {
+}
+function U(e) {
+  e();
+}
+var q = function(e) {
+  x(r, e);
+  function r(t) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, t ? (n.destination = t, ct(t) && t.add(n)) : n.destination = Yt, n;
+  }
+  return r.create = function(t, n, o) {
+    return new K(t, n, o);
+  }, r.prototype.next = function(t) {
+    this.isStopped || this._next(t);
+  }, r.prototype.error = function(t) {
+    this.isStopped || (this.isStopped = !0, this._error(t));
+  }, r.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, r.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, r.prototype._next = function(t) {
+    this.destination.next(t);
+  }, r.prototype._error = function(t) {
+    try {
+      this.destination.error(t);
+    } finally {
+      this.unsubscribe();
+    }
+  }, r.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, r;
+}(j), Bt = function() {
+  function e(r) {
+    this.partialObserver = r;
+  }
+  return e.prototype.next = function(r) {
+    var t = this.partialObserver;
+    if (t.next)
+      try {
+        t.next(r);
+      } catch (n) {
+        L(n);
+      }
+  }, e.prototype.error = function(r) {
+    var t = this.partialObserver;
+    if (t.error)
+      try {
+        t.error(r);
+      } catch (n) {
+        L(n);
+      }
+    else
+      L(r);
+  }, e.prototype.complete = function() {
+    var r = this.partialObserver;
+    if (r.complete)
+      try {
+        r.complete();
+      } catch (t) {
+        L(t);
+      }
+  }, e;
+}(), K = function(e) {
+  x(r, e);
+  function r(t, n, o) {
+    var i = e.call(this) || this, u;
+    return d(t) || !t ? u = {
+      next: t ?? void 0,
+      error: n ?? void 0,
+      complete: o ?? void 0
+    } : u = t, i.destination = new Bt(u), i;
+  }
+  return r;
+}(q);
+function L(e) {
+  at(e);
+}
+function Dt(e) {
+  throw e;
+}
+var Yt = {
+  closed: !0,
+  next: X,
+  error: Dt,
+  complete: X
+}, W = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function B(e) {
+  return e;
+}
+function zt(e) {
+  return e.length === 0 ? B : e.length === 1 ? e[0] : function(t) {
+    return e.reduce(function(n, o) {
+      return o(n);
+    }, t);
+  };
+}
+var w = function() {
+  function e(r) {
+    r && (this._subscribe = r);
+  }
+  return e.prototype.lift = function(r) {
+    var t = new e();
+    return t.source = this, t.operator = r, t;
+  }, e.prototype.subscribe = function(r, t, n) {
+    var o = this, i = Gt(r) ? r : new K(r, t, n);
+    return U(function() {
+      var u = o, c = u.operator, a = u.source;
+      i.add(c ? c.call(i, a) : a ? o._subscribe(i) : o._trySubscribe(i));
+    }), i;
+  }, e.prototype._trySubscribe = function(r) {
+    try {
+      return this._subscribe(r);
+    } catch (t) {
+      r.error(t);
+    }
+  }, e.prototype.forEach = function(r, t) {
+    var n = this;
+    return t = Z(t), new t(function(o, i) {
+      var u = new K({
+        next: function(c) {
+          try {
+            r(c);
+          } catch (a) {
+            i(a), u.unsubscribe();
+          }
+        },
+        error: i,
+        complete: o
+      });
+      n.subscribe(u);
+    });
+  }, e.prototype._subscribe = function(r) {
+    var t;
+    return (t = this.source) === null || t === void 0 ? void 0 : t.subscribe(r);
+  }, e.prototype[W] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var r = [], t = 0; t < arguments.length; t++)
+      r[t] = arguments[t];
+    return zt(r)(this);
+  }, e.prototype.toPromise = function(r) {
+    var t = this;
+    return r = Z(r), new r(function(n, o) {
+      var i;
+      t.subscribe(function(u) {
+        return i = u;
+      }, function(u) {
+        return o(u);
+      }, function() {
+        return n(i);
+      });
+    });
+  }, e.create = function(r) {
+    return new e(r);
+  }, e;
+}();
+function Z(e) {
+  var r;
+  return (r = e ?? Mt.Promise) !== null && r !== void 0 ? r : Promise;
+}
+function Ht(e) {
+  return e && d(e.next) && d(e.error) && d(e.complete);
+}
+function Gt(e) {
+  return e && e instanceof q || Ht(e) && ct(e);
+}
+function Kt(e) {
+  return d(e == null ? void 0 : e.lift);
+}
+function I(e) {
+  return function(r) {
+    if (Kt(r))
+      return r.lift(function(t) {
+        try {
+          return e(t, this);
+        } catch (n) {
+          this.error(n);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function _(e, r, t, n, o) {
+  return new qt(e, r, t, n, o);
+}
+var qt = function(e) {
+  x(r, e);
+  function r(t, n, o, i, u, c) {
+    var a = e.call(this, t) || this;
+    return a.onFinalize = u, a.shouldUnsubscribe = c, a._next = n ? function(s) {
+      try {
+        n(s);
+      } catch (l) {
+        t.error(l);
+      }
+    } : e.prototype._next, a._error = i ? function(s) {
+      try {
+        i(s);
+      } catch (l) {
+        t.error(l);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._error, a._complete = o ? function() {
+      try {
+        o();
+      } catch (s) {
+        t.error(s);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._complete, a;
+  }
+  return r.prototype.unsubscribe = function() {
+    var t;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var n = this.closed;
+      e.prototype.unsubscribe.call(this), !n && ((t = this.onFinalize) === null || t === void 0 || t.call(this));
+    }
+  }, r;
+}(q), Wt = ut(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), $ = function(e) {
+  x(r, e);
+  function r() {
+    var t = e.call(this) || this;
+    return t.closed = !1, t.currentObservers = null, t.observers = [], t.isStopped = !1, t.hasError = !1, t.thrownError = null, t;
+  }
+  return r.prototype.lift = function(t) {
+    var n = new N(this, this);
+    return n.operator = t, n;
+  }, r.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new Wt();
+  }, r.prototype.next = function(t) {
+    var n = this;
+    U(function() {
+      var o, i;
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.currentObservers || (n.currentObservers = Array.from(n.observers));
+        try {
+          for (var u = P(n.currentObservers), c = u.next(); !c.done; c = u.next()) {
+            var a = c.value;
+            a.next(t);
+          }
+        } catch (s) {
+          o = { error: s };
+        } finally {
+          try {
+            c && !c.done && (i = u.return) && i.call(u);
+          } finally {
+            if (o) throw o.error;
+          }
+        }
+      }
+    });
+  }, r.prototype.error = function(t) {
+    var n = this;
+    U(function() {
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.hasError = n.isStopped = !0, n.thrownError = t;
+        for (var o = n.observers; o.length; )
+          o.shift().error(t);
+      }
+    });
+  }, r.prototype.complete = function() {
+    var t = this;
+    U(function() {
+      if (t._throwIfClosed(), !t.isStopped) {
+        t.isStopped = !0;
+        for (var n = t.observers; n.length; )
+          n.shift().complete();
+      }
+    });
+  }, r.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(r.prototype, "observed", {
+    get: function() {
+      var t;
+      return ((t = this.observers) === null || t === void 0 ? void 0 : t.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), r.prototype._trySubscribe = function(t) {
+    return this._throwIfClosed(), e.prototype._trySubscribe.call(this, t);
+  }, r.prototype._subscribe = function(t) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(t), this._innerSubscribe(t);
+  }, r.prototype._innerSubscribe = function(t) {
+    var n = this, o = this, i = o.hasError, u = o.isStopped, c = o.observers;
+    return i || u ? st : (this.currentObservers = null, c.push(t), new j(function() {
+      n.currentObservers = null, M(c, t);
+    }));
+  }, r.prototype._checkFinalizedStatuses = function(t) {
+    var n = this, o = n.hasError, i = n.thrownError, u = n.isStopped;
+    o ? t.error(i) : u && t.complete();
+  }, r.prototype.asObservable = function() {
+    var t = new w();
+    return t.source = this, t;
+  }, r.create = function(t, n) {
+    return new N(t, n);
+  }, r;
+}(w), N = function(e) {
+  x(r, e);
+  function r(t, n) {
+    var o = e.call(this) || this;
+    return o.destination = t, o.source = n, o;
+  }
+  return r.prototype.next = function(t) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.next) === null || o === void 0 || o.call(n, t);
+  }, r.prototype.error = function(t) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.error) === null || o === void 0 || o.call(n, t);
+  }, r.prototype.complete = function() {
+    var t, n;
+    (n = (t = this.destination) === null || t === void 0 ? void 0 : t.complete) === null || n === void 0 || n.call(t);
+  }, r.prototype._subscribe = function(t) {
+    var n, o;
+    return (o = (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(t)) !== null && o !== void 0 ? o : st;
+  }, r;
+}($), Y = function(e) {
+  x(r, e);
+  function r(t) {
+    var n = e.call(this) || this;
+    return n._value = t, n;
+  }
+  return Object.defineProperty(r.prototype, "value", {
+    get: function() {
+      return this.getValue();
+    },
+    enumerable: !1,
+    configurable: !0
+  }), r.prototype._subscribe = function(t) {
+    var n = e.prototype._subscribe.call(this, t);
+    return !n.closed && t.next(this._value), n;
+  }, r.prototype.getValue = function() {
+    var t = this, n = t.hasError, o = t.thrownError, i = t._value;
+    if (n)
+      throw o;
+    return this._throwIfClosed(), i;
+  }, r.prototype.next = function(t) {
+    e.prototype.next.call(this, this._value = t);
+  }, r;
+}($), $t = {
+  now: function() {
+    return Date.now();
+  }
+}, Jt = function(e) {
+  x(r, e);
+  function r(t, n) {
+    return e.call(this) || this;
+  }
+  return r.prototype.schedule = function(t, n) {
+    return this;
+  }, r;
+}(j), tt = {
+  setInterval: function(e, r) {
+    for (var t = [], n = 2; n < arguments.length; n++)
+      t[n - 2] = arguments[n];
+    return setInterval.apply(void 0, F([e, r], R(t)));
+  },
+  clearInterval: function(e) {
+    return clearInterval(e);
+  },
+  delegate: void 0
+}, Qt = function(e) {
+  x(r, e);
+  function r(t, n) {
+    var o = e.call(this, t, n) || this;
+    return o.scheduler = t, o.work = n, o.pending = !1, o;
+  }
+  return r.prototype.schedule = function(t, n) {
+    var o;
+    if (n === void 0 && (n = 0), this.closed)
+      return this;
+    this.state = t;
+    var i = this.id, u = this.scheduler;
+    return i != null && (this.id = this.recycleAsyncId(u, i, n)), this.pending = !0, this.delay = n, this.id = (o = this.id) !== null && o !== void 0 ? o : this.requestAsyncId(u, this.id, n), this;
+  }, r.prototype.requestAsyncId = function(t, n, o) {
+    return o === void 0 && (o = 0), tt.setInterval(t.flush.bind(t, this), o);
+  }, r.prototype.recycleAsyncId = function(t, n, o) {
+    if (o === void 0 && (o = 0), o != null && this.delay === o && this.pending === !1)
+      return n;
+    n != null && tt.clearInterval(n);
+  }, r.prototype.execute = function(t, n) {
+    if (this.closed)
+      return new Error("executing a cancelled action");
+    this.pending = !1;
+    var o = this._execute(t, n);
+    if (o)
+      return o;
+    this.pending === !1 && this.id != null && (this.id = this.recycleAsyncId(this.scheduler, this.id, null));
+  }, r.prototype._execute = function(t, n) {
+    var o = !1, i;
+    try {
+      this.work(t);
+    } catch (u) {
+      o = !0, i = u || new Error("Scheduled action threw falsy error");
+    }
+    if (o)
+      return this.unsubscribe(), i;
+  }, r.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      var t = this, n = t.id, o = t.scheduler, i = o.actions;
+      this.work = this.state = this.scheduler = null, this.pending = !1, M(i, this), n != null && (this.id = this.recycleAsyncId(o, n, null)), this.delay = null, e.prototype.unsubscribe.call(this);
+    }
+  }, r;
+}(Jt), et = function() {
+  function e(r, t) {
+    t === void 0 && (t = e.now), this.schedulerActionCtor = r, this.now = t;
+  }
+  return e.prototype.schedule = function(r, t, n) {
+    return t === void 0 && (t = 0), new this.schedulerActionCtor(this, r).schedule(n, t);
+  }, e.now = $t.now, e;
+}(), Xt = function(e) {
+  x(r, e);
+  function r(t, n) {
+    n === void 0 && (n = et.now);
+    var o = e.call(this, t, n) || this;
+    return o.actions = [], o._active = !1, o;
+  }
+  return r.prototype.flush = function(t) {
+    var n = this.actions;
+    if (this._active) {
+      n.push(t);
+      return;
+    }
+    var o;
+    this._active = !0;
+    do
+      if (o = t.execute(t.state, t.delay))
+        break;
+    while (t = n.shift());
+    if (this._active = !1, o) {
+      for (; t = n.shift(); )
+        t.unsubscribe();
+      throw o;
+    }
+  }, r;
+}(et), Zt = new Xt(Qt);
+function Nt(e) {
+  return e && d(e.schedule);
+}
+function te(e) {
+  return e[e.length - 1];
+}
+function ee(e) {
+  return Nt(te(e)) ? e.pop() : void 0;
+}
+var lt = function(e) {
+  return e && typeof e.length == "number" && typeof e != "function";
+};
+function ft(e) {
+  return d(e == null ? void 0 : e.then);
+}
+function ht(e) {
+  return d(e[W]);
+}
+function vt(e) {
+  return Symbol.asyncIterator && d(e == null ? void 0 : e[Symbol.asyncIterator]);
+}
+function dt(e) {
+  return new TypeError("You provided " + (e !== null && typeof e == "object" ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function re() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var pt = re();
+function bt(e) {
+  return d(e == null ? void 0 : e[pt]);
+}
+function yt(e) {
+  return Rt(this, arguments, function() {
+    var t, n, o, i;
+    return it(this, function(u) {
+      switch (u.label) {
+        case 0:
+          t = e.getReader(), u.label = 1;
+        case 1:
+          u.trys.push([1, , 9, 10]), u.label = 2;
+        case 2:
+          return [4, A(t.read())];
+        case 3:
+          return n = u.sent(), o = n.value, i = n.done, i ? [4, A(void 0)] : [3, 5];
+        case 4:
+          return [2, u.sent()];
+        case 5:
+          return [4, A(o)];
+        case 6:
+          return [4, u.sent()];
+        case 7:
+          return u.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return t.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function mt(e) {
+  return d(e == null ? void 0 : e.getReader);
+}
+function T(e) {
+  if (e instanceof w)
+    return e;
+  if (e != null) {
+    if (ht(e))
+      return ne(e);
+    if (lt(e))
+      return oe(e);
+    if (ft(e))
+      return ie(e);
+    if (vt(e))
+      return wt(e);
+    if (bt(e))
+      return ue(e);
+    if (mt(e))
+      return se(e);
+  }
+  throw dt(e);
+}
+function ne(e) {
+  return new w(function(r) {
+    var t = e[W]();
+    if (d(t.subscribe))
+      return t.subscribe(r);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function oe(e) {
+  return new w(function(r) {
+    for (var t = 0; t < e.length && !r.closed; t++)
+      r.next(e[t]);
+    r.complete();
+  });
+}
+function ie(e) {
+  return new w(function(r) {
+    e.then(function(t) {
+      r.closed || (r.next(t), r.complete());
+    }, function(t) {
+      return r.error(t);
+    }).then(null, at);
+  });
+}
+function ue(e) {
+  return new w(function(r) {
+    var t, n;
+    try {
+      for (var o = P(e), i = o.next(); !i.done; i = o.next()) {
+        var u = i.value;
+        if (r.next(u), r.closed)
+          return;
+      }
+    } catch (c) {
+      t = { error: c };
+    } finally {
+      try {
+        i && !i.done && (n = o.return) && n.call(o);
+      } finally {
+        if (t) throw t.error;
+      }
+    }
+    r.complete();
+  });
+}
+function wt(e) {
+  return new w(function(r) {
+    ce(e, r).catch(function(t) {
+      return r.error(t);
+    });
+  });
+}
+function se(e) {
+  return wt(yt(e));
+}
+function ce(e, r) {
+  var t, n, o, i;
+  return Ut(this, void 0, void 0, function() {
+    var u, c;
+    return it(this, function(a) {
+      switch (a.label) {
+        case 0:
+          a.trys.push([0, 5, 6, 11]), t = Ft(e), a.label = 1;
+        case 1:
+          return [4, t.next()];
+        case 2:
+          if (n = a.sent(), !!n.done) return [3, 4];
+          if (u = n.value, r.next(u), r.closed)
+            return [2];
+          a.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return c = a.sent(), o = { error: c }, [3, 11];
+        case 6:
+          return a.trys.push([6, , 9, 10]), n && !n.done && (i = t.return) ? [4, i.call(t)] : [3, 8];
+        case 7:
+          a.sent(), a.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (o) throw o.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return r.complete(), [2];
+      }
+    });
+  });
+}
+function E(e, r, t, n, o) {
+  n === void 0 && (n = 0), o === void 0 && (o = !1);
+  var i = r.schedule(function() {
+    t(), o ? e.add(this.schedule(null, n)) : this.unsubscribe();
+  }, n);
+  if (e.add(i), !o)
+    return i;
+}
+function St(e, r) {
+  return r === void 0 && (r = 0), I(function(t, n) {
+    t.subscribe(_(n, function(o) {
+      return E(n, e, function() {
+        return n.next(o);
+      }, r);
+    }, function() {
+      return E(n, e, function() {
+        return n.complete();
+      }, r);
+    }, function(o) {
+      return E(n, e, function() {
+        return n.error(o);
+      }, r);
+    }));
+  });
+}
+function gt(e, r) {
+  return r === void 0 && (r = 0), I(function(t, n) {
+    n.add(e.schedule(function() {
+      return t.subscribe(n);
+    }, r));
+  });
+}
+function ae(e, r) {
+  return T(e).pipe(gt(r), St(r));
+}
+function le(e, r) {
+  return T(e).pipe(gt(r), St(r));
+}
+function fe(e, r) {
+  return new w(function(t) {
+    var n = 0;
+    return r.schedule(function() {
+      n === e.length ? t.complete() : (t.next(e[n++]), t.closed || this.schedule());
+    });
+  });
+}
+function he(e, r) {
+  return new w(function(t) {
+    var n;
+    return E(t, r, function() {
+      n = e[pt](), E(t, r, function() {
+        var o, i, u;
+        try {
+          o = n.next(), i = o.value, u = o.done;
+        } catch (c) {
+          t.error(c);
+          return;
+        }
+        u ? t.complete() : t.next(i);
+      }, 0, !0);
+    }), function() {
+      return d(n == null ? void 0 : n.return) && n.return();
+    };
+  });
+}
+function xt(e, r) {
+  if (!e)
+    throw new Error("Iterable cannot be null");
+  return new w(function(t) {
+    E(t, r, function() {
+      var n = e[Symbol.asyncIterator]();
+      E(t, r, function() {
+        n.next().then(function(o) {
+          o.done ? t.complete() : t.next(o.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function ve(e, r) {
+  return xt(yt(e), r);
+}
+function de(e, r) {
+  if (e != null) {
+    if (ht(e))
+      return ae(e, r);
+    if (lt(e))
+      return fe(e, r);
+    if (ft(e))
+      return le(e, r);
+    if (vt(e))
+      return xt(e, r);
+    if (bt(e))
+      return he(e, r);
+    if (mt(e))
+      return ve(e, r);
+  }
+  throw dt(e);
+}
+function pe(e, r) {
+  return r ? de(e, r) : T(e);
+}
+function J(e, r) {
+  return I(function(t, n) {
+    var o = 0;
+    t.subscribe(_(n, function(i) {
+      n.next(e.call(r, i, o++));
+    }));
+  });
+}
+function be(e, r, t, n, o, i, u, c) {
+  var a = [], s = 0, l = 0, p = !1, y = function() {
+    p && !a.length && !s && r.complete();
+  }, h = function(v) {
+    return s < n ? b(v) : a.push(v);
+  }, b = function(v) {
+    s++;
+    var O = !1;
+    T(t(v, l++)).subscribe(_(r, function(f) {
+      r.next(f);
+    }, function() {
+      O = !0;
+    }, void 0, function() {
+      if (O)
+        try {
+          s--;
+          for (var f = function() {
+            var m = a.shift();
+            u || b(m);
+          }; a.length && s < n; )
+            f();
+          y();
+        } catch (m) {
+          r.error(m);
+        }
+    }));
+  };
+  return e.subscribe(_(r, h, function() {
+    p = !0, y();
+  })), function() {
+  };
+}
+function V(e, r, t) {
+  return t === void 0 && (t = 1 / 0), d(r) ? V(function(n, o) {
+    return J(function(i, u) {
+      return r(n, i, o, u);
+    })(T(e(n, o)));
+  }, t) : (typeof r == "number" && (t = r), I(function(n, o) {
+    return be(n, o, e, t);
+  }));
+}
+function ye(e) {
+  return V(B, e);
+}
+function me() {
+  return ye(1);
+}
+function we() {
+  for (var e = [], r = 0; r < arguments.length; r++)
+    e[r] = arguments[r];
+  return me()(pe(e, ee(e)));
+}
+function Se(e, r) {
+  return I(function(t, n) {
+    var o = 0;
+    t.subscribe(_(n, function(i) {
+      return e.call(r, i, o++) && n.next(i);
+    }));
+  });
+}
+function rt(e, r) {
+  return d(r) ? V(e, r, 1) : V(e, 1);
+}
+function ge(e, r) {
+  return r === void 0 && (r = Zt), I(function(t, n) {
+    var o = null, i = null, u = null, c = function() {
+      if (o) {
+        o.unsubscribe(), o = null;
+        var s = i;
+        i = null, n.next(s);
+      }
+    };
+    function a() {
+      var s = u + e, l = r.now();
+      if (l < s) {
+        o = this.schedule(void 0, s - l), n.add(o);
+        return;
+      }
+      c();
+    }
+    t.subscribe(_(n, function(s) {
+      i = s, u = r.now(), o || (o = r.schedule(a, e), n.add(o));
+    }, function() {
+      c(), n.complete();
+    }, void 0, function() {
+      i = o = null;
+    }));
+  });
+}
+function xe(e, r) {
+  return r === void 0 && (r = B), e = e ?? _e, I(function(t, n) {
+    var o, i = !0;
+    t.subscribe(_(n, function(u) {
+      var c = r(u);
+      (i || !e(o, c)) && (i = !1, o = c, n.next(u));
+    }));
+  });
+}
+function _e(e, r) {
+  return e === r;
+}
+function Ie(e, r, t) {
+  var n = d(e) || r || t ? { next: e, error: r, complete: t } : e;
+  return n ? I(function(o, i) {
+    var u;
+    (u = n.subscribe) === null || u === void 0 || u.call(n);
+    var c = !0;
+    o.subscribe(_(i, function(a) {
+      var s;
+      (s = n.next) === null || s === void 0 || s.call(n, a), i.next(a);
+    }, function() {
+      var a;
+      c = !1, (a = n.complete) === null || a === void 0 || a.call(n), i.complete();
+    }, function(a) {
+      var s;
+      c = !1, (s = n.error) === null || s === void 0 || s.call(n, a), i.error(a);
+    }, function() {
+      var a, s;
+      c && ((a = n.unsubscribe) === null || a === void 0 || a.call(n)), (s = n.finalize) === null || s === void 0 || s.call(n);
+    }));
+  }) : B;
+}
+function Ee(e, r) {
+  const t = g({}), n = kt({ parent: window.parent, connect: e }), o = g(""), i = S({
+    get: () => o.value,
+    set: (c) => n.appState.set(c)
+  }), u = g({ availableLocales: [] });
+  return n.context.subscribe((c) => t.value = c), we(n.appState.get(), n.appState).subscribe((c) => o.value = c), n.locales.subscribe((c) => u.value = c), Ae(n.signal, n, r), ot(() => n.unsubscribe()), Object.assign(
+    nt(n, ["context", "toolbar", "appState", "locales"]),
+    {
+      context: t,
+      toolbar: Oe(n),
+      appState: i,
+      locales: u
+    }
+  );
+}
+function Oe(e) {
+  const r = {
+    start: S({
+      get: () => e.toolbar.get().start,
+      set: (t) => e.toolbar.set((n) => ({ ...n, start: t }))
+    }),
+    title: S({
+      get: () => e.toolbar.get().title,
+      set: (t) => e.toolbar.set((n) => ({ ...n, title: t }))
+    }),
+    searchEnabled: S({
+      get: () => e.toolbar.get().search.enabled,
+      set: (t) => e.toolbar.set((n) => ({ ...n, search: { ...n.search, enabled: t } }))
+    }),
+    search: g(""),
+    menu: S({
+      get: () => e.toolbar.get().menu ?? [],
+      set: (t) => e.toolbar.set((n) => ({ ...n, menu: t }))
+    }),
+    isLoading: S({
+      get: () => e.toolbar.get().isLoading,
+      set: (t) => e.toolbar.set((n) => ({ ...n, isLoading: t }))
+    })
+  };
+  return e.toolbar.pipe(J((t) => t.search.input ?? ""), xe(), ge(300), Ie(console.log)).forEach((t) => r.search.value = t), r;
+}
+function Ae(e, r, t) {
+  const { shift: n } = Et(), o = g(null), i = new $(), u = i.pipe(
+    rt(t ?? ((c) => Promise.resolve(c))),
+    rt((c) => e(c))
+  ).subscribe();
+  return r.add(u), Ot(n, () => {
+    const c = Date.now();
+    o.value && c - o.value < 300 ? (o.value = null, console.log("lastShiftPress"), i.next({ overlay: { action: "show" } })) : o.value = c;
+  }), u;
+}
+function Pe(e) {
+  return Object.fromEntries(
+    Object.entries(e).map(([r, t]) => [r, Tt(t)])
+  );
+}
+function Fe(e = "comms") {
+  const [r, t] = je(
+    e,
+    () => Ee(),
+    (n) => n.unsubscribe()
+  );
+  return { provideComms: r, injectComms: t };
+}
+function je(e, r, t) {
+  let n;
+  const o = () => (!n && (n = r()), n);
+  return [
+    (i) => (i.onUnmount(() => t && n && t(n)), i.provide(e, o)),
+    () => jt(e)()
+  ];
+}
+function Me(e, r, t) {
+  const o = At(e, r, { immediate: !1, ...t });
+  return Object.assign(nt(o, ["execute"]), {
+    execute: (...i) => o.execute(void 0, ...i),
+    executeDelayed: o.execute
+  });
+}
+function Ve(e) {
+  const { context: r } = e, t = new Y({}), n = (f) => t.next(f(t.value)), o = g(), i = new Y(void 0);
+  Object.entries(r).forEach(([f, m]) => z(
+    m,
+    (C) => n((k) => ({ ...k, [f]: C })),
+    { immediate: !0 }
+  )), z(o, (f) => i.next(f), { immediate: !0 });
+  const u = i.asObservable().pipe(
+    J((f) => f == null ? void 0 : f.contentWindow),
+    Se((f) => !!f)
+  ), c = new Y({ availableLocales: [] }), { locale: a, availableLocales: s } = H();
+  Ct(() => c.next(Pe({ locale: a, availableLocales: s })));
+  const l = Lt({ ...e, contextChanges: t, windowChanges: u, locales: c });
+  l.toolbar.subscribe((f) => {
+    var C, k;
+    const m = e.toolbar;
+    m.start.value = f.start, m.title.value = f.title, m.searchEnabled.value = ((C = f.search) == null ? void 0 : C.enabled) ?? !1, m.search.value = (k = f.search) == null ? void 0 : k.input, m.menu.value = f.menu, m.isLoading.value = (f == null ? void 0 : f.isLoading) ?? !1;
+  }), Pt(
+    e.toolbar.search,
+    (f) => l.toolbar.set.search(f),
+    { immediate: !0, debounce: 100 }
+  );
+  const p = g(l.appState.get()), y = S({
+    get: () => p.value,
+    set: (f) => l.appState.set(f)
+  });
+  l.appState.changes.subscribe((f) => p.value = f);
+  const h = g(!1);
+  l.isConnectionInitialized.subscribe((f) => h.value = f), ot(() => l.unsubscribe());
+  const { unsubscribe: b, signal: v, closed: O } = l;
+  return {
+    ...e,
+    client: o,
+    appState: y,
+    isConnectionInitialized: h,
+    unsubscribe: b,
+    signal: v,
+    closed: O
+  };
+}
+export {
+  Ue as useAntColorMode,
+  Re as useAntI18n,
+  Me as useApi,
+  Ee as useCommsClient,
+  Ve as useCommsHost,
+  Fe as useCommsInjection,
+  je as useSingleton
+};