import {
  __commonJS,
  __esm,
  __export,
  __toCommonJS
} from "/_nuxt/node_modules/.cache/vite/client/deps/chunk-V4OQ3NZ2.js?v=e4f18c29";

// node_modules/backo2/index.js
var require_backo2 = __commonJS({
  "node_modules/backo2/index.js"(exports, module2) {
    module2.exports = Backoff;
    function Backoff(opts) {
      opts = opts || {};
      this.ms = opts.min || 100;
      this.max = opts.max || 1e4;
      this.factor = opts.factor || 2;
      this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
      this.attempts = 0;
    }
    Backoff.prototype.duration = function() {
      var ms = this.ms * Math.pow(this.factor, this.attempts++);
      if (this.jitter) {
        var rand = Math.random();
        var deviation = Math.floor(rand * this.jitter * ms);
        ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
      }
      return Math.min(ms, this.max) | 0;
    };
    Backoff.prototype.reset = function() {
      this.attempts = 0;
    };
    Backoff.prototype.setMin = function(min) {
      this.ms = min;
    };
    Backoff.prototype.setMax = function(max) {
      this.max = max;
    };
    Backoff.prototype.setJitter = function(jitter) {
      this.jitter = jitter;
    };
  }
});

// node_modules/eventemitter3/index.js
var require_eventemitter3 = __commonJS({
  "node_modules/eventemitter3/index.js"(exports, module2) {
    "use strict";
    var has = Object.prototype.hasOwnProperty;
    var prefix = "~";
    function Events() {
    }
    if (Object.create) {
      Events.prototype = /* @__PURE__ */ Object.create(null);
      if (!new Events().__proto__) prefix = false;
    }
    function EE(fn, context, once) {
      this.fn = fn;
      this.context = context;
      this.once = once || false;
    }
    function addListener(emitter, event, fn, context, once) {
      if (typeof fn !== "function") {
        throw new TypeError("The listener must be a function");
      }
      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
      else emitter._events[evt] = [emitter._events[evt], listener];
      return emitter;
    }
    function clearEvent(emitter, evt) {
      if (--emitter._eventsCount === 0) emitter._events = new Events();
      else delete emitter._events[evt];
    }
    function EventEmitter() {
      this._events = new Events();
      this._eventsCount = 0;
    }
    EventEmitter.prototype.eventNames = function eventNames() {
      var names = [], events, name;
      if (this._eventsCount === 0) return names;
      for (name in events = this._events) {
        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
      }
      if (Object.getOwnPropertySymbols) {
        return names.concat(Object.getOwnPropertySymbols(events));
      }
      return names;
    };
    EventEmitter.prototype.listeners = function listeners(event) {
      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
      if (!handlers) return [];
      if (handlers.fn) return [handlers.fn];
      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
        ee[i] = handlers[i].fn;
      }
      return ee;
    };
    EventEmitter.prototype.listenerCount = function listenerCount(event) {
      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
      if (!listeners) return 0;
      if (listeners.fn) return 1;
      return listeners.length;
    };
    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt]) return false;
      var listeners = this._events[evt], len = arguments.length, args, i;
      if (listeners.fn) {
        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
        switch (len) {
          case 1:
            return listeners.fn.call(listeners.context), true;
          case 2:
            return listeners.fn.call(listeners.context, a1), true;
          case 3:
            return listeners.fn.call(listeners.context, a1, a2), true;
          case 4:
            return listeners.fn.call(listeners.context, a1, a2, a3), true;
          case 5:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
          case 6:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
        }
        for (i = 1, args = new Array(len - 1); i < len; i++) {
          args[i - 1] = arguments[i];
        }
        listeners.fn.apply(listeners.context, args);
      } else {
        var length = listeners.length, j;
        for (i = 0; i < length; i++) {
          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
          switch (len) {
            case 1:
              listeners[i].fn.call(listeners[i].context);
              break;
            case 2:
              listeners[i].fn.call(listeners[i].context, a1);
              break;
            case 3:
              listeners[i].fn.call(listeners[i].context, a1, a2);
              break;
            case 4:
              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
              break;
            default:
              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
                args[j - 1] = arguments[j];
              }
              listeners[i].fn.apply(listeners[i].context, args);
          }
        }
      }
      return true;
    };
    EventEmitter.prototype.on = function on(event, fn, context) {
      return addListener(this, event, fn, context, false);
    };
    EventEmitter.prototype.once = function once(event, fn, context) {
      return addListener(this, event, fn, context, true);
    };
    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt]) return this;
      if (!fn) {
        clearEvent(this, evt);
        return this;
      }
      var listeners = this._events[evt];
      if (listeners.fn) {
        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
          clearEvent(this, evt);
        }
      } else {
        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
            events.push(listeners[i]);
          }
        }
        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
        else clearEvent(this, evt);
      }
      return this;
    };
    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
      var evt;
      if (event) {
        evt = prefix ? prefix + event : event;
        if (this._events[evt]) clearEvent(this, evt);
      } else {
        this._events = new Events();
        this._eventsCount = 0;
      }
      return this;
    };
    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
    EventEmitter.prefixed = prefix;
    EventEmitter.EventEmitter = EventEmitter;
    if ("undefined" !== typeof module2) {
      module2.exports = EventEmitter;
    }
  }
});

