die heldin script add

node_modules/@stomp/stompjs/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018-2020 Deepak Kumar <deepak@kreatio.com>
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/@stomp/stompjs/README.md

@@ -0,0 +1,89 @@
+# STOMP.js
+
+[![Build Status](https://travis-ci.org/stomp-js/stompjs.svg?branch=master)](https://travis-ci.org/stomp-js/stompjs)
+
+This library provides a STOMP over WebSocket client for Web browser and node.js applications.
+
+# Introduction
+
+This repository is for version 5 and above of this library.
+Lower versions are not supported any longer.
+
+This library allows you to connect to a STOMP broker over WebSocket. This library
+supports complete STOMP specifications including all current protocol variants. Most
+popular messaging brokers support STOMP and STOMP over WebSockets either natively
+or using plugins.
+
+In general JavaScript engines in browsers are not friendly to binary protocols,
+so using STOMP is a good option because it is a text-oriented protocol.
+
+This library has its roots in a version released by [Jeff Mesnil](http://jmesnil.net/).
+
+## Current Status
+
+Version 5 of this library has been bottom-up rewritten using TypeScript (versions 3/4
+use CoffeeScript). The code has substantially changed, so, while there is a compatibility
+mode, you might need to update your code.
+
+This library is feature complete and has been used in production for many years. It
+is actively maintained. You are welcome to file issues and submit pull requests.
+
+## Getting started
+
+The API documentation is hosted as GitHub pages for the entire StompJS family of libraries.
+You may head straight to the https://stomp-js.github.io/api-docs/latest/
+
+This library comes with detailed usage instructions. Please find it at
+[Usage instructions](https://stomp-js.github.io/guide/stompjs/using-stompjs-v5.html).
+Check out other guides at https://stomp-js.github.io/.
+
+There are quite detailed API documentation,
+you should start at https://stomp-js.github.io/api-docs/latest/classes/Client.html.
+
+## Upgrading
+
+if you were using an older version of this library, you would need to make changes
+to your code. Head to
+[Upgrading](https://stomp-js.github.io/#upgrading).
+
+## Usage with RxJS
+
+https://github.com/stomp-js/rx-stomp is based on this library and exposes the entire functionality
+offered by this library as RxJS Observables.
+
+## Usage with Angular2+
+
+https://github.com/stomp-js/ng2-stompjs is based on https://github.com/stomp-js/rx-stomp
+and exposes key classes as Angular Injectable Services.
+
+## TypeScript definitions
+
+The npm package includes TypeScript definitions, so there is no need no install it separately.
+
+## Change-log
+
+Please visit [Change Log](Change-log.md).
+
+## Contributing
+
+If you want to understand the code, develop, or contribute. Please visit
+[How to contribute](Contribute.md).
+
+## Authors
+
+- [Jeff Mesnil](http://jmesnil.net/)
+- [Jeff Lindsay](http://github.com/progrium)
+- [Vanessa Williams](http://github.com/fridgebuzz)
+- [Deepak Kumar](https://github.com/kum-deepak)
+- [Astha Deep](https://github.com/astha183)
+- [Dillon Sellars](https://github.com/dillon-sellars)
+- [Jimi Charalampidis](https://github.com/jimic)
+- [Raul](https://github.com/rulonder)
+- [Dimitar Georgiev](https://github.com/iMitaka)
+- [Genadi](https://github.com/genadis)
+- [Bobohuochai](https://github.com/bobohuochai)
+- [Sailai](https://github.com/sailai)
+
+## License
+
+[License](LICENSE) - Apache-2.0

node_modules/@stomp/stompjs/esm6/augment-websocket.d.ts

@@ -0,0 +1,5 @@
+import { IStompSocket } from './types';
+/**
+ * @internal
+ */
+export declare function augmentWebsocket(webSocket: IStompSocket, debug: (msg: string) => void): void;

node_modules/@stomp/stompjs/esm6/augment-websocket.js

@@ -0,0 +1,26 @@
+/**
+ * @internal
+ */
+export 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,
+        });
+    };
+}
+//# sourceMappingURL=augment-websocket.js.map

node_modules/@stomp/stompjs/esm6/augment-websocket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"augment-websocket.js","sourceRoot":"","sources":["../src/augment-websocket.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAuB,EACvB,KAA4B;IAE5B,SAAS,CAAC,SAAS,GAAG;QACpB,MAAM,IAAI,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;QAEtB,6BAA6B;QAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QAEnB,MAAM,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;QAEtB,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;QAEjC,8CAA8C;QAC9C,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,EAAE;YAC1B,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;YAClD,KAAK,CACH,iCAAiC,KAAK,yBAAyB,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,MAAM,EAAE,CACtG,CAAC;QACJ,CAAC,CAAC;QAEF,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE;YACrB,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,0CAA0C;YAClD,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"}

node_modules/@stomp/stompjs/esm6/byte.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Some byte values, used as per STOMP specifications.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export declare const BYTE: {
+    LF: string;
+    NULL: string;
+};

node_modules/@stomp/stompjs/esm6/byte.js

@@ -0,0 +1,14 @@
+/**
+ * Some byte values, used as per STOMP specifications.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export const BYTE = {
+    // LINEFEED byte (octet 10)
+    LF: '\x0A',
+    // NULL byte (octet 0)
+    NULL: '\x00',
+};
+//# sourceMappingURL=byte.js.map

node_modules/@stomp/stompjs/esm6/byte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte.js","sourceRoot":"","sources":["../src/byte.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,2BAA2B;IAC3B,EAAE,EAAE,MAAM;IACV,sBAAsB;IACtB,IAAI,EAAE,MAAM;CACb,CAAC"}

node_modules/@stomp/stompjs/esm6/client.d.ts

@@ -0,0 +1,475 @@
+import { ITransaction } from './i-transaction';
+import { StompConfig } from './stomp-config';
+import { StompHeaders } from './stomp-headers';
+import { StompSubscription } from './stomp-subscription';
+import { ActivationState, closeEventCallbackType, debugFnType, frameCallbackType, IPublishParams, IStompSocket, messageCallbackType, wsErrorCallbackType } from './types';
+import { Versions } from './versions';
+/**
+ * STOMP Client Class.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare class Client {
+    /**
+     * The URL for the STOMP broker to connect to.
+     * Typically like `"ws://broker.329broker.com:15674/ws"` or `"wss://broker.329broker.com:15674/ws"`.
+     *
+     * Only one of this or [Client#webSocketFactory]{@link Client#webSocketFactory} need to be set.
+     * If both are set, [Client#webSocketFactory]{@link Client#webSocketFactory} will be used.
+     *
+     * If your environment does not support WebSockets natively, please refer to
+     * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}.
+     */
+    brokerURL: string;
+    /**
+     * STOMP versions to attempt during STOMP handshake. By default versions `1.0`, `1.1`, and `1.2` are attempted.
+     *
+     * Example:
+     * ```javascript
+     *        // Try only versions 1.0 and 1.1
+     *        client.stompVersions = new Versions(['1.0', '1.1'])
+     * ```
+     */
+    stompVersions: Versions;
+    /**
+     * This function should return a WebSocket or a similar (e.g. SockJS) object.
+     * If your environment does not support WebSockets natively, please refer to
+     * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}.
+     * If your STOMP Broker supports WebSockets, prefer setting [Client#brokerURL]{@link Client#brokerURL}.
+     *
+     * If both this and [Client#brokerURL]{@link Client#brokerURL} are set, this will be used.
+     *
+     * Example:
+     * ```javascript
+     *        // use a WebSocket
+     *        client.webSocketFactory= function () {
+     *          return new WebSocket("wss://broker.329broker.com:15674/ws");
+     *        };
+     *
+     *        // Typical usage with SockJS
+     *        client.webSocketFactory= function () {
+     *          return new SockJS("http://broker.329broker.com/stomp");
+     *        };
+     * ```
+     */
+    webSocketFactory: () => IStompSocket;
+    /**
+     * Will retry if Stomp connection is not established in specified milliseconds.
+     * Default 0, which implies wait for ever.
+     */
+    connectionTimeout: number;
+    private _connectionWatcher;
+    /**
+     *  automatically reconnect with delay in milliseconds, set to 0 to disable.
+     */
+    reconnectDelay: number;
+    /**
+     * Incoming heartbeat interval in milliseconds. Set to 0 to disable.
+     */
+    heartbeatIncoming: number;
+    /**
+     * Outgoing heartbeat interval in milliseconds. Set to 0 to disable.
+     */
+    heartbeatOutgoing: number;
+    /**
+     * This switches on a non standard behavior while sending WebSocket packets.
+     * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}.
+     * Only Java Spring brokers seems to use this mode.
+     *
+     * WebSockets, by itself, split large (text) packets,
+     * so it is not needed with a truly compliant STOMP/WebSocket broker.
+     * Actually setting it for such broker will cause large messages to fail.
+     *
+     * `false` by default.
+     *
+     * Binary frames are never split.
+     */
+    splitLargeFrames: boolean;
+    /**
+     * See [splitLargeFrames]{@link Client#splitLargeFrames}.
+     * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`.
+     */
+    maxWebSocketChunkSize: number;
+    /**
+     * Usually the
+     * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters}
+     * is automatically decided by type of the payload.
+     * Default is `false`, which should work with all compliant brokers.
+     *
+     * Set this flag to force binary frames.
+     */
+    forceBinaryWSFrames: boolean;
+    /**
+     * A bug in ReactNative chops a string on occurrence of a NULL.
+     * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}.
+     * This makes incoming WebSocket messages invalid STOMP packets.
+     * Setting this flag attempts to reverse the damage by appending a NULL.
+     * If the broker splits a large message into multiple WebSocket messages,
+     * this flag will cause data loss and abnormal termination of connection.
+     *
+     * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library.
+     */
+    appendMissingNULLonIncoming: boolean;
+    /**
+     * Underlying WebSocket instance, READONLY.
+     */
+    readonly webSocket: IStompSocket;
+    /**
+     * Connection headers, important keys - `login`, `passcode`, `host`.
+     * Though STOMP 1.2 standard marks these keys to be present, check your broker documentation for
+     * details specific to your broker.
+     */
+    connectHeaders: StompHeaders;
+    /**
+     * Disconnection headers.
+     */
+    disconnectHeaders: StompHeaders;
+    private _disconnectHeaders;
+    /**
+     * This function will be called for any unhandled messages.
+     * It is useful for receiving messages sent to RabbitMQ temporary queues.
+     *
+     * It can also get invoked with stray messages while the server is processing
+     * a request to [Client#unsubscribe]{@link Client#unsubscribe}
+     * from an endpoint.
+     *
+     * The actual {@link IMessage} will be passed as parameter to the callback.
+     */
+    onUnhandledMessage: messageCallbackType;
+    /**
+     * STOMP brokers can be requested to notify when an operation is actually completed.
+     * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. See
+     * [Client#watchForReceipt]{@link Client#watchForReceipt} for examples.
+     *
+     * The actual {@link FrameImpl} will be passed as parameter to the callback.
+     */
+    onUnhandledReceipt: frameCallbackType;
+    /**
+     * Will be invoked if {@link FrameImpl} of unknown type is received from the STOMP broker.
+     *
+     * The actual {@link IFrame} will be passed as parameter to the callback.
+     */
+    onUnhandledFrame: frameCallbackType;
+    /**
+     * `true` if there is a active connection with STOMP Broker
+     */
+    readonly connected: boolean;
+    /**
+     * Callback, invoked on before a connection connection to the STOMP broker.
+     *
+     * You can change options on the client, which will impact the immediate connect.
+     * It is valid to call [Client#decativate]{@link Client#deactivate} in this callback.
+     *
+     * As of version 5.1, this callback can be
+     * [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
+     * (i.e., it can return a
+     * [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)).
+     * In that case connect will be called only after the Promise is resolved.
+     * This can be used to reliably fetch credentials, access token etc. from some other service
+     * in an asynchronous way.
+     */
+    beforeConnect: () => void | Promise<void>;
+    /**
+     * Callback, invoked on every successful connection to the STOMP broker.
+     *
+     * The actual {@link FrameImpl} will be passed as parameter to the callback.
+     * Sometimes clients will like to use headers from this frame.
+     */
+    onConnect: frameCallbackType;
+    /**
+     * Callback, invoked on every successful disconnection from the STOMP broker. It will not be invoked if
+     * the STOMP broker disconnected due to an error.
+     *
+     * The actual Receipt {@link FrameImpl} acknowledging the DISCONNECT will be passed as parameter to the callback.
+     *
+     * The way STOMP protocol is designed, the connection may close/terminate without the client
+     * receiving the Receipt {@link FrameImpl} acknowledging the DISCONNECT.
+     * You might find [Client#onWebSocketClose]{@link Client#onWebSocketClose} more appropriate to watch
+     * STOMP broker disconnects.
+     */
+    onDisconnect: frameCallbackType;
+    /**
+     * Callback, invoked on an ERROR frame received from the STOMP Broker.
+     * A compliant STOMP Broker will close the connection after this type of frame.
+     * Please check broker specific documentation for exact behavior.
+     *
+     * The actual {@link IFrame} will be passed as parameter to the callback.
+     */
+    onStompError: frameCallbackType;
+    /**
+     * Callback, invoked when underlying WebSocket is closed.
+     *
+     * Actual [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
+     * is passed as parameter to the callback.
+     */
+    onWebSocketClose: closeEventCallbackType;
+    /**
+     * Callback, invoked when underlying WebSocket raises an error.
+     *
+     * Actual [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event}
+     * is passed as parameter to the callback.
+     */
+    onWebSocketError: wsErrorCallbackType;
+    /**
+     * Set it to log the actual raw communication with the broker.
+     * When unset, it logs headers of the parsed frames.
+     *
+     * Change in this effects from next broker reconnect.
+     *
+     * **Caution: this assumes that frames only have valid UTF8 strings.**
+     */
+    logRawCommunication: boolean;
+    /**
+     * By default, debug messages are discarded. To log to `console` following can be used:
+     *
+     * ```javascript
+     *        client.debug = function(str) {
+     *          console.log(str);
+     *        };
+     * ```
+     *
+     * Currently this method does not support levels of log. Be aware that the output can be quite verbose
+     * and may contain sensitive information (like passwords, tokens etc.).
+     */
+    debug: debugFnType;
+    /**
+     * Browsers do not immediately close WebSockets when `.close` is issued.
+     * This may cause reconnection to take a longer on certain type of failures.
+     * In case of incoming heartbeat failure, this experimental flag instructs the library
+     * to discard the socket immediately (even before it is actually closed).
+     */
+    discardWebsocketOnCommFailure: boolean;
+    /**
+     * version of STOMP protocol negotiated with the server, READONLY
+     */
+    readonly connectedVersion: string;
+    private _stompHandler;
+    /**
+     * if the client is active (connected or going to reconnect)
+     */
+    readonly active: boolean;
+    /**
+     * It will be called on state change.
+     *
+     * When deactivating it may go from ACTIVE to INACTIVE without entering DEACTIVATING.
+     */
+    onChangeState: (state: ActivationState) => void;
+    private _changeState;
+    private _resolveSocketClose;
+    /**
+     * Activation state.
+     *
+     * It will usually be ACTIVE or INACTIVE.
+     * When deactivating it may go from ACTIVE to INACTIVE without entering DEACTIVATING.
+     */
+    state: ActivationState;
+    private _reconnector;
+    /**
+     * Create an instance.
+     */
+    constructor(conf?: StompConfig);
+    /**
+     * Update configuration.
+     */
+    configure(conf: StompConfig): void;
+    /**
+     * Initiate the connection with the broker.
+     * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay},
+     * it will keep trying to reconnect.
+     *
+     * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts.
+     */
+    activate(): void;
+    private _connect;
+    private _createWebSocket;
+    private _schedule_reconnect;
+    /**
+     * 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}.
+     */
+    deactivate(): Promise<void>;
+    /**
+     * 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.
+     */
+    forceDisconnect(): void;
+    private _disposeStompHandler;
+    /**
+     * Send a message to a named destination. Refer to your STOMP broker documentation for types
+     * and naming of destinations.
+     *
+     * STOMP protocol specifies and suggests some headers and also allows broker specific headers.
+     *
+     * `body` must be String.
+     * You will need to covert the payload to string in case it is not string (e.g. JSON).
+     *
+     * To send a binary message body use binaryBody parameter. It should be a
+     * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
+     * Sometimes brokers may not support binary frames out of the box.
+     * Please check your broker documentation.
+     *
+     * `content-length` header is automatically added to the STOMP Frame sent to the broker.
+     * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added.
+     * For binary messages `content-length` header is always added.
+     *
+     * Caution: The broker will, most likely, report an error and disconnect if message body has NULL octet(s)
+     * and `content-length` header is missing.
+     *
+     * ```javascript
+     *        client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"});
+     *
+     *        // Only destination is mandatory parameter
+     *        client.publish({destination: "/queue/test", body: "Hello, STOMP"});
+     *
+     *        // Skip content-length header in the frame to the broker
+     *        client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true});
+     *
+     *        var binaryData = generateBinaryData(); // This need to be of type Uint8Array
+     *        // setting content-type header is not mandatory, however a good practice
+     *        client.publish({destination: '/topic/special', binaryBody: binaryData,
+     *                         headers: {'content-type': 'application/octet-stream'}});
+     * ```
+     */
+    publish(params: IPublishParams): void;
+    /**
+     * 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.
+     * The value (say receipt-id) for this header needs to be unique for each use. Typically a sequence, a UUID, a
+     * random number or a combination may be used.
+     *
+     * A complaint broker will send a RECEIPT frame when an operation has actually been completed.
+     * The operation needs to be matched based in the value of the receipt-id.
+     *
+     * This method allow watching for a receipt and invoke the callback
+     * when corresponding receipt has been received.
+     *
+     * The actual {@link FrameImpl} will be passed as parameter to the callback.
+     *
+     * Example:
+     * ```javascript
+     *        // Subscribing with acknowledgement
+     *        let receiptId = randomText();
+     *
+     *        client.watchForReceipt(receiptId, function() {
+     *          // Will be called after server acknowledges
+     *        });
+     *
+     *        client.subscribe(TEST.destination, onMessage, {receipt: receiptId});
+     *
+     *
+     *        // Publishing with acknowledgement
+     *        receiptId = randomText();
+     *
+     *        client.watchForReceipt(receiptId, function() {
+     *          // Will be called after server acknowledges
+     *        });
+     *        client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg});
+     * ```
+     */
+    watchForReceipt(receiptId: string, callback: frameCallbackType): void;
+    /**
+     * Subscribe to a STOMP Broker location. The callback will be invoked for each received message with
+     * the {@link IMessage} as argument.
+     *
+     * Note: The library will generate an unique ID if there is none provided in the headers.
+     *       To use your own ID, pass it using the headers argument.
+     *
+     * ```javascript
+     *        callback = function(message) {
+     *        // called when the client receives a STOMP message from the server
+     *          if (message.body) {
+     *            alert("got message with body " + message.body)
+     *          } else {
+     *            alert("got empty message");
+     *          }
+     *        });
+     *
+     *        var subscription = client.subscribe("/queue/test", callback);
+     *
+     *        // Explicit subscription id
+     *        var mySubId = 'my-subscription-id-001';
+     *        var subscription = client.subscribe(destination, callback, { id: mySubId });
+     * ```
+     */
+    subscribe(destination: string, callback: messageCallbackType, headers?: StompHeaders): StompSubscription;
+    /**
+     * It is preferable to unsubscribe from a subscription by calling
+     * `unsubscribe()` directly on {@link StompSubscription} returned by `client.subscribe()`:
+     *
+     * ```javascript
+     *        var subscription = client.subscribe(destination, onmessage);
+     *        // ...
+     *        subscription.unsubscribe();
+     * ```
+     *
+     * See: http://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame
+     */
+    unsubscribe(id: string, headers?: StompHeaders): void;
+    /**
+     * 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.
+     */
+    begin(transactionId?: string): ITransaction;
+    /**
+     * Commit a transaction.
+     *
+     * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on
+     * {@link ITransaction} returned by [client.begin]{@link Client#begin}.
+     *
+     * ```javascript
+     *        var tx = client.begin(txId);
+     *        //...
+     *        tx.commit();
+     * ```
+     */
+    commit(transactionId: string): void;
+    /**
+     * Abort a transaction.
+     * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on
+     * {@link ITransaction} returned by [client.begin]{@link Client#begin}.
+     *
+     * ```javascript
+     *        var tx = client.begin(txId);
+     *        //...
+     *        tx.abort();
+     * ```
+     */
+    abort(transactionId: string): void;
+    /**
+     * 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:
+     *
+     * ```javascript
+     *        var callback = function (message) {
+     *          // process the message
+     *          // acknowledge it
+     *          message.ack();
+     *        };
+     *        client.subscribe(destination, callback, {'ack': 'client'});
+     * ```
+     */
+    ack(messageId: string, subscriptionId: string, headers?: StompHeaders): void;
+    /**
+     * 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:
+     *
+     * ```javascript
+     *        var callback = function (message) {
+     *          // process the message
+     *          // an error occurs, nack it
+     *          message.nack();
+     *        };
+     *        client.subscribe(destination, callback, {'ack': 'client'});
+     * ```
+     */
+    nack(messageId: string, subscriptionId: string, headers?: StompHeaders): void;
+}

node_modules/@stomp/stompjs/esm6/client.js

@@ -0,0 +1,539 @@
+var __awaiter = (this && this.__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); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { StompHandler } from './stomp-handler';
+import { ActivationState, StompSocketState, } from './types';
+import { Versions } from './versions';
+/**
+ * STOMP Client Class.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class Client {
+    /**
+     * Create an instance.
+     */
+    constructor(conf = {}) {
+        /**
+         * STOMP versions to attempt during STOMP handshake. By default versions `1.0`, `1.1`, and `1.2` are attempted.
+         *
+         * Example:
+         * ```javascript
+         *        // Try only versions 1.0 and 1.1
+         *        client.stompVersions = new Versions(['1.0', '1.1'])
+         * ```
+         */
+        this.stompVersions = 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.
+         */
+        this.reconnectDelay = 5000;
+        /**
+         * Incoming heartbeat interval in milliseconds. Set to 0 to disable.
+         */
+        this.heartbeatIncoming = 10000;
+        /**
+         * Outgoing heartbeat interval in milliseconds. Set to 0 to disable.
+         */
+        this.heartbeatOutgoing = 10000;
+        /**
+         * This switches on a non standard behavior while sending WebSocket packets.
+         * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}.
+         * Only Java Spring brokers seems to use this mode.
+         *
+         * WebSockets, by itself, split large (text) packets,
+         * so it is not needed with a truly compliant STOMP/WebSocket broker.
+         * Actually setting it for such broker will cause large messages to fail.
+         *
+         * `false` by default.
+         *
+         * Binary frames are never split.
+         */
+        this.splitLargeFrames = false;
+        /**
+         * See [splitLargeFrames]{@link Client#splitLargeFrames}.
+         * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`.
+         */
+        this.maxWebSocketChunkSize = 8 * 1024;
+        /**
+         * Usually the
+         * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters}
+         * is automatically decided by type of the payload.
+         * Default is `false`, which should work with all compliant brokers.
+         *
+         * Set this flag to force binary frames.
+         */
+        this.forceBinaryWSFrames = false;
+        /**
+         * A bug in ReactNative chops a string on occurrence of a NULL.
+         * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}.
+         * This makes incoming WebSocket messages invalid STOMP packets.
+         * Setting this flag attempts to reverse the damage by appending a NULL.
+         * If the broker splits a large message into multiple WebSocket messages,
+         * this flag will cause data loss and abnormal termination of connection.
+         *
+         * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library.
+         */
+        this.appendMissingNULLonIncoming = false;
+        /**
+         * Activation state.
+         *
+         * It will usually be ACTIVE or INACTIVE.
+         * When deactivating it may go from ACTIVE to INACTIVE without entering DEACTIVATING.
+         */
+        this.state = ActivationState.INACTIVE;
+        // Dummy callbacks
+        const noOp = () => { };
+        this.debug = noOp;
+        this.beforeConnect = noOp;
+        this.onConnect = noOp;
+        this.onDisconnect = noOp;
+        this.onUnhandledMessage = noOp;
+        this.onUnhandledReceipt = noOp;
+        this.onUnhandledFrame = noOp;
+        this.onStompError = noOp;
+        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);
+    }
+    /**
+     * 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 === ActivationState.ACTIVE;
+    }
+    _changeState(state) {
+        this.state = state;
+        this.onChangeState(state);
+    }
+    /**
+     * Update configuration.
+     */
+    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},
+     * it will keep trying to reconnect.
+     *
+     * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts.
+     */
+    activate() {
+        if (this.state === 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(ActivationState.ACTIVE);
+        this._connect();
+    }
+    _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) {
+                // clear first
+                if (this._connectionWatcher) {
+                    clearTimeout(this._connectionWatcher);
+                }
+                this._connectionWatcher = setTimeout(() => {
+                    if (this.connected) {
+                        return;
+                    }
+                    // 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 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 === ActivationState.DEACTIVATING) {
+                        // Mark deactivation complete
+                        this._resolveSocketClose();
+                        this._resolveSocketClose = undefined;
+                        this._changeState(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();
+        });
+    }
+    _createWebSocket() {
+        let webSocket;
+        if (this.webSocketFactory) {
+            webSocket = this.webSocketFactory();
+        }
+        else {
+            webSocket = new WebSocket(this.brokerURL, this.stompVersions.protocolVersions());
+        }
+        webSocket.binaryType = 'arraybuffer';
+        return webSocket;
+    }
+    _schedule_reconnect() {
+        if (this.reconnectDelay > 0) {
+            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}.
+     */
+    deactivate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retPromise;
+            if (this.state !== ActivationState.ACTIVE) {
+                this.debug(`Already ${ActivationState[this.state]}, ignoring call to deactivate`);
+                return Promise.resolve();
+            }
+            this._changeState(ActivationState.DEACTIVATING);
+            // Clear if a reconnection was scheduled
+            if (this._reconnector) {
+                clearTimeout(this._reconnector);
+            }
+            if (this._stompHandler &&
+                this.webSocket.readyState !== 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(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.
+     */
+    forceDisconnect() {
+        if (this._stompHandler) {
+            this._stompHandler.forceDisconnect();
+        }
+    }
+    _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.
+     *
+     * STOMP protocol specifies and suggests some headers and also allows broker specific headers.
+     *
+     * `body` must be String.
+     * You will need to covert the payload to string in case it is not string (e.g. JSON).
+     *
+     * To send a binary message body use binaryBody parameter. It should be a
+     * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
+     * Sometimes brokers may not support binary frames out of the box.
+     * Please check your broker documentation.
+     *
+     * `content-length` header is automatically added to the STOMP Frame sent to the broker.
+     * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added.
+     * For binary messages `content-length` header is always added.
+     *
+     * Caution: The broker will, most likely, report an error and disconnect if message body has NULL octet(s)
+     * and `content-length` header is missing.
+     *
+     * ```javascript
+     *        client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"});
+     *
+     *        // Only destination is mandatory parameter
+     *        client.publish({destination: "/queue/test", body: "Hello, STOMP"});
+     *
+     *        // Skip content-length header in the frame to the broker
+     *        client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true});
+     *
+     *        var binaryData = generateBinaryData(); // This need to be of type Uint8Array
+     *        // setting content-type header is not mandatory, however a good practice
+     *        client.publish({destination: '/topic/special', binaryBody: binaryData,
+     *                         headers: {'content-type': 'application/octet-stream'}});
+     * ```
+     */
+    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.
+     * The value (say receipt-id) for this header needs to be unique for each use. Typically a sequence, a UUID, a
+     * random number or a combination may be used.
+     *
+     * A complaint broker will send a RECEIPT frame when an operation has actually been completed.
+     * The operation needs to be matched based in the value of the receipt-id.
+     *
+     * This method allow watching for a receipt and invoke the callback
+     * when corresponding receipt has been received.
+     *
+     * The actual {@link FrameImpl} will be passed as parameter to the callback.
+     *
+     * Example:
+     * ```javascript
+     *        // Subscribing with acknowledgement
+     *        let receiptId = randomText();
+     *
+     *        client.watchForReceipt(receiptId, function() {
+     *          // Will be called after server acknowledges
+     *        });
+     *
+     *        client.subscribe(TEST.destination, onMessage, {receipt: receiptId});
+     *
+     *
+     *        // Publishing with acknowledgement
+     *        receiptId = randomText();
+     *
+     *        client.watchForReceipt(receiptId, function() {
+     *          // Will be called after server acknowledges
+     *        });
+     *        client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg});
+     * ```
+     */
+    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.
+     *
+     * Note: The library will generate an unique ID if there is none provided in the headers.
+     *       To use your own ID, pass it using the headers argument.
+     *
+     * ```javascript
+     *        callback = function(message) {
+     *        // called when the client receives a STOMP message from the server
+     *          if (message.body) {
+     *            alert("got message with body " + message.body)
+     *          } else {
+     *            alert("got empty message");
+     *          }
+     *        });
+     *
+     *        var subscription = client.subscribe("/queue/test", callback);
+     *
+     *        // Explicit subscription id
+     *        var mySubId = 'my-subscription-id-001';
+     *        var subscription = client.subscribe(destination, callback, { id: mySubId });
+     * ```
+     */
+    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()`:
+     *
+     * ```javascript
+     *        var subscription = client.subscribe(destination, onmessage);
+     *        // ...
+     *        subscription.unsubscribe();
+     * ```
+     *
+     * See: http://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame
+     */
+    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.
+     */
+    begin(transactionId) {
+        return this._stompHandler.begin(transactionId);
+    }
+    /**
+     * Commit a transaction.
+     *
+     * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on
+     * {@link ITransaction} returned by [client.begin]{@link Client#begin}.
+     *
+     * ```javascript
+     *        var tx = client.begin(txId);
+     *        //...
+     *        tx.commit();
+     * ```
+     */
+    commit(transactionId) {
+        this._stompHandler.commit(transactionId);
+    }
+    /**
+     * Abort a transaction.
+     * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on
+     * {@link ITransaction} returned by [client.begin]{@link Client#begin}.
+     *
+     * ```javascript
+     *        var tx = client.begin(txId);
+     *        //...
+     *        tx.abort();
+     * ```
+     */
+    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:
+     *
+     * ```javascript
+     *        var callback = function (message) {
+     *          // process the message
+     *          // acknowledge it
+     *          message.ack();
+     *        };
+     *        client.subscribe(destination, callback, {'ack': 'client'});
+     * ```
+     */
+    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:
+     *
+     * ```javascript
+     *        var callback = function (message) {
+     *          // process the message
+     *          // an error occurs, nack it
+     *          message.nack();
+     *        };
+     *        client.subscribe(destination, callback, {'ack': 'client'});
+     * ```
+     */
+    nack(messageId, subscriptionId, headers = {}) {
+        this._stompHandler.nack(messageId, subscriptionId, headers);
+    }
+}
+//# sourceMappingURL=client.js.map

node_modules/@stomp/stompjs/esm6/compatibility/compat-client.d.ts

@@ -0,0 +1,149 @@
+import { Client } from '../client';
+import { StompHeaders } from '../stomp-headers';
+import { frameCallbackType, messageCallbackType } from '../types';
+/**
+ * Available for backward compatibility, please shift to using {@link Client}.
+ *
+ * **Deprecated**
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+ */
+export declare class CompatClient extends Client {
+    /**
+     * It is no op now. No longer needed. Large packets work out of the box.
+     */
+    maxWebSocketFrameSize: number;
+    /**
+     * Available for backward compatibility, please shift to using {@link Client}
+     * and [Client#webSocketFactory]{@link Client#webSocketFactory}.
+     *
+     * **Deprecated**
+     *
+     * @internal
+     */
+    constructor(webSocketFactory: () => any);
+    private _parseConnect;
+    /**
+     * Available for backward compatibility, please shift to using [Client#activate]{@link Client#activate}.
+     *
+     * **Deprecated**
+     *
+     * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the
+     * version with headers to pass your broker specific options.
+     *
+     * overloads:
+     * - connect(headers, connectCallback)
+     * - connect(headers, connectCallback, errorCallback)
+     * - connect(login, passcode, connectCallback)
+     * - connect(login, passcode, connectCallback, errorCallback)
+     * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback)
+     * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host)
+     *
+     * params:
+     * - headers, see [Client#connectHeaders]{@link Client#connectHeaders}
+     * - connectCallback, see [Client#onConnect]{@link Client#onConnect}
+     * - errorCallback, see [Client#onStompError]{@link Client#onStompError}
+     * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose}
+     * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders)
+     * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders)
+     * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders)
+     *
+     * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+     */
+    connect(...args: any[]): void;
+    /**
+     * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}.
+     *
+     * **Deprecated**
+     *
+     * See:
+     * [Client#onDisconnect]{@link Client#onDisconnect}, and
+     * [Client#disconnectHeaders]{@link Client#disconnectHeaders}
+     *
+     * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+     */
+    disconnect(disconnectCallback?: any, headers?: StompHeaders): void;
+    /**
+     * Available for backward compatibility, use [Client#publish]{@link Client#publish}.
+     *
+     * Send a message to a named destination. Refer to your STOMP broker documentation for types
+     * and naming of destinations. The headers will, typically, be available to the subscriber.
+     * However, there may be special purpose headers corresponding to your STOMP broker.
+     *
+     *  **Deprecated**, use [Client#publish]{@link Client#publish}
+     *
+     * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON)
+     *
+     * ```javascript
+     *        client.send("/queue/test", {priority: 9}, "Hello, STOMP");
+     *
+     *        // If you want to send a message with a body, you must also pass the headers argument.
+     *        client.send("/queue/test", {}, "Hello, STOMP");
+     * ```
+     *
+     * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+     */
+    send(destination: string, headers?: {
+        [key: string]: any;
+    }, body?: string): void;
+    /**
+     * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}.
+     *
+     * **Deprecated**
+     */
+    reconnect_delay: number;
+    /**
+     * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}.
+     *
+     * **Deprecated**
+     */
+    readonly ws: any;
+    /**
+     * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}.
+     *
+     * **Deprecated**
+     */
+    readonly version: string;
+    /**
+     * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+     *
+     * **Deprecated**
+     */
+    /**
+    * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+    *
+    * **Deprecated**
+    */
+    onreceive: messageCallbackType;
+    /**
+     * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+     * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}.
+     *
+     * **Deprecated**
+     */
+    /**
+    * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+    *
+    * **Deprecated**
+    */
+    onreceipt: frameCallbackType;
+    private _heartbeatInfo;
+    /**
+     * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}
+     * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
+     *
+     * **Deprecated**
+     */
+    /**
+    * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}
+    * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
+    *
+    * **Deprecated**
+    */
+    heartbeat: {
+        incoming: number;
+        outgoing: number;
+    };
+}

node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js

@@ -0,0 +1,241 @@
+import { Client } from '../client';
+import { HeartbeatInfo } from './heartbeat-info';
+/**
+ * Available for backward compatibility, please shift to using {@link Client}.
+ *
+ * **Deprecated**
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+ */
+export class CompatClient extends Client {
+    /**
+     * Available for backward compatibility, please shift to using {@link Client}
+     * and [Client#webSocketFactory]{@link Client#webSocketFactory}.
+     *
+     * **Deprecated**
+     *
+     * @internal
+     */
+    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 HeartbeatInfo(this);
+        this.reconnect_delay = 0;
+        this.webSocketFactory = webSocketFactory;
+        // Default from previous version
+        this.debug = (...message) => {
+            console.log(...message);
+        };
+    }
+    _parseConnect(...args) {
+        let closeEventCallback;
+        let connectCallback;
+        let errorCallback;
+        let headers = {};
+        if (args.length < 2) {
+            throw new Error('Connect requires at least 2 arguments');
+        }
+        if (typeof args[1] === 'function') {
+            [headers, connectCallback, errorCallback, closeEventCallback] = args;
+        }
+        else {
+            switch (args.length) {
+                case 6:
+                    [
+                        headers.login,
+                        headers.passcode,
+                        connectCallback,
+                        errorCallback,
+                        closeEventCallback,
+                        headers.host,
+                    ] = args;
+                    break;
+                default:
+                    [
+                        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}.
+     *
+     * **Deprecated**
+     *
+     * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the
+     * version with headers to pass your broker specific options.
+     *
+     * overloads:
+     * - connect(headers, connectCallback)
+     * - connect(headers, connectCallback, errorCallback)
+     * - connect(login, passcode, connectCallback)
+     * - connect(login, passcode, connectCallback, errorCallback)
+     * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback)
+     * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host)
+     *
+     * params:
+     * - headers, see [Client#connectHeaders]{@link Client#connectHeaders}
+     * - connectCallback, see [Client#onConnect]{@link Client#onConnect}
+     * - errorCallback, see [Client#onStompError]{@link Client#onStompError}
+     * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose}
+     * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders)
+     * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders)
+     * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders)
+     *
+     * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+     */
+    connect(...args) {
+        const out = this._parseConnect(...args);
+        if (out[0]) {
+            this.connectHeaders = out[0];
+        }
+        if (out[1]) {
+            this.onConnect = out[1];
+        }
+        if (out[2]) {
+            this.onStompError = out[2];
+        }
+        if (out[3]) {
+            this.onWebSocketClose = out[3];
+        }
+        super.activate();
+    }
+    /**
+     * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}.
+     *
+     * **Deprecated**
+     *
+     * See:
+     * [Client#onDisconnect]{@link Client#onDisconnect}, and
+     * [Client#disconnectHeaders]{@link Client#disconnectHeaders}
+     *
+     * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+     */
+    disconnect(disconnectCallback, headers = {}) {
+        if (disconnectCallback) {
+            this.onDisconnect = disconnectCallback;
+        }
+        this.disconnectHeaders = headers;
+        super.deactivate();
+    }
+    /**
+     * Available for backward compatibility, use [Client#publish]{@link Client#publish}.
+     *
+     * Send a message to a named destination. Refer to your STOMP broker documentation for types
+     * and naming of destinations. The headers will, typically, be available to the subscriber.
+     * However, there may be special purpose headers corresponding to your STOMP broker.
+     *
+     *  **Deprecated**, use [Client#publish]{@link Client#publish}
+     *
+     * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON)
+     *
+     * ```javascript
+     *        client.send("/queue/test", {priority: 9}, "Hello, STOMP");
+     *
+     *        // If you want to send a message with a body, you must also pass the headers argument.
+     *        client.send("/queue/test", {}, "Hello, STOMP");
+     * ```
+     *
+     * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+     */
+    send(destination, headers = {}, body = '') {
+        headers = Object.assign({}, headers);
+        const skipContentLengthHeader = headers['content-length'] === false;
+        if (skipContentLengthHeader) {
+            delete headers['content-length'];
+        }
+        this.publish({
+            destination,
+            headers: headers,
+            body,
+            skipContentLengthHeader,
+        });
+    }
+    /**
+     * 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;
+    }
+}
+//# sourceMappingURL=compat-client.js.map

node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat-client.js","sourceRoot":"","sources":["../../src/compatibility/compat-client.ts"],"names":[],"mappings":"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"}

node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.d.ts

@@ -0,0 +1,12 @@
+import { CompatClient } from './compat-client';
+/**
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export declare class HeartbeatInfo {
+    private client;
+    constructor(client: CompatClient);
+    outgoing: number;
+    incoming: number;
+}

node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js

@@ -0,0 +1,23 @@
+/**
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export class HeartbeatInfo {
+    constructor(client) {
+        this.client = client;
+    }
+    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;
+    }
+}
+//# sourceMappingURL=heartbeat-info.js.map

node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat-info.js","sourceRoot":"","sources":["../../src/compatibility/heartbeat-info.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,OAAO,aAAa;IACxB,YAAoB,MAAoB;QAApB,WAAM,GAAN,MAAM,CAAc;IAAG,CAAC;IAE5C,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;IACvC,CAAC;IAED,IAAI,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACxC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;IACvC,CAAC;IAED,IAAI,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACxC,CAAC;CACF"}

node_modules/@stomp/stompjs/esm6/compatibility/stomp.d.ts

@@ -0,0 +1,67 @@
+import { CompatClient } from './compat-client';
+/**
+ * STOMP Class, acts like a factory to create {@link Client}.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * **Deprecated**
+ *
+ * It will be removed in next major version. Please switch to {@link Client}.
+ */
+export declare class Stomp {
+    /**
+     * 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}.
+     */
+    static WebSocketClass: any;
+    /**
+     * This method creates a WebSocket client that is connected to
+     * the STOMP server located at the url.
+     *
+     * ```javascript
+     *        var url = "ws://localhost:61614/stomp";
+     *        var client = Stomp.client(url);
+     * ```
+     *
+     * **Deprecated**
+     *
+     * It will be removed in next major version. Please switch to {@link Client}
+     * using [Client#brokerURL]{@link Client#brokerURL}.
+     */
+    static client(url: string, protocols?: string[]): CompatClient;
+    /**
+     * 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
+     * a similar object).
+     *
+     * In order to support reconnection, the function Client._connect should be callable more than once.
+     * While reconnecting
+     * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function
+     * alternatively allows passing a function that should return a new instance of the underlying socket.
+     *
+     * ```javascript
+     *        var client = Stomp.over(function(){
+     *          return new WebSocket('ws://localhost:15674/ws')
+     *        });
+     * ```
+     *
+     * **Deprecated**
+     *
+     * It will be removed in next major version. Please switch to {@link Client}
+     * using [Client#webSocketFactory]{@link Client#webSocketFactory}.
+     */
+    static over(ws: any): CompatClient;
+}

node_modules/@stomp/stompjs/esm6/compatibility/stomp.js

@@ -0,0 +1,102 @@
+import { Versions } from '../versions';
+import { CompatClient } from './compat-client';
+/**
+ * STOMP Class, acts like a factory to create {@link Client}.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * **Deprecated**
+ *
+ * It will be removed in next major version. Please switch to {@link Client}.
+ */
+export class Stomp {
+    /**
+     * This method creates a WebSocket client that is connected to
+     * the STOMP server located at the url.
+     *
+     * ```javascript
+     *        var url = "ws://localhost:61614/stomp";
+     *        var client = Stomp.client(url);
+     * ```
+     *
+     * **Deprecated**
+     *
+     * It will be removed in next major version. Please switch to {@link Client}
+     * using [Client#brokerURL]{@link Client#brokerURL}.
+     */
+    static client(url, protocols) {
+        // This is a hack to allow another implementation than the standard
+        // HTML5 WebSocket class.
+        //
+        // It is possible to use another class by calling
+        //
+        //     Stomp.WebSocketClass = MozWebSocket
+        //
+        // *prior* to call `Stomp.client()`.
+        //
+        // This hack is deprecated and `Stomp.over()` method should be used
+        // instead.
+        // See remarks on the function Stomp.over
+        if (protocols == null) {
+            protocols = Versions.default.protocolVersions();
+        }
+        const wsFn = () => {
+            const klass = Stomp.WebSocketClass || WebSocket;
+            return new klass(url, protocols);
+        };
+        return new 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
+     * a similar object).
+     *
+     * In order to support reconnection, the function Client._connect should be callable more than once.
+     * While reconnecting
+     * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function
+     * alternatively allows passing a function that should return a new instance of the underlying socket.
+     *
+     * ```javascript
+     *        var client = Stomp.over(function(){
+     *          return new WebSocket('ws://localhost:15674/ws')
+     *        });
+     * ```
+     *
+     * **Deprecated**
+     *
+     * It will be removed in next major version. Please switch to {@link Client}
+     * using [Client#webSocketFactory]{@link Client#webSocketFactory}.
+     */
+    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 = () => ws;
+        }
+        return new 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;
+//# sourceMappingURL=stomp.js.map

node_modules/@stomp/stompjs/esm6/compatibility/stomp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stomp.js","sourceRoot":"","sources":["../../src/compatibility/stomp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAW/C;;;;;;;;GAQG;AACH,MAAM,OAAO,KAAK;IAqBhB;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,MAAM,CAAC,GAAW,EAAE,SAAoB;QACpD,mEAAmE;QACnE,yBAAyB;QACzB,EAAE;QACF,iDAAiD;QACjD,EAAE;QACF,0CAA0C;QAC1C,EAAE;QACF,oCAAoC;QACpC,EAAE;QACF,mEAAmE;QACnE,WAAW;QAEX,yCAAyC;QACzC,IAAI,SAAS,IAAI,IAAI,EAAE;YACrB,SAAS,GAAG,QAAQ,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;SACjD;QACD,MAAM,IAAI,GAAG,GAAG,EAAE;YAChB,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,IAAI,SAAS,CAAC;YAChD,OAAO,IAAI,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QACnC,CAAC,CAAC;QAEF,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,MAAM,CAAC,IAAI,CAAC,EAAO;QACxB,IAAI,IAAe,CAAC;QAEpB,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE;YAC5B,IAAI,GAAG,EAAE,CAAC;SACX;aAAM;YACL,OAAO,CAAC,IAAI,CACV,sEAAsE;gBACpE,+EAA+E,CAClF,CAAC;YACF,IAAI,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC;SACjB;QAED,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;;AA9FD;;;;;;;;;;;;;;;;GAgBG;AACH,yCAAyC;AAC3B,oBAAc,GAAQ,IAAI,CAAC"}

node_modules/@stomp/stompjs/esm6/frame-impl.d.ts

@@ -0,0 +1,95 @@
+import { IFrame } from './i-frame';
+import { StompHeaders } from './stomp-headers';
+import { IRawFrameType } from './types';
+/**
+ * Frame class represents a STOMP frame.
+ *
+ * @internal
+ */
+export declare class FrameImpl implements IFrame {
+    /**
+     * STOMP Command
+     */
+    command: string;
+    /**
+     * Headers, key value pairs.
+     */
+    headers: StompHeaders;
+    /**
+     * Is this frame binary (based on whether body/binaryBody was passed when creating this frame).
+     */
+    isBinaryBody: boolean;
+    /**
+     * body of the frame
+     */
+    readonly body: string;
+    private _body;
+    /**
+     * body as Uint8Array
+     */
+    readonly binaryBody: Uint8Array;
+    private _binaryBody;
+    private escapeHeaderValues;
+    private skipContentLengthHeader;
+    /**
+     * Frame constructor. `command`, `headers` and `body` are available as properties.
+     *
+     * @internal
+     */
+    constructor(params: {
+        command: string;
+        headers?: StompHeaders;
+        body?: string;
+        binaryBody?: Uint8Array;
+        escapeHeaderValues?: boolean;
+        skipContentLengthHeader?: boolean;
+    });
+    /**
+     * deserialize a STOMP Frame from raw data.
+     *
+     * @internal
+     */
+    static fromRawFrame(rawFrame: IRawFrameType, escapeHeaderValues: boolean): FrameImpl;
+    /**
+     * @internal
+     */
+    toString(): string;
+    /**
+     * serialize this Frame in a format suitable to be passed to WebSocket.
+     * If the body is string the output will be string.
+     * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer.
+     *
+     * @internal
+     */
+    serialize(): string | ArrayBuffer;
+    private serializeCmdAndHeaders;
+    private isBodyEmpty;
+    private bodyLength;
+    /**
+     * Compute the size of a UTF-8 string by counting its number of bytes
+     * (and not the number of characters composing the string)
+     */
+    private static sizeOfUTF8;
+    private static toUnit8Array;
+    /**
+     * Serialize a STOMP frame as per STOMP standards, suitable to be sent to the STOMP broker.
+     *
+     * @internal
+     */
+    static marshall(params: {
+        command: string;
+        headers?: StompHeaders;
+        body?: string;
+        binaryBody?: Uint8Array;
+        escapeHeaderValues?: boolean;
+        skipContentLengthHeader?: boolean;
+    }): string | ArrayBuffer;
+    /**
+     *  Escape header values
+     */
+    private static hdrValueEscape;
+    /**
+     * UnEscape header values
+     */
+    private static hdrValueUnEscape;
+}

node_modules/@stomp/stompjs/esm6/frame-impl.js

@@ -0,0 +1,170 @@
+import { BYTE } from './byte';
+/**
+ * Frame class represents a STOMP frame.
+ *
+ * @internal
+ */
+export class FrameImpl {
+    /**
+     * Frame constructor. `command`, `headers` and `body` are available as properties.
+     *
+     * @internal
+     */
+    constructor(params) {
+        const { command, headers, body, binaryBody, escapeHeaderValues, skipContentLengthHeader, } = params;
+        this.command = command;
+        this.headers = Object.assign({}, headers || {});
+        if (binaryBody) {
+            this._binaryBody = binaryBody;
+            this.isBinaryBody = true;
+        }
+        else {
+            this._body = body || '';
+            this.isBinaryBody = false;
+        }
+        this.escapeHeaderValues = escapeHeaderValues || false;
+        this.skipContentLengthHeader = skipContentLengthHeader || false;
+    }
+    /**
+     * 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
+     */
+    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 (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,
+            binaryBody: rawFrame.binaryBody,
+            escapeHeaderValues,
+        });
+    }
+    /**
+     * @internal
+     */
+    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.
+     * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer.
+     *
+     * @internal
+     */
+    serialize() {
+        const cmdAndHeaders = this.serializeCmdAndHeaders();
+        if (this.isBinaryBody) {
+            return FrameImpl.toUnit8Array(cmdAndHeaders, this._binaryBody).buffer;
+        }
+        else {
+            return cmdAndHeaders + this._body + BYTE.NULL;
+        }
+    }
+    serializeCmdAndHeaders() {
+        const lines = [this.command];
+        if (this.skipContentLengthHeader) {
+            delete this.headers['content-length'];
+        }
+        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}:${value}`);
+            }
+        }
+        if (this.isBinaryBody ||
+            (!this.isBodyEmpty() && !this.skipContentLengthHeader)) {
+            lines.push(`content-length:${this.bodyLength()}`);
+        }
+        return lines.join(BYTE.LF) + BYTE.LF + BYTE.LF;
+    }
+    isBodyEmpty() {
+        return this.bodyLength() === 0;
+    }
+    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)
+     */
+    static sizeOfUTF8(s) {
+        return s ? new TextEncoder().encode(s).length : 0;
+    }
+    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
+     */
+    static marshall(params) {
+        const frame = new FrameImpl(params);
+        return frame.serialize();
+    }
+    /**
+     *  Escape header values
+     */
+    static hdrValueEscape(str) {
+        return str
+            .replace(/\\/g, '\\\\')
+            .replace(/\r/g, '\\r')
+            .replace(/\n/g, '\\n')
+            .replace(/:/g, '\\c');
+    }
+    /**
+     * UnEscape header values
+     */
+    static hdrValueUnEscape(str) {
+        return str
+            .replace(/\\r/g, '\r')
+            .replace(/\\n/g, '\n')
+            .replace(/\\c/g, ':')
+            .replace(/\\\\/g, '\\');
+    }
+}
+//# sourceMappingURL=frame-impl.js.map

node_modules/@stomp/stompjs/esm6/frame-impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-impl.js","sourceRoot":"","sources":["../src/frame-impl.ts"],"names":[],"mappings":"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"}

node_modules/@stomp/stompjs/esm6/i-frame.d.ts

@@ -0,0 +1,35 @@
+import { StompHeaders } from './stomp-headers';
+/**
+ * It represents a STOMP frame. Many of the callbacks pass an IFrame received from
+ * the STOMP broker. For advanced usage you might need to access [headers]{@link IFrame#headers}.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * {@link IMessage} is an extended IFrame.
+ */
+export interface IFrame {
+    /**
+     * STOMP Command
+     */
+    command: string;
+    /**
+     * Headers, key value pairs.
+     */
+    headers: StompHeaders;
+    /**
+     * Is this frame binary (based on whether body/binaryBody was passed when creating this frame).
+     */
+    isBinaryBody: boolean;
+    /**
+     * body of the frame as string
+     */
+    readonly body: string;
+    /**
+     * body as Uint8Array
+     */
+    readonly binaryBody: Uint8Array;
+}
+/**
+ * Alias for {@link IFrame}
+ */
+export declare type Frame = IFrame;

node_modules/@stomp/stompjs/esm6/i-frame.js

@@ -0,0 +1 @@
+//# sourceMappingURL=i-frame.js.map

node_modules/@stomp/stompjs/esm6/i-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-frame.js","sourceRoot":"","sources":["../src/i-frame.ts"],"names":[],"mappings":""}

node_modules/@stomp/stompjs/esm6/i-message.d.ts

@@ -0,0 +1,32 @@
+import { IFrame } from './i-frame';
+import { StompHeaders } from './stomp-headers';
+/**
+ * Instance of Message will be passed to [subscription callback]{@link Client#subscribe}
+ * and [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+ * Since it is an extended {@link FrameImpl}, you can access [headers]{@link FrameImpl#headers}
+ * and [body]{@link FrameImpl#body} as properties.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * See [Client#subscribe]{@link Client#subscribe} for example.
+ */
+export interface IMessage extends IFrame {
+    /**
+     * When subscribing with manual acknowledgement, call this method on the message to ACK the message.
+     *
+     * See [Client#ack]{@link Client#ack} for an example.
+     */
+    ack: (headers?: StompHeaders) => void;
+    /**
+     * When subscribing with manual acknowledgement, call this method on the message to NACK the message.
+     *
+     * See [Client#nack]{@link Client#nack} for an example.
+     */
+    nack: (headers?: StompHeaders) => void;
+}
+/**
+ * Aliased to {@link IMessage}.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare type Message = IMessage;

node_modules/@stomp/stompjs/esm6/i-message.js

@@ -0,0 +1 @@
+//# sourceMappingURL=i-message.js.map

node_modules/@stomp/stompjs/esm6/i-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-message.js","sourceRoot":"","sources":["../src/i-message.ts"],"names":[],"mappings":""}

node_modules/@stomp/stompjs/esm6/i-transaction.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A Transaction is created by calling [Client#begin]{@link Client#begin}
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * TODO: Example and caveat
+ */
+export interface ITransaction {
+    /**
+     * You will need to access this to send, ack, or nack within this transaction.
+     */
+    id: string;
+    /**
+     * Commit this transaction. See [Client#commit]{@link Client#commit} for an example.
+     */
+    commit: () => void;
+    /**
+     * Abort this transaction. See [Client#abort]{@link Client#abort} for an example.
+     */
+    abort: () => void;
+}

node_modules/@stomp/stompjs/esm6/i-transaction.js

@@ -0,0 +1 @@
+//# sourceMappingURL=i-transaction.js.map

node_modules/@stomp/stompjs/esm6/i-transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-transaction.js","sourceRoot":"","sources":["../src/i-transaction.ts"],"names":[],"mappings":""}

node_modules/@stomp/stompjs/esm6/index.d.ts

@@ -0,0 +1,13 @@
+export * from './client';
+export * from './frame-impl';
+export * from './i-frame';
+export * from './i-message';
+export * from './parser';
+export * from './stomp-config';
+export * from './stomp-headers';
+export * from './stomp-subscription';
+export * from './i-transaction';
+export * from './types';
+export * from './versions';
+export * from './compatibility/compat-client';
+export * from './compatibility/stomp';

node_modules/@stomp/stompjs/esm6/index.js

@@ -0,0 +1,12 @@
+export * from './client';
+export * from './frame-impl';
+export * from './parser';
+export * from './stomp-config';
+export * from './stomp-headers';
+export * from './stomp-subscription';
+export * from './types';
+export * from './versions';
+// Compatibility code
+export * from './compatibility/compat-client';
+export * from './compatibility/stomp';
+//# sourceMappingURL=index.js.map

node_modules/@stomp/stompjs/esm6/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAG7B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AAErC,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAE3B,qBAAqB;AACrB,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC"}

node_modules/@stomp/stompjs/esm6/parser.d.ts

@@ -0,0 +1,70 @@
+import { IRawFrameType } from './types';
+/**
+ * This is an evented, rec descent parser.
+ * A stream of Octets can be passed and whenever it recognizes
+ * a complete Frame or an incoming ping it will invoke the registered callbacks.
+ *
+ * All incoming Octets are fed into _onByte function.
+ * Depending on current state the _onByte function keeps changing.
+ * Depending on the state it keeps accumulating into _token and _results.
+ * State is indicated by current value of _onByte, all states are named as _collect.
+ *
+ * STOMP standards https://stomp.github.io/stomp-specification-1.2.html
+ * imply that all lengths are considered in bytes (instead of string lengths).
+ * So, before actual parsing, if the incoming data is String it is converted to Octets.
+ * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body.
+ *
+ * There is no peek function on the incoming data.
+ * When a state change occurs based on an Octet without consuming the Octet,
+ * the Octet, after state change, is fed again (_reinjectByte).
+ * This became possible as the state change can be determined by inspecting just one Octet.
+ *
+ * There are two modes to collect the body, if content-length header is there then it by counting Octets
+ * otherwise it is determined by NULL terminator.
+ *
+ * Following the standards, the command and headers are converted to Strings
+ * and the body is returned as Octets.
+ * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header.
+ *
+ * This parser does not use Regular Expressions as that can only operate on Strings.
+ *
+ * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or
+ * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk
+ * is pushed.
+ *
+ * Typically the higher level function will convert headers to Hash, handle unescaping of header values
+ * (which is protocol version specific), and convert body to text.
+ *
+ * Check the parser.spec.js to understand cases that this parser is supposed to handle.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export declare class Parser {
+    onFrame: (rawFrame: IRawFrameType) => void;
+    onIncomingPing: () => void;
+    private readonly _encoder;
+    private readonly _decoder;
+    private _results;
+    private _token;
+    private _headerKey;
+    private _bodyBytesRemaining;
+    private _onByte;
+    constructor(onFrame: (rawFrame: IRawFrameType) => void, onIncomingPing: () => void);
+    parseChunk(segment: string | ArrayBuffer, appendMissingNULLonIncoming?: boolean): void;
+    private _collectFrame;
+    private _collectCommand;
+    private _collectHeaders;
+    private _reinjectByte;
+    private _collectHeaderKey;
+    private _collectHeaderValue;
+    private _setupCollectBody;
+    private _collectBodyNullTerminated;
+    private _collectBodyFixedSize;
+    private _retrievedBody;
+    private _consumeByte;
+    private _consumeTokenAsUTF8;
+    private _consumeTokenAsRaw;
+    private _initState;
+}

node_modules/@stomp/stompjs/esm6/parser.js

@@ -0,0 +1,214 @@
+/**
+ * @internal
+ */
+const NULL = 0;
+/**
+ * @internal
+ */
+const LF = 10;
+/**
+ * @internal
+ */
+const CR = 13;
+/**
+ * @internal
+ */
+const COLON = 58;
+/**
+ * This is an evented, rec descent parser.
+ * A stream of Octets can be passed and whenever it recognizes
+ * a complete Frame or an incoming ping it will invoke the registered callbacks.
+ *
+ * All incoming Octets are fed into _onByte function.
+ * Depending on current state the _onByte function keeps changing.
+ * Depending on the state it keeps accumulating into _token and _results.
+ * State is indicated by current value of _onByte, all states are named as _collect.
+ *
+ * STOMP standards https://stomp.github.io/stomp-specification-1.2.html
+ * imply that all lengths are considered in bytes (instead of string lengths).
+ * So, before actual parsing, if the incoming data is String it is converted to Octets.
+ * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body.
+ *
+ * There is no peek function on the incoming data.
+ * When a state change occurs based on an Octet without consuming the Octet,
+ * the Octet, after state change, is fed again (_reinjectByte).
+ * This became possible as the state change can be determined by inspecting just one Octet.
+ *
+ * There are two modes to collect the body, if content-length header is there then it by counting Octets
+ * otherwise it is determined by NULL terminator.
+ *
+ * Following the standards, the command and headers are converted to Strings
+ * and the body is returned as Octets.
+ * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header.
+ *
+ * This parser does not use Regular Expressions as that can only operate on Strings.
+ *
+ * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or
+ * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk
+ * is pushed.
+ *
+ * Typically the higher level function will convert headers to Hash, handle unescaping of header values
+ * (which is protocol version specific), and convert body to text.
+ *
+ * Check the parser.spec.js to understand cases that this parser is supposed to handle.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export class Parser {
+    constructor(onFrame, onIncomingPing) {
+        this.onFrame = onFrame;
+        this.onIncomingPing = onIncomingPing;
+        this._encoder = new TextEncoder();
+        this._decoder = new TextDecoder();
+        this._token = [];
+        this._initState();
+    }
+    parseChunk(segment, appendMissingNULLonIncoming = false) {
+        let chunk;
+        if (segment instanceof ArrayBuffer) {
+            chunk = new Uint8Array(segment);
+        }
+        else {
+            chunk = this._encoder.encode(segment);
+        }
+        // See https://github.com/stomp-js/stompjs/issues/89
+        // Remove when underlying issue is fixed.
+        //
+        // Send a NULL byte, if the last byte of a Text frame was not NULL.F
+        if (appendMissingNULLonIncoming && chunk[chunk.length - 1] !== 0) {
+            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 (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
+    _collectFrame(byte) {
+        if (byte === NULL) {
+            // Ignore
+            return;
+        }
+        if (byte === CR) {
+            // Ignore CR
+            return;
+        }
+        if (byte === LF) {
+            // Incoming Ping
+            this.onIncomingPing();
+            return;
+        }
+        this._onByte = this._collectCommand;
+        this._reinjectByte(byte);
+    }
+    _collectCommand(byte) {
+        if (byte === CR) {
+            // Ignore CR
+            return;
+        }
+        if (byte === LF) {
+            this._results.command = this._consumeTokenAsUTF8();
+            this._onByte = this._collectHeaders;
+            return;
+        }
+        this._consumeByte(byte);
+    }
+    _collectHeaders(byte) {
+        if (byte === CR) {
+            // Ignore CR
+            return;
+        }
+        if (byte === LF) {
+            this._setupCollectBody();
+            return;
+        }
+        this._onByte = this._collectHeaderKey;
+        this._reinjectByte(byte);
+    }
+    _reinjectByte(byte) {
+        this._onByte(byte);
+    }
+    _collectHeaderKey(byte) {
+        if (byte === COLON) {
+            this._headerKey = this._consumeTokenAsUTF8();
+            this._onByte = this._collectHeaderValue;
+            return;
+        }
+        this._consumeByte(byte);
+    }
+    _collectHeaderValue(byte) {
+        if (byte === CR) {
+            // Ignore CR
+            return;
+        }
+        if (byte === LF) {
+            this._results.headers.push([this._headerKey, this._consumeTokenAsUTF8()]);
+            this._headerKey = undefined;
+            this._onByte = this._collectHeaders;
+            return;
+        }
+        this._consumeByte(byte);
+    }
+    _setupCollectBody() {
+        const contentLengthHeader = this._results.headers.filter((header) => {
+            return header[0] === 'content-length';
+        })[0];
+        if (contentLengthHeader) {
+            this._bodyBytesRemaining = parseInt(contentLengthHeader[1], 10);
+            this._onByte = this._collectBodyFixedSize;
+        }
+        else {
+            this._onByte = this._collectBodyNullTerminated;
+        }
+    }
+    _collectBodyNullTerminated(byte) {
+        if (byte === NULL) {
+            this._retrievedBody();
+            return;
+        }
+        this._consumeByte(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);
+    }
+    _retrievedBody() {
+        this._results.binaryBody = this._consumeTokenAsRaw();
+        this.onFrame(this._results);
+        this._initState();
+    }
+    // Rec Descent Parser helpers
+    _consumeByte(byte) {
+        this._token.push(byte);
+    }
+    _consumeTokenAsUTF8() {
+        return this._decoder.decode(this._consumeTokenAsRaw());
+    }
+    _consumeTokenAsRaw() {
+        const rawResult = new Uint8Array(this._token);
+        this._token = [];
+        return rawResult;
+    }
+    _initState() {
+        this._results = {
+            command: undefined,
+            headers: [],
+            binaryBody: undefined,
+        };
+        this._token = [];
+        this._headerKey = undefined;
+        this._onByte = this._collectFrame;
+    }
+}
+//# sourceMappingURL=parser.js.map

node_modules/@stomp/stompjs/esm6/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"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"}

node_modules/@stomp/stompjs/esm6/stomp-config.d.ts

@@ -0,0 +1,119 @@
+import { StompHeaders } from './stomp-headers';
+import { ActivationState, closeEventCallbackType, debugFnType, frameCallbackType, messageCallbackType, wsErrorCallbackType } from './types';
+import { Versions } from './versions';
+/**
+ * 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`.
+ */
+export declare class StompConfig {
+    /**
+     * See [Client#brokerURL]{@link Client#brokerURL}.
+     */
+    brokerURL?: string;
+    /**
+     * See See [Client#stompVersions]{@link Client#stompVersions}.
+     */
+    stompVersions?: Versions;
+    /**
+     * See [Client#webSocketFactory]{@link Client#webSocketFactory}.
+     */
+    webSocketFactory?: () => any;
+    /**
+     * See [Client#connectionTimeout]{@link Client#connectionTimeout}.
+     */
+    connectionTimeout?: number;
+    /**
+     * See [Client#reconnectDelay]{@link Client#reconnectDelay}.
+     */
+    reconnectDelay?: number;
+    /**
+     * See [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}.
+     */
+    heartbeatIncoming?: number;
+    /**
+     * See [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
+     */
+    heartbeatOutgoing?: number;
+    /**
+     * See [Client#splitLargeFrames]{@link Client#splitLargeFrames}.
+     */
+    splitLargeFrames?: boolean;
+    /**
+     * See [Client#forceBinaryWSFrames]{@link Client#forceBinaryWSFrames}.
+     */
+    forceBinaryWSFrames?: boolean;
+    /**
+     * See [Client#appendMissingNULLonIncoming]{@link Client#appendMissingNULLonIncoming}.
+     */
+    appendMissingNULLonIncoming?: boolean;
+    /**
+     * See [Client#maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}.
+     */
+    maxWebSocketChunkSize?: number;
+    /**
+     * See [Client#connectHeaders]{@link Client#connectHeaders}.
+     */
+    connectHeaders?: StompHeaders;
+    /**
+     * See [Client#disconnectHeaders]{@link Client#disconnectHeaders}.
+     */
+    disconnectHeaders?: StompHeaders;
+    /**
+     * See [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+     */
+    onUnhandledMessage?: messageCallbackType;
+    /**
+     * See [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+     */
+    onUnhandledReceipt?: frameCallbackType;
+    /**
+     * See [Client#onUnhandledFrame]{@link Client#onUnhandledFrame}.
+     */
+    onUnhandledFrame?: frameCallbackType;
+    /**
+     * See [Client#beforeConnect]{@link Client#beforeConnect}.
+     */
+    beforeConnect?: () => void | Promise<void>;
+    /**
+     * See [Client#onConnect]{@link Client#onConnect}.
+     */
+    onConnect?: frameCallbackType;
+    /**
+     * See [Client#onDisconnect]{@link Client#onDisconnect}.
+     */
+    onDisconnect?: frameCallbackType;
+    /**
+     * See [Client#onStompError]{@link Client#onStompError}.
+     */
+    onStompError?: frameCallbackType;
+    /**
+     * See [Client#onWebSocketClose]{@link Client#onWebSocketClose}.
+     */
+    onWebSocketClose?: closeEventCallbackType;
+    /**
+     * See [Client#onWebSocketError]{@link Client#onWebSocketError}.
+     */
+    onWebSocketError?: wsErrorCallbackType;
+    /**
+     * See [Client#logRawCommunication]{@link Client#logRawCommunication}.
+     */
+    logRawCommunication?: boolean;
+    /**
+     * See [Client#debug]{@link Client#debug}.
+     */
+    debug?: debugFnType;
+    /**
+     * See [Client#discardWebsocketOnCommFailure]{@link Client#discardWebsocketOnCommFailure}.
+     */
+    discardWebsocketOnCommFailure?: boolean;
+    /**
+     * See [Client#onChangeState]{@link Client#onChangeState}.
+     */
+    onChangeState?: (state: ActivationState) => void;
+}

node_modules/@stomp/stompjs/esm6/stomp-config.js

@@ -0,0 +1,13 @@
+/**
+ * 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`.
+ */
+export class StompConfig {
+}
+//# sourceMappingURL=stomp-config.js.map

node_modules/@stomp/stompjs/esm6/stomp-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stomp-config.js","sourceRoot":"","sources":["../src/stomp-config.ts"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,MAAM,OAAO,WAAW;CAkIvB"}

node_modules/@stomp/stompjs/esm6/stomp-handler.d.ts

@@ -0,0 +1,72 @@
+import { Client } from './client';
+import { ITransaction } from './i-transaction';
+import { StompConfig } from './stomp-config';
+import { StompHeaders } from './stomp-headers';
+import { StompSubscription } from './stomp-subscription';
+import { closeEventCallbackType, debugFnType, frameCallbackType, IPublishParams, IStompSocket, messageCallbackType, wsErrorCallbackType } from './types';
+import { Versions } from './versions';
+/**
+ * The STOMP protocol handler
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export declare class StompHandler {
+    private _client;
+    _webSocket: IStompSocket;
+    debug: debugFnType;
+    stompVersions: Versions;
+    connectHeaders: StompHeaders;
+    disconnectHeaders: StompHeaders;
+    heartbeatIncoming: number;
+    heartbeatOutgoing: number;
+    onUnhandledMessage: messageCallbackType;
+    onUnhandledReceipt: frameCallbackType;
+    onUnhandledFrame: frameCallbackType;
+    onConnect: frameCallbackType;
+    onDisconnect: frameCallbackType;
+    onStompError: frameCallbackType;
+    onWebSocketClose: closeEventCallbackType;
+    onWebSocketError: wsErrorCallbackType;
+    logRawCommunication: boolean;
+    splitLargeFrames: boolean;
+    maxWebSocketChunkSize: number;
+    forceBinaryWSFrames: boolean;
+    appendMissingNULLonIncoming: boolean;
+    discardWebsocketOnCommFailure: boolean;
+    readonly connectedVersion: string;
+    private _connectedVersion;
+    readonly connected: boolean;
+    private _connected;
+    private readonly _subscriptions;
+    private readonly _receiptWatchers;
+    private _partialData;
+    private _escapeHeaderValues;
+    private _counter;
+    private _pinger;
+    private _ponger;
+    private _lastServerActivityTS;
+    private _onclose;
+    constructor(_client: Client, _webSocket: IStompSocket, config?: StompConfig);
+    configure(conf: StompConfig): void;
+    start(): void;
+    private readonly _serverFrameHandlers;
+    private _setupHeartbeat;
+    private _closeOrDiscardWebsocket;
+    forceDisconnect(): void;
+    _closeWebsocket(): void;
+    private _discardWebsocket;
+    private _transmit;
+    dispose(): void;
+    private _cleanUp;
+    publish(params: IPublishParams): void;
+    watchForReceipt(receiptId: string, callback: frameCallbackType): void;
+    subscribe(destination: string, callback: messageCallbackType, headers?: StompHeaders): StompSubscription;
+    unsubscribe(id: string, headers?: StompHeaders): void;
+    begin(transactionId: string): ITransaction;
+    commit(transactionId: string): void;
+    abort(transactionId: string): void;
+    ack(messageId: string, subscriptionId: string, headers?: StompHeaders): void;
+    nack(messageId: string, subscriptionId: string, headers?: StompHeaders): void;
+}

node_modules/@stomp/stompjs/esm6/stomp-handler.js

@@ -0,0 +1,373 @@
+import { BYTE } from './byte';
+import { FrameImpl } from './frame-impl';
+import { Parser } from './parser';
+import { StompSocketState, } from './types';
+import { Versions } from './versions';
+import { augmentWebsocket } from './augment-websocket';
+/**
+ * The STOMP protocol handler
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export 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: 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.V1_2) {
+                    this._escapeHeaderValues = true;
+                }
+                this._setupHeartbeat(frame.headers);
+                this.onConnect(frame);
+            },
+            // [MESSAGE Frame](http://stomp.github.com/stomp-specification-1.2.html#MESSAGE)
+            MESSAGE: frame => {
+                // the callback is registered when the client calls
+                // `subscribe()`.
+                // If there is no registered subscription for the received message,
+                // the default `onUnhandledMessage` callback is used that the client can set.
+                // 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)).
+                const subscription = frame.headers.subscription;
+                const onReceive = this._subscriptions[subscription] || this.onUnhandledMessage;
+                // bless the frame to be a Message
+                const message = frame;
+                const client = this;
+                const messageId = this._connectedVersion === 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 = (headers = {}) => {
+                    return client.ack(messageId, subscription, 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: 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']];
+                }
+                else {
+                    this.onUnhandledReceipt(frame);
+                }
+            },
+            // [ERROR Frame](http://stomp.github.com/stomp-specification-1.2.html#ERROR)
+            ERROR: frame => {
+                this.onStompError(frame);
+            },
+        };
+        // used to index subscribers
+        this._counter = 0;
+        // subscription callbacks indexed by subscriber's ID
+        this._subscriptions = {};
+        // receipt-watchers indexed by receipts-ids
+        this._receiptWatchers = {};
+        this._partialData = '';
+        this._escapeHeaderValues = false;
+        this._lastServerActivityTS = Date.now();
+        this.configure(config);
+    }
+    get connectedVersion() {
+        return this._connectedVersion;
+    }
+    get connected() {
+        return this._connected;
+    }
+    configure(conf) {
+        // bulk assign all properties to this
+        Object.assign(this, conf);
+    }
+    start() {
+        const parser = new Parser(
+        // On Frame
+        rawFrame => {
+            const frame = FrameImpl.fromRawFrame(rawFrame, this._escapeHeaderValues);
+            // if this.logRawCommunication is set, the rawChunk is logged at this._webSocket.onmessage
+            if (!this.logRawCommunication) {
+                this.debug(`<<< ${frame}`);
+            }
+            const serverFrameHandler = this._serverFrameHandlers[frame.command] || this.onUnhandledFrame;
+            serverFrameHandler(frame);
+        }, 
+        // On Incoming Ping
+        () => {
+            this.debug('<<< PONG');
+        });
+        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);
+        };
+        this._onclose = (closeEvent) => {
+            this.debug(`Connection closed to ${this._client.brokerURL}`);
+            this._cleanUp();
+            this.onWebSocketClose(closeEvent);
+        };
+        this._webSocket.onclose = this._onclose;
+        this._webSocket.onerror = (errorEvent) => {
+            this.onWebSocketError(errorEvent);
+        };
+        this._webSocket.onopen = () => {
+            // Clone before updating
+            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 });
+        };
+    }
+    _setupHeartbeat(headers) {
+        if (headers.version !== Versions.V1_1 &&
+            headers.version !== Versions.V1_2) {
+            return;
+        }
+        // It is valid for the server to not send this header
+        // https://stomp.github.io/stomp-specification-1.2.html#Heart-beating
+        if (!headers['heart-beat']) {
+            return;
+        }
+        // heart-beat header received from the server looks like:
+        //
+        //     heart-beat: sx, sy
+        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 === StompSocketState.OPEN) {
+                    this._webSocket.send(BYTE.LF);
+                    this.debug('>>> PING');
+                }
+            }, ttl);
+        }
+        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 * 2) {
+                    this.debug(`did not receive server activity for the last ${delta}ms`);
+                    this._closeOrDiscardWebsocket();
+                }
+            }, ttl);
+        }
+    }
+    _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 === StompSocketState.CONNECTING ||
+                this._webSocket.readyState === StompSocketState.OPEN) {
+                this._closeOrDiscardWebsocket();
+            }
+        }
+    }
+    _closeWebsocket() {
+        this._webSocket.onmessage = () => { }; // ignore messages
+        this._webSocket.close();
+    }
+    _discardWebsocket() {
+        if (!this._webSocket.terminate) {
+            augmentWebsocket(this._webSocket, (msg) => this.debug(msg));
+        }
+        this._webSocket.terminate();
+    }
+    _transmit(params) {
+        const { command, headers, body, binaryBody, skipContentLengthHeader } = params;
+        const frame = new FrameImpl({
+            command,
+            headers,
+            body,
+            binaryBody,
+            escapeHeaderValues: this._escapeHeaderValues,
+            skipContentLengthHeader,
+        });
+        let rawChunk = frame.serialize();
+        if (this.logRawCommunication) {
+            this.debug(`>>> ${rawChunk}`);
+        }
+        else {
+            this.debug(`>>> ${frame}`);
+        }
+        if (this.forceBinaryWSFrames && typeof rawChunk === 'string') {
+            rawChunk = new TextEncoder().encode(rawChunk);
+        }
+        if (typeof rawChunk !== 'string' || !this.splitLargeFrames) {
+            this._webSocket.send(rawChunk);
+        }
+        else {
+            let out = rawChunk;
+            while (out.length > 0) {
+                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}`);
+            }
+        }
+    }
+    dispose() {
+        if (this.connected) {
+            try {
+                // clone before updating
+                const disconnectHeaders = Object.assign({}, this.disconnectHeaders);
+                if (!disconnectHeaders.receipt) {
+                    disconnectHeaders.receipt = `close-${this._counter++}`;
+                }
+                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}`);
+            }
+        }
+        else {
+            if (this._webSocket.readyState === StompSocketState.CONNECTING ||
+                this._webSocket.readyState === StompSocketState.OPEN) {
+                this._closeWebsocket();
+            }
+        }
+    }
+    _cleanUp() {
+        this._connected = false;
+        if (this._pinger) {
+            clearInterval(this._pinger);
+        }
+        if (this._ponger) {
+            clearInterval(this._ponger);
+        }
+    }
+    publish(params) {
+        const { destination, headers, body, binaryBody, skipContentLengthHeader } = params;
+        const hdrs = Object.assign({ destination }, headers);
+        this._transmit({
+            command: 'SEND',
+            headers: hdrs,
+            body,
+            binaryBody,
+            skipContentLengthHeader,
+        });
+    }
+    watchForReceipt(receiptId, callback) {
+        this._receiptWatchers[receiptId] = callback;
+    }
+    subscribe(destination, callback, headers = {}) {
+        headers = Object.assign({}, headers);
+        if (!headers.id) {
+            headers.id = `sub-${this._counter++}`;
+        }
+        headers.destination = destination;
+        this._subscriptions[headers.id] = callback;
+        this._transmit({ command: 'SUBSCRIBE', headers });
+        const client = this;
+        return {
+            id: headers.id,
+            unsubscribe(hdrs) {
+                return client.unsubscribe(headers.id, hdrs);
+            },
+        };
+    }
+    unsubscribe(id, headers = {}) {
+        headers = Object.assign({}, headers);
+        delete this._subscriptions[id];
+        headers.id = id;
+        this._transmit({ command: 'UNSUBSCRIBE', headers });
+    }
+    begin(transactionId) {
+        const txId = transactionId || `tx-${this._counter++}`;
+        this._transmit({
+            command: 'BEGIN',
+            headers: {
+                transaction: txId,
+            },
+        });
+        const client = this;
+        return {
+            id: txId,
+            commit() {
+                client.commit(txId);
+            },
+            abort() {
+                client.abort(txId);
+            },
+        };
+    }
+    commit(transactionId) {
+        this._transmit({
+            command: 'COMMIT',
+            headers: {
+                transaction: transactionId,
+            },
+        });
+    }
+    abort(transactionId) {
+        this._transmit({
+            command: 'ABORT',
+            headers: {
+                transaction: transactionId,
+            },
+        });
+    }
+    ack(messageId, subscriptionId, headers = {}) {
+        headers = Object.assign({}, headers);
+        if (this._connectedVersion === Versions.V1_2) {
+            headers.id = messageId;
+        }
+        else {
+            headers['message-id'] = messageId;
+        }
+        headers.subscription = subscriptionId;
+        this._transmit({ command: 'ACK', headers });
+    }
+    nack(messageId, subscriptionId, headers = {}) {
+        headers = Object.assign({}, headers);
+        if (this._connectedVersion === Versions.V1_2) {
+            headers.id = messageId;
+        }
+        else {
+            headers['message-id'] = messageId;
+        }
+        headers.subscription = subscriptionId;
+        return this._transmit({ command: 'NACK', headers });
+    }
+}
+//# sourceMappingURL=stomp-handler.js.map

node_modules/@stomp/stompjs/esm6/stomp-headers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * STOMP headers. Many functions calls will accept headers as parameters.
+ * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}.
+ *
+ * `key` and `value` must be valid strings.
+ * In addition, `key` must not contain `CR`, `LF`, or `:`.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare class StompHeaders {
+    [key: string]: string;
+}

node_modules/@stomp/stompjs/esm6/stomp-headers.js

@@ -0,0 +1,12 @@
+/**
+ * STOMP headers. Many functions calls will accept headers as parameters.
+ * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}.
+ *
+ * `key` and `value` must be valid strings.
+ * In addition, `key` must not contain `CR`, `LF`, or `:`.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class StompHeaders {
+}
+//# sourceMappingURL=stomp-headers.js.map

node_modules/@stomp/stompjs/esm6/stomp-headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stomp-headers.js","sourceRoot":"","sources":["../src/stomp-headers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,OAAO,YAAY;CAExB"}

node_modules/@stomp/stompjs/esm6/stomp-subscription.d.ts

@@ -0,0 +1,16 @@
+import { StompHeaders } from './stomp-headers';
+/**
+ * Call [Client#subscribe]{@link Client#subscribe} to create a StompSubscription.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare class StompSubscription {
+    /**
+     * Id associated with this subscription.
+     */
+    id: string;
+    /**
+     * Unsubscribe. See [Client#unsubscribe]{@link Client#unsubscribe} for an example.
+     */
+    unsubscribe: (headers?: StompHeaders) => void;
+}

node_modules/@stomp/stompjs/esm6/stomp-subscription.js

@@ -0,0 +1,8 @@
+/**
+ * Call [Client#subscribe]{@link Client#subscribe} to create a StompSubscription.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class StompSubscription {
+}
+//# sourceMappingURL=stomp-subscription.js.map

node_modules/@stomp/stompjs/esm6/stomp-subscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stomp-subscription.js","sourceRoot":"","sources":["../src/stomp-subscription.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,OAAO,iBAAiB;CAU7B"}

node_modules/@stomp/stompjs/esm6/types.d.ts

@@ -0,0 +1,140 @@
+import { IFrame } from './i-frame';
+import { IMessage } from './i-message';
+import { StompHeaders } from './stomp-headers';
+/**
+ * This callback will receive a `string` as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare type debugFnType = (msg: string) => void;
+/**
+ * This callback will receive a {@link IMessage} as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare type messageCallbackType = (message: IMessage) => void;
+/**
+ * This callback will receive a {@link IFrame} as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare type frameCallbackType = (receipt: IFrame) => void;
+/**
+ * This callback will receive a [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
+ * as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare type closeEventCallbackType<T = any> = (evt: T) => void;
+/**
+ * This callback will receive an [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event}
+ * as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare type wsErrorCallbackType<T = any> = (evt: T) => void;
+/**
+ * Parameters for [Client#publish]{@link Client#publish}.
+ * Aliased as publishParams as well.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export interface IPublishParams {
+    /**
+     * destination end point
+     */
+    destination: string;
+    /**
+     * headers (optional)
+     */
+    headers?: StompHeaders;
+    /**
+     * body (optional)
+     */
+    body?: string;
+    /**
+     * binary body (optional)
+     */
+    binaryBody?: Uint8Array;
+    /**
+     * By default a `content-length` header will be added in the Frame to the broker.
+     * Set it to `true` for the header to be skipped.
+     */
+    skipContentLengthHeader?: boolean;
+}
+/**
+ * Backward compatibility, switch to {@link IPublishParams}.
+ */
+export declare type publishParams = IPublishParams;
+/**
+ * Used in {@link IRawFrameType}
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export declare type RawHeaderType = [string, string];
+/**
+ * The parser yield frames in this structure
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export interface IRawFrameType {
+    command: string;
+    headers: RawHeaderType[];
+    binaryBody: Uint8Array;
+}
+/**
+ * @internal
+ */
+export interface IStompSocketMessageEvent {
+    data?: string | ArrayBuffer;
+}
+/**
+ * Copied from Websocket interface to avoid dom typelib dependency.
+ *
+ * @internal
+ */
+export interface IStompSocket {
+    onclose: ((this: IStompSocket, ev?: any) => any) | null;
+    onerror: ((this: IStompSocket, ev: any) => any) | null;
+    onmessage: ((this: IStompSocket, ev: IStompSocketMessageEvent) => any) | null;
+    onopen: ((this: IStompSocket, ev?: any) => any) | null;
+    terminate?: ((this: IStompSocket) => any) | null;
+    /**
+     * Returns a string that indicates how binary data from the socket is exposed to scripts:
+     * We support only 'arraybuffer'.
+     */
+    binaryType: 'arraybuffer';
+    /**
+     * Returns the state of the socket connection. It can have the values of StompSocketState.
+     */
+    readonly readyState: number;
+    /**
+     * Closes the connection.
+     */
+    close(): void;
+    /**
+     * Transmits data using the connection. data can be a string or an ArrayBuffer.
+     */
+    send(data: string | ArrayBuffer): void;
+}
+/**
+ * Possible states for the IStompSocket
+ */
+export declare enum StompSocketState {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+/**
+ * Possible activation state
+ */
+export declare enum ActivationState {
+    ACTIVE = 0,
+    DEACTIVATING = 1,
+    INACTIVE = 2
+}

node_modules/@stomp/stompjs/esm6/types.js

@@ -0,0 +1,20 @@
+/**
+ * Possible states for the IStompSocket
+ */
+export var StompSocketState;
+(function (StompSocketState) {
+    StompSocketState[StompSocketState["CONNECTING"] = 0] = "CONNECTING";
+    StompSocketState[StompSocketState["OPEN"] = 1] = "OPEN";
+    StompSocketState[StompSocketState["CLOSING"] = 2] = "CLOSING";
+    StompSocketState[StompSocketState["CLOSED"] = 3] = "CLOSED";
+})(StompSocketState || (StompSocketState = {}));
+/**
+ * Possible activation state
+ */
+export var ActivationState;
+(function (ActivationState) {
+    ActivationState[ActivationState["ACTIVE"] = 0] = "ACTIVE";
+    ActivationState[ActivationState["DEACTIVATING"] = 1] = "DEACTIVATING";
+    ActivationState[ActivationState["INACTIVE"] = 2] = "INACTIVE";
+})(ActivationState || (ActivationState = {}));
+//# sourceMappingURL=types.js.map

node_modules/@stomp/stompjs/esm6/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AA0IA;;GAEG;AACH,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,mEAAU,CAAA;IACV,uDAAI,CAAA;IACJ,6DAAO,CAAA;IACP,2DAAM,CAAA;AACR,CAAC,EALW,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,yDAAM,CAAA;IACN,qEAAY,CAAA;IACZ,6DAAQ,CAAA;AACV,CAAC,EAJW,eAAe,KAAf,eAAe,QAI1B"}

node_modules/@stomp/stompjs/esm6/versions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Supported STOMP versions
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export declare class Versions {
+    versions: string[];
+    /**
+     * Indicates protocol version 1.0
+     */
+    static V1_0: string;
+    /**
+     * Indicates protocol version 1.1
+     */
+    static V1_1: string;
+    /**
+     * Indicates protocol version 1.2
+     */
+    static V1_2: string;
+    /**
+     * @internal
+     */
+    static default: 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.
+     */
+    constructor(versions: string[]);
+    /**
+     * Used as part of CONNECT STOMP Frame
+     */
+    supportedVersions(): string;
+    /**
+     * Used while creating a WebSocket
+     */
+    protocolVersions(): string[];
+}

node_modules/@stomp/stompjs/esm6/versions.js

@@ -0,0 +1,49 @@
+/**
+ * Supported STOMP versions
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export 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.
+     */
+    constructor(versions) {
+        this.versions = versions;
+    }
+    /**
+     * Used as part of CONNECT STOMP Frame
+     */
+    supportedVersions() {
+        return this.versions.join(',');
+    }
+    /**
+     * Used while creating a WebSocket
+     */
+    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,
+]);
+//# sourceMappingURL=versions.js.map

node_modules/@stomp/stompjs/esm6/versions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.js","sourceRoot":"","sources":["../src/versions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,QAAQ;IAuBnB;;;;;OAKG;IACH,YAAmB,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;IAAG,CAAC;IAEzC;;OAEG;IACI,iBAAiB;QACtB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,gBAAgB;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC;IAChE,CAAC;;AA1CD;;GAEG;AACW,aAAI,GAAG,KAAK,CAAC;AAC3B;;GAEG;AACW,aAAI,GAAG,KAAK,CAAC;AAC3B;;GAEG;AACW,aAAI,GAAG,KAAK,CAAC;AAE3B;;GAEG;AACW,gBAAO,GAAG,IAAI,QAAQ,CAAC;IACnC,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,IAAI;CACd,CAAC,CAAC"}

node_modules/@stomp/stompjs/index.d.ts

@@ -0,0 +1 @@
+export * from './esm6/';

node_modules/@stomp/stompjs/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@stomp/stompjs",
+  "version": "6.1.2",
+  "description": "STOMP client for Javascript and Typescript",
+  "scripts": {
+    "clean": "rm -rf bundles esm6",
+    "build-webpack": "webpack && webpack --mode=production --output-filename=stomp.umd.min.js",
+    "build": "npm run clean && npx tsc && npm run build-webpack",
+    "test": "jasmine",
+    "karma": "karma start --single-run",
+    "lint": "tslint 'src/**/*.ts'",
+    "prettier": "prettier --write .",
+    "prepublishOnly": "npm run lint && npm run build && npm run karma && npm run test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stomp-js/stompjs.git"
+  },
+  "keywords": [
+    "STOMP",
+    "RabbitMQ",
+    "ActiveMQ",
+    "Websocket",
+    "messaging",
+    "queue",
+    "SockJS"
+  ],
+  "author": "deepak@kreatio.com",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/stomp-js/stompjs/issues"
+  },
+  "homepage": "https://github.com/stomp-js/stompjs#readme",
+  "devDependencies": {
+    "@chiragrupani/karma-chromium-edge-launcher": "^2.0.0",
+    "awesome-typescript-loader": "^5.2.0",
+    "jasmine": "^3.1.0",
+    "karma": "^5.0.3",
+    "karma-chrome-launcher": "^3.0.0",
+    "karma-firefox-launcher": "^2.0.0",
+    "karma-jasmine": "^4.0.0",
+    "karma-safari-launcher": "git://github.com/RLovelett/karma-safari-launcher.git#safari-webdriver",
+    "karma-summary-reporter": "^2.0.2",
+    "prettier": "^2.1.2",
+    "text-encoding": "^0.7.0",
+    "tslint": "^6.0.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "=3.6.4",
+    "webpack": "^4.33.0",
+    "webpack-cli": "^3.3.2",
+    "ws": "^8.2.0"
+  },
+  "module": "./esm6/index.js",
+  "main": "bundles/stomp.umd.js",
+  "typings": "index.d.ts",
+  "sideEffects": false,
+  "dependencies": {}
+}

node_modules/@stomp/stompjs/src/augment-websocket.ts

@@ -0,0 +1,38 @@
+import { IStompSocket } from './types';
+
+/**
+ * @internal
+ */
+export function augmentWebsocket(
+  webSocket: IStompSocket,
+  debug: (msg: string) => void
+) {
+  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,
+    });
+  };
+}

