epicenter-libs 3.30.0 → 3.31.0-beta.1

package/dist/browser/cometd-acd4ed9d.js

@@ -0,0 +1,4398 @@
+import { c as createCommonjsModule, g as getDefaultExportFromCjs } from './epicenter-6dbc1da9.js';
+
+var classApplyDescriptorGet = createCommonjsModule(function (module) {
+function _classApplyDescriptorGet(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}
+
+module.exports = _classApplyDescriptorGet;
+module.exports["default"] = module.exports, module.exports.__esModule = true;
+});
+
+var classExtractFieldDescriptor = createCommonjsModule(function (module) {
+function _classExtractFieldDescriptor(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+
+  return privateMap.get(receiver);
+}
+
+module.exports = _classExtractFieldDescriptor;
+module.exports["default"] = module.exports, module.exports.__esModule = true;
+});
+
+var classPrivateFieldGet = createCommonjsModule(function (module) {
+function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = classExtractFieldDescriptor(receiver, privateMap, "get");
+  return classApplyDescriptorGet(receiver, descriptor);
+}
+
+module.exports = _classPrivateFieldGet;
+module.exports["default"] = module.exports, module.exports.__esModule = true;
+});
+
+var _classPrivateFieldGet = /*@__PURE__*/getDefaultExportFromCjs(classPrivateFieldGet);
+
+var classApplyDescriptorSet = createCommonjsModule(function (module) {
+function _classApplyDescriptorSet(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+}
+
+module.exports = _classApplyDescriptorSet;
+module.exports["default"] = module.exports, module.exports.__esModule = true;
+});
+
+var classPrivateFieldSet = createCommonjsModule(function (module) {
+function _classPrivateFieldSet(receiver, privateMap, value) {
+  var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set");
+  classApplyDescriptorSet(receiver, descriptor, value);
+  return value;
+}
+
+module.exports = _classPrivateFieldSet;
+module.exports["default"] = module.exports, module.exports.__esModule = true;
+});
+
+var _classPrivateFieldSet = /*@__PURE__*/getDefaultExportFromCjs(classPrivateFieldSet);
+
+function _classPrivateFieldInitSpec$a(obj, privateMap, value) { _checkPrivateRedeclaration$a(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$a(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+var _types = /*#__PURE__*/new WeakMap();
+var _transports$1 = /*#__PURE__*/new WeakMap();
+/*
+ * Copyright (c) 2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A registry for transports used by the CometD object.
+ */
+class TransportRegistry {
+  constructor() {
+    _classPrivateFieldInitSpec$a(this, _types, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec$a(this, _transports$1, {
+      writable: true,
+      value: {}
+    });
+  }
+  getTransportTypes() {
+    return _classPrivateFieldGet(this, _types).slice(0);
+  }
+  add(type, transport, index) {
+    let existing = false;
+    for (let i = 0; i < _classPrivateFieldGet(this, _types).length; ++i) {
+      if (_classPrivateFieldGet(this, _types)[i] === type) {
+        existing = true;
+        break;
+      }
+    }
+    if (!existing) {
+      if (typeof index !== "number") {
+        _classPrivateFieldGet(this, _types).push(type);
+      } else {
+        _classPrivateFieldGet(this, _types).splice(index, 0, type);
+      }
+      _classPrivateFieldGet(this, _transports$1)[type] = transport;
+    }
+    return !existing;
+  }
+  find(type) {
+    for (let i = 0; i < _classPrivateFieldGet(this, _types).length; ++i) {
+      if (_classPrivateFieldGet(this, _types)[i] === type) {
+        return _classPrivateFieldGet(this, _transports$1)[type];
+      }
+    }
+    return null;
+  }
+  negotiateTransport(types, version, crossDomain, url) {
+    for (let i = 0; i < _classPrivateFieldGet(this, _types).length; ++i) {
+      const type = _classPrivateFieldGet(this, _types)[i];
+      for (let j = 0; j < types.length; ++j) {
+        if (type === types[j]) {
+          const transport = _classPrivateFieldGet(this, _transports$1)[type];
+          if (transport.accept(version, crossDomain, url) === true) {
+            return transport;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  clear() {
+    _classPrivateFieldSet(this, _types, []);
+    _classPrivateFieldSet(this, _transports$1, {});
+  }
+  reset(init) {
+    for (let i = 0; i < _classPrivateFieldGet(this, _types).length; ++i) {
+      _classPrivateFieldGet(this, _transports$1)[_classPrivateFieldGet(this, _types)[i]].reset(init);
+    }
+  }
+  findTransportTypes(version, crossDomain, url) {
+    const result = [];
+    for (let i = 0; i < _classPrivateFieldGet(this, _types).length; ++i) {
+      const type = _classPrivateFieldGet(this, _types)[i];
+      if (_classPrivateFieldGet(this, _transports$1)[type].accept(version, crossDomain, url) === true) {
+        result.push(type);
+      }
+    }
+    return result;
+  }
+  remove(type) {
+    for (let i = 0; i < _classPrivateFieldGet(this, _types).length; ++i) {
+      if (_classPrivateFieldGet(this, _types)[i] === type) {
+        _classPrivateFieldGet(this, _types).splice(i, 1);
+        const transport = _classPrivateFieldGet(this, _transports$1)[type];
+        delete _classPrivateFieldGet(this, _transports$1)[type];
+        return transport;
+      }
+    }
+    return null;
+  }
+}
+
+function _classPrivateFieldInitSpec$9(obj, privateMap, value) { _checkPrivateRedeclaration$9(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$9(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+var _type = /*#__PURE__*/new WeakMap();
+var _cometd$1 = /*#__PURE__*/new WeakMap();
+var _url = /*#__PURE__*/new WeakMap();
+/*
+ * Copyright (c) 2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Base class with the common functionality for transports.
+ */
+class Transport {
+  constructor() {
+    _classPrivateFieldInitSpec$9(this, _type, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$9(this, _cometd$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$9(this, _url, {
+      writable: true,
+      value: void 0
+    });
+  }
+  /**
+   * Function invoked just after a transport has been successfully registered.
+   * @param type the type of transport (for example "long-polling")
+   * @param cometd the cometd object this transport has been registered to
+   * @see #unregistered()
+   */
+  registered(type, cometd) {
+    _classPrivateFieldSet(this, _type, type);
+    _classPrivateFieldSet(this, _cometd$1, cometd);
+  }
+  /**
+   * Function invoked just after a transport has been successfully unregistered.
+   * @see #registered(type, cometd)
+   */
+  unregistered() {
+    _classPrivateFieldSet(this, _type, null);
+    _classPrivateFieldSet(this, _cometd$1, null);
+  }
+  get cometd() {
+    return _classPrivateFieldGet(this, _cometd$1);
+  }
+  notifyTransportTimeout(messages) {
+    const callbacks = this.cometd._getTransportListeners("timeout");
+    if (callbacks) {
+      for (let i = 0; i < callbacks.length; ++i) {
+        const listener = callbacks[i];
+        try {
+          const result = listener.call(this, messages);
+          if (typeof result === "number" && result > 0) {
+            return result;
+          }
+        } catch (x) {
+          this.cometd._info("Exception during execution of transport listener", listener, x);
+        }
+      }
+    }
+    return 0;
+  }
+  debug() {
+    this.cometd._debug.apply(this.cometd, arguments);
+  }
+  get configuration() {
+    return this.cometd.getConfiguration();
+  }
+  get advice() {
+    return this.cometd.getAdvice();
+  }
+  setTimeout(funktion, delay) {
+    return this.cometd.setTimeout(funktion, delay);
+  }
+  clearTimeout(id) {
+    this.cometd.clearTimeout(id);
+  }
+  convertToJSON(messages) {
+    const maxSize = this.configuration.maxSendBayeuxMessageSize;
+    let result = "[";
+    for (let i = 0; i < messages.length; ++i) {
+      if (i > 0) {
+        result += ",";
+      }
+      const message = messages[i];
+      const json = JSON.stringify(message);
+      if (json.length > maxSize) {
+        throw new Error("maxSendBayeuxMessageSize " + maxSize + " exceeded");
+      }
+      result += json;
+    }
+    result += "]";
+    return result;
+  }
+  /**
+   * Converts the given response into an array of bayeux messages
+   * @param response the response to convert
+   * @return an array of bayeux messages obtained by converting the response
+   */
+  convertToMessages(response) {
+    if (response === undefined || response === null) {
+      return [];
+    }
+    if (typeof response === "string" || response instanceof String) {
+      try {
+        return JSON.parse(response);
+      } catch (x) {
+        this.debug("Could not convert to JSON the following string:", response);
+        throw x;
+      }
+    }
+    if (Array.isArray(response)) {
+      return response;
+    }
+    if (response instanceof Object) {
+      return [response];
+    }
+    throw new Error("Conversion Error " + response + ", typeof " + typeof response);
+  }
+  /**
+   * Returns whether this transport can work for the given version and cross domain communication case.
+   * @param version a string indicating the transport version
+   * @param crossDomain a boolean indicating whether the communication is cross domain
+   * @param url the URL to connect to
+   * @return true if this transport can work for the given version and cross domain communication case,
+   * false otherwise
+   */
+  accept(version, crossDomain, url) {
+    throw new Error("Abstract");
+  }
+  /**
+   * Returns the type of this transport.
+   * @see #registered(type, cometd)
+   */
+  get type() {
+    return _classPrivateFieldGet(this, _type);
+  }
+  get url() {
+    return _classPrivateFieldGet(this, _url);
+  }
+  set url(url) {
+    _classPrivateFieldSet(this, _url, url);
+  }
+  send(envelope, metaConnect) {
+    throw new Error("Abstract");
+  }
+  reset(init) {
+    this.debug("Transport", this.type, "reset", init ? "initial" : "retry");
+  }
+  abort() {
+    this.debug("Transport", this.type, "aborted");
+  }
+  toString() {
+    return this.type;
+  }
+}
+
+function _classPrivateMethodInitSpec$5(obj, privateSet) { _checkPrivateRedeclaration$8(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec$8(obj, privateMap, value) { _checkPrivateRedeclaration$8(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$8(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet$5(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+/**
+ * Base class with the common functionality for transports based on requests.
+ * The key responsibility is to allow at most 2 outstanding requests to the server,
+ * to avoid that requests are sent behind a long poll.
+ * To achieve this, we have one reserved request for the long poll, and all other
+ * requests are serialized one after the other.
+ */
+var _requestIds = /*#__PURE__*/new WeakMap();
+var _metaConnectRequest = /*#__PURE__*/new WeakMap();
+var _requests = /*#__PURE__*/new WeakMap();
+var _envelopes = /*#__PURE__*/new WeakMap();
+var _coalesceEnvelopes = /*#__PURE__*/new WeakSet();
+var _onTransportTimeout$1 = /*#__PURE__*/new WeakSet();
+var _transportSend = /*#__PURE__*/new WeakSet();
+var _queueSend$1 = /*#__PURE__*/new WeakSet();
+var _metaConnectComplete = /*#__PURE__*/new WeakSet();
+var _complete = /*#__PURE__*/new WeakSet();
+var _metaConnectSend = /*#__PURE__*/new WeakSet();
+class RequestTransport extends Transport {
+  constructor(...args) {
+    super(...args);
+    _classPrivateMethodInitSpec$5(this, _metaConnectSend);
+    _classPrivateMethodInitSpec$5(this, _complete);
+    _classPrivateMethodInitSpec$5(this, _metaConnectComplete);
+    _classPrivateMethodInitSpec$5(this, _queueSend$1);
+    _classPrivateMethodInitSpec$5(this, _transportSend);
+    _classPrivateMethodInitSpec$5(this, _onTransportTimeout$1);
+    _classPrivateMethodInitSpec$5(this, _coalesceEnvelopes);
+    _classPrivateFieldInitSpec$8(this, _requestIds, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$8(this, _metaConnectRequest, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$8(this, _requests, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec$8(this, _envelopes, {
+      writable: true,
+      value: []
+    });
+  }
+  complete(request, success, metaConnect) {
+    if (metaConnect) {
+      _classPrivateMethodGet$5(this, _metaConnectComplete, _metaConnectComplete2).call(this, request);
+    } else {
+      _classPrivateMethodGet$5(this, _complete, _complete2).call(this, request, success);
+    }
+  }
+  /**
+   * Performs the actual send depending on the transport type details.
+   * @param envelope the envelope to send
+   * @param request the request information
+   * @return {boolean} whether the send succeeded
+   */
+  transportSend(envelope, request) {
+    throw new Error("Abstract");
+  }
+  transportSuccess(envelope, request, responses) {
+    if (!request.expired) {
+      this.clearTimeout(request.timeout);
+      this.debug("Transport", this.type, "cancelled waiting for message replies");
+      this.complete(request, true, request.metaConnect);
+      if (responses && responses.length > 0) {
+        envelope.onSuccess(responses);
+      } else {
+        envelope.onFailure(request.xhr, envelope.messages, {
+          httpCode: 204
+        });
+      }
+    }
+  }
+  transportFailure(envelope, request, failure) {
+    if (!request.expired) {
+      this.clearTimeout(request.timeout);
+      this.debug("Transport", this.type, "cancelled waiting for failed message replies");
+      this.complete(request, false, request.metaConnect);
+      envelope.onFailure(request.xhr, envelope.messages, failure);
+    }
+  }
+  send(envelope, metaConnect) {
+    if (metaConnect) {
+      _classPrivateMethodGet$5(this, _metaConnectSend, _metaConnectSend2).call(this, envelope);
+    } else {
+      _classPrivateMethodGet$5(this, _queueSend$1, _queueSend2$1).call(this, envelope);
+    }
+  }
+  abort() {
+    super.abort();
+    for (let i = 0; i < _classPrivateFieldGet(this, _requests).length; ++i) {
+      const request = _classPrivateFieldGet(this, _requests)[i];
+      if (request) {
+        this.debug("Aborting request", request);
+        if (!this.abortXHR(request.xhr)) {
+          this.transportFailure(request.envelope, request, {
+            reason: "abort"
+          });
+        }
+      }
+    }
+    const metaConnectRequest = _classPrivateFieldGet(this, _metaConnectRequest);
+    if (metaConnectRequest) {
+      this.debug("Aborting /meta/connect request", metaConnectRequest);
+      if (!this.abortXHR(metaConnectRequest.xhr)) {
+        this.transportFailure(metaConnectRequest.envelope, metaConnectRequest, {
+          reason: "abort"
+        });
+      }
+    }
+    this.reset(true);
+  }
+  reset(init) {
+    super.reset(init);
+    _classPrivateFieldSet(this, _metaConnectRequest, null);
+    _classPrivateFieldSet(this, _requests, []);
+    _classPrivateFieldSet(this, _envelopes, []);
+  }
+  abortXHR(xhr) {
+    if (xhr) {
+      try {
+        const state = xhr.readyState;
+        xhr.abort();
+        return state !== window.XMLHttpRequest.UNSENT;
+      } catch (x) {
+        this.debug(x);
+      }
+    }
+    return false;
+  }
+  xhrStatus(xhr) {
+    if (xhr) {
+      try {
+        return xhr.status;
+      } catch (x) {
+        this.debug(x);
+      }
+    }
+    return -1;
+  }
+}
+function _coalesceEnvelopes2(envelope) {
+  while (_classPrivateFieldGet(this, _envelopes).length > 0) {
+    const envelopeAndRequest = _classPrivateFieldGet(this, _envelopes)[0];
+    const newEnvelope = envelopeAndRequest[0];
+    const newRequest = envelopeAndRequest[1];
+    if (newEnvelope.url === envelope.url && newEnvelope.sync === envelope.sync) {
+      _classPrivateFieldGet(this, _envelopes).shift();
+      envelope.messages = envelope.messages.concat(newEnvelope.messages);
+      this.debug("Coalesced", newEnvelope.messages.length, "messages from request", newRequest.id);
+      continue;
+    }
+    break;
+  }
+}
+function _onTransportTimeout2$1(envelope, request, delay) {
+  const result = this.notifyTransportTimeout(envelope.messages);
+  if (result > 0) {
+    this.debug("Transport", this.type, "extended waiting for message replies of request", request.id, ":", result, "ms");
+    request.timeout = this.setTimeout(() => {
+      _classPrivateMethodGet$5(this, _onTransportTimeout$1, _onTransportTimeout2$1).call(this, envelope, request, delay + result);
+    }, result);
+  } else {
+    request.expired = true;
+    const errorMessage = "Transport " + this + " expired waiting for message replies of request " + request.id + ": " + delay + " ms";
+    const failure = {
+      reason: errorMessage
+    };
+    const xhr = request.xhr;
+    failure.httpCode = this.xhrStatus(xhr);
+    this.abortXHR(xhr);
+    this.debug(errorMessage);
+    this.complete(request, false, request.metaConnect);
+    envelope.onFailure(xhr, envelope.messages, failure);
+  }
+}
+function _transportSend2(envelope, request) {
+  if (this.transportSend(envelope, request)) {
+    request.expired = false;
+    if (!envelope.sync) {
+      let delay = this.configuration.maxNetworkDelay;
+      if (request.metaConnect === true) {
+        delay += this.advice.timeout;
+      }
+      this.debug("Transport", this.type, "started waiting for message replies of request", request.id, ":", delay, "ms");
+      request.timeout = this.setTimeout(() => {
+        _classPrivateMethodGet$5(this, _onTransportTimeout$1, _onTransportTimeout2$1).call(this, envelope, request, delay);
+      }, delay);
+    }
+  }
+}
+function _queueSend2$1(envelope) {
+  var _this$requestIds;
+  const requestId = _classPrivateFieldSet(this, _requestIds, (_this$requestIds = _classPrivateFieldGet(this, _requestIds), ++_this$requestIds));
+  const request = {
+    id: requestId,
+    metaConnect: false,
+    envelope: envelope
+  };
+
+  // Consider the /meta/connect requests which should always be present.
+  if (_classPrivateFieldGet(this, _requests).length < this.configuration.maxConnections - 1) {
+    _classPrivateFieldGet(this, _requests).push(request);
+    _classPrivateMethodGet$5(this, _transportSend, _transportSend2).call(this, envelope, request);
+  } else {
+    this.debug("Transport", this.type, "queueing request", requestId, "envelope", envelope);
+    _classPrivateFieldGet(this, _envelopes).push([envelope, request]);
+  }
+}
+function _metaConnectComplete2(request) {
+  const requestId = request.id;
+  this.debug("Transport", this.type, "/meta/connect complete, request", requestId);
+  if (_classPrivateFieldGet(this, _metaConnectRequest) !== null && _classPrivateFieldGet(this, _metaConnectRequest).id !== requestId) {
+    throw new Error("/meta/connect request mismatch, completing request " + requestId);
+  }
+  _classPrivateFieldSet(this, _metaConnectRequest, null);
+}
+function _complete2(request, success) {
+  const index = _classPrivateFieldGet(this, _requests).indexOf(request);
+  // The index can be negative if the request has been aborted
+  if (index >= 0) {
+    _classPrivateFieldGet(this, _requests).splice(index, 1);
+  }
+  if (_classPrivateFieldGet(this, _envelopes).length > 0) {
+    const envelopeAndRequest = _classPrivateFieldGet(this, _envelopes).shift();
+    const nextEnvelope = envelopeAndRequest[0];
+    const nextRequest = envelopeAndRequest[1];
+    this.debug("Transport dequeued request", nextRequest.id);
+    if (success) {
+      if (this.configuration.autoBatch) {
+        _classPrivateMethodGet$5(this, _coalesceEnvelopes, _coalesceEnvelopes2).call(this, nextEnvelope);
+      }
+      _classPrivateMethodGet$5(this, _queueSend$1, _queueSend2$1).call(this, nextEnvelope);
+      this.debug("Transport", this.type, "completed request", request.id, nextEnvelope);
+    } else {
+      // Keep the semantic of calling callbacks asynchronously.
+      this.setTimeout(() => {
+        this.complete(nextRequest, false, nextRequest.metaConnect);
+        const failure = {
+          reason: "Previous request failed"
+        };
+        const xhr = nextRequest.xhr;
+        failure.httpCode = this.xhrStatus(xhr);
+        nextEnvelope.onFailure(xhr, nextEnvelope.messages, failure);
+      }, 0);
+    }
+  }
+}
+function _metaConnectSend2(envelope) {
+  var _this$requestIds2;
+  if (_classPrivateFieldGet(this, _metaConnectRequest) !== null) {
+    throw new Error("Concurrent /meta/connect requests not allowed, request id=" + _classPrivateFieldGet(this, _metaConnectRequest).id + " not yet completed");
+  }
+  const requestId = _classPrivateFieldSet(this, _requestIds, (_this$requestIds2 = _classPrivateFieldGet(this, _requestIds), ++_this$requestIds2));
+  this.debug("Transport", this.type, "/meta/connect send, request", requestId, "envelope", envelope);
+  const request = {
+    id: requestId,
+    metaConnect: true,
+    envelope: envelope
+  };
+  _classPrivateMethodGet$5(this, _transportSend, _transportSend2).call(this, envelope, request);
+  _classPrivateFieldSet(this, _metaConnectRequest, request);
+}
+
+function _classPrivateFieldInitSpec$7(obj, privateMap, value) { _checkPrivateRedeclaration$7(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$7(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+var _jsonp = /*#__PURE__*/new WeakMap();
+class CallbackPollingTransport extends RequestTransport {
+  constructor(...args) {
+    super(...args);
+    _classPrivateFieldInitSpec$7(this, _jsonp, {
+      writable: true,
+      value: 0
+    });
+  }
+  accept(version, crossDomain, url) {
+    return true;
+  }
+  jsonpSend(packet) {
+    var _this$jsonp, _this$jsonp2;
+    const head = window.document.getElementsByTagName("head")[0];
+    const script = window.document.createElement("script");
+    const callbackName = "_cometd_jsonp_" + (_classPrivateFieldSet(this, _jsonp, (_this$jsonp = _classPrivateFieldGet(this, _jsonp), _this$jsonp2 = _this$jsonp++, _this$jsonp)), _this$jsonp2);
+    window[callbackName] = responseText => {
+      head.removeChild(script);
+      delete window[callbackName];
+      packet.onSuccess(responseText);
+    };
+    let url = packet.url;
+    url += url.indexOf("?") < 0 ? "?" : "&";
+    url += "jsonp=" + callbackName;
+    url += "&message=" + encodeURIComponent(packet.body);
+    script.src = url;
+    script.async = packet.sync !== true;
+    script.type = "text/javascript";
+    script.onerror = e => {
+      packet.onError("jsonp " + e.type);
+    };
+    head.appendChild(script);
+  }
+  transportSend(envelope, request) {
+    // Microsoft Internet Explorer has a 2083 URL max length
+    // We must ensure that we stay within that length.
+    let start = 0;
+    let length = envelope.messages.length;
+    const lengths = [];
+    while (length > 0) {
+      // Encode the messages because all brackets, quotes, commas, colons, etc.
+      // present in the JSON will be URL encoded, taking many more characters.
+      const json = JSON.stringify(envelope.messages.slice(start, start + length));
+      const urlLength = envelope.url.length + encodeURI(json).length;
+      const maxLength = this.configuration.maxURILength;
+      if (urlLength > maxLength) {
+        if (length === 1) {
+          const x = "Bayeux message too big (" + urlLength + " bytes, max is " + maxLength + ") " + "for transport " + this;
+          // Keep the semantic of calling callbacks asynchronously.
+          this.setTimeout(() => this.transportFailure(envelope, request, {
+            exception: x
+          }), 0);
+          return false;
+        }
+        --length;
+        continue;
+      }
+      lengths.push(length);
+      start += length;
+      length = envelope.messages.length - start;
+    }
+
+    // Here we are sure that the messages can be sent within the URL limit
+
+    let envelopeToSend = envelope;
+    if (lengths.length > 1) {
+      let begin = 0;
+      let end = lengths[0];
+      this.debug("Transport", this.type, "split", envelope.messages.length, "messages into", lengths.join(" + "));
+      envelopeToSend = this.cometd._mixin(false, {}, envelope);
+      envelopeToSend.messages = envelope.messages.slice(begin, end);
+      envelopeToSend.onSuccess = envelope.onSuccess;
+      envelopeToSend.onFailure = envelope.onFailure;
+      for (let i = 1; i < lengths.length; ++i) {
+        const nextEnvelope = this.cometd._mixin(false, {}, envelope);
+        begin = end;
+        end += lengths[i];
+        nextEnvelope.messages = envelope.messages.slice(begin, end);
+        nextEnvelope.onSuccess = envelope.onSuccess;
+        nextEnvelope.onFailure = envelope.onFailure;
+        this.send(nextEnvelope, request.metaConnect);
+      }
+    }
+    this.debug("Transport", this.type, "sending request", request.id, "envelope", envelopeToSend);
+    try {
+      let sameStack = true;
+      this.jsonpSend({
+        transport: this,
+        url: envelopeToSend.url,
+        sync: envelopeToSend.sync,
+        headers: this.configuration.requestHeaders,
+        body: JSON.stringify(envelopeToSend.messages),
+        onSuccess: responses => {
+          let success = false;
+          try {
+            const received = this.convertToMessages(responses);
+            if (received.length === 0) {
+              this.transportFailure(envelopeToSend, request, {
+                httpCode: 204
+              });
+            } else {
+              success = true;
+              this.transportSuccess(envelopeToSend, request, received);
+            }
+          } catch (x) {
+            this.debug(x);
+            if (!success) {
+              this.transportFailure(envelopeToSend, request, {
+                exception: x
+              });
+            }
+          }
+        },
+        onError: (reason, exception) => {
+          const failure = {
+            reason: reason,
+            exception: exception
+          };
+          if (sameStack) {
+            // Keep the semantic of calling callbacks asynchronously.
+            this.setTimeout(() => {
+              this.transportFailure(envelopeToSend, request, failure);
+            }, 0);
+          } else {
+            this.transportFailure(envelopeToSend, request, failure);
+          }
+        }
+      });
+      sameStack = false;
+      return true;
+    } catch (xx) {
+      // Keep the semantic of calling callbacks asynchronously.
+      this.setTimeout(() => {
+        this.transportFailure(envelopeToSend, request, {
+          exception: xx
+        });
+      }, 0);
+      return false;
+    }
+  }
+}
+
+function _classPrivateMethodInitSpec$4(obj, privateSet) { _checkPrivateRedeclaration$6(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec$6(obj, privateMap, value) { _checkPrivateRedeclaration$6(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$6(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet$4(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+var _supportsCrossDomain = /*#__PURE__*/new WeakMap();
+var _newXMLHttpRequest = /*#__PURE__*/new WeakSet();
+var _copyContext = /*#__PURE__*/new WeakSet();
+class LongPollingTransport extends RequestTransport {
+  constructor(...args) {
+    super(...args);
+    _classPrivateMethodInitSpec$4(this, _copyContext);
+    _classPrivateMethodInitSpec$4(this, _newXMLHttpRequest);
+    // By default, support cross domain.
+    _classPrivateFieldInitSpec$6(this, _supportsCrossDomain, {
+      writable: true,
+      value: true
+    });
+  }
+  accept(version, crossDomain, url) {
+    return _classPrivateFieldGet(this, _supportsCrossDomain) || !crossDomain;
+  }
+  xhrSend(packet) {
+    const xhr = _classPrivateMethodGet$4(this, _newXMLHttpRequest, _newXMLHttpRequest2).call(this);
+    _classPrivateMethodGet$4(this, _copyContext, _copyContext2).call(this, xhr);
+    xhr.withCredentials = true;
+    xhr.open("POST", packet.url, packet.sync !== true);
+    const headers = packet.headers;
+    if (headers) {
+      for (let headerName in headers) {
+        if (headers.hasOwnProperty(headerName)) {
+          xhr.setRequestHeader(headerName, headers[headerName]);
+        }
+      }
+    }
+    xhr.setRequestHeader("Content-Type", "application/json");
+    xhr.onload = () => {
+      if (xhr.status === 200) {
+        packet.onSuccess(xhr.responseText);
+      } else {
+        packet.onError(xhr.statusText);
+      }
+    };
+    xhr.onabort = xhr.onerror = () => {
+      packet.onError(xhr.statusText);
+    };
+    xhr.send(packet.body);
+    return xhr;
+  }
+  transportSend(envelope, request) {
+    this.debug("Transport", this.type, "sending request", request.id, "envelope", envelope);
+    try {
+      let sameStack = true;
+      request.xhr = this.xhrSend({
+        transport: this,
+        url: envelope.url,
+        sync: envelope.sync,
+        headers: this.configuration.requestHeaders,
+        body: this.convertToJSON(envelope.messages),
+        onSuccess: response => {
+          this.debug("Transport", this.type, "received response", response);
+          let success = false;
+          try {
+            const received = this.convertToMessages(response);
+            if (received.length === 0) {
+              _classPrivateFieldSet(this, _supportsCrossDomain, false);
+              this.transportFailure(envelope, request, {
+                httpCode: 204
+              });
+            } else {
+              success = true;
+              this.transportSuccess(envelope, request, received);
+            }
+          } catch (x) {
+            this.debug(x);
+            if (!success) {
+              _classPrivateFieldSet(this, _supportsCrossDomain, false);
+              const failure = {
+                exception: x
+              };
+              failure.httpCode = this.xhrStatus(request.xhr);
+              this.transportFailure(envelope, request, failure);
+            }
+          }
+        },
+        onError: (reason, exception) => {
+          this.debug("Transport", this.type, "received error", reason, exception);
+          _classPrivateFieldSet(this, _supportsCrossDomain, false);
+          const failure = {
+            reason: reason,
+            exception: exception
+          };
+          failure.httpCode = this.xhrStatus(request.xhr);
+          if (sameStack) {
+            // Keep the semantic of calling callbacks asynchronously.
+            this.setTimeout(() => {
+              this.transportFailure(envelope, request, failure);
+            }, 0);
+          } else {
+            this.transportFailure(envelope, request, failure);
+          }
+        }
+      });
+      sameStack = false;
+      return true;
+    } catch (x) {
+      this.debug("Transport", this.type, "exception:", x);
+      _classPrivateFieldSet(this, _supportsCrossDomain, false);
+      // Keep the semantic of calling callbacks asynchronously.
+      this.setTimeout(() => {
+        this.transportFailure(envelope, request, {
+          exception: x
+        });
+      }, 0);
+      return false;
+    }
+  }
+  reset(init) {
+    super.reset(init);
+    _classPrivateFieldSet(this, _supportsCrossDomain, true);
+  }
+}
+function _newXMLHttpRequest2() {
+  return new window.XMLHttpRequest();
+}
+function _copyContext2(xhr) {
+  try {
+    // Copy external context, to be used in other environments.
+    xhr.context = this.context;
+  } catch (e) {
+    // May happen if XHR is wrapped by Object.seal(),
+    // Object.freeze(), or Object.preventExtensions().
+    this.debug("Could not copy transport context into XHR", e);
+  }
+}
+
+function _classPrivateMethodInitSpec$3(obj, privateSet) { _checkPrivateRedeclaration$5(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec$5(obj, privateMap, value) { _checkPrivateRedeclaration$5(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$5(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet$3(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+var _webSocketSupported = /*#__PURE__*/new WeakMap();
+var _webSocketConnected = /*#__PURE__*/new WeakMap();
+var _stickyReconnect = /*#__PURE__*/new WeakMap();
+var _context = /*#__PURE__*/new WeakMap();
+var _connecting = /*#__PURE__*/new WeakMap();
+var _connected$1 = /*#__PURE__*/new WeakMap();
+var _successCallback = /*#__PURE__*/new WeakMap();
+var _forceClose = /*#__PURE__*/new WeakSet();
+var _sameContext = /*#__PURE__*/new WeakSet();
+var _storeEnvelope = /*#__PURE__*/new WeakSet();
+var _removeEnvelope = /*#__PURE__*/new WeakSet();
+var _websocketConnect = /*#__PURE__*/new WeakSet();
+var _onTransportTimeout = /*#__PURE__*/new WeakSet();
+var _webSocketSend = /*#__PURE__*/new WeakSet();
+var _send$1 = /*#__PURE__*/new WeakSet();
+var _onOpen = /*#__PURE__*/new WeakSet();
+var _onMessage = /*#__PURE__*/new WeakSet();
+var _onClose = /*#__PURE__*/new WeakSet();
+var _webSocketClose = /*#__PURE__*/new WeakSet();
+class WebSocketTransport extends Transport {
+  constructor(...args) {
+    super(...args);
+    _classPrivateMethodInitSpec$3(this, _webSocketClose);
+    _classPrivateMethodInitSpec$3(this, _onClose);
+    _classPrivateMethodInitSpec$3(this, _onMessage);
+    _classPrivateMethodInitSpec$3(this, _onOpen);
+    _classPrivateMethodInitSpec$3(this, _send$1);
+    _classPrivateMethodInitSpec$3(this, _webSocketSend);
+    _classPrivateMethodInitSpec$3(this, _onTransportTimeout);
+    _classPrivateMethodInitSpec$3(this, _websocketConnect);
+    _classPrivateMethodInitSpec$3(this, _removeEnvelope);
+    _classPrivateMethodInitSpec$3(this, _storeEnvelope);
+    _classPrivateMethodInitSpec$3(this, _sameContext);
+    _classPrivateMethodInitSpec$3(this, _forceClose);
+    // By default, WebSocket is supported.
+    _classPrivateFieldInitSpec$5(this, _webSocketSupported, {
+      writable: true,
+      value: true
+    });
+    // Whether we were able to establish a WebSocket connection.
+    _classPrivateFieldInitSpec$5(this, _webSocketConnected, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$5(this, _stickyReconnect, {
+      writable: true,
+      value: true
+    });
+    // The context contains the envelopes that have been sent
+    // and the timeouts for the messages that have been sent.
+    _classPrivateFieldInitSpec$5(this, _context, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$5(this, _connecting, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$5(this, _connected$1, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$5(this, _successCallback, {
+      writable: true,
+      value: null
+    });
+  }
+  reset(init) {
+    super.reset(init);
+    _classPrivateFieldSet(this, _webSocketSupported, true);
+    if (init) {
+      _classPrivateFieldSet(this, _webSocketConnected, false);
+    }
+    _classPrivateFieldSet(this, _stickyReconnect, true);
+    if (init) {
+      _classPrivateFieldSet(this, _context, null);
+    }
+    _classPrivateFieldSet(this, _connecting, null);
+    _classPrivateFieldSet(this, _connected$1, false);
+  }
+  _notifySuccess(fn, messages) {
+    fn.call(this, messages);
+  }
+  _notifyFailure(fn, context, messages, failure) {
+    fn.call(this, context, messages, failure);
+  }
+  accept(version, crossDomain, url) {
+    this.debug("Transport", this.type, "accept, supported:", _classPrivateFieldGet(this, _webSocketSupported));
+    // Using !! to return a boolean (and not the WebSocket object).
+    return _classPrivateFieldGet(this, _webSocketSupported) && !!window.WebSocket && this.cometd.websocketEnabled !== false;
+  }
+  send(envelope, metaConnect) {
+    this.debug("Transport", this.type, "sending", envelope, "/meta/connect =", metaConnect);
+    _classPrivateMethodGet$3(this, _send$1, _send2$1).call(this, _classPrivateFieldGet(this, _context), envelope, metaConnect);
+  }
+  abort() {
+    super.abort();
+    _classPrivateMethodGet$3(this, _forceClose, _forceClose2).call(this, _classPrivateFieldGet(this, _context), {
+      code: 1000,
+      reason: "Abort"
+    });
+    this.reset(true);
+  }
+}
+function _forceClose2(context, event) {
+  if (context) {
+    _classPrivateMethodGet$3(this, _webSocketClose, _webSocketClose2).call(this, context, event.code, event.reason);
+    // Force immediate failure of pending messages to trigger reconnect.
+    // This is needed because the server may not reply to our close()
+    // and therefore the onclose function is never called.
+    _classPrivateMethodGet$3(this, _onClose, _onClose2).call(this, context, event);
+  }
+}
+function _sameContext2(context) {
+  return context === _classPrivateFieldGet(this, _connecting) || context === _classPrivateFieldGet(this, _context);
+}
+function _storeEnvelope2(context, envelope, metaConnect) {
+  const messageIds = [];
+  for (let i = 0; i < envelope.messages.length; ++i) {
+    const message = envelope.messages[i];
+    if (message.id) {
+      messageIds.push(message.id);
+    }
+  }
+  context.envelopes[messageIds.join(",")] = [envelope, metaConnect];
+  this.debug("Transport", this.type, "stored envelope, envelopes", context.envelopes);
+}
+function _removeEnvelope2(context, messageIds) {
+  let removed = false;
+  const envelopes = context.envelopes;
+  for (let j = 0; j < messageIds.length; ++j) {
+    const id = messageIds[j];
+    for (let key in envelopes) {
+      if (envelopes.hasOwnProperty(key)) {
+        const ids = key.split(",");
+        const index = ids.indexOf(id);
+        if (index >= 0) {
+          removed = true;
+          ids.splice(index, 1);
+          const envelope = envelopes[key][0];
+          const metaConnect = envelopes[key][1];
+          delete envelopes[key];
+          if (ids.length > 0) {
+            envelopes[ids.join(",")] = [envelope, metaConnect];
+          }
+          break;
+        }
+      }
+    }
+  }
+  if (removed) {
+    this.debug("Transport", this.type, "removed envelope, envelopes", envelopes);
+  }
+}
+function _websocketConnect2(context) {
+  // We may have multiple attempts to open a WebSocket
+  // connection, for example a /meta/connect request that
+  // may take time, along with a user-triggered publish.
+  // Early return if we are already connecting.
+  if (_classPrivateFieldGet(this, _connecting)) {
+    return;
+  }
+
+  // Mangle the URL, changing the scheme from "http" to "ws".
+  const url = this.cometd.getURL().replace(/^http/, "ws");
+  this.debug("Transport", this.type, "connecting to URL", url);
+  try {
+    const protocol = this.configuration.protocol;
+    context.webSocket = protocol ? new window.WebSocket(url, protocol) : new window.WebSocket(url);
+    _classPrivateFieldSet(this, _connecting, context);
+  } catch (x) {
+    _classPrivateFieldSet(this, _webSocketSupported, false);
+    this.debug("Exception while creating WebSocket object", x);
+    throw x;
+  }
+
+  // By default use sticky reconnects.
+  _classPrivateFieldSet(this, _stickyReconnect, this.configuration.stickyReconnect !== false);
+  const connectTimeout = this.configuration.connectTimeout;
+  if (connectTimeout > 0) {
+    context.connectTimer = this.setTimeout(() => {
+      this.debug("Transport", this.type, "timed out while connecting to URL", url, ":", connectTimeout, "ms");
+      // The connection was not opened, close anyway.
+      _classPrivateMethodGet$3(this, _forceClose, _forceClose2).call(this, context, {
+        code: 1000,
+        reason: "Connect Timeout"
+      });
+    }, connectTimeout);
+  }
+  const onopen = () => {
+    this.debug("Transport", this.type, "onopen", context);
+    if (context.connectTimer) {
+      this.clearTimeout(context.connectTimer);
+    }
+    if (_classPrivateMethodGet$3(this, _sameContext, _sameContext2).call(this, context)) {
+      _classPrivateFieldSet(this, _connecting, null);
+      _classPrivateFieldSet(this, _context, context);
+      _classPrivateFieldSet(this, _webSocketConnected, true);
+      _classPrivateMethodGet$3(this, _onOpen, _onOpen2).call(this, context);
+    } else {
+      // We have a valid connection already, close this one.
+      this.cometd._warn("Closing extra WebSocket connection", this, "active connection", _classPrivateFieldGet(this, _context));
+      _classPrivateMethodGet$3(this, _forceClose, _forceClose2).call(this, context, {
+        code: 1000,
+        reason: "Extra Connection"
+      });
+    }
+  };
+
+  // This callback is invoked when the server sends the close frame.
+  // The close frame for a connection may arrive *after* another
+  // connection has been opened, so we must make sure that actions
+  // are performed only if it's the same connection.
+  const onclose = event => {
+    event = event || {
+      code: 1000
+    };
+    this.debug("Transport", this.type, "onclose", context, event, "connecting", _classPrivateFieldGet(this, _connecting), "current", _classPrivateFieldGet(this, _context));
+    if (context.connectTimer) {
+      this.clearTimeout(context.connectTimer);
+    }
+    _classPrivateMethodGet$3(this, _onClose, _onClose2).call(this, context, event);
+  };
+  const onmessage = wsMessage => {
+    this.debug("Transport", this.type, "onmessage", wsMessage, context);
+    _classPrivateMethodGet$3(this, _onMessage, _onMessage2).call(this, context, wsMessage);
+  };
+  context.webSocket.onopen = onopen;
+  context.webSocket.onclose = onclose;
+  context.webSocket.onerror = () => {
+    // Clients should call onclose(), but if they do not we do it here for safety.
+    onclose({
+      code: 1000,
+      reason: "Error"
+    });
+  };
+  context.webSocket.onmessage = onmessage;
+  this.debug("Transport", this.type, "configured callbacks on", context);
+}
+function _onTransportTimeout2(context, message, delay) {
+  const result = this.notifyTransportTimeout([message]);
+  if (result > 0) {
+    this.debug("Transport", this.type, "extended waiting for message replies:", result, "ms");
+    context.timeouts[message.id] = this.setTimeout(() => {
+      _classPrivateMethodGet$3(this, _onTransportTimeout, _onTransportTimeout2).call(this, context, message, delay + result);
+    }, result);
+  } else {
+    this.debug("Transport", this.type, "expired waiting for message reply", message.id, ":", delay, "ms");
+    _classPrivateMethodGet$3(this, _forceClose, _forceClose2).call(this, context, {
+      code: 1000,
+      reason: "Message Timeout"
+    });
+  }
+}
+function _webSocketSend2(context, envelope, metaConnect) {
+  let json;
+  try {
+    json = this.convertToJSON(envelope.messages);
+  } catch (x) {
+    this.debug("Transport", this.type, "exception:", x);
+    const mIds = [];
+    for (let j = 0; j < envelope.messages.length; ++j) {
+      const m = envelope.messages[j];
+      mIds.push(m.id);
+    }
+    _classPrivateMethodGet$3(this, _removeEnvelope, _removeEnvelope2).call(this, context, mIds);
+    // Keep the semantic of calling callbacks asynchronously.
+    this.setTimeout(() => {
+      this._notifyFailure(envelope.onFailure, context, envelope.messages, {
+        exception: x
+      });
+    }, 0);
+    return;
+  }
+  context.webSocket.send(json);
+  this.debug("Transport", this.type, "sent", envelope, "/meta/connect =", metaConnect);
+
+  // Manage the timeout waiting for the response.
+  let delay = this.configuration.maxNetworkDelay;
+  if (metaConnect) {
+    delay += this.advice.timeout;
+    _classPrivateFieldSet(this, _connected$1, true);
+  }
+  const messageIds = [];
+  for (let i = 0; i < envelope.messages.length; ++i) {
+    const message = envelope.messages[i];
+    if (message.id) {
+      messageIds.push(message.id);
+      context.timeouts[message.id] = this.setTimeout(() => {
+        _classPrivateMethodGet$3(this, _onTransportTimeout, _onTransportTimeout2).call(this, context, message, delay);
+      }, delay);
+    }
+  }
+  this.debug("Transport", this.type, "started waiting for message replies", delay, "ms, messageIds:", messageIds, ", timeouts:", context.timeouts);
+}
+function _send2$1(context, envelope, metaConnect) {
+  try {
+    if (context === null) {
+      context = _classPrivateFieldGet(this, _connecting) || {
+        envelopes: {},
+        timeouts: {}
+      };
+      _classPrivateMethodGet$3(this, _storeEnvelope, _storeEnvelope2).call(this, context, envelope, metaConnect);
+      _classPrivateMethodGet$3(this, _websocketConnect, _websocketConnect2).call(this, context);
+    } else {
+      _classPrivateMethodGet$3(this, _storeEnvelope, _storeEnvelope2).call(this, context, envelope, metaConnect);
+      _classPrivateMethodGet$3(this, _webSocketSend, _webSocketSend2).call(this, context, envelope, metaConnect);
+    }
+  } catch (x) {
+    // Keep the semantic of calling callbacks asynchronously.
+    this.setTimeout(() => {
+      _classPrivateMethodGet$3(this, _forceClose, _forceClose2).call(this, context, {
+        code: 1000,
+        reason: "Exception",
+        exception: x
+      });
+    }, 0);
+  }
+}
+function _onOpen2(context) {
+  const envelopes = context.envelopes;
+  this.debug("Transport", this.type, "opened", context, "pending messages", envelopes);
+  for (let key in envelopes) {
+    if (envelopes.hasOwnProperty(key)) {
+      const element = envelopes[key];
+      const envelope = element[0];
+      const metaConnect = element[1];
+      // Store the success callback, which is independent of the envelope,
+      // so that it can be used to notify arrival of messages.
+      _classPrivateFieldSet(this, _successCallback, envelope.onSuccess);
+      _classPrivateMethodGet$3(this, _webSocketSend, _webSocketSend2).call(this, context, envelope, metaConnect);
+    }
+  }
+}
+function _onMessage2(context, wsMessage) {
+  this.debug("Transport", this.type, "received websocket message", wsMessage, context);
+  let close = false;
+  const messages = this.convertToMessages(wsMessage.data);
+  const messageIds = [];
+  for (let i = 0; i < messages.length; ++i) {
+    const message = messages[i];
+
+    // Detect if the message is a response to a request we made.
+    // If it's a meta message, for sure it's a response; otherwise it's
+    // a publish message and publish responses don't have the data field.
+    if (/^\/meta\//.test(message.channel) || message.data === undefined) {
+      if (message.id) {
+        messageIds.push(message.id);
+        const timeout = context.timeouts[message.id];
+        if (timeout) {
+          this.clearTimeout(timeout);
+          delete context.timeouts[message.id];
+          this.debug("Transport", this.type, "removed timeout for message", message.id, ", timeouts", context.timeouts);
+        }
+      }
+    }
+    if ("/meta/connect" === message.channel) {
+      _classPrivateFieldSet(this, _connected$1, false);
+    }
+    if ("/meta/disconnect" === message.channel && !_classPrivateFieldGet(this, _connected$1)) {
+      close = true;
+    }
+  }
+
+  // Remove the envelope corresponding to the messages.
+  _classPrivateMethodGet$3(this, _removeEnvelope, _removeEnvelope2).call(this, context, messageIds);
+  this._notifySuccess(_classPrivateFieldGet(this, _successCallback), messages);
+  if (close) {
+    _classPrivateMethodGet$3(this, _webSocketClose, _webSocketClose2).call(this, context, 1000, "Disconnect");
+  }
+}
+function _onClose2(context, event) {
+  this.debug("Transport", this.type, "closed", context, event);
+  if (_classPrivateMethodGet$3(this, _sameContext, _sameContext2).call(this, context)) {
+    // Remember if we were able to connect.
+    // This close event could be due to server shutdown,
+    // and if it restarts we want to try websocket again.
+    _classPrivateFieldSet(this, _webSocketSupported, _classPrivateFieldGet(this, _stickyReconnect) && _classPrivateFieldGet(this, _webSocketConnected));
+    _classPrivateFieldSet(this, _connecting, null);
+    _classPrivateFieldSet(this, _context, null);
+  }
+  const timeouts = context.timeouts;
+  context.timeouts = {};
+  for (let id in timeouts) {
+    if (timeouts.hasOwnProperty(id)) {
+      this.clearTimeout(timeouts[id]);
+    }
+  }
+  const envelopes = context.envelopes;
+  context.envelopes = {};
+  for (let key in envelopes) {
+    if (envelopes.hasOwnProperty(key)) {
+      const envelope = envelopes[key][0];
+      const metaConnect = envelopes[key][1];
+      if (metaConnect) {
+        _classPrivateFieldSet(this, _connected$1, false);
+      }
+      const failure = {
+        websocketCode: event.code,
+        reason: event.reason
+      };
+      if (event.exception) {
+        failure.exception = event.exception;
+      }
+      this._notifyFailure(envelope.onFailure, context, envelope.messages, failure);
+    }
+  }
+}
+function _webSocketClose2(context, code, reason) {
+  try {
+    if (context.webSocket) {
+      context.webSocket.close(code, reason);
+    }
+  } catch (x) {
+    this.debug(x);
+  }
+}
+
+var _CometD;
+function _classPrivateMethodInitSpec$2(obj, privateSet) { _checkPrivateRedeclaration$4(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec$4(obj, privateMap, value) { _checkPrivateRedeclaration$4(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$4(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet$2(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classStaticPrivateMethodGet(receiver, classConstructor, method) { _classCheckPrivateStaticAccess$1(receiver, classConstructor); return method; }
+function _classCheckPrivateStaticAccess$1(receiver, classConstructor) { if (receiver !== classConstructor) { throw new TypeError("Private static access of wrong provenance"); } }
+
+/**
+ * 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$1 = /*#__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$2 = /*#__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 _log = /*#__PURE__*/new WeakSet();
+var _isCrossDomain = /*#__PURE__*/new WeakSet();
+var _configure = /*#__PURE__*/new WeakSet();
+var _removeListener = /*#__PURE__*/new WeakSet();
+var _removeSubscription = /*#__PURE__*/new WeakSet();
+var _clearSubscriptions = /*#__PURE__*/new WeakSet();
+var _setStatus = /*#__PURE__*/new WeakSet();
+var _isDisconnected = /*#__PURE__*/new WeakSet();
+var _nextMessageId = /*#__PURE__*/new WeakSet();
+var _applyExtension = /*#__PURE__*/new WeakSet();
+var _applyIncomingExtensions = /*#__PURE__*/new WeakSet();
+var _applyOutgoingExtensions = /*#__PURE__*/new WeakSet();
+var _notify = /*#__PURE__*/new WeakSet();
+var _notifyListeners = /*#__PURE__*/new WeakSet();
+var _cancelDelayedSend = /*#__PURE__*/new WeakSet();
+var _delayedSend = /*#__PURE__*/new WeakSet();
+var _send = /*#__PURE__*/new WeakSet();
+var _queueSend = /*#__PURE__*/new WeakSet();
+var _resetBackoff = /*#__PURE__*/new WeakSet();
+var _increaseBackoff = /*#__PURE__*/new WeakSet();
+var _startBatch = /*#__PURE__*/new WeakSet();
+var _flushBatch = /*#__PURE__*/new WeakSet();
+var _endBatch = /*#__PURE__*/new WeakSet();
+var _connect = /*#__PURE__*/new WeakSet();
+var _delayedConnect = /*#__PURE__*/new WeakSet();
+var _updateAdvice = /*#__PURE__*/new WeakSet();
+var _disconnect = /*#__PURE__*/new WeakSet();
+var _notifyTransportException = /*#__PURE__*/new WeakSet();
+var _handshake = /*#__PURE__*/new WeakSet();
+var _delayedHandshake = /*#__PURE__*/new WeakSet();
+var _notifyCallback = /*#__PURE__*/new WeakSet();
+var _handleCallback = /*#__PURE__*/new WeakSet();
+var _handleRemoteCall = /*#__PURE__*/new WeakSet();
+var _handleTransportFailure = /*#__PURE__*/new WeakSet();
+var _failHandshake = /*#__PURE__*/new WeakSet();
+var _handshakeResponse = /*#__PURE__*/new WeakSet();
+var _handshakeFailure = /*#__PURE__*/new WeakSet();
+var _matchMetaConnect = /*#__PURE__*/new WeakSet();
+var _failConnect = /*#__PURE__*/new WeakSet();
+var _connectResponse = /*#__PURE__*/new WeakSet();
+var _connectFailure = /*#__PURE__*/new WeakSet();
+var _failDisconnect = /*#__PURE__*/new WeakSet();
+var _disconnectResponse = /*#__PURE__*/new WeakSet();
+var _disconnectFailure = /*#__PURE__*/new WeakSet();
+var _failSubscribe = /*#__PURE__*/new WeakSet();
+var _subscribeResponse = /*#__PURE__*/new WeakSet();
+var _subscribeFailure = /*#__PURE__*/new WeakSet();
+var _failUnsubscribe = /*#__PURE__*/new WeakSet();
+var _unsubscribeResponse = /*#__PURE__*/new WeakSet();
+var _unsubscribeFailure = /*#__PURE__*/new WeakSet();
+var _failMessage = /*#__PURE__*/new WeakSet();
+var _messageResponse = /*#__PURE__*/new WeakSet();
+var _messageFailure = /*#__PURE__*/new WeakSet();
+var _receive = /*#__PURE__*/new WeakSet();
+var _handleMessages = /*#__PURE__*/new WeakSet();
+var _handleFailure = /*#__PURE__*/new WeakSet();
+var _hasSubscriptions = /*#__PURE__*/new WeakSet();
+var _resolveScopedCallback = /*#__PURE__*/new WeakSet();
+var _addListener = /*#__PURE__*/new WeakSet();
+class CometD {
+  constructor(_name2) {
+    _classPrivateMethodInitSpec$2(this, _addListener);
+    _classPrivateMethodInitSpec$2(this, _resolveScopedCallback);
+    _classPrivateMethodInitSpec$2(this, _hasSubscriptions);
+    _classPrivateMethodInitSpec$2(this, _handleFailure);
+    _classPrivateMethodInitSpec$2(this, _handleMessages);
+    _classPrivateMethodInitSpec$2(this, _receive);
+    _classPrivateMethodInitSpec$2(this, _messageFailure);
+    _classPrivateMethodInitSpec$2(this, _messageResponse);
+    _classPrivateMethodInitSpec$2(this, _failMessage);
+    _classPrivateMethodInitSpec$2(this, _unsubscribeFailure);
+    _classPrivateMethodInitSpec$2(this, _unsubscribeResponse);
+    _classPrivateMethodInitSpec$2(this, _failUnsubscribe);
+    _classPrivateMethodInitSpec$2(this, _subscribeFailure);
+    _classPrivateMethodInitSpec$2(this, _subscribeResponse);
+    _classPrivateMethodInitSpec$2(this, _failSubscribe);
+    _classPrivateMethodInitSpec$2(this, _disconnectFailure);
+    _classPrivateMethodInitSpec$2(this, _disconnectResponse);
+    _classPrivateMethodInitSpec$2(this, _failDisconnect);
+    _classPrivateMethodInitSpec$2(this, _connectFailure);
+    _classPrivateMethodInitSpec$2(this, _connectResponse);
+    _classPrivateMethodInitSpec$2(this, _failConnect);
+    _classPrivateMethodInitSpec$2(this, _matchMetaConnect);
+    _classPrivateMethodInitSpec$2(this, _handshakeFailure);
+    _classPrivateMethodInitSpec$2(this, _handshakeResponse);
+    _classPrivateMethodInitSpec$2(this, _failHandshake);
+    _classPrivateMethodInitSpec$2(this, _handleTransportFailure);
+    _classPrivateMethodInitSpec$2(this, _handleRemoteCall);
+    _classPrivateMethodInitSpec$2(this, _handleCallback);
+    _classPrivateMethodInitSpec$2(this, _notifyCallback);
+    _classPrivateMethodInitSpec$2(this, _delayedHandshake);
+    /**
+     * Sends the initial handshake message
+     */
+    _classPrivateMethodInitSpec$2(this, _handshake);
+    _classPrivateMethodInitSpec$2(this, _notifyTransportException);
+    _classPrivateMethodInitSpec$2(this, _disconnect);
+    _classPrivateMethodInitSpec$2(this, _updateAdvice);
+    _classPrivateMethodInitSpec$2(this, _delayedConnect);
+    /**
+     * Sends the connect message
+     */
+    _classPrivateMethodInitSpec$2(this, _connect);
+    /**
+     * 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.
+     */
+    _classPrivateMethodInitSpec$2(this, _endBatch);
+    _classPrivateMethodInitSpec$2(this, _flushBatch);
+    /**
+     * Starts the batch of messages to be sent in a single request.
+     */
+    _classPrivateMethodInitSpec$2(this, _startBatch);
+    _classPrivateMethodInitSpec$2(this, _increaseBackoff);
+    _classPrivateMethodInitSpec$2(this, _resetBackoff);
+    _classPrivateMethodInitSpec$2(this, _queueSend);
+    /**
+     * 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
+     */
+    _classPrivateMethodInitSpec$2(this, _send);
+    _classPrivateMethodInitSpec$2(this, _delayedSend);
+    _classPrivateMethodInitSpec$2(this, _cancelDelayedSend);
+    _classPrivateMethodInitSpec$2(this, _notifyListeners);
+    _classPrivateMethodInitSpec$2(this, _notify);
+    _classPrivateMethodInitSpec$2(this, _applyOutgoingExtensions);
+    _classPrivateMethodInitSpec$2(this, _applyIncomingExtensions);
+    _classPrivateMethodInitSpec$2(this, _applyExtension);
+    _classPrivateMethodInitSpec$2(this, _nextMessageId);
+    _classPrivateMethodInitSpec$2(this, _isDisconnected);
+    _classPrivateMethodInitSpec$2(this, _setStatus);
+    _classPrivateMethodInitSpec$2(this, _clearSubscriptions);
+    _classPrivateMethodInitSpec$2(this, _removeSubscription);
+    _classPrivateMethodInitSpec$2(this, _removeListener);
+    _classPrivateMethodInitSpec$2(this, _configure);
+    /**
+     * 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
+     */
+    _classPrivateMethodInitSpec$2(this, _isCrossDomain);
+    _classPrivateMethodInitSpec$2(this, _log);
+    _classPrivateFieldInitSpec$4(this, _scheduler, {
+      writable: true,
+      value: new Scheduler()
+    });
+    _classPrivateFieldInitSpec$4(this, _name$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$4(this, _crossDomain, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$4(this, _transports, {
+      writable: true,
+      value: new TransportRegistry()
+    });
+    _classPrivateFieldInitSpec$4(this, _transport, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$4(this, _status, {
+      writable: true,
+      value: "disconnected"
+    });
+    _classPrivateFieldInitSpec$4(this, _messageId, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$4(this, _clientId, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$4(this, _batch$2, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$4(this, _messageQueue, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec$4(this, _internalBatch, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$4(this, _listenerId, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$4(this, _listeners, {
+      writable: true,
+      value: {}
+    });
+    _classPrivateFieldInitSpec$4(this, _transportListeners, {
+      writable: true,
+      value: {}
+    });
+    _classPrivateFieldInitSpec$4(this, _backoff, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$4(this, _scheduledSend, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$4(this, _extensions, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec$4(this, _advice, {
+      writable: true,
+      value: {}
+    });
+    _classPrivateFieldInitSpec$4(this, _handshakeProps, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$4(this, _handshakeCallback, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec$4(this, _callbacks, {
+      writable: true,
+      value: {}
+    });
+    _classPrivateFieldInitSpec$4(this, _remoteCalls, {
+      writable: true,
+      value: {}
+    });
+    _classPrivateFieldInitSpec$4(this, _reestablish, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$4(this, _connected, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$4(this, _unconnectTime, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$4(this, _handshakeMessages, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec$4(this, _metaConnect, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldInitSpec$4(this, _config, {
+      writable: true,
+      value: {
+        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(this, _name$1, _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 = _classStaticPrivateMethodGet(CometD, CometD, _fieldValue).call(CometD, object, propName);
+          const targ = _classStaticPrivateMethodGet(CometD, CometD, _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() {
+    _classPrivateMethodGet$2(this, _log, _log2).call(this, "warn", arguments);
+  }
+  _info() {
+    if (_classPrivateFieldGet(this, _config).logLevel !== "warn") {
+      _classPrivateMethodGet$2(this, _log, _log2).call(this, "info", arguments);
+    }
+  }
+  _debug() {
+    if (_classPrivateFieldGet(this, _config).logLevel === "debug") {
+      _classPrivateMethodGet$2(this, _log, _log2).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) {
+    _classPrivateMethodGet$2(this, _queueSend, _queueSend2).call(this, message);
+  }
+  _getCallback(messageId) {
+    return _classPrivateFieldGet(this, _callbacks)[messageId];
+  }
+  _putCallback(messageId, callback) {
+    const result = this._getCallback(messageId);
+    if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, callback)) {
+      _classPrivateFieldGet(this, _callbacks)[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 = _classPrivateMethodGet$2(this, _isCrossDomain, _isCrossDomain2).call(this, _classStaticPrivateMethodGet(CometD, CometD, _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;
+            _classPrivateMethodGet$2(this, _notifyTransportException, _notifyTransportException2).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(this, _transport) ? _classPrivateFieldGet(this, _transport).type : null;
+          const newTransport = transports.negotiateTransport(transportTypes, version, crossDomain, url);
+          if (!newTransport) {
+            this._warn("Could not negotiate transport, client=[" + transportTypes + "]");
+            _classPrivateMethodGet$2(this, _notifyTransportException, _notifyTransportException2).call(this, oldTransportType, null, message.failure);
+            failureInfo.action = "none";
+          } else {
+            const newTransportType = newTransport.type;
+            this._debug("Transport", oldTransportType, "->", newTransportType);
+            _classPrivateMethodGet$2(this, _notifyTransportException, _notifyTransportException2).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(this, _unconnectTime) === 0) {
+          _classPrivateFieldSet(this, _unconnectTime, now);
+        }
+        if (failureInfo.action === "retry") {
+          failureInfo.delay = this.increaseBackoffPeriod();
+          // Check whether we may switch to handshaking.
+          const maxInterval = _classPrivateFieldGet(this, _advice).maxInterval;
+          if (maxInterval > 0) {
+            const expiration = _classPrivateFieldGet(this, _advice).timeout + _classPrivateFieldGet(this, _advice).interval + maxInterval;
+            const unconnected = now - _classPrivateFieldGet(this, _unconnectTime);
+            if (unconnected + _classPrivateFieldGet(this, _backoff) > 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) {
+    _classPrivateMethodGet$2(this, _receive, _receive2).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(this, _transports).add(type, transport, index);
+    if (result) {
+      this._debug("Registered transport", type);
+      if (_classStaticPrivateMethodGet(CometD, CometD, _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(this, _transports).remove(type);
+    if (transport !== null) {
+      this._debug("Unregistered transport", type);
+      if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, transport.unregistered)) {
+        transport.unregistered();
+      }
+    }
+    return transport;
+  }
+  unregisterTransports() {
+    _classPrivateFieldGet(this, _transports).clear();
+  }
+  /**
+   * @return an array of all registered transport types
+   */
+  getTransportTypes() {
+    return _classPrivateFieldGet(this, _transports).getTransportTypes();
+  }
+  findTransport(name) {
+    return _classPrivateFieldGet(this, _transports).find(name);
+  }
+
+  /**
+   * @returns the TransportRegistry object
+   */
+  getTransportRegistry() {
+    return _classPrivateFieldGet(this, _transports);
+  }
+
+  /**
+   * 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) {
+    _classPrivateMethodGet$2(this, _configure, _configure2).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);
+    }
+    _classPrivateMethodGet$2(this, _handshake, _handshake2).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 (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, disconnectProps)) {
+      disconnectCallback = disconnectProps;
+      disconnectProps = undefined;
+    }
+    const bayeuxMessage = {
+      id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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);
+    _classPrivateMethodGet$2(this, _setStatus, _setStatus2).call(this, "disconnecting");
+    _classPrivateMethodGet$2(this, _send, _send2).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() {
+    _classPrivateMethodGet$2(this, _startBatch, _startBatch2).call(this);
+  }
+  /**
+   * Marks the end of a batch of application messages to be sent to the server
+   * in a single request.
+   */
+  endBatch() {
+    _classPrivateMethodGet$2(this, _endBatch, _endBatch2).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 = _classPrivateMethodGet$2(this, _resolveScopedCallback, _resolveScopedCallback2).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(this, _transportListeners)[event];
+    if (!callbacks) {
+      _classPrivateFieldGet(this, _transportListeners)[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(this, _transportListeners)[event];
+    if (callbacks) {
+      const index = callbacks.indexOf(callback);
+      if (index >= 0) {
+        callbacks.splice(index, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+  _getTransportListeners(event) {
+    return _classPrivateFieldGet(this, _transportListeners)[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 (!_classStaticPrivateMethodGet(CometD, CometD, _isString).call(CometD, channel)) {
+      throw new Error("Illegal argument type: channel must be a string");
+    }
+    return _classPrivateMethodGet$2(this, _addListener, _addListener2).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);
+    }
+    _classPrivateMethodGet$2(this, _removeListener, _removeListener2).call(this, subscription);
+  }
+  /**
+   * Removes all listeners registered with {@link #addListener(channel, scope, callback)} or
+   * {@link #subscribe(channel, scope, callback)}.
+   */
+  clearListeners() {
+    _classPrivateFieldSet(this, _listeners, {});
+  }
+  /**
+   * 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 (!_classStaticPrivateMethodGet(CometD, CometD, _isValidChannel).call(CometD, channel)) {
+      throw new Error("Illegal argument: invalid channel " + channel);
+    }
+    if (this.isDisconnected()) {
+      throw new Error("Illegal state: disconnected");
+    }
+
+    // Normalize arguments
+    if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, scope)) {
+      subscribeCallback = subscribeProps;
+      subscribeProps = callback;
+      callback = scope;
+      scope = undefined;
+    }
+    if (_classStaticPrivateMethodGet(CometD, CometD, _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 = !_classPrivateMethodGet$2(this, _hasSubscriptions, _hasSubscriptions2).call(this, channel);
+    const subscription = _classPrivateMethodGet$2(this, _addListener, _addListener2).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: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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);
+      _classPrivateMethodGet$2(this, _queueSend, _queueSend2).call(this, message);
+    } else {
+      if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, subscribeCallback)) {
+        // Keep the semantic of calling callbacks asynchronously.
+        this.setTimeout(() => {
+          _classPrivateMethodGet$2(this, _notifyCallback, _notifyCallback2).call(this, subscribeCallback, {
+            id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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 (_classStaticPrivateMethodGet(CometD, CometD, _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 (!_classPrivateMethodGet$2(this, _hasSubscriptions, _hasSubscriptions2).call(this, channel)) {
+      const bayeuxMessage = {
+        id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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);
+      _classPrivateMethodGet$2(this, _queueSend, _queueSend2).call(this, message);
+    } else {
+      if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, unsubscribeCallback)) {
+        // Keep the semantic of calling callbacks asynchronously.
+        this.setTimeout(() => {
+          _classPrivateMethodGet$2(this, _notifyCallback, _notifyCallback2).call(this, unsubscribeCallback, {
+            id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).call(this),
+            successful: true,
+            channel: "/meta/unsubscribe",
+            subscription: channel
+          });
+        }, 0);
+      }
+    }
+  }
+  resubscribe(subscription, subscribeProps) {
+    _classPrivateMethodGet$2(this, _removeSubscription, _removeSubscription2).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() {
+    _classPrivateMethodGet$2(this, _clearSubscriptions, _clearSubscriptions2).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 (!_classStaticPrivateMethodGet(CometD, CometD, _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 (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, content)) {
+      publishCallback = content;
+      content = {};
+      publishProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, publishProps)) {
+      publishCallback = publishProps;
+      publishProps = undefined;
+    }
+    const bayeuxMessage = {
+      id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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);
+    _classPrivateMethodGet$2(this, _queueSend, _queueSend2).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 (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, data)) {
+      publishCallback = data;
+      data = new ArrayBuffer(0);
+      last = true;
+      meta = undefined;
+      publishProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, last)) {
+      publishCallback = last;
+      last = true;
+      meta = undefined;
+      publishProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, meta)) {
+      publishCallback = meta;
+      meta = undefined;
+      publishProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _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 (!_classStaticPrivateMethodGet(CometD, CometD, _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 (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, content)) {
+      callback = content;
+      content = {};
+      timeout = _classPrivateFieldGet(this, _config).maxNetworkDelay;
+      callProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, timeout)) {
+      callback = timeout;
+      timeout = _classPrivateFieldGet(this, _config).maxNetworkDelay;
+      callProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _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 (!_classStaticPrivateMethodGet(CometD, CometD, _isValidChannel).call(CometD, channel)) {
+      throw new Error("Illegal argument: invalid target " + target);
+    }
+    const bayeuxMessage = {
+      id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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");
+        _classPrivateMethodGet$2(this, _failMessage, _failMessage2).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(this, _remoteCalls)[message.id] = context;
+    _classPrivateMethodGet$2(this, _queueSend, _queueSend2).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 (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, data)) {
+      callback = data;
+      data = new ArrayBuffer(0);
+      last = true;
+      meta = undefined;
+      timeout = _classPrivateFieldGet(this, _config).maxNetworkDelay;
+      callProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, last)) {
+      callback = last;
+      last = true;
+      meta = undefined;
+      timeout = _classPrivateFieldGet(this, _config).maxNetworkDelay;
+      callProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, meta)) {
+      callback = meta;
+      meta = undefined;
+      timeout = _classPrivateFieldGet(this, _config).maxNetworkDelay;
+      callProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _isFunction).call(CometD, timeout)) {
+      callback = timeout;
+      timeout = _classPrivateFieldGet(this, _config).maxNetworkDelay;
+      callProps = undefined;
+    } else if (_classStaticPrivateMethodGet(CometD, CometD, _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(this, _status);
+  }
+
+  /**
+   * Returns whether this instance has been disconnected.
+   */
+  isDisconnected() {
+    return _classPrivateMethodGet$2(this, _isDisconnected, _isDisconnected2).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(this, _config).backoffIncrement = period;
+  }
+  /**
+   * Returns the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
+   */
+  getBackoffIncrement() {
+    return _classPrivateFieldGet(this, _config).backoffIncrement;
+  }
+
+  /**
+   * Returns the backoff period to wait before retrying an unsuccessful or failed message.
+   */
+  getBackoffPeriod() {
+    return _classPrivateFieldGet(this, _backoff);
+  }
+
+  /**
+   * Increases the backoff period up to the maximum value configured.
+   * @returns the backoff period after increment
+   */
+  increaseBackoffPeriod() {
+    return _classPrivateMethodGet$2(this, _increaseBackoff, _increaseBackoff2).call(this);
+  }
+
+  /**
+   * Resets the backoff period to zero.
+   */
+  resetBackoffPeriod() {
+    _classPrivateMethodGet$2(this, _resetBackoff, _resetBackoff2).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(this, _config).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 (!_classStaticPrivateMethodGet(CometD, CometD, _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(this, _extensions).length; ++i) {
+      const existingExtension = _classPrivateFieldGet(this, _extensions)[i];
+      if (existingExtension.name === name) {
+        existing = true;
+        break;
+      }
+    }
+    if (!existing) {
+      _classPrivateFieldGet(this, _extensions).push({
+        name: name,
+        extension: extension
+      });
+      this._debug("Registered extension", name);
+
+      // Callback for extensions
+      if (_classStaticPrivateMethodGet(CometD, CometD, _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 (!_classStaticPrivateMethodGet(CometD, CometD, _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(this, _extensions).length; ++i) {
+      const extension = _classPrivateFieldGet(this, _extensions)[i];
+      if (extension.name === name) {
+        _classPrivateFieldGet(this, _extensions).splice(i, 1);
+        unregistered = true;
+        this._debug("Unregistered extension", name);
+
+        // Callback for extensions
+        const ext = extension.extension;
+        if (_classStaticPrivateMethodGet(CometD, CometD, _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(this, _extensions).length; ++i) {
+      const extension = _classPrivateFieldGet(this, _extensions)[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(this, _name$1);
+  }
+
+  /**
+   * Returns the clientId assigned by the Bayeux server during handshake.
+   */
+  getClientId() {
+    return _classPrivateFieldGet(this, _clientId);
+  }
+
+  /**
+   * Returns the URL of the Bayeux server.
+   */
+  getURL() {
+    const transport = this.getTransport();
+    if (transport) {
+      let url = transport.url;
+      if (url) {
+        return url;
+      }
+      url = _classPrivateFieldGet(this, _config).urls[transport.type];
+      if (url) {
+        return url;
+      }
+    }
+    return _classPrivateFieldGet(this, _config).url;
+  }
+  getTransport() {
+    return _classPrivateFieldGet(this, _transport);
+  }
+  getConfiguration() {
+    return this._mixin(true, {}, _classPrivateFieldGet(this, _config));
+  }
+  getAdvice() {
+    return this._mixin(true, {}, _classPrivateFieldGet(this, _advice));
+  }
+  setTimeout(funktion, delay) {
+    return _classPrivateFieldGet(this, _scheduler).setTimeout(() => {
+      try {
+        this._debug("Invoking timed function", funktion);
+        funktion();
+      } catch (x) {
+        this._debug("Exception invoking timed function", funktion, x);
+      }
+    }, delay);
+  }
+  clearTimeout(id) {
+    _classPrivateFieldGet(this, _scheduler).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 (!_classStaticPrivateMethodGet(_CometD, _CometD, _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 (_classStaticPrivateMethodGet(_CometD, _CometD, _isAlpha).call(_CometD, char) || _classStaticPrivateMethodGet(_CometD, _CometD, _isNumeric).call(_CometD, char) || _classStaticPrivateMethodGet(_CometD, _CometD, _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 _log2(level, args) {
+  if (window.console) {
+    const logger = window.console[level];
+    if (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, logger)) {
+      const now = new Date();
+      [].splice.call(args, 0, 0, _classStaticPrivateMethodGet(_CometD, _CometD, _zeroPad).call(_CometD, now.getHours(), 2) + ":" + _classStaticPrivateMethodGet(_CometD, _CometD, _zeroPad).call(_CometD, now.getMinutes(), 2) + ":" + _classStaticPrivateMethodGet(_CometD, _CometD, _zeroPad).call(_CometD, now.getSeconds(), 2) + "." + _classStaticPrivateMethodGet(_CometD, _CometD, _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);
+}
+function _isCrossDomain2(hostAndPort) {
+  if (window.location && window.location.host) {
+    if (hostAndPort) {
+      return hostAndPort !== window.location.host;
+    }
+  }
+  return false;
+}
+function _configure2(configuration) {
+  this._debug("Configuring cometd object with", configuration);
+  // Support old style param, where only the Bayeux server URL was passed.
+  if (_classStaticPrivateMethodGet(_CometD, _CometD, _isString).call(_CometD, configuration)) {
+    configuration = {
+      url: configuration
+    };
+  }
+  if (!configuration) {
+    configuration = {};
+  }
+  _classPrivateFieldSet(this, _config, this._mixin(false, _classPrivateFieldGet(this, _config), 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 = _classStaticPrivateMethodGet(_CometD, _CometD, _splitURL).call(_CometD, url);
+  const hostAndPort = urlParts[2];
+  const uri = urlParts[8];
+  const afterURI = urlParts[9];
+  _classPrivateFieldSet(this, _crossDomain, _classPrivateMethodGet$2(this, _isCrossDomain, _isCrossDomain2).call(this, hostAndPort));
+
+  // Check if appending extra path is supported.
+  if (_classPrivateFieldGet(this, _config).appendMessageTypeToURL) {
+    if (afterURI !== undefined && afterURI.length > 0) {
+      this._info("Appending message type to URI", uri, afterURI, "is not supported, disabling 'appendMessageTypeToURL' configuration");
+      _classPrivateFieldGet(this, _config).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(this, _config).appendMessageTypeToURL = false;
+      }
+    }
+  }
+  if (window.Worker && window.Blob && window.URL && _classPrivateFieldGet(this, _config).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(this, _scheduler).setTimeout = (funktion, delay) => {
+      const id = _classPrivateFieldGet(this, _scheduler).register(funktion);
+      worker.postMessage({
+        id: id,
+        type: "setTimeout",
+        delay: delay
+      });
+      return id;
+    };
+    _classPrivateFieldGet(this, _scheduler).clearTimeout = id => {
+      _classPrivateFieldGet(this, _scheduler).unregister(id);
+      worker.postMessage({
+        id: id,
+        type: "clearTimeout"
+      });
+    };
+    worker.onmessage = e => {
+      const id = e.data.id;
+      const funktion = _classPrivateFieldGet(this, _scheduler).unregister(id);
+      if (funktion) {
+        funktion();
+      }
+    };
+  }
+}
+function _removeListener2(subscription) {
+  if (subscription) {
+    const subscriptions = _classPrivateFieldGet(this, _listeners)[subscription.channel];
+    if (subscriptions && subscriptions[subscription.id]) {
+      delete subscriptions[subscription.id];
+      this._debug("Removed", subscription.listener ? "listener" : "subscription", subscription);
+    }
+  }
+}
+function _removeSubscription2(subscription) {
+  if (subscription && !subscription.listener) {
+    _classPrivateMethodGet$2(this, _removeListener, _removeListener2).call(this, subscription);
+  }
+}
+function _clearSubscriptions2() {
+  for (let channel in _classPrivateFieldGet(this, _listeners)) {
+    if (_classPrivateFieldGet(this, _listeners).hasOwnProperty(channel)) {
+      const subscriptions = _classPrivateFieldGet(this, _listeners)[channel];
+      if (subscriptions) {
+        for (let id in subscriptions) {
+          if (subscriptions.hasOwnProperty(id)) {
+            _classPrivateMethodGet$2(this, _removeSubscription, _removeSubscription2).call(this, subscriptions[id]);
+          }
+        }
+      }
+    }
+  }
+}
+function _setStatus2(newStatus) {
+  const oldStatus = this.getStatus();
+  if (oldStatus !== newStatus) {
+    this._debug("Status", oldStatus, "->", newStatus);
+    _classPrivateFieldSet(this, _status, newStatus);
+  }
+}
+function _isDisconnected2() {
+  const status = _classPrivateFieldGet(this, _status);
+  return status === "disconnecting" || status === "disconnected";
+}
+function _nextMessageId2() {
+  var _this$messageId;
+  const result = _classPrivateFieldSet(this, _messageId, (_this$messageId = _classPrivateFieldGet(this, _messageId), ++_this$messageId));
+  return "" + result;
+}
+function _applyExtension2(scope, callback, name, message, outgoing) {
+  try {
+    return callback.call(scope, message);
+  } catch (x) {
+    const handler = this.onExtensionException;
+    if (_classStaticPrivateMethodGet(_CometD, _CometD, _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 _applyIncomingExtensions2(message) {
+  for (let i = 0; i < _classPrivateFieldGet(this, _extensions).length; ++i) {
+    if (message === undefined || message === null) {
+      break;
+    }
+    const extension = _classPrivateFieldGet(this, _extensions)[i];
+    const callback = extension.extension.incoming;
+    if (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, callback)) {
+      const result = _classPrivateMethodGet$2(this, _applyExtension, _applyExtension2).call(this, extension.extension, callback, extension.name, message, false);
+      message = result === undefined ? message : result;
+    }
+  }
+  return message;
+}
+function _applyOutgoingExtensions2(message) {
+  for (let i = _classPrivateFieldGet(this, _extensions).length - 1; i >= 0; --i) {
+    if (message === undefined || message === null) {
+      break;
+    }
+    const extension = _classPrivateFieldGet(this, _extensions)[i];
+    const callback = extension.extension.outgoing;
+    if (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, callback)) {
+      const result = _classPrivateMethodGet$2(this, _applyExtension, _applyExtension2).call(this, extension.extension, callback, extension.name, message, true);
+      message = result === undefined ? message : result;
+    }
+  }
+  return message;
+}
+function _notify2(channel, message) {
+  const subscriptions = _classPrivateFieldGet(this, _listeners)[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 (_classStaticPrivateMethodGet(_CometD, _CometD, _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 _notifyListeners2(channel, message) {
+  // Notify direct listeners
+  _classPrivateMethodGet$2(this, _notify, _notify2).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) {
+      _classPrivateMethodGet$2(this, _notify, _notify2).call(this, channelPart, message);
+    }
+    // Add the recursive globber and notify.
+    channelPart += "*";
+    _classPrivateMethodGet$2(this, _notify, _notify2).call(this, channelPart, message);
+  }
+}
+function _cancelDelayedSend2() {
+  if (_classPrivateFieldGet(this, _scheduledSend) !== null) {
+    this.clearTimeout(_classPrivateFieldGet(this, _scheduledSend));
+  }
+  _classPrivateFieldSet(this, _scheduledSend, null);
+}
+function _delayedSend2(operation, delay) {
+  _classPrivateMethodGet$2(this, _cancelDelayedSend, _cancelDelayedSend2).call(this);
+  const time = _classPrivateFieldGet(this, _advice).interval + delay;
+  this._debug("Function scheduled in", time, "ms, interval =", _classPrivateFieldGet(this, _advice).interval, "backoff =", _classPrivateFieldGet(this, _backoff), operation);
+  _classPrivateFieldSet(this, _scheduledSend, this.setTimeout(operation, time));
+}
+function _send2(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 = _classPrivateMethodGet$2(this, _applyOutgoingExtensions, _applyOutgoingExtensions2).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(this, _callbacks)[messageId];
+      messages.splice(i--, 1);
+    }
+  }
+  if (messages.length === 0) {
+    return;
+  }
+  if (metaConnect) {
+    _classPrivateFieldSet(this, _metaConnect, messages[0]);
+  }
+  let url = this.getURL();
+  if (_classPrivateFieldGet(this, _config).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 {
+        _classPrivateMethodGet$2(this, _handleMessages, _handleMessages2).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";
+        _classPrivateMethodGet$2(this, _handleFailure, _handleFailure2).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 _queueSend2(message) {
+  if (_classPrivateFieldGet(this, _batch$2) > 0 || _classPrivateFieldGet(this, _internalBatch) === true) {
+    _classPrivateFieldGet(this, _messageQueue).push(message);
+  } else {
+    _classPrivateMethodGet$2(this, _send, _send2).call(this, [message], false);
+  }
+}
+function _resetBackoff2() {
+  _classPrivateFieldSet(this, _backoff, 0);
+}
+function _increaseBackoff2() {
+  if (_classPrivateFieldGet(this, _backoff) < _classPrivateFieldGet(this, _config).maxBackoff) {
+    _classPrivateFieldSet(this, _backoff, _classPrivateFieldGet(this, _backoff) + this.getBackoffIncrement());
+  }
+  return _classPrivateFieldGet(this, _backoff);
+}
+function _startBatch2() {
+  var _this$batch;
+  _classPrivateFieldSet(this, _batch$2, (_this$batch = _classPrivateFieldGet(this, _batch$2), ++_this$batch));
+  this._debug("Starting batch, depth", _classPrivateFieldGet(this, _batch$2));
+}
+function _flushBatch2() {
+  const messages = _classPrivateFieldGet(this, _messageQueue);
+  _classPrivateFieldSet(this, _messageQueue, []);
+  if (messages.length > 0) {
+    _classPrivateMethodGet$2(this, _send, _send2).call(this, messages, false);
+  }
+}
+function _endBatch2() {
+  var _this$batch2;
+  _classPrivateFieldSet(this, _batch$2, (_this$batch2 = _classPrivateFieldGet(this, _batch$2), --_this$batch2));
+  this._debug("Ending batch, depth", _classPrivateFieldGet(this, _batch$2));
+  if (_classPrivateFieldGet(this, _batch$2) < 0) {
+    throw new Error("Calls to startBatch() and endBatch() are not paired");
+  }
+  if (_classPrivateFieldGet(this, _batch$2) === 0 && !this.isDisconnected() && !_classPrivateFieldGet(this, _internalBatch)) {
+    _classPrivateMethodGet$2(this, _flushBatch, _flushBatch2).call(this);
+  }
+}
+function _connect2() {
+  if (!this.isDisconnected()) {
+    const bayeuxMessage = {
+      id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).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(this, _connected)) {
+      bayeuxMessage.advice = {
+        timeout: 0
+      };
+    }
+    _classPrivateMethodGet$2(this, _setStatus, _setStatus2).call(this, "connecting");
+    this._debug("Connect sent", bayeuxMessage);
+    _classPrivateMethodGet$2(this, _send, _send2).call(this, [bayeuxMessage], true, "connect");
+    _classPrivateMethodGet$2(this, _setStatus, _setStatus2).call(this, "connected");
+  }
+}
+function _delayedConnect2(delay) {
+  _classPrivateMethodGet$2(this, _setStatus, _setStatus2).call(this, "connecting");
+  _classPrivateMethodGet$2(this, _delayedSend, _delayedSend2).call(this, () => {
+    _classPrivateMethodGet$2(this, _connect, _connect2).call(this);
+  }, delay);
+}
+function _updateAdvice2(newAdvice) {
+  if (newAdvice) {
+    _classPrivateFieldSet(this, _advice, this._mixin(false, {}, _classPrivateFieldGet(this, _config).advice, newAdvice));
+    this._debug("New advice", _classPrivateFieldGet(this, _advice));
+  }
+}
+function _disconnect2(abort) {
+  _classPrivateMethodGet$2(this, _cancelDelayedSend, _cancelDelayedSend2).call(this);
+  const transport = this.getTransport();
+  if (abort && transport) {
+    transport.abort();
+  }
+  _classPrivateFieldSet(this, _crossDomain, false);
+  _classPrivateFieldSet(this, _transport, null);
+  _classPrivateMethodGet$2(this, _setStatus, _setStatus2).call(this, "disconnected");
+  _classPrivateFieldSet(this, _clientId, null);
+  _classPrivateFieldSet(this, _batch$2, 0);
+  _classPrivateMethodGet$2(this, _resetBackoff, _resetBackoff2).call(this);
+  _classPrivateFieldSet(this, _reestablish, false);
+  _classPrivateFieldSet(this, _connected, false);
+  _classPrivateFieldSet(this, _unconnectTime, 0);
+  _classPrivateFieldSet(this, _metaConnect, null);
+
+  // Fail any existing queued message
+  if (_classPrivateFieldGet(this, _messageQueue).length > 0) {
+    const messages = _classPrivateFieldGet(this, _messageQueue);
+    _classPrivateFieldSet(this, _messageQueue, []);
+    _classPrivateMethodGet$2(this, _handleFailure, _handleFailure2).call(this, undefined, messages, {
+      reason: "Disconnected"
+    });
+  }
+}
+function _notifyTransportException2(oldTransport, newTransport, failure) {
+  const handler = this.onTransportException;
+  if (_classStaticPrivateMethodGet(_CometD, _CometD, _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);
+    }
+  }
+}
+function _handshake2(handshakeProps, handshakeCallback) {
+  if (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, handshakeProps)) {
+    handshakeCallback = handshakeProps;
+    handshakeProps = undefined;
+  }
+  _classPrivateFieldSet(this, _clientId, null);
+  this.clearSubscriptions();
+
+  // Reset the transports if we're not retrying the handshake
+  if (this.isDisconnected()) {
+    _classPrivateFieldGet(this, _transports).reset(true);
+  }
+
+  // Reset the advice.
+  _classPrivateMethodGet$2(this, _updateAdvice, _updateAdvice2).call(this, {});
+  _classPrivateFieldSet(this, _batch$2, 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(this, _internalBatch, true);
+
+  // Save the properties provided by the user, so that
+  // we can reuse them during automatic re-handshake
+  _classPrivateFieldSet(this, _handshakeProps, handshakeProps);
+  _classPrivateFieldSet(this, _handshakeCallback, handshakeCallback);
+  const version = "1.0";
+
+  // Figure out the transports to send to the server
+  const url = this.getURL();
+  const transportTypes = _classPrivateFieldGet(this, _transports).findTransportTypes(version, _classPrivateFieldGet(this, _crossDomain), url);
+  const bayeuxMessage = {
+    id: _classPrivateMethodGet$2(this, _nextMessageId, _nextMessageId2).call(this),
+    version: version,
+    minimumVersion: version,
+    channel: "/meta/handshake",
+    supportedConnectionTypes: transportTypes,
+    advice: {
+      timeout: _classPrivateFieldGet(this, _advice).timeout,
+      interval: _classPrivateFieldGet(this, _advice).interval
+    }
+  };
+  // Do not allow the user to override important fields.
+  const message = this._mixin(false, {}, _classPrivateFieldGet(this, _handshakeProps), 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(this, _transport)) {
+    _classPrivateFieldSet(this, _transport, _classPrivateFieldGet(this, _transports).negotiateTransport(transportTypes, version, _classPrivateFieldGet(this, _crossDomain), url));
+    if (!_classPrivateFieldGet(this, _transport)) {
+      const failure = "Could not find initial transport among: " + this.getTransportTypes();
+      this._warn(failure);
+      throw new Error(failure);
+    }
+  }
+  this._debug("Initial transport is", _classPrivateFieldGet(this, _transport).type);
+
+  // We started a batch to hold the application messages,
+  // so here we must bypass it and send immediately.
+  _classPrivateMethodGet$2(this, _setStatus, _setStatus2).call(this, "handshaking");
+  this._debug("Handshake sent", message);
+  _classPrivateMethodGet$2(this, _send, _send2).call(this, [message], false, "handshake");
+}
+function _delayedHandshake2(delay) {
+  _classPrivateMethodGet$2(this, _setStatus, _setStatus2).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(this, _internalBatch, true);
+  _classPrivateMethodGet$2(this, _delayedSend, _delayedSend2).call(this, () => {
+    _classPrivateMethodGet$2(this, _handshake, _handshake2).call(this, _classPrivateFieldGet(this, _handshakeProps), _classPrivateFieldGet(this, _handshakeCallback));
+  }, delay);
+}
+function _notifyCallback2(callback, message) {
+  try {
+    callback.call(this, message);
+  } catch (x) {
+    const handler = this.onCallbackException;
+    if (_classStaticPrivateMethodGet(_CometD, _CometD, _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 _handleCallback2(message) {
+  const callback = this._getCallback([message.id]);
+  if (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, callback)) {
+    delete _classPrivateFieldGet(this, _callbacks)[message.id];
+    _classPrivateMethodGet$2(this, _notifyCallback, _notifyCallback2).call(this, callback, message);
+  }
+}
+function _handleRemoteCall2(message) {
+  const context = _classPrivateFieldGet(this, _remoteCalls)[message.id];
+  delete _classPrivateFieldGet(this, _remoteCalls)[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 (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, callback)) {
+      _classPrivateMethodGet$2(this, _notifyCallback, _notifyCallback2).call(this, callback, message);
+      return true;
+    }
+  }
+  return false;
+}
+function _handleTransportFailure2(failureInfo) {
+  this._debug("Transport failure handling", failureInfo);
+  if (failureInfo.transport) {
+    _classPrivateFieldSet(this, _transport, failureInfo.transport);
+  }
+  if (failureInfo.url) {
+    _classPrivateFieldGet(this, _transport).url = failureInfo.url;
+  }
+  const action = failureInfo.action;
+  const delay = failureInfo.delay || 0;
+  switch (action) {
+    case "handshake":
+      _classPrivateMethodGet$2(this, _delayedHandshake, _delayedHandshake2).call(this, delay);
+      break;
+    case "retry":
+      _classPrivateMethodGet$2(this, _delayedConnect, _delayedConnect2).call(this, delay);
+      break;
+    case "none":
+      _classPrivateMethodGet$2(this, _disconnect, _disconnect2).call(this, true);
+      break;
+    default:
+      throw new Error("Unknown action " + action);
+  }
+}
+function _failHandshake2(message, failureInfo) {
+  _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/handshake", message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsuccessful", message);
+
+  // The listeners may have disconnected.
+  if (this.isDisconnected()) {
+    failureInfo.action = "none";
+  }
+  this.onTransportFailure(message, failureInfo, failureInfo => _classPrivateMethodGet$2(this, _handleTransportFailure, _handleTransportFailure2).call(this, failureInfo));
+}
+function _handshakeResponse2(message) {
+  const url = this.getURL();
+  if (message.successful) {
+    const crossDomain = _classPrivateMethodGet$2(this, _isCrossDomain, _isCrossDomain2).call(this, _classStaticPrivateMethodGet(_CometD, _CometD, _splitURL).call(_CometD, url)[2]);
+    const newTransport = _classPrivateFieldGet(this, _transports).negotiateTransport(message.supportedConnectionTypes, message.version, crossDomain, url);
+    if (newTransport === null) {
+      message.successful = false;
+      _classPrivateMethodGet$2(this, _failHandshake, _failHandshake2).call(this, message, {
+        cause: "negotiation",
+        action: "none",
+        transport: null
+      });
+      return;
+    } else {
+      const oldTransport = _classPrivateFieldGet(this, _transport);
+      if (oldTransport !== newTransport) {
+        this._debug("Transport", oldTransport && oldTransport.type, "->", newTransport.type);
+        _classPrivateFieldSet(this, _transport, newTransport);
+      }
+    }
+    _classPrivateFieldSet(this, _clientId, 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(this, _internalBatch, false);
+    _classPrivateMethodGet$2(this, _flushBatch, _flushBatch2).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(this, _reestablish);
+    _classPrivateFieldSet(this, _reestablish, true);
+    _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+    _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/handshake", message);
+    _classPrivateFieldSet(this, _handshakeMessages, message["x-messages"] || 0);
+    const action = this.isDisconnected() ? "none" : _classPrivateFieldGet(this, _advice).reconnect || "retry";
+    switch (action) {
+      case "retry":
+        _classPrivateMethodGet$2(this, _resetBackoff, _resetBackoff2).call(this);
+        if (_classPrivateFieldGet(this, _handshakeMessages) === 0) {
+          _classPrivateMethodGet$2(this, _delayedConnect, _delayedConnect2).call(this, 0);
+        } else {
+          this._debug("Processing", _classPrivateFieldGet(this, _handshakeMessages), "handshake-delivered messages");
+        }
+        break;
+      case "none":
+        _classPrivateMethodGet$2(this, _disconnect, _disconnect2).call(this, true);
+        break;
+      default:
+        throw new Error("Unrecognized advice action " + action);
+    }
+  } else {
+    _classPrivateMethodGet$2(this, _failHandshake, _failHandshake2).call(this, message, {
+      cause: "unsuccessful",
+      action: _classPrivateFieldGet(this, _advice).reconnect || "handshake",
+      transport: this.getTransport()
+    });
+  }
+}
+function _handshakeFailure2(message) {
+  _classPrivateMethodGet$2(this, _failHandshake, _failHandshake2).call(this, message, {
+    cause: "failure",
+    action: "handshake",
+    transport: null
+  });
+}
+function _matchMetaConnect2(connect) {
+  if (this.getStatus() === "disconnected") {
+    return true;
+  }
+  if (_classPrivateFieldGet(this, _metaConnect) && _classPrivateFieldGet(this, _metaConnect).id === connect.id) {
+    _classPrivateFieldSet(this, _metaConnect, null);
+    return true;
+  }
+  return false;
+}
+function _failConnect2(message, failureInfo) {
+  // Notify the listeners after the status change but before the next action.
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/connect", message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsuccessful", message);
+
+  // The listeners may have disconnected.
+  if (this.isDisconnected()) {
+    failureInfo.action = "none";
+  }
+  this.onTransportFailure(message, failureInfo, failureInfo => _classPrivateMethodGet$2(this, _handleTransportFailure, _handleTransportFailure2).call(this, failureInfo));
+}
+function _connectResponse2(message) {
+  if (_classPrivateMethodGet$2(this, _matchMetaConnect, _matchMetaConnect2).call(this, message)) {
+    _classPrivateFieldSet(this, _connected, message.successful);
+    if (_classPrivateFieldGet(this, _connected)) {
+      _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).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(this, _advice).reconnect || "retry";
+      switch (action) {
+        case "retry":
+          _classPrivateMethodGet$2(this, _resetBackoff, _resetBackoff2).call(this);
+          _classPrivateMethodGet$2(this, _delayedConnect, _delayedConnect2).call(this, _classPrivateFieldGet(this, _backoff));
+          break;
+        case "none":
+          _classPrivateMethodGet$2(this, _disconnect, _disconnect2).call(this, false);
+          break;
+        default:
+          throw new Error("Unrecognized advice action " + action);
+      }
+    } else {
+      _classPrivateMethodGet$2(this, _failConnect, _failConnect2).call(this, message, {
+        cause: "unsuccessful",
+        action: _classPrivateFieldGet(this, _advice).reconnect || "retry",
+        transport: this.getTransport()
+      });
+    }
+  } else {
+    this._debug("Mismatched /meta/connect reply", message);
+  }
+}
+function _connectFailure2(message) {
+  if (_classPrivateMethodGet$2(this, _matchMetaConnect, _matchMetaConnect2).call(this, message)) {
+    _classPrivateFieldSet(this, _connected, false);
+    _classPrivateMethodGet$2(this, _failConnect, _failConnect2).call(this, message, {
+      cause: "failure",
+      action: "retry",
+      transport: null
+    });
+  } else {
+    this._debug("Mismatched /meta/connect failure", message);
+  }
+}
+function _failDisconnect2(message) {
+  _classPrivateMethodGet$2(this, _disconnect, _disconnect2).call(this, true);
+  _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/disconnect", message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsuccessful", message);
+}
+function _disconnectResponse2(message) {
+  if (message.successful) {
+    // Wait for the /meta/connect to arrive.
+    _classPrivateMethodGet$2(this, _disconnect, _disconnect2).call(this, false);
+    _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+    _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/disconnect", message);
+  } else {
+    _classPrivateMethodGet$2(this, _failDisconnect, _failDisconnect2).call(this, message);
+  }
+}
+function _disconnectFailure2(message) {
+  _classPrivateMethodGet$2(this, _failDisconnect, _failDisconnect2).call(this, message);
+}
+function _failSubscribe2(message) {
+  const subscriptions = _classPrivateFieldGet(this, _listeners)[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);
+        }
+      }
+    }
+  }
+  _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/subscribe", message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsuccessful", message);
+}
+function _subscribeResponse2(message) {
+  if (message.successful) {
+    _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+    _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/subscribe", message);
+  } else {
+    _classPrivateMethodGet$2(this, _failSubscribe, _failSubscribe2).call(this, message);
+  }
+}
+function _subscribeFailure2(message) {
+  _classPrivateMethodGet$2(this, _failSubscribe, _failSubscribe2).call(this, message);
+}
+function _failUnsubscribe2(message) {
+  _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsubscribe", message);
+  _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsuccessful", message);
+}
+function _unsubscribeResponse2(message) {
+  if (message.successful) {
+    _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+    _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsubscribe", message);
+  } else {
+    _classPrivateMethodGet$2(this, _failUnsubscribe, _failUnsubscribe2).call(this, message);
+  }
+}
+function _unsubscribeFailure2(message) {
+  _classPrivateMethodGet$2(this, _failUnsubscribe, _failUnsubscribe2).call(this, message);
+}
+function _failMessage2(message) {
+  if (!_classPrivateMethodGet$2(this, _handleRemoteCall, _handleRemoteCall2).call(this, message)) {
+    _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+    _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/publish", message);
+    _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/unsuccessful", message);
+  }
+}
+function _messageResponse2(message) {
+  if (message.data !== undefined) {
+    if (!_classPrivateMethodGet$2(this, _handleRemoteCall, _handleRemoteCall2).call(this, message)) {
+      _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, message.channel, message);
+      if (_classPrivateFieldGet(this, _handshakeMessages) > 0) {
+        var _this$handshakeMessag;
+        _classPrivateFieldSet(this, _handshakeMessages, (_this$handshakeMessag = _classPrivateFieldGet(this, _handshakeMessages), --_this$handshakeMessag));
+        if (_classPrivateFieldGet(this, _handshakeMessages) === 0) {
+          this._debug("Processed last handshake-delivered message");
+          _classPrivateMethodGet$2(this, _delayedConnect, _delayedConnect2).call(this, 0);
+        }
+      }
+    }
+  } else {
+    if (message.successful === undefined) {
+      this._warn("Unknown Bayeux Message", message);
+    } else {
+      if (message.successful) {
+        _classPrivateMethodGet$2(this, _handleCallback, _handleCallback2).call(this, message);
+        _classPrivateMethodGet$2(this, _notifyListeners, _notifyListeners2).call(this, "/meta/publish", message);
+      } else {
+        _classPrivateMethodGet$2(this, _failMessage, _failMessage2).call(this, message);
+      }
+    }
+  }
+}
+function _messageFailure2(failure) {
+  _classPrivateMethodGet$2(this, _failMessage, _failMessage2).call(this, failure);
+}
+function _receive2(message) {
+  _classPrivateFieldSet(this, _unconnectTime, 0);
+  message = _classPrivateMethodGet$2(this, _applyIncomingExtensions, _applyIncomingExtensions2).call(this, message);
+  if (message === undefined || message === null) {
+    return;
+  }
+  _classPrivateMethodGet$2(this, _updateAdvice, _updateAdvice2).call(this, message.advice);
+  const channel = message.channel;
+  switch (channel) {
+    case "/meta/handshake":
+      _classPrivateMethodGet$2(this, _handshakeResponse, _handshakeResponse2).call(this, message);
+      break;
+    case "/meta/connect":
+      _classPrivateMethodGet$2(this, _connectResponse, _connectResponse2).call(this, message);
+      break;
+    case "/meta/disconnect":
+      _classPrivateMethodGet$2(this, _disconnectResponse, _disconnectResponse2).call(this, message);
+      break;
+    case "/meta/subscribe":
+      _classPrivateMethodGet$2(this, _subscribeResponse, _subscribeResponse2).call(this, message);
+      break;
+    case "/meta/unsubscribe":
+      _classPrivateMethodGet$2(this, _unsubscribeResponse, _unsubscribeResponse2).call(this, message);
+      break;
+    default:
+      _classPrivateMethodGet$2(this, _messageResponse, _messageResponse2).call(this, message);
+      break;
+  }
+}
+function _handleMessages2(rcvdMessages) {
+  this._debug("Received", rcvdMessages);
+  for (let i = 0; i < rcvdMessages.length; ++i) {
+    const message = rcvdMessages[i];
+    this.receive(message);
+  }
+}
+function _handleFailure2(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":
+        _classPrivateMethodGet$2(this, _handshakeFailure, _handshakeFailure2).call(this, failureMessage);
+        break;
+      case "/meta/connect":
+        _classPrivateMethodGet$2(this, _connectFailure, _connectFailure2).call(this, failureMessage);
+        break;
+      case "/meta/disconnect":
+        _classPrivateMethodGet$2(this, _disconnectFailure, _disconnectFailure2).call(this, failureMessage);
+        break;
+      case "/meta/subscribe":
+        failureMessage.subscription = message.subscription;
+        _classPrivateMethodGet$2(this, _subscribeFailure, _subscribeFailure2).call(this, failureMessage);
+        break;
+      case "/meta/unsubscribe":
+        failureMessage.subscription = message.subscription;
+        _classPrivateMethodGet$2(this, _unsubscribeFailure, _unsubscribeFailure2).call(this, failureMessage);
+        break;
+      default:
+        _classPrivateMethodGet$2(this, _messageFailure, _messageFailure2).call(this, failureMessage);
+        break;
+    }
+  }
+}
+function _hasSubscriptions2(channel) {
+  const subscriptions = _classPrivateFieldGet(this, _listeners)[channel];
+  if (subscriptions) {
+    for (let id in subscriptions) {
+      if (subscriptions.hasOwnProperty(id)) {
+        if (subscriptions[id]) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function _resolveScopedCallback2(scope, callback) {
+  const delegate = {
+    scope: scope,
+    method: callback
+  };
+  if (_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, scope)) {
+    delegate.scope = undefined;
+    delegate.method = scope;
+  } else {
+    if (_classStaticPrivateMethodGet(_CometD, _CometD, _isString).call(_CometD, callback)) {
+      if (!scope) {
+        throw new Error("Invalid scope " + scope);
+      }
+      delegate.method = scope[callback];
+      if (!_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, delegate.method)) {
+        throw new Error("Invalid callback " + callback + " for scope " + scope);
+      }
+    } else if (!_classStaticPrivateMethodGet(_CometD, _CometD, _isFunction).call(_CometD, callback)) {
+      throw new Error("Invalid callback " + callback);
+    }
+  }
+  return delegate;
+}
+function _addListener2(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 = _classPrivateMethodGet$2(this, _resolveScopedCallback, _resolveScopedCallback2).call(this, scope, callback);
+  this._debug("Adding", isListener ? "listener" : "subscription", "on", channel, "with scope", delegate.scope, "and callback", delegate.method);
+  const id = _classPrivateFieldSet(this, _listenerId, (_this$listenerId = _classPrivateFieldGet(this, _listenerId), ++_this$listenerId));
+  const subscription = {
+    id: id,
+    channel: channel,
+    scope: delegate.scope,
+    callback: delegate.method,
+    listener: isListener
+  };
+  let subscriptions = _classPrivateFieldGet(this, _listeners)[channel];
+  if (!subscriptions) {
+    subscriptions = {};
+    _classPrivateFieldGet(this, _listeners)[channel] = subscriptions;
+  }
+  subscriptions[id] = subscription;
+  this._debug("Added", isListener ? "listener" : "subscription", subscription);
+  return subscription;
+}
+
+function _classPrivateFieldInitSpec$3(obj, privateMap, value) { _checkPrivateRedeclaration$3(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$3(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+var _cometd = /*#__PURE__*/new WeakMap();
+/*
+ * Copyright (c) 2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Base class for CometD extensions.
+ */
+class Extension {
+  constructor() {
+    _classPrivateFieldInitSpec$3(this, _cometd, {
+      writable: true,
+      value: void 0
+    });
+  }
+  registered(name, cometd) {
+    _classPrivateFieldSet(this, _cometd, cometd);
+  }
+  unregistered() {
+    _classPrivateFieldSet(this, _cometd, null);
+  }
+  get cometd() {
+    return _classPrivateFieldGet(this, _cometd);
+  }
+  incoming(message) {
+    return message;
+  }
+  outgoing(message) {
+    return message;
+  }
+}
+
+function _classPrivateMethodInitSpec$1(obj, privateSet) { _checkPrivateRedeclaration$2(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec$2(obj, privateMap, value) { _checkPrivateRedeclaration$2(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$2(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet$1(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+/**
+ * This client-side extension enables the client to acknowledge to the server
+ * the messages that the client has received.
+ * For the acknowledgement to work, the server must be configured with the
+ * correspondent server-side ack extension. If both client and server support
+ * the ack extension, then the ack functionality will take place automatically.
+ * By enabling this extension, all messages arriving from the server will arrive
+ * via /meta/connect, so the comet communication will be slightly chattier.
+ * The fact that all messages will return via /meta/connect means also that the
+ * messages will arrive with total order, which is not guaranteed if messages
+ * can arrive via both /meta/connect and normal response.
+ * Messages are not acknowledged one by one, but instead a batch of messages is
+ * acknowledged when the /meta/connect returns.
+ */
+var _serverSupportsAcks = /*#__PURE__*/new WeakMap();
+var _batch$1 = /*#__PURE__*/new WeakMap();
+var _debug = /*#__PURE__*/new WeakSet();
+class AckExtension extends Extension {
+  constructor(..._args) {
+    super(..._args);
+    _classPrivateMethodInitSpec$1(this, _debug);
+    _classPrivateFieldInitSpec$2(this, _serverSupportsAcks, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$2(this, _batch$1, {
+      writable: true,
+      value: 0
+    });
+  }
+  registered(name, cometd) {
+    super.registered(name, cometd);
+    _classPrivateMethodGet$1(this, _debug, _debug2).call(this, "AckExtension: executing registration callback");
+  }
+  unregistered() {
+    _classPrivateMethodGet$1(this, _debug, _debug2).call(this, "AckExtension: executing unregistration callback");
+    super.unregistered();
+  }
+  incoming(message) {
+    const channel = message.channel;
+    const ext = message.ext;
+    if (channel === "/meta/handshake") {
+      if (ext) {
+        const ackField = ext.ack;
+        if (typeof ackField === "object") {
+          // New format.
+          _classPrivateFieldSet(this, _serverSupportsAcks, ackField.enabled === true);
+          const batch = ackField.batch;
+          if (typeof batch === "number") {
+            _classPrivateFieldSet(this, _batch$1, batch);
+          }
+        } else {
+          // Old format.
+          _classPrivateFieldSet(this, _serverSupportsAcks, ackField === true);
+        }
+      }
+      _classPrivateMethodGet$1(this, _debug, _debug2).call(this, "AckExtension: server supports acknowledgements", _classPrivateFieldGet(this, _serverSupportsAcks));
+    } else if (channel === "/meta/connect" && message.successful && _classPrivateFieldGet(this, _serverSupportsAcks)) {
+      if (ext && typeof ext.ack === "number") {
+        _classPrivateFieldSet(this, _batch$1, ext.ack);
+        _classPrivateMethodGet$1(this, _debug, _debug2).call(this, "AckExtension: server sent batch", _classPrivateFieldGet(this, _batch$1));
+      }
+    }
+    return message;
+  }
+  outgoing(message) {
+    const channel = message.channel;
+    if (!message.ext) {
+      message.ext = {};
+    }
+    if (channel === "/meta/handshake") {
+      message.ext.ack = this.cometd && this.cometd.ackEnabled !== false;
+      _classPrivateFieldSet(this, _serverSupportsAcks, false);
+      _classPrivateFieldSet(this, _batch$1, 0);
+    } else if (channel === "/meta/connect") {
+      if (_classPrivateFieldGet(this, _serverSupportsAcks)) {
+        message.ext.ack = _classPrivateFieldGet(this, _batch$1);
+        _classPrivateMethodGet$1(this, _debug, _debug2).call(this, "AckExtension: client sending batch", _classPrivateFieldGet(this, _batch$1));
+      }
+    }
+    return message;
+  }
+}
+function _debug2(text, args) {
+  this.cometd._debug(text, args);
+}
+
+function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { _classCheckPrivateStaticAccess(receiver, classConstructor); _classCheckPrivateStaticFieldDescriptor(descriptor, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classCheckPrivateStaticFieldDescriptor(descriptor, action) { if (descriptor === undefined) { throw new TypeError("attempted to " + action + " private static field before its declaration"); } }
+function _classCheckPrivateStaticAccess(receiver, classConstructor) { if (receiver !== classConstructor) { throw new TypeError("Private static access of wrong provenance"); } }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+/*
+ * Copyright (c) 2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Z85 encoding/decoding as specified by https://rfc.zeromq.org/spec/32/.
+ * Z85 encodes binary data to a string that may be sent as JSON payload,
+ * and decodes strings to binary data.
+ */
+class Z85 {
+  /**
+   * Encodes the given bytes to a string.
+   * @param bytes the bytes to encode, either a number[], or an ArrayBuffer, or a TypedArray.
+   * @return {string} the bytes encoded as a string
+   */
+  static encode(bytes) {
+    let buffer = null;
+    if (bytes instanceof ArrayBuffer) {
+      buffer = bytes;
+    } else if (bytes.buffer instanceof ArrayBuffer) {
+      buffer = bytes.buffer;
+    } else if (Array.isArray(bytes)) {
+      buffer = new Uint8Array(bytes).buffer;
+    }
+    if (buffer == null) {
+      throw new Error("Cannot Z85 encode " + bytes);
+    }
+    const length = buffer.byteLength;
+    const remainder = length % 4;
+    const padding = 4 - (remainder === 0 ? 4 : remainder);
+    const view = new DataView(buffer);
+    let result = "";
+    let value = 0;
+    for (let i = 0; i < length + padding; ++i) {
+      const isPadding = i >= length;
+      value = value * 256 + (isPadding ? 0 : view.getUint8(i));
+      if ((i + 1) % 4 === 0) {
+        let divisor = 85 * 85 * 85 * 85;
+        for (let j = 5; j > 0; --j) {
+          if (!isPadding || j > padding) {
+            const code = Math.floor(value / divisor) % 85;
+            result += _classStaticPrivateFieldSpecGet(Z85, Z85, _z85EncodeTable)[code];
+          }
+          divisor /= 85;
+        }
+        value = 0;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Decodes the given string into an ArrayBuffer.
+   * @param string the string to decode
+   * @return {ArrayBuffer} the decoded bytes
+   */
+  static decode(string) {
+    const remainder = string.length % 5;
+    const padding = 5 - (remainder === 0 ? 5 : remainder);
+    for (let p = 0; p < padding; ++p) {
+      string += _classStaticPrivateFieldSpecGet(Z85, Z85, _z85EncodeTable)[_classStaticPrivateFieldSpecGet(Z85, Z85, _z85EncodeTable).length - 1];
+    }
+    const length = string.length;
+    const buffer = new ArrayBuffer(length * 4 / 5 - padding);
+    const view = new DataView(buffer);
+    let value = 0;
+    let charIdx = 0;
+    let byteIdx = 0;
+    for (let i = 0; i < length; ++i) {
+      const code = string.charCodeAt(charIdx++) - 32;
+      value = value * 85 + _classStaticPrivateFieldSpecGet(Z85, Z85, _z85DecodeTable)[code];
+      if (charIdx % 5 === 0) {
+        let divisor = 256 * 256 * 256;
+        while (divisor >= 1) {
+          if (byteIdx < view.byteLength) {
+            view.setUint8(byteIdx++, Math.floor(value / divisor) % 256);
+          }
+          divisor /= 256;
+        }
+        value = 0;
+      }
+    }
+    return buffer;
+  }
+}
+var _z85EncodeTable = {
+  writable: true,
+  value: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", ".", "-", ":", "+", "=", "^", "!", "/", "*", "?", "&", "<", ">", "(", ")", "[", "]", "{", "}", "@", "%", "$", "#"]
+};
+var _z85DecodeTable = {
+  writable: true,
+  value: [0x00, 0x44, 0x00, 0x54, 0x53, 0x52, 0x48, 0x00, 0x4B, 0x4C, 0x46, 0x41, 0x00, 0x3F, 0x3E, 0x45, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x40, 0x00, 0x49, 0x42, 0x4A, 0x47, 0x51, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x4D, 0x00, 0x4E, 0x43, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x4F, 0x00, 0x50, 0x00, 0x00]
+};
+
+/*
+ * Copyright (c) 2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Client-side extension that converts binary JavaScript objects
+ * (ArrayBuffer, DataView and TypedArrays) into a textual
+ * representation suitable for JSON, using the Z85 algorithm.
+ */
+class BinaryExtension extends Extension {
+  incoming(message) {
+    if (!/^\/meta\//.test(message.channel)) {
+      const ext = message.ext;
+      if (ext) {
+        const binaryExt = ext.binary;
+        if (binaryExt) {
+          message.data.data = Z85.decode(message.data.data);
+        }
+      }
+    }
+    return message;
+  }
+  outgoing(message) {
+    if (!/^\/meta\//.test(message.channel)) {
+      const ext = message.ext;
+      if (ext) {
+        const binaryExt = ext.binary;
+        if (binaryExt) {
+          message.data.data = Z85.encode(message.data.data);
+        }
+      }
+    }
+    return message;
+  }
+}
+
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration$1(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec$1(obj, privateMap, value) { _checkPrivateRedeclaration$1(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration$1(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+/**
+ * The reload extension allows a page to be loaded (or reloaded)
+ * without having to re-handshake in the new (or reloaded) page,
+ * therefore resuming the existing CometD connection.
+ *
+ * When the reload() method is called, the state of the CometD
+ * connection is stored in the window.sessionStorage object.
+ * The reload() method must therefore be called by page unload
+ * handlers, often provided by JavaScript toolkits.
+ *
+ * When the page is (re)loaded, this extension checks the
+ * window.sessionStorage and restores the CometD connection,
+ * maintaining the same CometD clientId.
+ */
+var _state = /*#__PURE__*/new WeakMap();
+var _name = /*#__PURE__*/new WeakMap();
+var _batch = /*#__PURE__*/new WeakMap();
+var _reloading = /*#__PURE__*/new WeakMap();
+var _reload = /*#__PURE__*/new WeakSet();
+var _similarState = /*#__PURE__*/new WeakSet();
+var _onHandshakeReply = /*#__PURE__*/new WeakSet();
+class ReloadExtension extends Extension {
+  constructor(configuration) {
+    super();
+    _classPrivateMethodInitSpec(this, _onHandshakeReply);
+    _classPrivateMethodInitSpec(this, _similarState);
+    _classPrivateMethodInitSpec(this, _reload);
+    _classPrivateFieldInitSpec$1(this, _state, {
+      writable: true,
+      value: {}
+    });
+    _classPrivateFieldInitSpec$1(this, _name, {
+      writable: true,
+      value: "org.cometd.reload"
+    });
+    _classPrivateFieldInitSpec$1(this, _batch, {
+      writable: true,
+      value: false
+    });
+    _classPrivateFieldInitSpec$1(this, _reloading, {
+      writable: true,
+      value: false
+    });
+    this.configure(configuration);
+  }
+  configure(config) {
+    if (config) {
+      if (typeof config.name === "string") {
+        _classPrivateFieldSet(this, _name, config.name);
+      }
+    }
+  }
+  _receive(response) {
+    this.cometd.receive(response);
+  }
+  registered(name, cometd) {
+    super.registered(name, cometd);
+    this.cometd.reload = config => _classPrivateMethodGet(this, _reload, _reload2).call(this, config);
+    this.cometd.addListener("/meta/handshake", m => _classPrivateMethodGet(this, _onHandshakeReply, _onHandshakeReply2).call(this, m));
+  }
+  unregistered() {
+    delete this.cometd.reload;
+    super.unregistered();
+  }
+  outgoing(message) {
+    switch (message.channel) {
+      case "/meta/handshake":
+        {
+          _classPrivateFieldSet(this, _state, {
+            url: this.cometd.getURL()
+          });
+          const state = window.sessionStorage.getItem(_classPrivateFieldGet(this, _name));
+          this.cometd._debug("Reload extension found state", state);
+          // Is there a saved handshake response from a prior load?
+          if (state) {
+            try {
+              const oldState = JSON.parse(state);
+
+              // Remove the state, not needed anymore.
+              window.sessionStorage.removeItem(_classPrivateFieldGet(this, _name));
+              if (oldState.handshakeResponse && _classPrivateMethodGet(this, _similarState, _similarState2).call(this, oldState)) {
+                this.cometd._debug("Reload extension restoring state", oldState);
+
+                // Since we are going to abort this message,
+                // we must save an eventual callback to restore
+                // it when we replay the handshake response.
+                const callback = this.cometd._getCallback(message.id);
+                this.cometd.setTimeout(() => {
+                  this.cometd._debug("Reload extension replaying handshake response", oldState.handshakeResponse);
+                  _classPrivateFieldGet(this, _state).handshakeResponse = oldState.handshakeResponse;
+                  _classPrivateFieldGet(this, _state).transportType = oldState.transportType;
+
+                  // Restore the callback.
+                  this.cometd._putCallback(message.id, callback);
+                  const response = this.cometd._mixin(true, {}, _classPrivateFieldGet(this, _state).handshakeResponse, {
+                    // Keep the response message id the same as the request.
+                    id: message.id,
+                    // Tells applications this is a handshake replayed by the reload extension.
+                    ext: {
+                      reload: true
+                    }
+                  });
+                  // Use the same transport as before.
+                  response.supportedConnectionTypes = [_classPrivateFieldGet(this, _state).transportType];
+                  this._receive(response);
+                  this.cometd._debug("Reload extension replayed handshake response", response);
+                }, 0);
+
+                // Delay any sends until first connect is complete.
+                // This avoids that there is an old /meta/connect pending on server
+                // that will be resumed to send messages to the client, when the
+                // client has already closed the connection, thereby losing the messages.
+                if (!_classPrivateFieldGet(this, _batch)) {
+                  _classPrivateFieldSet(this, _batch, true);
+                  this.cometd.startBatch();
+                }
+
+                // This handshake is aborted, as we will replay the prior handshake response.
+                return null;
+              } else {
+                this.cometd._debug("Reload extension could not restore state", oldState);
+              }
+            } catch (x) {
+              this.cometd._debug("Reload extension error while trying to restore state", x);
+            }
+          }
+          break;
+        }
+      case "/meta/connect":
+        {
+          if (_classPrivateFieldGet(this, _reloading) === true) {
+            // The reload causes the failure of the outstanding /meta/connect,
+            // which CometD will react to by sending another. Here we avoid
+            // that /meta/connect messages are sent between the reload and
+            // the destruction of the JavaScript context, so that we are sure
+            // that the first /meta/connect is the one triggered after the
+            // replay of the /meta/handshake by this extension.
+            this.cometd._debug("Reload extension aborting /meta/connect during reload");
+            return null;
+          }
+          if (!_classPrivateFieldGet(this, _state).transportType) {
+            _classPrivateFieldGet(this, _state).transportType = message.connectionType;
+            this.cometd._debug("Reload extension tracked transport type", _classPrivateFieldGet(this, _state).transportType);
+          }
+          break;
+        }
+      case "/meta/disconnect":
+        {
+          _classPrivateFieldSet(this, _state, {});
+          break;
+        }
+    }
+    return message;
+  }
+  incoming(message) {
+    switch (message.channel) {
+      case "/meta/handshake":
+        {
+          // Only record the handshake response if it's successful.
+          if (message.successful) {
+            // If the handshake response is already present, then we're replaying it.
+            // Since the replay may have modified the handshake response, do not record it again.
+            if (!_classPrivateFieldGet(this, _state).handshakeResponse) {
+              // Save successful handshake response
+              _classPrivateFieldGet(this, _state).handshakeResponse = message;
+              this.cometd._debug("Reload extension tracked handshake response", message);
+            }
+          }
+          break;
+        }
+      case "/meta/connect":
+        {
+          if (_classPrivateFieldGet(this, _batch)) {
+            _classPrivateFieldSet(this, _batch, false);
+            this.cometd.endBatch();
+          }
+          break;
+        }
+      case "/meta/disconnect":
+        {
+          if (_classPrivateFieldGet(this, _batch)) {
+            _classPrivateFieldSet(this, _batch, false);
+            this.cometd.endBatch();
+          }
+          _classPrivateFieldSet(this, _state, {});
+          break;
+        }
+    }
+    return message;
+  }
+}
+function _reload2(config) {
+  if (_classPrivateFieldGet(this, _state).handshakeResponse) {
+    _classPrivateFieldSet(this, _reloading, true);
+    const transport = this.cometd.getTransport();
+    if (transport) {
+      transport.abort();
+    }
+    this.configure(config);
+    const state = JSON.stringify(_classPrivateFieldGet(this, _state));
+    this.cometd._debug("Reload extension saving state", state);
+    window.sessionStorage.setItem(_classPrivateFieldGet(this, _name), state);
+  }
+}
+function _similarState2(oldState) {
+  // We want to check here that the CometD object
+  // did not change much between reloads.
+  // We just check the URL for now, but in future
+  // further checks may involve the transport type
+  // and other configuration parameters.
+  return _classPrivateFieldGet(this, _state).url === oldState.url;
+}
+function _onHandshakeReply2(message) {
+  // Unsuccessful handshakes should
+  // not be saved in case of reloads.
+  if (message.successful !== true) {
+    _classPrivateFieldSet(this, _state, {});
+  }
+}
+
+/*
+ * Copyright (c) 2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The timestamp extension adds the optional timestamp field to all outgoing messages.
+ */
+class TimeStampExtension extends Extension {
+  outgoing(message) {
+    message.timestamp = new Date().toUTCString();
+    return message;
+  }
+}
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+/**
+ * With each handshake or connect, the extension sends timestamps within the
+ * ext field like: <code>{ext:{timesync:{tc:12345567890,l:23,o:4567},...},...}</code>
+ * where:<ul>
+ *  <li>tc is the client timestamp in ms since 1970 of when the message was sent.
+ *  <li>l is the network lag that the client has calculated.
+ *  <li>o is the clock offset that the client has calculated.
+ * </ul>
+ *
+ * <p>
+ * A CometD server that supports timesync, can respond with an ext
+ * field like: <code>{ext:{timesync:{tc:12345567890,ts:1234567900,p:123,a:3},...},...}</code>
+ * where:<ul>
+ *  <li>tc is the client timestamp of when the message was sent,
+ *  <li>ts is the server timestamp of when the message was received
+ *  <li>p is the poll duration in ms - ie the time the server took before sending the response.
+ *  <li>a is the measured accuracy of the calculated offset and lag sent by the client
+ * </ul>
+ *
+ * <p>
+ * The relationship between tc, ts & l is given by <code>ts=tc+o+l</code> (the
+ * time the server received the message is the client time plus the offset plus the
+ * network lag).   Thus the accuracy of the o and l settings can be determined with
+ * <code>a=(tc+o+l)-ts</code>.
+ * </p>
+ * <p>
+ * When the client has received the response, it can make a more accurate estimate
+ * of the lag as <code>l2=(now-tc-p)/2</code> (assuming symmetric lag).
+ * A new offset can then be calculated with the relationship on the client
+ * that <code>ts=tc+o2+l2</code>, thus <code>o2=ts-tc-l2</code>.
+ * </p>
+ * <p>
+ * Since the client also receives the a value calculated on the server, it
+ * should be possible to analyse this and compensate for some asymmetry
+ * in the lag. But the current client does not do this.
+ * </p>
+ */
+var _maxSamples = /*#__PURE__*/new WeakMap();
+var _lags = /*#__PURE__*/new WeakMap();
+var _offsets = /*#__PURE__*/new WeakMap();
+var _lag = /*#__PURE__*/new WeakMap();
+var _offset = /*#__PURE__*/new WeakMap();
+class TimeSyncExtension extends Extension {
+  constructor(configuration) {
+    super();
+    _classPrivateFieldInitSpec(this, _maxSamples, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _lags, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec(this, _offsets, {
+      writable: true,
+      value: []
+    });
+    _classPrivateFieldInitSpec(this, _lag, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldInitSpec(this, _offset, {
+      writable: true,
+      value: 0
+    });
+    _classPrivateFieldSet(this, _maxSamples, configuration && configuration.maxSamples || 10);
+  }
+  registered(name, cometd) {
+    super.registered(name, cometd);
+    this.cometd._debug("TimeSyncExtension: executing registration callback");
+  }
+  unregistered() {
+    this.cometd._debug("TimeSyncExtension: executing unregistration callback");
+    super.unregistered();
+    _classPrivateFieldSet(this, _lags, []);
+    _classPrivateFieldSet(this, _offsets, []);
+    _classPrivateFieldSet(this, _lag, 0);
+    _classPrivateFieldSet(this, _offset, 0);
+  }
+  incoming(message) {
+    const channel = message.channel;
+    if (channel && channel.indexOf("/meta/") === 0) {
+      if (message.ext && message.ext.timesync) {
+        const timesync = message.ext.timesync;
+        this.cometd._debug("TimeSyncExtension: server sent timesync", timesync);
+        const now = new Date().getTime();
+        const l2 = (now - timesync.tc - timesync.p) / 2;
+        const o2 = timesync.ts - timesync.tc - l2;
+        _classPrivateFieldGet(this, _lags).push(l2);
+        _classPrivateFieldGet(this, _offsets).push(o2);
+        if (_classPrivateFieldGet(this, _offsets).length > _classPrivateFieldGet(this, _maxSamples)) {
+          _classPrivateFieldGet(this, _offsets).shift();
+          _classPrivateFieldGet(this, _lags).shift();
+        }
+        const samples = _classPrivateFieldGet(this, _offsets).length;
+        let lagsSum = 0;
+        let offsetsSum = 0;
+        for (let i = 0; i < samples; ++i) {
+          lagsSum += _classPrivateFieldGet(this, _lags)[i];
+          offsetsSum += _classPrivateFieldGet(this, _offsets)[i];
+        }
+        _classPrivateFieldSet(this, _lag, parseInt((lagsSum / samples).toFixed()));
+        _classPrivateFieldSet(this, _offset, parseInt((offsetsSum / samples).toFixed()));
+        this.cometd._debug("TimeSyncExtension: network lag", _classPrivateFieldGet(this, _lag), "ms, time offset with server", _classPrivateFieldGet(this, _offset), "ms");
+      }
+    }
+    return message;
+  }
+  outgoing(message) {
+    const channel = message.channel;
+    if (channel && channel.indexOf("/meta/") === 0) {
+      if (!message.ext) {
+        message.ext = {};
+      }
+      message.ext.timesync = {
+        tc: new Date().getTime(),
+        l: this.getNetworkLag(),
+        o: this.getTimeOffset()
+      };
+      this.cometd._debug("TimeSyncExtension: client sending timesync", message.ext.timesync);
+    }
+    return message;
+  }
+  /**
+   * Get the estimated offset in ms from the clients clock to the
+   * servers clock.  The server time is the client time plus the offset.
+   */
+  getTimeOffset() {
+    return _classPrivateFieldGet(this, _offset);
+  }
+
+  /**
+   * Get the estimated network lag in ms from the client to the server.
+   */
+  getNetworkLag() {
+    return _classPrivateFieldGet(this, _lag);
+  }
+
+  /**
+   * Get the estimated server time in ms since the epoch.
+   */
+  getServerTime() {
+    return new Date().getTime() + this.getTimeOffset();
+  }
+
+  /**
+   * Get the estimated server time as a Date object
+   */
+  getServerDate() {
+    return new Date(this.getServerTime());
+  }
+  /**
+   * Set a timeout to expire at given time on the server.
+   * @param callback The function to call when the timer expires
+   * @param atServerTimeOrDate a js Time or Date object representing the
+   * server time at which the timeout should expire
+   */
+  setTimeout(callback, atServerTimeOrDate) {
+    const ts = atServerTimeOrDate instanceof Date ? atServerTimeOrDate.getTime() : 0 + atServerTimeOrDate;
+    const tc = ts - this.getTimeOffset();
+    let interval = tc - new Date().getTime();
+    if (interval < 0) {
+      interval = 0;
+    }
+    return this.cometd.setTimeout(callback, interval);
+  }
+}
+
+export { AckExtension, BinaryExtension, CallbackPollingTransport, CometD, Extension, LongPollingTransport, ReloadExtension, RequestTransport, TimeStampExtension, TimeSyncExtension, Transport, WebSocketTransport };
+//# sourceMappingURL=cometd-acd4ed9d.js.map