// node_modules/subscriptions-transport-ws/dist/utils/is-string.js
var require_is_string = __commonJS({
  "node_modules/subscriptions-transport-ws/dist/utils/is-string.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    function isString(value) {
      return typeof value === "string";
    }
    exports.default = isString;
  }
});

// node_modules/subscriptions-transport-ws/dist/utils/is-object.js
var require_is_object = __commonJS({
  "node_modules/subscriptions-transport-ws/dist/utils/is-object.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    function isObject(value) {
      return value !== null && typeof value === "object";
    }
    exports.default = isObject;
  }
});

// vite:cjs-external-facade:graphql/language/printer
import * as m from "/_nuxt/node_modules/graphql/language/printer.mjs?v=e4f18c29";
var require_printer = __commonJS({
  "vite:cjs-external-facade:graphql/language/printer"(exports, module2) {
    module2.exports = { ...m };
  }
});

// vite:cjs-external-facade:graphql/utilities/getOperationAST
import * as m2 from "/_nuxt/node_modules/graphql/utilities/getOperationAST.mjs?v=e4f18c29";
var require_getOperationAST = __commonJS({
  "vite:cjs-external-facade:graphql/utilities/getOperationAST"(exports, module2) {
    module2.exports = { ...m2 };
  }
});

// node_modules/subscriptions-transport-ws/node_modules/symbol-observable/es/ponyfill.js
function symbolObservablePonyfill(root2) {
  var result2;
  var Symbol2 = root2.Symbol;
  if (typeof Symbol2 === "function") {
    if (Symbol2.observable) {
      result2 = Symbol2.observable;
    } else {
      result2 = Symbol2("observable");
      Symbol2.observable = result2;
    }
  } else {
    result2 = "@@observable";
  }
  return result2;
}
var init_ponyfill = __esm({
  "node_modules/subscriptions-transport-ws/node_modules/symbol-observable/es/ponyfill.js"() {
  }
});

// node_modules/subscriptions-transport-ws/node_modules/symbol-observable/es/index.js
var es_exports = {};
__export(es_exports, {
  default: () => es_default
});
var root, result, es_default;
var init_es = __esm({
  "node_modules/subscriptions-transport-ws/node_modules/symbol-observable/es/index.js"() {
    init_ponyfill();
    if (typeof self !== "undefined") {
      root = self;
    } else if (typeof window !== "undefined") {
      root = window;
    } else if (typeof global !== "undefined") {
      root = global;
    } else if (typeof module !== "undefined") {
      root = module;
    } else {
      root = Function("return this")();
    }
    result = symbolObservablePonyfill(root);
    es_default = result;
  }
});

