{"version":3,"file":"86f47dc3db165d044fab.bundle.js","mappings":"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","sources":["webpack://spartner/./node_modules/@10d/tend-ui-notifications/node_modules/centrifuge/build/index.js","webpack://spartner/./node_modules/@10d/tend-ui-notifications/node_modules/classnames/index.js"],"sourcesContent":["'use strict';\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol */\r\n\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\ntypeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\n\nfunction getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nvar events = {exports: {}};\n\nvar R = typeof Reflect === 'object' ? Reflect : null;\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  };\n\nvar ReflectOwnKeys;\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys;\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n};\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nevents.exports = EventEmitter;\nevents.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    }\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n\nvar eventsExports = events.exports;\nvar EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);\n\nexports.errorCodes = void 0;\n(function (errorCodes) {\n    errorCodes[errorCodes[\"timeout\"] = 1] = \"timeout\";\n    errorCodes[errorCodes[\"transportClosed\"] = 2] = \"transportClosed\";\n    errorCodes[errorCodes[\"clientDisconnected\"] = 3] = \"clientDisconnected\";\n    errorCodes[errorCodes[\"clientClosed\"] = 4] = \"clientClosed\";\n    errorCodes[errorCodes[\"clientConnectToken\"] = 5] = \"clientConnectToken\";\n    errorCodes[errorCodes[\"clientRefreshToken\"] = 6] = \"clientRefreshToken\";\n    errorCodes[errorCodes[\"subscriptionUnsubscribed\"] = 7] = \"subscriptionUnsubscribed\";\n    errorCodes[errorCodes[\"subscriptionSubscribeToken\"] = 8] = \"subscriptionSubscribeToken\";\n    errorCodes[errorCodes[\"subscriptionRefreshToken\"] = 9] = \"subscriptionRefreshToken\";\n    errorCodes[errorCodes[\"transportWriteError\"] = 10] = \"transportWriteError\";\n    errorCodes[errorCodes[\"connectionClosed\"] = 11] = \"connectionClosed\";\n    errorCodes[errorCodes[\"badConfiguration\"] = 12] = \"badConfiguration\";\n})(exports.errorCodes || (exports.errorCodes = {}));\nexports.connectingCodes = void 0;\n(function (connectingCodes) {\n    connectingCodes[connectingCodes[\"connectCalled\"] = 0] = \"connectCalled\";\n    connectingCodes[connectingCodes[\"transportClosed\"] = 1] = \"transportClosed\";\n    connectingCodes[connectingCodes[\"noPing\"] = 2] = \"noPing\";\n    connectingCodes[connectingCodes[\"subscribeTimeout\"] = 3] = \"subscribeTimeout\";\n    connectingCodes[connectingCodes[\"unsubscribeError\"] = 4] = \"unsubscribeError\";\n})(exports.connectingCodes || (exports.connectingCodes = {}));\nexports.disconnectedCodes = void 0;\n(function (disconnectedCodes) {\n    disconnectedCodes[disconnectedCodes[\"disconnectCalled\"] = 0] = \"disconnectCalled\";\n    disconnectedCodes[disconnectedCodes[\"unauthorized\"] = 1] = \"unauthorized\";\n    disconnectedCodes[disconnectedCodes[\"badProtocol\"] = 2] = \"badProtocol\";\n    disconnectedCodes[disconnectedCodes[\"messageSizeLimit\"] = 3] = \"messageSizeLimit\";\n})(exports.disconnectedCodes || (exports.disconnectedCodes = {}));\nexports.subscribingCodes = void 0;\n(function (subscribingCodes) {\n    subscribingCodes[subscribingCodes[\"subscribeCalled\"] = 0] = \"subscribeCalled\";\n    subscribingCodes[subscribingCodes[\"transportClosed\"] = 1] = \"transportClosed\";\n})(exports.subscribingCodes || (exports.subscribingCodes = {}));\nexports.unsubscribedCodes = void 0;\n(function (unsubscribedCodes) {\n    unsubscribedCodes[unsubscribedCodes[\"unsubscribeCalled\"] = 0] = \"unsubscribeCalled\";\n    unsubscribedCodes[unsubscribedCodes[\"unauthorized\"] = 1] = \"unauthorized\";\n    unsubscribedCodes[unsubscribedCodes[\"clientClosed\"] = 2] = \"clientClosed\";\n})(exports.unsubscribedCodes || (exports.unsubscribedCodes = {}));\n\n/** State of client. */\nexports.State = void 0;\n(function (State) {\n    State[\"Disconnected\"] = \"disconnected\";\n    State[\"Connecting\"] = \"connecting\";\n    State[\"Connected\"] = \"connected\";\n})(exports.State || (exports.State = {}));\n/** State of Subscription */\nexports.SubscriptionState = void 0;\n(function (SubscriptionState) {\n    SubscriptionState[\"Unsubscribed\"] = \"unsubscribed\";\n    SubscriptionState[\"Subscribing\"] = \"subscribing\";\n    SubscriptionState[\"Subscribed\"] = \"subscribed\";\n})(exports.SubscriptionState || (exports.SubscriptionState = {}));\n\n/** @internal */\nfunction startsWith(value, prefix) {\n    return value.lastIndexOf(prefix, 0) === 0;\n}\n/** @internal */\nfunction isFunction(value) {\n    if (value === undefined || value === null) {\n        return false;\n    }\n    return typeof value === 'function';\n}\n/** @internal */\nfunction log(level, args) {\n    if (globalThis.console) {\n        const logger = globalThis.console[level];\n        if (isFunction(logger)) {\n            logger.apply(globalThis.console, args);\n        }\n    }\n}\nfunction randomInt(min, max) {\n    return Math.floor(Math.random() * (max - min + 1) + min);\n}\n/** @internal */\nfunction backoff(step, min, max) {\n    // Full jitter technique, see:\n    // https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/\n    if (step > 31) {\n        step = 31;\n    }\n    const interval = randomInt(0, Math.min(max, min * Math.pow(2, step)));\n    return Math.min(max, min + interval);\n}\n/** @internal */\nfunction errorExists(data) {\n    return 'error' in data && data.error !== null;\n}\n/** @internal */\nfunction ttlMilliseconds(ttl) {\n    // https://stackoverflow.com/questions/12633405/what-is-the-maximum-delay-for-setinterval\n    return Math.min(ttl * 1000, 2147483647);\n}\n\n/** Subscription to a channel */\nclass Subscription extends EventEmitter$1 {\n    /** Subscription constructor should not be used directly, create subscriptions using Client method. */\n    constructor(centrifuge, channel, options) {\n        super();\n        this._resubscribeTimeout = null;\n        this._refreshTimeout = null;\n        this.channel = channel;\n        this.state = exports.SubscriptionState.Unsubscribed;\n        this._centrifuge = centrifuge;\n        this._token = '';\n        this._getToken = null;\n        this._data = null;\n        this._getData = null;\n        this._recover = false;\n        this._offset = null;\n        this._epoch = null;\n        this._recoverable = false;\n        this._positioned = false;\n        this._joinLeave = false;\n        this._minResubscribeDelay = 500;\n        this._maxResubscribeDelay = 20000;\n        this._resubscribeTimeout = null;\n        this._resubscribeAttempts = 0;\n        this._promises = {};\n        this._promiseId = 0;\n        this._inflight = false;\n        this._refreshTimeout = null;\n        this._delta = '';\n        this._delta_negotiated = false;\n        this._prevValue = null;\n        this._unsubPromise = Promise.resolve();\n        this._setOptions(options);\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        if (this._centrifuge._debugEnabled) {\n            this.on('state', (ctx) => {\n                // @ts-ignore – we are hiding some symbols from public API autocompletion.\n                this._centrifuge._debug('subscription state', channel, ctx.oldState, '->', ctx.newState);\n            });\n            this.on('error', (ctx) => {\n                // @ts-ignore – we are hiding some symbols from public API autocompletion.\n                this._centrifuge._debug('subscription error', channel, ctx);\n            });\n        }\n        else {\n            // Avoid unhandled exception in EventEmitter for non-set error handler.\n            this.on('error', function () { Function.prototype(); });\n        }\n    }\n    /** ready returns a Promise which resolves upon subscription goes to Subscribed\n     * state and rejects in case of subscription goes to Unsubscribed state.\n     * Optional timeout can be passed.*/\n    ready(timeout) {\n        if (this.state === exports.SubscriptionState.Unsubscribed) {\n            return Promise.reject({ code: exports.errorCodes.subscriptionUnsubscribed, message: this.state });\n        }\n        if (this.state === exports.SubscriptionState.Subscribed) {\n            return Promise.resolve();\n        }\n        return new Promise((res, rej) => {\n            const ctx = {\n                resolve: res,\n                reject: rej\n            };\n            if (timeout) {\n                ctx.timeout = setTimeout(function () {\n                    rej({ code: exports.errorCodes.timeout, message: 'timeout' });\n                }, timeout);\n            }\n            this._promises[this._nextPromiseId()] = ctx;\n        });\n    }\n    /** subscribe to a channel.*/\n    subscribe() {\n        if (this._isSubscribed()) {\n            return;\n        }\n        this._resubscribeAttempts = 0;\n        this._setSubscribing(exports.subscribingCodes.subscribeCalled, 'subscribe called');\n    }\n    /** unsubscribe from a channel, keeping position state.*/\n    unsubscribe() {\n        this._unsubPromise = this._setUnsubscribed(exports.unsubscribedCodes.unsubscribeCalled, 'unsubscribe called', true);\n    }\n    /** publish data to a channel.*/\n    publish(data) {\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._centrifuge.publish(self.channel, data);\n        });\n    }\n    /** get online presence for a channel.*/\n    presence() {\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._centrifuge.presence(self.channel);\n        });\n    }\n    /** presence stats for a channel (num clients and unique users).*/\n    presenceStats() {\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._centrifuge.presenceStats(self.channel);\n        });\n    }\n    /** history for a channel. By default it does not return publications (only current\n     *  StreamPosition data) – provide an explicit limit > 0 to load publications.*/\n    history(opts) {\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._centrifuge.history(self.channel, opts);\n        });\n    }\n    _methodCall() {\n        if (this._isSubscribed()) {\n            return Promise.resolve();\n        }\n        if (this._isUnsubscribed()) {\n            return Promise.reject({ code: exports.errorCodes.subscriptionUnsubscribed, message: this.state });\n        }\n        return new Promise((res, rej) => {\n            const timeout = setTimeout(function () {\n                rej({ code: exports.errorCodes.timeout, message: 'timeout' });\n                // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            }, this._centrifuge._config.timeout);\n            this._promises[this._nextPromiseId()] = {\n                timeout: timeout,\n                resolve: res,\n                reject: rej\n            };\n        });\n    }\n    _nextPromiseId() {\n        return ++this._promiseId;\n    }\n    _needRecover() {\n        return this._recover === true;\n    }\n    _isUnsubscribed() {\n        return this.state === exports.SubscriptionState.Unsubscribed;\n    }\n    _isSubscribing() {\n        return this.state === exports.SubscriptionState.Subscribing;\n    }\n    _isSubscribed() {\n        return this.state === exports.SubscriptionState.Subscribed;\n    }\n    _setState(newState) {\n        if (this.state !== newState) {\n            const oldState = this.state;\n            this.state = newState;\n            this.emit('state', { newState, oldState, channel: this.channel });\n            return true;\n        }\n        return false;\n    }\n    _usesToken() {\n        return this._token !== '' || this._getToken !== null;\n    }\n    _clearSubscribingState() {\n        this._resubscribeAttempts = 0;\n        this._clearResubscribeTimeout();\n    }\n    _clearSubscribedState() {\n        this._clearRefreshTimeout();\n    }\n    _setSubscribed(result) {\n        if (!this._isSubscribing()) {\n            return;\n        }\n        this._clearSubscribingState();\n        if (result.recoverable) {\n            this._recover = true;\n            this._offset = result.offset || 0;\n            this._epoch = result.epoch || '';\n        }\n        if (result.delta) {\n            this._delta_negotiated = true;\n        }\n        else {\n            this._delta_negotiated = false;\n        }\n        this._setState(exports.SubscriptionState.Subscribed);\n        // @ts-ignore – we are hiding some methods from public API autocompletion.\n        const ctx = this._centrifuge._getSubscribeContext(this.channel, result);\n        this.emit('subscribed', ctx);\n        this._resolvePromises();\n        const pubs = result.publications;\n        if (pubs && pubs.length > 0) {\n            for (const i in pubs) {\n                if (!pubs.hasOwnProperty(i)) {\n                    continue;\n                }\n                this._handlePublication(pubs[i]);\n            }\n        }\n        if (result.expires === true) {\n            this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));\n        }\n    }\n    _setSubscribing(code, reason) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (this._isSubscribing()) {\n                return;\n            }\n            if (this._isSubscribed()) {\n                this._clearSubscribedState();\n            }\n            if (this._setState(exports.SubscriptionState.Subscribing)) {\n                this.emit('subscribing', { channel: this.channel, code: code, reason: reason });\n            }\n            // @ts-ignore – for performance reasons only await _unsubPromise for emulution case where it's required.\n            if (this._centrifuge._transport && this._centrifuge._transport.emulation()) {\n                yield this._unsubPromise;\n            }\n            if (!this._isSubscribing()) {\n                return;\n            }\n            this._subscribe();\n        });\n    }\n    _subscribe() {\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        this._centrifuge._debug('subscribing on', this.channel);\n        // need to check transport readiness here, because there's no point for calling getData or getToken\n        // if transport is not ready yet\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        if (!this._centrifuge._transportIsOpen) {\n            // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            this._centrifuge._debug('delay subscribe on', this.channel, 'till connected');\n            // subscribe will be called later automatically.\n            return null;\n        }\n        const self = this;\n        const getDataCtx = {\n            channel: self.channel\n        };\n        if (!this._usesToken() || this._token) {\n            if (self._getData) {\n                self._getData(getDataCtx).then(function (data) {\n                    if (!self._isSubscribing()) {\n                        return;\n                    }\n                    self._data = data;\n                    self._sendSubscribe(self._token);\n                });\n                return null;\n            }\n            else {\n                return self._sendSubscribe(self._token);\n            }\n        }\n        this._getSubscriptionToken().then(function (token) {\n            if (!self._isSubscribing()) {\n                return;\n            }\n            if (!token) {\n                self._failUnauthorized();\n                return;\n            }\n            self._token = token;\n            if (self._getData) {\n                self._getData(getDataCtx).then(function (data) {\n                    if (!self._isSubscribing()) {\n                        return;\n                    }\n                    self._data = data;\n                    self._sendSubscribe(token);\n                });\n            }\n            else {\n                self._sendSubscribe(token);\n            }\n        }).catch(function (e) {\n            if (!self._isSubscribing()) {\n                return;\n            }\n            if (e instanceof UnauthorizedError) {\n                self._failUnauthorized();\n                return;\n            }\n            self.emit('error', {\n                type: 'subscribeToken',\n                channel: self.channel,\n                error: {\n                    code: exports.errorCodes.subscriptionSubscribeToken,\n                    message: e !== undefined ? e.toString() : ''\n                }\n            });\n            self._scheduleResubscribe();\n        });\n        return null;\n    }\n    _sendSubscribe(token) {\n        // we also need to check for transport state before sending subscription\n        // because it may change for subscription with side effects (getData, getToken options)\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        if (!this._centrifuge._transportIsOpen) {\n            return null;\n        }\n        const channel = this.channel;\n        const req = {\n            channel: channel\n        };\n        if (token) {\n            req.token = token;\n        }\n        if (this._data) {\n            req.data = this._data;\n        }\n        if (this._positioned) {\n            req.positioned = true;\n        }\n        if (this._recoverable) {\n            req.recoverable = true;\n        }\n        if (this._joinLeave) {\n            req.join_leave = true;\n        }\n        if (this._needRecover()) {\n            req.recover = true;\n            const offset = this._getOffset();\n            if (offset) {\n                req.offset = offset;\n            }\n            const epoch = this._getEpoch();\n            if (epoch) {\n                req.epoch = epoch;\n            }\n        }\n        if (this._delta) {\n            req.delta = this._delta;\n        }\n        const cmd = { subscribe: req };\n        this._inflight = true;\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        this._centrifuge._call(cmd).then(resolveCtx => {\n            this._inflight = false;\n            // @ts-ignore - improve later.\n            const result = resolveCtx.reply.subscribe;\n            this._handleSubscribeResponse(result);\n            // @ts-ignore - improve later.\n            if (resolveCtx.next) {\n                // @ts-ignore - improve later.\n                resolveCtx.next();\n            }\n        }, rejectCtx => {\n            this._inflight = false;\n            this._handleSubscribeError(rejectCtx.error);\n            if (rejectCtx.next) {\n                rejectCtx.next();\n            }\n        });\n        return cmd;\n    }\n    _handleSubscribeError(error) {\n        if (!this._isSubscribing()) {\n            return;\n        }\n        if (error.code === exports.errorCodes.timeout) {\n            // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            this._centrifuge._disconnect(exports.connectingCodes.subscribeTimeout, 'subscribe timeout', true);\n            return;\n        }\n        this._subscribeError(error);\n    }\n    _handleSubscribeResponse(result) {\n        if (!this._isSubscribing()) {\n            return;\n        }\n        this._setSubscribed(result);\n    }\n    _setUnsubscribed(code, reason, sendUnsubscribe) {\n        if (this._isUnsubscribed()) {\n            return Promise.resolve();\n        }\n        let promise = Promise.resolve();\n        if (this._isSubscribed()) {\n            if (sendUnsubscribe) {\n                // @ts-ignore – we are hiding some methods from public API autocompletion.\n                promise = this._centrifuge._unsubscribe(this);\n            }\n            this._clearSubscribedState();\n        }\n        else if (this._isSubscribing()) {\n            if (this._inflight && sendUnsubscribe) {\n                // @ts-ignore – we are hiding some methods from public API autocompletion.\n                promise = this._centrifuge._unsubscribe(this);\n            }\n            this._clearSubscribingState();\n        }\n        if (this._setState(exports.SubscriptionState.Unsubscribed)) {\n            this.emit('unsubscribed', { channel: this.channel, code: code, reason: reason });\n        }\n        this._rejectPromises({ code: exports.errorCodes.subscriptionUnsubscribed, message: this.state });\n        return promise;\n    }\n    _handlePublication(pub) {\n        if (this._delta && this._delta_negotiated) {\n            // @ts-ignore – we are hiding some methods from public API autocompletion.\n            const { newData, newPrevValue } = this._centrifuge._codec.applyDeltaIfNeeded(pub, this._prevValue);\n            pub.data = newData;\n            this._prevValue = newPrevValue;\n        }\n        // @ts-ignore – we are hiding some methods from public API autocompletion.\n        const ctx = this._centrifuge._getPublicationContext(this.channel, pub);\n        this.emit('publication', ctx);\n        if (pub.offset) {\n            this._offset = pub.offset;\n        }\n    }\n    _handleJoin(join) {\n        // @ts-ignore – we are hiding some methods from public API autocompletion.\n        const info = this._centrifuge._getJoinLeaveContext(join.info);\n        this.emit('join', { channel: this.channel, info: info });\n    }\n    _handleLeave(leave) {\n        // @ts-ignore – we are hiding some methods from public API autocompletion.\n        const info = this._centrifuge._getJoinLeaveContext(leave.info);\n        this.emit('leave', { channel: this.channel, info: info });\n    }\n    _resolvePromises() {\n        for (const id in this._promises) {\n            if (!this._promises.hasOwnProperty(id)) {\n                continue;\n            }\n            if (this._promises[id].timeout) {\n                clearTimeout(this._promises[id].timeout);\n            }\n            this._promises[id].resolve();\n            delete this._promises[id];\n        }\n    }\n    _rejectPromises(err) {\n        for (const id in this._promises) {\n            if (!this._promises.hasOwnProperty(id)) {\n                continue;\n            }\n            if (this._promises[id].timeout) {\n                clearTimeout(this._promises[id].timeout);\n            }\n            this._promises[id].reject(err);\n            delete this._promises[id];\n        }\n    }\n    _scheduleResubscribe() {\n        const self = this;\n        const delay = this._getResubscribeDelay();\n        this._resubscribeTimeout = setTimeout(function () {\n            if (self._isSubscribing()) {\n                self._subscribe();\n            }\n        }, delay);\n    }\n    _subscribeError(err) {\n        if (!this._isSubscribing()) {\n            return;\n        }\n        if (err.code < 100 || err.code === 109 || err.temporary === true) {\n            if (err.code === 109) { // Token expired error.\n                this._token = '';\n            }\n            const errContext = {\n                channel: this.channel,\n                type: 'subscribe',\n                error: err\n            };\n            if (this._centrifuge.state === exports.State.Connected) {\n                this.emit('error', errContext);\n            }\n            this._scheduleResubscribe();\n        }\n        else {\n            this._setUnsubscribed(err.code, err.message, false);\n        }\n    }\n    _getResubscribeDelay() {\n        const delay = backoff(this._resubscribeAttempts, this._minResubscribeDelay, this._maxResubscribeDelay);\n        this._resubscribeAttempts++;\n        return delay;\n    }\n    _setOptions(options) {\n        if (!options) {\n            return;\n        }\n        if (options.since) {\n            this._offset = options.since.offset;\n            this._epoch = options.since.epoch;\n            this._recover = true;\n        }\n        if (options.data) {\n            this._data = options.data;\n        }\n        if (options.getData) {\n            this._getData = options.getData;\n        }\n        if (options.minResubscribeDelay !== undefined) {\n            this._minResubscribeDelay = options.minResubscribeDelay;\n        }\n        if (options.maxResubscribeDelay !== undefined) {\n            this._maxResubscribeDelay = options.maxResubscribeDelay;\n        }\n        if (options.token) {\n            this._token = options.token;\n        }\n        if (options.getToken) {\n            this._getToken = options.getToken;\n        }\n        if (options.positioned === true) {\n            this._positioned = true;\n        }\n        if (options.recoverable === true) {\n            this._recoverable = true;\n        }\n        if (options.joinLeave === true) {\n            this._joinLeave = true;\n        }\n        if (options.delta) {\n            if (options.delta !== 'fossil') {\n                throw new Error('unsupported delta format');\n            }\n            this._delta = options.delta;\n        }\n    }\n    _getOffset() {\n        const offset = this._offset;\n        if (offset !== null) {\n            return offset;\n        }\n        return 0;\n    }\n    _getEpoch() {\n        const epoch = this._epoch;\n        if (epoch !== null) {\n            return epoch;\n        }\n        return '';\n    }\n    _clearRefreshTimeout() {\n        if (this._refreshTimeout !== null) {\n            clearTimeout(this._refreshTimeout);\n            this._refreshTimeout = null;\n        }\n    }\n    _clearResubscribeTimeout() {\n        if (this._resubscribeTimeout !== null) {\n            clearTimeout(this._resubscribeTimeout);\n            this._resubscribeTimeout = null;\n        }\n    }\n    _getSubscriptionToken() {\n        // @ts-ignore – we are hiding some methods from public API autocompletion.\n        this._centrifuge._debug('get subscription token for channel', this.channel);\n        const ctx = {\n            channel: this.channel\n        };\n        const getToken = this._getToken;\n        if (getToken === null) {\n            this.emit('error', {\n                type: 'configuration',\n                channel: this.channel,\n                error: {\n                    code: exports.errorCodes.badConfiguration,\n                    message: 'provide a function to get channel subscription token'\n                }\n            });\n            throw new UnauthorizedError('');\n        }\n        return getToken(ctx);\n    }\n    _refresh() {\n        this._clearRefreshTimeout();\n        const self = this;\n        this._getSubscriptionToken().then(function (token) {\n            if (!self._isSubscribed()) {\n                return;\n            }\n            if (!token) {\n                self._failUnauthorized();\n                return;\n            }\n            self._token = token;\n            const req = {\n                channel: self.channel,\n                token: token\n            };\n            const msg = {\n                'sub_refresh': req\n            };\n            // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            self._centrifuge._call(msg).then(resolveCtx => {\n                // @ts-ignore - improve later.\n                const result = resolveCtx.reply.sub_refresh;\n                self._refreshResponse(result);\n                // @ts-ignore - improve later.\n                if (resolveCtx.next) {\n                    // @ts-ignore - improve later.\n                    resolveCtx.next();\n                }\n            }, rejectCtx => {\n                self._refreshError(rejectCtx.error);\n                if (rejectCtx.next) {\n                    rejectCtx.next();\n                }\n            });\n        }).catch(function (e) {\n            if (e instanceof UnauthorizedError) {\n                self._failUnauthorized();\n                return;\n            }\n            self.emit('error', {\n                type: 'refreshToken',\n                channel: self.channel,\n                error: {\n                    code: exports.errorCodes.subscriptionRefreshToken,\n                    message: e !== undefined ? e.toString() : ''\n                }\n            });\n            self._refreshTimeout = setTimeout(() => self._refresh(), self._getRefreshRetryDelay());\n        });\n    }\n    _refreshResponse(result) {\n        if (!this._isSubscribed()) {\n            return;\n        }\n        // @ts-ignore – we are hiding some methods from public API autocompletion.\n        this._centrifuge._debug('subscription token refreshed, channel', this.channel);\n        this._clearRefreshTimeout();\n        if (result.expires === true) {\n            this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));\n        }\n    }\n    _refreshError(err) {\n        if (!this._isSubscribed()) {\n            return;\n        }\n        if (err.code < 100 || err.temporary === true) {\n            this.emit('error', {\n                type: 'refresh',\n                channel: this.channel,\n                error: err\n            });\n            this._refreshTimeout = setTimeout(() => this._refresh(), this._getRefreshRetryDelay());\n        }\n        else {\n            this._setUnsubscribed(err.code, err.message, true);\n        }\n    }\n    _getRefreshRetryDelay() {\n        return backoff(0, 10000, 20000);\n    }\n    _failUnauthorized() {\n        this._setUnsubscribed(exports.unsubscribedCodes.unauthorized, 'unauthorized', true);\n    }\n}\n\n/** @internal */\nclass SockjsTransport {\n    constructor(endpoint, options) {\n        this.endpoint = endpoint;\n        this.options = options;\n        this._transport = null;\n    }\n    name() {\n        return 'sockjs';\n    }\n    subName() {\n        return 'sockjs-' + this._transport.transport;\n    }\n    emulation() {\n        return false;\n    }\n    supported() {\n        return this.options.sockjs !== null;\n    }\n    initialize(_protocol, callbacks) {\n        this._transport = new this.options.sockjs(this.endpoint, null, this.options.sockjsOptions);\n        this._transport.onopen = () => {\n            callbacks.onOpen();\n        };\n        this._transport.onerror = e => {\n            callbacks.onError(e);\n        };\n        this._transport.onclose = closeEvent => {\n            callbacks.onClose(closeEvent);\n        };\n        this._transport.onmessage = event => {\n            callbacks.onMessage(event.data);\n        };\n    }\n    close() {\n        this._transport.close();\n    }\n    send(data) {\n        this._transport.send(data);\n    }\n}\n\n/** @internal */\nclass WebsocketTransport {\n    constructor(endpoint, options) {\n        this.endpoint = endpoint;\n        this.options = options;\n        this._transport = null;\n    }\n    name() {\n        return 'websocket';\n    }\n    subName() {\n        return 'websocket';\n    }\n    emulation() {\n        return false;\n    }\n    supported() {\n        return this.options.websocket !== undefined && this.options.websocket !== null;\n    }\n    initialize(protocol, callbacks) {\n        let subProtocol = '';\n        if (protocol === 'protobuf') {\n            subProtocol = 'centrifuge-protobuf';\n        }\n        if (subProtocol !== '') {\n            this._transport = new this.options.websocket(this.endpoint, subProtocol);\n        }\n        else {\n            this._transport = new this.options.websocket(this.endpoint);\n        }\n        if (protocol === 'protobuf') {\n            this._transport.binaryType = 'arraybuffer';\n        }\n        this._transport.onopen = () => {\n            callbacks.onOpen();\n        };\n        this._transport.onerror = e => {\n            callbacks.onError(e);\n        };\n        this._transport.onclose = closeEvent => {\n            callbacks.onClose(closeEvent);\n        };\n        this._transport.onmessage = event => {\n            callbacks.onMessage(event.data);\n        };\n    }\n    close() {\n        this._transport.close();\n    }\n    send(data) {\n        this._transport.send(data);\n    }\n}\n\n/** @internal */\nclass HttpStreamTransport {\n    constructor(endpoint, options) {\n        this.endpoint = endpoint;\n        this.options = options;\n        this._abortController = null;\n        this._utf8decoder = new TextDecoder();\n        this._protocol = 'json';\n    }\n    name() {\n        return 'http_stream';\n    }\n    subName() {\n        return 'http_stream';\n    }\n    emulation() {\n        return true;\n    }\n    _handleErrors(response) {\n        if (!response.ok)\n            throw new Error(response.status);\n        return response;\n    }\n    _fetchEventTarget(self, endpoint, options) {\n        const eventTarget = new EventTarget();\n        // fetch with connection timeout maybe? https://github.com/github/fetch/issues/175\n        const fetchFunc = self.options.fetch;\n        fetchFunc(endpoint, options)\n            .then(self._handleErrors)\n            .then(response => {\n            eventTarget.dispatchEvent(new Event('open'));\n            let jsonStreamBuf = '';\n            let jsonStreamPos = 0;\n            let protoStreamBuf = new Uint8Array();\n            const reader = response.body.getReader();\n            return new self.options.readableStream({\n                start(controller) {\n                    function pump() {\n                        return reader.read().then(({ done, value }) => {\n                            // When no more data needs to be consumed, close the stream\n                            if (done) {\n                                eventTarget.dispatchEvent(new Event('close'));\n                                controller.close();\n                                return;\n                            }\n                            try {\n                                if (self._protocol === 'json') {\n                                    jsonStreamBuf += self._utf8decoder.decode(value);\n                                    while (jsonStreamPos < jsonStreamBuf.length) {\n                                        if (jsonStreamBuf[jsonStreamPos] === '\\n') {\n                                            const line = jsonStreamBuf.substring(0, jsonStreamPos);\n                                            eventTarget.dispatchEvent(new MessageEvent('message', { data: line }));\n                                            jsonStreamBuf = jsonStreamBuf.substring(jsonStreamPos + 1);\n                                            jsonStreamPos = 0;\n                                        }\n                                        else {\n                                            ++jsonStreamPos;\n                                        }\n                                    }\n                                }\n                                else {\n                                    const mergedArray = new Uint8Array(protoStreamBuf.length + value.length);\n                                    mergedArray.set(protoStreamBuf);\n                                    mergedArray.set(value, protoStreamBuf.length);\n                                    protoStreamBuf = mergedArray;\n                                    while (true) {\n                                        const result = self.options.decoder.decodeReply(protoStreamBuf);\n                                        if (result.ok) {\n                                            const data = protoStreamBuf.slice(0, result.pos);\n                                            eventTarget.dispatchEvent(new MessageEvent('message', { data: data }));\n                                            protoStreamBuf = protoStreamBuf.slice(result.pos);\n                                            continue;\n                                        }\n                                        break;\n                                    }\n                                }\n                            }\n                            catch (error) {\n                                // @ts-ignore - improve later.\n                                eventTarget.dispatchEvent(new Event('error', { detail: error }));\n                                eventTarget.dispatchEvent(new Event('close'));\n                                controller.close();\n                                return;\n                            }\n                            pump();\n                        }).catch(function (e) {\n                            // @ts-ignore - improve later.\n                            eventTarget.dispatchEvent(new Event('error', { detail: e }));\n                            eventTarget.dispatchEvent(new Event('close'));\n                            controller.close();\n                            return;\n                        });\n                    }\n                    return pump();\n                }\n            });\n        })\n            .catch(error => {\n            // @ts-ignore - improve later.\n            eventTarget.dispatchEvent(new Event('error', { detail: error }));\n            eventTarget.dispatchEvent(new Event('close'));\n        });\n        return eventTarget;\n    }\n    supported() {\n        return this.options.fetch !== null &&\n            this.options.readableStream !== null &&\n            typeof TextDecoder !== 'undefined' &&\n            typeof AbortController !== 'undefined' &&\n            typeof EventTarget !== 'undefined' &&\n            typeof Event !== 'undefined' &&\n            typeof MessageEvent !== 'undefined' &&\n            typeof Error !== 'undefined';\n    }\n    initialize(protocol, callbacks, initialData) {\n        this._protocol = protocol;\n        this._abortController = new AbortController();\n        let headers;\n        let body;\n        if (protocol === 'json') {\n            headers = {\n                'Accept': 'application/json',\n                'Content-Type': 'application/json'\n            };\n            body = initialData;\n        }\n        else {\n            headers = {\n                'Accept': 'application/octet-stream',\n                'Content-Type': 'application/octet-stream'\n            };\n            body = initialData;\n        }\n        const fetchOptions = {\n            method: 'POST',\n            headers: headers,\n            body: body,\n            mode: 'cors',\n            credentials: 'same-origin',\n            cache: 'no-cache',\n            signal: this._abortController.signal\n        };\n        const eventTarget = this._fetchEventTarget(this, this.endpoint, fetchOptions);\n        eventTarget.addEventListener('open', () => {\n            callbacks.onOpen();\n        });\n        eventTarget.addEventListener('error', (e) => {\n            this._abortController.abort();\n            callbacks.onError(e);\n        });\n        eventTarget.addEventListener('close', () => {\n            this._abortController.abort();\n            callbacks.onClose({\n                code: 4,\n                reason: 'connection closed'\n            });\n        });\n        eventTarget.addEventListener('message', (e) => {\n            callbacks.onMessage(e.data);\n        });\n    }\n    close() {\n        this._abortController.abort();\n    }\n    send(data, session, node) {\n        let headers;\n        let body;\n        const req = {\n            session: session,\n            node: node,\n            data: data\n        };\n        if (this._protocol === 'json') {\n            headers = {\n                'Content-Type': 'application/json'\n            };\n            body = JSON.stringify(req);\n        }\n        else {\n            headers = {\n                'Content-Type': 'application/octet-stream'\n            };\n            body = this.options.encoder.encodeEmulationRequest(req);\n        }\n        const fetchFunc = this.options.fetch;\n        const fetchOptions = {\n            method: 'POST',\n            headers: headers,\n            body: body,\n            mode: 'cors',\n            credentials: 'same-origin',\n            cache: 'no-cache'\n        };\n        fetchFunc(this.options.emulationEndpoint, fetchOptions);\n    }\n}\n\n/** @internal */\nclass SseTransport {\n    constructor(endpoint, options) {\n        this.endpoint = endpoint;\n        this.options = options;\n        this._protocol = 'json';\n        this._transport = null;\n        this._onClose = null;\n    }\n    name() {\n        return 'sse';\n    }\n    subName() {\n        return 'sse';\n    }\n    emulation() {\n        return true;\n    }\n    supported() {\n        return this.options.eventsource !== null && this.options.fetch !== null;\n    }\n    initialize(_protocol, callbacks, initialData) {\n        let url;\n        if (globalThis && globalThis.document && globalThis.document.baseURI) {\n            // Handle case when endpoint is relative, like //example.com/connection/sse\n            url = new URL(this.endpoint, globalThis.document.baseURI);\n        }\n        else {\n            url = new URL(this.endpoint);\n        }\n        url.searchParams.append('cf_connect', initialData);\n        const eventsourceOptions = {};\n        const eventSource = new this.options.eventsource(url.toString(), eventsourceOptions);\n        this._transport = eventSource;\n        const self = this;\n        eventSource.onopen = function () {\n            callbacks.onOpen();\n        };\n        eventSource.onerror = function (e) {\n            eventSource.close();\n            callbacks.onError(e);\n            callbacks.onClose({\n                code: 4,\n                reason: 'connection closed'\n            });\n        };\n        eventSource.onmessage = function (e) {\n            callbacks.onMessage(e.data);\n        };\n        self._onClose = function () {\n            callbacks.onClose({\n                code: 4,\n                reason: 'connection closed'\n            });\n        };\n    }\n    close() {\n        this._transport.close();\n        if (this._onClose !== null) {\n            this._onClose();\n        }\n    }\n    send(data, session, node) {\n        const req = {\n            session: session,\n            node: node,\n            data: data\n        };\n        const headers = {\n            'Content-Type': 'application/json'\n        };\n        const body = JSON.stringify(req);\n        const fetchFunc = this.options.fetch;\n        const fetchOptions = {\n            method: 'POST',\n            headers: headers,\n            body: body,\n            mode: 'cors',\n            credentials: 'same-origin',\n            cache: 'no-cache'\n        };\n        fetchFunc(this.options.emulationEndpoint, fetchOptions);\n    }\n}\n\n/** @internal */\nclass WebtransportTransport {\n    constructor(endpoint, options) {\n        this.endpoint = endpoint;\n        this.options = options;\n        this._transport = null;\n        this._stream = null;\n        this._writer = null;\n        this._utf8decoder = new TextDecoder();\n        this._protocol = 'json';\n    }\n    name() {\n        return 'webtransport';\n    }\n    subName() {\n        return 'webtransport';\n    }\n    emulation() {\n        return false;\n    }\n    supported() {\n        return this.options.webtransport !== undefined && this.options.webtransport !== null;\n    }\n    initialize(protocol, callbacks) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let url;\n            if (globalThis && globalThis.document && globalThis.document.baseURI) {\n                // Handle case when endpoint is relative, like //example.com/connection/webtransport\n                url = new URL(this.endpoint, globalThis.document.baseURI);\n            }\n            else {\n                url = new URL(this.endpoint);\n            }\n            if (protocol === 'protobuf') {\n                url.searchParams.append('cf_protocol', 'protobuf');\n            }\n            this._protocol = protocol;\n            const eventTarget = new EventTarget();\n            this._transport = new this.options.webtransport(url.toString());\n            this._transport.closed.then(() => {\n                callbacks.onClose({\n                    code: 4,\n                    reason: 'connection closed'\n                });\n            }).catch(() => {\n                callbacks.onClose({\n                    code: 4,\n                    reason: 'connection closed'\n                });\n            });\n            try {\n                yield this._transport.ready;\n            }\n            catch (_a) {\n                this.close();\n                return;\n            }\n            let stream;\n            try {\n                stream = yield this._transport.createBidirectionalStream();\n            }\n            catch (_b) {\n                this.close();\n                return;\n            }\n            this._stream = stream;\n            this._writer = this._stream.writable.getWriter();\n            eventTarget.addEventListener('close', () => {\n                callbacks.onClose({\n                    code: 4,\n                    reason: 'connection closed'\n                });\n            });\n            eventTarget.addEventListener('message', (e) => {\n                callbacks.onMessage(e.data);\n            });\n            this._startReading(eventTarget);\n            callbacks.onOpen();\n        });\n    }\n    _startReading(eventTarget) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const reader = this._stream.readable.getReader();\n            let jsonStreamBuf = '';\n            let jsonStreamPos = 0;\n            let protoStreamBuf = new Uint8Array();\n            try {\n                while (true) {\n                    const { done, value } = yield reader.read();\n                    if (value.length > 0) {\n                        if (this._protocol === 'json') {\n                            jsonStreamBuf += this._utf8decoder.decode(value);\n                            while (jsonStreamPos < jsonStreamBuf.length) {\n                                if (jsonStreamBuf[jsonStreamPos] === '\\n') {\n                                    const line = jsonStreamBuf.substring(0, jsonStreamPos);\n                                    eventTarget.dispatchEvent(new MessageEvent('message', { data: line }));\n                                    jsonStreamBuf = jsonStreamBuf.substring(jsonStreamPos + 1);\n                                    jsonStreamPos = 0;\n                                }\n                                else {\n                                    ++jsonStreamPos;\n                                }\n                            }\n                        }\n                        else {\n                            const mergedArray = new Uint8Array(protoStreamBuf.length + value.length);\n                            mergedArray.set(protoStreamBuf);\n                            mergedArray.set(value, protoStreamBuf.length);\n                            protoStreamBuf = mergedArray;\n                            while (true) {\n                                const result = this.options.decoder.decodeReply(protoStreamBuf);\n                                if (result.ok) {\n                                    const data = protoStreamBuf.slice(0, result.pos);\n                                    eventTarget.dispatchEvent(new MessageEvent('message', { data: data }));\n                                    protoStreamBuf = protoStreamBuf.slice(result.pos);\n                                    continue;\n                                }\n                                break;\n                            }\n                        }\n                    }\n                    if (done) {\n                        break;\n                    }\n                }\n            }\n            catch (_a) {\n                eventTarget.dispatchEvent(new Event('close'));\n            }\n        });\n    }\n    close() {\n        return __awaiter(this, void 0, void 0, function* () {\n            try {\n                if (this._writer) {\n                    yield this._writer.close();\n                }\n                this._transport.close();\n            }\n            catch (e) {\n                // already closed.\n            }\n        });\n    }\n    send(data) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let binary;\n            if (this._protocol === 'json') {\n                // Need extra \\n since WT is non-frame protocol. \n                binary = new TextEncoder().encode(data + '\\n');\n            }\n            else {\n                binary = data;\n            }\n            try {\n                yield this._writer.write(binary);\n            }\n            catch (e) {\n                this.close();\n            }\n        });\n    }\n}\n\n/*\nCopyright 2014-2024 Dmitry Chestnykh (JavaScript port)\nCopyright 2007 D. Richard Hipp  (original C version)\n\nFossil SCM delta compression algorithm, this is only the applyDelta part extracted\nfrom https://github.com/dchest/fossil-delta-js. The code was slightly modified\nto strip unnecessary parts. The copyright on top of this file is from the original\nrepo on Github licensed under Simplified BSD License.\n*/\nconst zValue = [\n    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1,\n    -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n    24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, 36, -1, 37,\n    38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,\n    57, 58, 59, 60, 61, 62, -1, -1, -1, 63, -1,\n];\n// Reader reads bytes, chars, ints from array.\nclass Reader {\n    constructor(array) {\n        this.a = array; // source array\n        this.pos = 0; // current position in array\n    }\n    haveBytes() {\n        return this.pos < this.a.length;\n    }\n    getByte() {\n        const b = this.a[this.pos];\n        this.pos++;\n        if (this.pos > this.a.length)\n            throw new RangeError(\"out of bounds\");\n        return b;\n    }\n    getChar() {\n        return String.fromCharCode(this.getByte());\n    }\n    // Read base64-encoded unsigned integer.\n    getInt() {\n        let v = 0;\n        let c;\n        while (this.haveBytes() && (c = zValue[0x7f & this.getByte()]) >= 0) {\n            v = (v << 6) + c;\n        }\n        this.pos--;\n        return v >>> 0;\n    }\n}\n// Write writes an array.\nclass Writer {\n    constructor() {\n        this.a = [];\n    }\n    toByteArray(sourceType) {\n        if (Array.isArray(sourceType)) {\n            return this.a;\n        }\n        return new Uint8Array(this.a);\n    }\n    // Copy from array at start to end.\n    putArray(a, start, end) {\n        // TODO: optimize.\n        for (let i = start; i < end; i++)\n            this.a.push(a[i]);\n    }\n}\n// Return a 32-bit checksum of the array.\nfunction checksum(arr) {\n    let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, z = 0, N = arr.length;\n    //TODO measure if this unrolling is helpful.\n    while (N >= 16) {\n        sum0 = (sum0 + arr[z + 0]) | 0;\n        sum1 = (sum1 + arr[z + 1]) | 0;\n        sum2 = (sum2 + arr[z + 2]) | 0;\n        sum3 = (sum3 + arr[z + 3]) | 0;\n        sum0 = (sum0 + arr[z + 4]) | 0;\n        sum1 = (sum1 + arr[z + 5]) | 0;\n        sum2 = (sum2 + arr[z + 6]) | 0;\n        sum3 = (sum3 + arr[z + 7]) | 0;\n        sum0 = (sum0 + arr[z + 8]) | 0;\n        sum1 = (sum1 + arr[z + 9]) | 0;\n        sum2 = (sum2 + arr[z + 10]) | 0;\n        sum3 = (sum3 + arr[z + 11]) | 0;\n        sum0 = (sum0 + arr[z + 12]) | 0;\n        sum1 = (sum1 + arr[z + 13]) | 0;\n        sum2 = (sum2 + arr[z + 14]) | 0;\n        sum3 = (sum3 + arr[z + 15]) | 0;\n        z += 16;\n        N -= 16;\n    }\n    while (N >= 4) {\n        sum0 = (sum0 + arr[z + 0]) | 0;\n        sum1 = (sum1 + arr[z + 1]) | 0;\n        sum2 = (sum2 + arr[z + 2]) | 0;\n        sum3 = (sum3 + arr[z + 3]) | 0;\n        z += 4;\n        N -= 4;\n    }\n    sum3 = (((((sum3 + (sum2 << 8)) | 0) + (sum1 << 16)) | 0) + (sum0 << 24)) | 0;\n    switch (N) {\n        //@ts-ignore fallthrough is needed.\n        case 3:\n            sum3 = (sum3 + (arr[z + 2] << 8)) | 0; /* falls through */\n        //@ts-ignore fallthrough is needed.\n        case 2:\n            sum3 = (sum3 + (arr[z + 1] << 16)) | 0; /* falls through */\n        case 1:\n            sum3 = (sum3 + (arr[z + 0] << 24)) | 0; /* falls through */\n    }\n    return sum3 >>> 0;\n}\n/**\n * Apply a delta byte array to a source byte array, returning the target byte array.\n */\nfunction applyDelta(source, delta) {\n    let total = 0;\n    const zDelta = new Reader(delta);\n    const lenSrc = source.length;\n    const lenDelta = delta.length;\n    const limit = zDelta.getInt();\n    if (zDelta.getChar() !== \"\\n\")\n        throw new Error(\"size integer not terminated by '\\\\n'\");\n    const zOut = new Writer();\n    while (zDelta.haveBytes()) {\n        const cnt = zDelta.getInt();\n        let ofst;\n        switch (zDelta.getChar()) {\n            case \"@\":\n                ofst = zDelta.getInt();\n                if (zDelta.haveBytes() && zDelta.getChar() !== \",\")\n                    throw new Error(\"copy command not terminated by ','\");\n                total += cnt;\n                if (total > limit)\n                    throw new Error(\"copy exceeds output file size\");\n                if (ofst + cnt > lenSrc)\n                    throw new Error(\"copy extends past end of input\");\n                zOut.putArray(source, ofst, ofst + cnt);\n                break;\n            case \":\":\n                total += cnt;\n                if (total > limit)\n                    throw new Error(\"insert command gives an output larger than predicted\");\n                if (cnt > lenDelta)\n                    throw new Error(\"insert count exceeds size of delta\");\n                zOut.putArray(zDelta.a, zDelta.pos, zDelta.pos + cnt);\n                zDelta.pos += cnt;\n                break;\n            case \";\":\n                {\n                    const out = zOut.toByteArray(source);\n                    if (cnt !== checksum(out))\n                        throw new Error(\"bad checksum\");\n                    if (total !== limit)\n                        throw new Error(\"generated size does not match predicted size\");\n                    return out;\n                }\n            default:\n                throw new Error(\"unknown delta operator\");\n        }\n    }\n    throw new Error(\"unterminated delta\");\n}\n\n/** @internal */\nclass JsonCodec {\n    name() {\n        return 'json';\n    }\n    encodeCommands(commands) {\n        return commands.map(c => JSON.stringify(c)).join('\\n');\n    }\n    decodeReplies(data) {\n        return data.trim().split('\\n').map(r => JSON.parse(r));\n    }\n    applyDeltaIfNeeded(pub, prevValue) {\n        let newData, newPrevValue;\n        if (pub.delta) {\n            // JSON string delta.\n            const valueArray = applyDelta(prevValue, new TextEncoder().encode(pub.data));\n            newData = JSON.parse(new TextDecoder().decode(valueArray));\n            newPrevValue = valueArray;\n        }\n        else {\n            // Full data as JSON string.\n            newData = JSON.parse(pub.data);\n            newPrevValue = new TextEncoder().encode(pub.data);\n        }\n        return { newData, newPrevValue };\n    }\n}\n\nconst defaults = {\n    token: '',\n    getToken: null,\n    data: null,\n    getData: null,\n    debug: false,\n    name: 'js',\n    version: '',\n    fetch: null,\n    readableStream: null,\n    websocket: null,\n    eventsource: null,\n    sockjs: null,\n    sockjsOptions: {},\n    emulationEndpoint: '/emulation',\n    minReconnectDelay: 500,\n    maxReconnectDelay: 20000,\n    timeout: 5000,\n    maxServerPingDelay: 10000,\n    networkEventTarget: null,\n};\nclass UnauthorizedError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = this.constructor.name;\n    }\n}\n/** Centrifuge is a Centrifuge/Centrifugo bidirectional client. */\nclass Centrifuge extends EventEmitter$1 {\n    /** Constructs Centrifuge client. Call connect() method to start connecting. */\n    constructor(endpoint, options) {\n        super();\n        this._reconnectTimeout = null;\n        this._refreshTimeout = null;\n        this._serverPingTimeout = null;\n        this.state = exports.State.Disconnected;\n        this._transportIsOpen = false;\n        this._endpoint = endpoint;\n        this._emulation = false;\n        this._transports = [];\n        this._currentTransportIndex = 0;\n        this._triedAllTransports = false;\n        this._transportWasOpen = false;\n        this._transport = null;\n        this._transportId = 0;\n        this._deviceWentOffline = false;\n        this._transportClosed = true;\n        this._codec = new JsonCodec();\n        this._reconnecting = false;\n        this._reconnectTimeout = null;\n        this._reconnectAttempts = 0;\n        this._client = null;\n        this._session = '';\n        this._node = '';\n        this._subs = {};\n        this._serverSubs = {};\n        this._commandId = 0;\n        this._commands = [];\n        this._batching = false;\n        this._refreshRequired = false;\n        this._refreshTimeout = null;\n        this._callbacks = {};\n        this._token = '';\n        this._data = null;\n        this._dispatchPromise = Promise.resolve();\n        this._serverPing = 0;\n        this._serverPingTimeout = null;\n        this._sendPong = false;\n        this._promises = {};\n        this._promiseId = 0;\n        this._debugEnabled = false;\n        this._networkEventsSet = false;\n        this._config = Object.assign(Object.assign({}, defaults), options);\n        this._configure();\n        if (this._debugEnabled) {\n            this.on('state', (ctx) => {\n                this._debug('client state', ctx.oldState, '->', ctx.newState);\n            });\n            this.on('error', (ctx) => {\n                this._debug('client error', ctx);\n            });\n        }\n        else {\n            // Avoid unhandled exception in EventEmitter for non-set error handler.\n            this.on('error', function () { Function.prototype(); });\n        }\n    }\n    /** newSubscription allocates new Subscription to a channel. Since server only allows\n     * one subscription per channel per client this method throws if client already has\n     * channel subscription in internal registry.\n     * */\n    newSubscription(channel, options) {\n        if (this.getSubscription(channel) !== null) {\n            throw new Error('Subscription to the channel ' + channel + ' already exists');\n        }\n        const sub = new Subscription(this, channel, options);\n        this._subs[channel] = sub;\n        return sub;\n    }\n    /** getSubscription returns Subscription if it's registered in the internal\n     * registry or null. */\n    getSubscription(channel) {\n        return this._getSub(channel);\n    }\n    /** removeSubscription allows removing Subcription from the internal registry. Subscrption\n     * must be in unsubscribed state. */\n    removeSubscription(sub) {\n        if (!sub) {\n            return;\n        }\n        if (sub.state !== exports.SubscriptionState.Unsubscribed) {\n            sub.unsubscribe();\n        }\n        this._removeSubscription(sub);\n    }\n    /** Get a map with all current client-side subscriptions. */\n    subscriptions() {\n        return this._subs;\n    }\n    /** ready returns a Promise which resolves upon client goes to Connected\n     * state and rejects in case of client goes to Disconnected or Failed state.\n     * Users can provide optional timeout in milliseconds. */\n    ready(timeout) {\n        if (this.state === exports.State.Disconnected) {\n            return Promise.reject({ code: exports.errorCodes.clientDisconnected, message: 'client disconnected' });\n        }\n        if (this.state === exports.State.Connected) {\n            return Promise.resolve();\n        }\n        return new Promise((res, rej) => {\n            const ctx = {\n                resolve: res,\n                reject: rej\n            };\n            if (timeout) {\n                ctx.timeout = setTimeout(function () {\n                    rej({ code: exports.errorCodes.timeout, message: 'timeout' });\n                }, timeout);\n            }\n            this._promises[this._nextPromiseId()] = ctx;\n        });\n    }\n    /** connect to a server. */\n    connect() {\n        if (this._isConnected()) {\n            this._debug('connect called when already connected');\n            return;\n        }\n        if (this._isConnecting()) {\n            this._debug('connect called when already connecting');\n            return;\n        }\n        this._debug('connect called');\n        this._reconnectAttempts = 0;\n        this._startConnecting();\n    }\n    /** disconnect from a server. */\n    disconnect() {\n        this._disconnect(exports.disconnectedCodes.disconnectCalled, 'disconnect called', false);\n    }\n    /** setToken allows setting connection token. Or resetting used token to be empty.  */\n    setToken(token) {\n        this._token = token;\n    }\n    /** send asynchronous data to a server (without any response from a server\n     * expected, see rpc method if you need response). */\n    send(data) {\n        const cmd = {\n            send: {\n                data: data\n            }\n        };\n        const self = this;\n        return this._methodCall().then(function () {\n            const sent = self._transportSendCommands([cmd]); // can send message to server without id set\n            if (!sent) {\n                return Promise.reject(self._createErrorObject(exports.errorCodes.transportWriteError, 'transport write error'));\n            }\n            return Promise.resolve();\n        });\n    }\n    /** rpc to a server - i.e. a call which waits for a response with data. */\n    rpc(method, data) {\n        const cmd = {\n            rpc: {\n                method: method,\n                data: data\n            }\n        };\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._callPromise(cmd, function (reply) {\n                return {\n                    'data': reply.rpc.data\n                };\n            });\n        });\n    }\n    /** publish data to a channel. */\n    publish(channel, data) {\n        const cmd = {\n            publish: {\n                channel: channel,\n                data: data\n            }\n        };\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._callPromise(cmd, function () {\n                return {};\n            });\n        });\n    }\n    /** history for a channel. By default it does not return publications (only current\n     *  StreamPosition data) – provide an explicit limit > 0 to load publications.*/\n    history(channel, options) {\n        const cmd = {\n            history: this._getHistoryRequest(channel, options)\n        };\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._callPromise(cmd, function (reply) {\n                const result = reply.history;\n                const publications = [];\n                if (result.publications) {\n                    for (let i = 0; i < result.publications.length; i++) {\n                        publications.push(self._getPublicationContext(channel, result.publications[i]));\n                    }\n                }\n                return {\n                    'publications': publications,\n                    'epoch': result.epoch || '',\n                    'offset': result.offset || 0\n                };\n            });\n        });\n    }\n    /** presence for a channel. */\n    presence(channel) {\n        const cmd = {\n            presence: {\n                channel: channel\n            }\n        };\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._callPromise(cmd, function (reply) {\n                const clients = reply.presence.presence;\n                for (const clientId in clients) {\n                    if (clients.hasOwnProperty(clientId)) {\n                        const connInfo = clients[clientId]['conn_info'];\n                        const chanInfo = clients[clientId]['chan_info'];\n                        if (connInfo) {\n                            clients[clientId].connInfo = connInfo;\n                        }\n                        if (chanInfo) {\n                            clients[clientId].chanInfo = chanInfo;\n                        }\n                    }\n                }\n                return {\n                    'clients': clients\n                };\n            });\n        });\n    }\n    /** presence stats for a channel. */\n    presenceStats(channel) {\n        const cmd = {\n            'presence_stats': {\n                channel: channel\n            }\n        };\n        const self = this;\n        return this._methodCall().then(function () {\n            return self._callPromise(cmd, function (reply) {\n                const result = reply.presence_stats;\n                return {\n                    'numUsers': result.num_users,\n                    'numClients': result.num_clients\n                };\n            });\n        });\n    }\n    /** start command batching (collect into temporary buffer without sending to a server)\n     * until stopBatching called.*/\n    startBatching() {\n        // start collecting messages without sending them to Centrifuge until flush\n        // method called\n        this._batching = true;\n    }\n    /** stop batching commands and flush collected commands to the\n     * network (all in one request/frame).*/\n    stopBatching() {\n        const self = this;\n        // Why so nested? Two levels here requred to deal with promise resolving queue.\n        // In Subscription case we wait 2 futures before sending data to connection.\n        // Otherwise _batching becomes false before batching decision has a chance to be executed.\n        Promise.resolve().then(function () {\n            Promise.resolve().then(function () {\n                self._batching = false;\n                self._flush();\n            });\n        });\n    }\n    _debug(...args) {\n        if (!this._debugEnabled) {\n            return;\n        }\n        log('debug', args);\n    }\n    /** @internal */\n    _formatOverride() {\n        return;\n    }\n    _configure() {\n        if (!('Promise' in globalThis)) {\n            throw new Error('Promise polyfill required');\n        }\n        if (!this._endpoint) {\n            throw new Error('endpoint configuration required');\n        }\n        if (this._config.token !== null) {\n            this._token = this._config.token;\n        }\n        if (this._config.data !== null) {\n            this._data = this._config.data;\n        }\n        this._codec = new JsonCodec();\n        this._formatOverride();\n        if (this._config.debug === true ||\n            (typeof localStorage !== 'undefined' && localStorage.getItem('centrifuge.debug'))) {\n            this._debugEnabled = true;\n        }\n        this._debug('config', this._config);\n        if (typeof this._endpoint === 'string') ;\n        else if (typeof this._endpoint === 'object' && this._endpoint instanceof Array) {\n            this._transports = this._endpoint;\n            this._emulation = true;\n            for (const i in this._transports) {\n                if (this._transports.hasOwnProperty(i)) {\n                    const transportConfig = this._transports[i];\n                    if (!transportConfig.endpoint || !transportConfig.transport) {\n                        throw new Error('malformed transport configuration');\n                    }\n                    const transportName = transportConfig.transport;\n                    if (['websocket', 'http_stream', 'sse', 'sockjs', 'webtransport'].indexOf(transportName) < 0) {\n                        throw new Error('unsupported transport name: ' + transportName);\n                    }\n                }\n            }\n        }\n        else {\n            throw new Error('unsupported url configuration type: only string or array of objects are supported');\n        }\n    }\n    _setState(newState) {\n        if (this.state !== newState) {\n            this._reconnecting = false;\n            const oldState = this.state;\n            this.state = newState;\n            this.emit('state', { newState, oldState });\n            return true;\n        }\n        return false;\n    }\n    _isDisconnected() {\n        return this.state === exports.State.Disconnected;\n    }\n    _isConnecting() {\n        return this.state === exports.State.Connecting;\n    }\n    _isConnected() {\n        return this.state === exports.State.Connected;\n    }\n    _nextCommandId() {\n        return ++this._commandId;\n    }\n    _setNetworkEvents() {\n        if (this._networkEventsSet) {\n            return;\n        }\n        let eventTarget = null;\n        if (this._config.networkEventTarget !== null) {\n            eventTarget = this._config.networkEventTarget;\n        }\n        else if (typeof globalThis.addEventListener !== 'undefined') {\n            eventTarget = globalThis;\n        }\n        if (eventTarget) {\n            eventTarget.addEventListener('offline', () => {\n                this._debug('offline event triggered');\n                if (this.state === exports.State.Connected || this.state === exports.State.Connecting) {\n                    this._disconnect(exports.connectingCodes.transportClosed, 'transport closed', true);\n                    this._deviceWentOffline = true;\n                }\n            });\n            eventTarget.addEventListener('online', () => {\n                this._debug('online event triggered');\n                if (this.state !== exports.State.Connecting) {\n                    return;\n                }\n                if (this._deviceWentOffline && !this._transportClosed) {\n                    // This is a workaround for mobile Safari where close callback may be\n                    // not issued upon device going to the flight mode. We know for sure\n                    // that transport close was called, so we start reconnecting. In this\n                    // case if the close callback will be issued for some reason after some\n                    // time – it will be ignored due to transport ID mismatch.\n                    this._deviceWentOffline = false;\n                    this._transportClosed = true;\n                }\n                this._clearReconnectTimeout();\n                this._startReconnecting();\n            });\n            this._networkEventsSet = true;\n        }\n    }\n    _getReconnectDelay() {\n        const delay = backoff(this._reconnectAttempts, this._config.minReconnectDelay, this._config.maxReconnectDelay);\n        this._reconnectAttempts += 1;\n        return delay;\n    }\n    _clearOutgoingRequests() {\n        // fire errbacks of registered outgoing calls.\n        for (const id in this._callbacks) {\n            if (this._callbacks.hasOwnProperty(id)) {\n                const callbacks = this._callbacks[id];\n                clearTimeout(callbacks.timeout);\n                const errback = callbacks.errback;\n                if (!errback) {\n                    continue;\n                }\n                errback({ error: this._createErrorObject(exports.errorCodes.connectionClosed, 'connection closed') });\n            }\n        }\n        this._callbacks = {};\n    }\n    _clearConnectedState() {\n        this._client = null;\n        this._clearServerPingTimeout();\n        this._clearRefreshTimeout();\n        // fire events for client-side subscriptions.\n        for (const channel in this._subs) {\n            if (!this._subs.hasOwnProperty(channel)) {\n                continue;\n            }\n            const sub = this._subs[channel];\n            if (sub.state === exports.SubscriptionState.Subscribed) {\n                // @ts-ignore – we are hiding some symbols from public API autocompletion.\n                sub._setSubscribing(exports.subscribingCodes.transportClosed, 'transport closed');\n            }\n        }\n        // fire events for server-side subscriptions.\n        for (const channel in this._serverSubs) {\n            if (this._serverSubs.hasOwnProperty(channel)) {\n                this.emit('subscribing', { channel: channel });\n            }\n        }\n    }\n    _handleWriteError(commands) {\n        for (const command of commands) {\n            const id = command.id;\n            if (!(id in this._callbacks)) {\n                continue;\n            }\n            const callbacks = this._callbacks[id];\n            clearTimeout(this._callbacks[id].timeout);\n            delete this._callbacks[id];\n            const errback = callbacks.errback;\n            errback({ error: this._createErrorObject(exports.errorCodes.transportWriteError, 'transport write error') });\n        }\n    }\n    _transportSendCommands(commands) {\n        if (!commands.length) {\n            return true;\n        }\n        if (!this._transport) {\n            return false;\n        }\n        try {\n            this._transport.send(this._codec.encodeCommands(commands), this._session, this._node);\n        }\n        catch (e) {\n            this._debug('error writing commands', e);\n            this._handleWriteError(commands);\n            return false;\n        }\n        return true;\n    }\n    _initializeTransport() {\n        let websocket;\n        if (this._config.websocket !== null) {\n            websocket = this._config.websocket;\n        }\n        else {\n            if (!(typeof globalThis.WebSocket !== 'function' && typeof globalThis.WebSocket !== 'object')) {\n                websocket = globalThis.WebSocket;\n            }\n        }\n        let sockjs = null;\n        if (this._config.sockjs !== null) {\n            sockjs = this._config.sockjs;\n        }\n        else {\n            if (typeof globalThis.SockJS !== 'undefined') {\n                sockjs = globalThis.SockJS;\n            }\n        }\n        let eventsource = null;\n        if (this._config.eventsource !== null) {\n            eventsource = this._config.eventsource;\n        }\n        else {\n            if (typeof globalThis.EventSource !== 'undefined') {\n                eventsource = globalThis.EventSource;\n            }\n        }\n        let fetchFunc = null;\n        if (this._config.fetch !== null) {\n            fetchFunc = this._config.fetch;\n        }\n        else {\n            if (typeof globalThis.fetch !== 'undefined') {\n                fetchFunc = globalThis.fetch;\n            }\n        }\n        let readableStream = null;\n        if (this._config.readableStream !== null) {\n            readableStream = this._config.readableStream;\n        }\n        else {\n            if (typeof globalThis.ReadableStream !== 'undefined') {\n                readableStream = globalThis.ReadableStream;\n            }\n        }\n        if (!this._emulation) {\n            if (startsWith(this._endpoint, 'http')) {\n                throw new Error('Provide explicit transport endpoints configuration in case of using HTTP (i.e. using array of TransportEndpoint instead of a single string), or use ws(s):// scheme in an endpoint if you aimed using WebSocket transport');\n            }\n            else {\n                this._debug('client will use websocket');\n                this._transport = new WebsocketTransport(this._endpoint, {\n                    websocket: websocket\n                });\n                if (!this._transport.supported()) {\n                    throw new Error('WebSocket not available');\n                }\n            }\n        }\n        else {\n            if (this._currentTransportIndex >= this._transports.length) {\n                this._triedAllTransports = true;\n                this._currentTransportIndex = 0;\n            }\n            let count = 0;\n            while (true) {\n                if (count >= this._transports.length) {\n                    throw new Error('no supported transport found');\n                }\n                const transportConfig = this._transports[this._currentTransportIndex];\n                const transportName = transportConfig.transport;\n                const transportEndpoint = transportConfig.endpoint;\n                if (transportName === 'websocket') {\n                    this._debug('trying websocket transport');\n                    this._transport = new WebsocketTransport(transportEndpoint, {\n                        websocket: websocket\n                    });\n                    if (!this._transport.supported()) {\n                        this._debug('websocket transport not available');\n                        this._currentTransportIndex++;\n                        count++;\n                        continue;\n                    }\n                }\n                else if (transportName === 'webtransport') {\n                    this._debug('trying webtransport transport');\n                    this._transport = new WebtransportTransport(transportEndpoint, {\n                        webtransport: globalThis.WebTransport,\n                        decoder: this._codec,\n                        encoder: this._codec\n                    });\n                    if (!this._transport.supported()) {\n                        this._debug('webtransport transport not available');\n                        this._currentTransportIndex++;\n                        count++;\n                        continue;\n                    }\n                }\n                else if (transportName === 'http_stream') {\n                    this._debug('trying http_stream transport');\n                    this._transport = new HttpStreamTransport(transportEndpoint, {\n                        fetch: fetchFunc,\n                        readableStream: readableStream,\n                        emulationEndpoint: this._config.emulationEndpoint,\n                        decoder: this._codec,\n                        encoder: this._codec\n                    });\n                    if (!this._transport.supported()) {\n                        this._debug('http_stream transport not available');\n                        this._currentTransportIndex++;\n                        count++;\n                        continue;\n                    }\n                }\n                else if (transportName === 'sse') {\n                    this._debug('trying sse transport');\n                    this._transport = new SseTransport(transportEndpoint, {\n                        eventsource: eventsource,\n                        fetch: fetchFunc,\n                        emulationEndpoint: this._config.emulationEndpoint,\n                    });\n                    if (!this._transport.supported()) {\n                        this._debug('sse transport not available');\n                        this._currentTransportIndex++;\n                        count++;\n                        continue;\n                    }\n                }\n                else if (transportName === 'sockjs') {\n                    this._debug('trying sockjs');\n                    this._transport = new SockjsTransport(transportEndpoint, {\n                        sockjs: sockjs,\n                        sockjsOptions: this._config.sockjsOptions\n                    });\n                    if (!this._transport.supported()) {\n                        this._debug('sockjs transport not available');\n                        this._currentTransportIndex++;\n                        count++;\n                        continue;\n                    }\n                }\n                else {\n                    throw new Error('unknown transport ' + transportName);\n                }\n                break;\n            }\n        }\n        const self = this;\n        const transport = this._transport;\n        const transportId = this._nextTransportId();\n        self._debug(\"id of transport\", transportId);\n        let wasOpen = false;\n        const initialCommands = [];\n        if (this._transport.emulation()) {\n            const connectCommand = self._sendConnect(true);\n            initialCommands.push(connectCommand);\n        }\n        this._setNetworkEvents();\n        const initialData = this._codec.encodeCommands(initialCommands);\n        this._transportClosed = false;\n        let connectTimeout;\n        connectTimeout = setTimeout(function () {\n            transport.close();\n        }, this._config.timeout);\n        this._transport.initialize(this._codec.name(), {\n            onOpen: function () {\n                if (connectTimeout) {\n                    clearTimeout(connectTimeout);\n                    connectTimeout = null;\n                }\n                if (self._transportId != transportId) {\n                    self._debug('open callback from non-actual transport');\n                    transport.close();\n                    return;\n                }\n                wasOpen = true;\n                self._debug(transport.subName(), 'transport open');\n                if (transport.emulation()) {\n                    return;\n                }\n                self._transportIsOpen = true;\n                self._transportWasOpen = true;\n                self.startBatching();\n                self._sendConnect(false);\n                self._sendSubscribeCommands();\n                self.stopBatching();\n                //@ts-ignore must be used only for debug and test purposes. Exposed only for non-emulation transport.\n                self.emit('__centrifuge_debug:connect_frame_sent', {});\n            },\n            onError: function (e) {\n                if (self._transportId != transportId) {\n                    self._debug('error callback from non-actual transport');\n                    return;\n                }\n                self._debug('transport level error', e);\n            },\n            onClose: function (closeEvent) {\n                if (connectTimeout) {\n                    clearTimeout(connectTimeout);\n                    connectTimeout = null;\n                }\n                if (self._transportId != transportId) {\n                    self._debug('close callback from non-actual transport');\n                    return;\n                }\n                self._debug(transport.subName(), 'transport closed');\n                self._transportClosed = true;\n                self._transportIsOpen = false;\n                let reason = 'connection closed';\n                let needReconnect = true;\n                let code = 0;\n                if (closeEvent && 'code' in closeEvent && closeEvent.code) {\n                    code = closeEvent.code;\n                }\n                if (closeEvent && closeEvent.reason) {\n                    try {\n                        const advice = JSON.parse(closeEvent.reason);\n                        reason = advice.reason;\n                        needReconnect = advice.reconnect;\n                    }\n                    catch (e) {\n                        reason = closeEvent.reason;\n                        if ((code >= 3500 && code < 4000) || (code >= 4500 && code < 5000)) {\n                            needReconnect = false;\n                        }\n                    }\n                }\n                if (code < 3000) {\n                    if (code === 1009) {\n                        code = exports.disconnectedCodes.messageSizeLimit;\n                        reason = 'message size limit exceeded';\n                        needReconnect = false;\n                    }\n                    else {\n                        code = exports.connectingCodes.transportClosed;\n                        reason = 'transport closed';\n                    }\n                    if (self._emulation && !self._transportWasOpen) {\n                        self._currentTransportIndex++;\n                        if (self._currentTransportIndex >= self._transports.length) {\n                            self._triedAllTransports = true;\n                            self._currentTransportIndex = 0;\n                        }\n                    }\n                }\n                else {\n                    // Codes >= 3000 are sent from a server application level.\n                    self._transportWasOpen = true;\n                }\n                if (self._isConnecting() && !wasOpen) {\n                    self.emit('error', {\n                        type: 'transport',\n                        error: {\n                            code: exports.errorCodes.transportClosed,\n                            message: 'transport closed'\n                        },\n                        transport: transport.name()\n                    });\n                }\n                self._reconnecting = false;\n                self._disconnect(code, reason, needReconnect);\n            },\n            onMessage: function (data) {\n                self._dataReceived(data);\n            }\n        }, initialData);\n        //@ts-ignore must be used only for debug and test purposes.\n        self.emit('__centrifuge_debug:transport_initialized', {});\n    }\n    _sendConnect(skipSending) {\n        const connectCommand = this._constructConnectCommand();\n        const self = this;\n        this._call(connectCommand, skipSending).then(resolveCtx => {\n            // @ts-ignore = improve later.\n            const result = resolveCtx.reply.connect;\n            self._connectResponse(result);\n            // @ts-ignore - improve later.\n            if (resolveCtx.next) {\n                // @ts-ignore - improve later.\n                resolveCtx.next();\n            }\n        }, rejectCtx => {\n            self._connectError(rejectCtx.error);\n            if (rejectCtx.next) {\n                rejectCtx.next();\n            }\n        });\n        return connectCommand;\n    }\n    _startReconnecting() {\n        this._debug('start reconnecting');\n        if (!this._isConnecting()) {\n            this._debug('stop reconnecting: client not in connecting state');\n            return;\n        }\n        if (this._reconnecting) {\n            this._debug('reconnect already in progress, return from reconnect routine');\n            return;\n        }\n        if (this._transportClosed === false) {\n            this._debug('waiting for transport close');\n            return;\n        }\n        this._reconnecting = true;\n        const self = this;\n        const emptyToken = this._token === '';\n        const needTokenRefresh = this._refreshRequired || (emptyToken && this._config.getToken !== null);\n        if (!needTokenRefresh) {\n            if (this._config.getData) {\n                this._config.getData().then(function (data) {\n                    if (!self._isConnecting()) {\n                        return;\n                    }\n                    self._data = data;\n                    self._initializeTransport();\n                });\n            }\n            else {\n                this._initializeTransport();\n            }\n            return;\n        }\n        this._getToken().then(function (token) {\n            if (!self._isConnecting()) {\n                return;\n            }\n            if (token == null || token == undefined) {\n                self._failUnauthorized();\n                return;\n            }\n            self._token = token;\n            self._debug('connection token refreshed');\n            if (self._config.getData) {\n                self._config.getData().then(function (data) {\n                    if (!self._isConnecting()) {\n                        return;\n                    }\n                    self._data = data;\n                    self._initializeTransport();\n                });\n            }\n            else {\n                self._initializeTransport();\n            }\n        }).catch(function (e) {\n            if (!self._isConnecting()) {\n                return;\n            }\n            if (e instanceof UnauthorizedError) {\n                self._failUnauthorized();\n                return;\n            }\n            self.emit('error', {\n                'type': 'connectToken',\n                'error': {\n                    code: exports.errorCodes.clientConnectToken,\n                    message: e !== undefined ? e.toString() : ''\n                }\n            });\n            const delay = self._getReconnectDelay();\n            self._debug('error on connection token refresh, reconnect after ' + delay + ' milliseconds', e);\n            self._reconnecting = false;\n            self._reconnectTimeout = setTimeout(() => {\n                self._startReconnecting();\n            }, delay);\n        });\n    }\n    _connectError(err) {\n        if (this.state !== exports.State.Connecting) {\n            return;\n        }\n        if (err.code === 109) { // token expired.\n            // next connect attempt will try to refresh token.\n            this._refreshRequired = true;\n        }\n        if (err.code < 100 || err.temporary === true || err.code === 109) {\n            this.emit('error', {\n                'type': 'connect',\n                'error': err\n            });\n            this._debug('closing transport due to connect error');\n            this._disconnect(err.code, err.message, true);\n        }\n        else {\n            this._disconnect(err.code, err.message, false);\n        }\n    }\n    _scheduleReconnect() {\n        if (!this._isConnecting()) {\n            return;\n        }\n        let isInitialHandshake = false;\n        if (this._emulation && !this._transportWasOpen && !this._triedAllTransports) {\n            isInitialHandshake = true;\n        }\n        let delay = this._getReconnectDelay();\n        if (isInitialHandshake) {\n            delay = 0;\n        }\n        this._debug('reconnect after ' + delay + ' milliseconds');\n        this._clearReconnectTimeout();\n        this._reconnectTimeout = setTimeout(() => {\n            this._startReconnecting();\n        }, delay);\n    }\n    _constructConnectCommand() {\n        const req = {};\n        if (this._token) {\n            req.token = this._token;\n        }\n        if (this._data) {\n            req.data = this._data;\n        }\n        if (this._config.name) {\n            req.name = this._config.name;\n        }\n        if (this._config.version) {\n            req.version = this._config.version;\n        }\n        const subs = {};\n        let hasSubs = false;\n        for (const channel in this._serverSubs) {\n            if (this._serverSubs.hasOwnProperty(channel) && this._serverSubs[channel].recoverable) {\n                hasSubs = true;\n                const sub = {\n                    'recover': true\n                };\n                if (this._serverSubs[channel].offset) {\n                    sub['offset'] = this._serverSubs[channel].offset;\n                }\n                if (this._serverSubs[channel].epoch) {\n                    sub['epoch'] = this._serverSubs[channel].epoch;\n                }\n                subs[channel] = sub;\n            }\n        }\n        if (hasSubs) {\n            req.subs = subs;\n        }\n        return {\n            connect: req\n        };\n    }\n    _getHistoryRequest(channel, options) {\n        const req = {\n            channel: channel\n        };\n        if (options !== undefined) {\n            if (options.since) {\n                req.since = {\n                    offset: options.since.offset\n                };\n                if (options.since.epoch) {\n                    req.since.epoch = options.since.epoch;\n                }\n            }\n            if (options.limit !== undefined) {\n                req.limit = options.limit;\n            }\n            if (options.reverse === true) {\n                req.reverse = true;\n            }\n        }\n        return req;\n    }\n    _methodCall() {\n        if (this._isConnected()) {\n            return Promise.resolve();\n        }\n        return new Promise((res, rej) => {\n            const timeout = setTimeout(function () {\n                rej({ code: exports.errorCodes.timeout, message: 'timeout' });\n            }, this._config.timeout);\n            this._promises[this._nextPromiseId()] = {\n                timeout: timeout,\n                resolve: res,\n                reject: rej\n            };\n        });\n    }\n    _callPromise(cmd, resultCB) {\n        return new Promise((resolve, reject) => {\n            this._call(cmd, false).then(resolveCtx => {\n                // @ts-ignore - improve later.\n                resolve(resultCB(resolveCtx.reply));\n                // @ts-ignore - improve later.\n                if (resolveCtx.next) {\n                    // @ts-ignore - improve later.\n                    resolveCtx.next();\n                }\n            }, rejectCtx => {\n                reject(rejectCtx.error);\n                if (rejectCtx.next) {\n                    rejectCtx.next();\n                }\n            });\n        });\n    }\n    _dataReceived(data) {\n        if (this._serverPing > 0) {\n            this._waitServerPing();\n        }\n        const replies = this._codec.decodeReplies(data);\n        // We have to guarantee order of events in replies processing - i.e. start processing\n        // next reply only when we finished processing of current one. Without syncing things in\n        // this way we could get wrong publication events order as reply promises resolve\n        // on next loop tick so for loop continues before we finished emitting all reply events.\n        this._dispatchPromise = this._dispatchPromise.then(() => {\n            let finishDispatch;\n            this._dispatchPromise = new Promise(resolve => {\n                finishDispatch = resolve;\n            });\n            this._dispatchSynchronized(replies, finishDispatch);\n        });\n    }\n    _dispatchSynchronized(replies, finishDispatch) {\n        let p = Promise.resolve();\n        for (const i in replies) {\n            if (replies.hasOwnProperty(i)) {\n                p = p.then(() => {\n                    return this._dispatchReply(replies[i]);\n                });\n            }\n        }\n        p = p.then(() => {\n            finishDispatch();\n        });\n    }\n    _dispatchReply(reply) {\n        let next;\n        const p = new Promise(resolve => {\n            next = resolve;\n        });\n        if (reply === undefined || reply === null) {\n            this._debug('dispatch: got undefined or null reply');\n            next();\n            return p;\n        }\n        const id = reply.id;\n        if (id && id > 0) {\n            this._handleReply(reply, next);\n        }\n        else {\n            if (!reply.push) {\n                this._handleServerPing(next);\n            }\n            else {\n                this._handlePush(reply.push, next);\n            }\n        }\n        return p;\n    }\n    _call(cmd, skipSending) {\n        return new Promise((resolve, reject) => {\n            cmd.id = this._nextCommandId();\n            this._registerCall(cmd.id, resolve, reject);\n            if (!skipSending) {\n                this._addCommand(cmd);\n            }\n        });\n    }\n    _startConnecting() {\n        this._debug('start connecting');\n        if (this._setState(exports.State.Connecting)) {\n            this.emit('connecting', { code: exports.connectingCodes.connectCalled, reason: 'connect called' });\n        }\n        this._client = null;\n        this._startReconnecting();\n    }\n    _disconnect(code, reason, reconnect) {\n        if (this._isDisconnected()) {\n            return;\n        }\n        // we mark transport is closed right away, because _clearConnectedState will move subscriptions to subscribing state\n        // if transport will still be open at this time, subscribe frames will be sent to closing transport\n        this._transportIsOpen = false;\n        const previousState = this.state;\n        this._reconnecting = false;\n        const ctx = {\n            code: code,\n            reason: reason\n        };\n        let needEvent = false;\n        if (reconnect) {\n            needEvent = this._setState(exports.State.Connecting);\n        }\n        else {\n            needEvent = this._setState(exports.State.Disconnected);\n            this._rejectPromises({ code: exports.errorCodes.clientDisconnected, message: 'disconnected' });\n        }\n        this._clearOutgoingRequests();\n        if (previousState === exports.State.Connecting) {\n            this._clearReconnectTimeout();\n        }\n        if (previousState === exports.State.Connected) {\n            this._clearConnectedState();\n        }\n        if (needEvent) {\n            if (this._isConnecting()) {\n                this.emit('connecting', ctx);\n            }\n            else {\n                this.emit('disconnected', ctx);\n            }\n        }\n        if (this._transport) {\n            this._debug(\"closing existing transport\");\n            const transport = this._transport;\n            this._transport = null;\n            transport.close(); // Close only after setting this._transport to null to avoid recursion when calling transport close().\n            // Need to mark as closed here, because connect call may be sync called after disconnect,\n            // transport onClose callback will not be called yet\n            this._transportClosed = true;\n            this._nextTransportId();\n        }\n        else {\n            this._debug(\"no transport to close\");\n        }\n        this._scheduleReconnect();\n    }\n    _failUnauthorized() {\n        this._disconnect(exports.disconnectedCodes.unauthorized, 'unauthorized', false);\n    }\n    _getToken() {\n        this._debug('get connection token');\n        if (!this._config.getToken) {\n            this.emit('error', {\n                type: 'configuration',\n                error: {\n                    code: exports.errorCodes.badConfiguration,\n                    message: 'token expired but no getToken function set in the configuration'\n                }\n            });\n            throw new UnauthorizedError('');\n        }\n        return this._config.getToken({});\n    }\n    _refresh() {\n        const clientId = this._client;\n        const self = this;\n        this._getToken().then(function (token) {\n            if (clientId !== self._client) {\n                return;\n            }\n            if (!token) {\n                self._failUnauthorized();\n                return;\n            }\n            self._token = token;\n            self._debug('connection token refreshed');\n            if (!self._isConnected()) {\n                return;\n            }\n            const cmd = {\n                refresh: { token: self._token }\n            };\n            self._call(cmd, false).then(resolveCtx => {\n                // @ts-ignore - improve later.\n                const result = resolveCtx.reply.refresh;\n                self._refreshResponse(result);\n                // @ts-ignore - improve later.\n                if (resolveCtx.next) {\n                    // @ts-ignore - improve later.\n                    resolveCtx.next();\n                }\n            }, rejectCtx => {\n                self._refreshError(rejectCtx.error);\n                if (rejectCtx.next) {\n                    rejectCtx.next();\n                }\n            });\n        }).catch(function (e) {\n            if (!self._isConnected()) {\n                return;\n            }\n            if (e instanceof UnauthorizedError) {\n                self._failUnauthorized();\n                return;\n            }\n            self.emit('error', {\n                type: 'refreshToken',\n                error: {\n                    code: exports.errorCodes.clientRefreshToken,\n                    message: e !== undefined ? e.toString() : ''\n                }\n            });\n            self._refreshTimeout = setTimeout(() => self._refresh(), self._getRefreshRetryDelay());\n        });\n    }\n    _refreshError(err) {\n        if (err.code < 100 || err.temporary === true) {\n            this.emit('error', {\n                type: 'refresh',\n                error: err\n            });\n            this._refreshTimeout = setTimeout(() => this._refresh(), this._getRefreshRetryDelay());\n        }\n        else {\n            this._disconnect(err.code, err.message, false);\n        }\n    }\n    _getRefreshRetryDelay() {\n        return backoff(0, 5000, 10000);\n    }\n    _refreshResponse(result) {\n        if (this._refreshTimeout) {\n            clearTimeout(this._refreshTimeout);\n            this._refreshTimeout = null;\n        }\n        if (result.expires) {\n            this._client = result.client;\n            this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));\n        }\n    }\n    _removeSubscription(sub) {\n        if (sub === null) {\n            return;\n        }\n        delete this._subs[sub.channel];\n    }\n    _unsubscribe(sub) {\n        if (!this._transportIsOpen) {\n            return Promise.resolve();\n        }\n        const req = {\n            channel: sub.channel\n        };\n        const cmd = { unsubscribe: req };\n        const self = this;\n        const unsubscribePromise = new Promise((resolve, _) => {\n            this._call(cmd, false).then(resolveCtx => {\n                resolve();\n                // @ts-ignore - improve later.\n                if (resolveCtx.next) {\n                    // @ts-ignore - improve later.\n                    resolveCtx.next();\n                }\n            }, rejectCtx => {\n                resolve();\n                if (rejectCtx.next) {\n                    rejectCtx.next();\n                }\n                self._disconnect(exports.connectingCodes.unsubscribeError, 'unsubscribe error', true);\n            });\n        });\n        return unsubscribePromise;\n    }\n    _getSub(channel) {\n        const sub = this._subs[channel];\n        if (!sub) {\n            return null;\n        }\n        return sub;\n    }\n    _isServerSub(channel) {\n        return this._serverSubs[channel] !== undefined;\n    }\n    _sendSubscribeCommands() {\n        const commands = [];\n        for (const channel in this._subs) {\n            if (!this._subs.hasOwnProperty(channel)) {\n                continue;\n            }\n            const sub = this._subs[channel];\n            // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            if (sub._inflight === true) {\n                continue;\n            }\n            if (sub.state === exports.SubscriptionState.Subscribing) {\n                // @ts-ignore – we are hiding some symbols from public API autocompletion.\n                const cmd = sub._subscribe();\n                if (cmd) {\n                    commands.push(cmd);\n                }\n            }\n        }\n        return commands;\n    }\n    _connectResponse(result) {\n        this._transportIsOpen = true;\n        this._transportWasOpen = true;\n        this._reconnectAttempts = 0;\n        this._refreshRequired = false;\n        if (this._isConnected()) {\n            return;\n        }\n        this._client = result.client;\n        this._setState(exports.State.Connected);\n        if (this._refreshTimeout) {\n            clearTimeout(this._refreshTimeout);\n        }\n        if (result.expires) {\n            this._refreshTimeout = setTimeout(() => this._refresh(), ttlMilliseconds(result.ttl));\n        }\n        this._session = result.session;\n        this._node = result.node;\n        this.startBatching();\n        this._sendSubscribeCommands();\n        this.stopBatching();\n        const ctx = {\n            client: result.client,\n            transport: this._transport.subName()\n        };\n        if (result.data) {\n            ctx.data = result.data;\n        }\n        this.emit('connected', ctx);\n        this._resolvePromises();\n        this._processServerSubs(result.subs || {});\n        if (result.ping && result.ping > 0) {\n            this._serverPing = result.ping * 1000;\n            this._sendPong = result.pong === true;\n            this._waitServerPing();\n        }\n        else {\n            this._serverPing = 0;\n        }\n    }\n    _processServerSubs(subs) {\n        for (const channel in subs) {\n            if (!subs.hasOwnProperty(channel)) {\n                continue;\n            }\n            const sub = subs[channel];\n            this._serverSubs[channel] = {\n                'offset': sub.offset,\n                'epoch': sub.epoch,\n                'recoverable': sub.recoverable || false\n            };\n            const subCtx = this._getSubscribeContext(channel, sub);\n            this.emit('subscribed', subCtx);\n        }\n        for (const channel in subs) {\n            if (!subs.hasOwnProperty(channel)) {\n                continue;\n            }\n            const sub = subs[channel];\n            if (sub.recovered) {\n                const pubs = sub.publications;\n                if (pubs && pubs.length > 0) {\n                    for (const i in pubs) {\n                        if (pubs.hasOwnProperty(i)) {\n                            this._handlePublication(channel, pubs[i]);\n                        }\n                    }\n                }\n            }\n        }\n        for (const channel in this._serverSubs) {\n            if (!this._serverSubs.hasOwnProperty(channel)) {\n                continue;\n            }\n            if (!subs[channel]) {\n                this.emit('unsubscribed', { channel: channel });\n                delete this._serverSubs[channel];\n            }\n        }\n    }\n    _clearRefreshTimeout() {\n        if (this._refreshTimeout !== null) {\n            clearTimeout(this._refreshTimeout);\n            this._refreshTimeout = null;\n        }\n    }\n    _clearReconnectTimeout() {\n        if (this._reconnectTimeout !== null) {\n            clearTimeout(this._reconnectTimeout);\n            this._reconnectTimeout = null;\n        }\n    }\n    _clearServerPingTimeout() {\n        if (this._serverPingTimeout !== null) {\n            clearTimeout(this._serverPingTimeout);\n            this._serverPingTimeout = null;\n        }\n    }\n    _waitServerPing() {\n        if (this._config.maxServerPingDelay === 0) {\n            return;\n        }\n        if (!this._isConnected()) {\n            return;\n        }\n        this._clearServerPingTimeout();\n        this._serverPingTimeout = setTimeout(() => {\n            if (!this._isConnected()) {\n                return;\n            }\n            this._disconnect(exports.connectingCodes.noPing, 'no ping', true);\n        }, this._serverPing + this._config.maxServerPingDelay);\n    }\n    _getSubscribeContext(channel, result) {\n        const ctx = {\n            channel: channel,\n            positioned: false,\n            recoverable: false,\n            wasRecovering: false,\n            recovered: false\n        };\n        if (result.recovered) {\n            ctx.recovered = true;\n        }\n        if (result.positioned) {\n            ctx.positioned = true;\n        }\n        if (result.recoverable) {\n            ctx.recoverable = true;\n        }\n        if (result.was_recovering) {\n            ctx.wasRecovering = true;\n        }\n        let epoch = '';\n        if ('epoch' in result) {\n            epoch = result.epoch;\n        }\n        let offset = 0;\n        if ('offset' in result) {\n            offset = result.offset;\n        }\n        if (ctx.positioned || ctx.recoverable) {\n            ctx.streamPosition = {\n                'offset': offset,\n                'epoch': epoch\n            };\n        }\n        if (result.data) {\n            ctx.data = result.data;\n        }\n        return ctx;\n    }\n    _handleReply(reply, next) {\n        const id = reply.id;\n        if (!(id in this._callbacks)) {\n            next();\n            return;\n        }\n        const callbacks = this._callbacks[id];\n        clearTimeout(this._callbacks[id].timeout);\n        delete this._callbacks[id];\n        if (!errorExists(reply)) {\n            const callback = callbacks.callback;\n            if (!callback) {\n                return;\n            }\n            callback({ reply, next });\n        }\n        else {\n            const errback = callbacks.errback;\n            if (!errback) {\n                next();\n                return;\n            }\n            const error = reply.error;\n            errback({ error, next });\n        }\n    }\n    _handleJoin(channel, join) {\n        const sub = this._getSub(channel);\n        if (!sub) {\n            if (this._isServerSub(channel)) {\n                const ctx = { channel: channel, info: this._getJoinLeaveContext(join.info) };\n                this.emit('join', ctx);\n            }\n            return;\n        }\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        sub._handleJoin(join);\n    }\n    _handleLeave(channel, leave) {\n        const sub = this._getSub(channel);\n        if (!sub) {\n            if (this._isServerSub(channel)) {\n                const ctx = { channel: channel, info: this._getJoinLeaveContext(leave.info) };\n                this.emit('leave', ctx);\n            }\n            return;\n        }\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        sub._handleLeave(leave);\n    }\n    _handleUnsubscribe(channel, unsubscribe) {\n        const sub = this._getSub(channel);\n        if (!sub) {\n            if (this._isServerSub(channel)) {\n                delete this._serverSubs[channel];\n                this.emit('unsubscribed', { channel: channel });\n            }\n            return;\n        }\n        if (unsubscribe.code < 2500) {\n            // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            sub._setUnsubscribed(unsubscribe.code, unsubscribe.reason, false);\n        }\n        else {\n            // @ts-ignore – we are hiding some symbols from public API autocompletion.\n            sub._setSubscribing(unsubscribe.code, unsubscribe.reason);\n        }\n    }\n    _handleSubscribe(channel, sub) {\n        this._serverSubs[channel] = {\n            'offset': sub.offset,\n            'epoch': sub.epoch,\n            'recoverable': sub.recoverable || false\n        };\n        this.emit('subscribed', this._getSubscribeContext(channel, sub));\n    }\n    _handleDisconnect(disconnect) {\n        const code = disconnect.code;\n        let reconnect = true;\n        if ((code >= 3500 && code < 4000) || (code >= 4500 && code < 5000)) {\n            reconnect = false;\n        }\n        this._disconnect(code, disconnect.reason, reconnect);\n    }\n    _getPublicationContext(channel, pub) {\n        const ctx = {\n            channel: channel,\n            data: pub.data\n        };\n        if (pub.offset) {\n            ctx.offset = pub.offset;\n        }\n        if (pub.info) {\n            ctx.info = this._getJoinLeaveContext(pub.info);\n        }\n        if (pub.tags) {\n            ctx.tags = pub.tags;\n        }\n        return ctx;\n    }\n    _getJoinLeaveContext(clientInfo) {\n        const info = {\n            client: clientInfo.client,\n            user: clientInfo.user\n        };\n        if (clientInfo.conn_info) {\n            info.connInfo = clientInfo.conn_info;\n        }\n        if (clientInfo.chan_info) {\n            info.chanInfo = clientInfo.chan_info;\n        }\n        return info;\n    }\n    _handlePublication(channel, pub) {\n        const sub = this._getSub(channel);\n        if (!sub) {\n            if (this._isServerSub(channel)) {\n                const ctx = this._getPublicationContext(channel, pub);\n                this.emit('publication', ctx);\n                if (pub.offset !== undefined) {\n                    this._serverSubs[channel].offset = pub.offset;\n                }\n            }\n            return;\n        }\n        // @ts-ignore – we are hiding some symbols from public API autocompletion.\n        sub._handlePublication(pub);\n    }\n    _handleMessage(message) {\n        this.emit('message', { data: message.data });\n    }\n    _handleServerPing(next) {\n        if (this._sendPong) {\n            const cmd = {};\n            this._transportSendCommands([cmd]);\n        }\n        next();\n    }\n    _handlePush(data, next) {\n        const channel = data.channel;\n        if (data.pub) {\n            this._handlePublication(channel, data.pub);\n        }\n        else if (data.message) {\n            this._handleMessage(data.message);\n        }\n        else if (data.join) {\n            this._handleJoin(channel, data.join);\n        }\n        else if (data.leave) {\n            this._handleLeave(channel, data.leave);\n        }\n        else if (data.unsubscribe) {\n            this._handleUnsubscribe(channel, data.unsubscribe);\n        }\n        else if (data.subscribe) {\n            this._handleSubscribe(channel, data.subscribe);\n        }\n        else if (data.disconnect) {\n            this._handleDisconnect(data.disconnect);\n        }\n        next();\n    }\n    _flush() {\n        const commands = this._commands.slice(0);\n        this._commands = [];\n        this._transportSendCommands(commands);\n    }\n    _createErrorObject(code, message, temporary) {\n        const errObject = {\n            code: code,\n            message: message\n        };\n        if (temporary) {\n            errObject.temporary = true;\n        }\n        return errObject;\n    }\n    _registerCall(id, callback, errback) {\n        this._callbacks[id] = {\n            callback: callback,\n            errback: errback,\n            timeout: null\n        };\n        this._callbacks[id].timeout = setTimeout(() => {\n            delete this._callbacks[id];\n            if (isFunction(errback)) {\n                errback({ error: this._createErrorObject(exports.errorCodes.timeout, 'timeout') });\n            }\n        }, this._config.timeout);\n    }\n    _addCommand(command) {\n        if (this._batching) {\n            this._commands.push(command);\n        }\n        else {\n            this._transportSendCommands([command]);\n        }\n    }\n    _nextPromiseId() {\n        return ++this._promiseId;\n    }\n    _nextTransportId() {\n        return ++this._transportId;\n    }\n    _resolvePromises() {\n        for (const id in this._promises) {\n            if (!this._promises.hasOwnProperty(id)) {\n                continue;\n            }\n            if (this._promises[id].timeout) {\n                clearTimeout(this._promises[id].timeout);\n            }\n            this._promises[id].resolve();\n            delete this._promises[id];\n        }\n    }\n    _rejectPromises(err) {\n        for (const id in this._promises) {\n            if (!this._promises.hasOwnProperty(id)) {\n                continue;\n            }\n            if (this._promises[id].timeout) {\n                clearTimeout(this._promises[id].timeout);\n            }\n            this._promises[id].reject(err);\n            delete this._promises[id];\n        }\n    }\n}\nCentrifuge.SubscriptionState = exports.SubscriptionState;\nCentrifuge.State = exports.State;\nCentrifuge.UnauthorizedError = UnauthorizedError;\n\nexports.Centrifuge = Centrifuge;\nexports.Subscription = Subscription;\nexports.UnauthorizedError = UnauthorizedError;\n","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n"],"names":["__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","apply","getDefaultExportFromCjs","x","__esModule","Object","prototype","hasOwnProperty","call","SuppressedError","ReflectOwnKeys","events","exports","R","Reflect","ReflectApply","target","receiver","args","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","EventEmitter","init","this","once","emitter","name","errorListener","err","removeListener","resolver","slice","arguments","eventTargetAgnosticAddListener","handler","on","addErrorHandlerIfEventEmitter","_events","undefined","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","existing","warning","create","newListener","emit","unshift","push","length","warned","w","Error","String","count","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","arr","ret","Array","i","unwrapListeners","arrayClone","listenerCount","n","copy","flags","addEventListener","wrapListener","arg","removeEventListener","defineProperty","enumerable","get","set","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","len","listeners","addListener","prependListener","prependOnceListener","list","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","errorCodes","connectingCodes","disconnectedCodes","subscribingCodes","unsubscribedCodes","State","SubscriptionState","EventEmitter$1","isFunction","backoff","min","max","interval","Math","floor","random","randomInt","pow","ttlMilliseconds","ttl","Subscription","constructor","centrifuge","channel","options","super","_resubscribeTimeout","_refreshTimeout","Unsubscribed","_centrifuge","_token","_getToken","_data","_getData","_recover","_offset","_epoch","_recoverable","_positioned","_joinLeave","_minResubscribeDelay","_maxResubscribeDelay","_resubscribeAttempts","_promises","_promiseId","_inflight","_delta","_delta_negotiated","_prevValue","_unsubPromise","_setOptions","_debugEnabled","ctx","_debug","oldState","newState","ready","timeout","code","subscriptionUnsubscribed","Subscribed","res","rej","setTimeout","_nextPromiseId","subscribe","_isSubscribed","_setSubscribing","subscribeCalled","unsubscribe","_setUnsubscribed","unsubscribeCalled","publish","data","self","_methodCall","presence","presenceStats","history","opts","_isUnsubscribed","_config","_needRecover","_isSubscribing","Subscribing","_setState","_usesToken","_clearSubscribingState","_clearResubscribeTimeout","_clearSubscribedState","_clearRefreshTimeout","_setSubscribed","recoverable","offset","epoch","delta","_getSubscribeContext","_resolvePromises","pubs","publications","_handlePublication","expires","_refresh","reason","_transport","emulation","_subscribe","_transportIsOpen","getDataCtx","_sendSubscribe","_getSubscriptionToken","token","_failUnauthorized","catch","UnauthorizedError","subscriptionSubscribeToken","toString","_scheduleResubscribe","req","positioned","join_leave","recover","_getOffset","_getEpoch","cmd","_call","resolveCtx","reply","_handleSubscribeResponse","rejectCtx","_handleSubscribeError","_subscribeError","_disconnect","subscribeTimeout","sendUnsubscribe","promise","_unsubscribe","_rejectPromises","pub","newData","newPrevValue","_codec","applyDeltaIfNeeded","_getPublicationContext","_handleJoin","join","info","_getJoinLeaveContext","_handleLeave","leave","id","clearTimeout","delay","_getResubscribeDelay","temporary","errContext","Connected","since","getData","minResubscribeDelay","maxResubscribeDelay","getToken","joinLeave","badConfiguration","msg","sub_refresh","_refreshResponse","_refreshError","subscriptionRefreshToken","_getRefreshRetryDelay","unauthorized","SockjsTransport","endpoint","subName","transport","supported","sockjs","initialize","_protocol","callbacks","sockjsOptions","onopen","onOpen","onerror","onError","onclose","closeEvent","onClose","onmessage","event","onMessage","close","send","WebsocketTransport","websocket","protocol","subProtocol","binaryType","HttpStreamTransport","_abortController","_utf8decoder","TextDecoder","_handleErrors","response","ok","status","_fetchEventTarget","eventTarget","EventTarget","fetchFunc","fetch","dispatchEvent","Event","jsonStreamBuf","jsonStreamPos","protoStreamBuf","Uint8Array","reader","body","getReader","readableStream","start","controller","pump","read","decode","line","substring","MessageEvent","mergedArray","decoder","decodeReply","pos","detail","AbortController","initialData","headers","fetchOptions","method","mode","credentials","cache","signal","abort","session","node","JSON","stringify","encoder","encodeEmulationRequest","emulationEndpoint","SseTransport","_onClose","eventsource","url","globalThis","document","baseURI","URL","searchParams","append","eventSource","WebtransportTransport","_stream","_writer","webtransport","closed","_a","stream","createBidirectionalStream","_b","writable","getWriter","_startReading","readable","binary","TextEncoder","encode","write","zValue","Reader","array","a","haveBytes","getByte","b","getChar","fromCharCode","getInt","c","v","Writer","toByteArray","sourceType","isArray","putArray","end","checksum","sum0","sum1","sum2","sum3","z","N","JsonCodec","encodeCommands","commands","map","decodeReplies","trim","split","r","parse","prevValue","valueArray","source","total","zDelta","lenSrc","lenDelta","limit","zOut","cnt","ofst","out","applyDelta","defaults","debug","version","minReconnectDelay","maxReconnectDelay","maxServerPingDelay","networkEventTarget","Centrifuge","_reconnectTimeout","_serverPingTimeout","Disconnected","_endpoint","_emulation","_transports","_currentTransportIndex","_triedAllTransports","_transportWasOpen","_transportId","_deviceWentOffline","_transportClosed","_reconnecting","_reconnectAttempts","_client","_session","_node","_subs","_serverSubs","_commandId","_commands","_batching","_refreshRequired","_callbacks","_dispatchPromise","_serverPing","_sendPong","_networkEventsSet","assign","_configure","newSubscription","getSubscription","sub","_getSub","removeSubscription","_removeSubscription","subscriptions","clientDisconnected","connect","_isConnected","_isConnecting","_startConnecting","disconnect","disconnectCalled","setToken","_transportSendCommands","_createErrorObject","transportWriteError","rpc","_callPromise","_getHistoryRequest","clients","clientId","connInfo","chanInfo","presence_stats","num_users","num_clients","startBatching","stopBatching","_flush","level","logger","log","_formatOverride","localStorage","getItem","transportConfig","transportName","indexOf","_isDisconnected","Connecting","_nextCommandId","_setNetworkEvents","transportClosed","_clearReconnectTimeout","_startReconnecting","_getReconnectDelay","_clearOutgoingRequests","errback","connectionClosed","_clearConnectedState","_clearServerPingTimeout","_handleWriteError","command","_initializeTransport","WebSocket","SockJS","EventSource","ReadableStream","transportEndpoint","WebTransport","lastIndexOf","transportId","_nextTransportId","wasOpen","initialCommands","connectCommand","_sendConnect","connectTimeout","_sendSubscribeCommands","needReconnect","advice","reconnect","messageSizeLimit","_dataReceived","skipSending","_constructConnectCommand","_connectResponse","_connectError","emptyToken","clientConnectToken","_scheduleReconnect","isInitialHandshake","subs","hasSubs","reverse","resultCB","_waitServerPing","replies","finishDispatch","_dispatchSynchronized","p","_dispatchReply","_handleReply","_handlePush","_handleServerPing","_registerCall","_addCommand","connectCalled","previousState","needEvent","refresh","clientRefreshToken","client","_","unsubscribeError","_isServerSub","_processServerSubs","ping","pong","subCtx","recovered","noPing","wasRecovering","was_recovering","streamPosition","callback","_handleUnsubscribe","_handleSubscribe","_handleDisconnect","tags","clientInfo","user","conn_info","chan_info","_handleMessage","errObject","hasOwn","classNames","classes","appendClass","parseValue","includes","newClass","module","default"],"sourceRoot":""}