epicenter-libs 3.33.0 → 3.34.1

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

@@ -1,167 +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 _type = /*#__PURE__*/new WeakMap();
-var _cometd = /*#__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(this, _type, void 0);
-    _classPrivateFieldInitSpec(this, _cometd, void 0);
-    _classPrivateFieldInitSpec(this, _url, 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(_type, this, type);
-    _classPrivateFieldSet(_cometd, this, cometd);
-  }
-  /**
-   * Function invoked just after a transport has been successfully unregistered.
-   * @see #registered(type, cometd)
-   */
-  unregistered() {
-    _classPrivateFieldSet(_type, this, null);
-    _classPrivateFieldSet(_cometd, this, null);
-  }
-  get cometd() {
-    return _classPrivateFieldGet(_cometd, this);
-  }
-  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(_type, this);
-  }
-  get url() {
-    return _classPrivateFieldGet(_url, this);
-  }
-  set url(url) {
-    _classPrivateFieldSet(_url, this, 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;
-  }
-}
-
-export { Transport };

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

@@ -1,107 +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 _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 _types = /*#__PURE__*/new WeakMap();
-var _transports = /*#__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(this, _types, []);
-    _classPrivateFieldInitSpec(this, _transports, {});
-  }
-  getTransportTypes() {
-    return _classPrivateFieldGet(_types, this).slice(0);
-  }
-  add(type, transport, index) {
-    let existing = false;
-    for (let i = 0; i < _classPrivateFieldGet(_types, this).length; ++i) {
-      if (_classPrivateFieldGet(_types, this)[i] === type) {
-        existing = true;
-        break;
-      }
-    }
-    if (!existing) {
-      if (typeof index !== "number") {
-        _classPrivateFieldGet(_types, this).push(type);
-      } else {
-        _classPrivateFieldGet(_types, this).splice(index, 0, type);
-      }
-      _classPrivateFieldGet(_transports, this)[type] = transport;
-    }
-    return !existing;
-  }
-  find(type) {
-    for (let i = 0; i < _classPrivateFieldGet(_types, this).length; ++i) {
-      if (_classPrivateFieldGet(_types, this)[i] === type) {
-        return _classPrivateFieldGet(_transports, this)[type];
-      }
-    }
-    return null;
-  }
-  negotiateTransport(types, version, crossDomain, url) {
-    for (let i = 0; i < _classPrivateFieldGet(_types, this).length; ++i) {
-      const type = _classPrivateFieldGet(_types, this)[i];
-      for (let j = 0; j < types.length; ++j) {
-        if (type === types[j]) {
-          const transport = _classPrivateFieldGet(_transports, this)[type];
-          if (transport.accept(version, crossDomain, url) === true) {
-            return transport;
-          }
-        }
-      }
-    }
-    return null;
-  }
-  clear() {
-    _classPrivateFieldSet(_types, this, []);
-    _classPrivateFieldSet(_transports, this, {});
-  }
-  reset(init) {
-    for (let i = 0; i < _classPrivateFieldGet(_types, this).length; ++i) {
-      _classPrivateFieldGet(_transports, this)[_classPrivateFieldGet(_types, this)[i]].reset(init);
-    }
-  }
-  findTransportTypes(version, crossDomain, url) {
-    const result = [];
-    for (let i = 0; i < _classPrivateFieldGet(_types, this).length; ++i) {
-      const type = _classPrivateFieldGet(_types, this)[i];
-      if (_classPrivateFieldGet(_transports, this)[type].accept(version, crossDomain, url) === true) {
-        result.push(type);
-      }
-    }
-    return result;
-  }
-  remove(type) {
-    for (let i = 0; i < _classPrivateFieldGet(_types, this).length; ++i) {
-      if (_classPrivateFieldGet(_types, this)[i] === type) {
-        _classPrivateFieldGet(_types, this).splice(i, 1);
-        const transport = _classPrivateFieldGet(_transports, this)[type];
-        delete _classPrivateFieldGet(_transports, this)[type];
-        return transport;
-      }
-    }
-    return null;
-  }
-}
-
-export { TransportRegistry };

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

@@ -1,384 +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 _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 _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 = /*#__PURE__*/new WeakMap();
-var _successCallback = /*#__PURE__*/new WeakMap();
-var _WebSocketTransport_brand = /*#__PURE__*/new WeakSet();
-class WebSocketTransport extends Transport {
-  constructor(...args) {
-    super(...args);
-    _classPrivateMethodInitSpec(this, _WebSocketTransport_brand);
-    // By default, WebSocket is supported.
-    _classPrivateFieldInitSpec(this, _webSocketSupported, true);
-    // Whether we were able to establish a WebSocket connection.
-    _classPrivateFieldInitSpec(this, _webSocketConnected, false);
-    _classPrivateFieldInitSpec(this, _stickyReconnect, true);
-    // The context contains the envelopes that have been sent
-    // and the timeouts for the messages that have been sent.
-    _classPrivateFieldInitSpec(this, _context, null);
-    _classPrivateFieldInitSpec(this, _connecting, null);
-    _classPrivateFieldInitSpec(this, _connected, false);
-    _classPrivateFieldInitSpec(this, _successCallback, null);
-  }
-  reset(init) {
-    super.reset(init);
-    _classPrivateFieldSet(_webSocketSupported, this, true);
-    if (init) {
-      _classPrivateFieldSet(_webSocketConnected, this, false);
-    }
-    _classPrivateFieldSet(_stickyReconnect, this, true);
-    if (init) {
-      _classPrivateFieldSet(_context, this, null);
-    }
-    _classPrivateFieldSet(_connecting, this, null);
-    _classPrivateFieldSet(_connected, this, 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(_webSocketSupported, this));
-    // Using !! to return a boolean (and not the WebSocket object).
-    return _classPrivateFieldGet(_webSocketSupported, this) && !!window.WebSocket && this.cometd.websocketEnabled !== false;
-  }
-  send(envelope, metaConnect) {
-    this.debug("Transport", this.type, "sending", envelope, "/meta/connect =", metaConnect);
-    _assertClassBrand(_WebSocketTransport_brand, this, _send).call(this, _classPrivateFieldGet(_context, this), envelope, metaConnect);
-  }
-  abort() {
-    super.abort();
-    _assertClassBrand(_WebSocketTransport_brand, this, _forceClose).call(this, _classPrivateFieldGet(_context, this), {
-      code: 1000,
-      reason: "Abort"
-    });
-    this.reset(true);
-  }
-}
-function _forceClose(context, event) {
-  if (context) {
-    _assertClassBrand(_WebSocketTransport_brand, this, _webSocketClose).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.
-    _assertClassBrand(_WebSocketTransport_brand, this, _onClose).call(this, context, event);
-  }
-}
-function _sameContext(context) {
-  return context === _classPrivateFieldGet(_connecting, this) || context === _classPrivateFieldGet(_context, this);
-}
-function _storeEnvelope(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 _removeEnvelope(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 _websocketConnect(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(_connecting, this)) {
-    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(_connecting, this, context);
-  } catch (x) {
-    _classPrivateFieldSet(_webSocketSupported, this, false);
-    this.debug("Exception while creating WebSocket object", x);
-    throw x;
-  }
-
-  // By default use sticky reconnects.
-  _classPrivateFieldSet(_stickyReconnect, this, 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.
-      _assertClassBrand(_WebSocketTransport_brand, this, _forceClose).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 (_assertClassBrand(_WebSocketTransport_brand, this, _sameContext).call(this, context)) {
-      _classPrivateFieldSet(_connecting, this, null);
-      _classPrivateFieldSet(_context, this, context);
-      _classPrivateFieldSet(_webSocketConnected, this, true);
-      _assertClassBrand(_WebSocketTransport_brand, this, _onOpen).call(this, context);
-    } else {
-      // We have a valid connection already, close this one.
-      this.cometd._warn("Closing extra WebSocket connection", this, "active connection", _classPrivateFieldGet(_context, this));
-      _assertClassBrand(_WebSocketTransport_brand, this, _forceClose).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(_connecting, this), "current", _classPrivateFieldGet(_context, this));
-    if (context.connectTimer) {
-      this.clearTimeout(context.connectTimer);
-    }
-    _assertClassBrand(_WebSocketTransport_brand, this, _onClose).call(this, context, event);
-  };
-  const onmessage = wsMessage => {
-    this.debug("Transport", this.type, "onmessage", wsMessage, context);
-    _assertClassBrand(_WebSocketTransport_brand, this, _onMessage).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 _onTransportTimeout(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(() => {
-      _assertClassBrand(_WebSocketTransport_brand, this, _onTransportTimeout).call(this, context, message, delay + result);
-    }, result);
-  } else {
-    this.debug("Transport", this.type, "expired waiting for message reply", message.id, ":", delay, "ms");
-    _assertClassBrand(_WebSocketTransport_brand, this, _forceClose).call(this, context, {
-      code: 1000,
-      reason: "Message Timeout"
-    });
-  }
-}
-function _webSocketSend(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);
-    }
-    _assertClassBrand(_WebSocketTransport_brand, this, _removeEnvelope).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(_connected, this, 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(() => {
-        _assertClassBrand(_WebSocketTransport_brand, this, _onTransportTimeout).call(this, context, message, delay);
-      }, delay);
-    }
-  }
-  this.debug("Transport", this.type, "started waiting for message replies", delay, "ms, messageIds:", messageIds, ", timeouts:", context.timeouts);
-}
-function _send(context, envelope, metaConnect) {
-  try {
-    if (context === null) {
-      context = _classPrivateFieldGet(_connecting, this) || {
-        envelopes: {},
-        timeouts: {}
-      };
-      _assertClassBrand(_WebSocketTransport_brand, this, _storeEnvelope).call(this, context, envelope, metaConnect);
-      _assertClassBrand(_WebSocketTransport_brand, this, _websocketConnect).call(this, context);
-    } else {
-      _assertClassBrand(_WebSocketTransport_brand, this, _storeEnvelope).call(this, context, envelope, metaConnect);
-      _assertClassBrand(_WebSocketTransport_brand, this, _webSocketSend).call(this, context, envelope, metaConnect);
-    }
-  } catch (x) {
-    // Keep the semantic of calling callbacks asynchronously.
-    this.setTimeout(() => {
-      _assertClassBrand(_WebSocketTransport_brand, this, _forceClose).call(this, context, {
-        code: 1000,
-        reason: "Exception",
-        exception: x
-      });
-    }, 0);
-  }
-}
-function _onOpen(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(_successCallback, this, envelope.onSuccess);
-      _assertClassBrand(_WebSocketTransport_brand, this, _webSocketSend).call(this, context, envelope, metaConnect);
-    }
-  }
-}
-function _onMessage(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(_connected, this, false);
-    }
-    if ("/meta/disconnect" === message.channel && !_classPrivateFieldGet(_connected, this)) {
-      close = true;
-    }
-  }
-
-  // Remove the envelope corresponding to the messages.
-  _assertClassBrand(_WebSocketTransport_brand, this, _removeEnvelope).call(this, context, messageIds);
-  this._notifySuccess(_classPrivateFieldGet(_successCallback, this), messages);
-  if (close) {
-    _assertClassBrand(_WebSocketTransport_brand, this, _webSocketClose).call(this, context, 1000, "Disconnect");
-  }
-}
-function _onClose(context, event) {
-  this.debug("Transport", this.type, "closed", context, event);
-  if (_assertClassBrand(_WebSocketTransport_brand, this, _sameContext).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(_webSocketSupported, this, _classPrivateFieldGet(_stickyReconnect, this) && _classPrivateFieldGet(_webSocketConnected, this));
-    _classPrivateFieldSet(_connecting, this, null);
-    _classPrivateFieldSet(_context, this, 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(_connected, this, 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 _webSocketClose(context, code, reason) {
-  try {
-    if (context.webSocket) {
-      context.webSocket.close(code, reason);
-    }
-  } catch (x) {
-    this.debug(x);
-  }
-}
-
-export { WebSocketTransport };

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

@@ -1,9 +0,0 @@
-export { CometD } from './Client.js';
-export { Extension } from './Extension.js';
-export { AckExtension } from './AckExtension.js';
-export { ReloadExtension } from './ReloadExtension.js';
-export { Transport } from './Transport.js';
-export { RequestTransport } from './RequestTransport.js';
-export { CallbackPollingTransport } from './CallbackPollingTransport.js';
-export { LongPollingTransport } from './LongPollingTransport.js';
-export { WebSocketTransport } from './WebSocketTransport.js';