// node_modules/subscriptions-transport-ws/dist/protocol.js
var require_protocol = __commonJS({
  "node_modules/subscriptions-transport-ws/dist/protocol.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.GRAPHQL_SUBSCRIPTIONS = exports.GRAPHQL_WS = void 0;
    var GRAPHQL_WS = "graphql-ws";
    exports.GRAPHQL_WS = GRAPHQL_WS;
    var GRAPHQL_SUBSCRIPTIONS = "graphql-subscriptions";
    exports.GRAPHQL_SUBSCRIPTIONS = GRAPHQL_SUBSCRIPTIONS;
  }
});

// node_modules/subscriptions-transport-ws/dist/defaults.js
var require_defaults = __commonJS({
  "node_modules/subscriptions-transport-ws/dist/defaults.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.WS_TIMEOUT = exports.MIN_WS_TIMEOUT = void 0;
    var MIN_WS_TIMEOUT = 1e3;
    exports.MIN_WS_TIMEOUT = MIN_WS_TIMEOUT;
    var WS_TIMEOUT = 3e4;
    exports.WS_TIMEOUT = WS_TIMEOUT;
  }
});

// node_modules/subscriptions-transport-ws/dist/message-types.js
var require_message_types = __commonJS({
  "node_modules/subscriptions-transport-ws/dist/message-types.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var MessageTypes = function() {
      function MessageTypes2() {
        throw new Error("Static Class");
      }
      MessageTypes2.GQL_CONNECTION_INIT = "connection_init";
      MessageTypes2.GQL_CONNECTION_ACK = "connection_ack";
      MessageTypes2.GQL_CONNECTION_ERROR = "connection_error";
      MessageTypes2.GQL_CONNECTION_KEEP_ALIVE = "ka";
      MessageTypes2.GQL_CONNECTION_TERMINATE = "connection_terminate";
      MessageTypes2.GQL_START = "start";
      MessageTypes2.GQL_DATA = "data";
      MessageTypes2.GQL_ERROR = "error";
      MessageTypes2.GQL_COMPLETE = "complete";
      MessageTypes2.GQL_STOP = "stop";
      MessageTypes2.SUBSCRIPTION_START = "subscription_start";
      MessageTypes2.SUBSCRIPTION_DATA = "subscription_data";
      MessageTypes2.SUBSCRIPTION_SUCCESS = "subscription_success";
      MessageTypes2.SUBSCRIPTION_FAIL = "subscription_fail";
      MessageTypes2.SUBSCRIPTION_END = "subscription_end";
      MessageTypes2.INIT = "init";
      MessageTypes2.INIT_SUCCESS = "init_success";
      MessageTypes2.INIT_FAIL = "init_fail";
      MessageTypes2.KEEP_ALIVE = "keepalive";
      return MessageTypes2;
    }();
    exports.default = MessageTypes;
  }
});

