epicenter-libs 3.33.0 → 3.34.1

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

@@ -1,47 +0,0 @@
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-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(this, _cometd, void 0);
-  }
-  registered(name, cometd) {
-    _classPrivateFieldSet(_cometd, this, cometd);
-  }
-  unregistered() {
-    _classPrivateFieldSet(_cometd, this, null);
-  }
-  get cometd() {
-    return _classPrivateFieldGet(_cometd, this);
-  }
-  incoming(message) {
-    return message;
-  }
-  outgoing(message) {
-    return message;
-  }
-}
-
-export { Extension };

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

@@ -1,135 +0,0 @@
-import { RequestTransport } from './RequestTransport.js';
-
-function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-var _supportsCrossDomain = /*#__PURE__*/new WeakMap();
-var _LongPollingTransport_brand = /*#__PURE__*/new WeakSet();
-class LongPollingTransport extends RequestTransport {
-  constructor(...args) {
-    super(...args);
-    _classPrivateMethodInitSpec(this, _LongPollingTransport_brand);
-    // By default, support cross domain.
-    _classPrivateFieldInitSpec(this, _supportsCrossDomain, true);
-  }
-  accept(version, crossDomain, url) {
-    return _classPrivateFieldGet(_supportsCrossDomain, this) || !crossDomain;
-  }
-  xhrSend(packet) {
-    const xhr = _assertClassBrand(_LongPollingTransport_brand, this, _newXMLHttpRequest).call(this);
-    _assertClassBrand(_LongPollingTransport_brand, this, _copyContext).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(_supportsCrossDomain, this, false);
-              this.transportFailure(envelope, request, {
-                httpCode: 204
-              });
-            } else {
-              success = true;
-              this.transportSuccess(envelope, request, received);
-            }
-          } catch (x) {
-            this.debug(x);
-            if (!success) {
-              _classPrivateFieldSet(_supportsCrossDomain, this, 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(_supportsCrossDomain, this, 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(_supportsCrossDomain, this, 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(_supportsCrossDomain, this, true);
-  }
-}
-function _newXMLHttpRequest() {
-  return new window.XMLHttpRequest();
-}
-function _copyContext(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);
-  }
-}
-
-export { LongPollingTransport };

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

@@ -1,214 +0,0 @@
-import { Extension } from './Extension.js';
-
-function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-
-/**
- * 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 _ReloadExtension_brand = /*#__PURE__*/new WeakSet();
-class ReloadExtension extends Extension {
-  constructor(configuration) {
-    super();
-    _classPrivateMethodInitSpec(this, _ReloadExtension_brand);
-    _classPrivateFieldInitSpec(this, _state, {});
-    _classPrivateFieldInitSpec(this, _name, "org.cometd.reload");
-    _classPrivateFieldInitSpec(this, _batch, false);
-    _classPrivateFieldInitSpec(this, _reloading, false);
-    this.configure(configuration);
-  }
-  configure(config) {
-    if (config) {
-      if (typeof config.name === "string") {
-        _classPrivateFieldSet(_name, this, config.name);
-      }
-    }
-  }
-  _receive(response) {
-    this.cometd.receive(response);
-  }
-  registered(name, cometd) {
-    super.registered(name, cometd);
-    this.cometd.reload = config => _assertClassBrand(_ReloadExtension_brand, this, _reload).call(this, config);
-    this.cometd.addListener("/meta/handshake", m => _assertClassBrand(_ReloadExtension_brand, this, _onHandshakeReply).call(this, m));
-  }
-  unregistered() {
-    delete this.cometd.reload;
-    super.unregistered();
-  }
-  outgoing(message) {
-    switch (message.channel) {
-      case "/meta/handshake":
-        {
-          _classPrivateFieldSet(_state, this, {
-            url: this.cometd.getURL()
-          });
-          const state = window.sessionStorage.getItem(_classPrivateFieldGet(_name, this));
-          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(_name, this));
-              if (oldState.handshakeResponse && _assertClassBrand(_ReloadExtension_brand, this, _similarState).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(_state, this).handshakeResponse = oldState.handshakeResponse;
-                  _classPrivateFieldGet(_state, this).transportType = oldState.transportType;
-
-                  // Restore the callback.
-                  this.cometd._putCallback(message.id, callback);
-                  const response = this.cometd._mixin(true, {}, _classPrivateFieldGet(_state, this).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(_state, this).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(_batch, this)) {
-                  _classPrivateFieldSet(_batch, this, 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(_reloading, this) === 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(_state, this).transportType) {
-            _classPrivateFieldGet(_state, this).transportType = message.connectionType;
-            this.cometd._debug("Reload extension tracked transport type", _classPrivateFieldGet(_state, this).transportType);
-          }
-          break;
-        }
-      case "/meta/disconnect":
-        {
-          _classPrivateFieldSet(_state, this, {});
-          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(_state, this).handshakeResponse) {
-              // Save successful handshake response
-              _classPrivateFieldGet(_state, this).handshakeResponse = message;
-              this.cometd._debug("Reload extension tracked handshake response", message);
-            }
-          }
-          break;
-        }
-      case "/meta/connect":
-        {
-          if (_classPrivateFieldGet(_batch, this)) {
-            _classPrivateFieldSet(_batch, this, false);
-            this.cometd.endBatch();
-          }
-          break;
-        }
-      case "/meta/disconnect":
-        {
-          if (_classPrivateFieldGet(_batch, this)) {
-            _classPrivateFieldSet(_batch, this, false);
-            this.cometd.endBatch();
-          }
-          _classPrivateFieldSet(_state, this, {});
-          break;
-        }
-    }
-    return message;
-  }
-}
-function _reload(config) {
-  if (_classPrivateFieldGet(_state, this).handshakeResponse) {
-    _classPrivateFieldSet(_reloading, this, true);
-    const transport = this.cometd.getTransport();
-    if (transport) {
-      transport.abort();
-    }
-    this.configure(config);
-    const state = JSON.stringify(_classPrivateFieldGet(_state, this));
-    this.cometd._debug("Reload extension saving state", state);
-    window.sessionStorage.setItem(_classPrivateFieldGet(_name, this), state);
-  }
-}
-function _similarState(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(_state, this).url === oldState.url;
-}
-function _onHandshakeReply(message) {
-  // Unsuccessful handshakes should
-  // not be saved in case of reloads.
-  if (message.successful !== true) {
-    _classPrivateFieldSet(_state, this, {});
-  }
-}
-
-export { ReloadExtension };

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