node_modules/@stomp/stompjs/src/byte.ts

@@ -0,0 +1,13 @@
+/**
+ * Some byte values, used as per STOMP specifications.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export const BYTE = {
+  // LINEFEED byte (octet 10)
+  LF: '\x0A',
+  // NULL byte (octet 0)
+  NULL: '\x00',
+};

node_modules/@stomp/stompjs/src/client.ts

@@ -0,0 +1,812 @@
+import { ITransaction } from './i-transaction';
+import { StompConfig } from './stomp-config';
+import { StompHandler } from './stomp-handler';
+import { StompHeaders } from './stomp-headers';
+import { StompSubscription } from './stomp-subscription';
+import {
+  ActivationState,
+  closeEventCallbackType,
+  debugFnType,
+  frameCallbackType,
+  IPublishParams,
+  IStompSocket,
+  messageCallbackType,
+  StompSocketState,
+  wsErrorCallbackType,
+} from './types';
+import { Versions } from './versions';
+
+/**
+ * @internal
+ */
+declare const WebSocket: {
+  prototype: IStompSocket;
+  new (url: string, protocols?: string | string[]): IStompSocket;
+};
+
+/**
+ * STOMP Client Class.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class Client {
+  /**
+   * The URL for the STOMP broker to connect to.
+   * Typically like `"ws://broker.329broker.com:15674/ws"` or `"wss://broker.329broker.com:15674/ws"`.
+   *
+   * Only one of this or [Client#webSocketFactory]{@link Client#webSocketFactory} need to be set.
+   * If both are set, [Client#webSocketFactory]{@link Client#webSocketFactory} will be used.
+   *
+   * If your environment does not support WebSockets natively, please refer to
+   * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}.
+   */
+  public brokerURL: string;
+
+  /**
+   * STOMP versions to attempt during STOMP handshake. By default versions `1.0`, `1.1`, and `1.2` are attempted.
+   *
+   * Example:
+   * ```javascript
+   *        // Try only versions 1.0 and 1.1
+   *        client.stompVersions = new Versions(['1.0', '1.1'])
+   * ```
+   */
+  public stompVersions = Versions.default;
+
+  /**
+   * This function should return a WebSocket or a similar (e.g. SockJS) object.
+   * If your environment does not support WebSockets natively, please refer to
+   * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}.
+   * If your STOMP Broker supports WebSockets, prefer setting [Client#brokerURL]{@link Client#brokerURL}.
+   *
+   * If both this and [Client#brokerURL]{@link Client#brokerURL} are set, this will be used.
+   *
+   * Example:
+   * ```javascript
+   *        // use a WebSocket
+   *        client.webSocketFactory= function () {
+   *          return new WebSocket("wss://broker.329broker.com:15674/ws");
+   *        };
+   *
+   *        // Typical usage with SockJS
+   *        client.webSocketFactory= function () {
+   *          return new SockJS("http://broker.329broker.com/stomp");
+   *        };
+   * ```
+   */
+  public webSocketFactory: () => IStompSocket;
+
+  /**
+   * Will retry if Stomp connection is not established in specified milliseconds.
+   * Default 0, which implies wait for ever.
+   */
+  public connectionTimeout: number = 0;
+
+  private _connectionWatcher: number; // Timer
+
+  /**
+   *  automatically reconnect with delay in milliseconds, set to 0 to disable.
+   */
+  public reconnectDelay: number = 5000;
+
+  /**
+   * Incoming heartbeat interval in milliseconds. Set to 0 to disable.
+   */
+  public heartbeatIncoming: number = 10000;
+
+  /**
+   * Outgoing heartbeat interval in milliseconds. Set to 0 to disable.
+   */
+  public heartbeatOutgoing: number = 10000;
+
+  /**
+   * This switches on a non standard behavior while sending WebSocket packets.
+   * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}.
+   * Only Java Spring brokers seems to use this mode.
+   *
+   * WebSockets, by itself, split large (text) packets,
+   * so it is not needed with a truly compliant STOMP/WebSocket broker.
+   * Actually setting it for such broker will cause large messages to fail.
+   *
+   * `false` by default.
+   *
+   * Binary frames are never split.
+   */
+  public splitLargeFrames: boolean = false;
+
+  /**
+   * See [splitLargeFrames]{@link Client#splitLargeFrames}.
+   * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`.
+   */
+  public maxWebSocketChunkSize: number = 8 * 1024;
+
+  /**
+   * Usually the
+   * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters}
+   * is automatically decided by type of the payload.
+   * Default is `false`, which should work with all compliant brokers.
+   *
+   * Set this flag to force binary frames.
+   */
+  public forceBinaryWSFrames: boolean = false;
+
+  /**
+   * A bug in ReactNative chops a string on occurrence of a NULL.
+   * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}.
+   * This makes incoming WebSocket messages invalid STOMP packets.
+   * Setting this flag attempts to reverse the damage by appending a NULL.
+   * If the broker splits a large message into multiple WebSocket messages,
+   * this flag will cause data loss and abnormal termination of connection.
+   *
+   * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library.
+   */
+  public appendMissingNULLonIncoming: boolean = false;
+
+  /**
+   * Underlying WebSocket instance, READONLY.
+   */
+  get webSocket(): IStompSocket {
+    return this._stompHandler ? this._stompHandler._webSocket : undefined;
+  }
+
+  /**
+   * Connection headers, important keys - `login`, `passcode`, `host`.
+   * Though STOMP 1.2 standard marks these keys to be present, check your broker documentation for
+   * details specific to your broker.
+   */
+  public connectHeaders: StompHeaders;
+
+  /**
+   * Disconnection headers.
+   */
+  get disconnectHeaders(): StompHeaders {
+    return this._disconnectHeaders;
+  }
+
+  set disconnectHeaders(value: StompHeaders) {
+    this._disconnectHeaders = value;
+    if (this._stompHandler) {
+      this._stompHandler.disconnectHeaders = this._disconnectHeaders;
+    }
+  }
+  private _disconnectHeaders: StompHeaders;
+
+  /**
+   * This function will be called for any unhandled messages.
+   * It is useful for receiving messages sent to RabbitMQ temporary queues.
+   *
+   * It can also get invoked with stray messages while the server is processing
+   * a request to [Client#unsubscribe]{@link Client#unsubscribe}
+   * from an endpoint.
+   *
+   * The actual {@link IMessage} will be passed as parameter to the callback.
+   */
+  public onUnhandledMessage: messageCallbackType;
+
+  /**
+   * STOMP brokers can be requested to notify when an operation is actually completed.
+   * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. See
+   * [Client#watchForReceipt]{@link Client#watchForReceipt} for examples.
+   *
+   * The actual {@link FrameImpl} will be passed as parameter to the callback.
+   */
+  public onUnhandledReceipt: frameCallbackType;
+
+  /**
+   * Will be invoked if {@link FrameImpl} of unknown type is received from the STOMP broker.
+   *
+   * The actual {@link IFrame} will be passed as parameter to the callback.
+   */
+  public onUnhandledFrame: frameCallbackType;
+
+  /**
+   * `true` if there is a active connection with STOMP Broker
+   */
+  get connected(): boolean {
+    return !!this._stompHandler && this._stompHandler.connected;
+  }
+
+  /**
+   * Callback, invoked on before a connection connection to the STOMP broker.
+   *
+   * You can change options on the client, which will impact the immediate connect.
+   * It is valid to call [Client#decativate]{@link Client#deactivate} in this callback.
+   *
+   * As of version 5.1, this callback can be
+   * [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
+   * (i.e., it can return a
+   * [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)).
+   * In that case connect will be called only after the Promise is resolved.
+   * This can be used to reliably fetch credentials, access token etc. from some other service
+   * in an asynchronous way.
+   */
+  public beforeConnect: () => void | Promise<void>;
+
+  /**
+   * Callback, invoked on every successful connection to the STOMP broker.
+   *
+   * The actual {@link FrameImpl} will be passed as parameter to the callback.
+   * Sometimes clients will like to use headers from this frame.
+   */
+  public onConnect: frameCallbackType;
+
+  /**
+   * Callback, invoked on every successful disconnection from the STOMP broker. It will not be invoked if
+   * the STOMP broker disconnected due to an error.
+   *
+   * The actual Receipt {@link FrameImpl} acknowledging the DISCONNECT will be passed as parameter to the callback.
+   *
+   * The way STOMP protocol is designed, the connection may close/terminate without the client
+   * receiving the Receipt {@link FrameImpl} acknowledging the DISCONNECT.
+   * You might find [Client#onWebSocketClose]{@link Client#onWebSocketClose} more appropriate to watch
+   * STOMP broker disconnects.
+   */
+  public onDisconnect: frameCallbackType;
+
+  /**
+   * Callback, invoked on an ERROR frame received from the STOMP Broker.
+   * A compliant STOMP Broker will close the connection after this type of frame.
+   * Please check broker specific documentation for exact behavior.
+   *
+   * The actual {@link IFrame} will be passed as parameter to the callback.
+   */
+  public onStompError: frameCallbackType;
+
+  /**
+   * Callback, invoked when underlying WebSocket is closed.
+   *
+   * Actual [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
+   * is passed as parameter to the callback.
+   */
+  public onWebSocketClose: closeEventCallbackType;
+
+  /**
+   * Callback, invoked when underlying WebSocket raises an error.
+   *
+   * Actual [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event}
+   * is passed as parameter to the callback.
+   */
+  public onWebSocketError: wsErrorCallbackType;
+
+  /**
+   * Set it to log the actual raw communication with the broker.
+   * When unset, it logs headers of the parsed frames.
+   *
+   * Change in this effects from next broker reconnect.
+   *
+   * **Caution: this assumes that frames only have valid UTF8 strings.**
+   */
+  public logRawCommunication: boolean;
+
+  /**
+   * By default, debug messages are discarded. To log to `console` following can be used:
+   *
+   * ```javascript
+   *        client.debug = function(str) {
+   *          console.log(str);
+   *        };
+   * ```
+   *
+   * Currently this method does not support levels of log. Be aware that the output can be quite verbose
+   * and may contain sensitive information (like passwords, tokens etc.).
+   */
+  public debug: debugFnType;
+
+  /**
+   * Browsers do not immediately close WebSockets when `.close` is issued.
+   * This may cause reconnection to take a longer on certain type of failures.
+   * In case of incoming heartbeat failure, this experimental flag instructs the library
+   * to discard the socket immediately (even before it is actually closed).
+   */
+  public discardWebsocketOnCommFailure: boolean;
+
+  /**
+   * version of STOMP protocol negotiated with the server, READONLY
+   */
+  get connectedVersion(): string {
+    return this._stompHandler ? this._stompHandler.connectedVersion : undefined;
+  }
+
+  private _stompHandler: StompHandler;
+
+  /**
+   * if the client is active (connected or going to reconnect)
+   */
+  get active(): boolean {
+    return this.state === ActivationState.ACTIVE;
+  }
+
+  /**
+   * It will be called on state change.
+   *
+   * When deactivating it may go from ACTIVE to INACTIVE without entering DEACTIVATING.
+   */
+  public onChangeState: (state: ActivationState) => void;
+
+  private _changeState(state: ActivationState) {
+    this.state = state;
+    this.onChangeState(state);
+  }
+
+  // This will mark deactivate to complete, to be called after Websocket is closed
+  private _resolveSocketClose: (value?: PromiseLike<void> | void) => void;
+
+  /**
+   * Activation state.
+   *
+   * It will usually be ACTIVE or INACTIVE.
+   * When deactivating it may go from ACTIVE to INACTIVE without entering DEACTIVATING.
+   */
+  public state: ActivationState = ActivationState.INACTIVE;
+
+  private _reconnector: any;
+
+  /**
+   * Create an instance.
+   */
+  constructor(conf: StompConfig = {}) {
+    // Dummy callbacks
+    const noOp = () => {};
+    this.debug = noOp;
+    this.beforeConnect = noOp;
+    this.onConnect = noOp;
+    this.onDisconnect = noOp;
+    this.onUnhandledMessage = noOp;
+    this.onUnhandledReceipt = noOp;
+    this.onUnhandledFrame = noOp;
+    this.onStompError = noOp;
+    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);
+  }
+
+  /**
+   * Update configuration.
+   */
+  public configure(conf: StompConfig): void {
+    // bulk assign all properties to this
+    (Object as any).assign(this, conf);
+  }
+
+  /**
+   * Initiate the connection with the broker.
+   * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay},
+   * it will keep trying to reconnect.
+   *
+   * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts.
+   */
+  public activate(): void {
+    if (this.state === 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(ActivationState.ACTIVE);
+
+    this._connect();
+  }
+
+  private async _connect(): Promise<void> {
+    if (this.connected) {
+      this.debug('STOMP: already connected, nothing to do');
+      return;
+    }
+
+    await 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) {
+      // clear first
+      if (this._connectionWatcher) {
+        clearTimeout(this._connectionWatcher);
+      }
+      this._connectionWatcher = setTimeout(() => {
+        if (this.connected) {
+          return;
+        }
+        // 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 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 === ActivationState.DEACTIVATING) {
+          // Mark deactivation complete
+          this._resolveSocketClose();
+          this._resolveSocketClose = undefined;
+          this._changeState(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();
+  }
+
+  private _createWebSocket(): IStompSocket {
+    let webSocket: IStompSocket;
+
+    if (this.webSocketFactory) {
+      webSocket = this.webSocketFactory();
+    } else {
+      webSocket = new WebSocket(
+        this.brokerURL,
+        this.stompVersions.protocolVersions()
+      );
+    }
+    webSocket.binaryType = 'arraybuffer';
+    return webSocket;
+  }
+
+  private _schedule_reconnect(): void {
+    if (this.reconnectDelay > 0) {
+      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}.
+   */
+  public async deactivate(): Promise<void> {
+    let retPromise: Promise<void>;
+
+    if (this.state !== ActivationState.ACTIVE) {
+      this.debug(
+        `Already ${ActivationState[this.state]}, ignoring call to deactivate`
+      );
+      return Promise.resolve();
+    }
+
+    this._changeState(ActivationState.DEACTIVATING);
+
+    // Clear if a reconnection was scheduled
+    if (this._reconnector) {
+      clearTimeout(this._reconnector);
+    }
+
+    if (
+      this._stompHandler &&
+      this.webSocket.readyState !== StompSocketState.CLOSED
+    ) {
+      // we need to wait for underlying websocket to close
+      retPromise = new Promise<void>((resolve, reject) => {
+        this._resolveSocketClose = resolve;
+      });
+    } else {
+      // indicate that auto reconnect loop should terminate
+      this._changeState(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.
+   */
+  public forceDisconnect() {
+    if (this._stompHandler) {
+      this._stompHandler.forceDisconnect();
+    }
+  }
+
+  private _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.
+   *
+   * STOMP protocol specifies and suggests some headers and also allows broker specific headers.
+   *
+   * `body` must be String.
+   * You will need to covert the payload to string in case it is not string (e.g. JSON).
+   *
+   * To send a binary message body use binaryBody parameter. It should be a
+   * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
+   * Sometimes brokers may not support binary frames out of the box.
+   * Please check your broker documentation.
+   *
+   * `content-length` header is automatically added to the STOMP Frame sent to the broker.
+   * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added.
+   * For binary messages `content-length` header is always added.
+   *
+   * Caution: The broker will, most likely, report an error and disconnect if message body has NULL octet(s)
+   * and `content-length` header is missing.
+   *
+   * ```javascript
+   *        client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"});
+   *
+   *        // Only destination is mandatory parameter
+   *        client.publish({destination: "/queue/test", body: "Hello, STOMP"});
+   *
+   *        // Skip content-length header in the frame to the broker
+   *        client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true});
+   *
+   *        var binaryData = generateBinaryData(); // This need to be of type Uint8Array
+   *        // setting content-type header is not mandatory, however a good practice
+   *        client.publish({destination: '/topic/special', binaryBody: binaryData,
+   *                         headers: {'content-type': 'application/octet-stream'}});
+   * ```
+   */
+  public publish(params: IPublishParams) {
+    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.
+   * The value (say receipt-id) for this header needs to be unique for each use. Typically a sequence, a UUID, a
+   * random number or a combination may be used.
+   *
+   * A complaint broker will send a RECEIPT frame when an operation has actually been completed.
+   * The operation needs to be matched based in the value of the receipt-id.
+   *
+   * This method allow watching for a receipt and invoke the callback
+   * when corresponding receipt has been received.
+   *
+   * The actual {@link FrameImpl} will be passed as parameter to the callback.
+   *
+   * Example:
+   * ```javascript
+   *        // Subscribing with acknowledgement
+   *        let receiptId = randomText();
+   *
+   *        client.watchForReceipt(receiptId, function() {
+   *          // Will be called after server acknowledges
+   *        });
+   *
+   *        client.subscribe(TEST.destination, onMessage, {receipt: receiptId});
+   *
+   *
+   *        // Publishing with acknowledgement
+   *        receiptId = randomText();
+   *
+   *        client.watchForReceipt(receiptId, function() {
+   *          // Will be called after server acknowledges
+   *        });
+   *        client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg});
+   * ```
+   */
+  public watchForReceipt(receiptId: string, callback: frameCallbackType): void {
+    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.
+   *
+   * Note: The library will generate an unique ID if there is none provided in the headers.
+   *       To use your own ID, pass it using the headers argument.
+   *
+   * ```javascript
+   *        callback = function(message) {
+   *        // called when the client receives a STOMP message from the server
+   *          if (message.body) {
+   *            alert("got message with body " + message.body)
+   *          } else {
+   *            alert("got empty message");
+   *          }
+   *        });
+   *
+   *        var subscription = client.subscribe("/queue/test", callback);
+   *
+   *        // Explicit subscription id
+   *        var mySubId = 'my-subscription-id-001';
+   *        var subscription = client.subscribe(destination, callback, { id: mySubId });
+   * ```
+   */
+  public subscribe(
+    destination: string,
+    callback: messageCallbackType,
+    headers: StompHeaders = {}
+  ): StompSubscription {
+    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()`:
+   *
+   * ```javascript
+   *        var subscription = client.subscribe(destination, onmessage);
+   *        // ...
+   *        subscription.unsubscribe();
+   * ```
+   *
+   * See: http://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame
+   */
+  public unsubscribe(id: string, headers: StompHeaders = {}): void {
+    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.
+   */
+  public begin(transactionId?: string): ITransaction {
+    return this._stompHandler.begin(transactionId);
+  }
+
+  /**
+   * Commit a transaction.
+   *
+   * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on
+   * {@link ITransaction} returned by [client.begin]{@link Client#begin}.
+   *
+   * ```javascript
+   *        var tx = client.begin(txId);
+   *        //...
+   *        tx.commit();
+   * ```
+   */
+  public commit(transactionId: string): void {
+    this._stompHandler.commit(transactionId);
+  }
+
+  /**
+   * Abort a transaction.
+   * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on
+   * {@link ITransaction} returned by [client.begin]{@link Client#begin}.
+   *
+   * ```javascript
+   *        var tx = client.begin(txId);
+   *        //...
+   *        tx.abort();
+   * ```
+   */
+  public abort(transactionId: string): void {
+    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:
+   *
+   * ```javascript
+   *        var callback = function (message) {
+   *          // process the message
+   *          // acknowledge it
+   *          message.ack();
+   *        };
+   *        client.subscribe(destination, callback, {'ack': 'client'});
+   * ```
+   */
+  public ack(
+    messageId: string,
+    subscriptionId: string,
+    headers: StompHeaders = {}
+  ): void {
+    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:
+   *
+   * ```javascript
+   *        var callback = function (message) {
+   *          // process the message
+   *          // an error occurs, nack it
+   *          message.nack();
+   *        };
+   *        client.subscribe(destination, callback, {'ack': 'client'});
+   * ```
+   */
+  public nack(
+    messageId: string,
+    subscriptionId: string,
+    headers: StompHeaders = {}
+  ): void {
+    this._stompHandler.nack(messageId, subscriptionId, headers);
+  }
+}

node_modules/@stomp/stompjs/src/compatibility/compat-client.ts

@@ -0,0 +1,269 @@
+import { Client } from '../client';
+import { StompHeaders } from '../stomp-headers';
+import { frameCallbackType, messageCallbackType } from '../types';
+import { HeartbeatInfo } from './heartbeat-info';
+
+/**
+ * Available for backward compatibility, please shift to using {@link Client}.
+ *
+ * **Deprecated**
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+ */
+export class CompatClient extends Client {
+  /**
+   * It is no op now. No longer needed. Large packets work out of the box.
+   */
+  public maxWebSocketFrameSize: number = 16 * 1024;
+
+  /**
+   * Available for backward compatibility, please shift to using {@link Client}
+   * and [Client#webSocketFactory]{@link Client#webSocketFactory}.
+   *
+   * **Deprecated**
+   *
+   * @internal
+   */
+  constructor(webSocketFactory: () => any) {
+    super();
+    this.reconnect_delay = 0;
+    this.webSocketFactory = webSocketFactory;
+    // Default from previous version
+    this.debug = (...message: any[]) => {
+      console.log(...message);
+    };
+  }
+
+  private _parseConnect(...args: any[]): any {
+    let closeEventCallback;
+    let connectCallback;
+    let errorCallback;
+    let headers: StompHeaders = {};
+    if (args.length < 2) {
+      throw new Error('Connect requires at least 2 arguments');
+    }
+    if (typeof args[1] === 'function') {
+      [headers, connectCallback, errorCallback, closeEventCallback] = args;
+    } else {
+      switch (args.length) {
+        case 6:
+          [
+            headers.login,
+            headers.passcode,
+            connectCallback,
+            errorCallback,
+            closeEventCallback,
+            headers.host,
+          ] = args;
+          break;
+        default:
+          [
+            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}.
+   *
+   * **Deprecated**
+   *
+   * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the
+   * version with headers to pass your broker specific options.
+   *
+   * overloads:
+   * - connect(headers, connectCallback)
+   * - connect(headers, connectCallback, errorCallback)
+   * - connect(login, passcode, connectCallback)
+   * - connect(login, passcode, connectCallback, errorCallback)
+   * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback)
+   * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host)
+   *
+   * params:
+   * - headers, see [Client#connectHeaders]{@link Client#connectHeaders}
+   * - connectCallback, see [Client#onConnect]{@link Client#onConnect}
+   * - errorCallback, see [Client#onStompError]{@link Client#onStompError}
+   * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose}
+   * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders)
+   * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders)
+   * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders)
+   *
+   * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+   */
+  public connect(...args: any[]): void {
+    const out = this._parseConnect(...args);
+
+    if (out[0]) {
+      this.connectHeaders = out[0];
+    }
+    if (out[1]) {
+      this.onConnect = out[1];
+    }
+    if (out[2]) {
+      this.onStompError = out[2];
+    }
+    if (out[3]) {
+      this.onWebSocketClose = out[3];
+    }
+
+    super.activate();
+  }
+
+  /**
+   * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}.
+   *
+   * **Deprecated**
+   *
+   * See:
+   * [Client#onDisconnect]{@link Client#onDisconnect}, and
+   * [Client#disconnectHeaders]{@link Client#disconnectHeaders}
+   *
+   * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+   */
+  public disconnect(
+    disconnectCallback?: any,
+    headers: StompHeaders = {}
+  ): void {
+    if (disconnectCallback) {
+      this.onDisconnect = disconnectCallback;
+    }
+    this.disconnectHeaders = headers;
+
+    super.deactivate();
+  }
+
+  /**
+   * Available for backward compatibility, use [Client#publish]{@link Client#publish}.
+   *
+   * Send a message to a named destination. Refer to your STOMP broker documentation for types
+   * and naming of destinations. The headers will, typically, be available to the subscriber.
+   * However, there may be special purpose headers corresponding to your STOMP broker.
+   *
+   *  **Deprecated**, use [Client#publish]{@link Client#publish}
+   *
+   * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON)
+   *
+   * ```javascript
+   *        client.send("/queue/test", {priority: 9}, "Hello, STOMP");
+   *
+   *        // If you want to send a message with a body, you must also pass the headers argument.
+   *        client.send("/queue/test", {}, "Hello, STOMP");
+   * ```
+   *
+   * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html)
+   */
+  public send(
+    destination: string,
+    headers: { [key: string]: any } = {},
+    body: string = ''
+  ): void {
+    headers = (Object as any).assign({}, headers);
+
+    const skipContentLengthHeader = headers['content-length'] === false;
+    if (skipContentLengthHeader) {
+      delete headers['content-length'];
+    }
+    this.publish({
+      destination,
+      headers: headers as StompHeaders,
+      body,
+      skipContentLengthHeader,
+    });
+  }
+
+  /**
+   * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}.
+   *
+   * **Deprecated**
+   */
+  set reconnect_delay(value: number) {
+    this.reconnectDelay = value;
+  }
+
+  /**
+   * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}.
+   *
+   * **Deprecated**
+   */
+  get ws(): any {
+    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(): messageCallbackType {
+    return this.onUnhandledMessage;
+  }
+
+  /**
+   * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+   *
+   * **Deprecated**
+   */
+  set onreceive(value: messageCallbackType) {
+    this.onUnhandledMessage = value;
+  }
+
+  /**
+   * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+   * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}.
+   *
+   * **Deprecated**
+   */
+  get onreceipt(): frameCallbackType {
+    return this.onUnhandledReceipt;
+  }
+
+  /**
+   * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+   *
+   * **Deprecated**
+   */
+  set onreceipt(value: frameCallbackType) {
+    this.onUnhandledReceipt = value;
+  }
+
+  private _heartbeatInfo: HeartbeatInfo = new HeartbeatInfo(this);
+
+  /**
+   * 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: { incoming: number; outgoing: number }) {
+    this.heartbeatIncoming = value.incoming;
+    this.heartbeatOutgoing = value.outgoing;
+  }
+}

node_modules/@stomp/stompjs/src/compatibility/heartbeat-info.ts

@@ -0,0 +1,26 @@
+import { CompatClient } from './compat-client';
+
+/**
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export class HeartbeatInfo {
+  constructor(private client: CompatClient) {}
+
+  get outgoing(): number {
+    return this.client.heartbeatOutgoing;
+  }
+
+  set outgoing(value: number) {
+    this.client.heartbeatOutgoing = value;
+  }
+
+  get incoming(): number {
+    return this.client.heartbeatIncoming;
+  }
+
+  set incoming(value: number) {
+    this.client.heartbeatIncoming = value;
+  }
+}

node_modules/@stomp/stompjs/src/compatibility/stomp.ts

@@ -0,0 +1,118 @@
+import { Versions } from '../versions';
+import { CompatClient } from './compat-client';
+import { IStompSocket } from '../types';
+
+/**
+ * @internal
+ */
+declare const WebSocket: {
+  prototype: IStompSocket;
+  new (url: string, protocols?: string | string[]): IStompSocket;
+};
+
+/**
+ * STOMP Class, acts like a factory to create {@link Client}.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * **Deprecated**
+ *
+ * It will be removed in next major version. Please switch to {@link Client}.
+ */
+export class Stomp {
+  /**
+   * 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
+  public static WebSocketClass: any = null;
+
+  /**
+   * This method creates a WebSocket client that is connected to
+   * the STOMP server located at the url.
+   *
+   * ```javascript
+   *        var url = "ws://localhost:61614/stomp";
+   *        var client = Stomp.client(url);
+   * ```
+   *
+   * **Deprecated**
+   *
+   * It will be removed in next major version. Please switch to {@link Client}
+   * using [Client#brokerURL]{@link Client#brokerURL}.
+   */
+  public static client(url: string, protocols?: string[]): CompatClient {
+    // This is a hack to allow another implementation than the standard
+    // HTML5 WebSocket class.
+    //
+    // It is possible to use another class by calling
+    //
+    //     Stomp.WebSocketClass = MozWebSocket
+    //
+    // *prior* to call `Stomp.client()`.
+    //
+    // This hack is deprecated and `Stomp.over()` method should be used
+    // instead.
+
+    // See remarks on the function Stomp.over
+    if (protocols == null) {
+      protocols = Versions.default.protocolVersions();
+    }
+    const wsFn = () => {
+      const klass = Stomp.WebSocketClass || WebSocket;
+      return new klass(url, protocols);
+    };
+
+    return new 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
+   * a similar object).
+   *
+   * In order to support reconnection, the function Client._connect should be callable more than once.
+   * While reconnecting
+   * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function
+   * alternatively allows passing a function that should return a new instance of the underlying socket.
+   *
+   * ```javascript
+   *        var client = Stomp.over(function(){
+   *          return new WebSocket('ws://localhost:15674/ws')
+   *        });
+   * ```
+   *
+   * **Deprecated**
+   *
+   * It will be removed in next major version. Please switch to {@link Client}
+   * using [Client#webSocketFactory]{@link Client#webSocketFactory}.
+   */
+  public static over(ws: any): CompatClient {
+    let wsFn: () => any;
+
+    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 = () => ws;
+    }
+
+    return new CompatClient(wsFn);
+  }
+}

node_modules/@stomp/stompjs/src/frame-impl.ts

@@ -0,0 +1,250 @@
+import { BYTE } from './byte';
+import { IFrame } from './i-frame';
+import { StompHeaders } from './stomp-headers';
+import { IRawFrameType } from './types';
+
+/**
+ * Frame class represents a STOMP frame.
+ *
+ * @internal
+ */
+export class FrameImpl implements IFrame {
+  /**
+   * STOMP Command
+   */
+  public command: string;
+
+  /**
+   * Headers, key value pairs.
+   */
+  public headers: StompHeaders;
+
+  /**
+   * Is this frame binary (based on whether body/binaryBody was passed when creating this frame).
+   */
+  public isBinaryBody: boolean;
+
+  /**
+   * body of the frame
+   */
+  get body(): string {
+    if (!this._body && this.isBinaryBody) {
+      this._body = new TextDecoder().decode(this._binaryBody);
+    }
+    return this._body;
+  }
+  private _body: string;
+
+  /**
+   * body as Uint8Array
+   */
+  get binaryBody(): Uint8Array {
+    if (!this._binaryBody && !this.isBinaryBody) {
+      this._binaryBody = new TextEncoder().encode(this._body);
+    }
+    return this._binaryBody;
+  }
+  private _binaryBody: Uint8Array;
+
+  private escapeHeaderValues: boolean;
+  private skipContentLengthHeader: boolean;
+
+  /**
+   * Frame constructor. `command`, `headers` and `body` are available as properties.
+   *
+   * @internal
+   */
+  constructor(params: {
+    command: string;
+    headers?: StompHeaders;
+    body?: string;
+    binaryBody?: Uint8Array;
+    escapeHeaderValues?: boolean;
+    skipContentLengthHeader?: boolean;
+  }) {
+    const {
+      command,
+      headers,
+      body,
+      binaryBody,
+      escapeHeaderValues,
+      skipContentLengthHeader,
+    } = params;
+    this.command = command;
+    this.headers = (Object as any).assign({}, headers || {});
+
+    if (binaryBody) {
+      this._binaryBody = binaryBody;
+      this.isBinaryBody = true;
+    } else {
+      this._body = body || '';
+      this.isBinaryBody = false;
+    }
+    this.escapeHeaderValues = escapeHeaderValues || false;
+    this.skipContentLengthHeader = skipContentLengthHeader || false;
+  }
+
+  /**
+   * deserialize a STOMP Frame from raw data.
+   *
+   * @internal
+   */
+  public static fromRawFrame(
+    rawFrame: IRawFrameType,
+    escapeHeaderValues: boolean
+  ): FrameImpl {
+    const headers: StompHeaders = {};
+    const trim = (str: string): string => str.replace(/^\s+|\s+$/g, '');
+
+    // In case of repeated headers, as per standards, first value need to be used
+    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,
+      binaryBody: rawFrame.binaryBody,
+      escapeHeaderValues,
+    });
+  }
+
+  /**
+   * @internal
+   */
+  public toString(): string {
+    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.
+   * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer.
+   *
+   * @internal
+   */
+  public serialize(): string | ArrayBuffer {
+    const cmdAndHeaders = this.serializeCmdAndHeaders();
+
+    if (this.isBinaryBody) {
+      return FrameImpl.toUnit8Array(cmdAndHeaders, this._binaryBody).buffer;
+    } else {
+      return cmdAndHeaders + this._body + BYTE.NULL;
+    }
+  }
+
+  private serializeCmdAndHeaders(): string {
+    const lines = [this.command];
+    if (this.skipContentLengthHeader) {
+      delete this.headers['content-length'];
+    }
+
+    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}:${value}`);
+      }
+    }
+    if (
+      this.isBinaryBody ||
+      (!this.isBodyEmpty() && !this.skipContentLengthHeader)
+    ) {
+      lines.push(`content-length:${this.bodyLength()}`);
+    }
+    return lines.join(BYTE.LF) + BYTE.LF + BYTE.LF;
+  }
+
+  private isBodyEmpty(): boolean {
+    return this.bodyLength() === 0;
+  }
+
+  private bodyLength(): number {
+    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)
+   */
+  private static sizeOfUTF8(s: string): number {
+    return s ? new TextEncoder().encode(s).length : 0;
+  }
+
+  private static toUnit8Array(
+    cmdAndHeaders: string,
+    binaryBody: Uint8Array
+  ): Uint8Array {
+    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
+   */
+  public static marshall(params: {
+    command: string;
+    headers?: StompHeaders;
+    body?: string;
+    binaryBody?: Uint8Array;
+    escapeHeaderValues?: boolean;
+    skipContentLengthHeader?: boolean;
+  }) {
+    const frame = new FrameImpl(params);
+    return frame.serialize();
+  }
+
+  /**
+   *  Escape header values
+   */
+  private static hdrValueEscape(str: string): string {
+    return str
+      .replace(/\\/g, '\\\\')
+      .replace(/\r/g, '\\r')
+      .replace(/\n/g, '\\n')
+      .replace(/:/g, '\\c');
+  }
+
+  /**
+   * UnEscape header values
+   */
+  private static hdrValueUnEscape(str: string): string {
+    return str
+      .replace(/\\r/g, '\r')
+      .replace(/\\n/g, '\n')
+      .replace(/\\c/g, ':')
+      .replace(/\\\\/g, '\\');
+  }
+}

node_modules/@stomp/stompjs/src/i-frame.ts

@@ -0,0 +1,41 @@
+import { StompHeaders } from './stomp-headers';
+
+/**
+ * It represents a STOMP frame. Many of the callbacks pass an IFrame received from
+ * the STOMP broker. For advanced usage you might need to access [headers]{@link IFrame#headers}.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * {@link IMessage} is an extended IFrame.
+ */
+export interface IFrame {
+  /**
+   * STOMP Command
+   */
+  command: string;
+
+  /**
+   * Headers, key value pairs.
+   */
+  headers: StompHeaders;
+
+  /**
+   * Is this frame binary (based on whether body/binaryBody was passed when creating this frame).
+   */
+  isBinaryBody: boolean;
+
+  /**
+   * body of the frame as string
+   */
+  readonly body: string;
+
+  /**
+   * body as Uint8Array
+   */
+  readonly binaryBody: Uint8Array;
+}
+
+/**
+ * Alias for {@link IFrame}
+ */
+export type Frame = IFrame;

node_modules/@stomp/stompjs/src/i-message.ts

@@ -0,0 +1,35 @@
+import { IFrame } from './i-frame';
+import { StompHeaders } from './stomp-headers';
+
+/**
+ * Instance of Message will be passed to [subscription callback]{@link Client#subscribe}
+ * and [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+ * Since it is an extended {@link FrameImpl}, you can access [headers]{@link FrameImpl#headers}
+ * and [body]{@link FrameImpl#body} as properties.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * See [Client#subscribe]{@link Client#subscribe} for example.
+ */
+export interface IMessage extends IFrame {
+  /**
+   * When subscribing with manual acknowledgement, call this method on the message to ACK the message.
+   *
+   * See [Client#ack]{@link Client#ack} for an example.
+   */
+  ack: (headers?: StompHeaders) => void;
+
+  /**
+   * When subscribing with manual acknowledgement, call this method on the message to NACK the message.
+   *
+   * See [Client#nack]{@link Client#nack} for an example.
+   */
+  nack: (headers?: StompHeaders) => void;
+}
+
+/**
+ * Aliased to {@link IMessage}.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export type Message = IMessage;

node_modules/@stomp/stompjs/src/i-transaction.ts

@@ -0,0 +1,23 @@
+/**
+ * A Transaction is created by calling [Client#begin]{@link Client#begin}
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * TODO: Example and caveat
+ */
+export interface ITransaction {
+  /**
+   * You will need to access this to send, ack, or nack within this transaction.
+   */
+  id: string;
+
+  /**
+   * Commit this transaction. See [Client#commit]{@link Client#commit} for an example.
+   */
+  commit: () => void;
+
+  /**
+   * Abort this transaction. See [Client#abort]{@link Client#abort} for an example.
+   */
+  abort: () => void;
+}

node_modules/@stomp/stompjs/src/index.ts

@@ -0,0 +1,15 @@
+export * from './client';
+export * from './frame-impl';
+export * from './i-frame';
+export * from './i-message';
+export * from './parser';
+export * from './stomp-config';
+export * from './stomp-headers';
+export * from './stomp-subscription';
+export * from './i-transaction';
+export * from './types';
+export * from './versions';
+
+// Compatibility code
+export * from './compatibility/compat-client';
+export * from './compatibility/stomp';

node_modules/@stomp/stompjs/src/parser.ts

@@ -0,0 +1,255 @@
+import { IRawFrameType } from './types';
+
+/**
+ * @internal
+ */
+const NULL = 0;
+/**
+ * @internal
+ */
+const LF = 10;
+/**
+ * @internal
+ */
+const CR = 13;
+/**
+ * @internal
+ */
+const COLON = 58;
+
+/**
+ * This is an evented, rec descent parser.
+ * A stream of Octets can be passed and whenever it recognizes
+ * a complete Frame or an incoming ping it will invoke the registered callbacks.
+ *
+ * All incoming Octets are fed into _onByte function.
+ * Depending on current state the _onByte function keeps changing.
+ * Depending on the state it keeps accumulating into _token and _results.
+ * State is indicated by current value of _onByte, all states are named as _collect.
+ *
+ * STOMP standards https://stomp.github.io/stomp-specification-1.2.html
+ * imply that all lengths are considered in bytes (instead of string lengths).
+ * So, before actual parsing, if the incoming data is String it is converted to Octets.
+ * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body.
+ *
+ * There is no peek function on the incoming data.
+ * When a state change occurs based on an Octet without consuming the Octet,
+ * the Octet, after state change, is fed again (_reinjectByte).
+ * This became possible as the state change can be determined by inspecting just one Octet.
+ *
+ * There are two modes to collect the body, if content-length header is there then it by counting Octets
+ * otherwise it is determined by NULL terminator.
+ *
+ * Following the standards, the command and headers are converted to Strings
+ * and the body is returned as Octets.
+ * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header.
+ *
+ * This parser does not use Regular Expressions as that can only operate on Strings.
+ *
+ * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or
+ * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk
+ * is pushed.
+ *
+ * Typically the higher level function will convert headers to Hash, handle unescaping of header values
+ * (which is protocol version specific), and convert body to text.
+ *
+ * Check the parser.spec.js to understand cases that this parser is supposed to handle.
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export class Parser {
+  private readonly _encoder = new TextEncoder();
+  private readonly _decoder = new TextDecoder();
+
+  private _results: IRawFrameType;
+
+  private _token: number[] = [];
+  private _headerKey: string;
+  private _bodyBytesRemaining: number;
+
+  private _onByte: (byte: number) => void;
+
+  public constructor(
+    public onFrame: (rawFrame: IRawFrameType) => void,
+    public onIncomingPing: () => void
+  ) {
+    this._initState();
+  }
+
+  public parseChunk(
+    segment: string | ArrayBuffer,
+    appendMissingNULLonIncoming: boolean = false
+  ) {
+    let chunk: Uint8Array;
+
+    if (segment instanceof ArrayBuffer) {
+      chunk = new Uint8Array(segment);
+    } else {
+      chunk = this._encoder.encode(segment);
+    }
+
+    // See https://github.com/stomp-js/stompjs/issues/89
+    // Remove when underlying issue is fixed.
+    //
+    // Send a NULL byte, if the last byte of a Text frame was not NULL.F
+    if (appendMissingNULLonIncoming && chunk[chunk.length - 1] !== 0) {
+      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 (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
+
+  private _collectFrame(byte: number): void {
+    if (byte === NULL) {
+      // Ignore
+      return;
+    }
+    if (byte === CR) {
+      // Ignore CR
+      return;
+    }
+    if (byte === LF) {
+      // Incoming Ping
+      this.onIncomingPing();
+      return;
+    }
+
+    this._onByte = this._collectCommand;
+    this._reinjectByte(byte);
+  }
+
+  private _collectCommand(byte: number): void {
+    if (byte === CR) {
+      // Ignore CR
+      return;
+    }
+    if (byte === LF) {
+      this._results.command = this._consumeTokenAsUTF8();
+      this._onByte = this._collectHeaders;
+      return;
+    }
+
+    this._consumeByte(byte);
+  }
+
+  private _collectHeaders(byte: number): void {
+    if (byte === CR) {
+      // Ignore CR
+      return;
+    }
+    if (byte === LF) {
+      this._setupCollectBody();
+      return;
+    }
+    this._onByte = this._collectHeaderKey;
+    this._reinjectByte(byte);
+  }
+
+  private _reinjectByte(byte: number) {
+    this._onByte(byte);
+  }
+
+  private _collectHeaderKey(byte: number): void {
+    if (byte === COLON) {
+      this._headerKey = this._consumeTokenAsUTF8();
+      this._onByte = this._collectHeaderValue;
+      return;
+    }
+    this._consumeByte(byte);
+  }
+
+  private _collectHeaderValue(byte: number): void {
+    if (byte === CR) {
+      // Ignore CR
+      return;
+    }
+    if (byte === LF) {
+      this._results.headers.push([this._headerKey, this._consumeTokenAsUTF8()]);
+      this._headerKey = undefined;
+      this._onByte = this._collectHeaders;
+      return;
+    }
+    this._consumeByte(byte);
+  }
+
+  private _setupCollectBody() {
+    const contentLengthHeader = this._results.headers.filter(
+      (header: [string, string]) => {
+        return header[0] === 'content-length';
+      }
+    )[0];
+
+    if (contentLengthHeader) {
+      this._bodyBytesRemaining = parseInt(contentLengthHeader[1], 10);
+      this._onByte = this._collectBodyFixedSize;
+    } else {
+      this._onByte = this._collectBodyNullTerminated;
+    }
+  }
+
+  private _collectBodyNullTerminated(byte: number): void {
+    if (byte === NULL) {
+      this._retrievedBody();
+      return;
+    }
+    this._consumeByte(byte);
+  }
+
+  private _collectBodyFixedSize(byte: number): void {
+    // It is post decrement, so that we discard the trailing NULL octet
+    if (this._bodyBytesRemaining-- === 0) {
+      this._retrievedBody();
+      return;
+    }
+    this._consumeByte(byte);
+  }
+
+  private _retrievedBody() {
+    this._results.binaryBody = this._consumeTokenAsRaw();
+
+    this.onFrame(this._results);
+
+    this._initState();
+  }
+
+  // Rec Descent Parser helpers
+
+  private _consumeByte(byte: number) {
+    this._token.push(byte);
+  }
+
+  private _consumeTokenAsUTF8() {
+    return this._decoder.decode(this._consumeTokenAsRaw());
+  }
+
+  private _consumeTokenAsRaw() {
+    const rawResult = new Uint8Array(this._token);
+    this._token = [];
+    return rawResult;
+  }
+
+  private _initState() {
+    this._results = {
+      command: undefined,
+      headers: [],
+      binaryBody: undefined,
+    };
+
+    this._token = [];
+    this._headerKey = undefined;
+
+    this._onByte = this._collectFrame;
+  }
+}

node_modules/@stomp/stompjs/src/stomp-config.ts

@@ -0,0 +1,152 @@
+import { StompHeaders } from './stomp-headers';
+import {
+  ActivationState,
+  closeEventCallbackType,
+  debugFnType,
+  frameCallbackType,
+  messageCallbackType,
+  wsErrorCallbackType,
+} from './types';
+import { Versions } from './versions';
+
+/**
+ * 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`.
+ */
+export class StompConfig {
+  /**
+   * See [Client#brokerURL]{@link Client#brokerURL}.
+   */
+  public brokerURL?: string;
+
+  /**
+   * See See [Client#stompVersions]{@link Client#stompVersions}.
+   */
+  public stompVersions?: Versions;
+
+  /**
+   * See [Client#webSocketFactory]{@link Client#webSocketFactory}.
+   */
+  public webSocketFactory?: () => any;
+
+  /**
+   * See [Client#connectionTimeout]{@link Client#connectionTimeout}.
+   */
+  public connectionTimeout?: number;
+
+  /**
+   * See [Client#reconnectDelay]{@link Client#reconnectDelay}.
+   */
+  public reconnectDelay?: number;
+
+  /**
+   * See [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}.
+   */
+  public heartbeatIncoming?: number;
+
+  /**
+   * See [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}.
+   */
+  public heartbeatOutgoing?: number;
+
+  /**
+   * See [Client#splitLargeFrames]{@link Client#splitLargeFrames}.
+   */
+  public splitLargeFrames?: boolean;
+
+  /**
+   * See [Client#forceBinaryWSFrames]{@link Client#forceBinaryWSFrames}.
+   */
+  public forceBinaryWSFrames?: boolean;
+
+  /**
+   * See [Client#appendMissingNULLonIncoming]{@link Client#appendMissingNULLonIncoming}.
+   */
+  public appendMissingNULLonIncoming?: boolean;
+
+  /**
+   * See [Client#maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}.
+   */
+  public maxWebSocketChunkSize?: number;
+
+  /**
+   * See [Client#connectHeaders]{@link Client#connectHeaders}.
+   */
+  public connectHeaders?: StompHeaders;
+
+  /**
+   * See [Client#disconnectHeaders]{@link Client#disconnectHeaders}.
+   */
+  public disconnectHeaders?: StompHeaders;
+
+  /**
+   * See [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}.
+   */
+  public onUnhandledMessage?: messageCallbackType;
+
+  /**
+   * See [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}.
+   */
+  public onUnhandledReceipt?: frameCallbackType;
+
+  /**
+   * See [Client#onUnhandledFrame]{@link Client#onUnhandledFrame}.
+   */
+  public onUnhandledFrame?: frameCallbackType;
+
+  /**
+   * See [Client#beforeConnect]{@link Client#beforeConnect}.
+   */
+  public beforeConnect?: () => void | Promise<void>;
+
+  /**
+   * See [Client#onConnect]{@link Client#onConnect}.
+   */
+  public onConnect?: frameCallbackType;
+
+  /**
+   * See [Client#onDisconnect]{@link Client#onDisconnect}.
+   */
+  public onDisconnect?: frameCallbackType;
+
+  /**
+   * See [Client#onStompError]{@link Client#onStompError}.
+   */
+  public onStompError?: frameCallbackType;
+
+  /**
+   * See [Client#onWebSocketClose]{@link Client#onWebSocketClose}.
+   */
+  public onWebSocketClose?: closeEventCallbackType;
+
+  /**
+   * See [Client#onWebSocketError]{@link Client#onWebSocketError}.
+   */
+  public onWebSocketError?: wsErrorCallbackType;
+
+  /**
+   * See [Client#logRawCommunication]{@link Client#logRawCommunication}.
+   */
+  public logRawCommunication?: boolean;
+
+  /**
+   * See [Client#debug]{@link Client#debug}.
+   */
+  public debug?: debugFnType;
+
+  /**
+   * See [Client#discardWebsocketOnCommFailure]{@link Client#discardWebsocketOnCommFailure}.
+   */
+  public discardWebsocketOnCommFailure?: boolean;
+
+  /**
+   * See [Client#onChangeState]{@link Client#onChangeState}.
+   */
+  public onChangeState?: (state: ActivationState) => void;
+}

node_modules/@stomp/stompjs/src/stomp-handler.ts

@@ -0,0 +1,539 @@
+import { BYTE } from './byte';
+import { Client } from './client';
+import { FrameImpl } from './frame-impl';
+import { IMessage } from './i-message';
+import { ITransaction } from './i-transaction';
+import { Parser } from './parser';
+import { StompConfig } from './stomp-config';
+import { StompHeaders } from './stomp-headers';
+import { StompSubscription } from './stomp-subscription';
+import {
+  closeEventCallbackType,
+  debugFnType,
+  frameCallbackType,
+  IPublishParams,
+  IStompSocket,
+  IStompSocketMessageEvent,
+  messageCallbackType,
+  StompSocketState,
+  wsErrorCallbackType,
+} from './types';
+import { Versions } from './versions';
+import { augmentWebsocket } from './augment-websocket';
+
+/**
+ * The STOMP protocol handler
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export class StompHandler {
+  public debug: debugFnType;
+
+  public stompVersions: Versions;
+
+  public connectHeaders: StompHeaders;
+
+  public disconnectHeaders: StompHeaders;
+
+  public heartbeatIncoming: number;
+
+  public heartbeatOutgoing: number;
+
+  public onUnhandledMessage: messageCallbackType;
+
+  public onUnhandledReceipt: frameCallbackType;
+
+  public onUnhandledFrame: frameCallbackType;
+
+  public onConnect: frameCallbackType;
+
+  public onDisconnect: frameCallbackType;
+
+  public onStompError: frameCallbackType;
+
+  public onWebSocketClose: closeEventCallbackType;
+
+  public onWebSocketError: wsErrorCallbackType;
+
+  public logRawCommunication: boolean;
+
+  public splitLargeFrames: boolean;
+
+  public maxWebSocketChunkSize: number;
+
+  public forceBinaryWSFrames: boolean;
+
+  public appendMissingNULLonIncoming: boolean;
+
+  public discardWebsocketOnCommFailure: boolean;
+
+  get connectedVersion(): string {
+    return this._connectedVersion;
+  }
+  private _connectedVersion: string;
+
+  get connected(): boolean {
+    return this._connected;
+  }
+
+  private _connected: boolean;
+
+  private readonly _subscriptions: { [key: string]: messageCallbackType };
+  private readonly _receiptWatchers: { [key: string]: frameCallbackType };
+  private _partialData: string;
+  private _escapeHeaderValues: boolean;
+  private _counter: number;
+  private _pinger: any;
+  private _ponger: any;
+  private _lastServerActivityTS: number;
+
+  private _onclose: (closeEvent: any) => void;
+
+  constructor(
+    private _client: Client,
+    public _webSocket: IStompSocket,
+    config: StompConfig = {}
+  ) {
+    // used to index subscribers
+    this._counter = 0;
+
+    // subscription callbacks indexed by subscriber's ID
+    this._subscriptions = {};
+
+    // receipt-watchers indexed by receipts-ids
+    this._receiptWatchers = {};
+
+    this._partialData = '';
+
+    this._escapeHeaderValues = false;
+
+    this._lastServerActivityTS = Date.now();
+
+    this.configure(config);
+  }
+
+  public configure(conf: StompConfig): void {
+    // bulk assign all properties to this
+    (Object as any).assign(this, conf);
+  }
+
+  public start(): void {
+    const parser = new Parser(
+      // On Frame
+      rawFrame => {
+        const frame = FrameImpl.fromRawFrame(
+          rawFrame,
+          this._escapeHeaderValues
+        );
+
+        // if this.logRawCommunication is set, the rawChunk is logged at this._webSocket.onmessage
+        if (!this.logRawCommunication) {
+          this.debug(`<<< ${frame}`);
+        }
+
+        const serverFrameHandler =
+          this._serverFrameHandlers[frame.command] || this.onUnhandledFrame;
+        serverFrameHandler(frame);
+      },
+      // On Incoming Ping
+      () => {
+        this.debug('<<< PONG');
+      }
+    );
+
+    this._webSocket.onmessage = (evt: IStompSocketMessageEvent) => {
+      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);
+    };
+
+    this._onclose = (closeEvent): void => {
+      this.debug(`Connection closed to ${this._client.brokerURL}`);
+      this._cleanUp();
+      this.onWebSocketClose(closeEvent);
+    };
+
+    this._webSocket.onclose = this._onclose;
+
+    this._webSocket.onerror = (errorEvent): void => {
+      this.onWebSocketError(errorEvent);
+    };
+
+    this._webSocket.onopen = () => {
+      // Clone before updating
+      const connectHeaders = (Object as any).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 });
+    };
+  }
+
+  private readonly _serverFrameHandlers: {
+    [key: string]: frameCallbackType;
+  } = {
+    // [CONNECTED Frame](http://stomp.github.com/stomp-specification-1.2.html#CONNECTED_Frame)
+    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.V1_2) {
+        this._escapeHeaderValues = true;
+      }
+
+      this._setupHeartbeat(frame.headers);
+      this.onConnect(frame);
+    },
+
+    // [MESSAGE Frame](http://stomp.github.com/stomp-specification-1.2.html#MESSAGE)
+    MESSAGE: frame => {
+      // the callback is registered when the client calls
+      // `subscribe()`.
+      // If there is no registered subscription for the received message,
+      // the default `onUnhandledMessage` callback is used that the client can set.
+      // 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)).
+      const subscription = frame.headers.subscription;
+      const onReceive =
+        this._subscriptions[subscription] || this.onUnhandledMessage;
+
+      // bless the frame to be a Message
+      const message = frame as IMessage;
+
+      const client = this;
+      const messageId =
+        this._connectedVersion === 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 = (headers: StompHeaders = {}): void => {
+        return client.ack(messageId, subscription, headers);
+      };
+      message.nack = (headers: StompHeaders = {}): void => {
+        return client.nack(messageId, subscription, headers);
+      };
+      onReceive(message);
+    },
+
+    // [RECEIPT Frame](http://stomp.github.com/stomp-specification-1.2.html#RECEIPT)
+    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']];
+      } else {
+        this.onUnhandledReceipt(frame);
+      }
+    },
+
+    // [ERROR Frame](http://stomp.github.com/stomp-specification-1.2.html#ERROR)
+    ERROR: frame => {
+      this.onStompError(frame);
+    },
+  };
+
+  private _setupHeartbeat(headers: StompHeaders): void {
+    if (
+      headers.version !== Versions.V1_1 &&
+      headers.version !== Versions.V1_2
+    ) {
+      return;
+    }
+
+    // It is valid for the server to not send this header
+    // https://stomp.github.io/stomp-specification-1.2.html#Heart-beating
+    if (!headers['heart-beat']) {
+      return;
+    }
+
+    // heart-beat header received from the server looks like:
+    //
+    //     heart-beat: sx, sy
+    const [serverOutgoing, serverIncoming] = headers['heart-beat']
+      .split(',')
+      .map((v: string) => parseInt(v, 10));
+
+    if (this.heartbeatOutgoing !== 0 && serverIncoming !== 0) {
+      const ttl: number = Math.max(this.heartbeatOutgoing, serverIncoming);
+      this.debug(`send PING every ${ttl}ms`);
+      this._pinger = setInterval(() => {
+        if (this._webSocket.readyState === StompSocketState.OPEN) {
+          this._webSocket.send(BYTE.LF);
+          this.debug('>>> PING');
+        }
+      }, ttl);
+    }
+
+    if (this.heartbeatIncoming !== 0 && serverOutgoing !== 0) {
+      const ttl: number = 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 * 2) {
+          this.debug(`did not receive server activity for the last ${delta}ms`);
+          this._closeOrDiscardWebsocket();
+        }
+      }, ttl);
+    }
+  }
+
+  private _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();
+    }
+  }
+
+  public forceDisconnect() {
+    if (this._webSocket) {
+      if (
+        this._webSocket.readyState === StompSocketState.CONNECTING ||
+        this._webSocket.readyState === StompSocketState.OPEN
+      ) {
+        this._closeOrDiscardWebsocket();
+      }
+    }
+  }
+
+  public _closeWebsocket() {
+    this._webSocket.onmessage = () => {}; // ignore messages
+    this._webSocket.close();
+  }
+
+  private _discardWebsocket() {
+    if (!this._webSocket.terminate) {
+      augmentWebsocket(this._webSocket, (msg: string) => this.debug(msg));
+    }
+
+    this._webSocket.terminate();
+  }
+
+  private _transmit(params: {
+    command: string;
+    headers?: StompHeaders;
+    body?: string;
+    binaryBody?: Uint8Array;
+    skipContentLengthHeader?: boolean;
+  }): void {
+    const { command, headers, body, binaryBody, skipContentLengthHeader } =
+      params;
+    const frame = new FrameImpl({
+      command,
+      headers,
+      body,
+      binaryBody,
+      escapeHeaderValues: this._escapeHeaderValues,
+      skipContentLengthHeader,
+    });
+
+    let rawChunk = frame.serialize();
+
+    if (this.logRawCommunication) {
+      this.debug(`>>> ${rawChunk}`);
+    } else {
+      this.debug(`>>> ${frame}`);
+    }
+
+    if (this.forceBinaryWSFrames && typeof rawChunk === 'string') {
+      rawChunk = new TextEncoder().encode(rawChunk);
+    }
+
+    if (typeof rawChunk !== 'string' || !this.splitLargeFrames) {
+      this._webSocket.send(rawChunk);
+    } else {
+      let out = rawChunk as string;
+      while (out.length > 0) {
+        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}`);
+      }
+    }
+  }
+
+  public dispose(): void {
+    if (this.connected) {
+      try {
+        // clone before updating
+        const disconnectHeaders = (Object as any).assign(
+          {},
+          this.disconnectHeaders
+        );
+
+        if (!disconnectHeaders.receipt) {
+          disconnectHeaders.receipt = `close-${this._counter++}`;
+        }
+        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}`);
+      }
+    } else {
+      if (
+        this._webSocket.readyState === StompSocketState.CONNECTING ||
+        this._webSocket.readyState === StompSocketState.OPEN
+      ) {
+        this._closeWebsocket();
+      }
+    }
+  }
+
+  private _cleanUp() {
+    this._connected = false;
+
+    if (this._pinger) {
+      clearInterval(this._pinger);
+    }
+    if (this._ponger) {
+      clearInterval(this._ponger);
+    }
+  }
+
+  public publish(params: IPublishParams): void {
+    const { destination, headers, body, binaryBody, skipContentLengthHeader } =
+      params;
+    const hdrs: StompHeaders = (Object as any).assign({ destination }, headers);
+    this._transmit({
+      command: 'SEND',
+      headers: hdrs,
+      body,
+      binaryBody,
+      skipContentLengthHeader,
+    });
+  }
+
+  public watchForReceipt(receiptId: string, callback: frameCallbackType): void {
+    this._receiptWatchers[receiptId] = callback;
+  }
+
+  public subscribe(
+    destination: string,
+    callback: messageCallbackType,
+    headers: StompHeaders = {}
+  ): StompSubscription {
+    headers = (Object as any).assign({}, headers);
+
+    if (!headers.id) {
+      headers.id = `sub-${this._counter++}`;
+    }
+    headers.destination = destination;
+    this._subscriptions[headers.id] = callback;
+    this._transmit({ command: 'SUBSCRIBE', headers });
+    const client = this;
+    return {
+      id: headers.id,
+
+      unsubscribe(hdrs) {
+        return client.unsubscribe(headers.id, hdrs);
+      },
+    };
+  }
+
+  public unsubscribe(id: string, headers: StompHeaders = {}): void {
+    headers = (Object as any).assign({}, headers);
+
+    delete this._subscriptions[id];
+    headers.id = id;
+    this._transmit({ command: 'UNSUBSCRIBE', headers });
+  }
+
+  public begin(transactionId: string): ITransaction {
+    const txId = transactionId || `tx-${this._counter++}`;
+    this._transmit({
+      command: 'BEGIN',
+      headers: {
+        transaction: txId,
+      },
+    });
+    const client = this;
+    return {
+      id: txId,
+      commit(): void {
+        client.commit(txId);
+      },
+      abort(): void {
+        client.abort(txId);
+      },
+    };
+  }
+
+  public commit(transactionId: string): void {
+    this._transmit({
+      command: 'COMMIT',
+      headers: {
+        transaction: transactionId,
+      },
+    });
+  }
+
+  public abort(transactionId: string): void {
+    this._transmit({
+      command: 'ABORT',
+      headers: {
+        transaction: transactionId,
+      },
+    });
+  }
+
+  public ack(
+    messageId: string,
+    subscriptionId: string,
+    headers: StompHeaders = {}
+  ): void {
+    headers = (Object as any).assign({}, headers);
+
+    if (this._connectedVersion === Versions.V1_2) {
+      headers.id = messageId;
+    } else {
+      headers['message-id'] = messageId;
+    }
+    headers.subscription = subscriptionId;
+    this._transmit({ command: 'ACK', headers });
+  }
+
+  public nack(
+    messageId: string,
+    subscriptionId: string,
+    headers: StompHeaders = {}
+  ): void {
+    headers = (Object as any).assign({}, headers);
+
+    if (this._connectedVersion === Versions.V1_2) {
+      headers.id = messageId;
+    } else {
+      headers['message-id'] = messageId;
+    }
+    headers.subscription = subscriptionId;
+    return this._transmit({ command: 'NACK', headers });
+  }
+}

node_modules/@stomp/stompjs/src/stomp-headers.ts

@@ -0,0 +1,12 @@
+/**
+ * STOMP headers. Many functions calls will accept headers as parameters.
+ * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}.
+ *
+ * `key` and `value` must be valid strings.
+ * In addition, `key` must not contain `CR`, `LF`, or `:`.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class StompHeaders {
+  [key: string]: string;
+}

node_modules/@stomp/stompjs/src/stomp-subscription.ts

@@ -0,0 +1,18 @@
+import { StompHeaders } from './stomp-headers';
+
+/**
+ * Call [Client#subscribe]{@link Client#subscribe} to create a StompSubscription.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class StompSubscription {
+  /**
+   * Id associated with this subscription.
+   */
+  public id: string;
+
+  /**
+   * Unsubscribe. See [Client#unsubscribe]{@link Client#unsubscribe} for an example.
+   */
+  public unsubscribe: (headers?: StompHeaders) => void;
+}

node_modules/@stomp/stompjs/src/types.ts

@@ -0,0 +1,156 @@
+import { IFrame } from './i-frame';
+import { IMessage } from './i-message';
+import { StompHeaders } from './stomp-headers';
+
+/**
+ * This callback will receive a `string` as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export type debugFnType = (msg: string) => void;
+
+/**
+ * This callback will receive a {@link IMessage} as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export type messageCallbackType = (message: IMessage) => void;
+
+/**
+ * This callback will receive a {@link IFrame} as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export type frameCallbackType = (receipt: IFrame) => void;
+
+/**
+ * This callback will receive a [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
+ * as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export type closeEventCallbackType<T = any> = (evt: T) => void;
+
+/**
+ * This callback will receive an [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event}
+ * as parameter.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export type wsErrorCallbackType<T = any> = (evt: T) => void;
+
+/**
+ * Parameters for [Client#publish]{@link Client#publish}.
+ * Aliased as publishParams as well.
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export interface IPublishParams {
+  /**
+   * destination end point
+   */
+  destination: string;
+  /**
+   * headers (optional)
+   */
+  headers?: StompHeaders;
+  /**
+   * body (optional)
+   */
+  body?: string;
+  /**
+   * binary body (optional)
+   */
+  binaryBody?: Uint8Array;
+  /**
+   * By default a `content-length` header will be added in the Frame to the broker.
+   * Set it to `true` for the header to be skipped.
+   */
+  skipContentLengthHeader?: boolean;
+}
+
+/**
+ * Backward compatibility, switch to {@link IPublishParams}.
+ */
+export type publishParams = IPublishParams;
+
+/**
+ * Used in {@link IRawFrameType}
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export type RawHeaderType = [string, string];
+
+/**
+ * The parser yield frames in this structure
+ *
+ * Part of `@stomp/stompjs`.
+ *
+ * @internal
+ */
+export interface IRawFrameType {
+  command: string;
+  headers: RawHeaderType[];
+  binaryBody: Uint8Array;
+}
+
+/**
+ * @internal
+ */
+export interface IStompSocketMessageEvent {
+  data?: string | ArrayBuffer;
+}
+
+/**
+ * Copied from Websocket interface to avoid dom typelib dependency.
+ *
+ * @internal
+ */
+export interface IStompSocket {
+  onclose: ((this: IStompSocket, ev?: any) => any) | null;
+  onerror: ((this: IStompSocket, ev: any) => any) | null;
+  onmessage: ((this: IStompSocket, ev: IStompSocketMessageEvent) => any) | null;
+  onopen: ((this: IStompSocket, ev?: any) => any) | null;
+  terminate?: ((this: IStompSocket) => any) | null;
+
+  /**
+   * Returns a string that indicates how binary data from the socket is exposed to scripts:
+   * We support only 'arraybuffer'.
+   */
+  binaryType: 'arraybuffer';
+
+  /**
+   * Returns the state of the socket connection. It can have the values of StompSocketState.
+   */
+  readonly readyState: number;
+
+  /**
+   * Closes the connection.
+   */
+  close(): void;
+  /**
+   * Transmits data using the connection. data can be a string or an ArrayBuffer.
+   */
+  send(data: string | ArrayBuffer): void;
+}
+
+/**
+ * Possible states for the IStompSocket
+ */
+export enum StompSocketState {
+  CONNECTING,
+  OPEN,
+  CLOSING,
+  CLOSED,
+}
+
+/**
+ * Possible activation state
+ */
+export enum ActivationState {
+  ACTIVE,
+  DEACTIVATING,
+  INACTIVE,
+}

node_modules/@stomp/stompjs/src/versions.ts

@@ -0,0 +1,50 @@
+/**
+ * Supported STOMP versions
+ *
+ * Part of `@stomp/stompjs`.
+ */
+export class Versions {
+  /**
+   * Indicates protocol version 1.0
+   */
+  public static V1_0 = '1.0';
+  /**
+   * Indicates protocol version 1.1
+   */
+  public static V1_1 = '1.1';
+  /**
+   * Indicates protocol version 1.2
+   */
+  public static V1_2 = '1.2';
+
+  /**
+   * @internal
+   */
+  public static default = new Versions([
+    Versions.V1_0,
+    Versions.V1_1,
+    Versions.V1_2,
+  ]);
+
+  /**
+   * 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.
+   */
+  constructor(public versions: string[]) {}
+
+  /**
+   * Used as part of CONNECT STOMP Frame
+   */
+  public supportedVersions() {
+    return this.versions.join(',');
+  }
+
+  /**
+   * Used while creating a WebSocket
+   */
+  public protocolVersions() {
+    return this.versions.map(x => `v${x.replace('.', '')}.stomp`);
+  }
+}