// node_modules/subscriptions-transport-ws/dist/client.js
var require_client = __commonJS({
  "node_modules/subscriptions-transport-ws/dist/client.js"(exports) {
    var __assign = exports && exports.__assign || function() {
      __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
        }
        return t;
      };
      return __assign.apply(this, arguments);
    };
    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
      function adopt(value) {
        return value instanceof P ? value : new P(function(resolve) {
          resolve(value);
        });
      }
      return new (P || (P = Promise))(function(resolve, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e) {
            reject(e);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e) {
            reject(e);
          }
        }
        function step(result2) {
          result2.done ? resolve(result2.value) : adopt(result2.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    var __generator = exports && exports.__generator || function(thisArg, body) {
      var _ = { label: 0, sent: function() {
        if (t[0] & 1) throw t[1];
        return t[1];
      }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
        return this;
      }), g;
      function verb(n) {
        return function(v) {
          return step([n, v]);
        };
      }
      function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
          if (y = 0, t) op = [op[0] & 2, t.value];
          switch (op[0]) {
            case 0:
            case 1:
              t = op;
              break;
            case 4:
              _.label++;
              return { value: op[1], done: false };
            case 5:
              _.label++;
              y = op[1];
              op = [0];
              continue;
            case 7:
              op = _.ops.pop();
              _.trys.pop();
              continue;
            default:
              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                _ = 0;
                continue;
              }
              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
                _.label = op[1];
                break;
              }
              if (op[0] === 6 && _.label < t[1]) {
                _.label = t[1];
                t = op;
                break;
              }
              if (t && _.label < t[2]) {
                _.label = t[2];
                _.ops.push(op);
                break;
              }
              if (t[2]) _.ops.pop();
              _.trys.pop();
              continue;
          }
          op = body.call(thisArg, _);
        } catch (e) {
          op = [6, e];
          y = 0;
        } finally {
          f = t = 0;
        }
        if (op[0] & 5) throw op[1];
        return { value: op[0] ? op[1] : void 0, done: true };
      }
    };
    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
          ar[i] = from[i];
        }
      }
      return to.concat(ar || Array.prototype.slice.call(from));
    };
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.SubscriptionClient = void 0;
    var _global = typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : {};
    var NativeWebSocket = _global.WebSocket || _global.MozWebSocket;
    var Backoff = require_backo2();
    var eventemitter3_1 = require_eventemitter3();
    var is_string_1 = require_is_string();
    var is_object_1 = require_is_object();
    var printer_1 = require_printer();
    var getOperationAST_1 = require_getOperationAST();
    var symbol_observable_1 = (init_es(), __toCommonJS(es_exports));
    var protocol_1 = require_protocol();
    var defaults_1 = require_defaults();
    var message_types_1 = require_message_types();
    var SubscriptionClient = function() {
      function SubscriptionClient2(url, options, webSocketImpl, webSocketProtocols) {
        var _a = options || {}, _b = _a.connectionCallback, connectionCallback = _b === void 0 ? void 0 : _b, _c = _a.connectionParams, connectionParams = _c === void 0 ? {} : _c, _d = _a.minTimeout, minTimeout = _d === void 0 ? defaults_1.MIN_WS_TIMEOUT : _d, _e = _a.timeout, timeout = _e === void 0 ? defaults_1.WS_TIMEOUT : _e, _f = _a.reconnect, reconnect = _f === void 0 ? false : _f, _g = _a.reconnectionAttempts, reconnectionAttempts = _g === void 0 ? Infinity : _g, _h = _a.lazy, lazy = _h === void 0 ? false : _h, _j = _a.inactivityTimeout, inactivityTimeout = _j === void 0 ? 0 : _j, _k = _a.wsOptionArguments, wsOptionArguments = _k === void 0 ? [] : _k;
        this.wsImpl = webSocketImpl || NativeWebSocket;
        if (!this.wsImpl) {
          throw new Error("Unable to find native implementation, or alternative implementation for WebSocket!");
        }
        this.wsProtocols = webSocketProtocols || protocol_1.GRAPHQL_WS;
        this.connectionCallback = connectionCallback;
        this.url = url;
        this.operations = {};
        this.nextOperationId = 0;
        this.minWsTimeout = minTimeout;
        this.wsTimeout = timeout;
        this.unsentMessagesQueue = [];
        this.reconnect = reconnect;
        this.reconnecting = false;
        this.reconnectionAttempts = reconnectionAttempts;
        this.lazy = !!lazy;
        this.inactivityTimeout = inactivityTimeout;
        this.closedByUser = false;
        this.backoff = new Backoff({ jitter: 0.5 });
        this.eventEmitter = new eventemitter3_1.EventEmitter();
        this.middlewares = [];
        this.client = null;
        this.maxConnectTimeGenerator = this.createMaxConnectTimeGenerator();
        this.connectionParams = this.getConnectionParams(connectionParams);
        this.wsOptionArguments = wsOptionArguments;
        if (!this.lazy) {
          this.connect();
        }
      }
      Object.defineProperty(SubscriptionClient2.prototype, "status", {
        get: function() {
          if (this.client === null) {
            return this.wsImpl.CLOSED;
          }
          return this.client.readyState;
        },
        enumerable: false,
        configurable: true
      });
      SubscriptionClient2.prototype.close = function(isForced, closedByUser) {
        if (isForced === void 0) {
          isForced = true;
        }
        if (closedByUser === void 0) {
          closedByUser = true;
        }
        this.clearInactivityTimeout();
        if (this.client !== null) {
          this.closedByUser = closedByUser;
          if (isForced) {
            this.clearCheckConnectionInterval();
            this.clearMaxConnectTimeout();
            this.clearTryReconnectTimeout();
            this.unsubscribeAll();
            this.sendMessage(void 0, message_types_1.default.GQL_CONNECTION_TERMINATE, null);
          }
          this.client.close();
          this.client.onopen = null;
          this.client.onclose = null;
          this.client.onerror = null;
          this.client.onmessage = null;
          this.client = null;
          this.eventEmitter.emit("disconnected");
          if (!isForced) {
            this.tryReconnect();
          }
        }
      };
      SubscriptionClient2.prototype.request = function(request) {
        var _a;
        var getObserver = this.getObserver.bind(this);
        var executeOperation = this.executeOperation.bind(this);
        var unsubscribe = this.unsubscribe.bind(this);
        var opId;
        this.clearInactivityTimeout();
        return _a = {}, _a[symbol_observable_1.default] = function() {
          return this;
        }, _a.subscribe = function(observerOrNext, onError, onComplete) {
          var observer = getObserver(observerOrNext, onError, onComplete);
          opId = executeOperation(request, function(error, result2) {
            if (error === null && result2 === null) {
              if (observer.complete) {
                observer.complete();
              }
            } else if (error) {
              if (observer.error) {
                observer.error(error[0]);
              }
            } else {
              if (observer.next) {
                observer.next(result2);
              }
            }
          });
          return {
            unsubscribe: function() {
              if (opId) {
                unsubscribe(opId);
                opId = null;
              }
            }
          };
        }, _a;
      };
      SubscriptionClient2.prototype.on = function(eventName, callback, context) {
        var handler = this.eventEmitter.on(eventName, callback, context);
        return function() {
          handler.off(eventName, callback, context);
        };
      };
      SubscriptionClient2.prototype.onConnected = function(callback, context) {
        return this.on("connected", callback, context);
      };
      SubscriptionClient2.prototype.onConnecting = function(callback, context) {
        return this.on("connecting", callback, context);
      };
      SubscriptionClient2.prototype.onDisconnected = function(callback, context) {
        return this.on("disconnected", callback, context);
      };
      SubscriptionClient2.prototype.onReconnected = function(callback, context) {
        return this.on("reconnected", callback, context);
      };
      SubscriptionClient2.prototype.onReconnecting = function(callback, context) {
        return this.on("reconnecting", callback, context);
      };
      SubscriptionClient2.prototype.onError = function(callback, context) {
        return this.on("error", callback, context);
      };
      SubscriptionClient2.prototype.unsubscribeAll = function() {
        var _this = this;
        Object.keys(this.operations).forEach(function(subId) {
          _this.unsubscribe(subId);
        });
      };
      SubscriptionClient2.prototype.applyMiddlewares = function(options) {
        var _this = this;
        return new Promise(function(resolve, reject) {
          var queue = function(funcs, scope) {
            var next = function(error) {
              if (error) {
                reject(error);
              } else {
                if (funcs.length > 0) {
                  var f = funcs.shift();
                  if (f) {
                    f.applyMiddleware.apply(scope, [options, next]);
                  }
                } else {
                  resolve(options);
                }
              }
            };
            next();
          };
          queue(__spreadArray([], _this.middlewares, true), _this);
        });
      };
      SubscriptionClient2.prototype.use = function(middlewares) {
        var _this = this;
        middlewares.map(function(middleware) {
          if (typeof middleware.applyMiddleware === "function") {
            _this.middlewares.push(middleware);
          } else {
            throw new Error("Middleware must implement the applyMiddleware function.");
          }
        });
        return this;
      };
      SubscriptionClient2.prototype.getConnectionParams = function(connectionParams) {
        return function() {
          return new Promise(function(resolve, reject) {
            if (typeof connectionParams === "function") {
              try {
                return resolve(connectionParams.call(null));
              } catch (error) {
                return reject(error);
              }
            }
            resolve(connectionParams);
          });
        };
      };
      SubscriptionClient2.prototype.executeOperation = function(options, handler) {
        var _this = this;
        if (this.client === null) {
          this.connect();
        }
        var opId = this.generateOperationId();
        this.operations[opId] = { options, handler };
        this.applyMiddlewares(options).then(function(processedOptions) {
          _this.checkOperationOptions(processedOptions, handler);
          if (_this.operations[opId]) {
            _this.operations[opId] = { options: processedOptions, handler };
            _this.sendMessage(opId, message_types_1.default.GQL_START, processedOptions);
          }
        }).catch(function(error) {
          _this.unsubscribe(opId);
          handler(_this.formatErrors(error));
        });
        return opId;
      };
      SubscriptionClient2.prototype.getObserver = function(observerOrNext, error, complete) {
        if (typeof observerOrNext === "function") {
          return {
            next: function(v) {
              return observerOrNext(v);
            },
            error: function(e) {
              return error && error(e);
            },
            complete: function() {
              return complete && complete();
            }
          };
        }
        return observerOrNext;
      };
      SubscriptionClient2.prototype.createMaxConnectTimeGenerator = function() {
        var minValue = this.minWsTimeout;
        var maxValue = this.wsTimeout;
        return new Backoff({
          min: minValue,
          max: maxValue,
          factor: 1.2
        });
      };
      SubscriptionClient2.prototype.clearCheckConnectionInterval = function() {
        if (this.checkConnectionIntervalId) {
          clearInterval(this.checkConnectionIntervalId);
          this.checkConnectionIntervalId = null;
        }
      };
      SubscriptionClient2.prototype.clearMaxConnectTimeout = function() {
        if (this.maxConnectTimeoutId) {
          clearTimeout(this.maxConnectTimeoutId);
          this.maxConnectTimeoutId = null;
        }
      };
      SubscriptionClient2.prototype.clearTryReconnectTimeout = function() {
        if (this.tryReconnectTimeoutId) {
          clearTimeout(this.tryReconnectTimeoutId);
          this.tryReconnectTimeoutId = null;
        }
      };
      SubscriptionClient2.prototype.clearInactivityTimeout = function() {
        if (this.inactivityTimeoutId) {
          clearTimeout(this.inactivityTimeoutId);
          this.inactivityTimeoutId = null;
        }
      };
      SubscriptionClient2.prototype.setInactivityTimeout = function() {
        var _this = this;
        if (this.inactivityTimeout > 0 && Object.keys(this.operations).length === 0) {
          this.inactivityTimeoutId = setTimeout(function() {
            if (Object.keys(_this.operations).length === 0) {
              _this.close();
            }
          }, this.inactivityTimeout);
        }
      };
      SubscriptionClient2.prototype.checkOperationOptions = function(options, handler) {
        var query = options.query, variables = options.variables, operationName = options.operationName;
        if (!query) {
          throw new Error("Must provide a query.");
        }
        if (!handler) {
          throw new Error("Must provide an handler.");
        }
        if (!(0, is_string_1.default)(query) && !(0, getOperationAST_1.getOperationAST)(query, operationName) || operationName && !(0, is_string_1.default)(operationName) || variables && !(0, is_object_1.default)(variables)) {
          throw new Error("Incorrect option types. query must be a string or a document,`operationName` must be a string, and `variables` must be an object.");
        }
      };
      SubscriptionClient2.prototype.buildMessage = function(id, type, payload) {
        var payloadToReturn = payload && payload.query ? __assign(__assign({}, payload), { query: typeof payload.query === "string" ? payload.query : (0, printer_1.print)(payload.query) }) : payload;
        return {
          id,
          type,
          payload: payloadToReturn
        };
      };
      SubscriptionClient2.prototype.formatErrors = function(errors) {
        if (Array.isArray(errors)) {
          return errors;
        }
        if (errors && errors.errors) {
          return this.formatErrors(errors.errors);
        }
        if (errors && errors.message) {
          return [errors];
        }
        return [{
          name: "FormatedError",
          message: "Unknown error",
          originalError: errors
        }];
      };
      SubscriptionClient2.prototype.sendMessage = function(id, type, payload) {
        this.sendMessageRaw(this.buildMessage(id, type, payload));
      };
      SubscriptionClient2.prototype.sendMessageRaw = function(message) {
        switch (this.status) {
          case this.wsImpl.OPEN:
            var serializedMessage = JSON.stringify(message);
            try {
              JSON.parse(serializedMessage);
            } catch (e) {
              this.eventEmitter.emit("error", new Error("Message must be JSON-serializable. Got: " + message));
            }
            this.client.send(serializedMessage);
            break;
          case this.wsImpl.CONNECTING:
            this.unsentMessagesQueue.push(message);
            break;
          default:
            if (!this.reconnecting) {
              this.eventEmitter.emit("error", new Error("A message was not sent because socket is not connected, is closing or is already closed. Message was: " + JSON.stringify(message)));
            }
        }
      };
      SubscriptionClient2.prototype.generateOperationId = function() {
        return String(++this.nextOperationId);
      };
      SubscriptionClient2.prototype.tryReconnect = function() {
        var _this = this;
        if (!this.reconnect || this.backoff.attempts >= this.reconnectionAttempts) {
          return;
        }
        if (!this.reconnecting) {
          Object.keys(this.operations).forEach(function(key) {
            _this.unsentMessagesQueue.push(_this.buildMessage(key, message_types_1.default.GQL_START, _this.operations[key].options));
          });
          this.reconnecting = true;
        }
        this.clearTryReconnectTimeout();
        var delay = this.backoff.duration();
        this.tryReconnectTimeoutId = setTimeout(function() {
          _this.connect();
        }, delay);
      };
      SubscriptionClient2.prototype.flushUnsentMessagesQueue = function() {
        var _this = this;
        this.unsentMessagesQueue.forEach(function(message) {
          _this.sendMessageRaw(message);
        });
        this.unsentMessagesQueue = [];
      };
      SubscriptionClient2.prototype.checkConnection = function() {
        if (this.wasKeepAliveReceived) {
          this.wasKeepAliveReceived = false;
          return;
        }
        if (!this.reconnecting) {
          this.close(false, true);
        }
      };
      SubscriptionClient2.prototype.checkMaxConnectTimeout = function() {
        var _this = this;
        this.clearMaxConnectTimeout();
        this.maxConnectTimeoutId = setTimeout(function() {
          if (_this.status !== _this.wsImpl.OPEN) {
            _this.reconnecting = true;
            _this.close(false, true);
          }
        }, this.maxConnectTimeGenerator.duration());
      };
      SubscriptionClient2.prototype.connect = function() {
        var _a;
        var _this = this;
        this.client = new ((_a = this.wsImpl).bind.apply(_a, __spreadArray([void 0, this.url, this.wsProtocols], this.wsOptionArguments, false)))();
        this.checkMaxConnectTimeout();
        this.client.onopen = function() {
          return __awaiter(_this, void 0, void 0, function() {
            var connectionParams, error_1;
            return __generator(this, function(_a2) {
              switch (_a2.label) {
                case 0:
                  if (!(this.status === this.wsImpl.OPEN)) return [3, 4];
                  this.clearMaxConnectTimeout();
                  this.closedByUser = false;
                  this.eventEmitter.emit(this.reconnecting ? "reconnecting" : "connecting");
                  _a2.label = 1;
                case 1:
                  _a2.trys.push([1, 3, , 4]);
                  return [4, this.connectionParams()];
                case 2:
                  connectionParams = _a2.sent();
                  this.sendMessage(void 0, message_types_1.default.GQL_CONNECTION_INIT, connectionParams);
                  this.flushUnsentMessagesQueue();
                  return [3, 4];
                case 3:
                  error_1 = _a2.sent();
                  this.sendMessage(void 0, message_types_1.default.GQL_CONNECTION_ERROR, error_1);
                  this.flushUnsentMessagesQueue();
                  return [3, 4];
                case 4:
                  return [2];
              }
            });
          });
        };
        this.client.onclose = function() {
          if (!_this.closedByUser) {
            _this.close(false, false);
          }
        };
        this.client.onerror = function(err) {
          _this.eventEmitter.emit("error", err);
        };
        this.client.onmessage = function(_a2) {
          var data = _a2.data;
          _this.processReceivedData(data);
        };
      };
      SubscriptionClient2.prototype.processReceivedData = function(receivedData) {
        var parsedMessage;
        var opId;
        try {
          parsedMessage = JSON.parse(receivedData);
          opId = parsedMessage.id;
        } catch (e) {
          throw new Error("Message must be JSON-parseable. Got: " + receivedData);
        }
        if ([
          message_types_1.default.GQL_DATA,
          message_types_1.default.GQL_COMPLETE,
          message_types_1.default.GQL_ERROR
        ].indexOf(parsedMessage.type) !== -1 && !this.operations[opId]) {
          this.unsubscribe(opId);
          return;
        }
        switch (parsedMessage.type) {
          case message_types_1.default.GQL_CONNECTION_ERROR:
            if (this.connectionCallback) {
              this.connectionCallback(parsedMessage.payload);
            }
            break;
          case message_types_1.default.GQL_CONNECTION_ACK:
            this.eventEmitter.emit(this.reconnecting ? "reconnected" : "connected", parsedMessage.payload);
            this.reconnecting = false;
            this.backoff.reset();
            this.maxConnectTimeGenerator.reset();
            if (this.connectionCallback) {
              this.connectionCallback();
            }
            break;
          case message_types_1.default.GQL_COMPLETE:
            var handler = this.operations[opId].handler;
            delete this.operations[opId];
            handler.call(this, null, null);
            break;
          case message_types_1.default.GQL_ERROR:
            this.operations[opId].handler(this.formatErrors(parsedMessage.payload), null);
            delete this.operations[opId];
            break;
          case message_types_1.default.GQL_DATA:
            var parsedPayload = !parsedMessage.payload.errors ? parsedMessage.payload : __assign(__assign({}, parsedMessage.payload), { errors: this.formatErrors(parsedMessage.payload.errors) });
            this.operations[opId].handler(null, parsedPayload);
            break;
          case message_types_1.default.GQL_CONNECTION_KEEP_ALIVE:
            var firstKA = typeof this.wasKeepAliveReceived === "undefined";
            this.wasKeepAliveReceived = true;
            if (firstKA) {
              this.checkConnection();
            }
            if (this.checkConnectionIntervalId) {
              clearInterval(this.checkConnectionIntervalId);
              this.checkConnection();
            }
            this.checkConnectionIntervalId = setInterval(this.checkConnection.bind(this), this.wsTimeout);
            break;
          default:
            throw new Error("Invalid message type!");
        }
      };
      SubscriptionClient2.prototype.unsubscribe = function(opId) {
        if (this.operations[opId]) {
          delete this.operations[opId];
          this.setInactivityTimeout();
          this.sendMessage(opId, message_types_1.default.GQL_STOP, void 0);
        }
      };
      return SubscriptionClient2;
    }();
    exports.SubscriptionClient = SubscriptionClient;
  }
});

export {
  require_client
};
//# sourceMappingURL=chunk-73V6KLXH.js.map