@stomp/stompjs 6.0.0-beta1 → 6.1.0

package/bundles/stomp.umd.js

@@ -96,16 +96,55 @@ return /******/ (function(modules) { // webpackBootstrap
 /************************************************************************/
 /******/ ({
 
+/***/ "./src/augment-websocket.ts":
+/*!**********************************!*\
+  !*** ./src/augment-websocket.ts ***!
+  \**********************************/
+/*! exports provided: augmentWebsocket */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "augmentWebsocket", function() { return augmentWebsocket; });
+/**
+ * @internal
+ */
+function augmentWebsocket(webSocket, debug) {
+    webSocket.terminate = function () {
+        const noOp = () => { };
+        // set all callbacks to no op
+        this.onerror = noOp;
+        this.onmessage = noOp;
+        this.onopen = noOp;
+        const ts = new Date();
+        const origOnClose = this.onclose;
+        // Track delay in actual closure of the socket
+        this.onclose = closeEvent => {
+            const delay = new Date().getTime() - ts.getTime();
+            debug(`Discarded socket closed after ${delay}ms, with code/reason: ${closeEvent.code}/${closeEvent.reason}`);
+        };
+        this.close();
+        origOnClose.call(this, {
+            code: 4001,
+            reason: 'Heartbeat failure, discarding the socket',
+            wasClean: false,
+        });
+    };
+}
+
+
+/***/ }),
+
 /***/ "./src/byte.ts":
 /*!*********************!*\
   !*** ./src/byte.ts ***!
   \*********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: BYTE */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BYTE", function() { return BYTE; });
 /**
  * Some byte values, used as per STOMP specifications.
  *
@@ -113,11 +152,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *
  * @internal
  */
-exports.BYTE = {
+const BYTE = {
     // LINEFEED byte (octet 10)
     LF: '\x0A',
     // NULL byte (octet 0)
-    NULL: '\x00'
+    NULL: '\x00',
 };
 
 
@@ -127,12 +166,16 @@ exports.BYTE = {
 /*!***********************!*\
   !*** ./src/client.ts ***!
   \***********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: Client */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Client", function() { return Client; });
+/* harmony import */ var _stomp_handler__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./stomp-handler */ "./src/stomp-handler.ts");
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./types */ "./src/types.ts");
+/* harmony import */ var _versions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./versions */ "./src/versions.ts");
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -141,48 +184,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var stomp_handler_1 = __webpack_require__(/*! ./stomp-handler */ "./src/stomp-handler.ts");
-var types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
-var versions_1 = __webpack_require__(/*! ./versions */ "./src/versions.ts");
+
+
+
 /**
  * STOMP Client Class.
  *
  * Part of `@stomp/stompjs`.
  */
