@factoringplus/pl-components-pack-v3 0.4.88 → 0.4.89

package/dist/pl-components-pack-v3.es.js

@@ -36287,7 +36287,7 @@ function isUndefined(val) {
 function isBuffer(val) {
   return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
 }
-function isArrayBuffer(val) {
+function isArrayBuffer$1(val) {
   return toString.call(val) === "[object ArrayBuffer]";
 }
 function isFormData(val) {
@@ -36298,7 +36298,7 @@ function isArrayBufferView(val) {
   if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
     result = ArrayBuffer.isView(val);
   } else {
-    result = val && val.buffer && isArrayBuffer(val.buffer);
+    result = val && val.buffer && isArrayBuffer$1(val.buffer);
   }
   return result;
 }
@@ -36400,7 +36400,7 @@ function stripBOM(content) {
 }
 var utils$e = {
   isArray,
-  isArrayBuffer,
+  isArrayBuffer: isArrayBuffer$1,
   isBuffer,
   isFormData,
   isArrayBufferView,
@@ -37045,7 +37045,7 @@ var mergeConfig$2 = function mergeConfig2(config1, config2) {
 var data = {
   "version": "0.26.1"
 };
-var VERSION = data.version;
+var VERSION$1 = data.version;
 var validators$1 = {};
 ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type4, i2) {
   validators$1[type4] = function validator2(thing) {
@@ -37055,7 +37055,7 @@ var validators$1 = {};
 var deprecatedWarnings = {};
 validators$1.transitional = function transitional2(validator2, version, message2) {
   function formatMessage(opt, desc) {
-    return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message2 ? ". " + message2 : "");
+    return "[Axios v" + VERSION$1 + "] Transitional option '" + opt + "'" + desc + (message2 ? ". " + message2 : "");
   }
   return function(value, opt, opts) {
     if (validator2 === false) {
@@ -41857,158 +41857,2587 @@ const PlCheckboxPlugin = {
     app.component("PlCheckbox", _sfc_main$1);
   }
 };
-const useConfigStore = defineStore("config", {
-  state: () => ({
-    token: "",
-    baseUrl: ""
-  }),
-  actions: {
-    getToken(token) {
-      this.token = token;
-    },
-    getBaseUrl(url2) {
-      this.baseUrl = url2;
-    },
-    api(optionsRequest) {
-      return ApiJs(optionsRequest, false, `Bearer ${this.token}`, true);
-    }
+class HttpError extends Error {
+  constructor(errorMessage, statusCode) {
+    const trueProto = new.target.prototype;
+    super(`${errorMessage}: Status code '${statusCode}'`);
+    this.statusCode = statusCode;
+    this.__proto__ = trueProto;
   }
-});
-var apiChat = {
-  getChannels(api, baseUrl, category, count2 = 50) {
-    return api({
-      url: `${baseUrl}/api/channels/issues/${category}`,
+}
+class TimeoutError extends Error {
+  constructor(errorMessage = "A timeout occurred.") {
+    const trueProto = new.target.prototype;
+    super(errorMessage);
+    this.__proto__ = trueProto;
+  }
+}
+class AbortError extends Error {
+  constructor(errorMessage = "An abort occurred.") {
+    const trueProto = new.target.prototype;
+    super(errorMessage);
+    this.__proto__ = trueProto;
+  }
+}
+class UnsupportedTransportError extends Error {
+  constructor(message2, transport) {
+    const trueProto = new.target.prototype;
+    super(message2);
+    this.transport = transport;
+    this.errorType = "UnsupportedTransportError";
+    this.__proto__ = trueProto;
+  }
+}
+class DisabledTransportError extends Error {
+  constructor(message2, transport) {
+    const trueProto = new.target.prototype;
+    super(message2);
+    this.transport = transport;
+    this.errorType = "DisabledTransportError";
+    this.__proto__ = trueProto;
+  }
+}
+class FailedToStartTransportError extends Error {
+  constructor(message2, transport) {
+    const trueProto = new.target.prototype;
+    super(message2);
+    this.transport = transport;
+    this.errorType = "FailedToStartTransportError";
+    this.__proto__ = trueProto;
+  }
+}
+class FailedToNegotiateWithServerError extends Error {
+  constructor(message2) {
+    const trueProto = new.target.prototype;
+    super(message2);
+    this.errorType = "FailedToNegotiateWithServerError";
+    this.__proto__ = trueProto;
+  }
+}
+class AggregateErrors extends Error {
+  constructor(message2, innerErrors) {
+    const trueProto = new.target.prototype;
+    super(message2);
+    this.innerErrors = innerErrors;
+    this.__proto__ = trueProto;
+  }
+}
+class HttpResponse {
+  constructor(statusCode, statusText, content) {
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.content = content;
+  }
+}
+class HttpClient {
+  get(url2, options) {
+    return this.send({
+      ...options,
       method: "GET",
-      headers: {
-        "x-group-id": "FLINE"
-      },
-      params: {
-        count: count2
-      }
+      url: url2
     });
-  },
-  getUnreadChannels(api, baseUrl) {
-    return api({
-      url: `${baseUrl}/api/channels/issues/count`,
-      method: "GET",
-      headers: {
-        "x-group-id": "FLINE"
-      }
+  }
+  post(url2, options) {
+    return this.send({
+      ...options,
+      method: "POST",
+      url: url2
     });
-  },
-  getGroups(api, baseUrl) {
-    return api({
-      url: `${baseUrl}/api/groups`,
-      method: "GET",
-      headers: {
-        "x-group-id": "FLINE"
-      }
+  }
+  delete(url2, options) {
+    return this.send({
+      ...options,
+      method: "DELETE",
+      url: url2
     });
   }
-};
-const useCommonStore = defineStore("commonStore", {
-  state: () => ({
-    loadingStatus: "notLoading"
-  }),
-  getters: {
-    isLoading: (state) => state.loadingStatus === "loading"
-  },
-  actions: {
-    setLoadingStatus(status) {
-      this.loadingStatus = status;
+  getCookieString(url2) {
+    return "";
+  }
+}
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["Trace"] = 0] = "Trace";
+  LogLevel2[LogLevel2["Debug"] = 1] = "Debug";
+  LogLevel2[LogLevel2["Information"] = 2] = "Information";
+  LogLevel2[LogLevel2["Warning"] = 3] = "Warning";
+  LogLevel2[LogLevel2["Error"] = 4] = "Error";
+  LogLevel2[LogLevel2["Critical"] = 5] = "Critical";
+  LogLevel2[LogLevel2["None"] = 6] = "None";
+})(LogLevel || (LogLevel = {}));
+class NullLogger {
+  constructor() {
+  }
+  log(_logLevel, _message) {
+  }
+}
+NullLogger.instance = new NullLogger();
+const VERSION = "7.0.0";
+class Arg {
+  static isRequired(val, name) {
+    if (val === null || val === void 0) {
+      throw new Error(`The '${name}' argument is required.`);
     }
   }
-});
-const useChannelsStore = defineStore("channels", {
-  state: () => ({
-    channels: [],
-    unreadChannels: {},
-    groups: []
-  }),
-  getters: {
-    api() {
-      const configStore = useConfigStore();
-      return configStore.api;
-    },
-    baseUrl() {
-      const configStore = useConfigStore();
-      return configStore.baseUrl;
+  static isNotEmpty(val, name) {
+    if (!val || val.match(/^\s*$/)) {
+      throw new Error(`The '${name}' argument should not be empty.`);
     }
-  },
-  actions: {
-    loading() {
-      const commonStore = useCommonStore();
-      commonStore.setLoadingStatus("loading");
-    },
-    notLoading() {
-      const commonStore = useCommonStore();
-      commonStore.setLoadingStatus("notLoading");
-    },
-    async getChannels(category) {
-      try {
-        this.loading();
-        this.channels = await apiChat.getChannels(this.api, this.baseUrl, category);
-      } catch (error2) {
-        console.log(error2);
-      } finally {
-        this.notLoading();
+  }
+  static isIn(val, values, name) {
+    if (!(val in values)) {
+      throw new Error(`Unknown ${name} value: ${val}.`);
+    }
+  }
+}
+class Platform {
+  static get isBrowser() {
+    return typeof window === "object" && typeof window.document === "object";
+  }
+  static get isWebWorker() {
+    return typeof self === "object" && "importScripts" in self;
+  }
+  static get isReactNative() {
+    return typeof window === "object" && typeof window.document === "undefined";
+  }
+  static get isNode() {
+    return !this.isBrowser && !this.isWebWorker && !this.isReactNative;
+  }
+}
+function getDataDetail(data2, includeContent) {
+  let detail = "";
+  if (isArrayBuffer(data2)) {
+    detail = `Binary data of length ${data2.byteLength}`;
+    if (includeContent) {
+      detail += `. Content: '${formatArrayBuffer(data2)}'`;
+    }
+  } else if (typeof data2 === "string") {
+    detail = `String data of length ${data2.length}`;
+    if (includeContent) {
+      detail += `. Content: '${data2}'`;
+    }
+  }
+  return detail;
+}
+function formatArrayBuffer(data2) {
+  const view = new Uint8Array(data2);
+  let str2 = "";
+  view.forEach((num) => {
+    const pad = num < 16 ? "0" : "";
+    str2 += `0x${pad}${num.toString(16)} `;
+  });
+  return str2.substr(0, str2.length - 1);
+}
+function isArrayBuffer(val) {
+  return val && typeof ArrayBuffer !== "undefined" && (val instanceof ArrayBuffer || val.constructor && val.constructor.name === "ArrayBuffer");
+}
+async function sendMessage(logger, transportName, httpClient, url2, content, options) {
+  const headers = {};
+  const [name, value] = getUserAgentHeader();
+  headers[name] = value;
+  logger.log(LogLevel.Trace, `(${transportName} transport) sending data. ${getDataDetail(content, options.logMessageContent)}.`);
+  const responseType = isArrayBuffer(content) ? "arraybuffer" : "text";
+  const response2 = await httpClient.post(url2, {
+    content,
+    headers: { ...headers, ...options.headers },
+    responseType,
+    timeout: options.timeout,
+    withCredentials: options.withCredentials
+  });
+  logger.log(LogLevel.Trace, `(${transportName} transport) request complete. Response status: ${response2.statusCode}.`);
+}
+function createLogger(logger) {
+  if (logger === void 0) {
+    return new ConsoleLogger(LogLevel.Information);
+  }
+  if (logger === null) {
+    return NullLogger.instance;
+  }
+  if (logger.log !== void 0) {
+    return logger;
+  }
+  return new ConsoleLogger(logger);
+}
+class SubjectSubscription {
+  constructor(subject, observer) {
+    this._subject = subject;
+    this._observer = observer;
+  }
+  dispose() {
+    const index = this._subject.observers.indexOf(this._observer);
+    if (index > -1) {
+      this._subject.observers.splice(index, 1);
+    }
+    if (this._subject.observers.length === 0 && this._subject.cancelCallback) {
+      this._subject.cancelCallback().catch((_2) => {
+      });
+    }
+  }
+}
+class ConsoleLogger {
+  constructor(minimumLogLevel) {
+    this._minLevel = minimumLogLevel;
+    this.out = console;
+  }
+  log(logLevel, message2) {
+    if (logLevel >= this._minLevel) {
+      const msg = `[${new Date().toISOString()}] ${LogLevel[logLevel]}: ${message2}`;
+      switch (logLevel) {
+        case LogLevel.Critical:
+        case LogLevel.Error:
+          this.out.error(msg);
+          break;
+        case LogLevel.Warning:
+          this.out.warn(msg);
+          break;
+        case LogLevel.Information:
+          this.out.info(msg);
+          break;
+        default:
+          this.out.log(msg);
+          break;
       }
-    },
-    async getUnreadChannels() {
-      try {
-        this.unreadChannels = await apiChat.getUnreadChannels(this.api, this.baseUrl);
-      } catch (error2) {
-        console.log(error2);
+    }
+  }
+}
+function getUserAgentHeader() {
+  let userAgentHeaderName = "X-SignalR-User-Agent";
+  if (Platform.isNode) {
+    userAgentHeaderName = "User-Agent";
+  }
+  return [userAgentHeaderName, constructUserAgent(VERSION, getOsName(), getRuntime(), getRuntimeVersion())];
+}
+function constructUserAgent(version, os, runtime, runtimeVersion) {
+  let userAgent = "Microsoft SignalR/";
+  const majorAndMinor = version.split(".");
+  userAgent += `${majorAndMinor[0]}.${majorAndMinor[1]}`;
+  userAgent += ` (${version}; `;
+  if (os && os !== "") {
+    userAgent += `${os}; `;
+  } else {
+    userAgent += "Unknown OS; ";
+  }
+  userAgent += `${runtime}`;
+  if (runtimeVersion) {
+    userAgent += `; ${runtimeVersion}`;
+  } else {
+    userAgent += "; Unknown Runtime Version";
+  }
+  userAgent += ")";
+  return userAgent;
+}
+function getOsName() {
+  if (Platform.isNode) {
+    switch (process.platform) {
+      case "win32":
+        return "Windows NT";
+      case "darwin":
+        return "macOS";
+      case "linux":
+        return "Linux";
+      default:
+        return process.platform;
+    }
+  } else {
+    return "";
+  }
+}
+function getRuntimeVersion() {
+  if (Platform.isNode) {
+    return process.versions.node;
+  }
+  return void 0;
+}
+function getRuntime() {
+  if (Platform.isNode) {
+    return "NodeJS";
+  } else {
+    return "Browser";
+  }
+}
+function getErrorString(e2) {
+  if (e2.stack) {
+    return e2.stack;
+  } else if (e2.message) {
+    return e2.message;
+  }
+  return `${e2}`;
+}
+function getGlobalThis() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw new Error("could not find global");
+}
+class FetchHttpClient extends HttpClient {
+  constructor(logger) {
+    super();
+    this._logger = logger;
+    if (typeof fetch === "undefined") {
+      const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+      this._jar = new (requireFunc("tough-cookie")).CookieJar();
+      this._fetchType = requireFunc("node-fetch");
+      this._fetchType = requireFunc("fetch-cookie")(this._fetchType, this._jar);
+    } else {
+      this._fetchType = fetch.bind(getGlobalThis());
+    }
+    if (typeof AbortController === "undefined") {
+      const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+      this._abortControllerType = requireFunc("abort-controller");
+    } else {
+      this._abortControllerType = AbortController;
+    }
+  }
+  async send(request2) {
+    if (request2.abortSignal && request2.abortSignal.aborted) {
+      throw new AbortError();
+    }
+    if (!request2.method) {
+      throw new Error("No method defined.");
+    }
+    if (!request2.url) {
+      throw new Error("No url defined.");
+    }
+    const abortController = new this._abortControllerType();
+    let error2;
+    if (request2.abortSignal) {
+      request2.abortSignal.onabort = () => {
+        abortController.abort();
+        error2 = new AbortError();
+      };
+    }
+    let timeoutId = null;
+    if (request2.timeout) {
+      const msTimeout = request2.timeout;
+      timeoutId = setTimeout(() => {
+        abortController.abort();
+        this._logger.log(LogLevel.Warning, `Timeout from HTTP request.`);
+        error2 = new TimeoutError();
+      }, msTimeout);
+    }
+    if (request2.content === "") {
+      request2.content = void 0;
+    }
+    if (request2.content) {
+      request2.headers = request2.headers || {};
+      if (isArrayBuffer(request2.content)) {
+        request2.headers["Content-Type"] = "application/octet-stream";
+      } else {
+        request2.headers["Content-Type"] = "text/plain;charset=UTF-8";
       }
-    },
-    async getGroups() {
-      try {
-        this.groups = await apiChat.getGroups(this.api, this.baseUrl);
-      } catch (error2) {
-        console.log(error2);
+    }
+    let response2;
+    try {
+      response2 = await this._fetchType(request2.url, {
+        body: request2.content,
+        cache: "no-cache",
+        credentials: request2.withCredentials === true ? "include" : "same-origin",
+        headers: {
+          "X-Requested-With": "XMLHttpRequest",
+          ...request2.headers
+        },
+        method: request2.method,
+        mode: "cors",
+        redirect: "follow",
+        signal: abortController.signal
+      });
+    } catch (e2) {
+      if (error2) {
+        throw error2;
+      }
+      this._logger.log(LogLevel.Warning, `Error from HTTP request. ${e2}.`);
+      throw e2;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (request2.abortSignal) {
+        request2.abortSignal.onabort = null;
       }
     }
+    if (!response2.ok) {
+      const errorMessage = await deserializeContent(response2, "text");
+      throw new HttpError(errorMessage || response2.statusText, response2.status);
+    }
+    const content = deserializeContent(response2, request2.responseType);
+    const payload = await content;
+    return new HttpResponse(response2.status, response2.statusText, payload);
   }
-});
-const _sfc_main = {
-  __name: "pl-chat-manager",
-  props: {
-    token: {
-      type: String,
-      default: ""
-    },
-    baseUrl: {
-      type: String,
-      default: ""
+  getCookieString(url2) {
+    let cookies2 = "";
+    if (Platform.isNode && this._jar) {
+      this._jar.getCookies(url2, (e2, c2) => cookies2 = c2.join("; "));
     }
-  },
-  setup(__props) {
-    const props = __props;
-    const { token, baseUrl } = toRefs(props);
-    const configStore = useConfigStore();
-    const channelsStore = useChannelsStore();
-    const commonStore = useCommonStore();
-    const getChannelsInfo = async () => {
-      configStore.getToken(token);
-      configStore.getBaseUrl(baseUrl);
-      await Promise.all([
-        channelsStore.getChannels("new"),
-        channelsStore.getUnreadChannels(),
-        channelsStore.getGroups()
-      ]);
-    };
-    getChannelsInfo();
-    return (_ctx, _cache) => {
-      const _directive_loading = vLoading;
-      return openBlock(), createElementBlock(Fragment, null, [
-        withDirectives((openBlock(), createElementBlock("div", null, [
-          createTextVNode(toDisplayString(unref(channelsStore).channels), 1)
-        ])), [
-          [_directive_loading, unref(commonStore).isLoading]
-        ]),
-        createElementVNode("div", null, toDisplayString(unref(channelsStore).unreadChannels), 1),
-        createElementVNode("div", null, toDisplayString(unref(channelsStore).groups), 1)
-      ], 64);
+    return cookies2;
+  }
+}
+function deserializeContent(response2, responseType) {
+  let content;
+  switch (responseType) {
+    case "arraybuffer":
+      content = response2.arrayBuffer();
+      break;
+    case "text":
+      content = response2.text();
+      break;
+    case "blob":
+    case "document":
+    case "json":
+      throw new Error(`${responseType} is not supported.`);
+    default:
+      content = response2.text();
+      break;
+  }
+  return content;
+}
+class XhrHttpClient extends HttpClient {
+  constructor(logger) {
+    super();
+    this._logger = logger;
+  }
+  send(request2) {
+    if (request2.abortSignal && request2.abortSignal.aborted) {
+      return Promise.reject(new AbortError());
+    }
+    if (!request2.method) {
+      return Promise.reject(new Error("No method defined."));
+    }
+    if (!request2.url) {
+      return Promise.reject(new Error("No url defined."));
+    }
+    return new Promise((resolve, reject) => {
+      const xhr2 = new XMLHttpRequest();
+      xhr2.open(request2.method, request2.url, true);
+      xhr2.withCredentials = request2.withCredentials === void 0 ? true : request2.withCredentials;
+      xhr2.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+      if (request2.content === "") {
+        request2.content = void 0;
+      }
+      if (request2.content) {
+        if (isArrayBuffer(request2.content)) {
+          xhr2.setRequestHeader("Content-Type", "application/octet-stream");
+        } else {
+          xhr2.setRequestHeader("Content-Type", "text/plain;charset=UTF-8");
+        }
+      }
+      const headers = request2.headers;
+      if (headers) {
+        Object.keys(headers).forEach((header) => {
+          xhr2.setRequestHeader(header, headers[header]);
+        });
+      }
+      if (request2.responseType) {
+        xhr2.responseType = request2.responseType;
+      }
+      if (request2.abortSignal) {
+        request2.abortSignal.onabort = () => {
+          xhr2.abort();
+          reject(new AbortError());
+        };
+      }
+      if (request2.timeout) {
+        xhr2.timeout = request2.timeout;
+      }
+      xhr2.onload = () => {
+        if (request2.abortSignal) {
+          request2.abortSignal.onabort = null;
+        }
+        if (xhr2.status >= 200 && xhr2.status < 300) {
+          resolve(new HttpResponse(xhr2.status, xhr2.statusText, xhr2.response || xhr2.responseText));
+        } else {
+          reject(new HttpError(xhr2.response || xhr2.responseText || xhr2.statusText, xhr2.status));
+        }
+      };
+      xhr2.onerror = () => {
+        this._logger.log(LogLevel.Warning, `Error from HTTP request. ${xhr2.status}: ${xhr2.statusText}.`);
+        reject(new HttpError(xhr2.statusText, xhr2.status));
+      };
+      xhr2.ontimeout = () => {
+        this._logger.log(LogLevel.Warning, `Timeout from HTTP request.`);
+        reject(new TimeoutError());
+      };
+      xhr2.send(request2.content);
+    });
+  }
+}
+class DefaultHttpClient extends HttpClient {
+  constructor(logger) {
+    super();
+    if (typeof fetch !== "undefined" || Platform.isNode) {
+      this._httpClient = new FetchHttpClient(logger);
+    } else if (typeof XMLHttpRequest !== "undefined") {
+      this._httpClient = new XhrHttpClient(logger);
+    } else {
+      throw new Error("No usable HttpClient found.");
+    }
+  }
+  send(request2) {
+    if (request2.abortSignal && request2.abortSignal.aborted) {
+      return Promise.reject(new AbortError());
+    }
+    if (!request2.method) {
+      return Promise.reject(new Error("No method defined."));
+    }
+    if (!request2.url) {
+      return Promise.reject(new Error("No url defined."));
+    }
+    return this._httpClient.send(request2);
+  }
+  getCookieString(url2) {
+    return this._httpClient.getCookieString(url2);
+  }
+}
+class TextMessageFormat {
+  static write(output) {
+    return `${output}${TextMessageFormat.RecordSeparator}`;
+  }
+  static parse(input2) {
+    if (input2[input2.length - 1] !== TextMessageFormat.RecordSeparator) {
+      throw new Error("Message is incomplete.");
+    }
+    const messages2 = input2.split(TextMessageFormat.RecordSeparator);
+    messages2.pop();
+    return messages2;
+  }
+}
+TextMessageFormat.RecordSeparatorCode = 30;
+TextMessageFormat.RecordSeparator = String.fromCharCode(TextMessageFormat.RecordSeparatorCode);
+class HandshakeProtocol {
+  writeHandshakeRequest(handshakeRequest) {
+    return TextMessageFormat.write(JSON.stringify(handshakeRequest));
+  }
+  parseHandshakeResponse(data2) {
+    let messageData;
+    let remainingData;
+    if (isArrayBuffer(data2)) {
+      const binaryData = new Uint8Array(data2);
+      const separatorIndex = binaryData.indexOf(TextMessageFormat.RecordSeparatorCode);
+      if (separatorIndex === -1) {
+        throw new Error("Message is incomplete.");
+      }
+      const responseLength = separatorIndex + 1;
+      messageData = String.fromCharCode.apply(null, Array.prototype.slice.call(binaryData.slice(0, responseLength)));
+      remainingData = binaryData.byteLength > responseLength ? binaryData.slice(responseLength).buffer : null;
+    } else {
+      const textData = data2;
+      const separatorIndex = textData.indexOf(TextMessageFormat.RecordSeparator);
+      if (separatorIndex === -1) {
+        throw new Error("Message is incomplete.");
+      }
+      const responseLength = separatorIndex + 1;
+      messageData = textData.substring(0, responseLength);
+      remainingData = textData.length > responseLength ? textData.substring(responseLength) : null;
+    }
+    const messages2 = TextMessageFormat.parse(messageData);
+    const response2 = JSON.parse(messages2[0]);
+    if (response2.type) {
+      throw new Error("Expected a handshake response from the server.");
+    }
+    const responseMessage = response2;
+    return [remainingData, responseMessage];
+  }
+}
+var MessageType;
+(function(MessageType2) {
+  MessageType2[MessageType2["Invocation"] = 1] = "Invocation";
+  MessageType2[MessageType2["StreamItem"] = 2] = "StreamItem";
+  MessageType2[MessageType2["Completion"] = 3] = "Completion";
+  MessageType2[MessageType2["StreamInvocation"] = 4] = "StreamInvocation";
+  MessageType2[MessageType2["CancelInvocation"] = 5] = "CancelInvocation";
+  MessageType2[MessageType2["Ping"] = 6] = "Ping";
+  MessageType2[MessageType2["Close"] = 7] = "Close";
+})(MessageType || (MessageType = {}));
+class Subject {
+  constructor() {
+    this.observers = [];
+  }
+  next(item) {
+    for (const observer of this.observers) {
+      observer.next(item);
+    }
+  }
+  error(err) {
+    for (const observer of this.observers) {
+      if (observer.error) {
+        observer.error(err);
+      }
+    }
+  }
+  complete() {
+    for (const observer of this.observers) {
+      if (observer.complete) {
+        observer.complete();
+      }
+    }
+  }
+  subscribe(observer) {
+    this.observers.push(observer);
+    return new SubjectSubscription(this, observer);
+  }
+}
+const DEFAULT_TIMEOUT_IN_MS = 30 * 1e3;
+const DEFAULT_PING_INTERVAL_IN_MS = 15 * 1e3;
+var HubConnectionState;
+(function(HubConnectionState2) {
+  HubConnectionState2["Disconnected"] = "Disconnected";
+  HubConnectionState2["Connecting"] = "Connecting";
+  HubConnectionState2["Connected"] = "Connected";
+  HubConnectionState2["Disconnecting"] = "Disconnecting";
+  HubConnectionState2["Reconnecting"] = "Reconnecting";
+})(HubConnectionState || (HubConnectionState = {}));
+class HubConnection {
+  constructor(connection, logger, protocol, reconnectPolicy) {
+    this._nextKeepAlive = 0;
+    this._freezeEventListener = () => {
+      this._logger.log(LogLevel.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://docs.microsoft.com/aspnet/core/signalr/javascript-client#bsleep");
+    };
+    Arg.isRequired(connection, "connection");
+    Arg.isRequired(logger, "logger");
+    Arg.isRequired(protocol, "protocol");
+    this.serverTimeoutInMilliseconds = DEFAULT_TIMEOUT_IN_MS;
+    this.keepAliveIntervalInMilliseconds = DEFAULT_PING_INTERVAL_IN_MS;
+    this._logger = logger;
+    this._protocol = protocol;
+    this.connection = connection;
+    this._reconnectPolicy = reconnectPolicy;
+    this._handshakeProtocol = new HandshakeProtocol();
+    this.connection.onreceive = (data2) => this._processIncomingData(data2);
+    this.connection.onclose = (error2) => this._connectionClosed(error2);
+    this._callbacks = {};
+    this._methods = {};
+    this._closedCallbacks = [];
+    this._reconnectingCallbacks = [];
+    this._reconnectedCallbacks = [];
+    this._invocationId = 0;
+    this._receivedHandshakeResponse = false;
+    this._connectionState = HubConnectionState.Disconnected;
+    this._connectionStarted = false;
+    this._cachedPingMessage = this._protocol.writeMessage({ type: MessageType.Ping });
+  }
+  static create(connection, logger, protocol, reconnectPolicy) {
+    return new HubConnection(connection, logger, protocol, reconnectPolicy);
+  }
+  get state() {
+    return this._connectionState;
+  }
+  get connectionId() {
+    return this.connection ? this.connection.connectionId || null : null;
+  }
+  get baseUrl() {
+    return this.connection.baseUrl || "";
+  }
+  set baseUrl(url2) {
+    if (this._connectionState !== HubConnectionState.Disconnected && this._connectionState !== HubConnectionState.Reconnecting) {
+      throw new Error("The HubConnection must be in the Disconnected or Reconnecting state to change the url.");
+    }
+    if (!url2) {
+      throw new Error("The HubConnection url must be a valid url.");
+    }
+    this.connection.baseUrl = url2;
+  }
+  start() {
+    this._startPromise = this._startWithStateTransitions();
+    return this._startPromise;
+  }
+  async _startWithStateTransitions() {
+    if (this._connectionState !== HubConnectionState.Disconnected) {
+      return Promise.reject(new Error("Cannot start a HubConnection that is not in the 'Disconnected' state."));
+    }
+    this._connectionState = HubConnectionState.Connecting;
+    this._logger.log(LogLevel.Debug, "Starting HubConnection.");
+    try {
+      await this._startInternal();
+      if (Platform.isBrowser) {
+        window.document.addEventListener("freeze", this._freezeEventListener);
+      }
+      this._connectionState = HubConnectionState.Connected;
+      this._connectionStarted = true;
+      this._logger.log(LogLevel.Debug, "HubConnection connected successfully.");
+    } catch (e2) {
+      this._connectionState = HubConnectionState.Disconnected;
+      this._logger.log(LogLevel.Debug, `HubConnection failed to start successfully because of error '${e2}'.`);
+      return Promise.reject(e2);
+    }
+  }
+  async _startInternal() {
+    this._stopDuringStartError = void 0;
+    this._receivedHandshakeResponse = false;
+    const handshakePromise = new Promise((resolve, reject) => {
+      this._handshakeResolver = resolve;
+      this._handshakeRejecter = reject;
+    });
+    await this.connection.start(this._protocol.transferFormat);
+    try {
+      const handshakeRequest = {
+        protocol: this._protocol.name,
+        version: this._protocol.version
+      };
+      this._logger.log(LogLevel.Debug, "Sending handshake request.");
+      await this._sendMessage(this._handshakeProtocol.writeHandshakeRequest(handshakeRequest));
+      this._logger.log(LogLevel.Information, `Using HubProtocol '${this._protocol.name}'.`);
+      this._cleanupTimeout();
+      this._resetTimeoutPeriod();
+      this._resetKeepAliveInterval();
+      await handshakePromise;
+      if (this._stopDuringStartError) {
+        throw this._stopDuringStartError;
+      }
+      if (!this.connection.features.inherentKeepAlive) {
+        await this._sendMessage(this._cachedPingMessage);
+      }
+    } catch (e2) {
+      this._logger.log(LogLevel.Debug, `Hub handshake failed with error '${e2}' during start(). Stopping HubConnection.`);
+      this._cleanupTimeout();
+      this._cleanupPingTimer();
+      await this.connection.stop(e2);
+      throw e2;
+    }
+  }
+  async stop() {
+    const startPromise = this._startPromise;
+    this._stopPromise = this._stopInternal();
+    await this._stopPromise;
+    try {
+      await startPromise;
+    } catch (e2) {
+    }
+  }
+  _stopInternal(error2) {
+    if (this._connectionState === HubConnectionState.Disconnected) {
+      this._logger.log(LogLevel.Debug, `Call to HubConnection.stop(${error2}) ignored because it is already in the disconnected state.`);
+      return Promise.resolve();
+    }
+    if (this._connectionState === HubConnectionState.Disconnecting) {
+      this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error2}) ignored because the connection is already in the disconnecting state.`);
+      return this._stopPromise;
+    }
+    this._connectionState = HubConnectionState.Disconnecting;
+    this._logger.log(LogLevel.Debug, "Stopping HubConnection.");
+    if (this._reconnectDelayHandle) {
+      this._logger.log(LogLevel.Debug, "Connection stopped during reconnect delay. Done reconnecting.");
+      clearTimeout(this._reconnectDelayHandle);
+      this._reconnectDelayHandle = void 0;
+      this._completeClose();
+      return Promise.resolve();
+    }
+    this._cleanupTimeout();
+    this._cleanupPingTimer();
+    this._stopDuringStartError = error2 || new AbortError("The connection was stopped before the hub handshake could complete.");
+    return this.connection.stop(error2);
+  }
+  stream(methodName, ...args) {
+    const [streams, streamIds] = this._replaceStreamingParams(args);
+    const invocationDescriptor = this._createStreamInvocation(methodName, args, streamIds);
+    let promiseQueue;
+    const subject = new Subject();
+    subject.cancelCallback = () => {
+      const cancelInvocation = this._createCancelInvocation(invocationDescriptor.invocationId);
+      delete this._callbacks[invocationDescriptor.invocationId];
+      return promiseQueue.then(() => {
+        return this._sendWithProtocol(cancelInvocation);
+      });
+    };
+    this._callbacks[invocationDescriptor.invocationId] = (invocationEvent, error2) => {
+      if (error2) {
+        subject.error(error2);
+        return;
+      } else if (invocationEvent) {
+        if (invocationEvent.type === MessageType.Completion) {
+          if (invocationEvent.error) {
+            subject.error(new Error(invocationEvent.error));
+          } else {
+            subject.complete();
+          }
+        } else {
+          subject.next(invocationEvent.item);
+        }
+      }
+    };
+    promiseQueue = this._sendWithProtocol(invocationDescriptor).catch((e2) => {
+      subject.error(e2);
+      delete this._callbacks[invocationDescriptor.invocationId];
+    });
+    this._launchStreams(streams, promiseQueue);
+    return subject;
+  }
+  _sendMessage(message2) {
+    this._resetKeepAliveInterval();
+    return this.connection.send(message2);
+  }
+  _sendWithProtocol(message2) {
+    return this._sendMessage(this._protocol.writeMessage(message2));
+  }
+  send(methodName, ...args) {
+    const [streams, streamIds] = this._replaceStreamingParams(args);
+    const sendPromise = this._sendWithProtocol(this._createInvocation(methodName, args, true, streamIds));
+    this._launchStreams(streams, sendPromise);
+    return sendPromise;
+  }
+  invoke(methodName, ...args) {
+    const [streams, streamIds] = this._replaceStreamingParams(args);
+    const invocationDescriptor = this._createInvocation(methodName, args, false, streamIds);
+    const p2 = new Promise((resolve, reject) => {
+      this._callbacks[invocationDescriptor.invocationId] = (invocationEvent, error2) => {
+        if (error2) {
+          reject(error2);
+          return;
+        } else if (invocationEvent) {
+          if (invocationEvent.type === MessageType.Completion) {
+            if (invocationEvent.error) {
+              reject(new Error(invocationEvent.error));
+            } else {
+              resolve(invocationEvent.result);
+            }
+          } else {
+            reject(new Error(`Unexpected message type: ${invocationEvent.type}`));
+          }
+        }
+      };
+      const promiseQueue = this._sendWithProtocol(invocationDescriptor).catch((e2) => {
+        reject(e2);
+        delete this._callbacks[invocationDescriptor.invocationId];
+      });
+      this._launchStreams(streams, promiseQueue);
+    });
+    return p2;
+  }
+  on(methodName, newMethod) {
+    if (!methodName || !newMethod) {
+      return;
+    }
+    methodName = methodName.toLowerCase();
+    if (!this._methods[methodName]) {
+      this._methods[methodName] = [];
+    }
+    if (this._methods[methodName].indexOf(newMethod) !== -1) {
+      return;
+    }
+    this._methods[methodName].push(newMethod);
+  }
+  off(methodName, method4) {
+    if (!methodName) {
+      return;
+    }
+    methodName = methodName.toLowerCase();
+    const handlers = this._methods[methodName];
+    if (!handlers) {
+      return;
+    }
+    if (method4) {
+      const removeIdx = handlers.indexOf(method4);
+      if (removeIdx !== -1) {
+        handlers.splice(removeIdx, 1);
+        if (handlers.length === 0) {
+          delete this._methods[methodName];
+        }
+      }
+    } else {
+      delete this._methods[methodName];
+    }
+  }
+  onclose(callback) {
+    if (callback) {
+      this._closedCallbacks.push(callback);
+    }
+  }
+  onreconnecting(callback) {
+    if (callback) {
+      this._reconnectingCallbacks.push(callback);
+    }
+  }
+  onreconnected(callback) {
+    if (callback) {
+      this._reconnectedCallbacks.push(callback);
+    }
+  }
+  _processIncomingData(data2) {
+    this._cleanupTimeout();
+    if (!this._receivedHandshakeResponse) {
+      data2 = this._processHandshakeResponse(data2);
+      this._receivedHandshakeResponse = true;
+    }
+    if (data2) {
+      const messages2 = this._protocol.parseMessages(data2, this._logger);
+      for (const message2 of messages2) {
+        switch (message2.type) {
+          case MessageType.Invocation:
+            this._invokeClientMethod(message2);
+            break;
+          case MessageType.StreamItem:
+          case MessageType.Completion: {
+            const callback = this._callbacks[message2.invocationId];
+            if (callback) {
+              if (message2.type === MessageType.Completion) {
+                delete this._callbacks[message2.invocationId];
+              }
+              try {
+                callback(message2);
+              } catch (e2) {
+                this._logger.log(LogLevel.Error, `Stream callback threw error: ${getErrorString(e2)}`);
+              }
+            }
+            break;
+          }
+          case MessageType.Ping:
+            break;
+          case MessageType.Close: {
+            this._logger.log(LogLevel.Information, "Close message received from server.");
+            const error2 = message2.error ? new Error("Server returned an error on close: " + message2.error) : void 0;
+            if (message2.allowReconnect === true) {
+              this.connection.stop(error2);
+            } else {
+              this._stopPromise = this._stopInternal(error2);
+            }
+            break;
+          }
+          default:
+            this._logger.log(LogLevel.Warning, `Invalid message type: ${message2.type}.`);
+            break;
+        }
+      }
+    }
+    this._resetTimeoutPeriod();
+  }
+  _processHandshakeResponse(data2) {
+    let responseMessage;
+    let remainingData;
+    try {
+      [remainingData, responseMessage] = this._handshakeProtocol.parseHandshakeResponse(data2);
+    } catch (e2) {
+      const message2 = "Error parsing handshake response: " + e2;
+      this._logger.log(LogLevel.Error, message2);
+      const error2 = new Error(message2);
+      this._handshakeRejecter(error2);
+      throw error2;
+    }
+    if (responseMessage.error) {
+      const message2 = "Server returned handshake error: " + responseMessage.error;
+      this._logger.log(LogLevel.Error, message2);
+      const error2 = new Error(message2);
+      this._handshakeRejecter(error2);
+      throw error2;
+    } else {
+      this._logger.log(LogLevel.Debug, "Server handshake complete.");
+    }
+    this._handshakeResolver();
+    return remainingData;
+  }
+  _resetKeepAliveInterval() {
+    if (this.connection.features.inherentKeepAlive) {
+      return;
+    }
+    this._nextKeepAlive = new Date().getTime() + this.keepAliveIntervalInMilliseconds;
+    this._cleanupPingTimer();
+  }
+  _resetTimeoutPeriod() {
+    if (!this.connection.features || !this.connection.features.inherentKeepAlive) {
+      this._timeoutHandle = setTimeout(() => this.serverTimeout(), this.serverTimeoutInMilliseconds);
+      if (this._pingServerHandle === void 0) {
+        let nextPing = this._nextKeepAlive - new Date().getTime();
+        if (nextPing < 0) {
+          nextPing = 0;
+        }
+        this._pingServerHandle = setTimeout(async () => {
+          if (this._connectionState === HubConnectionState.Connected) {
+            try {
+              await this._sendMessage(this._cachedPingMessage);
+            } catch {
+              this._cleanupPingTimer();
+            }
+          }
+        }, nextPing);
+      }
+    }
+  }
+  serverTimeout() {
+    this.connection.stop(new Error("Server timeout elapsed without receiving a message from the server."));
+  }
+  async _invokeClientMethod(invocationMessage) {
+    const methodName = invocationMessage.target.toLowerCase();
+    const methods = this._methods[methodName];
+    if (!methods) {
+      this._logger.log(LogLevel.Warning, `No client method with the name '${methodName}' found.`);
+      if (invocationMessage.invocationId) {
+        this._logger.log(LogLevel.Warning, `No result given for '${methodName}' method and invocation ID '${invocationMessage.invocationId}'.`);
+        await this._sendWithProtocol(this._createCompletionMessage(invocationMessage.invocationId, "Client didn't provide a result.", null));
+      }
+      return;
+    }
+    const methodsCopy = methods.slice();
+    const expectsResponse = invocationMessage.invocationId ? true : false;
+    let res;
+    let exception;
+    let completionMessage;
+    for (const m2 of methodsCopy) {
+      try {
+        const prevRes = res;
+        res = await m2.apply(this, invocationMessage.arguments);
+        if (expectsResponse && res && prevRes) {
+          this._logger.log(LogLevel.Error, `Multiple results provided for '${methodName}'. Sending error to server.`);
+          completionMessage = this._createCompletionMessage(invocationMessage.invocationId, `Client provided multiple results.`, null);
+        }
+        exception = void 0;
+      } catch (e2) {
+        exception = e2;
+        this._logger.log(LogLevel.Error, `A callback for the method '${methodName}' threw error '${e2}'.`);
+      }
+    }
+    if (completionMessage) {
+      await this._sendWithProtocol(completionMessage);
+    } else if (expectsResponse) {
+      if (exception) {
+        completionMessage = this._createCompletionMessage(invocationMessage.invocationId, `${exception}`, null);
+      } else if (res !== void 0) {
+        completionMessage = this._createCompletionMessage(invocationMessage.invocationId, null, res);
+      } else {
+        this._logger.log(LogLevel.Warning, `No result given for '${methodName}' method and invocation ID '${invocationMessage.invocationId}'.`);
+        completionMessage = this._createCompletionMessage(invocationMessage.invocationId, "Client didn't provide a result.", null);
+      }
+      await this._sendWithProtocol(completionMessage);
+    } else {
+      if (res) {
+        this._logger.log(LogLevel.Error, `Result given for '${methodName}' method but server is not expecting a result.`);
+      }
+    }
+  }
+  _connectionClosed(error2) {
+    this._logger.log(LogLevel.Debug, `HubConnection.connectionClosed(${error2}) called while in state ${this._connectionState}.`);
+    this._stopDuringStartError = this._stopDuringStartError || error2 || new AbortError("The underlying connection was closed before the hub handshake could complete.");
+    if (this._handshakeResolver) {
+      this._handshakeResolver();
+    }
+    this._cancelCallbacksWithError(error2 || new Error("Invocation canceled due to the underlying connection being closed."));
+    this._cleanupTimeout();
+    this._cleanupPingTimer();
+    if (this._connectionState === HubConnectionState.Disconnecting) {
+      this._completeClose(error2);
+    } else if (this._connectionState === HubConnectionState.Connected && this._reconnectPolicy) {
+      this._reconnect(error2);
+    } else if (this._connectionState === HubConnectionState.Connected) {
+      this._completeClose(error2);
+    }
+  }
+  _completeClose(error2) {
+    if (this._connectionStarted) {
+      this._connectionState = HubConnectionState.Disconnected;
+      this._connectionStarted = false;
+      if (Platform.isBrowser) {
+        window.document.removeEventListener("freeze", this._freezeEventListener);
+      }
+      try {
+        this._closedCallbacks.forEach((c2) => c2.apply(this, [error2]));
+      } catch (e2) {
+        this._logger.log(LogLevel.Error, `An onclose callback called with error '${error2}' threw error '${e2}'.`);
+      }
+    }
+  }
+  async _reconnect(error2) {
+    const reconnectStartTime = Date.now();
+    let previousReconnectAttempts = 0;
+    let retryError = error2 !== void 0 ? error2 : new Error("Attempting to reconnect due to a unknown error.");
+    let nextRetryDelay = this._getNextRetryDelay(previousReconnectAttempts++, 0, retryError);
+    if (nextRetryDelay === null) {
+      this._logger.log(LogLevel.Debug, "Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt.");
+      this._completeClose(error2);
+      return;
+    }
+    this._connectionState = HubConnectionState.Reconnecting;
+    if (error2) {
+      this._logger.log(LogLevel.Information, `Connection reconnecting because of error '${error2}'.`);
+    } else {
+      this._logger.log(LogLevel.Information, "Connection reconnecting.");
+    }
+    if (this._reconnectingCallbacks.length !== 0) {
+      try {
+        this._reconnectingCallbacks.forEach((c2) => c2.apply(this, [error2]));
+      } catch (e2) {
+        this._logger.log(LogLevel.Error, `An onreconnecting callback called with error '${error2}' threw error '${e2}'.`);
+      }
+      if (this._connectionState !== HubConnectionState.Reconnecting) {
+        this._logger.log(LogLevel.Debug, "Connection left the reconnecting state in onreconnecting callback. Done reconnecting.");
+        return;
+      }
+    }
+    while (nextRetryDelay !== null) {
+      this._logger.log(LogLevel.Information, `Reconnect attempt number ${previousReconnectAttempts} will start in ${nextRetryDelay} ms.`);
+      await new Promise((resolve) => {
+        this._reconnectDelayHandle = setTimeout(resolve, nextRetryDelay);
+      });
+      this._reconnectDelayHandle = void 0;
+      if (this._connectionState !== HubConnectionState.Reconnecting) {
+        this._logger.log(LogLevel.Debug, "Connection left the reconnecting state during reconnect delay. Done reconnecting.");
+        return;
+      }
+      try {
+        await this._startInternal();
+        this._connectionState = HubConnectionState.Connected;
+        this._logger.log(LogLevel.Information, "HubConnection reconnected successfully.");
+        if (this._reconnectedCallbacks.length !== 0) {
+          try {
+            this._reconnectedCallbacks.forEach((c2) => c2.apply(this, [this.connection.connectionId]));
+          } catch (e2) {
+            this._logger.log(LogLevel.Error, `An onreconnected callback called with connectionId '${this.connection.connectionId}; threw error '${e2}'.`);
+          }
+        }
+        return;
+      } catch (e2) {
+        this._logger.log(LogLevel.Information, `Reconnect attempt failed because of error '${e2}'.`);
+        if (this._connectionState !== HubConnectionState.Reconnecting) {
+          this._logger.log(LogLevel.Debug, `Connection moved to the '${this._connectionState}' from the reconnecting state during reconnect attempt. Done reconnecting.`);
+          if (this._connectionState === HubConnectionState.Disconnecting) {
+            this._completeClose();
+          }
+          return;
+        }
+        retryError = e2 instanceof Error ? e2 : new Error(e2.toString());
+        nextRetryDelay = this._getNextRetryDelay(previousReconnectAttempts++, Date.now() - reconnectStartTime, retryError);
+      }
+    }
+    this._logger.log(LogLevel.Information, `Reconnect retries have been exhausted after ${Date.now() - reconnectStartTime} ms and ${previousReconnectAttempts} failed attempts. Connection disconnecting.`);
+    this._completeClose();
+  }
+  _getNextRetryDelay(previousRetryCount, elapsedMilliseconds, retryReason) {
+    try {
+      return this._reconnectPolicy.nextRetryDelayInMilliseconds({
+        elapsedMilliseconds,
+        previousRetryCount,
+        retryReason
+      });
+    } catch (e2) {
+      this._logger.log(LogLevel.Error, `IRetryPolicy.nextRetryDelayInMilliseconds(${previousRetryCount}, ${elapsedMilliseconds}) threw error '${e2}'.`);
+      return null;
+    }
+  }
+  _cancelCallbacksWithError(error2) {
+    const callbacks = this._callbacks;
+    this._callbacks = {};
+    Object.keys(callbacks).forEach((key) => {
+      const callback = callbacks[key];
+      try {
+        callback(null, error2);
+      } catch (e2) {
+        this._logger.log(LogLevel.Error, `Stream 'error' callback called with '${error2}' threw error: ${getErrorString(e2)}`);
+      }
+    });
+  }
+  _cleanupPingTimer() {
+    if (this._pingServerHandle) {
+      clearTimeout(this._pingServerHandle);
+      this._pingServerHandle = void 0;
+    }
+  }
+  _cleanupTimeout() {
+    if (this._timeoutHandle) {
+      clearTimeout(this._timeoutHandle);
+    }
+  }
+  _createInvocation(methodName, args, nonblocking, streamIds) {
+    if (nonblocking) {
+      if (streamIds.length !== 0) {
+        return {
+          arguments: args,
+          streamIds,
+          target: methodName,
+          type: MessageType.Invocation
+        };
+      } else {
+        return {
+          arguments: args,
+          target: methodName,
+          type: MessageType.Invocation
+        };
+      }
+    } else {
+      const invocationId = this._invocationId;
+      this._invocationId++;
+      if (streamIds.length !== 0) {
+        return {
+          arguments: args,
+          invocationId: invocationId.toString(),
+          streamIds,
+          target: methodName,
+          type: MessageType.Invocation
+        };
+      } else {
+        return {
+          arguments: args,
+          invocationId: invocationId.toString(),
+          target: methodName,
+          type: MessageType.Invocation
+        };
+      }
+    }
+  }
+  _launchStreams(streams, promiseQueue) {
+    if (streams.length === 0) {
+      return;
+    }
+    if (!promiseQueue) {
+      promiseQueue = Promise.resolve();
+    }
+    for (const streamId in streams) {
+      streams[streamId].subscribe({
+        complete: () => {
+          promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createCompletionMessage(streamId)));
+        },
+        error: (err) => {
+          let message2;
+          if (err instanceof Error) {
+            message2 = err.message;
+          } else if (err && err.toString) {
+            message2 = err.toString();
+          } else {
+            message2 = "Unknown error";
+          }
+          promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createCompletionMessage(streamId, message2)));
+        },
+        next: (item) => {
+          promiseQueue = promiseQueue.then(() => this._sendWithProtocol(this._createStreamItemMessage(streamId, item)));
+        }
+      });
+    }
+  }
+  _replaceStreamingParams(args) {
+    const streams = [];
+    const streamIds = [];
+    for (let i2 = 0; i2 < args.length; i2++) {
+      const argument = args[i2];
+      if (this._isObservable(argument)) {
+        const streamId = this._invocationId;
+        this._invocationId++;
+        streams[streamId] = argument;
+        streamIds.push(streamId.toString());
+        args.splice(i2, 1);
+      }
+    }
+    return [streams, streamIds];
+  }
+  _isObservable(arg) {
+    return arg && arg.subscribe && typeof arg.subscribe === "function";
+  }
+  _createStreamInvocation(methodName, args, streamIds) {
+    const invocationId = this._invocationId;
+    this._invocationId++;
+    if (streamIds.length !== 0) {
+      return {
+        arguments: args,
+        invocationId: invocationId.toString(),
+        streamIds,
+        target: methodName,
+        type: MessageType.StreamInvocation
+      };
+    } else {
+      return {
+        arguments: args,
+        invocationId: invocationId.toString(),
+        target: methodName,
+        type: MessageType.StreamInvocation
+      };
+    }
+  }
+  _createCancelInvocation(id) {
+    return {
+      invocationId: id,
+      type: MessageType.CancelInvocation
+    };
+  }
+  _createStreamItemMessage(id, item) {
+    return {
+      invocationId: id,
+      item,
+      type: MessageType.StreamItem
+    };
+  }
+  _createCompletionMessage(id, error2, result) {
+    if (error2) {
+      return {
+        error: error2,
+        invocationId: id,
+        type: MessageType.Completion
+      };
+    }
+    return {
+      invocationId: id,
+      result,
+      type: MessageType.Completion
+    };
+  }
+}
+const DEFAULT_RETRY_DELAYS_IN_MILLISECONDS = [0, 2e3, 1e4, 3e4, null];
+class DefaultReconnectPolicy {
+  constructor(retryDelays) {
+    this._retryDelays = retryDelays !== void 0 ? [...retryDelays, null] : DEFAULT_RETRY_DELAYS_IN_MILLISECONDS;
+  }
+  nextRetryDelayInMilliseconds(retryContext) {
+    return this._retryDelays[retryContext.previousRetryCount];
+  }
+}
+class HeaderNames {
+}
+HeaderNames.Authorization = "Authorization";
+HeaderNames.Cookie = "Cookie";
+class AccessTokenHttpClient extends HttpClient {
+  constructor(innerClient, accessTokenFactory) {
+    super();
+    this._innerClient = innerClient;
+    this._accessTokenFactory = accessTokenFactory;
+  }
+  async send(request2) {
+    let allowRetry = true;
+    if (this._accessTokenFactory && (!this._accessToken || request2.url && request2.url.indexOf("/negotiate?") > 0)) {
+      allowRetry = false;
+      this._accessToken = await this._accessTokenFactory();
+    }
+    this._setAuthorizationHeader(request2);
+    const response2 = await this._innerClient.send(request2);
+    if (allowRetry && response2.statusCode === 401 && this._accessTokenFactory) {
+      this._accessToken = await this._accessTokenFactory();
+      this._setAuthorizationHeader(request2);
+      return await this._innerClient.send(request2);
+    }
+    return response2;
+  }
+  _setAuthorizationHeader(request2) {
+    if (!request2.headers) {
+      request2.headers = {};
+    }
+    if (this._accessToken) {
+      request2.headers[HeaderNames.Authorization] = `Bearer ${this._accessToken}`;
+    } else if (this._accessTokenFactory) {
+      if (request2.headers[HeaderNames.Authorization]) {
+        delete request2.headers[HeaderNames.Authorization];
+      }
+    }
+  }
+  getCookieString(url2) {
+    return this._innerClient.getCookieString(url2);
+  }
+}
+var HttpTransportType;
+(function(HttpTransportType2) {
+  HttpTransportType2[HttpTransportType2["None"] = 0] = "None";
+  HttpTransportType2[HttpTransportType2["WebSockets"] = 1] = "WebSockets";
+  HttpTransportType2[HttpTransportType2["ServerSentEvents"] = 2] = "ServerSentEvents";
+  HttpTransportType2[HttpTransportType2["LongPolling"] = 4] = "LongPolling";
+})(HttpTransportType || (HttpTransportType = {}));
+var TransferFormat;
+(function(TransferFormat2) {
+  TransferFormat2[TransferFormat2["Text"] = 1] = "Text";
+  TransferFormat2[TransferFormat2["Binary"] = 2] = "Binary";
+})(TransferFormat || (TransferFormat = {}));
+class AbortController$1 {
+  constructor() {
+    this._isAborted = false;
+    this.onabort = null;
+  }
+  abort() {
+    if (!this._isAborted) {
+      this._isAborted = true;
+      if (this.onabort) {
+        this.onabort();
+      }
+    }
+  }
+  get signal() {
+    return this;
+  }
+  get aborted() {
+    return this._isAborted;
+  }
+}
+class LongPollingTransport {
+  constructor(httpClient, logger, options) {
+    this._httpClient = httpClient;
+    this._logger = logger;
+    this._pollAbort = new AbortController$1();
+    this._options = options;
+    this._running = false;
+    this.onreceive = null;
+    this.onclose = null;
+  }
+  get pollAborted() {
+    return this._pollAbort.aborted;
+  }
+  async connect(url2, transferFormat) {
+    Arg.isRequired(url2, "url");
+    Arg.isRequired(transferFormat, "transferFormat");
+    Arg.isIn(transferFormat, TransferFormat, "transferFormat");
+    this._url = url2;
+    this._logger.log(LogLevel.Trace, "(LongPolling transport) Connecting.");
+    if (transferFormat === TransferFormat.Binary && (typeof XMLHttpRequest !== "undefined" && typeof new XMLHttpRequest().responseType !== "string")) {
+      throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported.");
+    }
+    const [name, value] = getUserAgentHeader();
+    const headers = { [name]: value, ...this._options.headers };
+    const pollOptions = {
+      abortSignal: this._pollAbort.signal,
+      headers,
+      timeout: 1e5,
+      withCredentials: this._options.withCredentials
+    };
+    if (transferFormat === TransferFormat.Binary) {
+      pollOptions.responseType = "arraybuffer";
+    }
+    const pollUrl = `${url2}&_=${Date.now()}`;
+    this._logger.log(LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);
+    const response2 = await this._httpClient.get(pollUrl, pollOptions);
+    if (response2.statusCode !== 200) {
+      this._logger.log(LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response2.statusCode}.`);
+      this._closeError = new HttpError(response2.statusText || "", response2.statusCode);
+      this._running = false;
+    } else {
+      this._running = true;
+    }
+    this._receiving = this._poll(this._url, pollOptions);
+  }
+  async _poll(url2, pollOptions) {
+    try {
+      while (this._running) {
+        try {
+          const pollUrl = `${url2}&_=${Date.now()}`;
+          this._logger.log(LogLevel.Trace, `(LongPolling transport) polling: ${pollUrl}.`);
+          const response2 = await this._httpClient.get(pollUrl, pollOptions);
+          if (response2.statusCode === 204) {
+            this._logger.log(LogLevel.Information, "(LongPolling transport) Poll terminated by server.");
+            this._running = false;
+          } else if (response2.statusCode !== 200) {
+            this._logger.log(LogLevel.Error, `(LongPolling transport) Unexpected response code: ${response2.statusCode}.`);
+            this._closeError = new HttpError(response2.statusText || "", response2.statusCode);
+            this._running = false;
+          } else {
+            if (response2.content) {
+              this._logger.log(LogLevel.Trace, `(LongPolling transport) data received. ${getDataDetail(response2.content, this._options.logMessageContent)}.`);
+              if (this.onreceive) {
+                this.onreceive(response2.content);
+              }
+            } else {
+              this._logger.log(LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+            }
+          }
+        } catch (e2) {
+          if (!this._running) {
+            this._logger.log(LogLevel.Trace, `(LongPolling transport) Poll errored after shutdown: ${e2.message}`);
+          } else {
+            if (e2 instanceof TimeoutError) {
+              this._logger.log(LogLevel.Trace, "(LongPolling transport) Poll timed out, reissuing.");
+            } else {
+              this._closeError = e2;
+              this._running = false;
+            }
+          }
+        }
+      }
+    } finally {
+      this._logger.log(LogLevel.Trace, "(LongPolling transport) Polling complete.");
+      if (!this.pollAborted) {
+        this._raiseOnClose();
+      }
+    }
+  }
+  async send(data2) {
+    if (!this._running) {
+      return Promise.reject(new Error("Cannot send until the transport is connected"));
+    }
+    return sendMessage(this._logger, "LongPolling", this._httpClient, this._url, data2, this._options);
+  }
+  async stop() {
+    this._logger.log(LogLevel.Trace, "(LongPolling transport) Stopping polling.");
+    this._running = false;
+    this._pollAbort.abort();
+    try {
+      await this._receiving;
+      this._logger.log(LogLevel.Trace, `(LongPolling transport) sending DELETE request to ${this._url}.`);
+      const headers = {};
+      const [name, value] = getUserAgentHeader();
+      headers[name] = value;
+      const deleteOptions = {
+        headers: { ...headers, ...this._options.headers },
+        timeout: this._options.timeout,
+        withCredentials: this._options.withCredentials
+      };
+      await this._httpClient.delete(this._url, deleteOptions);
+      this._logger.log(LogLevel.Trace, "(LongPolling transport) DELETE request sent.");
+    } finally {
+      this._logger.log(LogLevel.Trace, "(LongPolling transport) Stop finished.");
+      this._raiseOnClose();
+    }
+  }
+  _raiseOnClose() {
+    if (this.onclose) {
+      let logMessage = "(LongPolling transport) Firing onclose event.";
+      if (this._closeError) {
+        logMessage += " Error: " + this._closeError;
+      }
+      this._logger.log(LogLevel.Trace, logMessage);
+      this.onclose(this._closeError);
+    }
+  }
+}
+class ServerSentEventsTransport {
+  constructor(httpClient, accessToken, logger, options) {
+    this._httpClient = httpClient;
+    this._accessToken = accessToken;
+    this._logger = logger;
+    this._options = options;
+    this.onreceive = null;
+    this.onclose = null;
+  }
+  async connect(url2, transferFormat) {
+    Arg.isRequired(url2, "url");
+    Arg.isRequired(transferFormat, "transferFormat");
+    Arg.isIn(transferFormat, TransferFormat, "transferFormat");
+    this._logger.log(LogLevel.Trace, "(SSE transport) Connecting.");
+    this._url = url2;
+    if (this._accessToken) {
+      url2 += (url2.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(this._accessToken)}`;
+    }
+    return new Promise((resolve, reject) => {
+      let opened = false;
+      if (transferFormat !== TransferFormat.Text) {
+        reject(new Error("The Server-Sent Events transport only supports the 'Text' transfer format"));
+        return;
+      }
+      let eventSource;
+      if (Platform.isBrowser || Platform.isWebWorker) {
+        eventSource = new this._options.EventSource(url2, { withCredentials: this._options.withCredentials });
+      } else {
+        const cookies2 = this._httpClient.getCookieString(url2);
+        const headers = {};
+        headers.Cookie = cookies2;
+        const [name, value] = getUserAgentHeader();
+        headers[name] = value;
+        eventSource = new this._options.EventSource(url2, { withCredentials: this._options.withCredentials, headers: { ...headers, ...this._options.headers } });
+      }
+      try {
+        eventSource.onmessage = (e2) => {
+          if (this.onreceive) {
+            try {
+              this._logger.log(LogLevel.Trace, `(SSE transport) data received. ${getDataDetail(e2.data, this._options.logMessageContent)}.`);
+              this.onreceive(e2.data);
+            } catch (error2) {
+              this._close(error2);
+              return;
+            }
+          }
+        };
+        eventSource.onerror = (e2) => {
+          if (opened) {
+            this._close();
+          } else {
+            reject(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."));
+          }
+        };
+        eventSource.onopen = () => {
+          this._logger.log(LogLevel.Information, `SSE connected to ${this._url}`);
+          this._eventSource = eventSource;
+          opened = true;
+          resolve();
+        };
+      } catch (e2) {
+        reject(e2);
+        return;
+      }
+    });
+  }
+  async send(data2) {
+    if (!this._eventSource) {
+      return Promise.reject(new Error("Cannot send until the transport is connected"));
+    }
+    return sendMessage(this._logger, "SSE", this._httpClient, this._url, data2, this._options);
+  }
+  stop() {
+    this._close();
+    return Promise.resolve();
+  }
+  _close(e2) {
+    if (this._eventSource) {
+      this._eventSource.close();
+      this._eventSource = void 0;
+      if (this.onclose) {
+        this.onclose(e2);
+      }
+    }
+  }
+}
+class WebSocketTransport {
+  constructor(httpClient, accessTokenFactory, logger, logMessageContent, webSocketConstructor, headers) {
+    this._logger = logger;
+    this._accessTokenFactory = accessTokenFactory;
+    this._logMessageContent = logMessageContent;
+    this._webSocketConstructor = webSocketConstructor;
+    this._httpClient = httpClient;
+    this.onreceive = null;
+    this.onclose = null;
+    this._headers = headers;
+  }
+  async connect(url2, transferFormat) {
+    Arg.isRequired(url2, "url");
+    Arg.isRequired(transferFormat, "transferFormat");
+    Arg.isIn(transferFormat, TransferFormat, "transferFormat");
+    this._logger.log(LogLevel.Trace, "(WebSockets transport) Connecting.");
+    let token;
+    if (this._accessTokenFactory) {
+      token = await this._accessTokenFactory();
+    }
+    return new Promise((resolve, reject) => {
+      url2 = url2.replace(/^http/, "ws");
+      let webSocket;
+      const cookies2 = this._httpClient.getCookieString(url2);
+      let opened = false;
+      if (Platform.isNode || Platform.isReactNative) {
+        const headers = {};
+        const [name, value] = getUserAgentHeader();
+        headers[name] = value;
+        if (token) {
+          headers[HeaderNames.Authorization] = `Bearer ${token}`;
+        }
+        if (cookies2) {
+          headers[HeaderNames.Cookie] = cookies2;
+        }
+        webSocket = new this._webSocketConstructor(url2, void 0, {
+          headers: { ...headers, ...this._headers }
+        });
+      } else {
+        if (token) {
+          url2 += (url2.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(token)}`;
+        }
+      }
+      if (!webSocket) {
+        webSocket = new this._webSocketConstructor(url2);
+      }
+      if (transferFormat === TransferFormat.Binary) {
+        webSocket.binaryType = "arraybuffer";
+      }
+      webSocket.onopen = (_event2) => {
+        this._logger.log(LogLevel.Information, `WebSocket connected to ${url2}.`);
+        this._webSocket = webSocket;
+        opened = true;
+        resolve();
+      };
+      webSocket.onerror = (event) => {
+        let error2 = null;
+        if (typeof ErrorEvent !== "undefined" && event instanceof ErrorEvent) {
+          error2 = event.error;
+        } else {
+          error2 = "There was an error with the transport";
+        }
+        this._logger.log(LogLevel.Information, `(WebSockets transport) ${error2}.`);
+      };
+      webSocket.onmessage = (message2) => {
+        this._logger.log(LogLevel.Trace, `(WebSockets transport) data received. ${getDataDetail(message2.data, this._logMessageContent)}.`);
+        if (this.onreceive) {
+          try {
+            this.onreceive(message2.data);
+          } catch (error2) {
+            this._close(error2);
+            return;
+          }
+        }
+      };
+      webSocket.onclose = (event) => {
+        if (opened) {
+          this._close(event);
+        } else {
+          let error2 = null;
+          if (typeof ErrorEvent !== "undefined" && event instanceof ErrorEvent) {
+            error2 = event.error;
+          } else {
+            error2 = "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.";
+          }
+          reject(new Error(error2));
+        }
+      };
+    });
+  }
+  send(data2) {
+    if (this._webSocket && this._webSocket.readyState === this._webSocketConstructor.OPEN) {
+      this._logger.log(LogLevel.Trace, `(WebSockets transport) sending data. ${getDataDetail(data2, this._logMessageContent)}.`);
+      this._webSocket.send(data2);
+      return Promise.resolve();
+    }
+    return Promise.reject("WebSocket is not in the OPEN state");
+  }
+  stop() {
+    if (this._webSocket) {
+      this._close(void 0);
+    }
+    return Promise.resolve();
+  }
+  _close(event) {
+    if (this._webSocket) {
+      this._webSocket.onclose = () => {
+      };
+      this._webSocket.onmessage = () => {
+      };
+      this._webSocket.onerror = () => {
+      };
+      this._webSocket.close();
+      this._webSocket = void 0;
+    }
+    this._logger.log(LogLevel.Trace, "(WebSockets transport) socket closed.");
+    if (this.onclose) {
+      if (this._isCloseEvent(event) && (event.wasClean === false || event.code !== 1e3)) {
+        this.onclose(new Error(`WebSocket closed with status code: ${event.code} (${event.reason || "no reason given"}).`));
+      } else if (event instanceof Error) {
+        this.onclose(event);
+      } else {
+        this.onclose();
+      }
+    }
+  }
+  _isCloseEvent(event) {
+    return event && typeof event.wasClean === "boolean" && typeof event.code === "number";
+  }
+}
+const MAX_REDIRECTS = 100;
+class HttpConnection {
+  constructor(url2, options = {}) {
+    this._stopPromiseResolver = () => {
+    };
+    this.features = {};
+    this._negotiateVersion = 1;
+    Arg.isRequired(url2, "url");
+    this._logger = createLogger(options.logger);
+    this.baseUrl = this._resolveUrl(url2);
+    options = options || {};
+    options.logMessageContent = options.logMessageContent === void 0 ? false : options.logMessageContent;
+    if (typeof options.withCredentials === "boolean" || options.withCredentials === void 0) {
+      options.withCredentials = options.withCredentials === void 0 ? true : options.withCredentials;
+    } else {
+      throw new Error("withCredentials option was not a 'boolean' or 'undefined' value");
+    }
+    options.timeout = options.timeout === void 0 ? 100 * 1e3 : options.timeout;
+    let webSocketModule = null;
+    let eventSourceModule = null;
+    if (Platform.isNode && typeof require !== "undefined") {
+      const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+      webSocketModule = requireFunc("ws");
+      eventSourceModule = requireFunc("eventsource");
+    }
+    if (!Platform.isNode && typeof WebSocket !== "undefined" && !options.WebSocket) {
+      options.WebSocket = WebSocket;
+    } else if (Platform.isNode && !options.WebSocket) {
+      if (webSocketModule) {
+        options.WebSocket = webSocketModule;
+      }
+    }
+    if (!Platform.isNode && typeof EventSource !== "undefined" && !options.EventSource) {
+      options.EventSource = EventSource;
+    } else if (Platform.isNode && !options.EventSource) {
+      if (typeof eventSourceModule !== "undefined") {
+        options.EventSource = eventSourceModule;
+      }
+    }
+    this._httpClient = new AccessTokenHttpClient(options.httpClient || new DefaultHttpClient(this._logger), options.accessTokenFactory);
+    this._connectionState = "Disconnected";
+    this._connectionStarted = false;
+    this._options = options;
+    this.onreceive = null;
+    this.onclose = null;
+  }
+  async start(transferFormat) {
+    transferFormat = transferFormat || TransferFormat.Binary;
+    Arg.isIn(transferFormat, TransferFormat, "transferFormat");
+    this._logger.log(LogLevel.Debug, `Starting connection with transfer format '${TransferFormat[transferFormat]}'.`);
+    if (this._connectionState !== "Disconnected") {
+      return Promise.reject(new Error("Cannot start an HttpConnection that is not in the 'Disconnected' state."));
+    }
+    this._connectionState = "Connecting";
+    this._startInternalPromise = this._startInternal(transferFormat);
+    await this._startInternalPromise;
+    if (this._connectionState === "Disconnecting") {
+      const message2 = "Failed to start the HttpConnection before stop() was called.";
+      this._logger.log(LogLevel.Error, message2);
+      await this._stopPromise;
+      return Promise.reject(new AbortError(message2));
+    } else if (this._connectionState !== "Connected") {
+      const message2 = "HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!";
+      this._logger.log(LogLevel.Error, message2);
+      return Promise.reject(new AbortError(message2));
+    }
+    this._connectionStarted = true;
+  }
+  send(data2) {
+    if (this._connectionState !== "Connected") {
+      return Promise.reject(new Error("Cannot send data if the connection is not in the 'Connected' State."));
+    }
+    if (!this._sendQueue) {
+      this._sendQueue = new TransportSendQueue(this.transport);
+    }
+    return this._sendQueue.send(data2);
+  }
+  async stop(error2) {
+    if (this._connectionState === "Disconnected") {
+      this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error2}) ignored because the connection is already in the disconnected state.`);
+      return Promise.resolve();
+    }
+    if (this._connectionState === "Disconnecting") {
+      this._logger.log(LogLevel.Debug, `Call to HttpConnection.stop(${error2}) ignored because the connection is already in the disconnecting state.`);
+      return this._stopPromise;
+    }
+    this._connectionState = "Disconnecting";
+    this._stopPromise = new Promise((resolve) => {
+      this._stopPromiseResolver = resolve;
+    });
+    await this._stopInternal(error2);
+    await this._stopPromise;
+  }
+  async _stopInternal(error2) {
+    this._stopError = error2;
+    try {
+      await this._startInternalPromise;
+    } catch (e2) {
+    }
+    if (this.transport) {
+      try {
+        await this.transport.stop();
+      } catch (e2) {
+        this._logger.log(LogLevel.Error, `HttpConnection.transport.stop() threw error '${e2}'.`);
+        this._stopConnection();
+      }
+      this.transport = void 0;
+    } else {
+      this._logger.log(LogLevel.Debug, "HttpConnection.transport is undefined in HttpConnection.stop() because start() failed.");
+    }
+  }
+  async _startInternal(transferFormat) {
+    let url2 = this.baseUrl;
+    this._accessTokenFactory = this._options.accessTokenFactory;
+    this._httpClient._accessTokenFactory = this._accessTokenFactory;
+    try {
+      if (this._options.skipNegotiation) {
+        if (this._options.transport === HttpTransportType.WebSockets) {
+          this.transport = this._constructTransport(HttpTransportType.WebSockets);
+          await this._startTransport(url2, transferFormat);
+        } else {
+          throw new Error("Negotiation can only be skipped when using the WebSocket transport directly.");
+        }
+      } else {
+        let negotiateResponse = null;
+        let redirects = 0;
+        do {
+          negotiateResponse = await this._getNegotiationResponse(url2);
+          if (this._connectionState === "Disconnecting" || this._connectionState === "Disconnected") {
+            throw new AbortError("The connection was stopped during negotiation.");
+          }
+          if (negotiateResponse.error) {
+            throw new Error(negotiateResponse.error);
+          }
+          if (negotiateResponse.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 (negotiateResponse.url) {
+            url2 = negotiateResponse.url;
+          }
+          if (negotiateResponse.accessToken) {
+            const accessToken = negotiateResponse.accessToken;
+            this._accessTokenFactory = () => accessToken;
+            this._httpClient._accessToken = accessToken;
+            this._httpClient._accessTokenFactory = void 0;
+          }
+          redirects++;
+        } while (negotiateResponse.url && redirects < MAX_REDIRECTS);
+        if (redirects === MAX_REDIRECTS && negotiateResponse.url) {
+          throw new Error("Negotiate redirection limit exceeded.");
+        }
+        await this._createTransport(url2, this._options.transport, negotiateResponse, transferFormat);
+      }
+      if (this.transport instanceof LongPollingTransport) {
+        this.features.inherentKeepAlive = true;
+      }
+      if (this._connectionState === "Connecting") {
+        this._logger.log(LogLevel.Debug, "The HttpConnection connected successfully.");
+        this._connectionState = "Connected";
+      }
+    } catch (e2) {
+      this._logger.log(LogLevel.Error, "Failed to start the connection: " + e2);
+      this._connectionState = "Disconnected";
+      this.transport = void 0;
+      this._stopPromiseResolver();
+      return Promise.reject(e2);
+    }
+  }
+  async _getNegotiationResponse(url2) {
+    const headers = {};
+    const [name, value] = getUserAgentHeader();
+    headers[name] = value;
+    const negotiateUrl = this._resolveNegotiateUrl(url2);
+    this._logger.log(LogLevel.Debug, `Sending negotiation request: ${negotiateUrl}.`);
+    try {
+      const response2 = await this._httpClient.post(negotiateUrl, {
+        content: "",
+        headers: { ...headers, ...this._options.headers },
+        timeout: this._options.timeout,
+        withCredentials: this._options.withCredentials
+      });
+      if (response2.statusCode !== 200) {
+        return Promise.reject(new Error(`Unexpected status code returned from negotiate '${response2.statusCode}'`));
+      }
+      const negotiateResponse = JSON.parse(response2.content);
+      if (!negotiateResponse.negotiateVersion || negotiateResponse.negotiateVersion < 1) {
+        negotiateResponse.connectionToken = negotiateResponse.connectionId;
+      }
+      return negotiateResponse;
+    } catch (e2) {
+      let errorMessage = "Failed to complete negotiation with the server: " + e2;
+      if (e2 instanceof HttpError) {
+        if (e2.statusCode === 404) {
+          errorMessage = errorMessage + " Either this is not a SignalR endpoint or there is a proxy blocking the connection.";
+        }
+      }
+      this._logger.log(LogLevel.Error, errorMessage);
+      return Promise.reject(new FailedToNegotiateWithServerError(errorMessage));
+    }
+  }
+  _createConnectUrl(url2, connectionToken) {
+    if (!connectionToken) {
+      return url2;
+    }
+    return url2 + (url2.indexOf("?") === -1 ? "?" : "&") + `id=${connectionToken}`;
+  }
+  async _createTransport(url2, requestedTransport, negotiateResponse, requestedTransferFormat) {
+    let connectUrl = this._createConnectUrl(url2, negotiateResponse.connectionToken);
+    if (this._isITransport(requestedTransport)) {
+      this._logger.log(LogLevel.Debug, "Connection was provided an instance of ITransport, using that directly.");
+      this.transport = requestedTransport;
+      await this._startTransport(connectUrl, requestedTransferFormat);
+      this.connectionId = negotiateResponse.connectionId;
+      return;
+    }
+    const transportExceptions = [];
+    const transports = negotiateResponse.availableTransports || [];
+    let negotiate = negotiateResponse;
+    for (const endpoint of transports) {
+      const transportOrError = this._resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat);
+      if (transportOrError instanceof Error) {
+        transportExceptions.push(`${endpoint.transport} failed:`);
+        transportExceptions.push(transportOrError);
+      } else if (this._isITransport(transportOrError)) {
+        this.transport = transportOrError;
+        if (!negotiate) {
+          try {
+            negotiate = await this._getNegotiationResponse(url2);
+          } catch (ex2) {
+            return Promise.reject(ex2);
+          }
+          connectUrl = this._createConnectUrl(url2, negotiate.connectionToken);
+        }
+        try {
+          await this._startTransport(connectUrl, requestedTransferFormat);
+          this.connectionId = negotiate.connectionId;
+          return;
+        } catch (ex2) {
+          this._logger.log(LogLevel.Error, `Failed to start the transport '${endpoint.transport}': ${ex2}`);
+          negotiate = void 0;
+          transportExceptions.push(new FailedToStartTransportError(`${endpoint.transport} failed: ${ex2}`, HttpTransportType[endpoint.transport]));
+          if (this._connectionState !== "Connecting") {
+            const message2 = "Failed to select transport before stop() was called.";
+            this._logger.log(LogLevel.Debug, message2);
+            return Promise.reject(new AbortError(message2));
+          }
+        }
+      }
+    }
+    if (transportExceptions.length > 0) {
+      return Promise.reject(new AggregateErrors(`Unable to connect to the server with any of the available transports. ${transportExceptions.join(" ")}`, transportExceptions));
+    }
+    return Promise.reject(new Error("None of the transports supported by the client are supported by the server."));
+  }
+  _constructTransport(transport) {
+    switch (transport) {
+      case HttpTransportType.WebSockets:
+        if (!this._options.WebSocket) {
+          throw new Error("'WebSocket' is not supported in your environment.");
+        }
+        return new WebSocketTransport(this._httpClient, this._accessTokenFactory, this._logger, this._options.logMessageContent, this._options.WebSocket, this._options.headers || {});
+      case HttpTransportType.ServerSentEvents:
+        if (!this._options.EventSource) {
+          throw new Error("'EventSource' is not supported in your environment.");
+        }
+        return new ServerSentEventsTransport(this._httpClient, this._httpClient._accessToken, this._logger, this._options);
+      case HttpTransportType.LongPolling:
+        return new LongPollingTransport(this._httpClient, this._logger, this._options);
+      default:
+        throw new Error(`Unknown transport: ${transport}.`);
+    }
+  }
+  _startTransport(url2, transferFormat) {
+    this.transport.onreceive = this.onreceive;
+    this.transport.onclose = (e2) => this._stopConnection(e2);
+    return this.transport.connect(url2, transferFormat);
+  }
+  _resolveTransportOrError(endpoint, requestedTransport, requestedTransferFormat) {
+    const transport = HttpTransportType[endpoint.transport];
+    if (transport === null || transport === void 0) {
+      this._logger.log(LogLevel.Debug, `Skipping transport '${endpoint.transport}' because it is not supported by this client.`);
+      return new Error(`Skipping transport '${endpoint.transport}' because it is not supported by this client.`);
+    } else {
+      if (transportMatches(requestedTransport, transport)) {
+        const transferFormats = endpoint.transferFormats.map((s2) => TransferFormat[s2]);
+        if (transferFormats.indexOf(requestedTransferFormat) >= 0) {
+          if (transport === HttpTransportType.WebSockets && !this._options.WebSocket || transport === HttpTransportType.ServerSentEvents && !this._options.EventSource) {
+            this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it is not supported in your environment.'`);
+            return new UnsupportedTransportError(`'${HttpTransportType[transport]}' is not supported in your environment.`, transport);
+          } else {
+            this._logger.log(LogLevel.Debug, `Selecting transport '${HttpTransportType[transport]}'.`);
+            try {
+              return this._constructTransport(transport);
+            } catch (ex2) {
+              return ex2;
+            }
+          }
+        } else {
+          this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it does not support the requested transfer format '${TransferFormat[requestedTransferFormat]}'.`);
+          return new Error(`'${HttpTransportType[transport]}' does not support ${TransferFormat[requestedTransferFormat]}.`);
+        }
+      } else {
+        this._logger.log(LogLevel.Debug, `Skipping transport '${HttpTransportType[transport]}' because it was disabled by the client.`);
+        return new DisabledTransportError(`'${HttpTransportType[transport]}' is disabled by the client.`, transport);
+      }
+    }
+  }
+  _isITransport(transport) {
+    return transport && typeof transport === "object" && "connect" in transport;
+  }
+  _stopConnection(error2) {
+    this._logger.log(LogLevel.Debug, `HttpConnection.stopConnection(${error2}) called while in state ${this._connectionState}.`);
+    this.transport = void 0;
+    error2 = this._stopError || error2;
+    this._stopError = void 0;
+    if (this._connectionState === "Disconnected") {
+      this._logger.log(LogLevel.Debug, `Call to HttpConnection.stopConnection(${error2}) was ignored because the connection is already in the disconnected state.`);
+      return;
+    }
+    if (this._connectionState === "Connecting") {
+      this._logger.log(LogLevel.Warning, `Call to HttpConnection.stopConnection(${error2}) was ignored because the connection is still in the connecting state.`);
+      throw new Error(`HttpConnection.stopConnection(${error2}) was called while the connection is still in the connecting state.`);
+    }
+    if (this._connectionState === "Disconnecting") {
+      this._stopPromiseResolver();
+    }
+    if (error2) {
+      this._logger.log(LogLevel.Error, `Connection disconnected with error '${error2}'.`);
+    } else {
+      this._logger.log(LogLevel.Information, "Connection disconnected.");
+    }
+    if (this._sendQueue) {
+      this._sendQueue.stop().catch((e2) => {
+        this._logger.log(LogLevel.Error, `TransportSendQueue.stop() threw error '${e2}'.`);
+      });
+      this._sendQueue = void 0;
+    }
+    this.connectionId = void 0;
+    this._connectionState = "Disconnected";
+    if (this._connectionStarted) {
+      this._connectionStarted = false;
+      try {
+        if (this.onclose) {
+          this.onclose(error2);
+        }
+      } catch (e2) {
+        this._logger.log(LogLevel.Error, `HttpConnection.onclose(${error2}) threw error '${e2}'.`);
+      }
+    }
+  }
+  _resolveUrl(url2) {
+    if (url2.lastIndexOf("https://", 0) === 0 || url2.lastIndexOf("http://", 0) === 0) {
+      return url2;
+    }
+    if (!Platform.isBrowser) {
+      throw new Error(`Cannot resolve '${url2}'.`);
+    }
+    const aTag = window.document.createElement("a");
+    aTag.href = url2;
+    this._logger.log(LogLevel.Information, `Normalizing '${url2}' to '${aTag.href}'.`);
+    return aTag.href;
+  }
+  _resolveNegotiateUrl(url2) {
+    const index = url2.indexOf("?");
+    let negotiateUrl = url2.substring(0, index === -1 ? url2.length : index);
+    if (negotiateUrl[negotiateUrl.length - 1] !== "/") {
+      negotiateUrl += "/";
+    }
+    negotiateUrl += "negotiate";
+    negotiateUrl += index === -1 ? "" : url2.substring(index);
+    if (negotiateUrl.indexOf("negotiateVersion") === -1) {
+      negotiateUrl += index === -1 ? "?" : "&";
+      negotiateUrl += "negotiateVersion=" + this._negotiateVersion;
+    }
+    return negotiateUrl;
+  }
+}
+function transportMatches(requestedTransport, actualTransport) {
+  return !requestedTransport || (actualTransport & requestedTransport) !== 0;
+}
+class TransportSendQueue {
+  constructor(_transport) {
+    this._transport = _transport;
+    this._buffer = [];
+    this._executing = true;
+    this._sendBufferedData = new PromiseSource();
+    this._transportResult = new PromiseSource();
+    this._sendLoopPromise = this._sendLoop();
+  }
+  send(data2) {
+    this._bufferData(data2);
+    if (!this._transportResult) {
+      this._transportResult = new PromiseSource();
+    }
+    return this._transportResult.promise;
+  }
+  stop() {
+    this._executing = false;
+    this._sendBufferedData.resolve();
+    return this._sendLoopPromise;
+  }
+  _bufferData(data2) {
+    if (this._buffer.length && typeof this._buffer[0] !== typeof data2) {
+      throw new Error(`Expected data to be of type ${typeof this._buffer} but was of type ${typeof data2}`);
+    }
+    this._buffer.push(data2);
+    this._sendBufferedData.resolve();
+  }
+  async _sendLoop() {
+    while (true) {
+      await this._sendBufferedData.promise;
+      if (!this._executing) {
+        if (this._transportResult) {
+          this._transportResult.reject("Connection stopped.");
+        }
+        break;
+      }
+      this._sendBufferedData = new PromiseSource();
+      const transportResult = this._transportResult;
+      this._transportResult = void 0;
+      const data2 = typeof this._buffer[0] === "string" ? this._buffer.join("") : TransportSendQueue._concatBuffers(this._buffer);
+      this._buffer.length = 0;
+      try {
+        await this._transport.send(data2);
+        transportResult.resolve();
+      } catch (error2) {
+        transportResult.reject(error2);
+      }
+    }
+  }
+  static _concatBuffers(arrayBuffers) {
+    const totalLength = arrayBuffers.map((b2) => b2.byteLength).reduce((a2, b2) => a2 + b2);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const item of arrayBuffers) {
+      result.set(new Uint8Array(item), offset);
+      offset += item.byteLength;
+    }
+    return result.buffer;
+  }
+}
+class PromiseSource {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => [this._resolver, this._rejecter] = [resolve, reject]);
+  }
+  resolve() {
+    this._resolver();
+  }
+  reject(reason) {
+    this._rejecter(reason);
+  }
+}
+const JSON_HUB_PROTOCOL_NAME = "json";
+class JsonHubProtocol {
+  constructor() {
+    this.name = JSON_HUB_PROTOCOL_NAME;
+    this.version = 1;
+    this.transferFormat = TransferFormat.Text;
+  }
+  parseMessages(input2, logger) {
+    if (typeof input2 !== "string") {
+      throw new Error("Invalid input for JSON hub protocol. Expected a string.");
+    }
+    if (!input2) {
+      return [];
+    }
+    if (logger === null) {
+      logger = NullLogger.instance;
+    }
+    const messages2 = TextMessageFormat.parse(input2);
+    const hubMessages = [];
+    for (const message2 of messages2) {
+      const parsedMessage = JSON.parse(message2);
+      if (typeof parsedMessage.type !== "number") {
+        throw new Error("Invalid payload.");
+      }
+      switch (parsedMessage.type) {
+        case MessageType.Invocation:
+          this._isInvocationMessage(parsedMessage);
+          break;
+        case MessageType.StreamItem:
+          this._isStreamItemMessage(parsedMessage);
+          break;
+        case MessageType.Completion:
+          this._isCompletionMessage(parsedMessage);
+          break;
+        case MessageType.Ping:
+          break;
+        case MessageType.Close:
+          break;
+        default:
+          logger.log(LogLevel.Information, "Unknown message type '" + parsedMessage.type + "' ignored.");
+          continue;
+      }
+      hubMessages.push(parsedMessage);
+    }
+    return hubMessages;
+  }
+  writeMessage(message2) {
+    return TextMessageFormat.write(JSON.stringify(message2));
+  }
+  _isInvocationMessage(message2) {
+    this._assertNotEmptyString(message2.target, "Invalid payload for Invocation message.");
+    if (message2.invocationId !== void 0) {
+      this._assertNotEmptyString(message2.invocationId, "Invalid payload for Invocation message.");
+    }
+  }
+  _isStreamItemMessage(message2) {
+    this._assertNotEmptyString(message2.invocationId, "Invalid payload for StreamItem message.");
+    if (message2.item === void 0) {
+      throw new Error("Invalid payload for StreamItem message.");
+    }
+  }
+  _isCompletionMessage(message2) {
+    if (message2.result && message2.error) {
+      throw new Error("Invalid payload for Completion message.");
+    }
+    if (!message2.result && message2.error) {
+      this._assertNotEmptyString(message2.error, "Invalid payload for Completion message.");
+    }
+    this._assertNotEmptyString(message2.invocationId, "Invalid payload for Completion message.");
+  }
+  _assertNotEmptyString(value, errorMessage) {
+    if (typeof value !== "string" || value === "") {
+      throw new Error(errorMessage);
+    }
+  }
+}
+const LogLevelNameMapping = {
+  trace: LogLevel.Trace,
+  debug: LogLevel.Debug,
+  info: LogLevel.Information,
+  information: LogLevel.Information,
+  warn: LogLevel.Warning,
+  warning: LogLevel.Warning,
+  error: LogLevel.Error,
+  critical: LogLevel.Critical,
+  none: LogLevel.None
+};
+function parseLogLevel(name) {
+  const mapping = LogLevelNameMapping[name.toLowerCase()];
+  if (typeof mapping !== "undefined") {
+    return mapping;
+  } else {
+    throw new Error(`Unknown log level: ${name}`);
+  }
+}
+class HubConnectionBuilder {
+  configureLogging(logging) {
+    Arg.isRequired(logging, "logging");
+    if (isLogger(logging)) {
+      this.logger = logging;
+    } else if (typeof logging === "string") {
+      const logLevel = parseLogLevel(logging);
+      this.logger = new ConsoleLogger(logLevel);
+    } else {
+      this.logger = new ConsoleLogger(logging);
+    }
+    return this;
+  }
+  withUrl(url2, transportTypeOrOptions) {
+    Arg.isRequired(url2, "url");
+    Arg.isNotEmpty(url2, "url");
+    this.url = url2;
+    if (typeof transportTypeOrOptions === "object") {
+      this.httpConnectionOptions = { ...this.httpConnectionOptions, ...transportTypeOrOptions };
+    } else {
+      this.httpConnectionOptions = {
+        ...this.httpConnectionOptions,
+        transport: transportTypeOrOptions
+      };
+    }
+    return this;
+  }
+  withHubProtocol(protocol) {
+    Arg.isRequired(protocol, "protocol");
+    this.protocol = protocol;
+    return this;
+  }
+  withAutomaticReconnect(retryDelaysOrReconnectPolicy) {
+    if (this.reconnectPolicy) {
+      throw new Error("A reconnectPolicy has already been set.");
+    }
+    if (!retryDelaysOrReconnectPolicy) {
+      this.reconnectPolicy = new DefaultReconnectPolicy();
+    } else if (Array.isArray(retryDelaysOrReconnectPolicy)) {
+      this.reconnectPolicy = new DefaultReconnectPolicy(retryDelaysOrReconnectPolicy);
+    } else {
+      this.reconnectPolicy = retryDelaysOrReconnectPolicy;
+    }
+    return this;
+  }
+  build() {
+    const httpConnectionOptions = this.httpConnectionOptions || {};
+    if (httpConnectionOptions.logger === void 0) {
+      httpConnectionOptions.logger = this.logger;
+    }
+    if (!this.url) {
+      throw new Error("The 'HubConnectionBuilder.withUrl' method must be called before building the connection.");
+    }
+    const connection = new HttpConnection(this.url, httpConnectionOptions);
+    return HubConnection.create(connection, this.logger || NullLogger.instance, this.protocol || new JsonHubProtocol(), this.reconnectPolicy);
+  }
+}
+function isLogger(logger) {
+  return logger.log !== void 0;
+}
+const useConfigStore = defineStore("config", {
+  state: () => ({
+    token: "",
+    baseUrl: ""
+  }),
+  actions: {
+    getToken(token) {
+      this.token = token;
+    },
+    getBaseUrl(url2) {
+      this.baseUrl = url2;
+    },
+    api(optionsRequest) {
+      return ApiJs(optionsRequest, false, `Bearer ${this.token}`, true);
+    },
+    channelsConnectionHub() {
+      return new HubConnectionBuilder().withUrl(`${this.baseUrl}/v2/channels`, {
+        accessTokenFactory: () => `${this.token}`
+      }).configureLogging(LogLevel.Information).build();
+    },
+    async connectChannelsSignalR(channelId) {
+      let startedPromise = null;
+      async function start() {
+        startedPromise = await this.channelsConnectionHub.start().catch((err) => {
+          console.error("Failed to connect with hub", err);
+          return new Promise((res, rej) => setTimeout(() => start().then(res).catch(rej), 5e3));
+        });
+        console.log("start $channelsConnectionHub");
+        return startedPromise;
+      }
+      try {
+        await start();
+        await this.channelsConnectionHub.invoke("Join", channelId);
+      } catch (err) {
+        console.error(err.toString());
+      }
+    }
+  }
+});
+var apiChat = {
+  getChannels(api, baseUrl, category, count2 = 50) {
+    return api({
+      url: `${baseUrl}/api/channels/issues/${category}`,
+      method: "GET",
+      headers: {
+        "x-group-id": "FLINE"
+      },
+      params: {
+        count: count2
+      }
+    });
+  },
+  getUnreadChannels(api, baseUrl) {
+    return api({
+      url: `${baseUrl}/api/channels/issues/count`,
+      method: "GET",
+      headers: {
+        "x-group-id": "FLINE"
+      }
+    });
+  },
+  getGroups(api, baseUrl) {
+    return api({
+      url: `${baseUrl}/api/groups`,
+      method: "GET",
+      headers: {
+        "x-group-id": "FLINE"
+      }
+    });
+  }
+};
+const useCommonStore = defineStore("commonStore", {
+  state: () => ({
+    loadingStatus: "notLoading"
+  }),
+  getters: {
+    isLoading: (state) => state.loadingStatus === "loading"
+  },
+  actions: {
+    setLoadingStatus(status) {
+      this.loadingStatus = status;
+    }
+  }
+});
+const useChannelsStore = defineStore("channels", {
+  state: () => ({
+    channels: [],
+    unreadChannels: {},
+    groups: [],
+    channelCategory: "Active",
+    notifications: {
+      messagesRead: null,
+      messageAdded: null,
+      activeChannels: null
+    },
+    selectedChannelInfo: {
+      channelId: "",
+      participant: [],
+      files: [],
+      messages: [],
+      unreadMessagesCount: null,
+      loadingMessages: false,
+      managerConnect: null,
+      afterMessagesLoaded: false,
+      beforeMessagesLoaded: false
+    }
+  }),
+  getters: {
+    api() {
+      const configStore = useConfigStore();
+      return configStore.api;
+    },
+    baseUrl() {
+      const configStore = useConfigStore();
+      return configStore.baseUrl;
+    }
+  },
+  actions: {
+    loading() {
+      const commonStore = useCommonStore();
+      commonStore.setLoadingStatus("loading");
+    },
+    notLoading() {
+      const commonStore = useCommonStore();
+      commonStore.setLoadingStatus("notLoading");
+    },
+    async getChannels(category) {
+      try {
+        this.loading();
+        const channels = await apiChat.getChannels(this.api, this.baseUrl, category);
+        this.channels = channels;
+        if (category === "New") {
+          this.notifications.activeChannels = channels;
+        }
+      } catch (error2) {
+        console.log(error2);
+      } finally {
+        this.notLoading();
+      }
+    },
+    async getUnreadChannels() {
+      try {
+        this.unreadChannels = await apiChat.getUnreadChannels(this.api, this.baseUrl);
+      } catch (error2) {
+        console.log(error2);
+      }
+    },
+    async getGroups() {
+      try {
+        this.groups = await apiChat.getGroups(this.api, this.baseUrl);
+      } catch (error2) {
+        console.log(error2);
+      }
+    }
+  }
+});
+var PlChatBtn_vue_vue_type_style_index_0_lang = "";
+var PlChatPopup_vue_vue_type_style_index_0_lang = "";
+const _sfc_main = {
+  __name: "pl-chat-manager",
+  props: {
+    token: {
+      type: String,
+      default: ""
+    },
+    baseUrl: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { token, baseUrl } = toRefs(props);
+    const configStore = useConfigStore();
+    const channelsStore = useChannelsStore();
+    useCommonStore();
+    const isHubsConnected = ref(true);
+    const getChannelsInfo = async () => {
+      configStore.getToken(token);
+      configStore.getBaseUrl(baseUrl);
+      await Promise.all([
+        await channelsStore.getChannels("New"),
+        await channelsStore.getUnreadChannels(),
+        await channelsStore.getGroups()
+      ]);
+    };
+    const updateChannels = async () => {
+      try {
+        await Promise.all([
+          await channelsStore.getChannels(channelsStore.channelCategory),
+          await channelsStore.getUnreadChannels()
+        ]);
+      } catch (error2) {
+        console.log(error2);
+      }
+    };
+    const managerChannelsSignalR = async () => {
+      try {
+        await Promise.all(channelsStore.notifications.activeChannels.map(async (channel) => {
+          await configStore.connectChannelsSignalR(channel.channelId);
+          await configStore.channelsConnectionHub.on("MessageAddedNotification", async (message2) => {
+            console.log("MessageAddedNotificationManager", message2);
+            await updateChannels();
+          });
+          await configStore.channelsConnectionHub.on("MessagesReadNotification", (message2) => {
+            console.log("MessagesReadNotification", message2);
+            updateChannels();
+          });
+        }));
+      } catch (error2) {
+        console.log(error2);
+      }
+    };
+    const chatManagerStart = async () => {
+      try {
+        await Promise.all([
+          getChannelsInfo(),
+          managerChannelsSignalR()
+        ]);
+      } catch (error2) {
+        console.log(error2);
+      } finally {
+        isHubsConnected.value = false;
+      }
+    };
+    chatManagerStart();
+    return (_ctx, _cache) => {
+      const _directive_loading = vLoading;
+      return withDirectives((openBlock(), createElementBlock("div", null, [
+        createTextVNode(toDisplayString(unref(channelsStore).notifications.activeChannels), 1)
+      ])), [
+        [_directive_loading, isHubsConnected.value]
+      ]);
     };
   }
 };