{"version":3,"sources":["webpack:///./node_modules/subscriptions-transport-ws/dist/utils/is-object.js","webpack:///./node_modules/subscriptions-transport-ws/dist/message-types.js","webpack:///./node_modules/subscriptions-transport-ws/dist/utils/is-string.js","webpack:///./node_modules/subscriptions-transport-ws/dist/client.js","webpack:///./node_modules/subscriptions-transport-ws/dist/defaults.js","webpack:///./node_modules/subscriptions-transport-ws/dist/protocol.js","webpack:///./node_modules/subscriptions-transport-ws/node_modules/eventemitter3/index.js"],"names":["isObject","value","Object","defineProperty","exports","default","MessageTypes","Error","GQL_CONNECTION_INIT","GQL_CONNECTION_ACK","GQL_CONNECTION_ERROR","GQL_CONNECTION_KEEP_ALIVE","GQL_CONNECTION_TERMINATE","GQL_START","GQL_DATA","GQL_ERROR","GQL_COMPLETE","GQL_STOP","SUBSCRIPTION_START","SUBSCRIPTION_DATA","SUBSCRIPTION_SUCCESS","SUBSCRIPTION_FAIL","SUBSCRIPTION_END","INIT","INIT_SUCCESS","INIT_FAIL","KEEP_ALIVE","isString","__assign","this","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","__generator","body","f","y","g","_","label","sent","trys","ops","verb","Symbol","iterator","v","op","TypeError","pop","push","__spreadArrays","il","r","Array","k","a","j","jl","SubscriptionClient","_global","global","window","NativeWebSocket","WebSocket","MozWebSocket","Backoff","eventemitter3_1","is_string_1","is_object_1","printer_1","getOperationAST_1","symbol_observable_1","protocol_1","defaults_1","message_types_1","url","options","webSocketImpl","webSocketProtocols","_a","_b","connectionCallback","undefined","_c","connectionParams","_d","minTimeout","MIN_WS_TIMEOUT","_e","timeout","WS_TIMEOUT","_f","reconnect","_g","reconnectionAttempts","Infinity","_h","lazy","_j","inactivityTimeout","_k","wsOptionArguments","wsImpl","wsProtocols","GRAPHQL_WS","operations","nextOperationId","minWsTimeout","wsTimeout","unsentMessagesQueue","reconnecting","closedByUser","backoff","jitter","eventEmitter","EventEmitter","middlewares","client","maxConnectTimeGenerator","createMaxConnectTimeGenerator","getConnectionParams","connect","get","CLOSED","readyState","enumerable","configurable","close","isForced","clearInactivityTimeout","clearCheckConnectionInterval","clearMaxConnectTimeout","clearTryReconnectTimeout","unsubscribeAll","sendMessage","onopen","onclose","onerror","onmessage","emit","tryReconnect","request","opId","getObserver","bind","executeOperation","unsubscribe","subscribe","observerOrNext","onError","onComplete","observer","error","complete","on","eventName","callback","context","handler","off","onConnected","onConnecting","onDisconnected","onReconnected","onReconnecting","_this","keys","forEach","subId","applyMiddlewares","queue","funcs","scope","shift","applyMiddleware","use","map","middleware","generateOperationId","processedOptions","checkOperationOptions","catch","formatErrors","minValue","maxValue","min","max","factor","checkConnectionIntervalId","clearInterval","maxConnectTimeoutId","clearTimeout","tryReconnectTimeoutId","inactivityTimeoutId","setInactivityTimeout","setTimeout","query","variables","operationName","getOperationAST","buildMessage","id","type","payload","payloadToReturn","print","errors","isArray","message","name","originalError","sendMessageRaw","status","OPEN","serializedMessage","JSON","stringify","parse","send","CONNECTING","String","attempts","key","delay","duration","flushUnsentMessagesQueue","checkConnection","wasKeepAliveReceived","checkMaxConnectTimeout","error_1","err","data","processReceivedData","receivedData","parsedMessage","indexOf","reset","parsedPayload","firstKA","setInterval","GRAPHQL_SUBSCRIPTIONS","has","prefix","Events","EE","fn","once","addListener","emitter","event","listener","evt","_events","_eventsCount","clearEvent","create","__proto__","eventNames","events","names","slice","getOwnPropertySymbols","concat","listeners","handlers","l","ee","listenerCount","a1","a2","a3","a4","a5","args","len","removeListener","removeAllListeners","prefixed","module"],"mappings":"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","file":"js/npm.subscriptions-transport-ws~9efe256e.b744ec76.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction isObject(value) {\n    return ((value !== null) && (typeof value === 'object'));\n}\nexports.default = isObject;\n//# sourceMappingURL=is-object.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar MessageTypes = (function () {\n    function MessageTypes() {\n        throw new Error('Static Class');\n    }\n    MessageTypes.GQL_CONNECTION_INIT = 'connection_init';\n    MessageTypes.GQL_CONNECTION_ACK = 'connection_ack';\n    MessageTypes.GQL_CONNECTION_ERROR = 'connection_error';\n    MessageTypes.GQL_CONNECTION_KEEP_ALIVE = 'ka';\n    MessageTypes.GQL_CONNECTION_TERMINATE = 'connection_terminate';\n    MessageTypes.GQL_START = 'start';\n    MessageTypes.GQL_DATA = 'data';\n    MessageTypes.GQL_ERROR = 'error';\n    MessageTypes.GQL_COMPLETE = 'complete';\n    MessageTypes.GQL_STOP = 'stop';\n    MessageTypes.SUBSCRIPTION_START = 'subscription_start';\n    MessageTypes.SUBSCRIPTION_DATA = 'subscription_data';\n    MessageTypes.SUBSCRIPTION_SUCCESS = 'subscription_success';\n    MessageTypes.SUBSCRIPTION_FAIL = 'subscription_fail';\n    MessageTypes.SUBSCRIPTION_END = 'subscription_end';\n    MessageTypes.INIT = 'init';\n    MessageTypes.INIT_SUCCESS = 'init_success';\n    MessageTypes.INIT_FAIL = 'init_fail';\n    MessageTypes.KEEP_ALIVE = 'keepalive';\n    return MessageTypes;\n}());\nexports.default = MessageTypes;\n//# sourceMappingURL=message-types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction isString(value) {\n    return typeof value === 'string';\n}\nexports.default = isString;\n//# sourceMappingURL=is-string.js.map","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            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;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n            r[k] = a[j];\n    return r;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SubscriptionClient = void 0;\nvar _global = typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : {});\nvar NativeWebSocket = _global.WebSocket || _global.MozWebSocket;\nvar Backoff = require(\"backo2\");\nvar eventemitter3_1 = require(\"eventemitter3\");\nvar is_string_1 = require(\"./utils/is-string\");\nvar is_object_1 = require(\"./utils/is-object\");\nvar printer_1 = require(\"graphql/language/printer\");\nvar getOperationAST_1 = require(\"graphql/utilities/getOperationAST\");\nvar symbol_observable_1 = require(\"symbol-observable\");\nvar protocol_1 = require(\"./protocol\");\nvar defaults_1 = require(\"./defaults\");\nvar message_types_1 = require(\"./message-types\");\nvar SubscriptionClient = (function () {\n    function SubscriptionClient(url, options, webSocketImpl, webSocketProtocols) {\n        var _a = (options || {}), _b = _a.connectionCallback, connectionCallback = _b === void 0 ? undefined : _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;\n        this.wsImpl = webSocketImpl || NativeWebSocket;\n        if (!this.wsImpl) {\n            throw new Error('Unable to find native implementation, or alternative implementation for WebSocket!');\n        }\n        this.wsProtocols = webSocketProtocols || protocol_1.GRAPHQL_WS;\n        this.connectionCallback = connectionCallback;\n        this.url = url;\n        this.operations = {};\n        this.nextOperationId = 0;\n        this.minWsTimeout = minTimeout;\n        this.wsTimeout = timeout;\n        this.unsentMessagesQueue = [];\n        this.reconnect = reconnect;\n        this.reconnecting = false;\n        this.reconnectionAttempts = reconnectionAttempts;\n        this.lazy = !!lazy;\n        this.inactivityTimeout = inactivityTimeout;\n        this.closedByUser = false;\n        this.backoff = new Backoff({ jitter: 0.5 });\n        this.eventEmitter = new eventemitter3_1.EventEmitter();\n        this.middlewares = [];\n        this.client = null;\n        this.maxConnectTimeGenerator = this.createMaxConnectTimeGenerator();\n        this.connectionParams = this.getConnectionParams(connectionParams);\n        this.wsOptionArguments = wsOptionArguments;\n        if (!this.lazy) {\n            this.connect();\n        }\n    }\n    Object.defineProperty(SubscriptionClient.prototype, \"status\", {\n        get: function () {\n            if (this.client === null) {\n                return this.wsImpl.CLOSED;\n            }\n            return this.client.readyState;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    SubscriptionClient.prototype.close = function (isForced, closedByUser) {\n        if (isForced === void 0) { isForced = true; }\n        if (closedByUser === void 0) { closedByUser = true; }\n        this.clearInactivityTimeout();\n        if (this.client !== null) {\n            this.closedByUser = closedByUser;\n            if (isForced) {\n                this.clearCheckConnectionInterval();\n                this.clearMaxConnectTimeout();\n                this.clearTryReconnectTimeout();\n                this.unsubscribeAll();\n                this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_TERMINATE, null);\n            }\n            this.client.close();\n            this.client.onopen = null;\n            this.client.onclose = null;\n            this.client.onerror = null;\n            this.client.onmessage = null;\n            this.client = null;\n            this.eventEmitter.emit('disconnected');\n            if (!isForced) {\n                this.tryReconnect();\n            }\n        }\n    };\n    SubscriptionClient.prototype.request = function (request) {\n        var _a;\n        var getObserver = this.getObserver.bind(this);\n        var executeOperation = this.executeOperation.bind(this);\n        var unsubscribe = this.unsubscribe.bind(this);\n        var opId;\n        this.clearInactivityTimeout();\n        return _a = {},\n            _a[symbol_observable_1.default] = function () {\n                return this;\n            },\n            _a.subscribe = function (observerOrNext, onError, onComplete) {\n                var observer = getObserver(observerOrNext, onError, onComplete);\n                opId = executeOperation(request, function (error, result) {\n                    if (error === null && result === null) {\n                        if (observer.complete) {\n                            observer.complete();\n                        }\n                    }\n                    else if (error) {\n                        if (observer.error) {\n                            observer.error(error[0]);\n                        }\n                    }\n                    else {\n                        if (observer.next) {\n                            observer.next(result);\n                        }\n                    }\n                });\n                return {\n                    unsubscribe: function () {\n                        if (opId) {\n                            unsubscribe(opId);\n                            opId = null;\n                        }\n                    },\n                };\n            },\n            _a;\n    };\n    SubscriptionClient.prototype.on = function (eventName, callback, context) {\n        var handler = this.eventEmitter.on(eventName, callback, context);\n        return function () {\n            handler.off(eventName, callback, context);\n        };\n    };\n    SubscriptionClient.prototype.onConnected = function (callback, context) {\n        return this.on('connected', callback, context);\n    };\n    SubscriptionClient.prototype.onConnecting = function (callback, context) {\n        return this.on('connecting', callback, context);\n    };\n    SubscriptionClient.prototype.onDisconnected = function (callback, context) {\n        return this.on('disconnected', callback, context);\n    };\n    SubscriptionClient.prototype.onReconnected = function (callback, context) {\n        return this.on('reconnected', callback, context);\n    };\n    SubscriptionClient.prototype.onReconnecting = function (callback, context) {\n        return this.on('reconnecting', callback, context);\n    };\n    SubscriptionClient.prototype.onError = function (callback, context) {\n        return this.on('error', callback, context);\n    };\n    SubscriptionClient.prototype.unsubscribeAll = function () {\n        var _this = this;\n        Object.keys(this.operations).forEach(function (subId) {\n            _this.unsubscribe(subId);\n        });\n    };\n    SubscriptionClient.prototype.applyMiddlewares = function (options) {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var queue = function (funcs, scope) {\n                var next = function (error) {\n                    if (error) {\n                        reject(error);\n                    }\n                    else {\n                        if (funcs.length > 0) {\n                            var f = funcs.shift();\n                            if (f) {\n                                f.applyMiddleware.apply(scope, [options, next]);\n                            }\n                        }\n                        else {\n                            resolve(options);\n                        }\n                    }\n                };\n                next();\n            };\n            queue(__spreadArrays(_this.middlewares), _this);\n        });\n    };\n    SubscriptionClient.prototype.use = function (middlewares) {\n        var _this = this;\n        middlewares.map(function (middleware) {\n            if (typeof middleware.applyMiddleware === 'function') {\n                _this.middlewares.push(middleware);\n            }\n            else {\n                throw new Error('Middleware must implement the applyMiddleware function.');\n            }\n        });\n        return this;\n    };\n    SubscriptionClient.prototype.getConnectionParams = function (connectionParams) {\n        return function () { return new Promise(function (resolve, reject) {\n            if (typeof connectionParams === 'function') {\n                try {\n                    return resolve(connectionParams.call(null));\n                }\n                catch (error) {\n                    return reject(error);\n                }\n            }\n            resolve(connectionParams);\n        }); };\n    };\n    SubscriptionClient.prototype.executeOperation = function (options, handler) {\n        var _this = this;\n        if (this.client === null) {\n            this.connect();\n        }\n        var opId = this.generateOperationId();\n        this.operations[opId] = { options: options, handler: handler };\n        this.applyMiddlewares(options)\n            .then(function (processedOptions) {\n            _this.checkOperationOptions(processedOptions, handler);\n            if (_this.operations[opId]) {\n                _this.operations[opId] = { options: processedOptions, handler: handler };\n                _this.sendMessage(opId, message_types_1.default.GQL_START, processedOptions);\n            }\n        })\n            .catch(function (error) {\n            _this.unsubscribe(opId);\n            handler(_this.formatErrors(error));\n        });\n        return opId;\n    };\n    SubscriptionClient.prototype.getObserver = function (observerOrNext, error, complete) {\n        if (typeof observerOrNext === 'function') {\n            return {\n                next: function (v) { return observerOrNext(v); },\n                error: function (e) { return error && error(e); },\n                complete: function () { return complete && complete(); },\n            };\n        }\n        return observerOrNext;\n    };\n    SubscriptionClient.prototype.createMaxConnectTimeGenerator = function () {\n        var minValue = this.minWsTimeout;\n        var maxValue = this.wsTimeout;\n        return new Backoff({\n            min: minValue,\n            max: maxValue,\n            factor: 1.2,\n        });\n    };\n    SubscriptionClient.prototype.clearCheckConnectionInterval = function () {\n        if (this.checkConnectionIntervalId) {\n            clearInterval(this.checkConnectionIntervalId);\n            this.checkConnectionIntervalId = null;\n        }\n    };\n    SubscriptionClient.prototype.clearMaxConnectTimeout = function () {\n        if (this.maxConnectTimeoutId) {\n            clearTimeout(this.maxConnectTimeoutId);\n            this.maxConnectTimeoutId = null;\n        }\n    };\n    SubscriptionClient.prototype.clearTryReconnectTimeout = function () {\n        if (this.tryReconnectTimeoutId) {\n            clearTimeout(this.tryReconnectTimeoutId);\n            this.tryReconnectTimeoutId = null;\n        }\n    };\n    SubscriptionClient.prototype.clearInactivityTimeout = function () {\n        if (this.inactivityTimeoutId) {\n            clearTimeout(this.inactivityTimeoutId);\n            this.inactivityTimeoutId = null;\n        }\n    };\n    SubscriptionClient.prototype.setInactivityTimeout = function () {\n        var _this = this;\n        if (this.inactivityTimeout > 0 && Object.keys(this.operations).length === 0) {\n            this.inactivityTimeoutId = setTimeout(function () {\n                if (Object.keys(_this.operations).length === 0) {\n                    _this.close();\n                }\n            }, this.inactivityTimeout);\n        }\n    };\n    SubscriptionClient.prototype.checkOperationOptions = function (options, handler) {\n        var query = options.query, variables = options.variables, operationName = options.operationName;\n        if (!query) {\n            throw new Error('Must provide a query.');\n        }\n        if (!handler) {\n            throw new Error('Must provide an handler.');\n        }\n        if ((!is_string_1.default(query) && !getOperationAST_1.getOperationAST(query, operationName)) ||\n            (operationName && !is_string_1.default(operationName)) ||\n            (variables && !is_object_1.default(variables))) {\n            throw new Error('Incorrect option types. query must be a string or a document,' +\n                '`operationName` must be a string, and `variables` must be an object.');\n        }\n    };\n    SubscriptionClient.prototype.buildMessage = function (id, type, payload) {\n        var payloadToReturn = payload && payload.query ? __assign(__assign({}, payload), { query: typeof payload.query === 'string' ? payload.query : printer_1.print(payload.query) }) :\n            payload;\n        return {\n            id: id,\n            type: type,\n            payload: payloadToReturn,\n        };\n    };\n    SubscriptionClient.prototype.formatErrors = function (errors) {\n        if (Array.isArray(errors)) {\n            return errors;\n        }\n        if (errors && errors.errors) {\n            return this.formatErrors(errors.errors);\n        }\n        if (errors && errors.message) {\n            return [errors];\n        }\n        return [{\n                name: 'FormatedError',\n                message: 'Unknown error',\n                originalError: errors,\n            }];\n    };\n    SubscriptionClient.prototype.sendMessage = function (id, type, payload) {\n        this.sendMessageRaw(this.buildMessage(id, type, payload));\n    };\n    SubscriptionClient.prototype.sendMessageRaw = function (message) {\n        switch (this.status) {\n            case this.wsImpl.OPEN:\n                var serializedMessage = JSON.stringify(message);\n                try {\n                    JSON.parse(serializedMessage);\n                }\n                catch (e) {\n                    this.eventEmitter.emit('error', new Error(\"Message must be JSON-serializable. Got: \" + message));\n                }\n                this.client.send(serializedMessage);\n                break;\n            case this.wsImpl.CONNECTING:\n                this.unsentMessagesQueue.push(message);\n                break;\n            default:\n                if (!this.reconnecting) {\n                    this.eventEmitter.emit('error', new Error('A message was not sent because socket is not connected, is closing or ' +\n                        'is already closed. Message was: ' + JSON.stringify(message)));\n                }\n        }\n    };\n    SubscriptionClient.prototype.generateOperationId = function () {\n        return String(++this.nextOperationId);\n    };\n    SubscriptionClient.prototype.tryReconnect = function () {\n        var _this = this;\n        if (!this.reconnect || this.backoff.attempts >= this.reconnectionAttempts) {\n            return;\n        }\n        if (!this.reconnecting) {\n            Object.keys(this.operations).forEach(function (key) {\n                _this.unsentMessagesQueue.push(_this.buildMessage(key, message_types_1.default.GQL_START, _this.operations[key].options));\n            });\n            this.reconnecting = true;\n        }\n        this.clearTryReconnectTimeout();\n        var delay = this.backoff.duration();\n        this.tryReconnectTimeoutId = setTimeout(function () {\n            _this.connect();\n        }, delay);\n    };\n    SubscriptionClient.prototype.flushUnsentMessagesQueue = function () {\n        var _this = this;\n        this.unsentMessagesQueue.forEach(function (message) {\n            _this.sendMessageRaw(message);\n        });\n        this.unsentMessagesQueue = [];\n    };\n    SubscriptionClient.prototype.checkConnection = function () {\n        if (this.wasKeepAliveReceived) {\n            this.wasKeepAliveReceived = false;\n            return;\n        }\n        if (!this.reconnecting) {\n            this.close(false, true);\n        }\n    };\n    SubscriptionClient.prototype.checkMaxConnectTimeout = function () {\n        var _this = this;\n        this.clearMaxConnectTimeout();\n        this.maxConnectTimeoutId = setTimeout(function () {\n            if (_this.status !== _this.wsImpl.OPEN) {\n                _this.reconnecting = true;\n                _this.close(false, true);\n            }\n        }, this.maxConnectTimeGenerator.duration());\n    };\n    SubscriptionClient.prototype.connect = function () {\n        var _a;\n        var _this = this;\n        this.client = new ((_a = this.wsImpl).bind.apply(_a, __spreadArrays([void 0, this.url, this.wsProtocols], this.wsOptionArguments)))();\n        this.checkMaxConnectTimeout();\n        this.client.onopen = function () { return __awaiter(_this, void 0, void 0, function () {\n            var connectionParams, error_1;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!(this.status === this.wsImpl.OPEN)) return [3, 4];\n                        this.clearMaxConnectTimeout();\n                        this.closedByUser = false;\n                        this.eventEmitter.emit(this.reconnecting ? 'reconnecting' : 'connecting');\n                        _a.label = 1;\n                    case 1:\n                        _a.trys.push([1, 3, , 4]);\n                        return [4, this.connectionParams()];\n                    case 2:\n                        connectionParams = _a.sent();\n                        this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_INIT, connectionParams);\n                        this.flushUnsentMessagesQueue();\n                        return [3, 4];\n                    case 3:\n                        error_1 = _a.sent();\n                        this.sendMessage(undefined, message_types_1.default.GQL_CONNECTION_ERROR, error_1);\n                        this.flushUnsentMessagesQueue();\n                        return [3, 4];\n                    case 4: return [2];\n                }\n            });\n        }); };\n        this.client.onclose = function () {\n            if (!_this.closedByUser) {\n                _this.close(false, false);\n            }\n        };\n        this.client.onerror = function (err) {\n            _this.eventEmitter.emit('error', err);\n        };\n        this.client.onmessage = function (_a) {\n            var data = _a.data;\n            _this.processReceivedData(data);\n        };\n    };\n    SubscriptionClient.prototype.processReceivedData = function (receivedData) {\n        var parsedMessage;\n        var opId;\n        try {\n            parsedMessage = JSON.parse(receivedData);\n            opId = parsedMessage.id;\n        }\n        catch (e) {\n            throw new Error(\"Message must be JSON-parseable. Got: \" + receivedData);\n        }\n        if ([message_types_1.default.GQL_DATA,\n            message_types_1.default.GQL_COMPLETE,\n            message_types_1.default.GQL_ERROR,\n        ].indexOf(parsedMessage.type) !== -1 && !this.operations[opId]) {\n            this.unsubscribe(opId);\n            return;\n        }\n        switch (parsedMessage.type) {\n            case message_types_1.default.GQL_CONNECTION_ERROR:\n                if (this.connectionCallback) {\n                    this.connectionCallback(parsedMessage.payload);\n                }\n                break;\n            case message_types_1.default.GQL_CONNECTION_ACK:\n                this.eventEmitter.emit(this.reconnecting ? 'reconnected' : 'connected', parsedMessage.payload);\n                this.reconnecting = false;\n                this.backoff.reset();\n                this.maxConnectTimeGenerator.reset();\n                if (this.connectionCallback) {\n                    this.connectionCallback();\n                }\n                break;\n            case message_types_1.default.GQL_COMPLETE:\n                var handler = this.operations[opId].handler;\n                delete this.operations[opId];\n                handler.call(this, null, null);\n                break;\n            case message_types_1.default.GQL_ERROR:\n                this.operations[opId].handler(this.formatErrors(parsedMessage.payload), null);\n                delete this.operations[opId];\n                break;\n            case message_types_1.default.GQL_DATA:\n                var parsedPayload = !parsedMessage.payload.errors ?\n                    parsedMessage.payload : __assign(__assign({}, parsedMessage.payload), { errors: this.formatErrors(parsedMessage.payload.errors) });\n                this.operations[opId].handler(null, parsedPayload);\n                break;\n            case message_types_1.default.GQL_CONNECTION_KEEP_ALIVE:\n                var firstKA = typeof this.wasKeepAliveReceived === 'undefined';\n                this.wasKeepAliveReceived = true;\n                if (firstKA) {\n                    this.checkConnection();\n                }\n                if (this.checkConnectionIntervalId) {\n                    clearInterval(this.checkConnectionIntervalId);\n                    this.checkConnection();\n                }\n                this.checkConnectionIntervalId = setInterval(this.checkConnection.bind(this), this.wsTimeout);\n                break;\n            default:\n                throw new Error('Invalid message type!');\n        }\n    };\n    SubscriptionClient.prototype.unsubscribe = function (opId) {\n        if (this.operations[opId]) {\n            delete this.operations[opId];\n            this.setInactivityTimeout();\n            this.sendMessage(opId, message_types_1.default.GQL_STOP, undefined);\n        }\n    };\n    return SubscriptionClient;\n}());\nexports.SubscriptionClient = SubscriptionClient;\n//# sourceMappingURL=client.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WS_TIMEOUT = exports.MIN_WS_TIMEOUT = void 0;\nvar MIN_WS_TIMEOUT = 1000;\nexports.MIN_WS_TIMEOUT = MIN_WS_TIMEOUT;\nvar WS_TIMEOUT = 30000;\nexports.WS_TIMEOUT = WS_TIMEOUT;\n//# sourceMappingURL=defaults.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GRAPHQL_SUBSCRIPTIONS = exports.GRAPHQL_WS = void 0;\nvar GRAPHQL_WS = 'graphql-ws';\nexports.GRAPHQL_WS = GRAPHQL_WS;\nvar GRAPHQL_SUBSCRIPTIONS = 'graphql-subscriptions';\nexports.GRAPHQL_SUBSCRIPTIONS = GRAPHQL_SUBSCRIPTIONS;\n//# sourceMappingURL=protocol.js.map","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\n}\n"],"sourceRoot":""}