@@ -1,252 +0,0 @@
-import { Transport } from './Transport.js';
-
-function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
-function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
-function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
-
-/**
- * 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 _RequestTransport_brand = /*#__PURE__*/new WeakSet();
-class RequestTransport extends Transport {
-  constructor(...args) {
-    super(...args);
-    _classPrivateMethodInitSpec(this, _RequestTransport_brand);
-    _classPrivateFieldInitSpec(this, _requestIds, 0);
-    _classPrivateFieldInitSpec(this, _metaConnectRequest, null);
-    _classPrivateFieldInitSpec(this, _requests, []);
-    _classPrivateFieldInitSpec(this, _envelopes, []);
-  }
-  complete(request, success, metaConnect) {
-    if (metaConnect) {
-      _assertClassBrand(_RequestTransport_brand, this, _metaConnectComplete).call(this, request);
-    } else {
-      _assertClassBrand(_RequestTransport_brand, this, _complete).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) {
-      _assertClassBrand(_RequestTransport_brand, this, _metaConnectSend).call(this, envelope);
-    } else {
-      _assertClassBrand(_RequestTransport_brand, this, _queueSend).call(this, envelope);
-    }
-  }
-  abort() {
-    super.abort();
-    for (let i = 0; i < _classPrivateFieldGet(_requests, this).length; ++i) {
-      const request = _classPrivateFieldGet(_requests, this)[i];
-      if (request) {
-        this.debug("Aborting request", request);
-        if (!this.abortXHR(request.xhr)) {
-          this.transportFailure(request.envelope, request, {
-            reason: "abort"
-          });
-        }
-      }
-    }
-    const metaConnectRequest = _classPrivateFieldGet(_metaConnectRequest, this);
-    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(_metaConnectRequest, this, null);
-    _classPrivateFieldSet(_requests, this, []);
-    _classPrivateFieldSet(_envelopes, this, []);
-  }
-  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 _coalesceEnvelopes(envelope) {
-  while (_classPrivateFieldGet(_envelopes, this).length > 0) {
-    const envelopeAndRequest = _classPrivateFieldGet(_envelopes, this)[0];
-    const newEnvelope = envelopeAndRequest[0];
-    const newRequest = envelopeAndRequest[1];
-    if (newEnvelope.url === envelope.url && newEnvelope.sync === envelope.sync) {
-      _classPrivateFieldGet(_envelopes, this).shift();
-      envelope.messages = envelope.messages.concat(newEnvelope.messages);
-      this.debug("Coalesced", newEnvelope.messages.length, "messages from request", newRequest.id);
-      continue;
-    }
-    break;
-  }
-}
-function _onTransportTimeout(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(() => {
-      _assertClassBrand(_RequestTransport_brand, this, _onTransportTimeout).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 _transportSend(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(() => {
-        _assertClassBrand(_RequestTransport_brand, this, _onTransportTimeout).call(this, envelope, request, delay);
-      }, delay);
-    }
-  }
-}
-function _queueSend(envelope) {
-  var _this$requestIds;
-  const requestId = _classPrivateFieldSet(_requestIds, this, (_this$requestIds = _classPrivateFieldGet(_requestIds, this), ++_this$requestIds));
-  const request = {
-    id: requestId,
-    metaConnect: false,
-    envelope: envelope
-  };
-
-  // Consider the /meta/connect requests which should always be present.
-  if (_classPrivateFieldGet(_requests, this).length < this.configuration.maxConnections - 1) {
-    _classPrivateFieldGet(_requests, this).push(request);
-    _assertClassBrand(_RequestTransport_brand, this, _transportSend).call(this, envelope, request);
-  } else {
-    this.debug("Transport", this.type, "queueing request", requestId, "envelope", envelope);
-    _classPrivateFieldGet(_envelopes, this).push([envelope, request]);
-  }
-}
-function _metaConnectComplete(request) {
-  const requestId = request.id;
-  this.debug("Transport", this.type, "/meta/connect complete, request", requestId);
-  if (_classPrivateFieldGet(_metaConnectRequest, this) !== null && _classPrivateFieldGet(_metaConnectRequest, this).id !== requestId) {
-    throw new Error("/meta/connect request mismatch, completing request " + requestId);
-  }
-  _classPrivateFieldSet(_metaConnectRequest, this, null);
-}
-function _complete(request, success) {
-  const index = _classPrivateFieldGet(_requests, this).indexOf(request);
-  // The index can be negative if the request has been aborted
-  if (index >= 0) {
-    _classPrivateFieldGet(_requests, this).splice(index, 1);
-  }
-  if (_classPrivateFieldGet(_envelopes, this).length > 0) {
-    const envelopeAndRequest = _classPrivateFieldGet(_envelopes, this).shift();
-    const nextEnvelope = envelopeAndRequest[0];
-    const nextRequest = envelopeAndRequest[1];
-    this.debug("Transport dequeued request", nextRequest.id);
-    if (success) {
-      if (this.configuration.autoBatch) {
-        _assertClassBrand(_RequestTransport_brand, this, _coalesceEnvelopes).call(this, nextEnvelope);
-      }
-      _assertClassBrand(_RequestTransport_brand, this, _queueSend).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 _metaConnectSend(envelope) {
-  var _this$requestIds2;
-  if (_classPrivateFieldGet(_metaConnectRequest, this) !== null) {
-    throw new Error("Concurrent /meta/connect requests not allowed, request id=" + _classPrivateFieldGet(_metaConnectRequest, this).id + " not yet completed");
-  }
-  const requestId = _classPrivateFieldSet(_requestIds, this, (_this$requestIds2 = _classPrivateFieldGet(_requestIds, this), ++_this$requestIds2));
-  this.debug("Transport", this.type, "/meta/connect send, request", requestId, "envelope", envelope);
-  const request = {
-    id: requestId,
-    metaConnect: true,
-    envelope: envelope
-  };
-  _assertClassBrand(_RequestTransport_brand, this, _transportSend).call(this, envelope, request);
-  _classPrivateFieldSet(_metaConnectRequest, this, request);
-}
-
-export { RequestTransport };