epicenter-libs 3.33.0 → 3.34.1

package/dist/test/node_modules/cometd/Client.js

@@ -1,2160 +0,0 @@
-import { TransportRegistry } from './TransportRegistry.js';
-import { CallbackPollingTransport } from './CallbackPollingTransport.js';
-import { LongPollingTransport } from './LongPollingTransport.js';
-import { WebSocketTransport } from './WebSocketTransport.js';
-
-var _CometD;
-function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-
-/**
- * Browsers may throttle the Window scheduler,
- * so we may replace it with a Worker scheduler.
- */
-function Scheduler() {
-  let _ids = 0;
-  const _tasks = {};
-  this.register = funktion => {
-    const id = ++_ids;
-    _tasks[id] = funktion;
-    return id;
-  };
-  this.unregister = id => {
-    const funktion = _tasks[id];
-    delete _tasks[id];
-    return funktion;
-  };
-  this.setTimeout = (funktion, delay) => window.setTimeout(funktion, delay);
-  this.clearTimeout = id => {
-    window.clearTimeout(id);
-  };
-}
-
-/**
- * The scheduler code that will run in the Worker.
- * Workers have a built-in `self` variable similar to `window`.
- */
-function WorkerScheduler() {
-  const _tasks = {};
-  self.onmessage = e => {
-    const cmd = e.data;
-    const id = _tasks[cmd.id];
-    switch (cmd.type) {
-      case "setTimeout":
-        _tasks[cmd.id] = self.setTimeout(() => {
-          delete _tasks[cmd.id];
-          self.postMessage({
-            id: cmd.id
-          });
-        }, cmd.delay);
-        break;
-      case "clearTimeout":
-        delete _tasks[cmd.id];
-        if (id) {
-          self.clearTimeout(id);
-        }
-        break;
-      default:
-        throw new Error("Unknown command " + cmd.type);
-    }
-  };
-}
-
-/**
- * The constructor for a CometD object, identified by an optional name.
- * The default name is the string "default".
- * @param name the optional name of this cometd object
- */
-var _scheduler = /*#__PURE__*/new WeakMap();
-var _name = /*#__PURE__*/new WeakMap();
-var _crossDomain = /*#__PURE__*/new WeakMap();
-var _transports = /*#__PURE__*/new WeakMap();
-var _transport = /*#__PURE__*/new WeakMap();
-var _status = /*#__PURE__*/new WeakMap();
-var _messageId = /*#__PURE__*/new WeakMap();
-var _clientId = /*#__PURE__*/new WeakMap();
-var _batch = /*#__PURE__*/new WeakMap();
-var _messageQueue = /*#__PURE__*/new WeakMap();
-var _internalBatch = /*#__PURE__*/new WeakMap();
-var _listenerId = /*#__PURE__*/new WeakMap();
-var _listeners = /*#__PURE__*/new WeakMap();
-var _transportListeners = /*#__PURE__*/new WeakMap();
-var _backoff = /*#__PURE__*/new WeakMap();
-var _scheduledSend = /*#__PURE__*/new WeakMap();
-var _extensions = /*#__PURE__*/new WeakMap();
-var _advice = /*#__PURE__*/new WeakMap();
-var _handshakeProps = /*#__PURE__*/new WeakMap();
-var _handshakeCallback = /*#__PURE__*/new WeakMap();
-var _callbacks = /*#__PURE__*/new WeakMap();
-var _remoteCalls = /*#__PURE__*/new WeakMap();
-var _reestablish = /*#__PURE__*/new WeakMap();
-var _connected = /*#__PURE__*/new WeakMap();
-var _unconnectTime = /*#__PURE__*/new WeakMap();
-var _handshakeMessages = /*#__PURE__*/new WeakMap();
-var _metaConnect = /*#__PURE__*/new WeakMap();
-var _config = /*#__PURE__*/new WeakMap();
-var _CometD_brand = /*#__PURE__*/new WeakSet();
-class CometD {
-  constructor(_name2) {
-    _classPrivateMethodInitSpec(this, _CometD_brand);
-    _classPrivateFieldInitSpec(this, _scheduler, new Scheduler());
-    _classPrivateFieldInitSpec(this, _name, void 0);
-    _classPrivateFieldInitSpec(this, _crossDomain, false);
-    _classPrivateFieldInitSpec(this, _transports, new TransportRegistry());
-    _classPrivateFieldInitSpec(this, _transport, void 0);
-    _classPrivateFieldInitSpec(this, _status, "disconnected");
-    _classPrivateFieldInitSpec(this, _messageId, 0);
-    _classPrivateFieldInitSpec(this, _clientId, null);
-    _classPrivateFieldInitSpec(this, _batch, 0);
-    _classPrivateFieldInitSpec(this, _messageQueue, []);
-    _classPrivateFieldInitSpec(this, _internalBatch, false);
-    _classPrivateFieldInitSpec(this, _listenerId, 0);
-    _classPrivateFieldInitSpec(this, _listeners, {});
-    _classPrivateFieldInitSpec(this, _transportListeners, {});
-    _classPrivateFieldInitSpec(this, _backoff, 0);
-    _classPrivateFieldInitSpec(this, _scheduledSend, null);
-    _classPrivateFieldInitSpec(this, _extensions, []);
-    _classPrivateFieldInitSpec(this, _advice, {});
-    _classPrivateFieldInitSpec(this, _handshakeProps, void 0);
-    _classPrivateFieldInitSpec(this, _handshakeCallback, void 0);
-    _classPrivateFieldInitSpec(this, _callbacks, {});
-    _classPrivateFieldInitSpec(this, _remoteCalls, {});
-    _classPrivateFieldInitSpec(this, _reestablish, false);
-    _classPrivateFieldInitSpec(this, _connected, false);
-    _classPrivateFieldInitSpec(this, _unconnectTime, 0);
-    _classPrivateFieldInitSpec(this, _handshakeMessages, 0);
-    _classPrivateFieldInitSpec(this, _metaConnect, null);
-    _classPrivateFieldInitSpec(this, _config, {
-      useWorkerScheduler: true,
-      protocol: null,
-      stickyReconnect: true,
-      connectTimeout: 0,
-      maxConnections: 2,
-      backoffIncrement: 1000,
-      maxBackoff: 60000,
-      logLevel: "info",
-      maxNetworkDelay: 10000,
-      requestHeaders: {},
-      appendMessageTypeToURL: true,
-      autoBatch: false,
-      urls: {},
-      maxURILength: 2000,
-      maxSendBayeuxMessageSize: 8192,
-      advice: {
-        timeout: 60000,
-        interval: 0,
-        reconnect: undefined,
-        maxInterval: 0
-      }
-    });
-    _classPrivateFieldSet(_name, this, _name2 || "default");
-    // Initialize transports.
-    if (window.WebSocket) {
-      this.registerTransport("websocket", new WebSocketTransport());
-    }
-    this.registerTransport("long-polling", new LongPollingTransport());
-    this.registerTransport("callback-polling", new CallbackPollingTransport());
-  }
-  /**
-   * Mixes in the given objects into the target object by copying the properties.
-   * @param deep if the copy must be deep
-   * @param target the target object
-   * @param objects the objects whose properties are copied into the target
-   */
-  _mixin(deep, target, objects) {
-    const result = target || {};
-
-    // Skip first 2 parameters (deep and target), and loop over the others.
-    for (let i = 2; i < arguments.length; ++i) {
-      const object = arguments[i];
-      if (object === undefined || object === null) {
-        continue;
-      }
-      for (let propName in object) {
-        if (object.hasOwnProperty(propName)) {
-          const prop = _fieldValue.call(CometD, object, propName);
-          const targ = _fieldValue.call(CometD, result, propName);
-
-          // Avoid infinite loops.
-          if (prop === target) {
-            continue;
-          }
-          // Do not mixin undefined values.
-          if (prop === undefined) {
-            continue;
-          }
-          if (deep && typeof prop === "object" && prop !== null) {
-            if (prop instanceof Array) {
-              result[propName] = this._mixin(deep, targ instanceof Array ? targ : [], prop);
-            } else {
-              const source = typeof targ === "object" && !(targ instanceof Array) ? targ : {};
-              result[propName] = this._mixin(deep, source, prop);
-            }
-          } else {
-            result[propName] = prop;
-          }
-        }
-      }
-    }
-    return result;
-  }
-  _warn() {
-    _assertClassBrand(_CometD_brand, this, _log).call(this, "warn", arguments);
-  }
-  _info() {
-    if (_classPrivateFieldGet(_config, this).logLevel !== "warn") {
-      _assertClassBrand(_CometD_brand, this, _log).call(this, "info", arguments);
-    }
-  }
-  _debug() {
-    if (_classPrivateFieldGet(_config, this).logLevel === "debug") {
-      _assertClassBrand(_CometD_brand, this, _log).call(this, "debug", arguments);
-    }
-  }
-  /**
-   * Sends a complete bayeux message.
-   * This method is exposed as a public so that extensions may use it
-   * to send bayeux message directly, for example in case of re-sending
-   * messages that have already been sent but that for some reason must
-   * be resent.
-   */
-  send(message) {
-    _assertClassBrand(_CometD_brand, this, _queueSend).call(this, message);
-  }
-  _getCallback(messageId) {
-    return _classPrivateFieldGet(_callbacks, this)[messageId];
-  }
-  _putCallback(messageId, callback) {
-    const result = this._getCallback(messageId);
-    if (_isFunction.call(CometD, callback)) {
-      _classPrivateFieldGet(_callbacks, this)[messageId] = callback;
-    }
-    return result;
-  }
-  onTransportFailure(message, failureInfo, failureHandler) {
-    this._debug("Transport failure", failureInfo, "for", message);
-    const transports = this.getTransportRegistry();
-    const url = this.getURL();
-    const crossDomain = _assertClassBrand(_CometD_brand, this, _isCrossDomain).call(this, _splitURL.call(CometD, url)[2]);
-    const version = "1.0";
-    const transportTypes = transports.findTransportTypes(version, crossDomain, url);
-    if (failureInfo.action === "none") {
-      if (message.channel === "/meta/handshake") {
-        if (!failureInfo.transport) {
-          const failure = "Could not negotiate transport, client=[" + transportTypes + "], server=[" + message.supportedConnectionTypes + "]";
-          this._warn(failure);
-          const transport = this.getTransport();
-          if (transport) {
-            const transportType = transport.type;
-            _assertClassBrand(_CometD_brand, this, _notifyTransportException).call(this, transportType, null, {
-              reason: failure,
-              connectionType: transportType,
-              transport: transport
-            });
-          }
-        }
-      }
-    } else {
-      failureInfo.delay = this.getBackoffPeriod();
-      // Different logic depending on whether we are handshaking or connecting.
-      if (message.channel === "/meta/handshake") {
-        if (!failureInfo.transport) {
-          // The transport is invalid, try to negotiate again.
-          const oldTransportType = _classPrivateFieldGet(_transport, this) ? _classPrivateFieldGet(_transport, this).type : null;
-          const newTransport = transports.negotiateTransport(transportTypes, version, crossDomain, url);
-          if (!newTransport) {
-            this._warn("Could not negotiate transport, client=[" + transportTypes + "]");
-            _assertClassBrand(_CometD_brand, this, _notifyTransportException).call(this, oldTransportType, null, message.failure);
-            failureInfo.action = "none";
-          } else {
-            const newTransportType = newTransport.type;
-            this._debug("Transport", oldTransportType, "->", newTransportType);
-            _assertClassBrand(_CometD_brand, this, _notifyTransportException).call(this, oldTransportType, newTransportType, message.failure);
-            failureInfo.action = "handshake";
-            failureInfo.transport = newTransport;
-          }
-        }
-        if (failureInfo.action !== "none") {
-          this.increaseBackoffPeriod();
-        }
-      } else {
-        const now = new Date().getTime();
-        if (_classPrivateFieldGet(_unconnectTime, this) === 0) {
-          _classPrivateFieldSet(_unconnectTime, this, now);
-        }
-        if (failureInfo.action === "retry") {
-          failureInfo.delay = this.increaseBackoffPeriod();
-          // Check whether we may switch to handshaking.
-          const maxInterval = _classPrivateFieldGet(_advice, this).maxInterval;
-          if (maxInterval > 0) {
-            const expiration = _classPrivateFieldGet(_advice, this).timeout + _classPrivateFieldGet(_advice, this).interval + maxInterval;
-            const unconnected = now - _classPrivateFieldGet(_unconnectTime, this);
-            if (unconnected + _classPrivateFieldGet(_backoff, this) > expiration) {
-              failureInfo.action = "handshake";
-            }
-          }
-        }
-        if (failureInfo.action === "handshake") {
-          failureInfo.delay = 0;
-          transports.reset(false);
-          this.resetBackoffPeriod();
-        }
-      }
-    }
-    failureHandler.call(this, failureInfo);
-  }
-  /**
-   * Receives a message.
-   * This method is exposed as a public so that extensions may inject
-   * messages simulating that they had been received.
-   */
-  receive(message) {
-    _assertClassBrand(_CometD_brand, this, _receive).call(this, message);
-  }
-  //
-  // PUBLIC API
-  //
-
-  /**
-   * Registers the given transport under the given transport type.
-   * The optional index parameter specifies the "priority" at which the
-   * transport is registered (where 0 is the max priority).
-   * If a transport with the same type is already registered, this function
-   * does nothing and returns false.
-   * @param type the transport type
-   * @param transport the transport object
-   * @param index the index at which this transport is to be registered
-   * @return true if the transport has been registered, false otherwise
-   */
-  registerTransport(type, transport, index) {
-    const result = _classPrivateFieldGet(_transports, this).add(type, transport, index);
-    if (result) {
-      this._debug("Registered transport", type);
-      if (_isFunction.call(CometD, transport.registered)) {
-        transport.registered(type, this);
-      }
-    }
-    return result;
-  }
-  /**
-   * Unregisters the transport with the given transport type.
-   * @param type the transport type to unregister
-   * @return the transport that has been unregistered,
-   * or null if no transport was previously registered under the given transport type
-   */
-  unregisterTransport(type) {
-    const transport = _classPrivateFieldGet(_transports, this).remove(type);
-    if (transport !== null) {
-      this._debug("Unregistered transport", type);
-      if (_isFunction.call(CometD, transport.unregistered)) {
-        transport.unregistered();
-      }
-    }
-    return transport;
-  }
-  unregisterTransports() {
-    _classPrivateFieldGet(_transports, this).clear();
-  }
-  /**
-   * @return an array of all registered transport types
-   */
-  getTransportTypes() {
-    return _classPrivateFieldGet(_transports, this).getTransportTypes();
-  }
-  findTransport(name) {
-    return _classPrivateFieldGet(_transports, this).find(name);
-  }
-
-  /**
-   * @returns the TransportRegistry object
-   */
-  getTransportRegistry() {
-    return _classPrivateFieldGet(_transports, this);
-  }
-
-  /**
-   * Configures the initial Bayeux communication with the Bayeux server.
-   * Configuration is passed via an object that must contain a mandatory field <code>url</code>
-   * of type string containing the URL of the Bayeux server.
-   * @param configuration the configuration object
-   */
-  configure(configuration) {
-    _assertClassBrand(_CometD_brand, this, _configure).call(this, configuration);
-  }
-  /**
-   * Configures and establishes the Bayeux communication with the Bayeux server
-   * via a handshake and a subsequent connect.
-   * @param configuration the configuration object
-   * @param handshakeProps an object to be merged with the handshake message
-   */
-  init(configuration, handshakeProps) {
-    this.configure(configuration);
-    this.handshake(handshakeProps);
-  }
-  /**
-   * Establishes the Bayeux communication with the Bayeux server
-   * via a handshake and a subsequent connect.
-   * @param handshakeProps an object to be merged with the handshake message
-   * @param handshakeCallback a function to be invoked when the handshake is acknowledged
-   */
-  handshake(handshakeProps, handshakeCallback) {
-    const status = this.getStatus();
-    if (status !== "disconnected") {
-      throw new Error("Illegal state: " + status);
-    }
-    _assertClassBrand(_CometD_brand, this, _handshake).call(this, handshakeProps, handshakeCallback);
-  }
-  /**
-   * Disconnects from the Bayeux server.
-   * @param disconnectProps an object to be merged with the disconnect message
-   * @param disconnectCallback a function to be invoked when the disconnect is acknowledged
-   */
-  disconnect(disconnectProps, disconnectCallback) {
-    if (this.isDisconnected()) {
-      return;
-    }
-    if (_isFunction.call(CometD, disconnectProps)) {
-      disconnectCallback = disconnectProps;
-      disconnectProps = undefined;
-    }
-    const bayeuxMessage = {
-      id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-      channel: "/meta/disconnect"
-    };
-    // Do not allow the user to override important fields.
-    const message = this._mixin(false, {}, disconnectProps, bayeuxMessage);
-
-    // Save the callback.
-    this._putCallback(message.id, disconnectCallback);
-    _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "disconnecting");
-    _assertClassBrand(_CometD_brand, this, _send).call(this, [message], false, "disconnect");
-  }
-  /**
-   * Marks the start of a batch of application messages to be sent to the server
-   * in a single request, obtaining a single response containing (possibly) many
-   * application reply messages.
-   * Messages are held in a queue and not sent until {@link #endBatch()} is called.
-   * If startBatch() is called multiple times, then an equal number of endBatch()
-   * calls must be made to close and send the batch of messages.
-   */
-  startBatch() {
-    _assertClassBrand(_CometD_brand, this, _startBatch).call(this);
-  }
-  /**
-   * Marks the end of a batch of application messages to be sent to the server
-   * in a single request.
-   */
-  endBatch() {
-    _assertClassBrand(_CometD_brand, this, _endBatch).call(this);
-  }
-  /**
-   * Executes the given callback in the given scope, surrounded by a {@link #startBatch()}
-   * and {@link #endBatch()} calls.
-   * @param scope the scope of the callback, may be omitted
-   * @param callback the callback to be executed within {@link #startBatch()} and {@link #endBatch()} calls
-   */
-  batch(scope, callback) {
-    const delegate = _assertClassBrand(_CometD_brand, this, _resolveScopedCallback).call(this, scope, callback);
-    this.startBatch();
-    try {
-      delegate.method.call(delegate.scope);
-      this.endBatch();
-    } catch (x) {
-      this._info("Exception during execution of batch", x);
-      this.endBatch();
-      throw x;
-    }
-  }
-  /**
-   * Adds a transport listener for the specified transport event,
-   * executing the given callback when the event happens.
-   *
-   * The currently supported event is "timeout".
-   *
-   * The callback function takes an array of messages for which
-   * the event happened.
-   *
-   * For the "timeout" event, the callback function may return a
-   * positive value that extends the wait for message replies by
-   * the returned amount, in milliseconds.
-   *
-   * @param {String} event the type of transport event
-   * @param {Function} callback the function associate to the given transport event
-   */
-  addTransportListener(event, callback) {
-    if (event !== "timeout") {
-      throw new Error("Unsupported event " + event);
-    }
-    let callbacks = _classPrivateFieldGet(_transportListeners, this)[event];
-    if (!callbacks) {
-      _classPrivateFieldGet(_transportListeners, this)[event] = callbacks = [];
-    }
-    callbacks.push(callback);
-  }
-  /**
-   * Removes the transport listener for the specified transport event.
-   * @param {String} event the type of transport event
-   * @param {Function} callback the function disassociate from the given transport event
-   * @return {boolean} whether the disassociation was successful
-   */
-  removeTransportListener(event, callback) {
-    const callbacks = _classPrivateFieldGet(_transportListeners, this)[event];
-    if (callbacks) {
-      const index = callbacks.indexOf(callback);
-      if (index >= 0) {
-        callbacks.splice(index, 1);
-        return true;
-      }
-    }
-    return false;
-  }
-  _getTransportListeners(event) {
-    return _classPrivateFieldGet(_transportListeners, this)[event];
-  }
-
-  /**
-   * Adds a listener for bayeux messages, performing the given callback in the given scope
-   * when a message for the given channel arrives.
-   * @param channel the channel the listener is interested to
-   * @param scope the scope of the callback, may be omitted
-   * @param callback the callback to call when a message is sent to the channel
-   * @returns the subscription handle to be passed to {@link #removeListener(object)}
-   */
-  addListener(channel, scope, callback) {
-    if (arguments.length < 2) {
-      throw new Error("Illegal arguments number: required 2, got " + arguments.length);
-    }
-    if (!_isString.call(CometD, channel)) {
-      throw new Error("Illegal argument type: channel must be a string");
-    }
-    return _assertClassBrand(_CometD_brand, this, _addListener).call(this, channel, scope, callback, true);
-  }
-  /**
-   * Removes the subscription obtained with a call to {@link #addListener(string, object, function)}.
-   * @param subscription the subscription to unsubscribe.
-   */
-  removeListener(subscription) {
-    // Beware of subscription.id == 0, which is falsy => cannot use !subscription.id
-    if (!subscription || !subscription.channel || !("id" in subscription)) {
-      throw new Error("Invalid argument: expected subscription, not " + subscription);
-    }
-    _assertClassBrand(_CometD_brand, this, _removeListener).call(this, subscription);
-  }
-  /**
-   * Removes all listeners registered with {@link #addListener(channel, scope, callback)} or
-   * {@link #subscribe(channel, scope, callback)}.
-   */
-  clearListeners() {
-    _classPrivateFieldSet(_listeners, this, {});
-  }
-  /**
-   * Subscribes to the given channel, performing the given callback in the given scope
-   * when a message for the channel arrives.
-   * @param channel the channel to subscribe to
-   * @param scope the scope of the callback, may be omitted
-   * @param callback the callback to call when a message is sent to the channel
-   * @param subscribeProps an object to be merged with the subscribe message
-   * @param subscribeCallback a function to be invoked when the subscription is acknowledged
-   * @return the subscription handle to be passed to {@link #unsubscribe(object)}
-   */
-  subscribe(channel, scope, callback, subscribeProps, subscribeCallback) {
-    if (arguments.length < 2) {
-      throw new Error("Illegal arguments number: required 2, got " + arguments.length);
-    }
-    if (!_isValidChannel.call(CometD, channel)) {
-      throw new Error("Illegal argument: invalid channel " + channel);
-    }
-    if (this.isDisconnected()) {
-      throw new Error("Illegal state: disconnected");
-    }
-
-    // Normalize arguments
-    if (_isFunction.call(CometD, scope)) {
-      subscribeCallback = subscribeProps;
-      subscribeProps = callback;
-      callback = scope;
-      scope = undefined;
-    }
-    if (_isFunction.call(CometD, subscribeProps)) {
-      subscribeCallback = subscribeProps;
-      subscribeProps = undefined;
-    }
-
-    // Only send the message to the server if this client has not yet subscribed to the channel
-    const send = !_assertClassBrand(_CometD_brand, this, _hasSubscriptions).call(this, channel);
-    const subscription = _assertClassBrand(_CometD_brand, this, _addListener).call(this, channel, scope, callback, false);
-    if (send) {
-      // Send the subscription message after the subscription registration to avoid
-      // races where the server would send a message to the subscribers, but here
-      // on the client the subscription has not been added yet to the data structures
-      const bayeuxMessage = {
-        id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-        channel: "/meta/subscribe",
-        subscription: channel
-      };
-      // Do not allow the user to override important fields.
-      const message = this._mixin(false, {}, subscribeProps, bayeuxMessage);
-
-      // Save the callback.
-      this._putCallback(message.id, subscribeCallback);
-      _assertClassBrand(_CometD_brand, this, _queueSend).call(this, message);
-    } else {
-      if (_isFunction.call(CometD, subscribeCallback)) {
-        // Keep the semantic of calling callbacks asynchronously.
-        this.setTimeout(() => {
-          _assertClassBrand(_CometD_brand, this, _notifyCallback).call(this, subscribeCallback, {
-            id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-            successful: true,
-            channel: "/meta/subscribe",
-            subscription: channel
-          });
-        }, 0);
-      }
-    }
-    return subscription;
-  }
-  /**
-   * Unsubscribes the subscription obtained with a call to {@link #subscribe(string, object, function)}.
-   * @param subscription the subscription to unsubscribe.
-   * @param unsubscribeProps an object to be merged with the unsubscribe message
-   * @param unsubscribeCallback a function to be invoked when the unsubscription is acknowledged
-   */
-  unsubscribe(subscription, unsubscribeProps, unsubscribeCallback) {
-    if (arguments.length < 1) {
-      throw new Error("Illegal arguments number: required 1, got " + arguments.length);
-    }
-    if (this.isDisconnected()) {
-      throw new Error("Illegal state: disconnected");
-    }
-    if (_isFunction.call(CometD, unsubscribeProps)) {
-      unsubscribeCallback = unsubscribeProps;
-      unsubscribeProps = undefined;
-    }
-
-    // Remove the local listener before sending the message
-    // This ensures that if the server fails, this client does not get notifications
-    this.removeListener(subscription);
-    const channel = subscription.channel;
-    // Only send the message to the server if this client unsubscribes the last subscription
-    if (!_assertClassBrand(_CometD_brand, this, _hasSubscriptions).call(this, channel)) {
-      const bayeuxMessage = {
-        id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-        channel: "/meta/unsubscribe",
-        subscription: channel
-      };
-      // Do not allow the user to override important fields.
-      const message = this._mixin(false, {}, unsubscribeProps, bayeuxMessage);
-
-      // Save the callback.
-      this._putCallback(message.id, unsubscribeCallback);
-      _assertClassBrand(_CometD_brand, this, _queueSend).call(this, message);
-    } else {
-      if (_isFunction.call(CometD, unsubscribeCallback)) {
-        // Keep the semantic of calling callbacks asynchronously.
-        this.setTimeout(() => {
-          _assertClassBrand(_CometD_brand, this, _notifyCallback).call(this, unsubscribeCallback, {
-            id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-            successful: true,
-            channel: "/meta/unsubscribe",
-            subscription: channel
-          });
-        }, 0);
-      }
-    }
-  }
-  resubscribe(subscription, subscribeProps) {
-    _assertClassBrand(_CometD_brand, this, _removeSubscription).call(this, subscription);
-    if (subscription) {
-      return this.subscribe(subscription.channel, subscription.scope, subscription.callback, subscribeProps);
-    }
-    return undefined;
-  }
-  /**
-   * Removes all subscriptions added via {@link #subscribe(channel, scope, callback, subscribeProps)},
-   * but does not remove the listeners added via {@link addListener(channel, scope, callback)}.
-   */
-  clearSubscriptions() {
-    _assertClassBrand(_CometD_brand, this, _clearSubscriptions).call(this);
-  }
-  /**
-   * Publishes a message on the given channel, containing the given content.
-   * @param channel the channel to publish the message to
-   * @param content the content of the message
-   * @param publishProps an object to be merged with the publish message
-   * @param publishCallback a function to be invoked when the publish is acknowledged by the server
-   */
-  publish(channel, content, publishProps, publishCallback) {
-    if (arguments.length < 1) {
-      throw new Error("Illegal arguments number: required 1, got " + arguments.length);
-    }
-    if (!_isValidChannel.call(CometD, channel)) {
-      throw new Error("Illegal argument: invalid channel " + channel);
-    }
-    if (/^\/meta\//.test(channel)) {
-      throw new Error("Illegal argument: cannot publish to meta channels");
-    }
-    if (this.isDisconnected()) {
-      throw new Error("Illegal state: disconnected");
-    }
-    if (_isFunction.call(CometD, content)) {
-      publishCallback = content;
-      content = {};
-      publishProps = undefined;
-    } else if (_isFunction.call(CometD, publishProps)) {
-      publishCallback = publishProps;
-      publishProps = undefined;
-    }
-    const bayeuxMessage = {
-      id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-      channel: channel,
-      data: content
-    };
-    // Do not allow the user to override important fields.
-    const message = this._mixin(false, {}, publishProps, bayeuxMessage);
-
-    // Save the callback.
-    this._putCallback(message.id, publishCallback);
-    _assertClassBrand(_CometD_brand, this, _queueSend).call(this, message);
-  }
-  /**
-   * Publishes a message with binary data on the given channel.
-   * The binary data chunk may be an ArrayBuffer, a DataView, a TypedArray
-   * (such as Uint8Array) or a plain integer array.
-   * The metadata object may contain additional application data such as
-   * a file name, a mime type, etc.
-   * @param channel the channel to publish the message to
-   * @param data the binary data to publish
-   * @param last whether the binary data chunk is the last
-   * @param meta an object containing metadata associated to the binary chunk
-   * @param publishProps an object to be merged with the publish message
-   * @param publishCallback a function to be invoked when the publish is acknowledged by the server
-   */
-  publishBinary(channel, data, last, meta, publishProps, publishCallback) {
-    if (_isFunction.call(CometD, data)) {
-      publishCallback = data;
-      data = new ArrayBuffer(0);
-      last = true;
-      meta = undefined;
-      publishProps = undefined;
-    } else if (_isFunction.call(CometD, last)) {
-      publishCallback = last;
-      last = true;
-      meta = undefined;
-      publishProps = undefined;
-    } else if (_isFunction.call(CometD, meta)) {
-      publishCallback = meta;
-      meta = undefined;
-      publishProps = undefined;
-    } else if (_isFunction.call(CometD, publishProps)) {
-      publishCallback = publishProps;
-      publishProps = undefined;
-    }
-    const content = {
-      meta: meta,
-      data: data,
-      last: last
-    };
-    const ext = this._mixin(false, publishProps, {
-      ext: {
-        binary: {}
-      }
-    });
-    this.publish(channel, content, ext, publishCallback);
-  }
-  /**
-   * Performs a remote call, a request with a response, to the given target with the given data.
-   * The response returned by the server is notified the given callback function.
-   * The invocation may specify a timeout in milliseconds, after which the call is aborted on
-   * the client-side, causing a failed response to be passed to the given callback function.
-   * @param target the remote call target
-   * @param content the remote call content
-   * @param timeout the remote call timeout, or 0 for no timeout
-   * @param callProps an object to be merged with the remote call message
-   * @param callback the function to be invoked with the response
-   */
-  remoteCall(target, content, timeout, callProps, callback) {
-    if (arguments.length < 1) {
-      throw new Error("Illegal arguments number: required 1, got " + arguments.length);
-    }
-    if (!_isString.call(CometD, target)) {
-      throw new Error("Illegal argument type: target must be a string");
-    }
-    if (this.isDisconnected()) {
-      throw new Error("Illegal state: disconnected");
-    }
-    if (_isFunction.call(CometD, content)) {
-      callback = content;
-      content = {};
-      timeout = _classPrivateFieldGet(_config, this).maxNetworkDelay;
-      callProps = undefined;
-    } else if (_isFunction.call(CometD, timeout)) {
-      callback = timeout;
-      timeout = _classPrivateFieldGet(_config, this).maxNetworkDelay;
-      callProps = undefined;
-    } else if (_isFunction.call(CometD, callProps)) {
-      callback = callProps;
-      callProps = undefined;
-    }
-    if (typeof timeout !== "number") {
-      throw new Error("Illegal argument type: timeout must be a number");
-    }
-    if (!target.match(/^\//)) {
-      target = "/" + target;
-    }
-    const channel = "/service" + target;
-    if (!_isValidChannel.call(CometD, channel)) {
-      throw new Error("Illegal argument: invalid target " + target);
-    }
-    const bayeuxMessage = {
-      id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-      channel: channel,
-      data: content
-    };
-    const message = this._mixin(false, {}, callProps, bayeuxMessage);
-    const context = {
-      callback: callback
-    };
-    if (timeout > 0) {
-      context.timeout = this.setTimeout(() => {
-        this._debug("Timing out remote call", message, "after", timeout, "ms");
-        _assertClassBrand(_CometD_brand, this, _failMessage).call(this, {
-          id: message.id,
-          error: "406::timeout",
-          successful: false,
-          failure: {
-            message: message,
-            reason: "Remote Call Timeout"
-          }
-        });
-      }, timeout);
-      this._debug("Scheduled remote call timeout", message, "in", timeout, "ms");
-    }
-    _classPrivateFieldGet(_remoteCalls, this)[message.id] = context;
-    _assertClassBrand(_CometD_brand, this, _queueSend).call(this, message);
-  }
-  /**
-   * Performs a remote call with binary data.
-   * @param target the remote call target
-   * @param data the remote call binary data
-   * @param last whether the binary data chunk is the last
-   * @param meta an object containing meta data associated to the binary chunk
-   * @param timeout the remote call timeout, or 0 for no timeout
-   * @param callProps an object to be merged with the remote call message
-   * @param callback the function to be invoked with the response
-   */
-  remoteCallBinary(target, data, last, meta, timeout, callProps, callback) {
-    if (_isFunction.call(CometD, data)) {
-      callback = data;
-      data = new ArrayBuffer(0);
-      last = true;
-      meta = undefined;
-      timeout = _classPrivateFieldGet(_config, this).maxNetworkDelay;
-      callProps = undefined;
-    } else if (_isFunction.call(CometD, last)) {
-      callback = last;
-      last = true;
-      meta = undefined;
-      timeout = _classPrivateFieldGet(_config, this).maxNetworkDelay;
-      callProps = undefined;
-    } else if (_isFunction.call(CometD, meta)) {
-      callback = meta;
-      meta = undefined;
-      timeout = _classPrivateFieldGet(_config, this).maxNetworkDelay;
-      callProps = undefined;
-    } else if (_isFunction.call(CometD, timeout)) {
-      callback = timeout;
-      timeout = _classPrivateFieldGet(_config, this).maxNetworkDelay;
-      callProps = undefined;
-    } else if (_isFunction.call(CometD, callProps)) {
-      callback = callProps;
-      callProps = undefined;
-    }
-    const content = {
-      meta: meta,
-      data: data,
-      last: last
-    };
-    const ext = this._mixin(false, callProps, {
-      ext: {
-        binary: {}
-      }
-    });
-    this.remoteCall(target, content, timeout, ext, callback);
-  }
-  /**
-   * Returns a string representing the status of the bayeux communication with the Bayeux server.
-   */
-  getStatus() {
-    return _classPrivateFieldGet(_status, this);
-  }
-
-  /**
-   * Returns whether this instance has been disconnected.
-   */
-  isDisconnected() {
-    return _assertClassBrand(_CometD_brand, this, _isDisconnected).call(this);
-  }
-
-  /**
-   * Sets the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
-   * Default value is 1 second, which means if there is a persistent failure the retries will happen
-   * after 1 second, then after 2 seconds, then after 3 seconds, etc. So for example with 15 seconds of
-   * elapsed time, there will be 5 retries (at 1, 3, 6, 10 and 15 seconds elapsed).
-   * @param period the backoff period to set
-   */
-  setBackoffIncrement(period) {
-    _classPrivateFieldGet(_config, this).backoffIncrement = period;
-  }
-  /**
-   * Returns the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
-   */
-  getBackoffIncrement() {
-    return _classPrivateFieldGet(_config, this).backoffIncrement;
-  }
-
-  /**
-   * Returns the backoff period to wait before retrying an unsuccessful or failed message.
-   */
-  getBackoffPeriod() {
-    return _classPrivateFieldGet(_backoff, this);
-  }
-
-  /**
-   * Increases the backoff period up to the maximum value configured.
-   * @returns the backoff period after increment
-   */
-  increaseBackoffPeriod() {
-    return _assertClassBrand(_CometD_brand, this, _increaseBackoff).call(this);
-  }
-
-  /**
-   * Resets the backoff period to zero.
-   */
-  resetBackoffPeriod() {
-    _assertClassBrand(_CometD_brand, this, _resetBackoff).call(this);
-  }
-  /**
-   * Sets the log level for console logging.
-   * Valid values are the strings "error", "warn", "info" and "debug", from
-   * less verbose to more verbose.
-   * @param level the log level string
-   */
-  setLogLevel(level) {
-    _classPrivateFieldGet(_config, this).logLevel = level;
-  }
-  /**
-   * Registers an extension whose callbacks are called for every incoming message
-   * (that comes from the server to this client implementation) and for every
-   * outgoing message (that originates from this client implementation for the
-   * server).
-   * The format of the extension object is the following:
-   * <pre>
-   * {
-   *     incoming: message => { ... },
-   *     outgoing: message => { ... }
-   * }
-   * </pre>
-   * Both properties are optional, but if they are present they will be called
-   * respectively for each incoming message and for each outgoing message.
-   * @param name the name of the extension
-   * @param extension the extension to register
-   * @return true if the extension was registered, false otherwise
-   */
-  registerExtension(name, extension) {
-    if (arguments.length < 2) {
-      throw new Error("Illegal arguments number: required 2, got " + arguments.length);
-    }
-    if (!_isString.call(CometD, name)) {
-      throw new Error("Illegal argument type: extension name must be a string");
-    }
-    let existing = false;
-    for (let i = 0; i < _classPrivateFieldGet(_extensions, this).length; ++i) {
-      const existingExtension = _classPrivateFieldGet(_extensions, this)[i];
-      if (existingExtension.name === name) {
-        existing = true;
-        break;
-      }
-    }
-    if (!existing) {
-      _classPrivateFieldGet(_extensions, this).push({
-        name: name,
-        extension: extension
-      });
-      this._debug("Registered extension", name);
-
-      // Callback for extensions
-      if (_isFunction.call(CometD, extension.registered)) {
-        extension.registered(name, this);
-      }
-      return true;
-    } else {
-      this._info("Could not register extension with name", name, "since another extension with the same name already exists");
-      return false;
-    }
-  }
-  /**
-   * Unregister an extension previously registered with
-   * {@link #registerExtension(name, extension)}.
-   * @param name the name of the extension to unregister.
-   * @return true if the extension was unregistered, false otherwise
-   */
-  unregisterExtension(name) {
-    if (!_isString.call(CometD, name)) {
-      throw new Error("Illegal argument type: extension name must be a string");
-    }
-    let unregistered = false;
-    for (let i = 0; i < _classPrivateFieldGet(_extensions, this).length; ++i) {
-      const extension = _classPrivateFieldGet(_extensions, this)[i];
-      if (extension.name === name) {
-        _classPrivateFieldGet(_extensions, this).splice(i, 1);
-        unregistered = true;
-        this._debug("Unregistered extension", name);
-
-        // Callback for extensions
-        const ext = extension.extension;
-        if (_isFunction.call(CometD, ext.unregistered)) {
-          ext.unregistered();
-        }
-        break;
-      }
-    }
-    return unregistered;
-  }
-  /**
-   * Find the extension registered with the given name.
-   * @param name the name of the extension to find
-   * @return the extension found or null if no extension with the given name has been registered
-   */
-  getExtension(name) {
-    for (let i = 0; i < _classPrivateFieldGet(_extensions, this).length; ++i) {
-      const extension = _classPrivateFieldGet(_extensions, this)[i];
-      if (extension.name === name) {
-        return extension.extension;
-      }
-    }
-    return null;
-  }
-  /**
-   * Returns the name assigned to this CometD object, or the string "default"
-   * if no name has been explicitly passed as parameter to the constructor.
-   */
-  getName() {
-    return _classPrivateFieldGet(_name, this);
-  }
-
-  /**
-   * Returns the clientId assigned by the Bayeux server during handshake.
-   */
-  getClientId() {
-    return _classPrivateFieldGet(_clientId, this);
-  }
-
-  /**
-   * Returns the URL of the Bayeux server.
-   */
-  getURL() {
-    const transport = this.getTransport();
-    if (transport) {
-      let url = transport.url;
-      if (url) {
-        return url;
-      }
-      url = _classPrivateFieldGet(_config, this).urls[transport.type];
-      if (url) {
-        return url;
-      }
-    }
-    return _classPrivateFieldGet(_config, this).url;
-  }
-  getTransport() {
-    return _classPrivateFieldGet(_transport, this);
-  }
-  getConfiguration() {
-    return this._mixin(true, {}, _classPrivateFieldGet(_config, this));
-  }
-  getAdvice() {
-    return this._mixin(true, {}, _classPrivateFieldGet(_advice, this));
-  }
-  setTimeout(funktion, delay) {
-    return _classPrivateFieldGet(_scheduler, this).setTimeout(() => {
-      try {
-        this._debug("Invoking timed function", funktion);
-        funktion();
-      } catch (x) {
-        this._debug("Exception invoking timed function", funktion, x);
-      }
-    }, delay);
-  }
-  clearTimeout(id) {
-    _classPrivateFieldGet(_scheduler, this).clearTimeout(id);
-  }
-}
-_CometD = CometD;
-function _fieldValue(object, name) {
-  try {
-    return object[name];
-  } catch (x) {
-    return undefined;
-  }
-}
-function _isString(value) {
-  if (value === undefined || value === null) {
-    return false;
-  }
-  return typeof value === "string" || value instanceof String;
-}
-function _isAlpha(char) {
-  if (char >= "A" && char <= "Z") {
-    return true;
-  }
-  return char >= "a" && char <= "z";
-}
-function _isNumeric(char) {
-  return char >= "0" && char <= "9";
-}
-function _isAllowed(char) {
-  switch (char) {
-    case " ":
-    case "!":
-    case "#":
-    case "$":
-    case "(":
-    case ")":
-    case "*":
-    case "+":
-    case "-":
-    case ".":
-    case "/":
-    case "@":
-    case "_":
-    case "{":
-    case "~":
-    case "}":
-      return true;
-    default:
-      return false;
-  }
-}
-function _isValidChannel(value) {
-  if (!_isString.call(_CometD, value)) {
-    return false;
-  }
-  if (value.length < 2) {
-    return false;
-  }
-  if (value.charAt(0) !== "/") {
-    return false;
-  }
-  for (let i = 1; i < value.length; ++i) {
-    const char = value.charAt(i);
-    if (_isAlpha.call(_CometD, char) || _isNumeric.call(_CometD, char) || _isAllowed.call(_CometD, char)) {
-      continue;
-    }
-    return false;
-  }
-  return true;
-}
-function _isFunction(value) {
-  if (value === undefined || value === null) {
-    return false;
-  }
-  return typeof value === "function";
-}
-function _zeroPad(value, length) {
-  let result = "";
-  while (--length > 0) {
-    if (value >= Math.pow(10, length)) {
-      break;
-    }
-    result += "0";
-  }
-  result += value;
-  return result;
-}
-function _log(level, args) {
-  if (window.console) {
-    const logger = window.console[level];
-    if (_isFunction.call(_CometD, logger)) {
-      const now = new Date();
-      [].splice.call(args, 0, 0, _zeroPad.call(_CometD, now.getHours(), 2) + ":" + _zeroPad.call(_CometD, now.getMinutes(), 2) + ":" + _zeroPad.call(_CometD, now.getSeconds(), 2) + "." + _zeroPad.call(_CometD, now.getMilliseconds(), 3));
-      logger.apply(window.console, args);
-    }
-  }
-}
-function _splitURL(url) {
-  // [1] = protocol://,
-  // [2] = host:port,
-  // [3] = host,
-  // [4] = IPv6_host,
-  // [5] = IPv4_host,
-  // [6] = :port,
-  // [7] = port,
-  // [8] = uri,
-  // [9] = rest (query / fragment)
-  return new RegExp("(^https?://)?(((\\[[^\\]]+])|([^:/?#]+))(:(\\d+))?)?([^?#]*)(.*)?").exec(url);
-}
-/**
- * Returns whether the given hostAndPort is cross domain.
- * The default implementation checks against window.location.host
- * but this function can be overridden to make it work in non-browser
- * environments.
- *
- * @param hostAndPort the host and port in format host:port
- * @return whether the given hostAndPort is cross domain
- */
-function _isCrossDomain(hostAndPort) {
-  if (window.location && window.location.host) {
-    if (hostAndPort) {
-      return hostAndPort !== window.location.host;
-    }
-  }
-  return false;
-}
-function _configure(configuration) {
-  this._debug("Configuring cometd object with", configuration);
-  // Support old style param, where only the Bayeux server URL was passed.
-  if (_isString.call(_CometD, configuration)) {
-    configuration = {
-      url: configuration
-    };
-  }
-  if (!configuration) {
-    configuration = {};
-  }
-  _classPrivateFieldSet(_config, this, this._mixin(false, _classPrivateFieldGet(_config, this), configuration));
-  const url = this.getURL();
-  if (!url) {
-    throw new Error("Missing required configuration parameter 'url' specifying the Bayeux server URL");
-  }
-
-  // Check if we're cross domain.
-  const urlParts = _splitURL.call(_CometD, url);
-  const hostAndPort = urlParts[2];
-  const uri = urlParts[8];
-  const afterURI = urlParts[9];
-  _classPrivateFieldSet(_crossDomain, this, _assertClassBrand(_CometD_brand, this, _isCrossDomain).call(this, hostAndPort));
-
-  // Check if appending extra path is supported.
-  if (_classPrivateFieldGet(_config, this).appendMessageTypeToURL) {
-    if (afterURI !== undefined && afterURI.length > 0) {
-      this._info("Appending message type to URI", uri, afterURI, "is not supported, disabling 'appendMessageTypeToURL' configuration");
-      _classPrivateFieldGet(_config, this).appendMessageTypeToURL = false;
-    } else {
-      const uriSegments = uri.split("/");
-      let lastSegmentIndex = uriSegments.length - 1;
-      if (uri.match(/\/$/)) {
-        lastSegmentIndex -= 1;
-      }
-      if (uriSegments[lastSegmentIndex].indexOf(".") >= 0) {
-        // Very likely the CometD servlet's URL pattern is mapped to an extension,
-        // such as *.cometd, so cannot add the extra path in this case.
-        this._info("Appending message type to URI", uri, "is not supported, disabling 'appendMessageTypeToURL' configuration");
-        _classPrivateFieldGet(_config, this).appendMessageTypeToURL = false;
-      }
-    }
-  }
-  if (window.Worker && window.Blob && window.URL && _classPrivateFieldGet(_config, this).useWorkerScheduler) {
-    let code = WorkerScheduler.toString();
-    // Remove the function declaration, the opening brace and the closing brace.
-    code = code.substring(code.indexOf("{") + 1, code.lastIndexOf("}"));
-    const blob = new window.Blob([code], {
-      type: "application/json"
-    });
-    const blobURL = window.URL.createObjectURL(blob);
-    const worker = new window.Worker(blobURL);
-    // Replace setTimeout() and clearTimeout() with the worker implementation.
-    _classPrivateFieldGet(_scheduler, this).setTimeout = (funktion, delay) => {
-      const id = _classPrivateFieldGet(_scheduler, this).register(funktion);
-      worker.postMessage({
-        id: id,
-        type: "setTimeout",
-        delay: delay
-      });
-      return id;
-    };
-    _classPrivateFieldGet(_scheduler, this).clearTimeout = id => {
-      _classPrivateFieldGet(_scheduler, this).unregister(id);
-      worker.postMessage({
-        id: id,
-        type: "clearTimeout"
-      });
-    };
-    worker.onmessage = e => {
-      const id = e.data.id;
-      const funktion = _classPrivateFieldGet(_scheduler, this).unregister(id);
-      if (funktion) {
-        funktion();
-      }
-    };
-  }
-}
-function _removeListener(subscription) {
-  if (subscription) {
-    const subscriptions = _classPrivateFieldGet(_listeners, this)[subscription.channel];
-    if (subscriptions && subscriptions[subscription.id]) {
-      delete subscriptions[subscription.id];
-      this._debug("Removed", subscription.listener ? "listener" : "subscription", subscription);
-    }
-  }
-}
-function _removeSubscription(subscription) {
-  if (subscription && !subscription.listener) {
-    _assertClassBrand(_CometD_brand, this, _removeListener).call(this, subscription);
-  }
-}
-function _clearSubscriptions() {
-  for (let channel in _classPrivateFieldGet(_listeners, this)) {
-    if (_classPrivateFieldGet(_listeners, this).hasOwnProperty(channel)) {
-      const subscriptions = _classPrivateFieldGet(_listeners, this)[channel];
-      if (subscriptions) {
-        for (let id in subscriptions) {
-          if (subscriptions.hasOwnProperty(id)) {
-            _assertClassBrand(_CometD_brand, this, _removeSubscription).call(this, subscriptions[id]);
-          }
-        }
-      }
-    }
-  }
-}
-function _setStatus(newStatus) {
-  const oldStatus = this.getStatus();
-  if (oldStatus !== newStatus) {
-    this._debug("Status", oldStatus, "->", newStatus);
-    _classPrivateFieldSet(_status, this, newStatus);
-  }
-}
-function _isDisconnected() {
-  const status = _classPrivateFieldGet(_status, this);
-  return status === "disconnecting" || status === "disconnected";
-}
-function _nextMessageId() {
-  var _this$messageId;
-  const result = _classPrivateFieldSet(_messageId, this, (_this$messageId = _classPrivateFieldGet(_messageId, this), ++_this$messageId));
-  return "" + result;
-}
-function _applyExtension(scope, callback, name, message, outgoing) {
-  try {
-    return callback.call(scope, message);
-  } catch (x) {
-    const handler = this.onExtensionException;
-    if (_isFunction.call(_CometD, handler)) {
-      this._debug("Invoking extension exception handler", name, x);
-      try {
-        handler.call(this, x, name, outgoing, message);
-      } catch (xx) {
-        this._info("Exception during execution of extension exception handler", name, xx);
-      }
-    } else {
-      this._info("Exception during execution of extension", name, x);
-    }
-    return message;
-  }
-}
-function _applyIncomingExtensions(message) {
-  for (let i = 0; i < _classPrivateFieldGet(_extensions, this).length; ++i) {
-    if (message === undefined || message === null) {
-      break;
-    }
-    const extension = _classPrivateFieldGet(_extensions, this)[i];
-    const callback = extension.extension.incoming;
-    if (_isFunction.call(_CometD, callback)) {
-      const result = _assertClassBrand(_CometD_brand, this, _applyExtension).call(this, extension.extension, callback, extension.name, message, false);
-      message = result === undefined ? message : result;
-    }
-  }
-  return message;
-}
-function _applyOutgoingExtensions(message) {
-  for (let i = _classPrivateFieldGet(_extensions, this).length - 1; i >= 0; --i) {
-    if (message === undefined || message === null) {
-      break;
-    }
-    const extension = _classPrivateFieldGet(_extensions, this)[i];
-    const callback = extension.extension.outgoing;
-    if (_isFunction.call(_CometD, callback)) {
-      const result = _assertClassBrand(_CometD_brand, this, _applyExtension).call(this, extension.extension, callback, extension.name, message, true);
-      message = result === undefined ? message : result;
-    }
-  }
-  return message;
-}
-function _notify(channel, message) {
-  const subscriptions = _classPrivateFieldGet(_listeners, this)[channel];
-  if (subscriptions) {
-    for (let id in subscriptions) {
-      if (subscriptions.hasOwnProperty(id)) {
-        const subscription = subscriptions[id];
-        // Subscriptions may come and go, so the array may have holes.
-        if (subscription) {
-          try {
-            subscription.callback.call(subscription.scope, message);
-          } catch (x) {
-            const handler = this.onListenerException;
-            if (_isFunction.call(_CometD, handler)) {
-              this._debug("Invoking listener exception handler", subscription, x);
-              try {
-                handler.call(this, x, subscription, subscription.listener, message);
-              } catch (xx) {
-                this._info("Exception during execution of listener exception handler", subscription, xx);
-              }
-            } else {
-              this._info("Exception during execution of listener", subscription, message, x);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-function _notifyListeners(channel, message) {
-  // Notify direct listeners
-  _assertClassBrand(_CometD_brand, this, _notify).call(this, channel, message);
-
-  // Notify the globbing listeners
-  const channelParts = channel.split("/");
-  const last = channelParts.length - 1;
-  for (let i = last; i > 0; --i) {
-    let channelPart = channelParts.slice(0, i).join("/") + "/*";
-    // We don't want to notify /foo/* if the channel is /foo/bar/baz,
-    // so we stop at the first non-recursive globbing.
-    if (i === last) {
-      _assertClassBrand(_CometD_brand, this, _notify).call(this, channelPart, message);
-    }
-    // Add the recursive globber and notify.
-    channelPart += "*";
-    _assertClassBrand(_CometD_brand, this, _notify).call(this, channelPart, message);
-  }
-}
-function _cancelDelayedSend() {
-  if (_classPrivateFieldGet(_scheduledSend, this) !== null) {
-    this.clearTimeout(_classPrivateFieldGet(_scheduledSend, this));
-  }
-  _classPrivateFieldSet(_scheduledSend, this, null);
-}
-function _delayedSend(operation, delay) {
-  _assertClassBrand(_CometD_brand, this, _cancelDelayedSend).call(this);
-  const time = _classPrivateFieldGet(_advice, this).interval + delay;
-  this._debug("Function scheduled in", time, "ms, interval =", _classPrivateFieldGet(_advice, this).interval, "backoff =", _classPrivateFieldGet(_backoff, this), operation);
-  _classPrivateFieldSet(_scheduledSend, this, this.setTimeout(operation, time));
-}
-/**
- * Delivers the messages to the CometD server
- * @param messages the array of messages to send
- * @param metaConnect true if this send is on /meta/connect
- * @param extraPath an extra path to append to the Bayeux server URL
- */
-function _send(messages, metaConnect, extraPath) {
-  // We must be sure that the messages have a clientId.
-  // This is not guaranteed since the handshake may take time to return
-  // (and hence the clientId is not known yet) and the application
-  // may create other messages.
-  for (let i = 0; i < messages.length; ++i) {
-    let message = messages[i];
-    const messageId = message.id;
-    const clientId = this.getClientId();
-    if (clientId) {
-      message.clientId = clientId;
-    }
-    message = _assertClassBrand(_CometD_brand, this, _applyOutgoingExtensions).call(this, message);
-    if (message !== undefined && message !== null) {
-      // Extensions may have modified the message id, but we need to own it.
-      message.id = messageId;
-      messages[i] = message;
-    } else {
-      delete _classPrivateFieldGet(_callbacks, this)[messageId];
-      messages.splice(i--, 1);
-    }
-  }
-  if (messages.length === 0) {
-    return;
-  }
-  if (metaConnect) {
-    _classPrivateFieldSet(_metaConnect, this, messages[0]);
-  }
-  let url = this.getURL();
-  if (_classPrivateFieldGet(_config, this).appendMessageTypeToURL) {
-    // If url does not end with "/", then append it
-    if (!url.match(/\/$/)) {
-      url = url + "/";
-    }
-    if (extraPath) {
-      url = url + extraPath;
-    }
-  }
-  const envelope = {
-    url: url,
-    sync: false,
-    messages: messages,
-    onSuccess: rcvdMessages => {
-      try {
-        _assertClassBrand(_CometD_brand, this, _handleMessages).call(this, rcvdMessages);
-      } catch (x) {
-        this._info("Exception during handling of messages", x);
-      }
-    },
-    onFailure: (conduit, messages, failure) => {
-      try {
-        const transport = this.getTransport();
-        failure.connectionType = transport ? transport.type : "unknown";
-        _assertClassBrand(_CometD_brand, this, _handleFailure).call(this, conduit, messages, failure);
-      } catch (x) {
-        this._info("Exception during handling of failure", x);
-      }
-    }
-  };
-  this._debug("Send", envelope);
-  this.getTransport().send(envelope, metaConnect);
-}
-function _queueSend(message) {
-  if (_classPrivateFieldGet(_batch, this) > 0 || _classPrivateFieldGet(_internalBatch, this) === true) {
-    _classPrivateFieldGet(_messageQueue, this).push(message);
-  } else {
-    _assertClassBrand(_CometD_brand, this, _send).call(this, [message], false);
-  }
-}
-function _resetBackoff() {
-  _classPrivateFieldSet(_backoff, this, 0);
-}
-function _increaseBackoff() {
-  if (_classPrivateFieldGet(_backoff, this) < _classPrivateFieldGet(_config, this).maxBackoff) {
-    _classPrivateFieldSet(_backoff, this, _classPrivateFieldGet(_backoff, this) + this.getBackoffIncrement());
-  }
-  return _classPrivateFieldGet(_backoff, this);
-}
-/**
- * Starts the batch of messages to be sent in a single request.
- */
-function _startBatch() {
-  var _this$batch;
-  _classPrivateFieldSet(_batch, this, (_this$batch = _classPrivateFieldGet(_batch, this), ++_this$batch));
-  this._debug("Starting batch, depth", _classPrivateFieldGet(_batch, this));
-}
-function _flushBatch() {
-  const messages = _classPrivateFieldGet(_messageQueue, this);
-  _classPrivateFieldSet(_messageQueue, this, []);
-  if (messages.length > 0) {
-    _assertClassBrand(_CometD_brand, this, _send).call(this, messages, false);
-  }
-}
-/**
- * Ends the batch of messages to be sent in a single request,
- * optionally sending messages present in the message queue depending
- * on the given argument.
- */
-function _endBatch() {
-  var _this$batch2;
-  _classPrivateFieldSet(_batch, this, (_this$batch2 = _classPrivateFieldGet(_batch, this), --_this$batch2));
-  this._debug("Ending batch, depth", _classPrivateFieldGet(_batch, this));
-  if (_classPrivateFieldGet(_batch, this) < 0) {
-    throw new Error("Calls to startBatch() and endBatch() are not paired");
-  }
-  if (_classPrivateFieldGet(_batch, this) === 0 && !this.isDisconnected() && !_classPrivateFieldGet(_internalBatch, this)) {
-    _assertClassBrand(_CometD_brand, this, _flushBatch).call(this);
-  }
-}
-/**
- * Sends the connect message
- */
-function _connect() {
-  if (!this.isDisconnected()) {
-    const bayeuxMessage = {
-      id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-      channel: "/meta/connect",
-      connectionType: this.getTransport().type
-    };
-
-    // In case of reload or temporary loss of connection
-    // we want the next successful connect to return immediately
-    // instead of being held by the server, so that connect listeners
-    // can be notified that the connection has been re-established
-    if (!_classPrivateFieldGet(_connected, this)) {
-      bayeuxMessage.advice = {
-        timeout: 0
-      };
-    }
-    _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "connecting");
-    this._debug("Connect sent", bayeuxMessage);
-    _assertClassBrand(_CometD_brand, this, _send).call(this, [bayeuxMessage], true, "connect");
-    _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "connected");
-  }
-}
-function _delayedConnect(delay) {
-  _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "connecting");
-  _assertClassBrand(_CometD_brand, this, _delayedSend).call(this, () => {
-    _assertClassBrand(_CometD_brand, this, _connect).call(this);
-  }, delay);
-}
-function _updateAdvice(newAdvice) {
-  if (newAdvice) {
-    _classPrivateFieldSet(_advice, this, this._mixin(false, {}, _classPrivateFieldGet(_config, this).advice, newAdvice));
-    this._debug("New advice", _classPrivateFieldGet(_advice, this));
-  }
-}
-function _disconnect(abort) {
-  _assertClassBrand(_CometD_brand, this, _cancelDelayedSend).call(this);
-  const transport = this.getTransport();
-  if (abort && transport) {
-    transport.abort();
-  }
-  _classPrivateFieldSet(_crossDomain, this, false);
-  _classPrivateFieldSet(_transport, this, null);
-  _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "disconnected");
-  _classPrivateFieldSet(_clientId, this, null);
-  _classPrivateFieldSet(_batch, this, 0);
-  _assertClassBrand(_CometD_brand, this, _resetBackoff).call(this);
-  _classPrivateFieldSet(_reestablish, this, false);
-  _classPrivateFieldSet(_connected, this, false);
-  _classPrivateFieldSet(_unconnectTime, this, 0);
-  _classPrivateFieldSet(_metaConnect, this, null);
-
-  // Fail any existing queued message
-  if (_classPrivateFieldGet(_messageQueue, this).length > 0) {
-    const messages = _classPrivateFieldGet(_messageQueue, this);
-    _classPrivateFieldSet(_messageQueue, this, []);
-    _assertClassBrand(_CometD_brand, this, _handleFailure).call(this, undefined, messages, {
-      reason: "Disconnected"
-    });
-  }
-}
-function _notifyTransportException(oldTransport, newTransport, failure) {
-  const handler = this.onTransportException;
-  if (_isFunction.call(_CometD, handler)) {
-    this._debug("Invoking transport exception handler", oldTransport, newTransport, failure);
-    try {
-      handler.call(this, failure, oldTransport, newTransport);
-    } catch (x) {
-      this._info("Exception during execution of transport exception handler", x);
-    }
-  }
-}
-/**
- * Sends the initial handshake message
- */
-function _handshake(handshakeProps, handshakeCallback) {
-  if (_isFunction.call(_CometD, handshakeProps)) {
-    handshakeCallback = handshakeProps;
-    handshakeProps = undefined;
-  }
-  _classPrivateFieldSet(_clientId, this, null);
-  this.clearSubscriptions();
-
-  // Reset the transports if we're not retrying the handshake
-  if (this.isDisconnected()) {
-    _classPrivateFieldGet(_transports, this).reset(true);
-  }
-
-  // Reset the advice.
-  _assertClassBrand(_CometD_brand, this, _updateAdvice).call(this, {});
-  _classPrivateFieldSet(_batch, this, 0);
-
-  // Mark the start of an internal batch.
-  // This is needed because handshake and connect are async.
-  // It may happen that the application calls init() then subscribe()
-  // and the subscribe message is sent before the connect message, if
-  // the subscribe message is not held until the connect message is sent.
-  // So here we start a batch to hold temporarily any message until
-  // the connection is fully established.
-  _classPrivateFieldSet(_internalBatch, this, true);
-
-  // Save the properties provided by the user, so that
-  // we can reuse them during automatic re-handshake
-  _classPrivateFieldSet(_handshakeProps, this, handshakeProps);
-  _classPrivateFieldSet(_handshakeCallback, this, handshakeCallback);
-  const version = "1.0";
-
-  // Figure out the transports to send to the server
-  const url = this.getURL();
-  const transportTypes = _classPrivateFieldGet(_transports, this).findTransportTypes(version, _classPrivateFieldGet(_crossDomain, this), url);
-  const bayeuxMessage = {
-    id: _assertClassBrand(_CometD_brand, this, _nextMessageId).call(this),
-    version: version,
-    minimumVersion: version,
-    channel: "/meta/handshake",
-    supportedConnectionTypes: transportTypes,
-    advice: {
-      timeout: _classPrivateFieldGet(_advice, this).timeout,
-      interval: _classPrivateFieldGet(_advice, this).interval
-    }
-  };
-  // Do not allow the user to override important fields.
-  const message = this._mixin(false, {}, _classPrivateFieldGet(_handshakeProps, this), bayeuxMessage);
-
-  // Save the callback.
-  this._putCallback(message.id, handshakeCallback);
-
-  // Pick up the first available transport as initial transport
-  // since we don't know if the server supports it
-  if (!_classPrivateFieldGet(_transport, this)) {
-    _classPrivateFieldSet(_transport, this, _classPrivateFieldGet(_transports, this).negotiateTransport(transportTypes, version, _classPrivateFieldGet(_crossDomain, this), url));
-    if (!_classPrivateFieldGet(_transport, this)) {
-      const failure = "Could not find initial transport among: " + this.getTransportTypes();
-      this._warn(failure);
-      throw new Error(failure);
-    }
-  }
-  this._debug("Initial transport is", _classPrivateFieldGet(_transport, this).type);
-
-  // We started a batch to hold the application messages,
-  // so here we must bypass it and send immediately.
-  _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "handshaking");
-  this._debug("Handshake sent", message);
-  _assertClassBrand(_CometD_brand, this, _send).call(this, [message], false, "handshake");
-}
-function _delayedHandshake(delay) {
-  _assertClassBrand(_CometD_brand, this, _setStatus).call(this, "handshaking");
-
-  // We will call #handshake() which will reset #clientId, but we want to avoid
-  // that between the end of this method and the call to #handshake() someone may
-  // call publish() (or other methods that call #queueSend()).
-  _classPrivateFieldSet(_internalBatch, this, true);
-  _assertClassBrand(_CometD_brand, this, _delayedSend).call(this, () => {
-    _assertClassBrand(_CometD_brand, this, _handshake).call(this, _classPrivateFieldGet(_handshakeProps, this), _classPrivateFieldGet(_handshakeCallback, this));
-  }, delay);
-}
-function _notifyCallback(callback, message) {
-  try {
-    callback.call(this, message);
-  } catch (x) {
-    const handler = this.onCallbackException;
-    if (_isFunction.call(_CometD, handler)) {
-      this._debug("Invoking callback exception handler", x);
-      try {
-        handler.call(this, x, message);
-      } catch (xx) {
-        this._info("Exception during execution of callback exception handler", xx);
-      }
-    } else {
-      this._info("Exception during execution of message callback", x);
-    }
-  }
-}
-function _handleCallback(message) {
-  const callback = this._getCallback([message.id]);
-  if (_isFunction.call(_CometD, callback)) {
-    delete _classPrivateFieldGet(_callbacks, this)[message.id];
-    _assertClassBrand(_CometD_brand, this, _notifyCallback).call(this, callback, message);
-  }
-}
-function _handleRemoteCall(message) {
-  const context = _classPrivateFieldGet(_remoteCalls, this)[message.id];
-  delete _classPrivateFieldGet(_remoteCalls, this)[message.id];
-  if (context) {
-    this._debug("Handling remote call response for", message, "with context", context);
-
-    // Clear the timeout, if present.
-    const timeout = context.timeout;
-    if (timeout) {
-      this.clearTimeout(timeout);
-    }
-    const callback = context.callback;
-    if (_isFunction.call(_CometD, callback)) {
-      _assertClassBrand(_CometD_brand, this, _notifyCallback).call(this, callback, message);
-      return true;
-    }
-  }
-  return false;
-}
-function _handleTransportFailure(failureInfo) {
-  this._debug("Transport failure handling", failureInfo);
-  if (failureInfo.transport) {
-    _classPrivateFieldSet(_transport, this, failureInfo.transport);
-  }
-  if (failureInfo.url) {
-    _classPrivateFieldGet(_transport, this).url = failureInfo.url;
-  }
-  const action = failureInfo.action;
-  const delay = failureInfo.delay || 0;
-  switch (action) {
-    case "handshake":
-      _assertClassBrand(_CometD_brand, this, _delayedHandshake).call(this, delay);
-      break;
-    case "retry":
-      _assertClassBrand(_CometD_brand, this, _delayedConnect).call(this, delay);
-      break;
-    case "none":
-      _assertClassBrand(_CometD_brand, this, _disconnect).call(this, true);
-      break;
-    default:
-      throw new Error("Unknown action " + action);
-  }
-}
-function _failHandshake(message, failureInfo) {
-  _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/handshake", message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsuccessful", message);
-
-  // The listeners may have disconnected.
-  if (this.isDisconnected()) {
-    failureInfo.action = "none";
-  }
-  this.onTransportFailure(message, failureInfo, failureInfo => _assertClassBrand(_CometD_brand, this, _handleTransportFailure).call(this, failureInfo));
-}
-function _handshakeResponse(message) {
-  const url = this.getURL();
-  if (message.successful) {
-    const crossDomain = _assertClassBrand(_CometD_brand, this, _isCrossDomain).call(this, _splitURL.call(_CometD, url)[2]);
-    const newTransport = _classPrivateFieldGet(_transports, this).negotiateTransport(message.supportedConnectionTypes, message.version, crossDomain, url);
-    if (newTransport === null) {
-      message.successful = false;
-      _assertClassBrand(_CometD_brand, this, _failHandshake).call(this, message, {
-        cause: "negotiation",
-        action: "none",
-        transport: null
-      });
-      return;
-    } else {
-      const oldTransport = _classPrivateFieldGet(_transport, this);
-      if (oldTransport !== newTransport) {
-        this._debug("Transport", oldTransport && oldTransport.type, "->", newTransport.type);
-        _classPrivateFieldSet(_transport, this, newTransport);
-      }
-    }
-    _classPrivateFieldSet(_clientId, this, message.clientId);
-
-    // End the internal batch and allow held messages from the application
-    // to go to the server (see #handshake() where we start the internal batch).
-    _classPrivateFieldSet(_internalBatch, this, false);
-    _assertClassBrand(_CometD_brand, this, _flushBatch).call(this);
-
-    // Here the new transport is in place, as well as the clientId, so
-    // the listeners can perform a publish() if they want.
-    // Notify the listeners before the connect below.
-    message.reestablish = _classPrivateFieldGet(_reestablish, this);
-    _classPrivateFieldSet(_reestablish, this, true);
-    _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-    _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/handshake", message);
-    _classPrivateFieldSet(_handshakeMessages, this, message["x-messages"] || 0);
-    const action = this.isDisconnected() ? "none" : _classPrivateFieldGet(_advice, this).reconnect || "retry";
-    switch (action) {
-      case "retry":
-        _assertClassBrand(_CometD_brand, this, _resetBackoff).call(this);
-        if (_classPrivateFieldGet(_handshakeMessages, this) === 0) {
-          _assertClassBrand(_CometD_brand, this, _delayedConnect).call(this, 0);
-        } else {
-          this._debug("Processing", _classPrivateFieldGet(_handshakeMessages, this), "handshake-delivered messages");
-        }
-        break;
-      case "none":
-        _assertClassBrand(_CometD_brand, this, _disconnect).call(this, true);
-        break;
-      default:
-        throw new Error("Unrecognized advice action " + action);
-    }
-  } else {
-    _assertClassBrand(_CometD_brand, this, _failHandshake).call(this, message, {
-      cause: "unsuccessful",
-      action: _classPrivateFieldGet(_advice, this).reconnect || "handshake",
-      transport: this.getTransport()
-    });
-  }
-}
-function _handshakeFailure(message) {
-  _assertClassBrand(_CometD_brand, this, _failHandshake).call(this, message, {
-    cause: "failure",
-    action: "handshake",
-    transport: null
-  });
-}
-function _matchMetaConnect(connect) {
-  if (this.getStatus() === "disconnected") {
-    return true;
-  }
-  if (_classPrivateFieldGet(_metaConnect, this) && _classPrivateFieldGet(_metaConnect, this).id === connect.id) {
-    _classPrivateFieldSet(_metaConnect, this, null);
-    return true;
-  }
-  return false;
-}
-function _failConnect(message, failureInfo) {
-  // Notify the listeners after the status change but before the next action.
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/connect", message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsuccessful", message);
-
-  // The listeners may have disconnected.
-  if (this.isDisconnected()) {
-    failureInfo.action = "none";
-  }
-  this.onTransportFailure(message, failureInfo, failureInfo => _assertClassBrand(_CometD_brand, this, _handleTransportFailure).call(this, failureInfo));
-}
-function _connectResponse(message) {
-  if (_assertClassBrand(_CometD_brand, this, _matchMetaConnect).call(this, message)) {
-    _classPrivateFieldSet(_connected, this, message.successful);
-    if (_classPrivateFieldGet(_connected, this)) {
-      _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/connect", message);
-
-      // Normally, the advice will say "reconnect: "retry", interval: 0"
-      // and the server will hold the request, so when a response returns
-      // we immediately call the server again (long polling).
-      // Listeners can call disconnect(), so check the state after they run.
-      const action = this.isDisconnected() ? "none" : _classPrivateFieldGet(_advice, this).reconnect || "retry";
-      switch (action) {
-        case "retry":
-          _assertClassBrand(_CometD_brand, this, _resetBackoff).call(this);
-          _assertClassBrand(_CometD_brand, this, _delayedConnect).call(this, _classPrivateFieldGet(_backoff, this));
-          break;
-        case "none":
-          _assertClassBrand(_CometD_brand, this, _disconnect).call(this, false);
-          break;
-        default:
-          throw new Error("Unrecognized advice action " + action);
-      }
-    } else {
-      _assertClassBrand(_CometD_brand, this, _failConnect).call(this, message, {
-        cause: "unsuccessful",
-        action: _classPrivateFieldGet(_advice, this).reconnect || "retry",
-        transport: this.getTransport()
-      });
-    }
-  } else {
-    this._debug("Mismatched /meta/connect reply", message);
-  }
-}
-function _connectFailure(message) {
-  if (_assertClassBrand(_CometD_brand, this, _matchMetaConnect).call(this, message)) {
-    _classPrivateFieldSet(_connected, this, false);
-    _assertClassBrand(_CometD_brand, this, _failConnect).call(this, message, {
-      cause: "failure",
-      action: "retry",
-      transport: null
-    });
-  } else {
-    this._debug("Mismatched /meta/connect failure", message);
-  }
-}
-function _failDisconnect(message) {
-  _assertClassBrand(_CometD_brand, this, _disconnect).call(this, true);
-  _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/disconnect", message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsuccessful", message);
-}
-function _disconnectResponse(message) {
-  if (message.successful) {
-    // Wait for the /meta/connect to arrive.
-    _assertClassBrand(_CometD_brand, this, _disconnect).call(this, false);
-    _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-    _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/disconnect", message);
-  } else {
-    _assertClassBrand(_CometD_brand, this, _failDisconnect).call(this, message);
-  }
-}
-function _disconnectFailure(message) {
-  _assertClassBrand(_CometD_brand, this, _failDisconnect).call(this, message);
-}
-function _failSubscribe(message) {
-  const subscriptions = _classPrivateFieldGet(_listeners, this)[message.subscription];
-  if (subscriptions) {
-    for (let id in subscriptions) {
-      if (subscriptions.hasOwnProperty(id)) {
-        const subscription = subscriptions[id];
-        if (subscription && !subscription.listener) {
-          delete subscriptions[id];
-          this._debug("Removed failed subscription", subscription);
-        }
-      }
-    }
-  }
-  _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/subscribe", message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsuccessful", message);
-}
-function _subscribeResponse(message) {
-  if (message.successful) {
-    _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-    _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/subscribe", message);
-  } else {
-    _assertClassBrand(_CometD_brand, this, _failSubscribe).call(this, message);
-  }
-}
-function _subscribeFailure(message) {
-  _assertClassBrand(_CometD_brand, this, _failSubscribe).call(this, message);
-}
-function _failUnsubscribe(message) {
-  _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsubscribe", message);
-  _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsuccessful", message);
-}
-function _unsubscribeResponse(message) {
-  if (message.successful) {
-    _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-    _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsubscribe", message);
-  } else {
-    _assertClassBrand(_CometD_brand, this, _failUnsubscribe).call(this, message);
-  }
-}
-function _unsubscribeFailure(message) {
-  _assertClassBrand(_CometD_brand, this, _failUnsubscribe).call(this, message);
-}
-function _failMessage(message) {
-  if (!_assertClassBrand(_CometD_brand, this, _handleRemoteCall).call(this, message)) {
-    _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-    _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/publish", message);
-    _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/unsuccessful", message);
-  }
-}
-function _messageResponse(message) {
-  if (message.data !== undefined) {
-    if (!_assertClassBrand(_CometD_brand, this, _handleRemoteCall).call(this, message)) {
-      _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, message.channel, message);
-      if (_classPrivateFieldGet(_handshakeMessages, this) > 0) {
-        var _this$handshakeMessag;
-        _classPrivateFieldSet(_handshakeMessages, this, (_this$handshakeMessag = _classPrivateFieldGet(_handshakeMessages, this), --_this$handshakeMessag));
-        if (_classPrivateFieldGet(_handshakeMessages, this) === 0) {
-          this._debug("Processed last handshake-delivered message");
-          _assertClassBrand(_CometD_brand, this, _delayedConnect).call(this, 0);
-        }
-      }
-    }
-  } else {
-    if (message.successful === undefined) {
-      this._warn("Unknown Bayeux Message", message);
-    } else {
-      if (message.successful) {
-        _assertClassBrand(_CometD_brand, this, _handleCallback).call(this, message);
-        _assertClassBrand(_CometD_brand, this, _notifyListeners).call(this, "/meta/publish", message);
-      } else {
-        _assertClassBrand(_CometD_brand, this, _failMessage).call(this, message);
-      }
-    }
-  }
-}
-function _messageFailure(failure) {
-  _assertClassBrand(_CometD_brand, this, _failMessage).call(this, failure);
-}
-function _receive(message) {
-  _classPrivateFieldSet(_unconnectTime, this, 0);
-  message = _assertClassBrand(_CometD_brand, this, _applyIncomingExtensions).call(this, message);
-  if (message === undefined || message === null) {
-    return;
-  }
-  _assertClassBrand(_CometD_brand, this, _updateAdvice).call(this, message.advice);
-  const channel = message.channel;
-  switch (channel) {
-    case "/meta/handshake":
-      _assertClassBrand(_CometD_brand, this, _handshakeResponse).call(this, message);
-      break;
-    case "/meta/connect":
-      _assertClassBrand(_CometD_brand, this, _connectResponse).call(this, message);
-      break;
-    case "/meta/disconnect":
-      _assertClassBrand(_CometD_brand, this, _disconnectResponse).call(this, message);
-      break;
-    case "/meta/subscribe":
-      _assertClassBrand(_CometD_brand, this, _subscribeResponse).call(this, message);
-      break;
-    case "/meta/unsubscribe":
-      _assertClassBrand(_CometD_brand, this, _unsubscribeResponse).call(this, message);
-      break;
-    default:
-      _assertClassBrand(_CometD_brand, this, _messageResponse).call(this, message);
-      break;
-  }
-}
-function _handleMessages(rcvdMessages) {
-  this._debug("Received", rcvdMessages);
-  for (let i = 0; i < rcvdMessages.length; ++i) {
-    const message = rcvdMessages[i];
-    this.receive(message);
-  }
-}
-function _handleFailure(conduit, messages, failure) {
-  this._debug("handleFailure", conduit, messages, failure);
-  failure.transport = conduit;
-  for (let i = 0; i < messages.length; ++i) {
-    const message = messages[i];
-    const failureMessage = {
-      id: message.id,
-      successful: false,
-      channel: message.channel,
-      failure: failure
-    };
-    failure.message = message;
-    switch (message.channel) {
-      case "/meta/handshake":
-        _assertClassBrand(_CometD_brand, this, _handshakeFailure).call(this, failureMessage);
-        break;
-      case "/meta/connect":
-        _assertClassBrand(_CometD_brand, this, _connectFailure).call(this, failureMessage);
-        break;
-      case "/meta/disconnect":
-        _assertClassBrand(_CometD_brand, this, _disconnectFailure).call(this, failureMessage);
-        break;
-      case "/meta/subscribe":
-        failureMessage.subscription = message.subscription;
-        _assertClassBrand(_CometD_brand, this, _subscribeFailure).call(this, failureMessage);
-        break;
-      case "/meta/unsubscribe":
-        failureMessage.subscription = message.subscription;
-        _assertClassBrand(_CometD_brand, this, _unsubscribeFailure).call(this, failureMessage);
-        break;
-      default:
-        _assertClassBrand(_CometD_brand, this, _messageFailure).call(this, failureMessage);
-        break;
-    }
-  }
-}
-function _hasSubscriptions(channel) {
-  const subscriptions = _classPrivateFieldGet(_listeners, this)[channel];
-  if (subscriptions) {
-    for (let id in subscriptions) {
-      if (subscriptions.hasOwnProperty(id)) {
-        if (subscriptions[id]) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-function _resolveScopedCallback(scope, callback) {
-  const delegate = {
-    scope: scope,
-    method: callback
-  };
-  if (_isFunction.call(_CometD, scope)) {
-    delegate.scope = undefined;
-    delegate.method = scope;
-  } else {
-    if (_isString.call(_CometD, callback)) {
-      if (!scope) {
-        throw new Error("Invalid scope " + scope);
-      }
-      delegate.method = scope[callback];
-      if (!_isFunction.call(_CometD, delegate.method)) {
-        throw new Error("Invalid callback " + callback + " for scope " + scope);
-      }
-    } else if (!_isFunction.call(_CometD, callback)) {
-      throw new Error("Invalid callback " + callback);
-    }
-  }
-  return delegate;
-}
-function _addListener(channel, scope, callback, isListener) {
-  var _this$listenerId;
-  // The data structure is a map<channel, subscription[]>, where each subscription
-  // holds the callback to be called and its scope.
-
-  const delegate = _assertClassBrand(_CometD_brand, this, _resolveScopedCallback).call(this, scope, callback);
-  this._debug("Adding", isListener ? "listener" : "subscription", "on", channel, "with scope", delegate.scope, "and callback", delegate.method);
-  const id = _classPrivateFieldSet(_listenerId, this, (_this$listenerId = _classPrivateFieldGet(_listenerId, this), ++_this$listenerId));
-  const subscription = {
-    id: id,
-    channel: channel,
-    scope: delegate.scope,
-    callback: delegate.method,
-    listener: isListener
-  };
-  let subscriptions = _classPrivateFieldGet(_listeners, this)[channel];
-  if (!subscriptions) {
-    subscriptions = {};
-    _classPrivateFieldGet(_listeners, this)[channel] = subscriptions;
-  }
-  subscriptions[id] = subscription;
-  this._debug("Added", isListener ? "listener" : "subscription", subscription);
-  return subscription;
-}
-
-export { CometD };