-var Client = /** @class */ (function () {
+class Client {
     /**
      * Create an instance.
      */
-    function Client(conf) {
-        if (conf === void 0) { conf = {}; }
+    constructor(conf = {}) {
         /**
          * STOMP versions to attempt during STOMP handshake. By default versions `1.0`, `1.1`, and `1.2` are attempted.
          *
@@ -192,7 +206,12 @@ var Client = /** @class */ (function () {
          *        client.stompVersions = new Versions(['1.0', '1.1'])
          * ```
          */
-        this.stompVersions = versions_1.Versions.default;
+        this.stompVersions = _versions__WEBPACK_IMPORTED_MODULE_2__["Versions"].default;
+        /**
+         * Will retry if Stomp connection is not established in specified milliseconds.
+         * Default 0, which implies wait for ever.
+         */
+        this.connectionTimeout = 0;
         /**
          *  automatically reconnect with delay in milliseconds, set to 0 to disable.
          */
@@ -244,9 +263,15 @@ var Client = /** @class */ (function () {
          * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library.
          */
         this.appendMissingNULLonIncoming = false;
-        this._active = false;
+        /**
+         * Activation state.
+         *
+         * It will usually be ACTIVE or INACTIVE.
+         * When deactivating it may go from ACTIVE to INACTIVE without entering DEACTIVATING.
+         */
+        this.state = _types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].INACTIVE;
         // Dummy callbacks
-        var noOp = function () { };
+        const noOp = () => { };
         this.debug = noOp;
         this.beforeConnect = noOp;
         this.onConnect = noOp;
@@ -258,75 +283,60 @@ var Client = /** @class */ (function () {
         this.onWebSocketClose = noOp;
         this.onWebSocketError = noOp;
         this.logRawCommunication = false;
+        this.onChangeState = noOp;
         // These parameters would typically get proper values before connect is called
         this.connectHeaders = {};
         this._disconnectHeaders = {};
         // Apply configuration
         this.configure(conf);
     }
-    Object.defineProperty(Client.prototype, "webSocket", {
-        /**
-         * Underlying WebSocket instance, READONLY.
-         */
-        get: function () {
-            return this._webSocket;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Client.prototype, "disconnectHeaders", {
-        /**
-         * Disconnection headers.
-         */
-        get: function () {
-            return this._disconnectHeaders;
-        },
-        set: function (value) {
-            this._disconnectHeaders = value;
-            if (this._stompHandler) {
-                this._stompHandler.disconnectHeaders = this._disconnectHeaders;
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Client.prototype, "connected", {
-        /**
-         * `true` if there is a active connection with STOMP Broker
-         */
-        get: function () {
-            return (!!this._stompHandler) && this._stompHandler.connected;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Client.prototype, "connectedVersion", {
-        /**
-         * version of STOMP protocol negotiated with the server, READONLY
-         */
-        get: function () {
-            return this._stompHandler ? this._stompHandler.connectedVersion : undefined;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Client.prototype, "active", {
-        /**
-         * if the client is active (connected or going to reconnect)
-         */
-        get: function () {
-            return this._active;
-        },
-        enumerable: true,
-        configurable: true
-    });
+    /**
+     * Underlying WebSocket instance, READONLY.
+     */
+    get webSocket() {
+        return this._stompHandler ? this._stompHandler._webSocket : undefined;
+    }
+    /**
+     * Disconnection headers.
+     */
+    get disconnectHeaders() {
+        return this._disconnectHeaders;
+    }
+    set disconnectHeaders(value) {
+        this._disconnectHeaders = value;
+        if (this._stompHandler) {
+            this._stompHandler.disconnectHeaders = this._disconnectHeaders;
+        }
+    }
+    /**
+     * `true` if there is a active connection with STOMP Broker
+     */
+    get connected() {
+        return !!this._stompHandler && this._stompHandler.connected;
+    }
+    /**
+     * version of STOMP protocol negotiated with the server, READONLY
+     */
+    get connectedVersion() {
+        return this._stompHandler ? this._stompHandler.connectedVersion : undefined;
+    }
+    /**
+     * if the client is active (connected or going to reconnect)
+     */
+    get active() {
+        return this.state === _types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].ACTIVE;
+    }
+    _changeState(state) {
+        this.state = state;
+        this.onChangeState(state);
+    }
     /**
      * Update configuration.
      */
-    Client.prototype.configure = function (conf) {
+    configure(conf) {
         // bulk assign all properties to this
         Object.assign(this, conf);
-    };
+    }
     /**
      * Initiate the connection with the broker.
      * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay},
@@ -334,86 +344,106 @@ var Client = /** @class */ (function () {
      *
      * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts.
      */
-    Client.prototype.activate = function () {
-        this._active = true;
+    activate() {
+        if (this.state === _types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].DEACTIVATING) {
+            this.debug('Still DEACTIVATING, please await call to deactivate before trying to re-activate');
+            throw new Error('Still DEACTIVATING, can not activate now');
+        }
+        if (this.active) {
+            this.debug('Already ACTIVE, ignoring request to activate');
+            return;
+        }
+        this._changeState(_types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].ACTIVE);
         this._connect();
-    };
-    Client.prototype._connect = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.connected) {
-                            this.debug('STOMP: already connected, nothing to do');
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.beforeConnect()];
-                    case 1:
-                        _a.sent();
-                        if (!this._active) {
-                            this.debug('Client has been marked inactive, will not attempt to connect');
-                            return [2 /*return*/];
-                        }
-                        this.debug('Opening Web Socket...');
-                        // Get the actual WebSocket (or a similar object)
-                        this._webSocket = this._createWebSocket();
-                        this._stompHandler = new stomp_handler_1.StompHandler(this, this._webSocket, {
-                            debug: this.debug,
-                            stompVersions: this.stompVersions,
-                            connectHeaders: this.connectHeaders,
-                            disconnectHeaders: this._disconnectHeaders,
-                            heartbeatIncoming: this.heartbeatIncoming,
-                            heartbeatOutgoing: this.heartbeatOutgoing,
-                            splitLargeFrames: this.splitLargeFrames,
-                            maxWebSocketChunkSize: this.maxWebSocketChunkSize,
-                            forceBinaryWSFrames: this.forceBinaryWSFrames,
-                            logRawCommunication: this.logRawCommunication,
-                            appendMissingNULLonIncoming: this.appendMissingNULLonIncoming,
-                            discardWebsocketOnCommFailure: this.discardWebsocketOnCommFailure,
-                            onConnect: function (frame) {
-                                if (!_this._active) {
-                                    _this.debug('STOMP got connected while deactivate was issued, will disconnect now');
-                                    _this._disposeStompHandler();
-                                    return;
-                                }
-                                _this.onConnect(frame);
-                            },
-                            onDisconnect: function (frame) {
-                                _this.onDisconnect(frame);
-                            },
-                            onStompError: function (frame) {
-                                _this.onStompError(frame);
-                            },
-                            onWebSocketClose: function (evt) {
-                                _this.onWebSocketClose(evt);
-                                // The callback is called before attempting to reconnect, this would allow the client
-                                // to be `deactivated` in the callback.
-                                if (_this._active) {
-                                    _this._schedule_reconnect();
-                                }
-                            },
-                            onWebSocketError: function (evt) {
-                                _this.onWebSocketError(evt);
-                            },
-                            onUnhandledMessage: function (message) {
-                                _this.onUnhandledMessage(message);
-                            },
-                            onUnhandledReceipt: function (frame) {
-                                _this.onUnhandledReceipt(frame);
-                            },
-                            onUnhandledFrame: function (frame) {
-                                _this.onUnhandledFrame(frame);
-                            }
-                        });
-                        this._stompHandler.start();
-                        return [2 /*return*/];
-                }
+    }
+    _connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connected) {
+                this.debug('STOMP: already connected, nothing to do');
+                return;
+            }
+            yield this.beforeConnect();
+            if (!this.active) {
+                this.debug('Client has been marked inactive, will not attempt to connect');
+                return;
+            }
+            // setup connection watcher
+            if (this.connectionTimeout > 0) {
+                this._connectionWatcher = setTimeout(() => {
+                    // Connection not established, close the underlying socket
+                    // a reconnection will be attempted
+                    this.debug(`Connection not established in ${this.connectionTimeout}ms, closing socket`);
+                    this.forceDisconnect();
+                }, this.connectionTimeout);
+            }
+            this.debug('Opening Web Socket...');
+            // Get the actual WebSocket (or a similar object)
+            const webSocket = this._createWebSocket();
+            this._stompHandler = new _stomp_handler__WEBPACK_IMPORTED_MODULE_0__["StompHandler"](this, webSocket, {
+                debug: this.debug,
+                stompVersions: this.stompVersions,
+                connectHeaders: this.connectHeaders,
+                disconnectHeaders: this._disconnectHeaders,
+                heartbeatIncoming: this.heartbeatIncoming,
+                heartbeatOutgoing: this.heartbeatOutgoing,
+                splitLargeFrames: this.splitLargeFrames,
+                maxWebSocketChunkSize: this.maxWebSocketChunkSize,
+                forceBinaryWSFrames: this.forceBinaryWSFrames,
+                logRawCommunication: this.logRawCommunication,
+                appendMissingNULLonIncoming: this.appendMissingNULLonIncoming,
+                discardWebsocketOnCommFailure: this.discardWebsocketOnCommFailure,
+                onConnect: frame => {
+                    // Successfully connected, stop the connection watcher
+                    if (this._connectionWatcher) {
+                        clearTimeout(this._connectionWatcher);
+                        this._connectionWatcher = undefined;
+                    }
+                    if (!this.active) {
+                        this.debug('STOMP got connected while deactivate was issued, will disconnect now');
+                        this._disposeStompHandler();
+                        return;
+                    }
+                    this.onConnect(frame);
+                },
+                onDisconnect: frame => {
+                    this.onDisconnect(frame);
+                },
+                onStompError: frame => {
+                    this.onStompError(frame);
+                },
+                onWebSocketClose: evt => {
+                    this._stompHandler = undefined; // a new one will be created in case of a reconnect
+                    if (this.state === _types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].DEACTIVATING) {
+                        // Mark deactivation complete
+                        this._resolveSocketClose();
+                        this._resolveSocketClose = undefined;
+                        this._changeState(_types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].INACTIVE);
+                    }
+                    this.onWebSocketClose(evt);
+                    // The callback is called before attempting to reconnect, this would allow the client
+                    // to be `deactivated` in the callback.
+                    if (this.active) {
+                        this._schedule_reconnect();
+                    }
+                },
+                onWebSocketError: evt => {
+                    this.onWebSocketError(evt);
+                },
+                onUnhandledMessage: message => {
+                    this.onUnhandledMessage(message);
+                },
+                onUnhandledReceipt: frame => {
+                    this.onUnhandledReceipt(frame);
+                },
+                onUnhandledFrame: frame => {
+                    this.onUnhandledFrame(frame);
+                },
             });
+            this._stompHandler.start();
         });
-    };
-    Client.prototype._createWebSocket = function () {
-        var webSocket;
+    }
+    _createWebSocket() {
+        let webSocket;
         if (this.webSocketFactory) {
             webSocket = this.webSocketFactory();
         }
@@ -422,52 +452,70 @@ var Client = /** @class */ (function () {
         }
         webSocket.binaryType = 'arraybuffer';
         return webSocket;
-    };
-    Client.prototype._schedule_reconnect = function () {
-        var _this = this;
+    }
+    _schedule_reconnect() {
         if (this.reconnectDelay > 0) {
-            this.debug("STOMP: scheduling reconnection in " + this.reconnectDelay + "ms");
-            this._reconnector = setTimeout(function () {
-                _this._connect();
+            this.debug(`STOMP: scheduling reconnection in ${this.reconnectDelay}ms`);
+            this._reconnector = setTimeout(() => {
+                this._connect();
             }, this.reconnectDelay);
         }
-    };
+    }
     /**
      * Disconnect if connected and stop auto reconnect loop.
      * Appropriate callbacks will be invoked if underlying STOMP connection was connected.
      *
+     * This call is async, it will resolve immediately if there is no underlying active websocket,
+     * otherwise, it will resolve after underlying websocket is properly disposed.
+     *
      * To reactivate you can call [Client#activate]{@link Client#activate}.
      */
-    Client.prototype.deactivate = function () {
-        // indicate that auto reconnect loop should terminate
-        this._active = false;
-        // Clear if a reconnection was scheduled
-        if (this._reconnector) {
-            clearTimeout(this._reconnector);
-        }
-        this._disposeStompHandler();
-    };
+    deactivate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retPromise;
+            if (this.state !== _types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].ACTIVE) {
+                this.debug(`Already ${_types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"][this.state]}, ignoring call to deactivate`);
+                return Promise.resolve();
+            }
+            this._changeState(_types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].DEACTIVATING);
+            // Clear if a reconnection was scheduled
+            if (this._reconnector) {
+                clearTimeout(this._reconnector);
+            }
+            if (this._stompHandler &&
+                this.webSocket.readyState !== _types__WEBPACK_IMPORTED_MODULE_1__["StompSocketState"].CLOSED) {
+                // we need to wait for underlying websocket to close
+                retPromise = new Promise((resolve, reject) => {
+                    this._resolveSocketClose = resolve;
+                });
+            }
+            else {
+                // indicate that auto reconnect loop should terminate
+                this._changeState(_types__WEBPACK_IMPORTED_MODULE_1__["ActivationState"].INACTIVE);
+                return Promise.resolve();
+            }
+            this._disposeStompHandler();
+            return retPromise;
+        });
+    }
     /**
      * Force disconnect if there is an active connection by directly closing the underlying WebSocket.
      * This is different than a normal disconnect where a DISCONNECT sequence is carried out with the broker.
      * After forcing disconnect, automatic reconnect will be attempted.
      * To stop further reconnects call [Client#deactivate]{@link Client#deactivate} as well.
      */
-    Client.prototype.forceDisconnect = function () {
-        if (this._webSocket) {
-            if (this._webSocket.readyState === types_1.StompSocketState.CONNECTING
-                || this._webSocket.readyState === types_1.StompSocketState.OPEN) {
-                this._stompHandler._closeWebsocket();
-            }
+    forceDisconnect() {
+        if (this._stompHandler) {
+            this._stompHandler.forceDisconnect();
         }
-    };
-    Client.prototype._disposeStompHandler = function () {
+    }
+    _disposeStompHandler() {
         // Dispose STOMP Handler
         if (this._stompHandler) {
             this._stompHandler.dispose();
             this._stompHandler = null;
         }
-    };
+    }
     /**
      * Send a message to a named destination. Refer to your STOMP broker documentation for types
      * and naming of destinations.
@@ -504,9 +552,9 @@ var Client = /** @class */ (function () {
      *                         headers: {'content-type': 'application/octet-stream'}});
      * ```
      */
-    Client.prototype.publish = function (params) {
+    publish(params) {
         this._stompHandler.publish(params);
-    };
+    }
     /**
      * STOMP brokers may carry out operation asynchronously and allow requesting for acknowledgement.
      * To request an acknowledgement, a `receipt` header needs to be sent with the actual request.
@@ -542,9 +590,9 @@ var Client = /** @class */ (function () {
      *        client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg});
      * ```
      */
-    Client.prototype.watchForReceipt = function (receiptId, callback) {
+    watchForReceipt(receiptId, callback) {
         this._stompHandler.watchForReceipt(receiptId, callback);
-    };
+    }
     /**
      * Subscribe to a STOMP Broker location. The callback will be invoked for each received message with
      * the {@link IMessage} as argument.
@@ -569,10 +617,9 @@ var Client = /** @class */ (function () {
      *        var subscription = client.subscribe(destination, callback, { id: mySubId });
      * ```
      */
-    Client.prototype.subscribe = function (destination, callback, headers) {
-        if (headers === void 0) { headers = {}; }
+    subscribe(destination, callback, headers = {}) {
         return this._stompHandler.subscribe(destination, callback, headers);
-    };
+    }
     /**
      * It is preferable to unsubscribe from a subscription by calling
      * `unsubscribe()` directly on {@link StompSubscription} returned by `client.subscribe()`:
@@ -585,19 +632,18 @@ var Client = /** @class */ (function () {
      *
      * See: http://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame
      */
-    Client.prototype.unsubscribe = function (id, headers) {
-        if (headers === void 0) { headers = {}; }
+    unsubscribe(id, headers = {}) {
         this._stompHandler.unsubscribe(id, headers);
-    };
+    }
     /**
      * Start a transaction, the returned {@link ITransaction} has methods - [commit]{@link ITransaction#commit}
      * and [abort]{@link ITransaction#abort}.
      *
      * `transactionId` is optional, if not passed the library will generate it internally.
      */
-    Client.prototype.begin = function (transactionId) {
+    begin(transactionId) {
         return this._stompHandler.begin(transactionId);
-    };
+    }
     /**
      * Commit a transaction.
      *
@@ -610,9 +656,9 @@ var Client = /** @class */ (function () {
      *        tx.commit();
      * ```
      */
-    Client.prototype.commit = function (transactionId) {
+    commit(transactionId) {
         this._stompHandler.commit(transactionId);
-    };
+    }
     /**
      * Abort a transaction.
      * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on
@@ -624,9 +670,9 @@ var Client = /** @class */ (function () {
      *        tx.abort();
      * ```
      */
-    Client.prototype.abort = function (transactionId) {
+    abort(transactionId) {
         this._stompHandler.abort(transactionId);
-    };
+    }
     /**
      * ACK a message. It is preferable to acknowledge a message by calling [ack]{@link IMessage#ack} directly
      * on the {@link IMessage} handled by a subscription callback:
@@ -640,10 +686,9 @@ var Client = /** @class */ (function () {
      *        client.subscribe(destination, callback, {'ack': 'client'});
      * ```
      */
-    Client.prototype.ack = function (messageId, subscriptionId, headers) {
-        if (headers === void 0) { headers = {}; }
+    ack(messageId, subscriptionId, headers = {}) {
         this._stompHandler.ack(messageId, subscriptionId, headers);
-    };
+    }
     /**
      * NACK a message. It is preferable to acknowledge a message by calling [nack]{@link IMessage#nack} directly
      * on the {@link IMessage} handled by a subscription callback:
@@ -657,13 +702,10 @@ var Client = /** @class */ (function () {
      *        client.subscribe(destination, callback, {'ack': 'client'});
      * ```
      */
-    Client.prototype.nack = function (messageId, subscriptionId, headers) {
-        if (headers === void 0) { headers = {}; }
+    nack(messageId, subscriptionId, headers = {}) {
         this._stompHandler.nack(messageId, subscriptionId, headers);
-    };
-    return Client;
-}());
-exports.Client = Client;
+    }
+}
 
 
 /***/ }),
@@ -672,27 +714,16 @@ exports.Client = Client;
 /*!********************************************!*\
   !*** ./src/compatibility/compat-client.ts ***!
   \********************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: CompatClient */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CompatClient", function() { return CompatClient; });
+/* harmony import */ var _client__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../client */ "./src/client.ts");
+/* harmony import */ var _heartbeat_info__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./heartbeat-info */ "./src/compatibility/heartbeat-info.ts");
+
 
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-var client_1 = __webpack_require__(/*! ../client */ "./src/client.ts");
-var heartbeat_info_1 = __webpack_require__(/*! ./heartbeat-info */ "./src/compatibility/heartbeat-info.ts");
 /**
  * Available for backward compatibility, please shift to using {@link Client}.
  *
@@ -702,8 +733,7 @@ var heartbeat_info_1 = __webpack_require__(/*! ./heartbeat-info */ "./src/compat
  *
  * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
  */
-var CompatClient = /** @class */ (function (_super) {
-    __extends(CompatClient, _super);
+class CompatClient extends _client__WEBPACK_IMPORTED_MODULE_0__["Client"] {
     /**
      * Available for backward compatibility, please shift to using {@link Client}
      * and [Client#webSocketFactory]{@link Client#webSocketFactory}.
@@ -712,51 +742,55 @@ var CompatClient = /** @class */ (function (_super) {
      *
      * @internal
      */
-    function CompatClient(webSocketFactory) {
-        var _this = _super.call(this) || this;
+    constructor(webSocketFactory) {
+        super();
         /**
          * It is no op now. No longer needed. Large packets work out of the box.
          */
-        _this.maxWebSocketFrameSize = 16 * 1024;
-        _this._heartbeatInfo = new heartbeat_info_1.HeartbeatInfo(_this);
-        _this.reconnect_delay = 0;
-        _this.webSocketFactory = webSocketFactory;
+        this.maxWebSocketFrameSize = 16 * 1024;
+        this._heartbeatInfo = new _heartbeat_info__WEBPACK_IMPORTED_MODULE_1__["HeartbeatInfo"](this);
+        this.reconnect_delay = 0;
+        this.webSocketFactory = webSocketFactory;
         // Default from previous version
-        _this.debug = function () {
-            var message = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                message[_i] = arguments[_i];
-            }
-            console.log.apply(console, message);
+        this.debug = (...message) => {
+            console.log(...message);
         };
-        return _this;
     }
-    CompatClient.prototype._parseConnect = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var closeEventCallback;
-        var connectCallback;
-        var errorCallback;
-        var headers = {};
+    _parseConnect(...args) {
+        let closeEventCallback;
+        let connectCallback;
+        let errorCallback;
+        let headers = {};
         if (args.length < 2) {
-            throw new Error(('Connect requires at least 2 arguments'));
+            throw new Error('Connect requires at least 2 arguments');
         }
-        if (typeof (args[1]) === 'function') {
-            headers = args[0], connectCallback = args[1], errorCallback = args[2], closeEventCallback = args[3];
+        if (typeof args[1] === 'function') {
+            [headers, connectCallback, errorCallback, closeEventCallback] = args;
         }
         else {
             switch (args.length) {
                 case 6:
-                    headers.login = args[0], headers.passcode = args[1], connectCallback = args[2], errorCallback = args[3], closeEventCallback = args[4], headers.host = args[5];
+                    [
+                        headers.login,
+                        headers.passcode,
+                        connectCallback,
+                        errorCallback,
+                        closeEventCallback,
+                        headers.host,
+                    ] = args;
                     break;
                 default:
-                    headers.login = args[0], headers.passcode = args[1], connectCallback = args[2], errorCallback = args[3], closeEventCallback = args[4];
+                    [
+                        headers.login,
+                        headers.passcode,
+                        connectCallback,
+                        errorCallback,
+                        closeEventCallback,
+                    ] = args;
             }
         }
         return [headers, connectCallback, errorCallback, closeEventCallback];
-    };
+    }
     /**
      * Available for backward compatibility, please shift to using [Client#activate]{@link Client#activate}.
      *
@@ -784,12 +818,8 @@ var CompatClient = /** @class */ (function (_super) {
      *
      * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
      */
-    CompatClient.prototype.connect = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var out = this._parseConnect.apply(this, args);
+    connect(...args) {
+        const out = this._parseConnect(...args);
         if (out[0]) {
             this.connectHeaders = out[0];
         }
@@ -802,8 +832,8 @@ var CompatClient = /** @class */ (function (_super) {
         if (out[3]) {
             this.onWebSocketClose = out[3];
         }
-        _super.prototype.activate.call(this);
-    };
+        super.activate();
+    }
     /**
      * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}.
      *
@@ -815,14 +845,13 @@ var CompatClient = /** @class */ (function (_super) {
      *
      * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
      */
-    CompatClient.prototype.disconnect = function (disconnectCallback, headers) {
-        if (headers === void 0) { headers = {}; }
+    disconnect(disconnectCallback, headers = {}) {
         if (disconnectCallback) {
             this.onDisconnect = disconnectCallback;
         }
         this.disconnectHeaders = headers;
-        _super.prototype.deactivate.call(this);
-    };
+        super.deactivate();
+    }
     /**
      * Available for backward compatibility, use [Client#publish]{@link Client#publish}.
      *
@@ -843,124 +872,96 @@ var CompatClient = /** @class */ (function (_super) {
      *
      * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
      */
-    CompatClient.prototype.send = function (destination, headers, body) {
-        if (headers === void 0) { headers = {}; }
-        if (body === void 0) { body = ''; }
+    send(destination, headers = {}, body = '') {
         headers = Object.assign({}, headers);
-        var skipContentLengthHeader = (headers['content-length'] === false);
+        const skipContentLengthHeader = headers['content-length'] === false;
         if (skipContentLengthHeader) {
             delete headers['content-length'];
         }
         this.publish({
-            destination: destination,
+            destination,
             headers: headers,
-            body: body,
-            skipContentLengthHeader: skipContentLengthHeader
+            body,
+            skipContentLengthHeader,
         });
-    };
-    Object.defineProperty(CompatClient.prototype, "reconnect_delay", {
-        /**
-         * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}.
-         *
-         * **Deprecated**
-         */
-        set: function (value) {
-            this.reconnectDelay = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CompatClient.prototype, "ws", {
-        /**
-         * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}.
-         *
-         * **Deprecated**
-         */
-        get: function () {
-            return this._webSocket;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CompatClient.prototype, "version", {
-        /**
-         * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}.
-         *
-         * **Deprecated**
-         */
-        get: function () {
-            return this.connectedVersion;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CompatClient.prototype, "onreceive", {
-        /**
-         * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
-         *
-         * **Deprecated**
-         */
-        get: function () {
-            return this.onUnhandledMessage;
-        },
-        /**
-         * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
-         *
-         * **Deprecated**
-         */
-        set: function (value) {
-            this.onUnhandledMessage = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CompatClient.prototype, "onreceipt", {
-        /**
-         * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
-         * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}.
-         *
-         * **Deprecated**
-         */
-        get: function () {
-            return this.onUnhandledReceipt;
-        },
-        /**
-         * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
-         *
-         * **Deprecated**
-         */
-        set: function (value) {
-            this.onUnhandledReceipt = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CompatClient.prototype, "heartbeat", {
-        /**
-         * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}
-         * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
-         *
-         * **Deprecated**
-         */
-        get: function () {
-            return this._heartbeatInfo;
-        },
-        /**
-         * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}
-         * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
-         *
-         * **Deprecated**
-         */
-        set: function (value) {
-            this.heartbeatIncoming = value.incoming;
-            this.heartbeatOutgoing = value.outgoing;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return CompatClient;
-}(client_1.Client));
-exports.CompatClient = CompatClient;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}.
+     *
+     * **Deprecated**
+     */
+    set reconnect_delay(value) {
+        this.reconnectDelay = value;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}.
+     *
+     * **Deprecated**
+     */
+    get ws() {
+        return this.webSocket;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}.
+     *
+     * **Deprecated**
+     */
+    get version() {
+        return this.connectedVersion;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+     *
+     * **Deprecated**
+     */
+    get onreceive() {
+        return this.onUnhandledMessage;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+     *
+     * **Deprecated**
+     */
+    set onreceive(value) {
+        this.onUnhandledMessage = value;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+     * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}.
+     *
+     * **Deprecated**
+     */
+    get onreceipt() {
+        return this.onUnhandledReceipt;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+     *
+     * **Deprecated**
+     */
+    set onreceipt(value) {
+        this.onUnhandledReceipt = value;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}
+     * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
+     *
+     * **Deprecated**
+     */
+    get heartbeat() {
+        return this._heartbeatInfo;
+    }
+    /**
+     * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}
+     * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
+     *
+     * **Deprecated**
+     */
+    set heartbeat(value) {
+        this.heartbeatIncoming = value.incoming;
+        this.heartbeatOutgoing = value.outgoing;
+    }
+}
 
 
 /***/ }),
@@ -969,44 +970,34 @@ exports.CompatClient = CompatClient;
 /*!*********************************************!*\
   !*** ./src/compatibility/heartbeat-info.ts ***!
   \*********************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: HeartbeatInfo */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HeartbeatInfo", function() { return HeartbeatInfo; });
 /**
  * Part of `@stomp/stompjs`.
  *
  * @internal
  */
-var HeartbeatInfo = /** @class */ (function () {
-    function HeartbeatInfo(client) {
+class HeartbeatInfo {
+    constructor(client) {
         this.client = client;
     }
-    Object.defineProperty(HeartbeatInfo.prototype, "outgoing", {
-        get: function () {
-            return this.client.heartbeatOutgoing;
-        },
-        set: function (value) {
-            this.client.heartbeatOutgoing = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(HeartbeatInfo.prototype, "incoming", {
-        get: function () {
-            return this.client.heartbeatIncoming;
-        },
-        set: function (value) {
-            this.client.heartbeatIncoming = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return HeartbeatInfo;
-}());
-exports.HeartbeatInfo = HeartbeatInfo;
+    get outgoing() {
+        return this.client.heartbeatOutgoing;
+    }
+    set outgoing(value) {
+        this.client.heartbeatOutgoing = value;
+    }
+    get incoming() {
+        return this.client.heartbeatIncoming;
+    }
+    set incoming(value) {
+        this.client.heartbeatIncoming = value;
+    }
+}
 
 
 /***/ }),
@@ -1015,14 +1006,16 @@ exports.HeartbeatInfo = HeartbeatInfo;
 /*!************************************!*\
   !*** ./src/compatibility/stomp.ts ***!
   \************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: Stomp */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Stomp", function() { return Stomp; });
+/* harmony import */ var _versions__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../versions */ "./src/versions.ts");
+/* harmony import */ var _compat_client__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./compat-client */ "./src/compatibility/compat-client.ts");
+
 
-Object.defineProperty(exports, "__esModule", { value: true });
-var versions_1 = __webpack_require__(/*! ../versions */ "./src/versions.ts");
-var compat_client_1 = __webpack_require__(/*! ./compat-client */ "./src/compatibility/compat-client.ts");
 /**
  * STOMP Class, acts like a factory to create {@link Client}.
  *
@@ -1032,9 +1025,7 @@ var compat_client_1 = __webpack_require__(/*! ./compat-client */ "./src/compatib
  *
  * It will be removed in next major version. Please switch to {@link Client}.
  */
-var Stomp = /** @class */ (function () {
-    function Stomp() {
-    }
+class Stomp {
     /**
      * This method creates a WebSocket client that is connected to
      * the STOMP server located at the url.
@@ -1049,7 +1040,7 @@ var Stomp = /** @class */ (function () {
      * It will be removed in next major version. Please switch to {@link Client}
      * using [Client#brokerURL]{@link Client#brokerURL}.
      */
-    Stomp.client = function (url, protocols) {
+    static client(url, protocols) {
         // This is a hack to allow another implementation than the standard
         // HTML5 WebSocket class.
         //
@@ -1063,14 +1054,14 @@ var Stomp = /** @class */ (function () {
         // instead.
         // See remarks on the function Stomp.over
         if (protocols == null) {
-            protocols = versions_1.Versions.default.protocolVersions();
+            protocols = _versions__WEBPACK_IMPORTED_MODULE_0__["Versions"].default.protocolVersions();
         }
-        var wsFn = function () {
-            var klass = Stomp.WebSocketClass || WebSocket;
+        const wsFn = () => {
+            const klass = Stomp.WebSocketClass || WebSocket;
             return new klass(url, protocols);
         };
-        return new compat_client_1.CompatClient(wsFn);
-    };
+        return new _compat_client__WEBPACK_IMPORTED_MODULE_1__["CompatClient"](wsFn);
+    }
     /**
      * This method is an alternative to [Stomp#client]{@link Stomp#client} to let the user
      * specify the WebSocket to use (either a standard HTML5 WebSocket or
@@ -1092,40 +1083,38 @@ var Stomp = /** @class */ (function () {
      * It will be removed in next major version. Please switch to {@link Client}
      * using [Client#webSocketFactory]{@link Client#webSocketFactory}.
      */
-    Stomp.over = function (ws) {
-        var wsFn;
-        if (typeof (ws) === 'function') {
+    static over(ws) {
+        let wsFn;
+        if (typeof ws === 'function') {
             wsFn = ws;
         }
         else {
             console.warn('Stomp.over did not receive a factory, auto reconnect will not work. ' +
                 'Please see https://stomp-js.github.io/api-docs/latest/classes/Stomp.html#over');
-            wsFn = function () { return ws; };
+            wsFn = () => ws;
         }
-        return new compat_client_1.CompatClient(wsFn);
-    };
-    /**
-     * In case you need to use a non standard class for WebSocket.
-     *
-     * For example when using within NodeJS environment:
-     *
-     * ```javascript
-     *        StompJs = require('../../esm5/');
-     *        Stomp = StompJs.Stomp;
-     *        Stomp.WebSocketClass = require('websocket').w3cwebsocket;
-     * ```
-     *
-     * **Deprecated**
-     *
-     *
-     * It will be removed in next major version. Please switch to {@link Client}
-     * using [Client#webSocketFactory]{@link Client#webSocketFactory}.
-     */
-    // tslint:disable-next-line:variable-name
-    Stomp.WebSocketClass = null;
-    return Stomp;
-}());
-exports.Stomp = Stomp;
+        return new _compat_client__WEBPACK_IMPORTED_MODULE_1__["CompatClient"](wsFn);
+    }
+}
+/**
+ * In case you need to use a non standard class for WebSocket.
+ *
+ * For example when using within NodeJS environment:
+ *
+ * ```javascript
+ *        StompJs = require('../../esm5/');
+ *        Stomp = StompJs.Stomp;
+ *        Stomp.WebSocketClass = require('websocket').w3cwebsocket;
+ * ```
+ *
+ * **Deprecated**
+ *
+ *
+ * It will be removed in next major version. Please switch to {@link Client}
+ * using [Client#webSocketFactory]{@link Client#webSocketFactory}.
+ */
+// tslint:disable-next-line:variable-name
+Stomp.WebSocketClass = null;
 
 
 /***/ }),
@@ -1134,26 +1123,27 @@ exports.Stomp = Stomp;
 /*!***************************!*\
   !*** ./src/frame-impl.ts ***!
   \***************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: FrameImpl */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FrameImpl", function() { return FrameImpl; });
+/* harmony import */ var _byte__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./byte */ "./src/byte.ts");
 
-Object.defineProperty(exports, "__esModule", { value: true });
-var byte_1 = __webpack_require__(/*! ./byte */ "./src/byte.ts");
 /**
  * Frame class represents a STOMP frame.
  *
  * @internal
  */
-var FrameImpl = /** @class */ (function () {
+class FrameImpl {
     /**
      * Frame constructor. `command`, `headers` and `body` are available as properties.
      *
      * @internal
      */
-    function FrameImpl(params) {
-        var command = params.command, headers = params.headers, body = params.body, binaryBody = params.binaryBody, escapeHeaderValues = params.escapeHeaderValues, skipContentLengthHeader = params.skipContentLengthHeader;
+    constructor(params) {
+        const { command, headers, body, binaryBody, escapeHeaderValues, skipContentLengthHeader, } = params;
         this.command = command;
         this.headers = Object.assign({}, headers || {});
         if (binaryBody) {
@@ -1167,64 +1157,57 @@ var FrameImpl = /** @class */ (function () {
         this.escapeHeaderValues = escapeHeaderValues || false;
         this.skipContentLengthHeader = skipContentLengthHeader || false;
     }
-    Object.defineProperty(FrameImpl.prototype, "body", {
-        /**
-         * body of the frame
-         */
-        get: function () {
-            if (!this._body && this.isBinaryBody) {
-                this._body = new TextDecoder().decode(this._binaryBody);
-            }
-            return this._body;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(FrameImpl.prototype, "binaryBody", {
-        /**
-         * body as Uint8Array
-         */
-        get: function () {
-            if (!this._binaryBody && !this.isBinaryBody) {
-                this._binaryBody = new TextEncoder().encode(this._body);
-            }
-            return this._binaryBody;
-        },
-        enumerable: true,
-        configurable: true
-    });
+    /**
+     * body of the frame
+     */
+    get body() {
+        if (!this._body && this.isBinaryBody) {
+            this._body = new TextDecoder().decode(this._binaryBody);
+        }
+        return this._body;
+    }
+    /**
+     * body as Uint8Array
+     */
+    get binaryBody() {
+        if (!this._binaryBody && !this.isBinaryBody) {
+            this._binaryBody = new TextEncoder().encode(this._body);
+        }
+        return this._binaryBody;
+    }
     /**
      * deserialize a STOMP Frame from raw data.
      *
      * @internal
      */
-    FrameImpl.fromRawFrame = function (rawFrame, escapeHeaderValues) {
-        var headers = {};
-        var trim = function (str) { return str.replace(/^\s+|\s+$/g, ''); };
+    static fromRawFrame(rawFrame, escapeHeaderValues) {
+        const headers = {};
+        const trim = (str) => str.replace(/^\s+|\s+$/g, '');
         // In case of repeated headers, as per standards, first value need to be used
-        for (var _i = 0, _a = rawFrame.headers.reverse(); _i < _a.length; _i++) {
-            var header = _a[_i];
-            var idx = header.indexOf(':');
-            var key = trim(header[0]);
-            var value = trim(header[1]);
-            if (escapeHeaderValues && (rawFrame.command !== 'CONNECT') && (rawFrame.command !== 'CONNECTED')) {
+        for (const header of rawFrame.headers.reverse()) {
+            const idx = header.indexOf(':');
+            const key = trim(header[0]);
+            let value = trim(header[1]);
+            if (escapeHeaderValues &&
+                rawFrame.command !== 'CONNECT' &&
+                rawFrame.command !== 'CONNECTED') {
                 value = FrameImpl.hdrValueUnEscape(value);
             }
             headers[key] = value;
         }
         return new FrameImpl({
             command: rawFrame.command,
-            headers: headers,
+            headers,
             binaryBody: rawFrame.binaryBody,
-            escapeHeaderValues: escapeHeaderValues
+            escapeHeaderValues,
         });
-    };
+    }
     /**
      * @internal
      */
-    FrameImpl.prototype.toString = function () {
+    toString() {
         return this.serializeCmdAndHeaders();
-    };
+    }
     /**
      * serialize this Frame in a format suitable to be passed to WebSocket.
      * If the body is string the output will be string.
@@ -1232,82 +1215,90 @@ var FrameImpl = /** @class */ (function () {
      *
      * @internal
      */
-    FrameImpl.prototype.serialize = function () {
-        var cmdAndHeaders = this.serializeCmdAndHeaders();
+    serialize() {
+        const cmdAndHeaders = this.serializeCmdAndHeaders();
         if (this.isBinaryBody) {
             return FrameImpl.toUnit8Array(cmdAndHeaders, this._binaryBody).buffer;
         }
         else {
-            return cmdAndHeaders + this._body + byte_1.BYTE.NULL;
+            return cmdAndHeaders + this._body + _byte__WEBPACK_IMPORTED_MODULE_0__["BYTE"].NULL;
         }
-    };
-    FrameImpl.prototype.serializeCmdAndHeaders = function () {
-        var lines = [this.command];
+    }
+    serializeCmdAndHeaders() {
+        const lines = [this.command];
         if (this.skipContentLengthHeader) {
             delete this.headers['content-length'];
         }
-        for (var _i = 0, _a = Object.keys(this.headers || {}); _i < _a.length; _i++) {
-            var name_1 = _a[_i];
-            var value = this.headers[name_1];
-            if (this.escapeHeaderValues && (this.command !== 'CONNECT') && (this.command !== 'CONNECTED')) {
-                lines.push(name_1 + ":" + FrameImpl.hdrValueEscape("" + value));
+        for (const name of Object.keys(this.headers || {})) {
+            const value = this.headers[name];
+            if (this.escapeHeaderValues &&
+                this.command !== 'CONNECT' &&
+                this.command !== 'CONNECTED') {
+                lines.push(`${name}:${FrameImpl.hdrValueEscape(`${value}`)}`);
             }
             else {
-                lines.push(name_1 + ":" + value);
+                lines.push(`${name}:${value}`);
             }
         }
-        if (this.isBinaryBody || (!this.isBodyEmpty() && !this.skipContentLengthHeader)) {
-            lines.push("content-length:" + this.bodyLength());
+        if (this.isBinaryBody ||
+            (!this.isBodyEmpty() && !this.skipContentLengthHeader)) {
+            lines.push(`content-length:${this.bodyLength()}`);
         }
-        return lines.join(byte_1.BYTE.LF) + byte_1.BYTE.LF + byte_1.BYTE.LF;
-    };
-    FrameImpl.prototype.isBodyEmpty = function () {
+        return lines.join(_byte__WEBPACK_IMPORTED_MODULE_0__["BYTE"].LF) + _byte__WEBPACK_IMPORTED_MODULE_0__["BYTE"].LF + _byte__WEBPACK_IMPORTED_MODULE_0__["BYTE"].LF;
+    }
+    isBodyEmpty() {
         return this.bodyLength() === 0;
-    };
-    FrameImpl.prototype.bodyLength = function () {
-        var binaryBody = this.binaryBody;
+    }
+    bodyLength() {
+        const binaryBody = this.binaryBody;
         return binaryBody ? binaryBody.length : 0;
-    };
+    }
     /**
      * Compute the size of a UTF-8 string by counting its number of bytes
      * (and not the number of characters composing the string)
      */
-    FrameImpl.sizeOfUTF8 = function (s) {
+    static sizeOfUTF8(s) {
         return s ? new TextEncoder().encode(s).length : 0;
-    };
-    FrameImpl.toUnit8Array = function (cmdAndHeaders, binaryBody) {
-        var uint8CmdAndHeaders = new TextEncoder().encode(cmdAndHeaders);
-        var nullTerminator = new Uint8Array([0]);
-        var uint8Frame = new Uint8Array(uint8CmdAndHeaders.length + binaryBody.length + nullTerminator.length);
+    }
+    static toUnit8Array(cmdAndHeaders, binaryBody) {
+        const uint8CmdAndHeaders = new TextEncoder().encode(cmdAndHeaders);
+        const nullTerminator = new Uint8Array([0]);
+        const uint8Frame = new Uint8Array(uint8CmdAndHeaders.length + binaryBody.length + nullTerminator.length);
         uint8Frame.set(uint8CmdAndHeaders);
         uint8Frame.set(binaryBody, uint8CmdAndHeaders.length);
         uint8Frame.set(nullTerminator, uint8CmdAndHeaders.length + binaryBody.length);
         return uint8Frame;
-    };
+    }
     /**
      * Serialize a STOMP frame as per STOMP standards, suitable to be sent to the STOMP broker.
      *
      * @internal
      */
-    FrameImpl.marshall = function (params) {
-        var frame = new FrameImpl(params);
+    static marshall(params) {
+        const frame = new FrameImpl(params);
         return frame.serialize();
-    };
+    }
     /**
      *  Escape header values
      */
-    FrameImpl.hdrValueEscape = function (str) {
-        return str.replace(/\\/g, '\\\\').replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/:/g, '\\c');
-    };
+    static hdrValueEscape(str) {
+        return str
+            .replace(/\\/g, '\\\\')
+            .replace(/\r/g, '\\r')
+            .replace(/\n/g, '\\n')
+            .replace(/:/g, '\\c');
+    }
     /**
      * UnEscape header values
      */
-    FrameImpl.hdrValueUnEscape = function (str) {
-        return str.replace(/\\r/g, '\r').replace(/\\n/g, '\n').replace(/\\c/g, ':').replace(/\\\\/g, '\\');
-    };
-    return FrameImpl;
-}());
-exports.FrameImpl = FrameImpl;
+    static hdrValueUnEscape(str) {
+        return str
+            .replace(/\\r/g, '\r')
+            .replace(/\\n/g, '\n')
+            .replace(/\\c/g, ':')
+            .replace(/\\\\/g, '\\');
+    }
+}
 
 
 /***/ }),
@@ -1316,26 +1307,54 @@ exports.FrameImpl = FrameImpl;
 /*!**********************!*\
   !*** ./src/index.ts ***!
   \**********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: Client, FrameImpl, Parser, StompConfig, StompHeaders, StompSubscription, StompSocketState, ActivationState, Versions, CompatClient, Stomp */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _client__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./client */ "./src/client.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Client", function() { return _client__WEBPACK_IMPORTED_MODULE_0__["Client"]; });
+
+/* harmony import */ var _frame_impl__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./frame-impl */ "./src/frame-impl.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "FrameImpl", function() { return _frame_impl__WEBPACK_IMPORTED_MODULE_1__["FrameImpl"]; });
+
+/* harmony import */ var _parser__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./parser */ "./src/parser.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Parser", function() { return _parser__WEBPACK_IMPORTED_MODULE_2__["Parser"]; });
+
+/* harmony import */ var _stomp_config__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./stomp-config */ "./src/stomp-config.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "StompConfig", function() { return _stomp_config__WEBPACK_IMPORTED_MODULE_3__["StompConfig"]; });
+
+/* harmony import */ var _stomp_headers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./stomp-headers */ "./src/stomp-headers.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "StompHeaders", function() { return _stomp_headers__WEBPACK_IMPORTED_MODULE_4__["StompHeaders"]; });
+
+/* harmony import */ var _stomp_subscription__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./stomp-subscription */ "./src/stomp-subscription.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "StompSubscription", function() { return _stomp_subscription__WEBPACK_IMPORTED_MODULE_5__["StompSubscription"]; });
+
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./types */ "./src/types.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "StompSocketState", function() { return _types__WEBPACK_IMPORTED_MODULE_6__["StompSocketState"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ActivationState", function() { return _types__WEBPACK_IMPORTED_MODULE_6__["ActivationState"]; });
+
+/* harmony import */ var _versions__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./versions */ "./src/versions.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Versions", function() { return _versions__WEBPACK_IMPORTED_MODULE_7__["Versions"]; });
+
+/* harmony import */ var _compatibility_compat_client__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./compatibility/compat-client */ "./src/compatibility/compat-client.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CompatClient", function() { return _compatibility_compat_client__WEBPACK_IMPORTED_MODULE_8__["CompatClient"]; });
+
+/* harmony import */ var _compatibility_stomp__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./compatibility/stomp */ "./src/compatibility/stomp.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Stomp", function() { return _compatibility_stomp__WEBPACK_IMPORTED_MODULE_9__["Stomp"]; });
+
+
+
+
+
+
+
+
 
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./client */ "./src/client.ts"));
-__export(__webpack_require__(/*! ./frame-impl */ "./src/frame-impl.ts"));
-__export(__webpack_require__(/*! ./parser */ "./src/parser.ts"));
-__export(__webpack_require__(/*! ./stomp-config */ "./src/stomp-config.ts"));
-__export(__webpack_require__(/*! ./stomp-headers */ "./src/stomp-headers.ts"));
-__export(__webpack_require__(/*! ./stomp-subscription */ "./src/stomp-subscription.ts"));
-__export(__webpack_require__(/*! ./types */ "./src/types.ts"));
-__export(__webpack_require__(/*! ./versions */ "./src/versions.ts"));
 // Compatibility code
-__export(__webpack_require__(/*! ./compatibility/compat-client */ "./src/compatibility/compat-client.ts"));
-__export(__webpack_require__(/*! ./compatibility/stomp */ "./src/compatibility/stomp.ts"));
+
+
 
 
 /***/ }),
@@ -1344,28 +1363,28 @@ __export(__webpack_require__(/*! ./compatibility/stomp */ "./src/compatibility/s
 /*!***********************!*\
   !*** ./src/parser.ts ***!
   \***********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: Parser */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Parser", function() { return Parser; });
 /**
  * @internal
  */
-var NULL = 0;
+const NULL = 0;
 /**
  * @internal
  */
-var LF = 10;
+const LF = 10;
 /**
  * @internal
  */
-var CR = 13;
+const CR = 13;
 /**
  * @internal
  */
-var COLON = 58;
+const COLON = 58;
 /**
  * This is an evented, rec descent parser.
  * A stream of Octets can be passed and whenever it recognizes
@@ -1408,8 +1427,8 @@ var COLON = 58;
  *
  * @internal
  */
-var Parser = /** @class */ (function () {
-    function Parser(onFrame, onIncomingPing) {
+class Parser {
+    constructor(onFrame, onIncomingPing) {
         this.onFrame = onFrame;
         this.onIncomingPing = onIncomingPing;
         this._encoder = new TextEncoder();
@@ -1417,10 +1436,9 @@ var Parser = /** @class */ (function () {
         this._token = [];
         this._initState();
     }
-    Parser.prototype.parseChunk = function (segment, appendMissingNULLonIncoming) {
-        if (appendMissingNULLonIncoming === void 0) { appendMissingNULLonIncoming = false; }
-        var chunk;
-        if ((segment instanceof ArrayBuffer)) {
+    parseChunk(segment, appendMissingNULLonIncoming = false) {
+        let chunk;
+        if (segment instanceof ArrayBuffer) {
             chunk = new Uint8Array(segment);
         }
         else {
@@ -1431,35 +1449,39 @@ var Parser = /** @class */ (function () {
         //
         // Send a NULL byte, if the last byte of a Text frame was not NULL.F
         if (appendMissingNULLonIncoming && chunk[chunk.length - 1] !== 0) {
-            var chunkWithNull = new Uint8Array(chunk.length + 1);
+            const chunkWithNull = new Uint8Array(chunk.length + 1);
             chunkWithNull.set(chunk, 0);
             chunkWithNull[chunk.length] = 0;
             chunk = chunkWithNull;
         }
         // tslint:disable-next-line:prefer-for-of
-        for (var i = 0; i < chunk.length; i++) {
-            var byte = chunk[i];
+        for (let i = 0; i < chunk.length; i++) {
+            const byte = chunk[i];
             this._onByte(byte);
         }
-    };
+    }
     // The following implements a simple Rec Descent Parser.
     // The grammar is simple and just one byte tells what should be the next state
-    Parser.prototype._collectFrame = function (byte) {
-        if (byte === NULL) { // Ignore
+    _collectFrame(byte) {
+        if (byte === NULL) {
+            // Ignore
             return;
         }
-        if (byte === CR) { // Ignore CR
+        if (byte === CR) {
+            // Ignore CR
             return;
         }
-        if (byte === LF) { // Incoming Ping
+        if (byte === LF) {
+            // Incoming Ping
             this.onIncomingPing();
             return;
         }
         this._onByte = this._collectCommand;
         this._reinjectByte(byte);
-    };
-    Parser.prototype._collectCommand = function (byte) {
-        if (byte === CR) { // Ignore CR
+    }
+    _collectCommand(byte) {
+        if (byte === CR) {
+            // Ignore CR
             return;
         }
         if (byte === LF) {
@@ -1468,9 +1490,10 @@ var Parser = /** @class */ (function () {
             return;
         }
         this._consumeByte(byte);
-    };
-    Parser.prototype._collectHeaders = function (byte) {
-        if (byte === CR) { // Ignore CR
+    }
+    _collectHeaders(byte) {
+        if (byte === CR) {
+            // Ignore CR
             return;
         }
         if (byte === LF) {
@@ -1479,20 +1502,21 @@ var Parser = /** @class */ (function () {
         }
         this._onByte = this._collectHeaderKey;
         this._reinjectByte(byte);
-    };
-    Parser.prototype._reinjectByte = function (byte) {
+    }
+    _reinjectByte(byte) {
         this._onByte(byte);
-    };
-    Parser.prototype._collectHeaderKey = function (byte) {
+    }
+    _collectHeaderKey(byte) {
         if (byte === COLON) {
             this._headerKey = this._consumeTokenAsUTF8();
             this._onByte = this._collectHeaderValue;
             return;
         }
         this._consumeByte(byte);
-    };
-    Parser.prototype._collectHeaderValue = function (byte) {
-        if (byte === CR) { // Ignore CR
+    }
+    _collectHeaderValue(byte) {
+        if (byte === CR) {
+            // Ignore CR
             return;
         }
         if (byte === LF) {
@@ -1502,9 +1526,9 @@ var Parser = /** @class */ (function () {
             return;
         }
         this._consumeByte(byte);
-    };
-    Parser.prototype._setupCollectBody = function () {
-        var contentLengthHeader = this._results.headers.filter(function (header) {
+    }
+    _setupCollectBody() {
+        const contentLengthHeader = this._results.headers.filter((header) => {
             return header[0] === 'content-length';
         })[0];
         if (contentLengthHeader) {
@@ -1514,52 +1538,50 @@ var Parser = /** @class */ (function () {
         else {
             this._onByte = this._collectBodyNullTerminated;
         }
-    };
-    Parser.prototype._collectBodyNullTerminated = function (byte) {
+    }
+    _collectBodyNullTerminated(byte) {
         if (byte === NULL) {
             this._retrievedBody();
             return;
         }
         this._consumeByte(byte);
-    };
-    Parser.prototype._collectBodyFixedSize = function (byte) {
+    }
+    _collectBodyFixedSize(byte) {
         // It is post decrement, so that we discard the trailing NULL octet
         if (this._bodyBytesRemaining-- === 0) {
             this._retrievedBody();
             return;
         }
         this._consumeByte(byte);
-    };
-    Parser.prototype._retrievedBody = function () {
+    }
+    _retrievedBody() {
         this._results.binaryBody = this._consumeTokenAsRaw();
         this.onFrame(this._results);
         this._initState();
-    };
+    }
     // Rec Descent Parser helpers
-    Parser.prototype._consumeByte = function (byte) {
+    _consumeByte(byte) {
         this._token.push(byte);
-    };
-    Parser.prototype._consumeTokenAsUTF8 = function () {
+    }
+    _consumeTokenAsUTF8() {
         return this._decoder.decode(this._consumeTokenAsRaw());
-    };
-    Parser.prototype._consumeTokenAsRaw = function () {
-        var rawResult = new Uint8Array(this._token);
+    }
+    _consumeTokenAsRaw() {
+        const rawResult = new Uint8Array(this._token);
         this._token = [];
         return rawResult;
-    };
-    Parser.prototype._initState = function () {
+    }
+    _initState() {
         this._results = {
             command: undefined,
             headers: [],
-            binaryBody: undefined
+            binaryBody: undefined,
         };
         this._token = [];
         this._headerKey = undefined;
         this._onByte = this._collectFrame;
-    };
-    return Parser;
-}());
-exports.Parser = Parser;
+    }
+}
 
 
 /***/ }),
@@ -1568,25 +1590,24 @@ exports.Parser = Parser;
 /*!*****************************!*\
   !*** ./src/stomp-config.ts ***!
   \*****************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: StompConfig */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StompConfig", function() { return StompConfig; });
 /**
  * Configuration options for STOMP Client, each key corresponds to
  * field by the same name in {@link Client}. This can be passed to
  * the constructor of {@link Client} or to [Client#configure]{@link Client#configure}.
  *
+ * There used to be a class with the same name in `@stomp/ng2-stompjs`, which has been replaced by
+ * {@link RxStompConfig} and {@link InjectableRxStompConfig}.
+ *
  * Part of `@stomp/stompjs`.
  */
-var StompConfig = /** @class */ (function () {
-    function StompConfig() {
-    }
-    return StompConfig;
-}());
-exports.StompConfig = StompConfig;
+class StompConfig {
+}
 
 
 /***/ }),
@@ -1595,17 +1616,24 @@ exports.StompConfig = StompConfig;
 /*!******************************!*\
   !*** ./src/stomp-handler.ts ***!
   \******************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: StompHandler */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StompHandler", function() { return StompHandler; });
+/* harmony import */ var _byte__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./byte */ "./src/byte.ts");
+/* harmony import */ var _frame_impl__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./frame-impl */ "./src/frame-impl.ts");
+/* harmony import */ var _parser__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./parser */ "./src/parser.ts");
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./types */ "./src/types.ts");
+/* harmony import */ var _versions__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./versions */ "./src/versions.ts");
+/* harmony import */ var _augment_websocket__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./augment-websocket */ "./src/augment-websocket.ts");
+
+
+
+
+
 
-Object.defineProperty(exports, "__esModule", { value: true });
-var byte_1 = __webpack_require__(/*! ./byte */ "./src/byte.ts");
-var frame_impl_1 = __webpack_require__(/*! ./frame-impl */ "./src/frame-impl.ts");
-var parser_1 = __webpack_require__(/*! ./parser */ "./src/parser.ts");
-var types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
-var versions_1 = __webpack_require__(/*! ./versions */ "./src/versions.ts");
 /**
  * The STOMP protocol handler
  *
@@ -1613,27 +1641,25 @@ var versions_1 = __webpack_require__(/*! ./versions */ "./src/versions.ts");
  *
  * @internal
  */
-var StompHandler = /** @class */ (function () {
-    function StompHandler(_client, _webSocket, config) {
-        var _this = this;
-        if (config === void 0) { config = {}; }
+class StompHandler {
+    constructor(_client, _webSocket, config = {}) {
         this._client = _client;
         this._webSocket = _webSocket;
         this._serverFrameHandlers = {
             // [CONNECTED Frame](http://stomp.github.com/stomp-specification-1.2.html#CONNECTED_Frame)
-            CONNECTED: function (frame) {
-                _this.debug("connected to server " + frame.headers.server);
-                _this._connected = true;
-                _this._connectedVersion = frame.headers.version;
+            CONNECTED: frame => {
+                this.debug(`connected to server ${frame.headers.server}`);
+                this._connected = true;
+                this._connectedVersion = frame.headers.version;
                 // STOMP version 1.2 needs header values to be escaped
-                if (_this._connectedVersion === versions_1.Versions.V1_2) {
-                    _this._escapeHeaderValues = true;
+                if (this._connectedVersion === _versions__WEBPACK_IMPORTED_MODULE_4__["Versions"].V1_2) {
+                    this._escapeHeaderValues = true;
                 }
-                _this._setupHeartbeat(frame.headers);
-                _this.onConnect(frame);
+                this._setupHeartbeat(frame.headers);
+                this.onConnect(frame);
             },
             // [MESSAGE Frame](http://stomp.github.com/stomp-specification-1.2.html#MESSAGE)
-            MESSAGE: function (frame) {
+            MESSAGE: frame => {
                 // the callback is registered when the client calls
                 // `subscribe()`.
                 // If there is no registered subscription for the received message,
@@ -1641,40 +1667,40 @@ var StompHandler = /** @class */ (function () {
                 // This is useful for subscriptions that are automatically created
                 // on the browser side (e.g. [RabbitMQ's temporary
                 // queues](http://www.rabbitmq.com/stomp.html)).
-                var subscription = frame.headers.subscription;
-                var onReceive = _this._subscriptions[subscription] || _this.onUnhandledMessage;
+                const subscription = frame.headers.subscription;
+                const onReceive = this._subscriptions[subscription] || this.onUnhandledMessage;
                 // bless the frame to be a Message
-                var message = frame;
-                var client = _this;
-                var messageId = _this._connectedVersion === versions_1.Versions.V1_2 ? message.headers.ack : message.headers['message-id'];
+                const message = frame;
+                const client = this;
+                const messageId = this._connectedVersion === _versions__WEBPACK_IMPORTED_MODULE_4__["Versions"].V1_2
+                    ? message.headers.ack
+                    : message.headers['message-id'];
                 // add `ack()` and `nack()` methods directly to the returned frame
                 // so that a simple call to `message.ack()` can acknowledge the message.
-                message.ack = function (headers) {
-                    if (headers === void 0) { headers = {}; }
+                message.ack = (headers = {}) => {
                     return client.ack(messageId, subscription, headers);
                 };
-                message.nack = function (headers) {
-                    if (headers === void 0) { headers = {}; }
+                message.nack = (headers = {}) => {
                     return client.nack(messageId, subscription, headers);
                 };
                 onReceive(message);
             },
             // [RECEIPT Frame](http://stomp.github.com/stomp-specification-1.2.html#RECEIPT)
-            RECEIPT: function (frame) {
-                var callback = _this._receiptWatchers[frame.headers['receipt-id']];
+            RECEIPT: frame => {
+                const callback = this._receiptWatchers[frame.headers['receipt-id']];
                 if (callback) {
                     callback(frame);
                     // Server will acknowledge only once, remove the callback
-                    delete _this._receiptWatchers[frame.headers['receipt-id']];
+                    delete this._receiptWatchers[frame.headers['receipt-id']];
                 }
                 else {
-                    _this.onUnhandledReceipt(frame);
+                    this.onUnhandledReceipt(frame);
                 }
             },
             // [ERROR Frame](http://stomp.github.com/stomp-specification-1.2.html#ERROR)
-            ERROR: function (frame) {
-                _this.onStompError(frame);
-            }
+            ERROR: frame => {
+                this.onStompError(frame);
+            },
         };
         // used to index subscribers
         this._counter = 0;
@@ -1687,71 +1713,67 @@ var StompHandler = /** @class */ (function () {
         this._lastServerActivityTS = Date.now();
         this.configure(config);
     }
-    Object.defineProperty(StompHandler.prototype, "connectedVersion", {
-        get: function () {
-            return this._connectedVersion;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(StompHandler.prototype, "connected", {
-        get: function () {
-            return this._connected;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    StompHandler.prototype.configure = function (conf) {
+    get connectedVersion() {
+        return this._connectedVersion;
+    }
+    get connected() {
+        return this._connected;
+    }
+    configure(conf) {
         // bulk assign all properties to this
         Object.assign(this, conf);
-    };
-    StompHandler.prototype.start = function () {
-        var _this = this;
-        var parser = new parser_1.Parser(
+    }
+    start() {
+        const parser = new _parser__WEBPACK_IMPORTED_MODULE_2__["Parser"](
         // On Frame
-        function (rawFrame) {
-            var frame = frame_impl_1.FrameImpl.fromRawFrame(rawFrame, _this._escapeHeaderValues);
+        rawFrame => {
+            const frame = _frame_impl__WEBPACK_IMPORTED_MODULE_1__["FrameImpl"].fromRawFrame(rawFrame, this._escapeHeaderValues);
             // if this.logRawCommunication is set, the rawChunk is logged at this._webSocket.onmessage
-            if (!_this.logRawCommunication) {
-                _this.debug("<<< " + frame);
+            if (!this.logRawCommunication) {
+                this.debug(`<<< ${frame}`);
             }
-            var serverFrameHandler = _this._serverFrameHandlers[frame.command] || _this.onUnhandledFrame;
+            const serverFrameHandler = this._serverFrameHandlers[frame.command] || this.onUnhandledFrame;
             serverFrameHandler(frame);
         }, 
         // On Incoming Ping
-        function () {
-            _this.debug('<<< PONG');
+        () => {
+            this.debug('<<< PONG');
         });
-        this._webSocket.onmessage = function (evt) {
-            _this.debug('Received data');
-            _this._lastServerActivityTS = Date.now();
-            if (_this.logRawCommunication) {
-                var rawChunkAsString = (evt.data instanceof ArrayBuffer) ? new TextDecoder().decode(evt.data) : evt.data;
-                _this.debug("<<< " + rawChunkAsString);
+        this._webSocket.onmessage = (evt) => {
+            this.debug('Received data');
+            this._lastServerActivityTS = Date.now();
+            if (this.logRawCommunication) {
+                const rawChunkAsString = evt.data instanceof ArrayBuffer
+                    ? new TextDecoder().decode(evt.data)
+                    : evt.data;
+                this.debug(`<<< ${rawChunkAsString}`);
             }
-            parser.parseChunk(evt.data, _this.appendMissingNULLonIncoming);
+            parser.parseChunk(evt.data, this.appendMissingNULLonIncoming);
         };
-        this._onclose = function (closeEvent) {
-            _this.debug("Connection closed to " + _this._client.brokerURL);
-            _this.onWebSocketClose(closeEvent);
-            _this._cleanUp();
+        this._onclose = (closeEvent) => {
+            this.debug(`Connection closed to ${this._client.brokerURL}`);
+            this._cleanUp();
+            this.onWebSocketClose(closeEvent);
         };
         this._webSocket.onclose = this._onclose;
-        this._webSocket.onerror = function (errorEvent) {
-            _this.onWebSocketError(errorEvent);
+        this._webSocket.onerror = (errorEvent) => {
+            this.onWebSocketError(errorEvent);
         };
-        this._webSocket.onopen = function () {
+        this._webSocket.onopen = () => {
             // Clone before updating
-            var connectHeaders = Object.assign({}, _this.connectHeaders);
-            _this.debug('Web Socket Opened...');
-            connectHeaders['accept-version'] = _this.stompVersions.supportedVersions();
-            connectHeaders['heart-beat'] = [_this.heartbeatOutgoing, _this.heartbeatIncoming].join(',');
-            _this._transmit({ command: 'CONNECT', headers: connectHeaders });
+            const connectHeaders = Object.assign({}, this.connectHeaders);
+            this.debug('Web Socket Opened...');
+            connectHeaders['accept-version'] = this.stompVersions.supportedVersions();
+            connectHeaders['heart-beat'] = [
+                this.heartbeatOutgoing,
+                this.heartbeatIncoming,
+            ].join(',');
+            this._transmit({ command: 'CONNECT', headers: connectHeaders });
         };
-    };
-    StompHandler.prototype._setupHeartbeat = function (headers) {
-        var _this = this;
-        if ((headers.version !== versions_1.Versions.V1_1 && headers.version !== versions_1.Versions.V1_2)) {
+    }
+    _setupHeartbeat(headers) {
+        if (headers.version !== _versions__WEBPACK_IMPORTED_MODULE_4__["Versions"].V1_1 &&
+            headers.version !== _versions__WEBPACK_IMPORTED_MODULE_4__["Versions"].V1_2) {
             return;
         }
         // It is valid for the server to not send this header
@@ -1762,78 +1784,76 @@ var StompHandler = /** @class */ (function () {
         // heart-beat header received from the server looks like:
         //
         //     heart-beat: sx, sy
-        var _a = (headers['heart-beat']).split(',').map(function (v) { return parseInt(v, 10); }), serverOutgoing = _a[0], serverIncoming = _a[1];
-        if ((this.heartbeatOutgoing !== 0) && (serverIncoming !== 0)) {
-            var ttl = Math.max(this.heartbeatOutgoing, serverIncoming);
-            this.debug("send PING every " + ttl + "ms");
-            this._pinger = setInterval(function () {
-                if (_this._webSocket.readyState === types_1.StompSocketState.OPEN) {
-                    _this._webSocket.send(byte_1.BYTE.LF);
-                    _this.debug('>>> PING');
+        const [serverOutgoing, serverIncoming] = headers['heart-beat']
+            .split(',')
+            .map((v) => parseInt(v, 10));
+        if (this.heartbeatOutgoing !== 0 && serverIncoming !== 0) {
+            const ttl = Math.max(this.heartbeatOutgoing, serverIncoming);
+            this.debug(`send PING every ${ttl}ms`);
+            this._pinger = setInterval(() => {
+                if (this._webSocket.readyState === _types__WEBPACK_IMPORTED_MODULE_3__["StompSocketState"].OPEN) {
+                    this._webSocket.send(_byte__WEBPACK_IMPORTED_MODULE_0__["BYTE"].LF);
+                    this.debug('>>> PING');
                 }
             }, ttl);
         }
-        if ((this.heartbeatIncoming !== 0) && (serverOutgoing !== 0)) {
-            var ttl_1 = Math.max(this.heartbeatIncoming, serverOutgoing);
-            this.debug("check PONG every " + ttl_1 + "ms");
-            this._ponger = setInterval(function () {
-                var delta = Date.now() - _this._lastServerActivityTS;
+        if (this.heartbeatIncoming !== 0 && serverOutgoing !== 0) {
+            const ttl = Math.max(this.heartbeatIncoming, serverOutgoing);
+            this.debug(`check PONG every ${ttl}ms`);
+            this._ponger = setInterval(() => {
+                const delta = Date.now() - this._lastServerActivityTS;
                 // We wait twice the TTL to be flexible on window's setInterval calls
-                if (delta > (ttl_1 * 2)) {
-                    _this.debug("did not receive server activity for the last " + delta + "ms");
-                    if (_this.discardWebsocketOnCommFailure) {
-                        _this.debug('Discarding websocket, the underlying socket may linger for a while');
-                        _this._discardWebsocket();
-                    }
-                    else {
-                        _this.debug('Issuing close on the websocket');
-                        _this._closeWebsocket();
-                    }
+                if (delta > ttl * 2) {
+                    this.debug(`did not receive server activity for the last ${delta}ms`);
+                    this._closeOrDiscardWebsocket();
                 }
-            }, ttl_1);
+            }, ttl);
         }
-    };
-    StompHandler.prototype._closeWebsocket = function () {
-        this._webSocket.onmessage = function () { }; // ignore messages
-        this._webSocket.close();
-    };
-    StompHandler.prototype._discardWebsocket = function () {
-        var _this = this;
-        var noOp = function () { };
-        // set all callbacks to no op
-        this._webSocket.onerror = noOp;
-        this._webSocket.onmessage = noOp;
-        this._webSocket.onopen = noOp;
-        var ts = new Date();
-        // Track delay in actual closure of the socket
-        this._webSocket.onclose = function (closeEvent) {
-            var delay = (new Date()).getTime() - ts.getTime();
-            _this.debug("Discarded socket closed after " + delay + "ms, with code/reason: " + closeEvent.code + "/" + closeEvent.reason);
-        };
+    }
+    _closeOrDiscardWebsocket() {
+        if (this.discardWebsocketOnCommFailure) {
+            this.debug("Discarding websocket, the underlying socket may linger for a while");
+            this._discardWebsocket();
+        }
+        else {
+            this.debug("Issuing close on the websocket");
+            this._closeWebsocket();
+        }
+    }
+    forceDisconnect() {
+        if (this._webSocket) {
+            if (this._webSocket.readyState === _types__WEBPACK_IMPORTED_MODULE_3__["StompSocketState"].CONNECTING ||
+                this._webSocket.readyState === _types__WEBPACK_IMPORTED_MODULE_3__["StompSocketState"].OPEN) {
+                this._closeOrDiscardWebsocket();
+            }
+        }
+    }
+    _closeWebsocket() {
+        this._webSocket.onmessage = () => { }; // ignore messages
         this._webSocket.close();
-        var customCloseEvent = {
-            code: 4001,
-            reason: 'Heartbeat failure, discarding the socket',
-            wasClean: false
-        };
-        this._onclose(customCloseEvent);
-    };
-    StompHandler.prototype._transmit = function (params) {
-        var command = params.command, headers = params.headers, body = params.body, binaryBody = params.binaryBody, skipContentLengthHeader = params.skipContentLengthHeader;
-        var frame = new frame_impl_1.FrameImpl({
-            command: command,
-            headers: headers,
-            body: body,
-            binaryBody: binaryBody,
+    }
+    _discardWebsocket() {
+        if (!this._webSocket.terminate) {
+            Object(_augment_websocket__WEBPACK_IMPORTED_MODULE_5__["augmentWebsocket"])(this._webSocket, (msg) => this.debug(msg));
+        }
+        this._webSocket.terminate();
+    }
+    _transmit(params) {
+        const { command, headers, body, binaryBody, skipContentLengthHeader, } = params;
+        const frame = new _frame_impl__WEBPACK_IMPORTED_MODULE_1__["FrameImpl"]({
+            command,
+            headers,
+            body,
+            binaryBody,
             escapeHeaderValues: this._escapeHeaderValues,
-            skipContentLengthHeader: skipContentLengthHeader
+            skipContentLengthHeader,
         });
-        var rawChunk = frame.serialize();
+        let rawChunk = frame.serialize();
         if (this.logRawCommunication) {
-            this.debug(">>> " + rawChunk);
+            this.debug(`>>> ${rawChunk}`);
         }
         else {
-            this.debug(">>> " + frame);
+            this.debug(`>>> ${frame}`);
         }
         if (this.forceBinaryWSFrames && typeof rawChunk === 'string') {
             rawChunk = new TextEncoder().encode(rawChunk);
@@ -1842,43 +1862,42 @@ var StompHandler = /** @class */ (function () {
             this._webSocket.send(rawChunk);
         }
         else {
-            var out = rawChunk;
+            let out = rawChunk;
             while (out.length > 0) {
-                var chunk = out.substring(0, this.maxWebSocketChunkSize);
+                const chunk = out.substring(0, this.maxWebSocketChunkSize);
                 out = out.substring(this.maxWebSocketChunkSize);
                 this._webSocket.send(chunk);
-                this.debug("chunk sent = " + chunk.length + ", remaining = " + out.length);
+                this.debug(`chunk sent = ${chunk.length}, remaining = ${out.length}`);
             }
         }
-    };
-    StompHandler.prototype.dispose = function () {
-        var _this = this;
+    }
+    dispose() {
         if (this.connected) {
             try {
                 // clone before updating
-                var disconnectHeaders = Object.assign({}, this.disconnectHeaders);
+                const disconnectHeaders = Object.assign({}, this.disconnectHeaders);
                 if (!disconnectHeaders.receipt) {
-                    disconnectHeaders.receipt = "close-" + this._counter++;
+                    disconnectHeaders.receipt = `close-${this._counter++}`;
                 }
-                this.watchForReceipt(disconnectHeaders.receipt, function (frame) {
-                    _this._closeWebsocket();
-                    _this._cleanUp();
-                    _this.onDisconnect(frame);
+                this.watchForReceipt(disconnectHeaders.receipt, frame => {
+                    this._closeWebsocket();
+                    this._cleanUp();
+                    this.onDisconnect(frame);
                 });
                 this._transmit({ command: 'DISCONNECT', headers: disconnectHeaders });
             }
             catch (error) {
-                this.debug("Ignoring error during disconnect " + error);
+                this.debug(`Ignoring error during disconnect ${error}`);
             }
         }
         else {
-            if (this._webSocket.readyState === types_1.StompSocketState.CONNECTING
-                || this._webSocket.readyState === types_1.StompSocketState.OPEN) {
+            if (this._webSocket.readyState === _types__WEBPACK_IMPORTED_MODULE_3__["StompSocketState"].CONNECTING ||
+                this._webSocket.readyState === _types__WEBPACK_IMPORTED_MODULE_3__["StompSocketState"].OPEN) {
                 this._closeWebsocket();
             }
         }
-    };
-    StompHandler.prototype._cleanUp = function () {
+    }
+    _cleanUp() {
         this._connected = false;
         if (this._pinger) {
             clearInterval(this._pinger);
@@ -1886,104 +1905,101 @@ var StompHandler = /** @class */ (function () {
         if (this._ponger) {
             clearInterval(this._ponger);
         }
-    };
-    StompHandler.prototype.publish = function (params) {
-        var destination = params.destination, headers = params.headers, body = params.body, binaryBody = params.binaryBody, skipContentLengthHeader = params.skipContentLengthHeader;
-        var hdrs = Object.assign({ destination: destination }, headers);
+    }
+    publish(params) {
+        const { destination, headers, body, binaryBody, skipContentLengthHeader, } = params;
+        const hdrs = Object.assign({ destination }, headers);
         this._transmit({
             command: 'SEND',
             headers: hdrs,
-            body: body,
-            binaryBody: binaryBody,
-            skipContentLengthHeader: skipContentLengthHeader
+            body,
+            binaryBody,
+            skipContentLengthHeader,
         });
-    };
-    StompHandler.prototype.watchForReceipt = function (receiptId, callback) {
+    }
+    watchForReceipt(receiptId, callback) {
         this._receiptWatchers[receiptId] = callback;
-    };
-    StompHandler.prototype.subscribe = function (destination, callback, headers) {
-        if (headers === void 0) { headers = {}; }
+    }
+    subscribe(destination, callback, headers = {}) {
         headers = Object.assign({}, headers);
         if (!headers.id) {
-            headers.id = "sub-" + this._counter++;
+            headers.id = `sub-${this._counter++}`;
         }
         headers.destination = destination;
         this._subscriptions[headers.id] = callback;
-        this._transmit({ command: 'SUBSCRIBE', headers: headers });
-        var client = this;
+        this._transmit({ command: 'SUBSCRIBE', headers });
+        const client = this;
         return {
             id: headers.id,
-            unsubscribe: function (hdrs) {
+            unsubscribe(hdrs) {
                 return client.unsubscribe(headers.id, hdrs);
-            }
+            },
         };
-    };
-    StompHandler.prototype.unsubscribe = function (id, headers) {
-        if (headers === void 0) { headers = {}; }
+    }
+    unsubscribe(id, headers = {}) {
         headers = Object.assign({}, headers);
         delete this._subscriptions[id];
         headers.id = id;
-        this._transmit({ command: 'UNSUBSCRIBE', headers: headers });
-    };
-    StompHandler.prototype.begin = function (transactionId) {
-        var txId = transactionId || ("tx-" + this._counter++);
+        this._transmit({ command: 'UNSUBSCRIBE', headers });
+    }
+    begin(transactionId) {
+        const txId = transactionId || `tx-${this._counter++}`;
         this._transmit({
-            command: 'BEGIN', headers: {
-                transaction: txId
-            }
+            command: 'BEGIN',
+            headers: {
+                transaction: txId,
+            },
         });
-        var client = this;
+        const client = this;
         return {
             id: txId,
-            commit: function () {
+            commit() {
                 client.commit(txId);
             },
-            abort: function () {
+            abort() {
                 client.abort(txId);
-            }
+            },
         };
-    };
-    StompHandler.prototype.commit = function (transactionId) {
+    }
+    commit(transactionId) {
         this._transmit({
-            command: 'COMMIT', headers: {
-                transaction: transactionId
-            }
+            command: 'COMMIT',
+            headers: {
+                transaction: transactionId,
+            },
         });
-    };
-    StompHandler.prototype.abort = function (transactionId) {
+    }
+    abort(transactionId) {
         this._transmit({
-            command: 'ABORT', headers: {
-                transaction: transactionId
-            }
+            command: 'ABORT',
+            headers: {
+                transaction: transactionId,
+            },
         });
-    };
-    StompHandler.prototype.ack = function (messageId, subscriptionId, headers) {
-        if (headers === void 0) { headers = {}; }
+    }
+    ack(messageId, subscriptionId, headers = {}) {
         headers = Object.assign({}, headers);
-        if (this._connectedVersion === versions_1.Versions.V1_2) {
+        if (this._connectedVersion === _versions__WEBPACK_IMPORTED_MODULE_4__["Versions"].V1_2) {
             headers.id = messageId;
         }
         else {
             headers['message-id'] = messageId;
         }
         headers.subscription = subscriptionId;
-        this._transmit({ command: 'ACK', headers: headers });
-    };
-    StompHandler.prototype.nack = function (messageId, subscriptionId, headers) {
-        if (headers === void 0) { headers = {}; }
+        this._transmit({ command: 'ACK', headers });
+    }
+    nack(messageId, subscriptionId, headers = {}) {
         headers = Object.assign({}, headers);
-        if (this._connectedVersion === versions_1.Versions.V1_2) {
+        if (this._connectedVersion === _versions__WEBPACK_IMPORTED_MODULE_4__["Versions"].V1_2) {
             headers.id = messageId;
         }
         else {
             headers['message-id'] = messageId;
         }
         headers.subscription = subscriptionId;
-        return this._transmit({ command: 'NACK', headers: headers });
-    };
-    return StompHandler;
-}());
-exports.StompHandler = StompHandler;
+        return this._transmit({ command: 'NACK', headers });
+    }
+}
 
 
 /***/ }),
@@ -1992,12 +2008,12 @@ exports.StompHandler = StompHandler;
 /*!******************************!*\
   !*** ./src/stomp-headers.ts ***!
   \******************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: StompHeaders */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StompHeaders", function() { return StompHeaders; });
 /**
  * STOMP headers. Many functions calls will accept headers as parameters.
  * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}.
@@ -2007,12 +2023,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *
  * Part of `@stomp/stompjs`.
  */
-var StompHeaders = /** @class */ (function () {
-    function StompHeaders() {
-    }
-    return StompHeaders;
-}());
-exports.StompHeaders = StompHeaders;
+class StompHeaders {
+}
 
 
 /***/ }),
@@ -2021,23 +2033,19 @@ exports.StompHeaders = StompHeaders;
 /*!***********************************!*\
   !*** ./src/stomp-subscription.ts ***!
   \***********************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: StompSubscription */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StompSubscription", function() { return StompSubscription; });
 /**
  * Call [Client#subscribe]{@link Client#subscribe} to create a StompSubscription.
  *
  * Part of `@stomp/stompjs`.
  */
-var StompSubscription = /** @class */ (function () {
-    function StompSubscription() {
-    }
-    return StompSubscription;
-}());
-exports.StompSubscription = StompSubscription;
+class StompSubscription {
+}
 
 
 /***/ }),
@@ -2046,15 +2054,15 @@ exports.StompSubscription = StompSubscription;
 /*!**********************!*\
   !*** ./src/types.ts ***!
   \**********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: StompSocketState, ActivationState */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StompSocketState", function() { return StompSocketState; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ActivationState", function() { return ActivationState; });
 /**
  * Possible states for the IStompSocket
- *
  */
 var StompSocketState;
 (function (StompSocketState) {
@@ -2062,7 +2070,16 @@ var StompSocketState;
     StompSocketState[StompSocketState["OPEN"] = 1] = "OPEN";
     StompSocketState[StompSocketState["CLOSING"] = 2] = "CLOSING";
     StompSocketState[StompSocketState["CLOSED"] = 3] = "CLOSED";
-})(StompSocketState = exports.StompSocketState || (exports.StompSocketState = {}));
+})(StompSocketState || (StompSocketState = {}));
+/**
+ * Possible activation state
+ */
+var ActivationState;
+(function (ActivationState) {
+    ActivationState[ActivationState["ACTIVE"] = 0] = "ACTIVE";
+    ActivationState[ActivationState["DEACTIVATING"] = 1] = "DEACTIVATING";
+    ActivationState[ActivationState["INACTIVE"] = 2] = "INACTIVE";
+})(ActivationState || (ActivationState = {}));
 
 
 /***/ }),
@@ -2071,58 +2088,60 @@ var StompSocketState;
 /*!*************************!*\
   !*** ./src/versions.ts ***!
   \*************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/*! exports provided: Versions */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Versions", function() { return Versions; });
 /**
  * Supported STOMP versions
  *
  * Part of `@stomp/stompjs`.
  */
-var Versions = /** @class */ (function () {
+class Versions {
     /**
      * Takes an array of string of versions, typical elements '1.0', '1.1', or '1.2'
      *
      * You will an instance if this class if you want to override supported versions to be declared during
      * STOMP handshake.
      */
-    function Versions(versions) {
+    constructor(versions) {
         this.versions = versions;
     }
     /**
      * Used as part of CONNECT STOMP Frame
      */
-    Versions.prototype.supportedVersions = function () {
+    supportedVersions() {
         return this.versions.join(',');
-    };
+    }
     /**
      * Used while creating a WebSocket
      */
-    Versions.prototype.protocolVersions = function () {
-        return this.versions.map(function (x) { return "v" + x.replace('.', '') + ".stomp"; });
-    };
-    /**
-     * Indicates protocol version 1.0
-     */
-    Versions.V1_0 = '1.0';
-    /**
-     * Indicates protocol version 1.1
-     */
-    Versions.V1_1 = '1.1';
-    /**
-     * Indicates protocol version 1.2
-     */
-    Versions.V1_2 = '1.2';
-    /**
-     * @internal
-     */
-    Versions.default = new Versions([Versions.V1_0, Versions.V1_1, Versions.V1_2]);
-    return Versions;
-}());
-exports.Versions = Versions;
+    protocolVersions() {
+        return this.versions.map(x => `v${x.replace('.', '')}.stomp`);
+    }
+}
+/**
+ * Indicates protocol version 1.0
+ */
+Versions.V1_0 = '1.0';
+/**
+ * Indicates protocol version 1.1
+ */
+Versions.V1_1 = '1.1';
+/**
+ * Indicates protocol version 1.2
+ */
+Versions.V1_2 = '1.2';
+/**
+ * @internal
+ */
+Versions.default = new Versions([
+    Versions.V1_0,
+    Versions.V1_1,
+    Versions.V1_2,
+]);
 
 
 /***/ }),