@mindline/sync 1.0.89 → 1.0.91

package/dist/sync.es.js

@@ -0,0 +1,4214 @@
+var st = Object.defineProperty;
+var Fe = (r) => {
+  throw TypeError(r);
+};
+var ot = (r, e, t) => e in r ? st(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var d = (r, e, t) => ot(r, typeof e != "symbol" ? e + "" : e, t), rt = (r, e, t) => e.has(r) || Fe("Cannot " + t);
+var we = (r, e, t) => e.has(r) ? Fe("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t);
+var Z = (r, e, t) => (rt(r, e, "access private method"), t);
+class V extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.HttpError}.
+   *
+   * @param {string} errorMessage A descriptive error message.
+   * @param {number} statusCode The HTTP status code represented by this error.
+   */
+  constructor(e, t) {
+    const n = new.target.prototype;
+    super(`${e}: Status code '${t}'`), this.statusCode = t, this.__proto__ = n;
+  }
+}
+class Le extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.TimeoutError}.
+   *
+   * @param {string} errorMessage A descriptive error message.
+   */
+  constructor(e = "A timeout occurred.") {
+    const t = new.target.prototype;
+    super(e), this.__proto__ = t;
+  }
+}
+class K extends Error {
+  /** Constructs a new instance of {@link AbortError}.
+   *
+   * @param {string} errorMessage A descriptive error message.
+   */
+  constructor(e = "An abort occurred.") {
+    const t = new.target.prototype;
+    super(e), this.__proto__ = t;
+  }
+}
+class it extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.UnsupportedTransportError}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occurred on.
+   */
+  constructor(e, t) {
+    const n = new.target.prototype;
+    super(e), this.transport = t, this.errorType = "UnsupportedTransportError", this.__proto__ = n;
+  }
+}
+class at extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.DisabledTransportError}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occurred on.
+   */
+  constructor(e, t) {
+    const n = new.target.prototype;
+    super(e), this.transport = t, this.errorType = "DisabledTransportError", this.__proto__ = n;
+  }
+}
+class ct extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.FailedToStartTransportError}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occurred on.
+   */
+  constructor(e, t) {
+    const n = new.target.prototype;
+    super(e), this.transport = t, this.errorType = "FailedToStartTransportError", this.__proto__ = n;
+  }
+}
+class Ue extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.FailedToNegotiateWithServerError}.
+   *
+   * @param {string} message A descriptive error message.
+   */
+  constructor(e) {
+    const t = new.target.prototype;
+    super(e), this.errorType = "FailedToNegotiateWithServerError", this.__proto__ = t;
+  }
+}
+class lt extends Error {
+  /** Constructs a new instance of {@link @microsoft/signalr.AggregateErrors}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {Error[]} innerErrors The collection of errors this error is aggregating.
+   */
+  constructor(e, t) {
+    const n = new.target.prototype;
+    super(e), this.innerErrors = t, this.__proto__ = n;
+  }
+}
+class Xe {
+  constructor(e, t, n) {
+    this.statusCode = e, this.statusText = t, this.content = n;
+  }
+}
+class Ie {
+  get(e, t) {
+    return this.send({
+      ...t,
+      method: "GET",
+      url: e
+    });
+  }
+  post(e, t) {
+    return this.send({
+      ...t,
+      method: "POST",
+      url: e
+    });
+  }
+  delete(e, t) {
+    return this.send({
+      ...t,
+      method: "DELETE",
+      url: e
+    });
+  }
+  /** Gets all cookies that apply to the specified URL.
+   *
+   * @param url The URL that the cookies are valid for.
+   * @returns {string} A string containing all the key-value cookie pairs for the specified URL.
+   */
+  // @ts-ignore
+  getCookieString(e) {
+    return "";
+  }
+}
+var h;
+(function(r) {
+  r[r.Trace = 0] = "Trace", r[r.Debug = 1] = "Debug", r[r.Information = 2] = "Information", r[r.Warning = 3] = "Warning", r[r.Error = 4] = "Error", r[r.Critical = 5] = "Critical", r[r.None = 6] = "None";
+})(h || (h = {}));
+class fe {
+  constructor() {
+  }
+  /** @inheritDoc */
+  // eslint-disable-next-line
+  log(e, t) {
+  }
+}
+fe.instance = new fe();
+const ut = "8.0.7";
+class D {
+  static isRequired(e, t) {
+    if (e == null)
+      throw new Error(`The '${t}' argument is required.`);
+  }
+  static isNotEmpty(e, t) {
+    if (!e || e.match(/^\s*$/))
+      throw new Error(`The '${t}' argument should not be empty.`);
+  }
+  static isIn(e, t, n) {
+    if (!(e in t))
+      throw new Error(`Unknown ${n} value: ${e}.`);
+  }
+}
+class k {
+  // react-native has a window but no document so we should check both
+  static get isBrowser() {
+    return !k.isNode && typeof window == "object" && typeof window.document == "object";
+  }
+  // WebWorkers don't have a window object so the isBrowser check would fail
+  static get isWebWorker() {
+    return !k.isNode && typeof self == "object" && "importScripts" in self;
+  }
+  // react-native has a window but no document
+  static get isReactNative() {
+    return !k.isNode && typeof window == "object" && typeof window.document > "u";
+  }
+  // Node apps shouldn't have a window object, but WebWorkers don't either
+  // so we need to check for both WebWorker and window
+  static get isNode() {
+    return typeof process < "u" && process.release && process.release.name === "node";
+  }
+}
+function pe(r, e) {
+  let t = "";
+  return te(r) ? (t = `Binary data of length ${r.byteLength}`, e && (t += `. Content: '${dt(r)}'`)) : typeof r == "string" && (t = `String data of length ${r.length}`, e && (t += `. Content: '${r}'`)), t;
+}
+function dt(r) {
+  const e = new Uint8Array(r);
+  let t = "";
+  return e.forEach((n) => {
+    const s = n < 16 ? "0" : "";
+    t += `0x${s}${n.toString(16)} `;
+  }), t.substr(0, t.length - 1);
+}
+function te(r) {
+  return r && typeof ArrayBuffer < "u" && (r instanceof ArrayBuffer || // Sometimes we get an ArrayBuffer that doesn't satisfy instanceof
+  r.constructor && r.constructor.name === "ArrayBuffer");
+}
+async function Ze(r, e, t, n, s, o) {
+  const i = {}, [c, a] = ce();
+  i[c] = a, r.log(h.Trace, `(${e} transport) sending data. ${pe(s, o.logMessageContent)}.`);
+  const l = te(s) ? "arraybuffer" : "text", u = await t.post(n, {
+    content: s,
+    headers: { ...i, ...o.headers },
+    responseType: l,
+    timeout: o.timeout,
+    withCredentials: o.withCredentials
+  });
+  r.log(h.Trace, `(${e} transport) request complete. Response status: ${u.statusCode}.`);
+}
+function ht(r) {
+  return r === void 0 ? new be(h.Information) : r === null ? fe.instance : r.log !== void 0 ? r : new be(r);
+}
+class ft {
+  constructor(e, t) {
+    this._subject = e, this._observer = t;
+  }
+  dispose() {
+    const e = this._subject.observers.indexOf(this._observer);
+    e > -1 && this._subject.observers.splice(e, 1), this._subject.observers.length === 0 && this._subject.cancelCallback && this._subject.cancelCallback().catch((t) => {
+    });
+  }
+}
+class be {
+  constructor(e) {
+    this._minLevel = e, this.out = console;
+  }
+  log(e, t) {
+    if (e >= this._minLevel) {
+      const n = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${h[e]}: ${t}`;
+      switch (e) {
+        case h.Critical:
+        case h.Error:
+          this.out.error(n);
+          break;
+        case h.Warning:
+          this.out.warn(n);
+          break;
+        case h.Information:
+          this.out.info(n);
+          break;
+        default:
+          this.out.log(n);
+          break;
+      }
+    }
+  }
+}
+function ce() {
+  let r = "X-SignalR-User-Agent";
+  return k.isNode && (r = "User-Agent"), [r, pt(ut, gt(), _t(), mt())];
+}
+function pt(r, e, t, n) {
+  let s = "Microsoft SignalR/";
+  const o = r.split(".");
+  return s += `${o[0]}.${o[1]}`, s += ` (${r}; `, e && e !== "" ? s += `${e}; ` : s += "Unknown OS; ", s += `${t}`, n ? s += `; ${n}` : s += "; Unknown Runtime Version", s += ")", s;
+}
+function gt() {
+  if (k.isNode)
+    switch (process.platform) {
+      case "win32":
+        return "Windows NT";
+      case "darwin":
+        return "macOS";
+      case "linux":
+        return "Linux";
+      default:
+        return process.platform;
+    }
+  else
+    return "";
+}
+function mt() {
+  if (k.isNode)
+    return process.versions.node;
+}
+function _t() {
+  return k.isNode ? "NodeJS" : "Browser";
+}
+function Ee(r) {
+  return r.stack ? r.stack : r.message ? r.message : `${r}`;
+}
+function yt() {
+  if (typeof globalThis < "u")
+    return globalThis;
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u")
+    return window;
+  if (typeof global < "u")
+    return global;
+  throw new Error("could not find global");
+}
+class wt extends Ie {
+  constructor(e) {
+    if (super(), this._logger = e, typeof fetch > "u" || k.isNode) {
+      const t = typeof __webpack_require__ == "function" ? __non_webpack_require__ : require;
+      this._jar = new (t("tough-cookie")).CookieJar(), typeof fetch > "u" ? this._fetchType = t("node-fetch") : this._fetchType = fetch, this._fetchType = t("fetch-cookie")(this._fetchType, this._jar);
+    } else
+      this._fetchType = fetch.bind(yt());
+    if (typeof AbortController > "u") {
+      const t = typeof __webpack_require__ == "function" ? __non_webpack_require__ : require;
+      this._abortControllerType = t("abort-controller");
+    } else
+      this._abortControllerType = AbortController;
+  }
+  /** @inheritDoc */
+  async send(e) {
+    if (e.abortSignal && e.abortSignal.aborted)
+      throw new K();
+    if (!e.method)
+      throw new Error("No method defined.");
+    if (!e.url)
+      throw new Error("No url defined.");
+    const t = new this._abortControllerType();
+    let n;
+    e.abortSignal && (e.abortSignal.onabort = () => {
+      t.abort(), n = new K();
+    });
+    let s = null;
+    if (e.timeout) {
+      const a = e.timeout;
+      s = setTimeout(() => {
+        t.abort(), this._logger.log(h.Warning, "Timeout from HTTP request."), n = new Le();
+      }, a);
+    }
+    e.content === "" && (e.content = void 0), e.content && (e.headers = e.headers || {}, te(e.content) ? e.headers["Content-Type"] = "application/octet-stream" : e.headers["Content-Type"] = "text/plain;charset=UTF-8");
+    let o;
+    try {
+      o = await this._fetchType(e.url, {
+        body: e.content,
+        cache: "no-cache",
+        credentials: e.withCredentials === !0 ? "include" : "same-origin",
+        headers: {
+          "X-Requested-With": "XMLHttpRequest",
+          ...e.headers
+        },
+        method: e.method,
+        mode: "cors",
+        redirect: "follow",
+        signal: t.signal
+      });
+    } catch (a) {
+      throw n || (this._logger.log(h.Warning, `Error from HTTP request. ${a}.`), a);
+    } finally {
+      s && clearTimeout(s), e.abortSignal && (e.abortSignal.onabort = null);
+    }
+    if (!o.ok) {
+      const a = await He(o, "text");
+      throw new V(a || o.statusText, o.status);
+    }
+    const c = await He(o, e.responseType);
+    return new Xe(o.status, o.statusText, c);
+  }
+  getCookieString(e) {
+    let t = "";
+    return k.isNode && this._jar && this._jar.getCookies(e, (n, s) => t = s.join("; ")), t;
+  }
+}
+function He(r, e) {
+  let t;
+  switch (e) {
+    case "arraybuffer":
+      t = r.arrayBuffer();
+      break;
+    case "text":
+      t = r.text();
+      break;
+    case "blob":
+    case "document":
+    case "json":
+      throw new Error(`${e} is not supported.`);
+    default:
+      t = r.text();
+      break;
+  }
+  return t;
+}
+class St extends Ie {
+  constructor(e) {
+    super(), this._logger = e;
+  }
+  /** @inheritDoc */
+  send(e) {
+    return e.abortSignal && e.abortSignal.aborted ? Promise.reject(new K()) : e.method ? e.url ? new Promise((t, n) => {
+      const s = new XMLHttpRequest();
+      s.open(e.method, e.url, !0), s.withCredentials = e.withCredentials === void 0 ? !0 : e.withCredentials, s.setRequestHeader("X-Requested-With", "XMLHttpRequest"), e.content === "" && (e.content = void 0), e.content && (te(e.content) ? s.setRequestHeader("Content-Type", "application/octet-stream") : s.setRequestHeader("Content-Type", "text/plain;charset=UTF-8"));
+      const o = e.headers;
+      o && Object.keys(o).forEach((i) => {
+        s.setRequestHeader(i, o[i]);
+      }), e.responseType && (s.responseType = e.responseType), e.abortSignal && (e.abortSignal.onabort = () => {
+        s.abort(), n(new K());
+      }), e.timeout && (s.timeout = e.timeout), s.onload = () => {
+        e.abortSignal && (e.abortSignal.onabort = null), s.status >= 200 && s.status < 300 ? t(new Xe(s.status, s.statusText, s.response || s.responseText)) : n(new V(s.response || s.responseText || s.statusText, s.status));
+      }, s.onerror = () => {
+        this._logger.log(h.Warning, `Error from HTTP request. ${s.status}: ${s.statusText}.`), n(new V(s.statusText, s.status));
+      }, s.ontimeout = () => {
+        this._logger.log(h.Warning, "Timeout from HTTP request."), n(new Le());
+      }, s.send(e.content);
+    }) : Promise.reject(new Error("No url defined.")) : Promise.reject(new Error("No method defined."));
+  }
+}
+class bt extends Ie {
+  /** Creates a new instance of the {@link @microsoft/signalr.DefaultHttpClient}, using the provided {@link @microsoft/signalr.ILogger} to log messages. */
+  constructor(e) {
+    if (super(), typeof fetch < "u" || k.isNode)
+      this._httpClient = new wt(e);
+    else if (typeof XMLHttpRequest < "u")
+      this._httpClient = new St(e);
+    else
+      throw new Error("No usable HttpClient found.");
+  }
+  /** @inheritDoc */
+  send(e) {
+    return e.abortSignal && e.abortSignal.aborted ? Promise.reject(new K()) : e.method ? e.url ? this._httpClient.send(e) : Promise.reject(new Error("No url defined.")) : Promise.reject(new Error("No method defined."));
+  }
+  getCookieString(e) {
+    return this._httpClient.getCookieString(e);
+  }
+}
+class q {
+  static write(e) {
+    return `${e}${q.RecordSeparator}`;
+  }
+  static parse(e) {
+    if (e[e.length - 1] !== q.RecordSeparator)
+      throw new Error("Message is incomplete.");
+    const t = e.split(q.RecordSeparator);
+    return t.pop(), t;
+  }
+}
+q.RecordSeparatorCode = 30;
+q.RecordSeparator = String.fromCharCode(q.RecordSeparatorCode);
+class Tt {
+  // Handshake request is always JSON
+  writeHandshakeRequest(e) {
+    return q.write(JSON.stringify(e));
+  }
+  parseHandshakeResponse(e) {
+    let t, n;
+    if (te(e)) {
+      const c = new Uint8Array(e), a = c.indexOf(q.RecordSeparatorCode);
+      if (a === -1)
+        throw new Error("Message is incomplete.");
+      const l = a + 1;
+      t = String.fromCharCode.apply(null, Array.prototype.slice.call(c.slice(0, l))), n = c.byteLength > l ? c.slice(l).buffer : null;
+    } else {
+      const c = e, a = c.indexOf(q.RecordSeparator);
+      if (a === -1)
+        throw new Error("Message is incomplete.");
+      const l = a + 1;
+      t = c.substring(0, l), n = c.length > l ? c.substring(l) : null;
+    }
+    const s = q.parse(t), o = JSON.parse(s[0]);
+    if (o.type)
+      throw new Error("Expected a handshake response from the server.");
+    return [n, o];
+  }
+}
+var _;
+(function(r) {
+  r[r.Invocation = 1] = "Invocation", r[r.StreamItem = 2] = "StreamItem", r[r.Completion = 3] = "Completion", r[r.StreamInvocation = 4] = "StreamInvocation", r[r.CancelInvocation = 5] = "CancelInvocation", r[r.Ping = 6] = "Ping", r[r.Close = 7] = "Close", r[r.Ack = 8] = "Ack", r[r.Sequence = 9] = "Sequence";
+})(_ || (_ = {}));
+class Ct {
+  constructor() {
+    this.observers = [];
+  }
+  next(e) {
+    for (const t of this.observers)
+      t.next(e);
+  }
+  error(e) {
+    for (const t of this.observers)
+      t.error && t.error(e);
+  }
+  complete() {
+    for (const e of this.observers)
+      e.complete && e.complete();
+  }
+  subscribe(e) {
+    return this.observers.push(e), new ft(this, e);
+  }
+}
+class It {
+  constructor(e, t, n) {
+    this._bufferSize = 1e5, this._messages = [], this._totalMessageCount = 0, this._waitForSequenceMessage = !1, this._nextReceivingSequenceId = 1, this._latestReceivedSequenceId = 0, this._bufferedByteCount = 0, this._reconnectInProgress = !1, this._protocol = e, this._connection = t, this._bufferSize = n;
+  }
+  async _send(e) {
+    const t = this._protocol.writeMessage(e);
+    let n = Promise.resolve();
+    if (this._isInvocationMessage(e)) {
+      this._totalMessageCount++;
+      let s = () => {
+      }, o = () => {
+      };
+      te(t) ? this._bufferedByteCount += t.byteLength : this._bufferedByteCount += t.length, this._bufferedByteCount >= this._bufferSize && (n = new Promise((i, c) => {
+        s = i, o = c;
+      })), this._messages.push(new vt(t, this._totalMessageCount, s, o));
+    }
+    try {
+      this._reconnectInProgress || await this._connection.send(t);
+    } catch {
+      this._disconnected();
+    }
+    await n;
+  }
+  _ack(e) {
+    let t = -1;
+    for (let n = 0; n < this._messages.length; n++) {
+      const s = this._messages[n];
+      if (s._id <= e.sequenceId)
+        t = n, te(s._message) ? this._bufferedByteCount -= s._message.byteLength : this._bufferedByteCount -= s._message.length, s._resolver();
+      else if (this._bufferedByteCount < this._bufferSize)
+        s._resolver();
+      else
+        break;
+    }
+    t !== -1 && (this._messages = this._messages.slice(t + 1));
+  }
+  _shouldProcessMessage(e) {
+    if (this._waitForSequenceMessage)
+      return e.type !== _.Sequence ? !1 : (this._waitForSequenceMessage = !1, !0);
+    if (!this._isInvocationMessage(e))
+      return !0;
+    const t = this._nextReceivingSequenceId;
+    return this._nextReceivingSequenceId++, t <= this._latestReceivedSequenceId ? (t === this._latestReceivedSequenceId && this._ackTimer(), !1) : (this._latestReceivedSequenceId = t, this._ackTimer(), !0);
+  }
+  _resetSequence(e) {
+    if (e.sequenceId > this._nextReceivingSequenceId) {
+      this._connection.stop(new Error("Sequence ID greater than amount of messages we've received."));
+      return;
+    }
+    this._nextReceivingSequenceId = e.sequenceId;
+  }
+  _disconnected() {
+    this._reconnectInProgress = !0, this._waitForSequenceMessage = !0;
+  }
+  async _resend() {
+    const e = this._messages.length !== 0 ? this._messages[0]._id : this._totalMessageCount + 1;
+    await this._connection.send(this._protocol.writeMessage({ type: _.Sequence, sequenceId: e }));
+    const t = this._messages;
+    for (const n of t)
+      await this._connection.send(n._message);
+    this._reconnectInProgress = !1;
+  }
+  _dispose(e) {
+    e ?? (e = new Error("Unable to reconnect to server."));
+    for (const t of this._messages)
+      t._rejector(e);
+  }
+  _isInvocationMessage(e) {
+    switch (e.type) {
+      case _.Invocation:
+      case _.StreamItem:
+      case _.Completion:
+      case _.StreamInvocation:
+      case _.CancelInvocation:
+        return !0;
+      case _.Close:
+      case _.Sequence:
+      case _.Ping:
+      case _.Ack:
+        return !1;
+    }
+  }
+  _ackTimer() {
+    this._ackTimerHandle === void 0 && (this._ackTimerHandle = setTimeout(async () => {
+      try {
+        this._reconnectInProgress || await this._connection.send(this._protocol.writeMessage({ type: _.Ack, sequenceId: this._latestReceivedSequenceId }));
+      } catch {
+      }
+      clearTimeout(this._ackTimerHandle), this._ackTimerHandle = void 0;
+    }, 1e3));
+  }
+}
+class vt {
+  constructor(e, t, n, s) {
+    this._message = e, this._id = t, this._resolver = n, this._rejector = s;
+  }
+}
+const kt = 30 * 1e3, At = 15 * 1e3, Et = 1e5;
+var v;
+(function(r) {
+  r.Disconnected = "Disconnected", r.Connecting = "Connecting", r.Connected = "Connected", r.Disconnecting = "Disconnecting", r.Reconnecting = "Reconnecting";
+})(v || (v = {}));
+class Ge {
+  /** @internal */
+  // Using a public static factory method means we can have a private constructor and an _internal_
+  // create method that can be used by HubConnectionBuilder. An "internal" constructor would just
+  // be stripped away and the '.d.ts' file would have no constructor, which is interpreted as a
+  // public parameter-less constructor.
+  static create(e, t, n, s, o, i, c) {
+    return new Ge(e, t, n, s, o, i, c);
+  }
+  constructor(e, t, n, s, o, i, c) {
+    this._nextKeepAlive = 0, this._freezeEventListener = () => {
+      this._logger.log(h.Warning, "The page is being frozen, this will likely lead to the connection being closed and messages being lost. For more information see the docs at https://learn.microsoft.com/aspnet/core/signalr/javascript-client#bsleep");
+    }, D.isRequired(e, "connection"), D.isRequired(t, "logger"), D.isRequired(n, "protocol"), this.serverTimeoutInMilliseconds = o ?? kt, this.keepAliveIntervalInMilliseconds = i ?? At, this._statefulReconnectBufferSize = c ?? Et, this._logger = t, this._protocol = n, this.connection = e, this._reconnectPolicy = s, this._handshakeProtocol = new Tt(), this.connection.onreceive = (a) => this._processIncomingData(a), this.connection.onclose = (a) => this._connectionClosed(a), this._callbacks = {}, this._methods = {}, this._closedCallbacks = [], this._reconnectingCallbacks = [], this._reconnectedCallbacks = [], this._invocationId = 0, this._receivedHandshakeResponse = !1, this._connectionState = v.Disconnected, this._connectionStarted = !1, this._cachedPingMessage = this._protocol.writeMessage({ type: _.Ping });
+  }
+  /** Indicates the state of the {@link HubConnection} to the server. */
+  get state() {
+    return this._connectionState;
+  }
+  /** Represents the connection id of the {@link HubConnection} on the server. The connection id will be null when the connection is either
+   *  in the disconnected state or if the negotiation step was skipped.
+   */
+  get connectionId() {
+    return this.connection && this.connection.connectionId || null;
+  }
+  /** Indicates the url of the {@link HubConnection} to the server. */
+  get baseUrl() {
+    return this.connection.baseUrl || "";
+  }
+  /**
+   * Sets a new url for the HubConnection. Note that the url can only be changed when the connection is in either the Disconnected or
+   * Reconnecting states.
+   * @param {string} url The url to connect to.
+   */
+  set baseUrl(e) {
+    if (this._connectionState !== v.Disconnected && this._connectionState !== v.Reconnecting)
+      throw new Error("The HubConnection must be in the Disconnected or Reconnecting state to change the url.");
+    if (!e)
+      throw new Error("The HubConnection url must be a valid url.");
+    this.connection.baseUrl = e;
+  }
+  /** Starts the connection.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the connection has been successfully established, or rejects with an error.
+   */
+  start() {
+    return this._startPromise = this._startWithStateTransitions(), this._startPromise;
+  }
+  async _startWithStateTransitions() {
+    if (this._connectionState !== v.Disconnected)
+      return Promise.reject(new Error("Cannot start a HubConnection that is not in the 'Disconnected' state."));
+    this._connectionState = v.Connecting, this._logger.log(h.Debug, "Starting HubConnection.");
+    try {
+      await this._startInternal(), k.isBrowser && window.document.addEventListener("freeze", this._freezeEventListener), this._connectionState = v.Connected, this._connectionStarted = !0, this._logger.log(h.Debug, "HubConnection connected successfully.");
+    } catch (e) {
+      return this._connectionState = v.Disconnected, this._logger.log(h.Debug, `HubConnection failed to start successfully because of error '${e}'.`), Promise.reject(e);
+    }
+  }
+  async _startInternal() {
+    this._stopDuringStartError = void 0, this._receivedHandshakeResponse = !1;
+    const e = new Promise((t, n) => {
+      this._handshakeResolver = t, this._handshakeRejecter = n;
+    });
+    await this.connection.start(this._protocol.transferFormat);
+    try {
+      let t = this._protocol.version;
+      this.connection.features.reconnect || (t = 1);
+      const n = {
+        protocol: this._protocol.name,
+        version: t
+      };
+      if (this._logger.log(h.Debug, "Sending handshake request."), await this._sendMessage(this._handshakeProtocol.writeHandshakeRequest(n)), this._logger.log(h.Information, `Using HubProtocol '${this._protocol.name}'.`), this._cleanupTimeout(), this._resetTimeoutPeriod(), this._resetKeepAliveInterval(), await e, this._stopDuringStartError)
+        throw this._stopDuringStartError;
+      (this.connection.features.reconnect || !1) && (this._messageBuffer = new It(this._protocol, this.connection, this._statefulReconnectBufferSize), this.connection.features.disconnected = this._messageBuffer._disconnected.bind(this._messageBuffer), this.connection.features.resend = () => {
+        if (this._messageBuffer)
+          return this._messageBuffer._resend();
+      }), this.connection.features.inherentKeepAlive || await this._sendMessage(this._cachedPingMessage);
+    } catch (t) {
+      throw this._logger.log(h.Debug, `Hub handshake failed with error '${t}' during start(). Stopping HubConnection.`), this._cleanupTimeout(), this._cleanupPingTimer(), await this.connection.stop(t), t;
+    }
+  }
+  /** Stops the connection.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the connection has been successfully terminated, or rejects with an error.
+   */
+  async stop() {
+    const e = this._startPromise;
+    this.connection.features.reconnect = !1, this._stopPromise = this._stopInternal(), await this._stopPromise;
+    try {
+      await e;
+    } catch {
+    }
+  }
+  _stopInternal(e) {
+    if (this._connectionState === v.Disconnected)
+      return this._logger.log(h.Debug, `Call to HubConnection.stop(${e}) ignored because it is already in the disconnected state.`), Promise.resolve();
+    if (this._connectionState === v.Disconnecting)
+      return this._logger.log(h.Debug, `Call to HttpConnection.stop(${e}) ignored because the connection is already in the disconnecting state.`), this._stopPromise;
+    const t = this._connectionState;
+    return this._connectionState = v.Disconnecting, this._logger.log(h.Debug, "Stopping HubConnection."), this._reconnectDelayHandle ? (this._logger.log(h.Debug, "Connection stopped during reconnect delay. Done reconnecting."), clearTimeout(this._reconnectDelayHandle), this._reconnectDelayHandle = void 0, this._completeClose(), Promise.resolve()) : (t === v.Connected && this._sendCloseMessage(), this._cleanupTimeout(), this._cleanupPingTimer(), this._stopDuringStartError = e || new K("The connection was stopped before the hub handshake could complete."), this.connection.stop(e));
+  }
+  async _sendCloseMessage() {
+    try {
+      await this._sendWithProtocol(this._createCloseMessage());
+    } catch {
+    }
+  }
+  /** Invokes a streaming hub method on the server using the specified name and arguments.
+   *
+   * @typeparam T The type of the items returned by the server.
+   * @param {string} methodName The name of the server method to invoke.
+   * @param {any[]} args The arguments used to invoke the server method.
+   * @returns {IStreamResult<T>} An object that yields results from the server as they are received.
+   */
+  stream(e, ...t) {
+    const [n, s] = this._replaceStreamingParams(t), o = this._createStreamInvocation(e, t, s);
+    let i;
+    const c = new Ct();
+    return c.cancelCallback = () => {
+      const a = this._createCancelInvocation(o.invocationId);
+      return delete this._callbacks[o.invocationId], i.then(() => this._sendWithProtocol(a));
+    }, this._callbacks[o.invocationId] = (a, l) => {
+      if (l) {
+        c.error(l);
+        return;
+      } else a && (a.type === _.Completion ? a.error ? c.error(new Error(a.error)) : c.complete() : c.next(a.item));
+    }, i = this._sendWithProtocol(o).catch((a) => {
+      c.error(a), delete this._callbacks[o.invocationId];
+    }), this._launchStreams(n, i), c;
+  }
+  _sendMessage(e) {
+    return this._resetKeepAliveInterval(), this.connection.send(e);
+  }
+  /**
+   * Sends a js object to the server.
+   * @param message The js object to serialize and send.
+   */
+  _sendWithProtocol(e) {
+    return this._messageBuffer ? this._messageBuffer._send(e) : this._sendMessage(this._protocol.writeMessage(e));
+  }
+  /** Invokes a hub method on the server using the specified name and arguments. Does not wait for a response from the receiver.
+   *
+   * The Promise returned by this method resolves when the client has sent the invocation to the server. The server may still
+   * be processing the invocation.
+   *
+   * @param {string} methodName The name of the server method to invoke.
+   * @param {any[]} args The arguments used to invoke the server method.
+   * @returns {Promise<void>} A Promise that resolves when the invocation has been successfully sent, or rejects with an error.
+   */
+  send(e, ...t) {
+    const [n, s] = this._replaceStreamingParams(t), o = this._sendWithProtocol(this._createInvocation(e, t, !0, s));
+    return this._launchStreams(n, o), o;
+  }
+  /** Invokes a hub method on the server using the specified name and arguments.
+   *
+   * The Promise returned by this method resolves when the server indicates it has finished invoking the method. When the promise
+   * resolves, the server has finished invoking the method. If the server method returns a result, it is produced as the result of
+   * resolving the Promise.
+   *
+   * @typeparam T The expected return type.
+   * @param {string} methodName The name of the server method to invoke.
+   * @param {any[]} args The arguments used to invoke the server method.
+   * @returns {Promise<T>} A Promise that resolves with the result of the server method (if any), or rejects with an error.
+   */
+  invoke(e, ...t) {
+    const [n, s] = this._replaceStreamingParams(t), o = this._createInvocation(e, t, !1, s);
+    return new Promise((c, a) => {
+      this._callbacks[o.invocationId] = (u, p) => {
+        if (p) {
+          a(p);
+          return;
+        } else u && (u.type === _.Completion ? u.error ? a(new Error(u.error)) : c(u.result) : a(new Error(`Unexpected message type: ${u.type}`)));
+      };
+      const l = this._sendWithProtocol(o).catch((u) => {
+        a(u), delete this._callbacks[o.invocationId];
+      });
+      this._launchStreams(n, l);
+    });
+  }
+  on(e, t) {
+    !e || !t || (e = e.toLowerCase(), this._methods[e] || (this._methods[e] = []), this._methods[e].indexOf(t) === -1 && this._methods[e].push(t));
+  }
+  off(e, t) {
+    if (!e)
+      return;
+    e = e.toLowerCase();
+    const n = this._methods[e];
+    if (n)
+      if (t) {
+        const s = n.indexOf(t);
+        s !== -1 && (n.splice(s, 1), n.length === 0 && delete this._methods[e]);
+      } else
+        delete this._methods[e];
+  }
+  /** Registers a handler that will be invoked when the connection is closed.
+   *
+   * @param {Function} callback The handler that will be invoked when the connection is closed. Optionally receives a single argument containing the error that caused the connection to close (if any).
+   */
+  onclose(e) {
+    e && this._closedCallbacks.push(e);
+  }
+  /** Registers a handler that will be invoked when the connection starts reconnecting.
+   *
+   * @param {Function} callback The handler that will be invoked when the connection starts reconnecting. Optionally receives a single argument containing the error that caused the connection to start reconnecting (if any).
+   */
+  onreconnecting(e) {
+    e && this._reconnectingCallbacks.push(e);
+  }
+  /** Registers a handler that will be invoked when the connection successfully reconnects.
+   *
+   * @param {Function} callback The handler that will be invoked when the connection successfully reconnects.
+   */
+  onreconnected(e) {
+    e && this._reconnectedCallbacks.push(e);
+  }
+  _processIncomingData(e) {
+    if (this._cleanupTimeout(), this._receivedHandshakeResponse || (e = this._processHandshakeResponse(e), this._receivedHandshakeResponse = !0), e) {
+      const t = this._protocol.parseMessages(e, this._logger);
+      for (const n of t)
+        if (!(this._messageBuffer && !this._messageBuffer._shouldProcessMessage(n)))
+          switch (n.type) {
+            case _.Invocation:
+              this._invokeClientMethod(n).catch((s) => {
+                this._logger.log(h.Error, `Invoke client method threw error: ${Ee(s)}`);
+              });
+              break;
+            case _.StreamItem:
+            case _.Completion: {
+              const s = this._callbacks[n.invocationId];
+              if (s) {
+                n.type === _.Completion && delete this._callbacks[n.invocationId];
+                try {
+                  s(n);
+                } catch (o) {
+                  this._logger.log(h.Error, `Stream callback threw error: ${Ee(o)}`);
+                }
+              }
+              break;
+            }
+            case _.Ping:
+              break;
+            case _.Close: {
+              this._logger.log(h.Information, "Close message received from server.");
+              const s = n.error ? new Error("Server returned an error on close: " + n.error) : void 0;
+              n.allowReconnect === !0 ? this.connection.stop(s) : this._stopPromise = this._stopInternal(s);
+              break;
+            }
+            case _.Ack:
+              this._messageBuffer && this._messageBuffer._ack(n);
+              break;
+            case _.Sequence:
+              this._messageBuffer && this._messageBuffer._resetSequence(n);
+              break;
+            default:
+              this._logger.log(h.Warning, `Invalid message type: ${n.type}.`);
+              break;
+          }
+    }
+    this._resetTimeoutPeriod();
+  }
+  _processHandshakeResponse(e) {
+    let t, n;
+    try {
+      [n, t] = this._handshakeProtocol.parseHandshakeResponse(e);
+    } catch (s) {
+      const o = "Error parsing handshake response: " + s;
+      this._logger.log(h.Error, o);
+      const i = new Error(o);
+      throw this._handshakeRejecter(i), i;
+    }
+    if (t.error) {
+      const s = "Server returned handshake error: " + t.error;
+      this._logger.log(h.Error, s);
+      const o = new Error(s);
+      throw this._handshakeRejecter(o), o;
+    } else
+      this._logger.log(h.Debug, "Server handshake complete.");
+    return this._handshakeResolver(), n;
+  }
+  _resetKeepAliveInterval() {
+    this.connection.features.inherentKeepAlive || (this._nextKeepAlive = (/* @__PURE__ */ new Date()).getTime() + this.keepAliveIntervalInMilliseconds, this._cleanupPingTimer());
+  }
+  _resetTimeoutPeriod() {
+    if ((!this.connection.features || !this.connection.features.inherentKeepAlive) && (this._timeoutHandle = setTimeout(() => this.serverTimeout(), this.serverTimeoutInMilliseconds), this._pingServerHandle === void 0)) {
+      let e = this._nextKeepAlive - (/* @__PURE__ */ new Date()).getTime();
+      e < 0 && (e = 0), this._pingServerHandle = setTimeout(async () => {
+        if (this._connectionState === v.Connected)
+          try {
+            await this._sendMessage(this._cachedPingMessage);
+          } catch {
+            this._cleanupPingTimer();
+          }
+      }, e);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  serverTimeout() {
+    this.connection.stop(new Error("Server timeout elapsed without receiving a message from the server."));
+  }
+  async _invokeClientMethod(e) {
+    const t = e.target.toLowerCase(), n = this._methods[t];
+    if (!n) {
+      this._logger.log(h.Warning, `No client method with the name '${t}' found.`), e.invocationId && (this._logger.log(h.Warning, `No result given for '${t}' method and invocation ID '${e.invocationId}'.`), await this._sendWithProtocol(this._createCompletionMessage(e.invocationId, "Client didn't provide a result.", null)));
+      return;
+    }
+    const s = n.slice(), o = !!e.invocationId;
+    let i, c, a;
+    for (const l of s)
+      try {
+        const u = i;
+        i = await l.apply(this, e.arguments), o && i && u && (this._logger.log(h.Error, `Multiple results provided for '${t}'. Sending error to server.`), a = this._createCompletionMessage(e.invocationId, "Client provided multiple results.", null)), c = void 0;
+      } catch (u) {
+        c = u, this._logger.log(h.Error, `A callback for the method '${t}' threw error '${u}'.`);
+      }
+    a ? await this._sendWithProtocol(a) : o ? (c ? a = this._createCompletionMessage(e.invocationId, `${c}`, null) : i !== void 0 ? a = this._createCompletionMessage(e.invocationId, null, i) : (this._logger.log(h.Warning, `No result given for '${t}' method and invocation ID '${e.invocationId}'.`), a = this._createCompletionMessage(e.invocationId, "Client didn't provide a result.", null)), await this._sendWithProtocol(a)) : i && this._logger.log(h.Error, `Result given for '${t}' method but server is not expecting a result.`);
+  }
+  _connectionClosed(e) {
+    this._logger.log(h.Debug, `HubConnection.connectionClosed(${e}) called while in state ${this._connectionState}.`), this._stopDuringStartError = this._stopDuringStartError || e || new K("The underlying connection was closed before the hub handshake could complete."), this._handshakeResolver && this._handshakeResolver(), this._cancelCallbacksWithError(e || new Error("Invocation canceled due to the underlying connection being closed.")), this._cleanupTimeout(), this._cleanupPingTimer(), this._connectionState === v.Disconnecting ? this._completeClose(e) : this._connectionState === v.Connected && this._reconnectPolicy ? this._reconnect(e) : this._connectionState === v.Connected && this._completeClose(e);
+  }
+  _completeClose(e) {
+    if (this._connectionStarted) {
+      this._connectionState = v.Disconnected, this._connectionStarted = !1, this._messageBuffer && (this._messageBuffer._dispose(e ?? new Error("Connection closed.")), this._messageBuffer = void 0), k.isBrowser && window.document.removeEventListener("freeze", this._freezeEventListener);
+      try {
+        this._closedCallbacks.forEach((t) => t.apply(this, [e]));
+      } catch (t) {
+        this._logger.log(h.Error, `An onclose callback called with error '${e}' threw error '${t}'.`);
+      }
+    }
+  }
+  async _reconnect(e) {
+    const t = Date.now();
+    let n = 0, s = e !== void 0 ? e : new Error("Attempting to reconnect due to a unknown error."), o = this._getNextRetryDelay(n++, 0, s);
+    if (o === null) {
+      this._logger.log(h.Debug, "Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt."), this._completeClose(e);
+      return;
+    }
+    if (this._connectionState = v.Reconnecting, e ? this._logger.log(h.Information, `Connection reconnecting because of error '${e}'.`) : this._logger.log(h.Information, "Connection reconnecting."), this._reconnectingCallbacks.length !== 0) {
+      try {
+        this._reconnectingCallbacks.forEach((i) => i.apply(this, [e]));
+      } catch (i) {
+        this._logger.log(h.Error, `An onreconnecting callback called with error '${e}' threw error '${i}'.`);
+      }
+      if (this._connectionState !== v.Reconnecting) {
+        this._logger.log(h.Debug, "Connection left the reconnecting state in onreconnecting callback. Done reconnecting.");
+        return;
+      }
+    }
+    for (; o !== null; ) {
+      if (this._logger.log(h.Information, `Reconnect attempt number ${n} will start in ${o} ms.`), await new Promise((i) => {
+        this._reconnectDelayHandle = setTimeout(i, o);
+      }), this._reconnectDelayHandle = void 0, this._connectionState !== v.Reconnecting) {
+        this._logger.log(h.Debug, "Connection left the reconnecting state during reconnect delay. Done reconnecting.");
+        return;
+      }
+      try {
+        if (await this._startInternal(), this._connectionState = v.Connected, this._logger.log(h.Information, "HubConnection reconnected successfully."), this._reconnectedCallbacks.length !== 0)
+          try {
+            this._reconnectedCallbacks.forEach((i) => i.apply(this, [this.connection.connectionId]));
+          } catch (i) {
+            this._logger.log(h.Error, `An onreconnected callback called with connectionId '${this.connection.connectionId}; threw error '${i}'.`);
+          }
+        return;
+      } catch (i) {
+        if (this._logger.log(h.Information, `Reconnect attempt failed because of error '${i}'.`), this._connectionState !== v.Reconnecting) {
+          this._logger.log(h.Debug, `Connection moved to the '${this._connectionState}' from the reconnecting state during reconnect attempt. Done reconnecting.`), this._connectionState === v.Disconnecting && this._completeClose();
+          return;
+        }
+        s = i instanceof Error ? i : new Error(i.toString()), o = this._getNextRetryDelay(n++, Date.now() - t, s);
+      }
+    }
+    this._logger.log(h.Information, `Reconnect retries have been exhausted after ${Date.now() - t} ms and ${n} failed attempts. Connection disconnecting.`), this._completeClose();
+  }
+  _getNextRetryDelay(e, t, n) {
+    try {
+      return this._reconnectPolicy.nextRetryDelayInMilliseconds({
+        elapsedMilliseconds: t,
+        previousRetryCount: e,
+        retryReason: n
+      });
+    } catch (s) {
+      return this._logger.log(h.Error, `IRetryPolicy.nextRetryDelayInMilliseconds(${e}, ${t}) threw error '${s}'.`), null;
+    }
+  }
+  _cancelCallbacksWithError(e) {
+    const t = this._callbacks;
+    this._callbacks = {}, Object.keys(t).forEach((n) => {
+      const s = t[n];
+      try {
+        s(null, e);
+      } catch (o) {
+        this._logger.log(h.Error, `Stream 'error' callback called with '${e}' threw error: ${Ee(o)}`);
+      }
+    });
+  }
+  _cleanupPingTimer() {
+    this._pingServerHandle && (clearTimeout(this._pingServerHandle), this._pingServerHandle = void 0);
+  }
+  _cleanupTimeout() {
+    this._timeoutHandle && clearTimeout(this._timeoutHandle);
+  }
+  _createInvocation(e, t, n, s) {
+    if (n)
+      return s.length !== 0 ? {
+        arguments: t,
+        streamIds: s,
+        target: e,
+        type: _.Invocation
+      } : {
+        arguments: t,
+        target: e,
+        type: _.Invocation
+      };
+    {
+      const o = this._invocationId;
+      return this._invocationId++, s.length !== 0 ? {
+        arguments: t,
+        invocationId: o.toString(),
+        streamIds: s,
+        target: e,
+        type: _.Invocation
+      } : {
+        arguments: t,
+        invocationId: o.toString(),
+        target: e,
+        type: _.Invocation
+      };
+    }
+  }
+  _launchStreams(e, t) {
+    if (e.length !== 0) {
+      t || (t = Promise.resolve());
+      for (const n in e)
+        e[n].subscribe({
+          complete: () => {
+            t = t.then(() => this._sendWithProtocol(this._createCompletionMessage(n)));
+          },
+          error: (s) => {
+            let o;
+            s instanceof Error ? o = s.message : s && s.toString ? o = s.toString() : o = "Unknown error", t = t.then(() => this._sendWithProtocol(this._createCompletionMessage(n, o)));
+          },
+          next: (s) => {
+            t = t.then(() => this._sendWithProtocol(this._createStreamItemMessage(n, s)));
+          }
+        });
+    }
+  }
+  _replaceStreamingParams(e) {
+    const t = [], n = [];
+    for (let s = 0; s < e.length; s++) {
+      const o = e[s];
+      if (this._isObservable(o)) {
+        const i = this._invocationId;
+        this._invocationId++, t[i] = o, n.push(i.toString()), e.splice(s, 1);
+      }
+    }
+    return [t, n];
+  }
+  _isObservable(e) {
+    return e && e.subscribe && typeof e.subscribe == "function";
+  }
+  _createStreamInvocation(e, t, n) {
+    const s = this._invocationId;
+    return this._invocationId++, n.length !== 0 ? {
+      arguments: t,
+      invocationId: s.toString(),
+      streamIds: n,
+      target: e,
+      type: _.StreamInvocation
+    } : {
+      arguments: t,
+      invocationId: s.toString(),
+      target: e,
+      type: _.StreamInvocation
+    };
+  }
+  _createCancelInvocation(e) {
+    return {
+      invocationId: e,
+      type: _.CancelInvocation
+    };
+  }
+  _createStreamItemMessage(e, t) {
+    return {
+      invocationId: e,
+      item: t,
+      type: _.StreamItem
+    };
+  }
+  _createCompletionMessage(e, t, n) {
+    return t ? {
+      error: t,
+      invocationId: e,
+      type: _.Completion
+    } : {
+      invocationId: e,
+      result: n,
+      type: _.Completion
+    };
+  }
+  _createCloseMessage() {
+    return { type: _.Close };
+  }
+}
+const Pt = [0, 2e3, 1e4, 3e4, null];
+class je {
+  constructor(e) {
+    this._retryDelays = e !== void 0 ? [...e, null] : Pt;
+  }
+  nextRetryDelayInMilliseconds(e) {
+    return this._retryDelays[e.previousRetryCount];
+  }
+}
+class ee {
+}
+ee.Authorization = "Authorization";
+ee.Cookie = "Cookie";
+class $t extends Ie {
+  constructor(e, t) {
+    super(), this._innerClient = e, this._accessTokenFactory = t;
+  }
+  async send(e) {
+    let t = !0;
+    this._accessTokenFactory && (!this._accessToken || e.url && e.url.indexOf("/negotiate?") > 0) && (t = !1, this._accessToken = await this._accessTokenFactory()), this._setAuthorizationHeader(e);
+    const n = await this._innerClient.send(e);
+    return t && n.statusCode === 401 && this._accessTokenFactory ? (this._accessToken = await this._accessTokenFactory(), this._setAuthorizationHeader(e), await this._innerClient.send(e)) : n;
+  }
+  _setAuthorizationHeader(e) {
+    e.headers || (e.headers = {}), this._accessToken ? e.headers[ee.Authorization] = `Bearer ${this._accessToken}` : this._accessTokenFactory && e.headers[ee.Authorization] && delete e.headers[ee.Authorization];
+  }
+  getCookieString(e) {
+    return this._innerClient.getCookieString(e);
+  }
+}
+var O;
+(function(r) {
+  r[r.None = 0] = "None", r[r.WebSockets = 1] = "WebSockets", r[r.ServerSentEvents = 2] = "ServerSentEvents", r[r.LongPolling = 4] = "LongPolling";
+})(O || (O = {}));
+var B;
+(function(r) {
+  r[r.Text = 1] = "Text", r[r.Binary = 2] = "Binary";
+})(B || (B = {}));
+let Dt = class {
+  constructor() {
+    this._isAborted = !1, this.onabort = null;
+  }
+  abort() {
+    this._isAborted || (this._isAborted = !0, this.onabort && this.onabort());
+  }
+  get signal() {
+    return this;
+  }
+  get aborted() {
+    return this._isAborted;
+  }
+};
+class ze {
+  // This is an internal type, not exported from 'index' so this is really just internal.
+  get pollAborted() {
+    return this._pollAbort.aborted;
+  }
+  constructor(e, t, n) {
+    this._httpClient = e, this._logger = t, this._pollAbort = new Dt(), this._options = n, this._running = !1, this.onreceive = null, this.onclose = null;
+  }
+  async connect(e, t) {
+    if (D.isRequired(e, "url"), D.isRequired(t, "transferFormat"), D.isIn(t, B, "transferFormat"), this._url = e, this._logger.log(h.Trace, "(LongPolling transport) Connecting."), t === B.Binary && typeof XMLHttpRequest < "u" && typeof new XMLHttpRequest().responseType != "string")
+      throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported.");
+    const [n, s] = ce(), o = { [n]: s, ...this._options.headers }, i = {
+      abortSignal: this._pollAbort.signal,
+      headers: o,
+      timeout: 1e5,
+      withCredentials: this._options.withCredentials
+    };
+    t === B.Binary && (i.responseType = "arraybuffer");
+    const c = `${e}&_=${Date.now()}`;
+    this._logger.log(h.Trace, `(LongPolling transport) polling: ${c}.`);
+    const a = await this._httpClient.get(c, i);
+    a.statusCode !== 200 ? (this._logger.log(h.Error, `(LongPolling transport) Unexpected response code: ${a.statusCode}.`), this._closeError = new V(a.statusText || "", a.statusCode), this._running = !1) : this._running = !0, this._receiving = this._poll(this._url, i);
+  }
+  async _poll(e, t) {
+    try {
+      for (; this._running; )
+        try {
+          const n = `${e}&_=${Date.now()}`;
+          this._logger.log(h.Trace, `(LongPolling transport) polling: ${n}.`);
+          const s = await this._httpClient.get(n, t);
+          s.statusCode === 204 ? (this._logger.log(h.Information, "(LongPolling transport) Poll terminated by server."), this._running = !1) : s.statusCode !== 200 ? (this._logger.log(h.Error, `(LongPolling transport) Unexpected response code: ${s.statusCode}.`), this._closeError = new V(s.statusText || "", s.statusCode), this._running = !1) : s.content ? (this._logger.log(h.Trace, `(LongPolling transport) data received. ${pe(s.content, this._options.logMessageContent)}.`), this.onreceive && this.onreceive(s.content)) : this._logger.log(h.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+        } catch (n) {
+          this._running ? n instanceof Le ? this._logger.log(h.Trace, "(LongPolling transport) Poll timed out, reissuing.") : (this._closeError = n, this._running = !1) : this._logger.log(h.Trace, `(LongPolling transport) Poll errored after shutdown: ${n.message}`);
+        }
+    } finally {
+      this._logger.log(h.Trace, "(LongPolling transport) Polling complete."), this.pollAborted || this._raiseOnClose();
+    }
+  }
+  async send(e) {
+    return this._running ? Ze(this._logger, "LongPolling", this._httpClient, this._url, e, this._options) : Promise.reject(new Error("Cannot send until the transport is connected"));
+  }
+  async stop() {
+    this._logger.log(h.Trace, "(LongPolling transport) Stopping polling."), this._running = !1, this._pollAbort.abort();
+    try {
+      await this._receiving, this._logger.log(h.Trace, `(LongPolling transport) sending DELETE request to ${this._url}.`);
+      const e = {}, [t, n] = ce();
+      e[t] = n;
+      const s = {
+        headers: { ...e, ...this._options.headers },
+        timeout: this._options.timeout,
+        withCredentials: this._options.withCredentials
+      };
+      let o;
+      try {
+        await this._httpClient.delete(this._url, s);
+      } catch (i) {
+        o = i;
+      }
+      o ? o instanceof V && (o.statusCode === 404 ? this._logger.log(h.Trace, "(LongPolling transport) A 404 response was returned from sending a DELETE request.") : this._logger.log(h.Trace, `(LongPolling transport) Error sending a DELETE request: ${o}`)) : this._logger.log(h.Trace, "(LongPolling transport) DELETE request accepted.");
+    } finally {
+      this._logger.log(h.Trace, "(LongPolling transport) Stop finished."), this._raiseOnClose();
+    }
+  }
+  _raiseOnClose() {
+    if (this.onclose) {
+      let e = "(LongPolling transport) Firing onclose event.";
+      this._closeError && (e += " Error: " + this._closeError), this._logger.log(h.Trace, e), this.onclose(this._closeError);
+    }
+  }
+}
+class Rt {
+  constructor(e, t, n, s) {
+    this._httpClient = e, this._accessToken = t, this._logger = n, this._options = s, this.onreceive = null, this.onclose = null;
+  }
+  async connect(e, t) {
+    return D.isRequired(e, "url"), D.isRequired(t, "transferFormat"), D.isIn(t, B, "transferFormat"), this._logger.log(h.Trace, "(SSE transport) Connecting."), this._url = e, this._accessToken && (e += (e.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(this._accessToken)}`), new Promise((n, s) => {
+      let o = !1;
+      if (t !== B.Text) {
+        s(new Error("The Server-Sent Events transport only supports the 'Text' transfer format"));
+        return;
+      }
+      let i;
+      if (k.isBrowser || k.isWebWorker)
+        i = new this._options.EventSource(e, { withCredentials: this._options.withCredentials });
+      else {
+        const c = this._httpClient.getCookieString(e), a = {};
+        a.Cookie = c;
+        const [l, u] = ce();
+        a[l] = u, i = new this._options.EventSource(e, { withCredentials: this._options.withCredentials, headers: { ...a, ...this._options.headers } });
+      }
+      try {
+        i.onmessage = (c) => {
+          if (this.onreceive)
+            try {
+              this._logger.log(h.Trace, `(SSE transport) data received. ${pe(c.data, this._options.logMessageContent)}.`), this.onreceive(c.data);
+            } catch (a) {
+              this._close(a);
+              return;
+            }
+        }, i.onerror = (c) => {
+          o ? this._close() : s(new Error("EventSource failed to connect. The connection could not be found on the server, either the connection ID is not present on the server, or a proxy is refusing/buffering the connection. If you have multiple servers check that sticky sessions are enabled."));
+        }, i.onopen = () => {
+          this._logger.log(h.Information, `SSE connected to ${this._url}`), this._eventSource = i, o = !0, n();
+        };
+      } catch (c) {
+        s(c);
+        return;
+      }
+    });
+  }
+  async send(e) {
+    return this._eventSource ? Ze(this._logger, "SSE", this._httpClient, this._url, e, this._options) : Promise.reject(new Error("Cannot send until the transport is connected"));
+  }
+  stop() {
+    return this._close(), Promise.resolve();
+  }
+  _close(e) {
+    this._eventSource && (this._eventSource.close(), this._eventSource = void 0, this.onclose && this.onclose(e));
+  }
+}
+class xt {
+  constructor(e, t, n, s, o, i) {
+    this._logger = n, this._accessTokenFactory = t, this._logMessageContent = s, this._webSocketConstructor = o, this._httpClient = e, this.onreceive = null, this.onclose = null, this._headers = i;
+  }
+  async connect(e, t) {
+    D.isRequired(e, "url"), D.isRequired(t, "transferFormat"), D.isIn(t, B, "transferFormat"), this._logger.log(h.Trace, "(WebSockets transport) Connecting.");
+    let n;
+    return this._accessTokenFactory && (n = await this._accessTokenFactory()), new Promise((s, o) => {
+      e = e.replace(/^http/, "ws");
+      let i;
+      const c = this._httpClient.getCookieString(e);
+      let a = !1;
+      if (k.isNode || k.isReactNative) {
+        const l = {}, [u, p] = ce();
+        l[u] = p, n && (l[ee.Authorization] = `Bearer ${n}`), c && (l[ee.Cookie] = c), i = new this._webSocketConstructor(e, void 0, {
+          headers: { ...l, ...this._headers }
+        });
+      } else
+        n && (e += (e.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(n)}`);
+      i || (i = new this._webSocketConstructor(e)), t === B.Binary && (i.binaryType = "arraybuffer"), i.onopen = (l) => {
+        this._logger.log(h.Information, `WebSocket connected to ${e}.`), this._webSocket = i, a = !0, s();
+      }, i.onerror = (l) => {
+        let u = null;
+        typeof ErrorEvent < "u" && l instanceof ErrorEvent ? u = l.error : u = "There was an error with the transport", this._logger.log(h.Information, `(WebSockets transport) ${u}.`);
+      }, i.onmessage = (l) => {
+        if (this._logger.log(h.Trace, `(WebSockets transport) data received. ${pe(l.data, this._logMessageContent)}.`), this.onreceive)
+          try {
+            this.onreceive(l.data);
+          } catch (u) {
+            this._close(u);
+            return;
+          }
+      }, i.onclose = (l) => {
+        if (a)
+          this._close(l);
+        else {
+          let u = null;
+          typeof ErrorEvent < "u" && l instanceof ErrorEvent ? u = l.error : u = "WebSocket failed to connect. The connection could not be found on the server, either the endpoint may not be a SignalR endpoint, the connection ID is not present on the server, or there is a proxy blocking WebSockets. If you have multiple servers check that sticky sessions are enabled.", o(new Error(u));
+        }
+      };
+    });
+  }
+  send(e) {
+    return this._webSocket && this._webSocket.readyState === this._webSocketConstructor.OPEN ? (this._logger.log(h.Trace, `(WebSockets transport) sending data. ${pe(e, this._logMessageContent)}.`), this._webSocket.send(e), Promise.resolve()) : Promise.reject("WebSocket is not in the OPEN state");
+  }
+  stop() {
+    return this._webSocket && this._close(void 0), Promise.resolve();
+  }
+  _close(e) {
+    this._webSocket && (this._webSocket.onclose = () => {
+    }, this._webSocket.onmessage = () => {
+    }, this._webSocket.onerror = () => {
+    }, this._webSocket.close(), this._webSocket = void 0), this._logger.log(h.Trace, "(WebSockets transport) socket closed."), this.onclose && (this._isCloseEvent(e) && (e.wasClean === !1 || e.code !== 1e3) ? this.onclose(new Error(`WebSocket closed with status code: ${e.code} (${e.reason || "no reason given"}).`)) : e instanceof Error ? this.onclose(e) : this.onclose());
+  }
+  _isCloseEvent(e) {
+    return e && typeof e.wasClean == "boolean" && typeof e.code == "number";
+  }
+}
+const qe = 100;
+class Nt {
+  constructor(e, t = {}) {
+    if (this._stopPromiseResolver = () => {
+    }, this.features = {}, this._negotiateVersion = 1, D.isRequired(e, "url"), this._logger = ht(t.logger), this.baseUrl = this._resolveUrl(e), t = t || {}, t.logMessageContent = t.logMessageContent === void 0 ? !1 : t.logMessageContent, typeof t.withCredentials == "boolean" || t.withCredentials === void 0)
+      t.withCredentials = t.withCredentials === void 0 ? !0 : t.withCredentials;
+    else
+      throw new Error("withCredentials option was not a 'boolean' or 'undefined' value");
+    t.timeout = t.timeout === void 0 ? 100 * 1e3 : t.timeout;
+    let n = null, s = null;
+    if (k.isNode && typeof require < "u") {
+      const o = typeof __webpack_require__ == "function" ? __non_webpack_require__ : require;
+      n = o("ws"), s = o("eventsource");
+    }
+    !k.isNode && typeof WebSocket < "u" && !t.WebSocket ? t.WebSocket = WebSocket : k.isNode && !t.WebSocket && n && (t.WebSocket = n), !k.isNode && typeof EventSource < "u" && !t.EventSource ? t.EventSource = EventSource : k.isNode && !t.EventSource && typeof s < "u" && (t.EventSource = s), this._httpClient = new $t(t.httpClient || new bt(this._logger), t.accessTokenFactory), this._connectionState = "Disconnected", this._connectionStarted = !1, this._options = t, this.onreceive = null, this.onclose = null;
+  }
+  async start(e) {
+    if (e = e || B.Binary, D.isIn(e, B, "transferFormat"), this._logger.log(h.Debug, `Starting connection with transfer format '${B[e]}'.`), this._connectionState !== "Disconnected")
+      return Promise.reject(new Error("Cannot start an HttpConnection that is not in the 'Disconnected' state."));
+    if (this._connectionState = "Connecting", this._startInternalPromise = this._startInternal(e), await this._startInternalPromise, this._connectionState === "Disconnecting") {
+      const t = "Failed to start the HttpConnection before stop() was called.";
+      return this._logger.log(h.Error, t), await this._stopPromise, Promise.reject(new K(t));
+    } else if (this._connectionState !== "Connected") {
+      const t = "HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!";
+      return this._logger.log(h.Error, t), Promise.reject(new K(t));
+    }
+    this._connectionStarted = !0;
+  }
+  send(e) {
+    return this._connectionState !== "Connected" ? Promise.reject(new Error("Cannot send data if the connection is not in the 'Connected' State.")) : (this._sendQueue || (this._sendQueue = new We(this.transport)), this._sendQueue.send(e));
+  }
+  async stop(e) {
+    if (this._connectionState === "Disconnected")
+      return this._logger.log(h.Debug, `Call to HttpConnection.stop(${e}) ignored because the connection is already in the disconnected state.`), Promise.resolve();
+    if (this._connectionState === "Disconnecting")
+      return this._logger.log(h.Debug, `Call to HttpConnection.stop(${e}) ignored because the connection is already in the disconnecting state.`), this._stopPromise;
+    this._connectionState = "Disconnecting", this._stopPromise = new Promise((t) => {
+      this._stopPromiseResolver = t;
+    }), await this._stopInternal(e), await this._stopPromise;
+  }
+  async _stopInternal(e) {
+    this._stopError = e;
+    try {
+      await this._startInternalPromise;
+    } catch {
+    }
+    if (this.transport) {
+      try {
+        await this.transport.stop();
+      } catch (t) {
+        this._logger.log(h.Error, `HttpConnection.transport.stop() threw error '${t}'.`), this._stopConnection();
+      }
+      this.transport = void 0;
+    } else
+      this._logger.log(h.Debug, "HttpConnection.transport is undefined in HttpConnection.stop() because start() failed.");
+  }
+  async _startInternal(e) {
+    let t = this.baseUrl;
+    this._accessTokenFactory = this._options.accessTokenFactory, this._httpClient._accessTokenFactory = this._accessTokenFactory;
+    try {
+      if (this._options.skipNegotiation)
+        if (this._options.transport === O.WebSockets)
+          this.transport = this._constructTransport(O.WebSockets), await this._startTransport(t, e);
+        else
+          throw new Error("Negotiation can only be skipped when using the WebSocket transport directly.");
+      else {
+        let n = null, s = 0;
+        do {
+          if (n = await this._getNegotiationResponse(t), this._connectionState === "Disconnecting" || this._connectionState === "Disconnected")
+            throw new K("The connection was stopped during negotiation.");
+          if (n.error)
+            throw new Error(n.error);
+          if (n.ProtocolVersion)
+            throw new Error("Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details.");
+          if (n.url && (t = n.url), n.accessToken) {
+            const o = n.accessToken;
+            this._accessTokenFactory = () => o, this._httpClient._accessToken = o, this._httpClient._accessTokenFactory = void 0;
+          }
+          s++;
+        } while (n.url && s < qe);
+        if (s === qe && n.url)
+          throw new Error("Negotiate redirection limit exceeded.");
+        await this._createTransport(t, this._options.transport, n, e);
+      }
+      this.transport instanceof ze && (this.features.inherentKeepAlive = !0), this._connectionState === "Connecting" && (this._logger.log(h.Debug, "The HttpConnection connected successfully."), this._connectionState = "Connected");
+    } catch (n) {
+      return this._logger.log(h.Error, "Failed to start the connection: " + n), this._connectionState = "Disconnected", this.transport = void 0, this._stopPromiseResolver(), Promise.reject(n);
+    }
+  }
+  async _getNegotiationResponse(e) {
+    const t = {}, [n, s] = ce();
+    t[n] = s;
+    const o = this._resolveNegotiateUrl(e);
+    this._logger.log(h.Debug, `Sending negotiation request: ${o}.`);
+    try {
+      const i = await this._httpClient.post(o, {
+        content: "",
+        headers: { ...t, ...this._options.headers },
+        timeout: this._options.timeout,
+        withCredentials: this._options.withCredentials
+      });
+      if (i.statusCode !== 200)
+        return Promise.reject(new Error(`Unexpected status code returned from negotiate '${i.statusCode}'`));
+      const c = JSON.parse(i.content);
+      return (!c.negotiateVersion || c.negotiateVersion < 1) && (c.connectionToken = c.connectionId), c.useStatefulReconnect && this._options._useStatefulReconnect !== !0 ? Promise.reject(new Ue("Client didn't negotiate Stateful Reconnect but the server did.")) : c;
+    } catch (i) {
+      let c = "Failed to complete negotiation with the server: " + i;
+      return i instanceof V && i.statusCode === 404 && (c = c + " Either this is not a SignalR endpoint or there is a proxy blocking the connection."), this._logger.log(h.Error, c), Promise.reject(new Ue(c));
+    }
+  }
+  _createConnectUrl(e, t) {
+    return t ? e + (e.indexOf("?") === -1 ? "?" : "&") + `id=${t}` : e;
+  }
+  async _createTransport(e, t, n, s) {
+    let o = this._createConnectUrl(e, n.connectionToken);
+    if (this._isITransport(t)) {
+      this._logger.log(h.Debug, "Connection was provided an instance of ITransport, using that directly."), this.transport = t, await this._startTransport(o, s), this.connectionId = n.connectionId;
+      return;
+    }
+    const i = [], c = n.availableTransports || [];
+    let a = n;
+    for (const l of c) {
+      const u = this._resolveTransportOrError(l, t, s, (a == null ? void 0 : a.useStatefulReconnect) === !0);
+      if (u instanceof Error)
+        i.push(`${l.transport} failed:`), i.push(u);
+      else if (this._isITransport(u)) {
+        if (this.transport = u, !a) {
+          try {
+            a = await this._getNegotiationResponse(e);
+          } catch (p) {
+            return Promise.reject(p);
+          }
+          o = this._createConnectUrl(e, a.connectionToken);
+        }
+        try {
+          await this._startTransport(o, s), this.connectionId = a.connectionId;
+          return;
+        } catch (p) {
+          if (this._logger.log(h.Error, `Failed to start the transport '${l.transport}': ${p}`), a = void 0, i.push(new ct(`${l.transport} failed: ${p}`, O[l.transport])), this._connectionState !== "Connecting") {
+            const f = "Failed to select transport before stop() was called.";
+            return this._logger.log(h.Debug, f), Promise.reject(new K(f));
+          }
+        }
+      }
+    }
+    return i.length > 0 ? Promise.reject(new lt(`Unable to connect to the server with any of the available transports. ${i.join(" ")}`, i)) : Promise.reject(new Error("None of the transports supported by the client are supported by the server."));
+  }
+  _constructTransport(e) {
+    switch (e) {
+      case O.WebSockets:
+        if (!this._options.WebSocket)
+          throw new Error("'WebSocket' is not supported in your environment.");
+        return new xt(this._httpClient, this._accessTokenFactory, this._logger, this._options.logMessageContent, this._options.WebSocket, this._options.headers || {});
+      case O.ServerSentEvents:
+        if (!this._options.EventSource)
+          throw new Error("'EventSource' is not supported in your environment.");
+        return new Rt(this._httpClient, this._httpClient._accessToken, this._logger, this._options);
+      case O.LongPolling:
+        return new ze(this._httpClient, this._logger, this._options);
+      default:
+        throw new Error(`Unknown transport: ${e}.`);
+    }
+  }
+  _startTransport(e, t) {
+    return this.transport.onreceive = this.onreceive, this.features.reconnect ? this.transport.onclose = async (n) => {
+      let s = !1;
+      if (this.features.reconnect)
+        try {
+          this.features.disconnected(), await this.transport.connect(e, t), await this.features.resend();
+        } catch {
+          s = !0;
+        }
+      else {
+        this._stopConnection(n);
+        return;
+      }
+      s && this._stopConnection(n);
+    } : this.transport.onclose = (n) => this._stopConnection(n), this.transport.connect(e, t);
+  }
+  _resolveTransportOrError(e, t, n, s) {
+    const o = O[e.transport];
+    if (o == null)
+      return this._logger.log(h.Debug, `Skipping transport '${e.transport}' because it is not supported by this client.`), new Error(`Skipping transport '${e.transport}' because it is not supported by this client.`);
+    if (Ot(t, o))
+      if (e.transferFormats.map((c) => B[c]).indexOf(n) >= 0) {
+        if (o === O.WebSockets && !this._options.WebSocket || o === O.ServerSentEvents && !this._options.EventSource)
+          return this._logger.log(h.Debug, `Skipping transport '${O[o]}' because it is not supported in your environment.'`), new it(`'${O[o]}' is not supported in your environment.`, o);
+        this._logger.log(h.Debug, `Selecting transport '${O[o]}'.`);
+        try {
+          return this.features.reconnect = o === O.WebSockets ? s : void 0, this._constructTransport(o);
+        } catch (c) {
+          return c;
+        }
+      } else
+        return this._logger.log(h.Debug, `Skipping transport '${O[o]}' because it does not support the requested transfer format '${B[n]}'.`), new Error(`'${O[o]}' does not support ${B[n]}.`);
+    else
+      return this._logger.log(h.Debug, `Skipping transport '${O[o]}' because it was disabled by the client.`), new at(`'${O[o]}' is disabled by the client.`, o);
+  }
+  _isITransport(e) {
+    return e && typeof e == "object" && "connect" in e;
+  }
+  _stopConnection(e) {
+    if (this._logger.log(h.Debug, `HttpConnection.stopConnection(${e}) called while in state ${this._connectionState}.`), this.transport = void 0, e = this._stopError || e, this._stopError = void 0, this._connectionState === "Disconnected") {
+      this._logger.log(h.Debug, `Call to HttpConnection.stopConnection(${e}) was ignored because the connection is already in the disconnected state.`);
+      return;
+    }
+    if (this._connectionState === "Connecting")
+      throw this._logger.log(h.Warning, `Call to HttpConnection.stopConnection(${e}) was ignored because the connection is still in the connecting state.`), new Error(`HttpConnection.stopConnection(${e}) was called while the connection is still in the connecting state.`);
+    if (this._connectionState === "Disconnecting" && this._stopPromiseResolver(), e ? this._logger.log(h.Error, `Connection disconnected with error '${e}'.`) : this._logger.log(h.Information, "Connection disconnected."), this._sendQueue && (this._sendQueue.stop().catch((t) => {
+      this._logger.log(h.Error, `TransportSendQueue.stop() threw error '${t}'.`);
+    }), this._sendQueue = void 0), this.connectionId = void 0, this._connectionState = "Disconnected", this._connectionStarted) {
+      this._connectionStarted = !1;
+      try {
+        this.onclose && this.onclose(e);
+      } catch (t) {
+        this._logger.log(h.Error, `HttpConnection.onclose(${e}) threw error '${t}'.`);
+      }
+    }
+  }
+  _resolveUrl(e) {
+    if (e.lastIndexOf("https://", 0) === 0 || e.lastIndexOf("http://", 0) === 0)
+      return e;
+    if (!k.isBrowser)
+      throw new Error(`Cannot resolve '${e}'.`);
+    const t = window.document.createElement("a");
+    return t.href = e, this._logger.log(h.Information, `Normalizing '${e}' to '${t.href}'.`), t.href;
+  }
+  _resolveNegotiateUrl(e) {
+    const t = new URL(e);
+    t.pathname.endsWith("/") ? t.pathname += "negotiate" : t.pathname += "/negotiate";
+    const n = new URLSearchParams(t.searchParams);
+    return n.has("negotiateVersion") || n.append("negotiateVersion", this._negotiateVersion.toString()), n.has("useStatefulReconnect") ? n.get("useStatefulReconnect") === "true" && (this._options._useStatefulReconnect = !0) : this._options._useStatefulReconnect === !0 && n.append("useStatefulReconnect", "true"), t.search = n.toString(), t.toString();
+  }
+}
+function Ot(r, e) {
+  return !r || (e & r) !== 0;
+}
+class We {
+  constructor(e) {
+    this._transport = e, this._buffer = [], this._executing = !0, this._sendBufferedData = new Se(), this._transportResult = new Se(), this._sendLoopPromise = this._sendLoop();
+  }
+  send(e) {
+    return this._bufferData(e), this._transportResult || (this._transportResult = new Se()), this._transportResult.promise;
+  }
+  stop() {
+    return this._executing = !1, this._sendBufferedData.resolve(), this._sendLoopPromise;
+  }
+  _bufferData(e) {
+    if (this._buffer.length && typeof this._buffer[0] != typeof e)
+      throw new Error(`Expected data to be of type ${typeof this._buffer} but was of type ${typeof e}`);
+    this._buffer.push(e), this._sendBufferedData.resolve();
+  }
+  async _sendLoop() {
+    for (; ; ) {
+      if (await this._sendBufferedData.promise, !this._executing) {
+        this._transportResult && this._transportResult.reject("Connection stopped.");
+        break;
+      }
+      this._sendBufferedData = new Se();
+      const e = this._transportResult;
+      this._transportResult = void 0;
+      const t = typeof this._buffer[0] == "string" ? this._buffer.join("") : We._concatBuffers(this._buffer);
+      this._buffer.length = 0;
+      try {
+        await this._transport.send(t), e.resolve();
+      } catch (n) {
+        e.reject(n);
+      }
+    }
+  }
+  static _concatBuffers(e) {
+    const t = e.map((o) => o.byteLength).reduce((o, i) => o + i), n = new Uint8Array(t);
+    let s = 0;
+    for (const o of e)
+      n.set(new Uint8Array(o), s), s += o.byteLength;
+    return n.buffer;
+  }
+}
+class Se {
+  constructor() {
+    this.promise = new Promise((e, t) => [this._resolver, this._rejecter] = [e, t]);
+  }
+  resolve() {
+    this._resolver();
+  }
+  reject(e) {
+    this._rejecter(e);
+  }
+}
+const Mt = "json";
+class Lt {
+  constructor() {
+    this.name = Mt, this.version = 2, this.transferFormat = B.Text;
+  }
+  /** Creates an array of {@link @microsoft/signalr.HubMessage} objects from the specified serialized representation.
+   *
+   * @param {string} input A string containing the serialized representation.
+   * @param {ILogger} logger A logger that will be used to log messages that occur during parsing.
+   */
+  parseMessages(e, t) {
+    if (typeof e != "string")
+      throw new Error("Invalid input for JSON hub protocol. Expected a string.");
+    if (!e)
+      return [];
+    t === null && (t = fe.instance);
+    const n = q.parse(e), s = [];
+    for (const o of n) {
+      const i = JSON.parse(o);
+      if (typeof i.type != "number")
+        throw new Error("Invalid payload.");
+      switch (i.type) {
+        case _.Invocation:
+          this._isInvocationMessage(i);
+          break;
+        case _.StreamItem:
+          this._isStreamItemMessage(i);
+          break;
+        case _.Completion:
+          this._isCompletionMessage(i);
+          break;
+        case _.Ping:
+          break;
+        case _.Close:
+          break;
+        case _.Ack:
+          this._isAckMessage(i);
+          break;
+        case _.Sequence:
+          this._isSequenceMessage(i);
+          break;
+        default:
+          t.log(h.Information, "Unknown message type '" + i.type + "' ignored.");
+          continue;
+      }
+      s.push(i);
+    }
+    return s;
+  }
+  /** Writes the specified {@link @microsoft/signalr.HubMessage} to a string and returns it.
+   *
+   * @param {HubMessage} message The message to write.
+   * @returns {string} A string containing the serialized representation of the message.
+   */
+  writeMessage(e) {
+    return q.write(JSON.stringify(e));
+  }
+  _isInvocationMessage(e) {
+    this._assertNotEmptyString(e.target, "Invalid payload for Invocation message."), e.invocationId !== void 0 && this._assertNotEmptyString(e.invocationId, "Invalid payload for Invocation message.");
+  }
+  _isStreamItemMessage(e) {
+    if (this._assertNotEmptyString(e.invocationId, "Invalid payload for StreamItem message."), e.item === void 0)
+      throw new Error("Invalid payload for StreamItem message.");
+  }
+  _isCompletionMessage(e) {
+    if (e.result && e.error)
+      throw new Error("Invalid payload for Completion message.");
+    !e.result && e.error && this._assertNotEmptyString(e.error, "Invalid payload for Completion message."), this._assertNotEmptyString(e.invocationId, "Invalid payload for Completion message.");
+  }
+  _isAckMessage(e) {
+    if (typeof e.sequenceId != "number")
+      throw new Error("Invalid SequenceId for Ack message.");
+  }
+  _isSequenceMessage(e) {
+    if (typeof e.sequenceId != "number")
+      throw new Error("Invalid SequenceId for Sequence message.");
+  }
+  _assertNotEmptyString(e, t) {
+    if (typeof e != "string" || e === "")
+      throw new Error(t);
+  }
+}
+const Gt = {
+  trace: h.Trace,
+  debug: h.Debug,
+  info: h.Information,
+  information: h.Information,
+  warn: h.Warning,
+  warning: h.Warning,
+  error: h.Error,
+  critical: h.Critical,
+  none: h.None
+};
+function Wt(r) {
+  const e = Gt[r.toLowerCase()];
+  if (typeof e < "u")
+    return e;
+  throw new Error(`Unknown log level: ${r}`);
+}
+class Bt {
+  configureLogging(e) {
+    if (D.isRequired(e, "logging"), Ft(e))
+      this.logger = e;
+    else if (typeof e == "string") {
+      const t = Wt(e);
+      this.logger = new be(t);
+    } else
+      this.logger = new be(e);
+    return this;
+  }
+  withUrl(e, t) {
+    return D.isRequired(e, "url"), D.isNotEmpty(e, "url"), this.url = e, typeof t == "object" ? this.httpConnectionOptions = { ...this.httpConnectionOptions, ...t } : this.httpConnectionOptions = {
+      ...this.httpConnectionOptions,
+      transport: t
+    }, this;
+  }
+  /** Configures the {@link @microsoft/signalr.HubConnection} to use the specified Hub Protocol.
+   *
+   * @param {IHubProtocol} protocol The {@link @microsoft/signalr.IHubProtocol} implementation to use.
+   */
+  withHubProtocol(e) {
+    return D.isRequired(e, "protocol"), this.protocol = e, this;
+  }
+  withAutomaticReconnect(e) {
+    if (this.reconnectPolicy)
+      throw new Error("A reconnectPolicy has already been set.");
+    return e ? Array.isArray(e) ? this.reconnectPolicy = new je(e) : this.reconnectPolicy = e : this.reconnectPolicy = new je(), this;
+  }
+  /** Configures {@link @microsoft/signalr.HubConnection.serverTimeoutInMilliseconds} for the {@link @microsoft/signalr.HubConnection}.
+   *
+   * @returns The {@link @microsoft/signalr.HubConnectionBuilder} instance, for chaining.
+   */
+  withServerTimeout(e) {
+    return D.isRequired(e, "milliseconds"), this._serverTimeoutInMilliseconds = e, this;
+  }
+  /** Configures {@link @microsoft/signalr.HubConnection.keepAliveIntervalInMilliseconds} for the {@link @microsoft/signalr.HubConnection}.
+   *
+   * @returns The {@link @microsoft/signalr.HubConnectionBuilder} instance, for chaining.
+   */
+  withKeepAliveInterval(e) {
+    return D.isRequired(e, "milliseconds"), this._keepAliveIntervalInMilliseconds = e, this;
+  }
+  /** Enables and configures options for the Stateful Reconnect feature.
+   *
+   * @returns The {@link @microsoft/signalr.HubConnectionBuilder} instance, for chaining.
+   */
+  withStatefulReconnect(e) {
+    return this.httpConnectionOptions === void 0 && (this.httpConnectionOptions = {}), this.httpConnectionOptions._useStatefulReconnect = !0, this._statefulReconnectBufferSize = e == null ? void 0 : e.bufferSize, this;
+  }
+  /** Creates a {@link @microsoft/signalr.HubConnection} from the configuration options specified in this builder.
+   *
+   * @returns {HubConnection} The configured {@link @microsoft/signalr.HubConnection}.
+   */
+  build() {
+    const e = this.httpConnectionOptions || {};
+    if (e.logger === void 0 && (e.logger = this.logger), !this.url)
+      throw new Error("The 'HubConnectionBuilder.withUrl' method must be called before building the connection.");
+    const t = new Nt(this.url, e);
+    return Ge.create(t, this.logger || fe.instance, this.protocol || new Lt(), this.reconnectPolicy, this._serverTimeoutInMilliseconds, this._keepAliveIntervalInMilliseconds, this._statefulReconnectBufferSize);
+  }
+}
+function Ft(r) {
+  return r.log !== void 0;
+}
+var w;
+(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";
+})(w || (w = {}));
+var Ut = (
+  /** @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(s) {
+        return !s.options || s.options.toClassOnly === !0 && s.options.toPlainOnly === !0 ? !0 : s.options.toClassOnly === !0 ? n === w.CLASS_TO_CLASS || n === w.PLAIN_TO_CLASS : s.options.toPlainOnly === !0 ? n === w.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), s = this._exposeMetadatas.get(e), o = s && s.get(void 0);
+      return n && o || !n && !o ? "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 === w.CLASS_TO_CLASS || t === w.PLAIN_TO_CLASS : n.options.toPlainOnly === !0 ? t === w.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 === w.CLASS_TO_CLASS || t === w.PLAIN_TO_CLASS : n.options.toPlainOnly === !0 ? t === w.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), s;
+      n && (s = Array.from(n.values()).filter(function(p) {
+        return p.propertyName !== void 0;
+      }));
+      for (var o = [], i = 0, c = this.getAncestors(t); i < c.length; i++) {
+        var a = c[i], l = e.get(a);
+        if (l) {
+          var u = Array.from(l.values()).filter(function(p) {
+            return p.propertyName !== void 0;
+          });
+          o.push.apply(o, u);
+        }
+      }
+      return o.concat(s || []);
+    }, r.prototype.findMetadata = function(e, t, n) {
+      var s = e.get(t);
+      if (s) {
+        var o = s.get(n);
+        if (o)
+          return o;
+      }
+      for (var i = 0, c = this.getAncestors(t); i < c.length; i++) {
+        var a = c[i], l = e.get(a);
+        if (l) {
+          var u = l.get(n);
+          if (u)
+            return u;
+        }
+      }
+    }, r.prototype.findMetadatas = function(e, t, n) {
+      var s = e.get(t), o;
+      s && (o = s.get(n));
+      for (var i = [], c = 0, a = this.getAncestors(t); c < a.length; c++) {
+        var l = a[c], u = e.get(l);
+        u && u.has(n) && i.push.apply(i, u.get(n));
+      }
+      return i.slice().reverse().concat((o || []).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;
+  }()
+), H = new Ut();
+function Ht() {
+  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 jt(r) {
+  return r !== null && typeof r == "object" && typeof r.then == "function";
+}
+var Je = function(r, e, t) {
+  if (t || arguments.length === 2) for (var n = 0, s = e.length, o; n < s; n++)
+    (o || !(n in e)) && (o || (o = Array.prototype.slice.call(e, 0, n)), o[n] = e[n]);
+  return r.concat(o || Array.prototype.slice.call(e));
+};
+function zt(r) {
+  var e = new r();
+  return !(e instanceof Set) && !("push" in e) ? [] : e;
+}
+var oe = (
+  /** @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, s, o, i) {
+      var c = this;
+      if (i === void 0 && (i = 0), Array.isArray(t) || t instanceof Set) {
+        var a = s && this.transformationType === w.PLAIN_TO_CLASS ? zt(s) : [];
+        return t.forEach(function(g, b) {
+          var y = e ? e[b] : void 0;
+          if (!c.options.enableCircularCheck || !c.isCircular(g)) {
+            var T = void 0;
+            if (typeof n != "function" && n && n.options && n.options.discriminator && n.options.discriminator.property && n.options.discriminator.subTypes) {
+              if (c.transformationType === w.PLAIN_TO_CLASS) {
+                T = n.options.discriminator.subTypes.find(function(J) {
+                  return J.name === g[n.options.discriminator.property];
+                });
+                var z = { newObject: a, object: g, property: void 0 }, C = n.typeFunction(z);
+                T === void 0 ? T = C : T = T.value, n.options.keepDiscriminatorProperty || delete g[n.options.discriminator.property];
+              }
+              c.transformationType === w.CLASS_TO_CLASS && (T = g.constructor), c.transformationType === w.CLASS_TO_PLAIN && (g[n.options.discriminator.property] = n.options.discriminator.subTypes.find(function(J) {
+                return J.value === g.constructor;
+              }).name);
+            } else
+              T = n;
+            var N = c.transform(y, g, T, void 0, g instanceof Map, i + 1);
+            a instanceof Set ? a.add(N) : a.push(N);
+          } else c.transformationType === w.CLASS_TO_CLASS && (a instanceof Set ? a.add(g) : a.push(g));
+        }), a;
+      } else {
+        if (n === String && !o)
+          return t == null ? t : String(t);
+        if (n === Number && !o)
+          return t == null ? t : Number(t);
+        if (n === Boolean && !o)
+          return t == null ? t : !!t;
+        if ((n === Date || t instanceof Date) && !o)
+          return t instanceof Date ? new Date(t.valueOf()) : t == null ? t : new Date(t);
+        if (Ht().Buffer && (n === Buffer || t instanceof Buffer) && !o)
+          return t == null ? t : Buffer.from(t);
+        if (jt(t) && !o)
+          return new Promise(function(g, b) {
+            t.then(function(y) {
+              return g(c.transform(void 0, y, n, void 0, void 0, i + 1));
+            }, b);
+          });
+        if (!o && 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 l = this.getKeys(n, t, o), u = e || {};
+          !e && (this.transformationType === w.PLAIN_TO_CLASS || this.transformationType === w.CLASS_TO_CLASS) && (o ? u = /* @__PURE__ */ new Map() : n ? u = new n() : u = {});
+          for (var p = function(g) {
+            if (g === "__proto__" || g === "constructor")
+              return "continue";
+            var b = g, y = g, T = g;
+            if (!f.options.ignoreDecorators && n) {
+              if (f.transformationType === w.PLAIN_TO_CLASS) {
+                var z = H.findExposeMetadataByCustomName(n, g);
+                z && (T = z.propertyName, y = z.propertyName);
+              } else if (f.transformationType === w.CLASS_TO_PLAIN || f.transformationType === w.CLASS_TO_CLASS) {
+                var z = H.findExposeMetadata(n, g);
+                z && z.options && z.options.name && (y = z.options.name);
+              }
+            }
+            var C = void 0;
+            f.transformationType === w.PLAIN_TO_CLASS ? C = t[b] : t instanceof Map ? C = t.get(b) : t[b] instanceof Function ? C = t[b]() : C = t[b];
+            var N = void 0, J = C instanceof Map;
+            if (n && o)
+              N = n;
+            else if (n) {
+              var $ = H.findTypeMetadata(n, T);
+              if ($) {
+                var ye = { newObject: u, object: t, property: T }, se = $.typeFunction ? $.typeFunction(ye) : $.reflectedType;
+                $.options && $.options.discriminator && $.options.discriminator.property && $.options.discriminator.subTypes ? t[b] instanceof Array ? N = $ : (f.transformationType === w.PLAIN_TO_CLASS && (N = $.options.discriminator.subTypes.find(function(U) {
+                  if (C && C instanceof Object && $.options.discriminator.property in C)
+                    return U.name === C[$.options.discriminator.property];
+                }), N === void 0 ? N = se : N = N.value, $.options.keepDiscriminatorProperty || C && C instanceof Object && $.options.discriminator.property in C && delete C[$.options.discriminator.property]), f.transformationType === w.CLASS_TO_CLASS && (N = C.constructor), f.transformationType === w.CLASS_TO_PLAIN && C && (C[$.options.discriminator.property] = $.options.discriminator.subTypes.find(function(U) {
+                  return U.value === C.constructor;
+                }).name)) : N = se, J = J || $.reflectedType === Map;
+              } else if (f.options.targetMaps)
+                f.options.targetMaps.filter(function(U) {
+                  return U.target === n && !!U.properties[T];
+                }).forEach(function(U) {
+                  return N = U.properties[T];
+                });
+              else if (f.options.enableImplicitConversion && f.transformationType === w.PLAIN_TO_CLASS) {
+                var le = Reflect.getMetadata("design:type", n.prototype, T);
+                le && (N = le);
+              }
+            }
+            var ue = Array.isArray(t[b]) ? f.getReflectedType(n, T) : void 0, de = e ? e[b] : void 0;
+            if (u.constructor.prototype) {
+              var S = Object.getOwnPropertyDescriptor(u.constructor.prototype, y);
+              if ((f.transformationType === w.PLAIN_TO_CLASS || f.transformationType === w.CLASS_TO_CLASS) && // eslint-disable-next-line @typescript-eslint/unbound-method
+              (S && !S.set || u[y] instanceof Function))
+                return "continue";
+            }
+            if (!f.options.enableCircularCheck || !f.isCircular(C)) {
+              var F = f.transformationType === w.PLAIN_TO_CLASS ? y : g, I = void 0;
+              f.transformationType === w.CLASS_TO_PLAIN ? (I = t[F], I = f.applyCustomTransformations(I, n, F, t, f.transformationType), I = t[F] === I ? C : I, I = f.transform(de, I, N, ue, J, i + 1)) : C === void 0 && f.options.exposeDefaultValues ? I = u[y] : (I = f.transform(de, C, N, ue, J, i + 1), I = f.applyCustomTransformations(I, n, F, t, f.transformationType)), (I !== void 0 || f.options.exposeUnsetFields) && (u instanceof Map ? u.set(y, I) : u[y] = I);
+            } else if (f.transformationType === w.CLASS_TO_CLASS) {
+              var I = C;
+              I = f.applyCustomTransformations(I, n, g, t, f.transformationType), (I !== void 0 || f.options.exposeUnsetFields) && (u instanceof Map ? u.set(y, I) : u[y] = I);
+            }
+          }, f = this, P = 0, W = l; P < W.length; P++) {
+            var M = W[P];
+            p(M);
+          }
+          return this.options.enableCircularCheck && this.recursionStack.delete(t), u;
+        } else
+          return t;
+      }
+    }, r.prototype.applyCustomTransformations = function(e, t, n, s, o) {
+      var i = this, c = H.findTransformMetadatas(t, n, this.transformationType);
+      return this.options.version !== void 0 && (c = c.filter(function(a) {
+        return a.options ? i.checkVersion(a.options.since, a.options.until) : !0;
+      })), this.options.groups && this.options.groups.length ? c = c.filter(function(a) {
+        return a.options ? i.checkGroups(a.options.groups) : !0;
+      }) : c = c.filter(function(a) {
+        return !a.options || !a.options.groups || !a.options.groups.length;
+      }), c.forEach(function(a) {
+        e = a.transformFn({ value: e, key: n, obj: s, type: o, options: i.options });
+      }), e;
+    }, r.prototype.isCircular = function(e) {
+      return this.recursionStack.has(e);
+    }, r.prototype.getReflectedType = function(e, t) {
+      if (e) {
+        var n = H.findTypeMetadata(e, t);
+        return n ? n.reflectedType : void 0;
+      }
+    }, r.prototype.getKeys = function(e, t, n) {
+      var s = this, o = H.getStrategy(e);
+      o === "none" && (o = this.options.strategy || "exposeAll");
+      var i = [];
+      if ((o === "exposeAll" || n) && (t instanceof Map ? i = Array.from(t.keys()) : i = Object.keys(t)), n)
+        return i;
+      if (this.options.ignoreDecorators && this.options.excludeExtraneousValues && e) {
+        var c = H.getExposedProperties(e, this.transformationType), a = H.getExcludedProperties(e, this.transformationType);
+        i = Je(Je([], c, !0), a, !0);
+      }
+      if (!this.options.ignoreDecorators && e) {
+        var c = H.getExposedProperties(e, this.transformationType);
+        this.transformationType === w.PLAIN_TO_CLASS && (c = c.map(function(p) {
+          var f = H.findExposeMetadata(e, p);
+          return f && f.options && f.options.name ? f.options.name : p;
+        })), this.options.excludeExtraneousValues ? i = c : i = i.concat(c);
+        var l = H.getExcludedProperties(e, this.transformationType);
+        l.length > 0 && (i = i.filter(function(p) {
+          return !l.includes(p);
+        })), this.options.version !== void 0 && (i = i.filter(function(p) {
+          var f = H.findExposeMetadata(e, p);
+          return !f || !f.options ? !0 : s.checkVersion(f.options.since, f.options.until);
+        })), this.options.groups && this.options.groups.length ? i = i.filter(function(p) {
+          var f = H.findExposeMetadata(e, p);
+          return !f || !f.options ? !0 : s.checkGroups(f.options.groups);
+        }) : i = i.filter(function(p) {
+          var f = H.findExposeMetadata(e, p);
+          return !f || !f.options || !f.options.groups || !f.options.groups.length;
+        });
+      }
+      return this.options.excludePrefixes && this.options.excludePrefixes.length && (i = i.filter(function(u) {
+        return s.options.excludePrefixes.every(function(p) {
+          return u.substr(0, p.length) !== p;
+        });
+      })), i = i.filter(function(u, p, f) {
+        return f.indexOf(u) === p;
+      }), i;
+    }, 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;
+  }()
+), re = {
+  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
+}, j = function() {
+  return j = Object.assign || function(r) {
+    for (var e, t = 1, n = arguments.length; t < n; t++) {
+      e = arguments[t];
+      for (var s in e) Object.prototype.hasOwnProperty.call(e, s) && (r[s] = e[s]);
+    }
+    return r;
+  }, j.apply(this, arguments);
+}, qt = (
+  /** @class */
+  function() {
+    function r() {
+    }
+    return r.prototype.instanceToPlain = function(e, t) {
+      var n = new oe(w.CLASS_TO_PLAIN, j(j({}, re), t));
+      return n.transform(void 0, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.classToPlainFromExist = function(e, t, n) {
+      var s = new oe(w.CLASS_TO_PLAIN, j(j({}, re), n));
+      return s.transform(t, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.plainToInstance = function(e, t, n) {
+      var s = new oe(w.PLAIN_TO_CLASS, j(j({}, re), n));
+      return s.transform(void 0, t, e, void 0, void 0, void 0);
+    }, r.prototype.plainToClassFromExist = function(e, t, n) {
+      var s = new oe(w.PLAIN_TO_CLASS, j(j({}, re), n));
+      return s.transform(e, t, void 0, void 0, void 0, void 0);
+    }, r.prototype.instanceToInstance = function(e, t) {
+      var n = new oe(w.CLASS_TO_CLASS, j(j({}, re), t));
+      return n.transform(void 0, e, void 0, void 0, void 0, void 0);
+    }, r.prototype.classToClassFromExist = function(e, t, n) {
+      var s = new oe(w.CLASS_TO_CLASS, j(j({}, re), n));
+      return s.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 s = JSON.parse(t);
+      return this.plainToInstance(e, s, n);
+    }, r.prototype.deserializeArray = function(e, t, n) {
+      var s = JSON.parse(t);
+      return this.plainToInstance(e, s, n);
+    }, r;
+  }()
+), Jt = new qt();
+function ae(r, e, t) {
+  return Jt.deserializeArray(r, e, t);
+}
+const Te = "1.0.90", Kt = [
+  {
+    oid: "1",
+    name: "",
+    mail: "",
+    authority: "",
+    tid: "",
+    companyName: "",
+    companyDomain: "",
+    session: "Sign In",
+    sel: !0
+  }
+], Xt = [
+  {
+    tid: "1",
+    name: "",
+    domain: "",
+    tenantType: "",
+    authority: "",
+    sel: !0,
+    graphSP: ""
+  }
+], Zt = [], Qt = [
+  {
+    id: "1",
+    name: "",
+    associatedUsers: [
+      "1"
+    ],
+    associatedTenants: [
+      "1"
+    ],
+    associatedConfigs: [],
+    sel: !0
+  }
+], Yt = [
+  {
+    Run: "3",
+    Start: "2023-09-17T12:00:00.000-07:00",
+    POST: "2023-09-17T12:00:09.500-07:00",
+    Read: "2023-09-17T12:00:15.500-07:00",
+    Write: "2023-09-17T12:01:30.000-07:00"
+  },
+  {
+    Run: "2",
+    Start: "2023-09-17T12:00:00.000-07:00",
+    POST: "2023-09-17T12:00:09.500-07:00",
+    Read: "2023-09-17T12:00:15.500-07:00",
+    Write: "2023-09-17T12:01:30.000-07:00"
+  },
+  {
+    Run: "1",
+    Start: "2023-09-17T12:00:00.000-07:00",
+    POST: "2023-09-17T12:00:09.500-07:00",
+    Read: "2023-09-17T12:00:15.500-07:00",
+    Write: "2023-09-17T12:01:30.000-07:00"
+  }
+], Vt = [
+  {
+    type: "mg",
+    resource: "Tenant Root Group",
+    cost: 0,
+    expanded: !0,
+    resources: [
+      {
+        type: "sub",
+        resource: "Applications",
+        cost: 16677.52,
+        expanded: !0,
+        resources: [
+          {
+            type: "rg",
+            resource: "ssfdev",
+            cost: 7500.08,
+            expanded: !0,
+            resources: [
+              {
+                type: "resources",
+                resource: "SSFServices",
+                cost: 0,
+                expanded: !1,
+                resources: []
+              }
+            ]
+          }
+        ]
+      },
+      {
+        type: "sub",
+        resource: "Infrastructure",
+        cost: 8737.58,
+        expanded: !0,
+        resources: [
+          {
+            type: "rg",
+            resource: "SFFA_Prod_Mgmt_Shared_Resources_RG",
+            cost: 7500.08,
+            expanded: !0,
+            resources: [
+              {
+                type: "resources",
+                resource: "SSFA-Prod-UTIL-01",
+                cost: 0,
+                expanded: !1,
+                resources: []
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+], en = [
+  {
+    type: "user",
+    actor: "arvind@mindline.site",
+    resource: "kv-syncproject",
+    role: "Key Vault Certificate Officer",
+    updatedby: "arvind@mindline.site",
+    updatedon: "2023-09-06T15:36:45.7760714Z",
+    resources: []
+  },
+  {
+    type: "app",
+    actor: "mindline1-sync-512169f5-38d1-4b57-be8b-967f2d0ae4c6",
+    resource: "dev-subscription",
+    role: "Contributor",
+    updatedby: "arvind@mindline.site",
+    updatedon: "2023-09-06T15:36:45.7760714Z",
+    resources: []
+  }
+], ie = "workspaceIDs";
+function Fn(r, e) {
+  return r + e;
+}
+function Un() {
+  return "hello NPM";
+}
+class A {
+  constructor() {
+    d(this, "result");
+    d(this, "status");
+    d(this, "error");
+    d(this, "version");
+    d(this, "array");
+    this.result = !0, this.status = 200, this.error = "", this.version = Te, this.array = null;
+  }
+}
+class ge {
+}
+// azure graph REST API endpoints
+d(ge, "azureElevateAccess", "https://management.azure.com/providers/Microsoft.Authorization/elevateAccess?api-version=2016-07-01"), d(ge, "azureListRootAssignments", "https://management.azure.com/providers/Microsoft.Authorization/roleAssignments?api-version=2022-04-01&$filter=principalId+eq+");
+const L = class L {
+  // config API endpoints
+  static adminEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/admin`;
+  }
+  static adminIncompleteEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/incomplete-admin`;
+  }
+  static adminsEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/admins`;
+  }
+  static configConsentEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/configuration/consent`;
+  }
+  static configEnabledEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/configuration/status`;
+  }
+  static configEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/configuration`;
+  }
+  static configsEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/configurations`;
+  }
+  static initEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/configuration/init`;
+  }
+  static readerStartSyncEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/startSync`;
+  }
+  static tenantEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/tenant`;
+  }
+  static tenantsEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/tenants`;
+  }
+  static workspaceEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/workspace`;
+  }
+  static workspacesEndpoint() {
+    return `https://${L.environmentTag}-configurationapi-westus.azurewebsites.net/api/v1/workspaces`;
+  }
+  // SignalR endpoint
+  static signalREndpoint() {
+    return `https://${L.environmentTag}-signalrdispatcher-westus.azurewebsites.net/statsHub`;
+  }
+};
+d(L, "environmentTag", "dev");
+let R = L;
+class m {
+}
+// graph API predicates
+d(m, "graphGroupsPredicate", "v1.0/groups"), d(m, "graphMailPredicate", "v1.0/me/messages"), d(m, "graphMePredicate", "v1.0/me"), d(m, "graphOauth2PermissionGrantsPredicate", "v1.0/oauth2PermissionGrants"), d(m, "graphServicePrincipalsPredicate", "v1.0/servicePrincipals"), d(m, "graphUsersPredicate", "v1.0/users"), d(m, "graphTenantByDomainPredicate", "beta/tenantRelationships/findTenantInformationByDomainName"), d(m, "graphTenantByIdPredicate", "beta/tenantRelationships/findTenantInformationByTenantId"), // authority values are based on the well-known OIDC auth endpoints
+d(m, "authorityWW", "https://login.microsoftonline.com/"), d(m, "authorityWWRegex", /^(https:\/\/login\.microsoftonline\.com\/)([\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{12})\/oauth2\/authorize$/), d(m, "authorityUS", "https://login.microsoftonline.us/"), d(m, "authorityUSRegex", /^(https:\/\/login\.microsoftonline\.us\/)([\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{12})\/oauth2\/authorize$/), d(m, "authorityCN", "https://login.partner.microsoftonline.cn/"), d(m, "authorityCNRegex", /^(https:\/\/login\.partner\.microsoftonline\.cn\/)([\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{4}-[\dA-Fa-f]{12})\/oauth2\/authorize$/);
+class Hn {
+  constructor() {
+    d(this, "id", "");
+    d(this, "displayName", "");
+    d(this, "description", "");
+  }
+}
+class jn {
+  constructor() {
+    d(this, "group", "");
+    d(this, "value", "");
+    d(this, "consented", !1);
+    d(this, "removable", !1);
+    d(this, "expanded", "");
+  }
+  static compareByValue(e, t) {
+    return e.value.localeCompare(t.value);
+  }
+  static compareByGroup(e, t) {
+    return e.group.localeCompare(t.group);
+  }
+}
+class $e {
+  // set when the user is logging in to support spinner visibility
+  constructor() {
+    d(this, "oid");
+    d(this, "name");
+    d(this, "mail");
+    d(this, "authority");
+    d(this, "tid");
+    d(this, "companyName");
+    d(this, "companyDomain");
+    d(this, "workspaceIDs");
+    d(this, "session");
+    // button text
+    d(this, "spacode");
+    // to get front end access token
+    d(this, "graphAccessToken");
+    // front end graph access token
+    d(this, "mindlineAccessToken");
+    // front end mindline access token
+    d(this, "azureAccessToken");
+    // front end azure access token
+    d(this, "loginHint");
+    // to help sign out without prompt
+    d(this, "scopes");
+    // to detect if incremental consent has happened
+    d(this, "authTS");
+    // timestamp user was authenticated
+    d(this, "sel");
+    // selection state
+    d(this, "loggingIn");
+    this.oid = "", this.name = "", this.mail = "", this.authority = "", this.tid = "", this.companyName = "", this.companyDomain = "", this.workspaceIDs = "", this.session = "Sign In", this.spacode = "", this.graphAccessToken = "", this.mindlineAccessToken = "", this.azureAccessToken = "", this.loginHint = "", this.scopes = new Array(), this.authTS = /* @__PURE__ */ new Date(0), this.sel = !1, this.loggingIn = !1;
+  }
+}
+var tn = /* @__PURE__ */ ((r) => (r[r.invalid = 0] = "invalid", r[r.aad = 1] = "aad", r[r.ad = 2] = "ad", r[r.googleworkspace = 3] = "googleworkspace", r))(tn || {}), nn = /* @__PURE__ */ ((r) => (r[r.read = 1] = "read", r[r.write = 2] = "write", r[r.notassigned = 3] = "notassigned", r))(nn || {});
+class me {
+  // are we validating by TID or by domain? "Domain" | "Tenant ID"
+  constructor() {
+    d(this, "tid");
+    d(this, "name");
+    d(this, "domain");
+    d(this, "tenantType");
+    d(this, "authority");
+    d(this, "workspaceIDs");
+    d(this, "sel");
+    // selection state
+    d(this, "graphSP");
+    // graph resource ID (service principal) for this tenant
+    d(this, "lookupfield");
+    this.tid = "", this.name = "", this.domain = "", this.tenantType = "aad", this.authority = "", this.workspaceIDs = "", this.sel = !1, this.graphSP = "", this.lookupfield = "Domain";
+  }
+}
+function sn(r, e) {
+  switch (r) {
+    case m.authorityWW:
+      return e === 1 ? "85d35da2-4118-4b03-aa05-605cedd7f2f8" : "63100afe-506e-4bb2-8ff7-d8d5ab373129";
+    case m.authorityUS:
+      return e === 1 ? "b08630c7-e227-4215-9746-afc9286fb864" : "17aa5d5a-f09f-4cec-87a6-28596f9fa513";
+    case m.authorityCN:
+      return e === 1 ? "7db7293b-add9-4a3f-8562-1a20bfe27d5e" : "debd015b-1154-4111-a4cb-fc220a537697";
+    default:
+      debugger;
+      return "";
+  }
+}
+function ne(r) {
+  switch (r) {
+    case m.authorityWW:
+      return "https://graph.microsoft.com/";
+    case m.authorityUS:
+      return "https://graph.microsoft.us/";
+    case m.authorityCN:
+      return "https://microsoftgraph.chinacloudapi.cn/";
+    default:
+      debugger;
+      return "";
+  }
+}
+function on(r) {
+  switch (r) {
+    case m.authorityWW:
+      return "https://login.microsoftonline.com/";
+    case m.authorityUS:
+      return "https://login.microsoftonline.us/";
+    case m.authorityCN:
+      return "https://login.partner.microsoftonline.cn/";
+    default:
+      debugger;
+      return "";
+  }
+}
+var rn = /* @__PURE__ */ ((r) => (r[r.source = 1] = "source", r[r.target = 2] = "target", r[r.sourcetarget = 3] = "sourcetarget", r))(rn || {});
+class an {
+  constructor() {
+    d(this, "tid");
+    d(this, "sourceGroupId");
+    d(this, "sourceGroupName");
+    d(this, "targetGroupId");
+    d(this, "targetGroupName");
+    d(this, "configurationTenantType");
+    d(this, "deltaToken");
+    d(this, "usersWritten");
+    d(this, "configId");
+    d(this, "batchId");
+    d(this, "isReadPermissionConsented");
+    d(this, "isWritePermissionConsented");
+    this.tid = "", this.sourceGroupId = "", this.sourceGroupName = "", this.targetGroupId = "", this.targetGroupName = "", this.configurationTenantType = "source", this.deltaToken = "", this.usersWritten = 0, this.configId = "", this.batchId = "", this.isReadPermissionConsented = !1, this.isWritePermissionConsented = !1;
+  }
+}
+class De {
+  // selection state
+  constructor() {
+    d(this, "id");
+    d(this, "workspaceId");
+    d(this, "name");
+    d(this, "description");
+    d(this, "tenants");
+    d(this, "isEnabled");
+    d(this, "workspaceIDs");
+    d(this, "sel");
+    this.id = "", this.name = "", this.workspaceId = "", this.description = "", this.tenants = new Array(), this.isEnabled = !1, this.workspaceIDs = "", this.sel = !1;
+  }
+}
+class Re {
+  // selection state
+  constructor() {
+    d(this, "id");
+    d(this, "name");
+    d(this, "ownerid");
+    d(this, "associatedUsers");
+    d(this, "associatedTenants");
+    d(this, "associatedConfigs");
+    d(this, "sel");
+    this.id = "", this.name = "", this.ownerid = "", this.associatedUsers = new Array(), this.associatedTenants = new Array(), this.associatedConfigs = new Array(), this.sel = !1;
+  }
+}
+function Q() {
+  let r;
+  try {
+    r = window.localStorage;
+    const e = "__storage_test__";
+    return r.setItem(e, e), r.removeItem(e), !0;
+  } catch (e) {
+    return e instanceof DOMException && // everything except Firefox
+    (e.code === 22 || // Firefox
+    e.code === 1014 || // test name field too, because code might not be present
+    // everything except Firefox
+    e.name === "QuotaExceededError" || // Firefox
+    e.name === "NS_ERROR_DOM_QUOTA_REACHED") && // acknowledge QuotaExceededError only if there's something already stored
+    r && r.length !== 0;
+  }
+}
+var Ce, Qe;
+class zn {
+  constructor(e = !1) {
+    we(this, Ce);
+    d(this, "version", "");
+    d(this, "tab", 0);
+    d(this, "us", []);
+    d(this, "ts", []);
+    d(this, "cs", []);
+    d(this, "ws", []);
+    d(this, "configlevelconsent_configid", "");
+    d(this, "configlevelconsent_access", 3);
+    this.init(e);
+  }
+  // get initial data from localStorage or file
+  init(e) {
+    if (console.log(`Calling InitInfo::init(bClearLocalStorage: ${e ? "true" : "false"})`), Q()) {
+      let i = localStorage.getItem("InitInfo");
+      if (i != null && typeof i == "string" && i !== "") {
+        let a = JSON.parse(i);
+        if (a.us.length !== 0)
+          if (e)
+            localStorage.removeItem("InitInfo");
+          else {
+            Z(this, Ce, Qe).call(this, a);
+            return;
+          }
+      }
+    }
+    this.tab = 0, this.version = Te, this.configlevelconsent_configid = "", this.configlevelconsent_access = 3;
+    var t = JSON.stringify(Kt), n = JSON.stringify(Xt), s = JSON.stringify(Zt), o = JSON.stringify(Qt);
+    try {
+      this.us = ae($e, t), this.ts = ae(me, n), this.cs = ae(De, s), this.ws = ae(Re, o), this.tagWithWorkspaces();
+    } catch {
+      debugger;
+    }
+  }
+  save() {
+    let e = JSON.stringify(this);
+    localStorage.setItem("InitInfo", e);
+  }
+  tagWithWorkspaces() {
+    this.us.map((e) => e.workspaceIDs = ""), this.ts.map((e) => e.workspaceIDs = ""), this.cs.map((e) => e.workspaceIDs = "");
+    for (let e of this.ws) {
+      for (let t of e.associatedUsers) {
+        let n = this.us.find((s) => s.oid === t);
+        if (n !== void 0)
+          n[ie] += e.id, n[ie] += " ";
+        else
+          debugger;
+      }
+      for (let t of e.associatedTenants) {
+        let n = this.ts.find((s) => s.tid === t);
+        if (n !== void 0)
+          n[ie] += e.id, n[ie] += " ";
+        else
+          debugger;
+      }
+      for (let t of e.associatedConfigs) {
+        let n = this.cs.find((s) => s.id === t);
+        if (n !== void 0)
+          n[ie] += e.id, n[ie] += " ";
+        else
+          debugger;
+      }
+    }
+    return !0;
+  }
+}
+Ce = new WeakSet(), Qe = function(e) {
+  this.tab = e.tab, this.version = Te, this.configlevelconsent_configid = e.configlevelconsent_configid, this.configlevelconsent_access = e.configlevelconsent_access, typeof e.us > "u" ? this.us = new Array() : this.us = e.us.map((t) => {
+    let n = new $e();
+    return n.oid = t.oid, n.name = t.name, n.mail = t.mail, n.authority = t.authority, n.tid = t.tid, n.companyName = t.companyName, n.companyDomain = t.companyDomain, n.workspaceIDs = t.workspaceIDs, n.session = t.session, n.spacode = t.spacode, n.graphAccessToken = t.graphAccessToken, n.mindlineAccessToken = t.mindlineAccessToken, n.azureAccessToken = t.azureAccessToken, n.loginHint = t.loginHint, n.scopes = t.scopes, n.authTS = new Date(t.authTS), n.sel = t.sel, n.loggingIn = t.loggingIn, n;
+  }), typeof e.ts > "u" ? this.ts = new Array() : this.ts = e.ts.map((t) => {
+    let n = new me();
+    return n.tid = t.tid, n.name = t.name, n.domain = t.domain, n.tenantType = t.tenantType, n.authority = t.authority, n.workspaceIDs = t.workspaceIDs, n.sel = t.sel, n.lookupfield = t.lookupfield, n;
+  }), typeof e.cs > "u" ? this.cs = new Array() : this.cs = e.cs.map((t) => {
+    let n = new De();
+    return n.id = t.id, n.workspaceId = t.workspaceId, n.name = t.name, n.description = t.description, n.tenants = t.tenants, n.isEnabled = t.isEnabled, n.workspaceIDs = t.workspaceIDs, n.sel = t.sel, n;
+  }), typeof e.ws > "u" ? this.ws = new Array() : this.ws = e.ws.map((t) => {
+    let n = new Re();
+    return n.id = t.id, n.name = t.name, n.ownerid = t.ownerid, n.associatedUsers = t.associatedUsers, n.associatedTenants = t.associatedTenants, n.associatedConfigs = t.associatedConfigs, n.sel = t.sel, n;
+  });
+};
+const cn = [
+  {
+    id: 1,
+    task: "initialization",
+    start: "1970-01-01T00:00:00",
+    end: "1970-01-01T00:00:00",
+    expected: "0:22",
+    status: "not started",
+    expanded: !0,
+    subtasks: [
+      {
+        id: 2,
+        task: "authenticate user",
+        start: "1970-01-01T00:00:00",
+        end: "1970-01-01T00:00:00",
+        expected: "0:01",
+        status: "not started"
+      },
+      {
+        id: 3,
+        task: "reload React",
+        start: "1970-01-01T00:00:00",
+        end: "1970-01-01T00:00:00",
+        expected: "0:07",
+        status: "not started"
+      },
+      {
+        id: 4,
+        task: "GET tenant details",
+        start: "1970-01-01T00:00:00",
+        end: "1970-01-01T00:00:00",
+        expected: "0:01",
+        status: "not started"
+      },
+      {
+        id: 5,
+        task: "POST config init",
+        start: "1970-01-01T00:00:00",
+        end: "1970-01-01T00:00:00",
+        expected: "0:10",
+        status: "not started"
+      },
+      {
+        id: 6,
+        task: "GET workspaces",
+        start: "1970-01-01T00:00:00",
+        end: "1970-01-01T00:00:00",
+        expected: "0:04",
+        status: "not started"
+      }
+    ]
+  }
+];
+var X, xe, Ne, Oe;
+class qn {
+  constructor(e) {
+    we(this, X);
+    d(this, "tasks");
+    this.tasks = [new Pe()], this.init(e);
+  }
+  // get initial data from localStorage or file
+  init(e) {
+    if (console.log(`Calling TaskArray::init(bClearLocalStorage: ${e ? "true" : "false"})`), this.tasks.length = 0, e && Q() && localStorage.removeItem("Tasks"), Q()) {
+      let t = localStorage.getItem("Tasks");
+      if (t != null && typeof t == "string" && t !== "") {
+        let s = JSON.parse(t);
+        if (this.tasks = Z(this, X, Ne).call(this, s.tasks), this.tasks.length !== 0) return;
+      }
+    }
+    this.tasks = Z(this, X, Ne).call(this, cn);
+  }
+  // set start time for a task
+  setTaskStart(e, t) {
+    let n = Z(this, X, xe).call(this, e);
+    if (n != null && n != null)
+      n.setStart(t), n.status = "in progress", Z(this, X, Oe).call(this);
+    else
+      debugger;
+  }
+  // set end time for a task
+  setTaskEnd(e, t, n) {
+    let s = Z(this, X, xe).call(this, e);
+    if (s != null && s != null)
+      s.setEnd(t), s.status = n, Z(this, X, Oe).call(this);
+    else
+      debugger;
+  }
+}
+X = new WeakSet(), //
+// private
+//
+xe = function(e) {
+  let t = this.tasks.find((n) => n.task == e);
+  if (t == null || t == null) {
+    for (t of this.tasks)
+      if (t.subtasks != null && t.subtasks != null && (t = t.subtasks.find((n) => n.task == e), t != null && t != null))
+        break;
+  }
+  return t;
+}, Ne = function(e) {
+  return e.map((t) => {
+    let n = new Pe();
+    return n.id = t.id, n.task = t.task, n.setStart(new Date(t.start)), n.setEnd(new Date(t.end)), n.expected = t.expected, n.status = t.status, n.expanded = t.expanded, typeof t.subtasks < "u" && t.subtasks != null && (n.subtasks = t.subtasks.map((s) => {
+      let o = new Pe();
+      return o.id = s.id, o.task = s.task, o.setStart(new Date(s.start)), o.setEnd(new Date(s.end)), o.expected = s.expected, o.status = s.status, o.expanded = s.expanded, o;
+    })), n;
+  });
+}, Oe = function() {
+  let e = JSON.stringify(this);
+  Q() && localStorage.setItem("Tasks", e);
+};
+class Pe {
+  constructor() {
+    d(this, "id", 0);
+    d(this, "task", "");
+    d(this, "start", /* @__PURE__ */ new Date());
+    d(this, "startDisplay", "");
+    d(this, "end", /* @__PURE__ */ new Date());
+    d(this, "endDisplay", "");
+    d(this, "elapsedDisplay", "");
+    d(this, "expected", 0);
+    d(this, "status", "");
+    d(this, "expanded", !1);
+    d(this, "subtasks", []);
+  }
+  setEnd(e) {
+    this.end = e, this.endDisplay = `${this.end.getMinutes().toString().padStart(2, "0")}:${this.end.getSeconds().toString().padStart(2, "0")}`;
+    let t = 0, n = this.end.getSeconds() - this.start.getSeconds();
+    n < 0 && (n += 60, t = -1);
+    let s = this.end.getMinutes() - this.start.getMinutes() + t;
+    s < 0 && (s += 60), this.elapsedDisplay = `${s.toString().padStart(2, "0")}:${n.toString().padStart(2, "0")}`;
+  }
+  setStart(e) {
+    this.start = e, this.startDisplay = `${this.start.getMinutes().toString().padStart(2, "0")}:${this.start.getSeconds().toString().padStart(2, "0")}`;
+  }
+}
+class he {
+  constructor(e) {
+    d(this, "Run", 0);
+    d(this, "Start", /* @__PURE__ */ new Date());
+    d(this, "startDisplay", "");
+    d(this, "POST");
+    d(this, "postDisplay");
+    d(this, "Read");
+    d(this, "readDisplay");
+    d(this, "Write");
+    d(this, "writeDisplay");
+    d(this, "Duration");
+    d(this, "durationDisplay");
+    this.Run = e, this.start(""), this.POST = /* @__PURE__ */ new Date(), this.postDisplay = "", this.Read = /* @__PURE__ */ new Date(), this.readDisplay = "", this.Write = /* @__PURE__ */ new Date(), this.writeDisplay = "", this.Duration = /* @__PURE__ */ new Date(), this.durationDisplay = "";
+  }
+  start(e) {
+    e == "" ? this.Start = /* @__PURE__ */ new Date() : this.Start = new Date(e), this.startDisplay = `${this.Start.getMinutes().toString().padStart(2, "0")}:${this.Start.getSeconds().toString().padStart(2, "0")}`;
+  }
+  post(e) {
+    e == "" ? this.POST = /* @__PURE__ */ new Date() : this.POST = new Date(e), this.postDisplay = `${this.POST.getMinutes().toString().padStart(2, "0")}:${this.POST.getSeconds().toString().padStart(2, "0")}`;
+  }
+  read(e) {
+    e == "" ? this.Read = /* @__PURE__ */ new Date() : this.Read = new Date(e), this.readDisplay = `${this.Read.getMinutes().toString().padStart(2, "0")}:${this.Read.getSeconds().toString().padStart(2, "0")}`;
+  }
+  write(e) {
+    e == "" ? this.Write = /* @__PURE__ */ new Date() : this.Write = new Date(e), this.writeDisplay = `${this.Write.getMinutes().toString().padStart(2, "0")}:${this.Write.getSeconds().toString().padStart(2, "0")}`, this.Duration = new Date(this.Write.getTime() - this.Start.getTime()), this.durationDisplay = `${this.Duration.getMinutes().toString().padStart(2, "0")}:${this.Duration.getSeconds().toString().padStart(2, "0")}`;
+  }
+}
+var _e, Me;
+class ln {
+  constructor(e) {
+    we(this, _e);
+    d(this, "milestones", []);
+    this.init(e);
+  }
+  init(e) {
+    if (Q()) {
+      let t = localStorage.getItem("syncmilestones");
+      if (t != null && typeof t == "string" && t !== "") {
+        let s = JSON.parse(t);
+        if (s.length !== 0)
+          if (e)
+            localStorage.removeItem("syncmilestones");
+          else {
+            Z(this, _e, Me).call(this, s);
+            return;
+          }
+      }
+    }
+    Z(this, _e, Me).call(this, Yt);
+  }
+  save() {
+    let e = JSON.stringify(this.milestones);
+    Q() && localStorage.setItem("syncmilestones", e);
+  }
+  // milestone tracking during a sync
+  start(e) {
+    if (this.milestones == null || this.milestones.length < 1) {
+      debugger;
+      return;
+    }
+    let t = Number(this.milestones[0].Run), n = new he(t + 1);
+    this.milestones.unshift(n), this.milestones = this.milestones.map((s) => {
+      let o = new he(s.Run);
+      return o.Start = s.Start, o.startDisplay = s.startDisplay, o.POST = s.POST, o.postDisplay = s.postDisplay, o.Read = s.Read, o.readDisplay = s.readDisplay, o.Write = s.Write, o.writeDisplay = s.writeDisplay, o.Duration = s.Duration, o.durationDisplay = s.durationDisplay, o;
+    }), e(this.milestones), console.log(`Start milestone: ${this.milestones[0].Run}:${this.milestones[0].Start}`);
+  }
+  unstart(e) {
+    if (this.milestones == null || this.milestones.length < 1) {
+      debugger;
+      return;
+    }
+    let t = this.milestones.shift();
+    this.milestones = this.milestones.map((n) => {
+      let s = new he(n.Run);
+      return s.Start = n.Start, s.startDisplay = n.startDisplay, s.POST = n.POST, s.postDisplay = n.postDisplay, s.Read = n.Read, s.readDisplay = n.readDisplay, s.Write = n.Write, s.writeDisplay = n.writeDisplay, s.Duration = n.Duration, s.durationDisplay = n.durationDisplay, s;
+    }), e(this.milestones), console.log(`Unstart removed first milestone: ${t.Run}:${t.Start}`);
+  }
+  post(e) {
+    if (this.milestones == null || this.milestones.length < 1) {
+      debugger;
+      return;
+    }
+    this.milestones[0].post(""), e(this.milestones), console.log(`POST milestone: ${this.milestones[0].Run}:${this.milestones[0].POST}`);
+  }
+  read(e) {
+    if (this.milestones == null || this.milestones.length < 1) {
+      debugger;
+      return;
+    }
+    this.milestones[0].read(""), e(this.milestones), console.log(`Read milestone: ${this.milestones[0].Run}:${this.milestones[0].Read}`);
+  }
+  write(e) {
+    if (this.milestones == null || this.milestones.length < 1) {
+      debugger;
+      return;
+    }
+    for (this.milestones[0].write(""); this.milestones.length > 10; ) {
+      let t = this.milestones.pop();
+      console.log(`Removed milestone #${t.Run}: ${t.Start}`);
+    }
+    this.save(), this.milestones = this.milestones.map((t) => {
+      let n = new he(t.Run);
+      return n.Start = t.Start, n.startDisplay = t.startDisplay, n.POST = t.POST, n.postDisplay = t.postDisplay, n.Read = t.Read, n.readDisplay = t.readDisplay, n.Write = t.Write, n.writeDisplay = t.writeDisplay, n.Duration = t.Duration, n.durationDisplay = t.durationDisplay, n;
+    }), e(this.milestones);
+  }
+}
+_e = new WeakSet(), Me = function(e) {
+  e == null ? this.milestones = new Array() : this.milestones = e.map((t) => {
+    let n = new he(Number(t.Run));
+    return n.start(t.Start), n.post(t.POST), n.read(t.Read), n.write(t.Write), n;
+  });
+};
+class Jn {
+  constructor(e, t, n) {
+    d(this, "tenantNodes");
+    d(this, "pb_startTS");
+    d(this, "pb_progress");
+    d(this, "pb_increment");
+    d(this, "pb_idle");
+    d(this, "pb_idleMax");
+    d(this, "pb_total");
+    d(this, "pb_timer");
+    d(this, "milestoneArray");
+    this.tenantNodes = new Array(), this.init(e, t, n), this.pb_startTS = 0, this.pb_progress = 0, this.pb_increment = 0, this.pb_timer = null, this.pb_idle = 0, this.pb_idleMax = 0, this.pb_total = 0, this.milestoneArray = new ln(!1);
+  }
+  // populate tenantNodes based on config tenants
+  init(e, t, n) {
+    console.log(
+      `Calling BatchArray::init(config: "${e ? e.name : "null"}", bClearLocalStorage: ${n ? "true" : "false"})`
+    ), n && Q() && (localStorage.removeItem(e.name), this.milestoneArray.init(n)), e != null && e.tenants != null && t != null && (this.tenantNodes.length = 0, e.tenants.map((s) => {
+      if (s.configurationTenantType === "source" || s.configurationTenantType === "sourcetarget") {
+        let o = t.ts.find(
+          (i) => i.tid === s.tid
+        );
+        if (o != null) {
+          let i = new Ke(
+            s.tid,
+            o.name,
+            s.batchId
+          );
+          this.tenantNodes.push(i);
+        } else {
+          console.log(
+            `Error: no tenant found for config source tenant ${e.name}`
+          );
+          debugger;
+          return;
+        }
+      }
+    }), this.tenantNodes.map((s) => {
+      e.tenants.map((o) => {
+        if ((o.configurationTenantType === "target" || o.configurationTenantType === "sourcetarget") && o.tid !== s.tid) {
+          let i = t.ts.find(
+            (c) => c.tid === o.tid
+          );
+          if (i != null) {
+            let c = new Ke(
+              o.tid,
+              i.name,
+              o.batchId
+            );
+            s.targets.push(c), s.expanded = !0;
+          } else {
+            console.log(
+              `Error: no tenant found for config target tenant ${e.name}`
+            );
+            debugger;
+            return;
+          }
+        }
+      });
+    }));
+  }
+  initializeProgressBar(e, t, n, s) {
+    this.pb_startTS = Date.now(), this.pb_progress = 0, this.pb_increment = 0.25, this.pb_idle = 0, this.pb_idleMax = 0, this.pb_total = 0, this.pb_timer = setInterval(() => {
+      this.milestoneArray.milestones[0].Write != null ? (clearInterval(this.pb_timer), this.pb_timer = null, this.pb_progress = 100, e(this.pb_progress), n(`Complete. [max idle: ${this.pb_idleMax}]`)) : (this.pb_total = this.pb_total + 1, this.pb_idle = this.pb_idle + 1, this.pb_idleMax = Math.max(this.pb_idle, this.pb_idleMax), n(`${this.pb_total} seconds elapsed. Last update ${this.pb_idle} seconds ago. [max idle: ${this.pb_idleMax}/60]`), this.pb_idle >= 60 && this.milestoneArray.milestones[0].Write == null && t(`sync continuing, but no update for ${this.pb_idle} seconds`), this.pb_progress < 100 && (this.pb_progress = Math.min(100, this.pb_progress + this.pb_increment), e(this.pb_progress)));
+    }, 1e3), this.milestoneArray.start(s);
+  }
+  uninitializeProgressBar(e, t, n, s) {
+    this.pb_startTS = 0, this.pb_progress = 0, e(this.pb_progress), t("sync failed to execute"), this.pb_increment = 0, clearInterval(this.pb_timer), this.pb_timer = null, this.pb_idle = 0, this.pb_idleMax = 0, n(`No updates seen for ${this.pb_idle} seconds. [max idle: ${this.pb_idleMax}]`), this.milestoneArray.unstart(s);
+  }
+  initializeSignalR(e, t, n, s, o, i, c, a, l, u, p) {
+    this.milestoneArray.post(l), u("started sync, waiting for updates..."), this.init(e, t, !1);
+    let f = (P) => {
+      console.log(P);
+      let W = JSON.parse(P);
+      this.pb_idle = 0;
+      let M = n.find((S) => S.BatchId == W.TargetID);
+      if (M == null) {
+        console.log(`Batch ${W.TargetID} not found in batchIdArray.`);
+        debugger;
+        return;
+      }
+      let g = this.tenantNodes.find((S) => S.tid === M.SourceId);
+      if (g == null) {
+        console.log(`Tenant ${M.SourceId} not found in BatchArray.`);
+        debugger;
+        return;
+      }
+      g.batchId = M.BatchId;
+      let b = W.Stats, y = Object.keys(b), T = Object.values(b), z = !1, C = !1;
+      for (let S = 0; S < y.length; S++) {
+        let F = y[S].endsWith("TotalCount"), I = y[S].endsWith("CurrentCount"), U = y[S].endsWith("DeferredCount"), ke = y[S].endsWith("RescheduledCount");
+        if (y[S].startsWith("Reader")) {
+          let Y = /Reader\/TID:(.+)\/TotalCount/;
+          if (I && (Y = /Reader\/TID:(.+)\/CurrentCount/), U && (Y = /Reader\/TID:(.+)\/DeferredCount/), ke && (Y = /Reader\/TID:(.+)\/RescheduledCount/), y[S].match(Y) == null) {
+            console.log(`tid not found in ${y[S]}.`);
+            debugger;
+            return;
+          }
+          F ? (z = Number(T[S]) == 0, g.total = Math.max(Number(T[S]), g.total), console.log(`----- ${g.name} TID: ${g.tid} batchId: ${g.batchId}`), console.log(`----- ${g.name} Total To Read: ${g.total}`)) : (C = Number(T[S]) == 0, g.read = Math.max(Number(T[S]), g.read), console.log(`----- ${g.name} Currently Read: ${g.read}`));
+        }
+        if (g.nothingtosync = z && C, y[S].startsWith("Writer")) {
+          let Y = /Writer\/TID:(.+)\/TotalCount/;
+          I && (Y = /Writer\/TID:(.+)\/CurrentCount/), U && (Y = /Writer\/TID:(.+)\/DeferredCount/), ke && (Y = /Writer\/TID:(.+)\/RescheduledCount/);
+          let Ae = y[S].match(Y);
+          if (Ae == null) {
+            console.log(`tid not found in ${y[S]}.`);
+            debugger;
+            return;
+          }
+          let E = g.targets.find((nt) => nt.tid === Ae[1]);
+          if (E == null) {
+            console.log(`Writer ${g.name} not found under Reader ${g.name}.`);
+            debugger;
+            return;
+          }
+          if (E.batchId = M.BatchId, F)
+            E.total = Math.max(Number(T[S]), E.total), console.log(`----- ${E.name} TID: ${E.tid} batchId: ${E.batchId}`), console.log(`----- ${E.name} Total To Write: ${E.total}`);
+          else if (I)
+            E.written = Math.max(Number(T[S]), E.written), console.log(`----- ${E.name} Total Written: ${E.written}`);
+          else if (U || ke)
+            E.deferred = Math.max(Number(T[S]), E.deferred), console.log(`----- ${E.name} Total Deferred: ${E.deferred}`);
+          else {
+            console.log("unknown writer type");
+            debugger;
+            return;
+          }
+          E.update(E.total, E.read, E.written, E.deferred);
+        }
+      }
+      g.update(g.total, g.read, g.written, g.deferred);
+      let N = !0, J = !0, $ = !1, ye = !0, se = 0, le = 0, ue = 0, de = 0;
+      if (this.tenantNodes.map((S) => {
+        S.targets.map((F) => {
+          J && (J = F.status == "complete" || F.status == "failed"), $ || ($ = F.total > 0 || F.status != "not started"), ue += Math.max(F.total, S.total), de += F.written;
+        }), ye && (ye = S.nothingtosync), N && (N = S.status == "complete" || S.status == "failed"), se += S.total, le += S.read;
+      }), o(se), i(le), c(Math.max(ue, se)), a(de), ye)
+        this.milestoneArray.write(l), u("nothing to sync"), console.log('Setting config sync result: "nothing to sync"');
+      else {
+        if (N && this.milestoneArray.milestones[0].Read == null) {
+          this.milestoneArray.read(l), u("reading complete"), console.log('Setting config sync result: "reading complete"'), s(e.workspaceId);
+          let U = (Date.now() - this.pb_startTS) / 1e3 / 8.5;
+          this.pb_increment = U, console.log(`Setting increment: ${this.pb_increment}% per second`);
+        }
+        J ? (this.milestoneArray.write(l), u("sync complete"), console.log('Setting config sync result: "complete"')) : $ ? (u("writing in progress"), console.log('Setting config sync result: "writing in progress"')) : this.milestoneArray.milestones[0].Read == null && (u("reading in progress"), console.log('Setting config sync result: "reading in progress"'));
+      }
+    };
+    n.map((P) => {
+      const W = R.signalREndpoint();
+      let M = new URL(W);
+      M.searchParams.append("statsId", P.BatchId), console.log(`Creating SignalR Hub for TID: ${P.SourceId} ${M.href}`);
+      const g = new Bt().withUrl(M.href).withAutomaticReconnect().configureLogging(h.Information).build();
+      g.on("newMessage", f), g.onreconnecting((b) => {
+        console.assert(g.state === v.Reconnecting), console.log(`Connection lost due to error "${b}". Reconnecting.`);
+      }), g.onreconnected((b) => {
+        console.assert(g.state === v.Connected), console.log(`Connection reestablished. Connected with connectionId "${b}".`);
+      }), g.onclose(async () => {
+        console.log("Connection closing. Attempting restart."), await g.start();
+      }), g.start().catch(console.error);
+    });
+  }
+  // start a sync cycle
+  async startSync(e, t, n) {
+    let s = new A();
+    if (this.tenantNodes == null || this.tenantNodes.length == 0) {
+      debugger;
+      return s.result = !1, s.error = "startSync: invalid parameters", s.status = 500, s;
+    }
+    return s = await Gn(e, t, n), s;
+  }
+}
+class Ke {
+  constructor(e, t, n) {
+    d(this, "expanded");
+    d(this, "status", "");
+    d(this, "name");
+    d(this, "tid");
+    d(this, "batchId");
+    d(this, "total", 0);
+    d(this, "read", 0);
+    d(this, "written", 0);
+    d(this, "deferred", 0);
+    d(this, "nothingtosync");
+    d(this, "targets");
+    this.expanded = !1, this.name = t, this.tid = e, this.batchId = n, this.nothingtosync = !1, this.targets = new Array(), this.update(0, 0, 0, 0);
+  }
+  update(e, t, n, s) {
+    this.total = e, this.read = t, this.written = n, this.deferred = s, this.read === 0 && this.written === 0 && (this.status = "not started"), this.read > 0 ? this.read < this.total ? this.status = "in progress" : this.read === this.total && (this.status = "complete") : this.written > 0 && (this.written + this.deferred < this.total ? this.status = "in progress" : this.written === this.total ? this.status = "complete" : this.written + this.deferred >= this.total && (this.status = "failed"));
+  }
+}
+class Ye {
+  constructor(e, t) {
+    d(this, "resourceNodes");
+    this.resourceNodes = new Array(), e && this.init(t);
+  }
+  // get resource data from localStorage or file
+  init(e) {
+    if (console.log(`Calling ResourceArray::init(bClearLocalStorage: ${e ? "true" : "false"})`), Q()) {
+      let n = localStorage.getItem("ResourceArray");
+      if (n != null && typeof n == "string" && n !== "")
+        if (e)
+          localStorage.removeItem("ResourceArray");
+        else {
+          let o = JSON.parse(n);
+          this.resourceNodes = o.resourceNodes;
+          return;
+        }
+    }
+    var t = JSON.stringify(Vt);
+    try {
+      this.resourceNodes = ae(un, t);
+    } catch {
+      debugger;
+    }
+  }
+  // read
+  async read(e, t) {
+    let n = new Ye(!1, !1);
+    return n.resourceNodes = await bn(e, t), n;
+  }
+  // save resource data to localstorage
+  save() {
+    if (Q()) {
+      let e = JSON.stringify(this);
+      localStorage.setItem("ResourceArray", e);
+    }
+  }
+}
+class un {
+  constructor(e, t, n) {
+    d(this, "type");
+    d(this, "resource");
+    d(this, "cost");
+    d(this, "expanded");
+    d(this, "resources");
+    this.type = e, this.resource = t, this.cost = n, this.expanded = !1, this.resources = new Array();
+  }
+}
+class Kn {
+  constructor(e) {
+    d(this, "actorNodes");
+    this.actorNodes = new Array(), this.init(e);
+  }
+  // get initial data from localStorage or file
+  init(e) {
+    if (console.log(`Calling ResourceArray::init(bClearLocalStorage: ${e ? "true" : "false"})`), Q()) {
+      let n = localStorage.getItem("RBACActors");
+      if (n != null && typeof n == "string" && n !== "")
+        if (e)
+          localStorage.removeItem("RBACActors");
+        else {
+          let o = JSON.parse(n);
+          this.actorNodes = o.actorNodes;
+          return;
+        }
+    }
+    var t = JSON.stringify(en);
+    try {
+      this.actorNodes = ae(dn, t);
+    } catch {
+      debugger;
+    }
+  }
+}
+class dn {
+  constructor(e, t, n, s, o, i) {
+    d(this, "type");
+    d(this, "actor");
+    d(this, "resource");
+    d(this, "role");
+    d(this, "updatedby");
+    d(this, "updatedon");
+    d(this, "actors");
+    this.type = e, this.actor = t, this.resource = n, this.role = s, this.updatedby = o, this.updatedon = i, this.actors = new Array();
+  }
+}
+function hn(r) {
+  return "Group.Read.All User.Read.All openid profile offline_access User.Read Contacts.Read CrossTenantInformation.ReadBasic.All";
+}
+async function ve(r, e) {
+  const t = new Headers();
+  t.append("Content-Type", "application/json"), t.append("accept", "*/*");
+  const n = hn();
+  if (e.graphAccessToken == null || e.graphAccessToken === "")
+    try {
+      let s = await r.acquireTokenByCode({
+        code: e.spacode
+      });
+      e.graphAccessToken = s.accessToken, console.log("Front end token acquired by code: " + e.graphAccessToken.slice(0, 20));
+    } catch (s) {
+      console.log("Front end token failure: " + s);
+    }
+  else
+    try {
+      let s = r.getAllAccounts(), o = e.oid + "." + e.tid, i = null;
+      for (let a = 0; a < s.length; a++)
+        s[a].homeAccountId == o && (i = s[a]);
+      let c = await r.acquireTokenSilent({
+        scopes: [n],
+        account: i
+      });
+      e.graphAccessToken = c.accessToken, console.log("Front end token graph acquired silently: " + e.graphAccessToken.slice(0, 20));
+    } catch (s) {
+      try {
+        console.log("Front end graph token silent acquisition failure: " + s);
+        let o = r.getAllAccounts(), i = e.oid + "." + e.tid, c = null;
+        for (let a = 0; a < o.length; a++)
+          o[a].homeAccountId == i && (c = o[a]);
+        r.acquireTokenRedirect({
+          scopes: [n],
+          account: c
+        });
+      } catch (o) {
+        console.log("Front end graph token redirect acquisition failure: " + o);
+      }
+    }
+  return t.append("Authorization", `Bearer ${e.graphAccessToken}`), t;
+}
+async function Xn(r, e, t) {
+  if (e == null || e.spacode == "")
+    return { groups: [], error: "500: invalid user passed to groupsGet" };
+  let s = { method: "GET", headers: await ve(r, e) };
+  try {
+    let o = ne(e.authority) + m.graphGroupsPredicate;
+    o += `/?$filter=startsWith(displayName, '${t}')`;
+    let c = await (await fetch(o, s)).json();
+    return typeof c.error < "u" ? { groups: [], error: `${c.error.code}: ${c.error.message}` } : { groups: c.value, error: "" };
+  } catch (o) {
+    return console.log(o), { groups: [], error: `Exception: ${o}` };
+  }
+}
+async function fn(r, e, t, n) {
+  try {
+    let s = ne(e.authority) + m.graphOauth2PermissionGrantsPredicate, o = new URL(s);
+    o.searchParams.append("$filter", `resourceId eq '${t}' and consentType eq 'Principal' and principalId eq '${n}'`);
+    let c = await (await fetch(o.href, r)).json();
+    if (typeof c.error < "u")
+      return { grants: null, id: null, error: `${c.error.code}: ${c.error.message}` };
+    if (c.value.length != 1) {
+      debugger;
+      return { grants: null, id: null, error: "oauth2PermissionGrantsGet: more than one matching delegated consent grant." };
+    }
+    return { grants: c.value[0].scope, id: c.value[0].id, error: "" };
+  } catch (s) {
+    return console.log(s), { grants: null, id: null, error: `Exception: ${s}` };
+  }
+}
+async function pn(r, e, t, n) {
+  if (e == null || e.spacode == "")
+    return !1;
+  try {
+    let s = ne(e.authority);
+    s += m.graphOauth2PermissionGrantsPredicate + `/${t}`;
+    let o = `{ "scope": "${n}" }`, c = { method: "PATCH", headers: await ve(r, e), body: o }, a = await fetch(s, c), l = await a.json();
+    if (a.status == 204 && a.statusText == "No Content")
+      return !0;
+    debugger;
+    return console.log(`oauth2PermissionGrantsSet: PATCH failed ${l.error.code}: ${l.error.message}`), !1;
+  } catch (s) {
+    debugger;
+    return console.log(s), !1;
+  }
+}
+function Zn(r, e) {
+  let t = on(r.authority);
+  t += r.tid, t += "/adminconsent";
+  let n = new URL(t), s = sn(r.authority, e);
+  n.searchParams.append("client_id", s), n.searchParams.append("redirect_uri", window.location.origin), n.searchParams.append("domain_hint", r.companyDomain), n.searchParams.append("login_hint", r.mail), window.location.assign(n.href);
+}
+async function gn(r, e, t) {
+  try {
+    let n = ne(e.authority);
+    n += m.graphServicePrincipalsPredicate, n += `(appId='${t}')`;
+    let s = new URL(n);
+    s.searchParams.append("$select", "id,appId,displayName");
+    let i = await (await fetch(s.href, r)).json();
+    return typeof i.error < "u" ? { spid: "", error: `${i.error.code}: ${i.error.message}` } : { spid: i.id, error: "" };
+  } catch (n) {
+    return console.log(n), { spid: "", error: `Exception: ${n}` };
+  }
+}
+async function Qn(r, e) {
+  if (r.authority == "") {
+    let s = new me();
+    if (s.domain = r.tid, await Ve(s, !1))
+      r.authority = s.authority;
+    else {
+      debugger;
+      return !1;
+    }
+  }
+  let t = window.location.href;
+  switch (r.authority) {
+    case m.authorityWW:
+      t += "MicrosoftIdentity/Account/SignIn";
+      break;
+    case m.authorityUS:
+      t += "USGov/SignIn";
+      break;
+    case m.authorityCN:
+      t += "China/SignIn";
+      break;
+    default:
+      return !1;
+  }
+  let n = new URL(t);
+  if (n.searchParams.append("redirectUri", window.location.origin), r.oid !== "1") {
+    n.searchParams.append("loginHint", r.mail);
+    const s = /@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})$/, o = r.mail.match(s);
+    let i = o ? o[1] : "organizations";
+    n.searchParams.append("domainHint", i);
+  } else
+    n.searchParams.append("domainHint", "organizations");
+  return e.setTaskStart("initialization", /* @__PURE__ */ new Date()), e.setTaskStart("authenticate user", /* @__PURE__ */ new Date()), window.location.assign(n.href), !0;
+}
+function Yn(r, e) {
+  debugger;
+  if (r.oid == "1") return;
+  let t = window.location.href;
+  switch (r.authority) {
+    case m.authorityWW:
+      t += "MicrosoftIdentity/Account/Challenge";
+      break;
+    case m.authorityUS:
+      t += "USGov/Challenge";
+      break;
+    case m.authorityCN:
+      t += "China/Challenge";
+      break;
+    default:
+      return;
+  }
+  let n = new URL(t);
+  n.searchParams.append("redirectUri", window.location.origin), n.searchParams.append("scope", e), n.searchParams.append("domainHint", "organizations"), n.searchParams.append("loginHint", r.mail), window.location.assign(n.href);
+}
+async function Vn(r) {
+  if (r.oid == "1") return !1;
+  let e = window.location.href;
+  e += "user";
+  let t = new URL(e);
+  t.searchParams.append("oid", r.oid), t.searchParams.append("tid", r.tid), t.searchParams.append("loginHint", r.loginHint), t.searchParams.append("verb", "LOGOUT");
+  let n = { method: "PATCH" }, s = await fetch(t.href, n);
+  if (s.status == 200 && s.statusText == "OK")
+    console.log(`Successfully set admin ${r.mail} logout_hint`);
+  else
+    return console.log(`Failed to set admin ${r.mail} logout_hint`), !1;
+  let o = window.location.href;
+  switch (r.authority) {
+    case m.authorityWW:
+      o += "MicrosoftIdentity/Account/SignOut";
+      break;
+    case m.authorityUS:
+      o += "USGov/SignOut";
+      break;
+    case m.authorityCN:
+      o += "China/SignOut";
+      break;
+    default:
+      return !1;
+  }
+  return t = new URL(o), t.searchParams.append("redirectUri", window.location.origin), window.location.assign(t.href), !0;
+}
+async function es(r, e, t, n) {
+  if (n) debugger;
+  if (e.name != null && e.name !== "") return !1;
+  if (r.graphAccessToken != null && r.graphAccessToken === "") {
+    console.log(`tenantRelationshipsGetByDomain called with invalid logged in user: ${r.name}`);
+    try {
+      let a = await t.acquireTokenByCode({ code: r.spacode, scopes: ["user.read", "contacts.read", "CrossTenantInformation.ReadBasic.All"] });
+      r.graphAccessToken = a.accessToken, console.log("tenantRelationshipsGetByDomain: Front end token acquired: " + r.graphAccessToken.slice(0, 20));
+    } catch (a) {
+      return console.log("tenantRelationshipsGetByDomain: Front end token failure: " + a), !1;
+    }
+  }
+  const s = new Headers(), o = `Bearer ${r.graphAccessToken}`;
+  s.append("Authorization", o);
+  let i = { method: "GET", headers: s };
+  try {
+    var c = ne(e.authority) + m.graphTenantByDomainPredicate;
+    c += "(domainName='", c += e.domain, c += "')", console.log("tenantRelationshipsGetByDomain: Attempting GET from /findTenantInformationByDomainName:", c);
+    let a = await fetch(c, i);
+    if (a.status == 200) {
+      let l = await a.json();
+      if (l) {
+        if (l.error != null) {
+          debugger;
+          return console.log("tenantRelationshipsGetByDomain: Failed GET from /findTenantInformationByDomainName: ", l.error.message), !1;
+        } else if (l.displayName != null && l.displayName !== "")
+          return e.tid = l.tenantId, e.name = l.displayName, console.log("tenantRelationshipsGetByDomain: Successful GET from /findTenantInformationByDomainName: ", l.displayName), !0;
+      } else
+        console.log("tenantRelationshipsGetByDomain: Failed to GET from /findTenantInformationByDomainName: ", c);
+    }
+  } catch (a) {
+    return console.log("Failed to GET from /findTenantInformationByDomainName: ", a), !1;
+  }
+  return !1;
+}
+async function mn(r, e, t, n, s) {
+  if (console.log("**** tenantRelationshipsGetById"), s) debugger;
+  if (r.graphAccessToken === "")
+    try {
+      let l = await n.acquireTokenByCode({ code: r.spacode, scopes: ["user.read", "contacts.read", "CrossTenantInformation.ReadBasic.All"] });
+      r.graphAccessToken = l.accessToken, console.log("tenantRelationshipsGetById: Front end token acquired: " + r.graphAccessToken.slice(0, 20));
+    } catch (l) {
+      return console.log("tenantRelationshipsGetById: Front end token failure: " + l), !1;
+    }
+  const o = new Headers(), i = `Bearer ${r.graphAccessToken}`;
+  o.append("Authorization", i);
+  let c = { method: "GET", headers: o };
+  try {
+    var a = ne(r.authority) + m.graphTenantByIdPredicate;
+    a += "(tenantId='", a += e.tid, a += "')", console.log("tenantRelationshipsGetById: Attempting GET from /findTenantInformationByTenantId:", a);
+    let u = await (await fetch(a, c)).json();
+    if (u && typeof u.displayName !== void 0 && u.displayName !== "") {
+      if (e !== void 0)
+        e.name = u.displayName, e.domain = u.defaultDomainName;
+      else {
+        console.log("tenantRelationshipsGetById: missing associated tenant for logged in user.");
+        debugger;
+      }
+      return console.log("tenantRelationshipsGetById: Successful GET from /findTenantInformationByTenantId: ", u.displayName), !0;
+    } else
+      console.log("tenantRelationshipsGetById: Failed to GET from /findTenantInformationByTenantId: ", a);
+  } catch (l) {
+    return console.log("tenantRelationshipsGetById: Failed to GET from /findTenantInformationByTenantId: ", l), !1;
+  }
+  return !1;
+}
+async function Ve(r, e) {
+  if (e) debugger;
+  let t = [m.authorityWW, m.authorityUS, m.authorityCN], n = [m.authorityWWRegex, m.authorityUSRegex, m.authorityCNRegex], s = null;
+  try {
+    for (let a = 0; a < 3; a++) {
+      var o = t[a];
+      if (r.lookupfield == "Domain" ? o += r.domain : r.lookupfield == "Tenant ID" && (o += r.tid), o += "/.well-known/openid-configuration", console.log("Attempting GET from openid well-known endpoint: ", o), s = await fetch(o), s.status == 200) {
+        let l = await s.json();
+        if (l) {
+          var i = l.authorization_endpoint;
+          for (let u = 0; u < 3; u++) {
+            var c = i.match(n[u]);
+            if (c != null)
+              return r.tid = c[2], r.authority = c[1], console.log(`Successful GET from openid well-known endpoint: tid: ${r.tid} authority: ${r.authority}`), !0;
+          }
+        } else
+          console.log(`Failed JSON parse of openid well-known endpoint response ${o}.`);
+      } else
+        console.log(`Failed GET from ${o}.`);
+    }
+  } catch (a) {
+    console.log("Failed to GET from openid well-known endpoint: ", a);
+  }
+  return (r.tid == "" || r.authority == "") && console.log(`GET from openid well-known endpoint failed to find tenant: ${s ? s.statusText : "unknown"}`), !1;
+}
+async function _n(r, e, t) {
+  if (e == null || e.spacode == "" || t == null) {
+    debugger;
+    return { scopes: null, id: null, error: "500: invalid parameter(s) passed to getUserDelegatedScopes" };
+  }
+  let s = { method: "GET", headers: await ve(r, e) };
+  try {
+    if (t.graphSP == "") {
+      let { spid: a, error: l } = await gn(s, e, "00000003-0000-0000-c000-000000000000");
+      if (l != "") {
+        debugger;
+        return { scopes: null, id: null, error: `${l}` };
+      }
+      t.graphSP = a;
+    }
+    let { grants: o, id: i, error: c } = await fn(s, e, t.graphSP, e.oid);
+    if (c != "") {
+      debugger;
+      return { scopes: null, id: null, error: `${c}` };
+    }
+    return { scopes: o, id: i, error: "" };
+  } catch (o) {
+    debugger;
+    return console.log(o), { scopes: null, id: null, error: `Exception: ${o}` };
+  }
+}
+async function ts(r, e, t, n) {
+  if (e == null || e.spacode == "" || t == null) {
+    debugger;
+    return !1;
+  }
+  let { scopes: s, id: o, error: i } = await _n(r, e, t);
+  if (i != "") {
+    debugger;
+    return console.log(`userDelegatedScopesRemove: cannot find userDelegatedScopes for ${e.mail}: ${i}`), !1;
+  }
+  s = s.replace(n, "");
+  let c = await pn(r, e, o, s);
+  if (!c) {
+    debugger;
+    return console.log(`userDelegatedScopesRemove: cannot set oauth2PermissionGrants for ${e.mail}: ${i}`), !1;
+  }
+  return e.scopes = s.split(" "), c;
+}
+async function ns(r, e) {
+  if (e == null || e.spacode == "")
+    return { users: [], error: "500: invalid user passed to usersGet" };
+  try {
+    let n = { method: "GET", headers: await ve(r, e) }, s = ne(e.authority);
+    s += m.graphUsersPredicate;
+    let i = await (await fetch(s, n)).json();
+    if (typeof i.error < "u")
+      return { users: [], error: `${i.error.code}: ${i.error.message}` };
+    let c = new Array();
+    for (let a of i.value)
+      c.push(a.mail);
+    return { users: c, error: "" };
+  } catch (t) {
+    return console.log(t), { users: [], error: `Exception: ${t}` };
+  }
+}
+async function ss(r, e, t, n, s, o, i, c) {
+  let a = new A();
+  if (t.id === "1") {
+    if (a = await $n(r, e, t, o.id, c), a.result) {
+      n && n(t.id);
+      const l = {};
+      Object.defineProperty(l, t.id, { value: !0, writable: !0, enumerable: !0 }), s(l);
+      let u = o.associatedConfigs.findIndex((p) => p == "1");
+      u !== -1 && (o.associatedConfigs.splice(u, 1), o.associatedConfigs.push(t.id));
+    }
+  } else
+    a = await Dn(r, e, t, c);
+  return i.save(), a;
+}
+async function os(r, e, t, n, s) {
+  let o = new A();
+  return o = await Pn(r, e, t, n, s), o;
+}
+async function rs(r, e, t, n, s) {
+  return En(r, e, t, n);
+}
+async function is(r, e, t, n, s) {
+  return kn(r, e, t, n, s);
+}
+async function as(r, e, t, n, s) {
+  return An(r, e, t, n, s);
+}
+async function cs(r, e, t, n, s) {
+  let o = new A();
+  if (s) debugger;
+  try {
+    let i = n.ws.find((c) => c.id === t);
+    if (i != null) {
+      i.associatedConfigs.length = 0;
+      let c = await tt(r, e, i.id, s);
+      if (!c.result) return c;
+      let a = "";
+      for (let l of i.associatedConfigs) {
+        let u = n.cs.find((p) => p.id === l);
+        u != null && u.sel && (a = u.id);
+      }
+      et(i, n, c.array, a), n.tagWithWorkspaces();
+    }
+    return o;
+  } catch (i) {
+    console.log(i.message), o.error = i.message;
+  }
+  return o.result = !1, o.status = 500, o;
+}
+async function ls(r, e, t, n, s) {
+  console.log(">>>>>> initGet");
+  let o = new A();
+  if (s)
+    debugger;
+  let i = new me();
+  return i.tid = e.tid, i.domain = e.tid, await Ve(i, s) ? (e.authority = i.authority, n.setTaskStart("GET tenant details", /* @__PURE__ */ new Date()), o.result = await mn(e, i, t, r, s), n.setTaskEnd("GET tenant details", /* @__PURE__ */ new Date(), "complete"), o.result && (e.companyName = i.name, e.companyDomain = i.domain, n.setTaskStart("POST config init", /* @__PURE__ */ new Date()), o = await Rn(r, e, s), n.setTaskEnd("POST config init", /* @__PURE__ */ new Date(), o.result ? "complete" : "failed")), o.result && (n.setTaskStart("GET workspaces", /* @__PURE__ */ new Date()), o = await Sn(r, e, t, s), n.setTaskEnd("GET workspaces", /* @__PURE__ */ new Date(), o.result ? "complete" : "failed")), console.log("initGet complete. Version: " + Te), o) : (o.error = `Failed to retrieve authority for user "${e.mail}" TID ${e.tid}.`, o.result = !1, o);
+}
+async function us(r, e, t, n) {
+  return On(r, e, t, n);
+}
+async function ds(r, e, t, n, s) {
+  return xn(r, e, t, n);
+}
+async function hs(r, e, t, n) {
+  return vn(r, e, t, n);
+}
+async function fs(r, e, t, n) {
+  return Cn(r, e, t, n);
+}
+async function ps(r, e, t, n) {
+  return await Mn(r, e, t, n);
+}
+function yn(r, e, t, n) {
+  t.map((s) => {
+    let o = null, i = e.us.findIndex((l) => l.oid === s.userId || l.oid === s.email);
+    if (i === -1) {
+      let l = e.us.findIndex((u) => u.oid === "1");
+      if (l !== -1) {
+        o = e.us.at(l);
+        let u = r.associatedUsers.findIndex((p) => p == "1");
+        u !== -1 && (r.associatedUsers.splice(u, 1), r.associatedUsers.push(s.userId));
+      } else
+        o = new $e(), e.us.push(o);
+    } else
+      o = e.us.at(i);
+    o.sel = n === s.userId, o.oid = s.userId ? s.userId : s.email, o.name = s.firstName ?? o.name, o.mail = s.email, o.tid = s.tenantId;
+    let c = e.ts.find((l) => l.tid === o.tid);
+    c != null && (o.authority = c.authority, o.companyName = c.name, o.companyDomain = c.domain), r.associatedUsers.findIndex((l) => l === o.oid) == -1 && r.associatedUsers.push(o.oid);
+  }), e.save();
+}
+function wn(r, e, t, n) {
+  t.map((s) => {
+    let o = null, i = e.ts.findIndex((u) => u.tid === s.tenantId);
+    if (i === -1) {
+      let u = e.ts.findIndex((p) => p.tid === "1");
+      if (u !== -1) {
+        o = e.ts.at(u);
+        let p = r.associatedTenants.findIndex((f) => f == "1");
+        p !== -1 && (r.associatedTenants.splice(p, 1), r.associatedTenants.push(s.tenantId));
+      } else
+        o = new me(), e.ts.push(o);
+    } else
+      o = e.ts.at(i);
+    o.sel = n === s.tenantId, o.tid = s.tenantId, o.name = s.name, o.domain = s.domain, o.tenantType = s.type.toLowerCase();
+    const c = /^(https:\/\/login.microsoftonline.(?:us|com)\/)organizations\/v2.0$/, a = s.authority.match(c);
+    o.authority = a ? a[1] : s.authority, r.associatedTenants.findIndex((u) => u === s.tenantId) == -1 && r.associatedTenants.push(s.tenantId);
+  }), e.save();
+}
+function et(r, e, t, n) {
+  t.map((s) => {
+    let o = null, i = e.cs.findIndex((a) => a.id === s.id);
+    if (i === -1) {
+      let a = e.cs.findIndex((l) => l.id === "1");
+      if (a !== -1) {
+        o = e.cs.at(a);
+        let l = r.associatedConfigs.findIndex((u) => u == "1");
+        l !== -1 && (r.associatedConfigs.splice(l, 1), r.associatedConfigs.push(s.id));
+      } else
+        o = new De(), e.cs.push(o);
+    } else
+      o = e.cs.at(i);
+    o.sel = n === s.id, o.id = s.id, o.workspaceId = s.workspaceId, o.name = s.name, o.description = s.description, o.isEnabled = s.isEnabled, o.tenants.length = 0, s.tenants.map((a) => {
+      let l = new an();
+      l.tid = a.tenantId, l.sourceGroupId = a.sourceGroupId ?? "", l.sourceGroupName = a.sourceGroupName ?? "", l.targetGroupId = a.targetGroupId ?? "", l.targetGroupName = a.targetGroupName ?? "", l.configurationTenantType = a.configurationTenantType.toLowerCase(), l.deltaToken = a.deltaToken ?? "", l.configId = o.id, l.batchId = a.batchId ?? "", l.isReadPermissionConsented = a.isReadPermissionConsented, l.isWritePermissionConsented = a.isWritePermissionConsented, o.tenants.push(l);
+    }), r.associatedConfigs.findIndex((a) => a === s.id) == -1 && r.associatedConfigs.push(s.id);
+  }), e.save();
+}
+async function Sn(r, e, t, n) {
+  let s = new A();
+  if (n) debugger;
+  try {
+    if (s = await Ln(r, e, n), s.result) {
+      for (let o of s.array) {
+        let i = null, c = t.ws.findIndex((b) => b.id === o.id);
+        if (c === -1) {
+          let b = t.ws.findIndex((y) => y.id === "1");
+          b !== -1 ? i = t.ws.at(b) : (i = new Re(), t.ws.push(i));
+        } else
+          i = t.ws.at(c);
+        let a = "";
+        for (let b of i.associatedUsers) {
+          let y = t.us.find((T) => T.oid === b);
+          y != null && y.sel && (a = y.oid);
+        }
+        let l = "";
+        for (let b of i.associatedTenants) {
+          let y = t.ts.find((T) => T.tid === b);
+          y != null && y.sel && (l = y.tid);
+        }
+        let u = "";
+        for (let b of i.associatedConfigs) {
+          let y = t.cs.find((T) => T.id === b);
+          y != null && y.sel && (u = y.id);
+        }
+        i.associatedUsers.length = 0, i.associatedTenants.length = 0, i.associatedConfigs.length = 0, i.id = o.id, i.name = o.name, i.ownerid = o.ownerid;
+        let p = In(r, e, i.id, n), f = Nn(r, e, i.id, n), P = tt(r, e, i.id, n), [W, M, g] = await Promise.all([p, f, P]);
+        if (!W.result) return W;
+        if (!M.result) return M;
+        if (!g.result) return g;
+        wn(i, t, M.array, l), yn(i, t, W.array, a), et(i, t, g.array, u), t.tagWithWorkspaces();
+      }
+      return s;
+    }
+  } catch (o) {
+    console.log(o.message), s.error = o.message;
+  }
+  return s.result = !1, s.status = 500, s;
+}
+async function gs(r, e) {
+  let t = "";
+  try {
+    let n = r.getAllAccounts(), s = e.oid + "." + e.tid, o = null;
+    for (let c = 0; c < n.length; c++)
+      n[c].homeAccountId == s && (o = n[c]);
+    t = (await r.acquireTokenSilent({
+      scopes: [
+        "https://analysis.windows.net/powerbi/api/App.Read.All",
+        "https://analysis.windows.net/powerbi/api/Dataset.ReadWrite.All",
+        "https://analysis.windows.net/powerbi/api/Report.ReadWrite.All",
+        "https://analysis.windows.net/powerbi/api/Workspace.ReadWrite.All"
+      ],
+      account: o
+    })).accessToken, console.log("PowerBI token acquired silently: " + t.slice(0, 20));
+  } catch {
+    console.log("PowerBI token failed to be acquired silently");
+  }
+  return t;
+}
+async function Be(r, e) {
+  const t = new Headers();
+  if (t.append("Content-Type", "application/json"), t.append("accept", "*/*"), e.azureAccessToken == null || e.azureAccessToken === "")
+    try {
+      let n = r.getAllAccounts(), s = e.oid + "." + e.tid, o = null;
+      for (let c = 0; c < n.length; c++)
+        n[c].homeAccountId == s && (o = n[c]);
+      let i = await r.acquireTokenSilent({
+        scopes: ["https://management.azure.com/user_impersonation"],
+        account: o
+      });
+      e.azureAccessToken = i.accessToken, console.log("Front end token acquired silently: " + e.azureAccessToken.slice(0, 20));
+    } catch (n) {
+      try {
+        console.log("Front end token silent acquisition failure: " + n);
+        let s = r.getAllAccounts(), o = e.oid + "." + e.tid, i = null;
+        for (let c = 0; c < s.length; c++)
+          s[c].homeAccountId == o && (i = s[c]);
+        r.acquireTokenRedirect({
+          scopes: ["https://management.azure.com/user_impersonation"],
+          account: i
+        });
+      } catch (s) {
+        console.log("Front end token popup acquisition failure: " + s);
+      }
+    }
+  return t.append("Authorization", `Bearer ${e.azureAccessToken}`), t;
+}
+async function ms(r, e) {
+  if (e == null || e.spacode == "")
+    return !1;
+  try {
+    let n = { method: "GET", headers: await Be(r, e) }, s = ge.azureListRootAssignments;
+    s += "'", s += e.oid, s += "'";
+    let o = await fetch(s, n);
+    if (o.status == 200) {
+      let i = await o.json();
+      i = i;
+      debugger;
+      console.log("Successful call to Azure Resource Graph list root assignments");
+    } else
+      return console.log(await x(o)), !1;
+  } catch (t) {
+    return console.log(t), !1;
+  }
+  return !0;
+}
+async function _s(r, e) {
+  if (e == null || e.spacode == "")
+    return !1;
+  try {
+    let n = { method: "POST", headers: await Be(r, e) }, s = ge.azureElevateAccess, o = await fetch(s, n);
+    if (o.status == 200)
+      console.log("Successful call to Azure Resource Graph list root assignments");
+    else
+      return console.log(await x(o)), !1;
+  } catch (t) {
+    return console.log(t), !1;
+  }
+  return !0;
+}
+async function bn(r, e) {
+  let t = new Array();
+  if (e == null || e.spacode == "")
+    return t;
+  try {
+    let s = { method: "GET", headers: await Be(r, e) }, o = ge.azureListRootAssignments;
+    o += "'", o += e.oid, o += "'";
+    let i = await fetch(o, s);
+    if (i.status == 200) {
+      let c = await i.json();
+      c = c;
+      debugger;
+      console.log("Successful call to Azure Resource Graph list root assignments");
+    } else
+      return console.log(await x(i)), t;
+  } catch (n) {
+    return console.log(n), t;
+  }
+  return t;
+}
+function Tn(r) {
+  let e = "8d95d21c-c378-4bb0-9f52-88c30d271e7a", t = r.authority.toLowerCase();
+  return t.startsWith("https://login.microsoftonline.com/") ? e = "8d95d21c-c378-4bb0-9f52-88c30d271e7a" : t.startsWith("https://login.microsoftonline.us/") ? e = "48da942e-ea3d-49e4-a054-81649012f8f2" : t.startsWith("https://login.partner.microsoftonline.cn/") && (e = "c91d32e4-dcc5-4d77-826a-16e93ffce666"), `api://${e}/Config.Write`;
+}
+async function G(r, e) {
+  debugger;
+  console.log("DEBUGGER: mindlineDefineHeaders");
+  const t = new Headers();
+  t.append("Content-Type", "application/json"), t.append("accept", "*/*");
+  const n = Tn(e);
+  try {
+    let s = r.getAllAccounts(), o = e.oid + "." + e.tid, i = null;
+    for (let a = 0; a < s.length; a++)
+      s[a].homeAccountId == o && (i = s[a]);
+    let c = await r.acquireTokenSilent({
+      scopes: [n],
+      account: i
+    });
+    e.mindlineAccessToken = c.accessToken, console.log("Front end mindline token acquired silently: " + e.mindlineAccessToken.slice(0, 20));
+  } catch (s) {
+    try {
+      console.log("Front end mindline token silent acquisition failure, triggering redirect: " + s);
+      let o = r.getAllAccounts(), i = e.oid + "." + e.tid, c = null;
+      for (let a = 0; a < o.length; a++)
+        o[a].homeAccountId == i && (c = o[a]);
+      r.acquireTokenRedirect({
+        scopes: [n],
+        account: c
+      });
+    } catch (o) {
+      console.log("Front end mindline token redirect acquisition failure: " + o);
+    }
+  }
+  return t.append("Authorization", `Bearer ${e.mindlineAccessToken}`), t;
+}
+async function x(r) {
+  let e = "";
+  if (r.status === 401 && (e = r.statusText, e != ""))
+    return e;
+  let t = await r.json();
+  if (t.error !== void 0)
+    e = `Error: ${t.error} Message: ${t.message}`;
+  else if (t.errors !== void 0)
+    e = Object.keys(t.errors).reduce(
+      (o, i) => o + i + ": " + t.errors[i] + " ",
+      ""
+    );
+  else if (t.title !== void 0)
+    e = t.title;
+  else
+    debugger;
+  return e;
+}
+async function Cn(r, e, t, n) {
+  let s = new A();
+  if (t.oid == "" && t.mail == "" || n == "")
+    return s.result = !1, s.error = "adminDelete: invalid parameters", s.status = 500, s;
+  let o = null;
+  o = new URL(R.adminEndpoint()), o.searchParams.append("workspaceId", n), o.searchParams.append("email", t.mail);
+  let c = { method: "DELETE", headers: await G(r, e) };
+  try {
+    console.log("Attempting DELETE from /admin: " + o.href);
+    let a = await fetch(o.href, c);
+    return a.status === 200 && a.statusText === "OK" ? (console.log(`Successful DELETE from /admin: ${o.href}`), s) : (s.error = await x(a), console.log(`Failed DELETE from /admin: ${o.href}`), console.log(s.error), s.status = 500, s.result = !1, s);
+  } catch (a) {
+    s.error = a.message, s.status = 500, s.result = !1, console.log(a.message);
+  }
+  return s;
+}
+async function In(r, e, t, n) {
+  let s = new A();
+  if (t === "")
+    return s.result = !1, s.status = 500, s.error = "adminsGet: no workspace provided", s;
+  let o = R.adminsEndpoint(), i = new URL(o);
+  i.searchParams.append("workspaceId", t);
+  let a = { method: "GET", headers: await G(r, e) };
+  try {
+    if (n) debugger;
+    console.log("Attempting GET from /admins: " + i.href);
+    let l = await fetch(i.href, a);
+    if (l.status === 200 && l.statusText === "OK") {
+      let u = await l.json();
+      return u != null ? (s.array = u, console.log(`Successful GET from /admins: ${s.array.reduce((f, P) => f + P.email + " ", "")}`), s) : (s.error = "Failed GET from /admins: failed to JSON-parse response", console.log(s.error), s.status = 500, s.result = !1, s);
+    } else
+      return console.log(`Failed GET from /admins: ${i.href}`), s.error = await x(l), s.status = 500, s.result = !1, console.log(s.error), s;
+  } catch (l) {
+    s.error = l.message, s.status = 500, s.result = !1, console.log(l.message);
+  }
+  return s;
+}
+async function vn(r, e, t, n) {
+  let s = new A();
+  if (t.mail == "" || t.authority == "" || t.tid === "")
+    return s.result = !1, s.error = "adminPost: invalid argument", s.status = 500, s;
+  let o = R.adminEndpoint();
+  const i = await G(r, e);
+  let c = `
+    {"email": "${t.mail}", 
+     "tenantId": "${t.tid}", 
+     "workspaceId": "${n}"
+    }`, a = { method: "POST", headers: i, body: c };
+  try {
+    console.log("Attempting POST to /admin: " + o);
+    let l = await fetch(o, a);
+    return l.status === 200 && l.statusText === "OK" ? (console.log(`Successful POST to /admin: ${c}`), s) : (s.error = await x(l), console.log(`Failed POST to /admin: ${c}`), console.log(s.error), s.status = 500, s.result = !1, s);
+  } catch (l) {
+    s.error = l.message, s.status = 500, s.result = !1, console.log(l.message);
+  }
+  return s;
+}
+async function kn(r, e, t, n, s) {
+  let o = new A(), i = R.configConsentEndpoint(), c = new URL(i);
+  c.searchParams.append("configurationId", t);
+  const a = await G(r, e);
+  let l = `
+    {
+      "tenantId": "${n}",
+      "isReadPermissionConsented": ${s ? "true" : "false"}
+     }`, u = { method: "PUT", headers: a, body: l };
+  try {
+    console.log("Attempting PUT read consent to /configuration/consent: " + c.href);
+    let p = await fetch(c.href, u);
+    return p.status === 200 && p.statusText === "OK" ? (console.log(`Successful PUT to ${c.href}`), o) : (o.error = await x(p), console.log(`Failed PUT to ${c.href}`), console.log(o.error), o.status = 500, o.result = !1, o);
+  } catch (p) {
+    o.error = p.message, o.status = 500, o.result = !1, console.log(p.message);
+  }
+  return o;
+}
+async function An(r, e, t, n, s) {
+  let o = new A(), i = R.configConsentEndpoint(), c = new URL(i);
+  c.searchParams.append("configurationId", t);
+  const a = await G(r, e);
+  let l = `
+    {
+      "tenantId": "${n}",
+      "isWritePermissionConsented": ${s ? "true" : "false"}
+     }`, u = { method: "PUT", headers: a, body: l };
+  try {
+    console.log("Attempting PUT read consent to /configuration/consent: " + c.href);
+    let p = await fetch(c.href, u);
+    return p.status === 200 && p.statusText === "OK" ? (console.log(`Successful PUT to ${c.href}`), o) : (o.error = await x(p), console.log(`Failed PUT to ${c.href}`), console.log(o.error), o.status = 500, o.result = !1, o);
+  } catch (p) {
+    o.error = p.message, o.status = 500, o.result = !1, console.log(p.message);
+  }
+  return o;
+}
+async function En(r, e, t, n, s) {
+  let o = new A();
+  if (t.id === "" || n == "")
+    return o.result = !1, o.error = "configPost: invalid config ID", o.status = 500, o;
+  let i = null;
+  i = new URL(R.configEndpoint()), i.searchParams.append("configurationId", t.id);
+  let a = { method: "DELETE", headers: await G(r, e) };
+  try {
+    console.log("Attempting DELETE from /config: " + i.href);
+    let l = await fetch(i.href, a);
+    return l.status === 200 && l.statusText === "OK" ? (console.log("Successful DELETE from /config"), o) : (o.error = await x(l), console.log(`Failed DELETE from ${i.href}`), console.log(o.error), o.status = 500, o.result = !1, o);
+  } catch (l) {
+    o.error = l.message, o.status = 500, o.result = !1, console.log(l.message);
+  }
+  return o;
+}
+async function Pn(r, e, t, n, s) {
+  let o = new A();
+  if (t === "")
+    return o.result = !1, o.error = "configPatch: invalid config ID", o.status = 500, o;
+  let i = R.configEnabledEndpoint(), c = new URL(i);
+  c.searchParams.append("configurationId", t), c.searchParams.append("isEnabled", n.toString());
+  let l = { method: "PATCH", headers: await G(r, e) };
+  try {
+    if (s) debugger;
+    console.log("Attempting PATCH to /config: " + c.href);
+    let u = await fetch(c.href, l);
+    return u.status === 200 && u.statusText === "OK" ? (console.log(`Successful PATCH to ${c.href}: ${n.toString()}`), o) : (o.error = await x(u), console.log(`Failed PATCH to ${c.href}: ${n.toString()}`), console.log(o.error), o.status = 500, o.result = !1, o);
+  } catch (u) {
+    o.error = u.message, o.status = 500, o.result = !1, console.log(u.message);
+  }
+  return o;
+}
+async function $n(r, e, t, n, s) {
+  let o = new A();
+  if (t.id === "")
+    return o.result = !1, o.error = "configPost: invalid config ID", o.status = 500, o;
+  let i = R.configEndpoint();
+  const c = await G(r, e);
+  let a = `
+    {
+      "workspaceId": "${n}",
+      "name": "${t.name}",
+      "description": "${t.description}",
+      "isEnabled": ${t.isEnabled},
+      "tenants": [`;
+  t.tenants.map((u) => {
+    let p = u.sourceGroupId != "" ? `"${u.sourceGroupId}"` : "null", f = u.sourceGroupName != "" ? `"${u.sourceGroupName}"` : "null", P = u.targetGroupId != "" ? `"${u.targetGroupId}"` : "null", W = u.targetGroupName != "" ? `"${u.targetGroupName}"` : "null";
+    a.slice(-1) === "}" && (a += ","), a += `{
+        "tenantId": "${u.tid}",
+        "sourceGroupId": ${p},
+        "sourceGroupName": ${f},
+        "targetGroupId": ${P},
+        "targetGroupName": ${W},
+        "configurationTenantType": "${u.configurationTenantType}"
+      }`;
+  }), a += "]}";
+  let l = { method: "POST", headers: c, body: a };
+  try {
+    if (s) debugger;
+    console.log("Attempting POST to /config: " + i);
+    let u = await fetch(i, l);
+    if (u.status === 200 && u.statusText === "OK") {
+      let p = await u.json();
+      return t.id = p, console.log(
+        `Successful ConfigID: ${p} from POST to /config: ${a}`
+      ), o;
+    } else
+      return o.error = await x(u), console.log(`Failed PUT to /config: ${a}`), console.log(o.error), o.status = 500, o.result = !1, o;
+  } catch (u) {
+    return o.status = 500, o.result = !1, o.error = u.message, console.log(o.error), o;
+  }
+}
+async function Dn(r, e, t, n) {
+  let s = new A();
+  if (t.id === "")
+    return s.result = !1, s.error = "configPost: invalid config ID", s.status = 500, s;
+  let o = R.configEndpoint(), i = new URL(o);
+  i.searchParams.append("configurationId", t.id);
+  const c = await G(r, e);
+  let a = `
+    {
+      "name": "${t.name}",
+      "description": "${t.description}",
+      "tenants": [`;
+  t.tenants.map((u) => {
+    a.slice(-1) === "}" && (a += ",");
+    let f = u.sourceGroupId != "" ? `"${u.sourceGroupId}"` : "null", P = u.sourceGroupName != "" ? `"${u.sourceGroupName}"` : "null", W = u.targetGroupId != "" ? `"${u.targetGroupId}"` : "null", M = u.targetGroupName != "" ? `"${u.targetGroupName}"` : "null";
+    a += `{
+          "tenantId": "${u.tid}",
+          "sourceGroupId": ${f},
+          "sourceGroupName": ${P},
+          "targetGroupId": ${W},
+          "targetGroupName": ${M},
+          "configurationTenantType": "${u.configurationTenantType}",
+          "deltaToken": "${u.deltaToken}"
+        }`;
+  }), a += "]}";
+  let l = { method: "PUT", headers: c, body: a };
+  try {
+    if (n) debugger;
+    console.log("Attempting PUT to /config: " + i.href);
+    let u = await fetch(i.href, l);
+    return u.status === 200 && u.statusText === "OK" ? (console.log(`Successful PUT to ${i.href}: ${a}`), s) : (s.error = await x(u), console.log(`Failed PUT to ${i.href}: ${a}`), console.log(s.error), s.status = 500, s.result = !1, s);
+  } catch (u) {
+    s.error = u.message, s.status = 500, s.result = !1, console.log(u.message);
+  }
+  return s;
+}
+async function tt(r, e, t, n) {
+  let s = new A();
+  if (t === "")
+    return s.result = !1, s.status = 500, s.error = "configsGet: no workspace provided", s;
+  let o = R.configsEndpoint(), i = new URL(o);
+  i.searchParams.append("workspaceId", t);
+  let a = { method: "GET", headers: await G(r, e) };
+  try {
+    if (n) debugger;
+    console.log("Attempting GET from /configurations: " + i.href);
+    let l = await fetch(i.href, a);
+    if (l.status === 200 && l.statusText === "OK") {
+      let u = await l.json();
+      return u != null ? (s.array = u, console.log(`Successful GET from /configurations: ${s.array.reduce((f, P) => f + P.name + " ", "")}`), s) : (s.error = "Failed GET from /configurations: failed to JSON-parse response", console.log(s.error), s.status = 500, s.result = !1, s);
+    } else
+      return console.log(`Failed GET from /configurations: ${i.href}`), s.error = await x(l), s.status = 500, s.result = !1, console.log(s.error), s;
+  } catch (l) {
+    s.error = l.message, s.status = 500, s.result = !1, console.log(l.message);
+  }
+  return s;
+}
+async function Rn(r, e, t) {
+  let n = new A();
+  if (e.companyName === "" || e.companyDomain === "")
+    return n.result = !1, n.error = "initPost: invalid company name or domain", n.status = 500, n;
+  let s = R.initEndpoint();
+  const o = await G(r, e);
+  let i = `
+  {
+    "tenantCreateModel": {
+      "tenantId": "${e.tid}",
+      "name": "${e.companyName}",
+      "domain": "${e.companyDomain}",
+      "type": "aad",
+      "authority": "${e.authority}"
+    }
+  }`, c = { method: "POST", headers: o, body: i };
+  try {
+    if (t) debugger;
+    console.log("Attempting POST to /configuration/init: " + s);
+    let a = await fetch(s, c);
+    return a.status === 200 && a.statusText === "OK" ? (console.log(`Successful POST to /configuration/init: ${i}`), n) : (n.error = await x(a), n.status = 500, n.result = !1, console.log(`Failed POST to /configuration/init: ${i}`), console.log(n.error), n);
+  } catch (a) {
+    n.error = a.message, console.log(n.error);
+  }
+  return n.status = 500, n.result = !1, n;
+}
+async function xn(r, e, t, n, s) {
+  let o = new A();
+  if (t.tid === "" || n === "")
+    return o.result = !1, o.error = "tenantDelete: invalid tid, workspaceId", o.status = 500, o;
+  let i = new URL(R.tenantEndpoint());
+  i.searchParams.append("tenantId", t.tid), i.searchParams.append("workspaceId", n);
+  let a = { method: "DELETE", headers: await G(r, e) };
+  try {
+    console.log("Attempting DELETE from /tenant: " + i.href);
+    let l = await fetch(i.href, a);
+    return l.status === 200 && l.statusText === "OK" ? (console.log(`Successful DELETE from /tenant: ${i.href}`), o) : (console.log(`Failed DELETE from /tenant: ${i.href}`), o.error = await x(l), console.log(o.error), o.status = 500, o.result = !1, o);
+  } catch (l) {
+    o.error = l.message, o.status = 500, o.result = !1, console.log(o.error);
+  }
+  return o;
+}
+async function Nn(r, e, t, n) {
+  let s = new A();
+  if (t === "")
+    return s.result = !1, s.status = 500, s.error = "tenantsGet: no workspace provided", s;
+  let o = R.tenantsEndpoint(), i = new URL(o);
+  i.searchParams.append("workspaceId", t);
+  let a = { method: "GET", headers: await G(r, e) };
+  try {
+    if (n) debugger;
+    console.log(`Attempting GET from /tenants: ${i.href}`);
+    let l = await fetch(i.href, a);
+    if (l.status === 200 && l.statusText === "OK") {
+      let u = await l.json();
+      return u != null ? (s.array = u, console.log(`Successful GET from /tenants: ${s.array.reduce((f, P) => f + P.domain + " ", "")}`), s) : (s.error = "Failed GET from /tenants: failed to JSON-parse response", console.log(s.error), s.status = 500, s.result = !1, s);
+    } else
+      return console.log(`Failed GET from /tenants: ${i.href}`), s.error = await x(l), s.status = 500, s.result = !1, console.log(s.error), s;
+  } catch (l) {
+    s.error = l.message, s.status = 500, s.result = !1, console.log(l.message);
+  }
+  return s;
+}
+async function On(r, e, t, n) {
+  let s = new A();
+  if (t.tid === "" || t.name === "" || t.domain === "")
+    return s.result = !1, s.error = "tenantPost: invalid tid, name, domain", s.status = 500, s;
+  let o = R.tenantEndpoint(), i = new URL(o);
+  i.searchParams.append("workspaceId", n);
+  const c = await G(r, e);
+  let a = `
+    {"tenantId": "${t.tid}", 
+     "name": "${t.name}", 
+     "domain": "${t.domain}",
+     "type": 1,
+     "authority": "${t.authority}"
+    }`, l = { method: "POST", headers: c, body: a };
+  try {
+    console.log(`Attempting POST to ${i.href}: ${a}`);
+    let u = await fetch(i.href, l);
+    return u.status === 200 && u.statusText === "OK" ? (console.log(`Successful POST to ${i.href}: ${a}`), s) : (console.log(`Failed POST to ${i.href}: ${a}`), s.error = await x(u), console.log(s.error), s.status = 500, s.result = !1, s);
+  } catch (u) {
+    s.error = u.message, s.status = 500, s.result = !1, console.log(s.error);
+  }
+  return s;
+}
+async function Mn(r, e, t, n) {
+  let s = new A();
+  if (t == "" || n == "")
+    return s.result = !1, s.error = "workspacePut: invalid workspace ID or name", s.status = 500, s;
+  let o = R.workspaceEndpoint(), i = new URL(o);
+  i.searchParams.append("workspaceId", t), i.searchParams.append("workspaceName", n);
+  let a = { method: "PUT", headers: await G(r, e) };
+  try {
+    console.log("Attempting PUT to /workspace: " + i.href);
+    let l = await fetch(i.href, a);
+    return l.status === 200 && l.statusText === "OK" ? (console.log(`Successful PUT to ${i.href}`), s) : (s.error = await x(l), console.log(`Failed PUT to ${i.href}`), console.log(s.error), s.status = 500, s.result = !1, s);
+  } catch (l) {
+    s.error = l.message, s.status = 500, s.result = !1, console.log(l.message);
+  }
+  return s;
+}
+async function Ln(r, e, t) {
+  let n = new A();
+  if (e.mail == null || e.mail == "")
+    return n.result = !1, n.status = 500, n.error = "adminsGet: no workspace provided", n;
+  let s = R.workspacesEndpoint(), o = new URL(s), c = { method: "GET", headers: await G(r, e) };
+  try {
+    if (t) debugger;
+    console.log("Attempting GET from /workspaces endpoint: " + o.href);
+    let a = await fetch(o.href, c);
+    if (a.status === 200 && a.statusText === "OK") {
+      let l = await a.json();
+      return l != null ? (n.array = l, console.log(`Successful GET from /workspaces: ${n.array.reduce((p, f) => p + f.name + " ", "")}`), n) : (n.error = "Failed GET from /workspaces: failed to JSON-parse response", console.log(n.error), n.status = 500, n.result = !1, n);
+    } else
+      return console.log(`Failed GET from /workspaces: ${o.href}`), n.error = await x(a), n.status = 500, n.result = !1, console.log(n.error), n;
+  } catch (a) {
+    n.error = a.message, n.status = 500, n.result = !1, console.log(a.message);
+  }
+  return n;
+}
+async function Gn(r, e, t) {
+  let n = new A();
+  if (r == null || e == null)
+    return n.result = !1, n.error = "readerPost: invalid parameters", n.status = 500, n;
+  let s = R.readerStartSyncEndpoint(), o = new URL(s);
+  o.searchParams.append("configurationId", t.id);
+  let c = { method: "POST", headers: await G(r, e) };
+  try {
+    console.log("Attempting POST to /startSync: " + o.href);
+    let a = await fetch(o.href, c);
+    if (a.status === 200 && a.statusText === "OK") {
+      console.log(`Successful POST to /startSync: ${s}`);
+      let l = await a.json();
+      return l.PayloadStr != "" ? n.array = JSON.parse(l.PayloadStr) : (n.result = !1, n.error = "readerPost: blank payload returned, sync may be disabled on back end", n.status = 500), n;
+    } else
+      return n.error = await x(a), console.log(`Failed POST to /startSync: ${s}`), console.log(n.error), n.status = 500, n.result = !1, n;
+  } catch (a) {
+    n.error = a.message, n.status = 500, n.result = !1, console.log(a.message);
+  }
+  return n;
+}
+export {
+  A as APIResult,
+  Kn as ActorArray,
+  dn as ActorNode,
+  Jn as BatchArray,
+  De as Config,
+  Hn as Group,
+  zn as InitInfo,
+  he as Milestone,
+  ln as MilestoneArray,
+  Ye as ResourceArray,
+  un as ResourceNode,
+  Pe as Task,
+  qn as TaskArray,
+  me as Tenant,
+  an as TenantConfigInfo,
+  rn as TenantConfigType,
+  Ke as TenantNode,
+  nn as TenantPermissionType,
+  tn as TenantType,
+  $e as User,
+  jn as UserScope,
+  Re as Workspace,
+  Cn as adminDelete,
+  vn as adminPost,
+  In as adminsGet,
+  ge as azureConfig,
+  ms as canListRootAssignments,
+  is as configConsentForRead,
+  as as configConsentForWrite,
+  kn as configConsentReadPut,
+  An as configConsentWritePut,
+  En as configDelete,
+  ss as configEdit,
+  os as configEnable,
+  Pn as configPatch,
+  $n as configPost,
+  Dn as configPut,
+  rs as configRemove,
+  tt as configsGet,
+  cs as configsRefresh,
+  _s as elevateGlobalAdminToUserAccessAdmin,
+  gs as getPowerBIAccessToken,
+  m as graphConfig,
+  Xn as groupsGet,
+  Un as helloNpm,
+  ls as initGet,
+  Rn as initPost,
+  R as mindlineConfig,
+  fn as oauth2PermissionGrantsGet,
+  pn as oauth2PermissionGrantsSet,
+  x as processErrors,
+  Gn as readerPost,
+  Zn as requestAdminConsent,
+  gn as servicePrincipalGet,
+  Qn as signIn,
+  Yn as signInIncrementally,
+  Vn as signOut,
+  Fn as sum,
+  us as tenantAdd,
+  xn as tenantDelete,
+  On as tenantPost,
+  es as tenantRelationshipsGetByDomain,
+  mn as tenantRelationshipsGetById,
+  ds as tenantRemove,
+  Ve as tenantUnauthenticatedLookup,
+  Nn as tenantsGet,
+  hs as userAdd,
+  _n as userDelegatedScopesGet,
+  ts as userDelegatedScopesRemove,
+  fs as userRemove,
+  ns as usersGet,
+  ps as workspaceEdit,
+  Mn as workspacePut,
+  Ln as workspacesGet
+};
+//# sourceMappingURL=sync.es.js.map