Index: trip-planner-front/node_modules/engine.io/CHANGELOG.md
===================================================================
--- trip-planner-front/node_modules/engine.io/CHANGELOG.md	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/engine.io/CHANGELOG.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -1,2 +1,122 @@
+# [6.1.0](https://github.com/socketio/engine.io/compare/6.0.0...6.1.0) (2021-11-08)
+
+
+### Bug Fixes
+
+* fix payload encoding for v3 clients ([ed50fc3](https://github.com/socketio/engine.io/commit/ed50fc346b9c58459bf4e6fe5c45e8d34faac8da))
+
+
+### Features
+
+* add an implementation based on uWebSockets.js ([271e2df](https://github.com/socketio/engine.io/commit/271e2df94d39bbd13c33cab98cdd5915f9d28536))
+
+
+### Performance Improvements
+
+* refresh ping timer ([#628](https://github.com/socketio/engine.io/issues/628)) ([37474c7](https://github.com/socketio/engine.io/commit/37474c7e67be7c5f25f9ca2d4ea99f3a256bd2de))
+
+
+
+## [6.0.1](https://github.com/socketio/engine.io/compare/6.0.0...6.0.1) (2021-11-06)
+
+
+### Bug Fixes
+
+* fix payload encoding for v3 clients ([3f42262](https://github.com/socketio/engine.io/commit/3f42262fd27a77a7383cdbb44ede7c6211a9782b))
+
+
+
+# [6.0.0](https://github.com/socketio/engine.io/compare/5.2.0...6.0.0) (2021-10-08)
+
+The codebase was migrated to TypeScript ([c0d6eaa](https://github.com/socketio/engine.io/commit/c0d6eaa1ba1291946dc8425d5f533d5f721862dd))
+
+An ES module wrapper was also added ([401f4b6](https://github.com/socketio/engine.io/commit/401f4b60693fb6702c942692ce42e5bb701d81d7)).
+
+Please note that the communication protocol was not updated, so a v5 client will be able to reach a v6 server (and vice-versa).
+
+Reference: https://github.com/socketio/engine.io-protocol
+
+### BREAKING CHANGES
+
+- the default export was removed, so the following code won't work anymore:
+
+```js
+const eioServer = require("engine.io")(httpServer);
+```
+
+Please use this instead:
+
+```js
+const { Server } = require("engine.io");
+const eioServer = new Server(httpServer);
+```
+
+### Dependencies
+
+`ws` version: `~8.2.3` (bumped from `~7.4.2`)
+
+# [5.2.0](https://github.com/socketio/engine.io/compare/5.1.1...5.2.0) (2021-08-29)
+
+No change on the server-side, this matches the client release.
+
+
+## [5.1.1](https://github.com/socketio/engine.io/compare/5.1.0...5.1.1) (2021-05-16)
+
+
+### Bug Fixes
+
+* properly close the websocket connection upon handshake error ([4360686](https://github.com/socketio/engine.io/commit/43606865e5299747cbb31f3ed9baf4567502a879))
+
+
+# [5.1.0](https://github.com/socketio/engine.io/compare/5.0.0...5.1.0) (2021-05-04)
+
+
+### Features
+
+* add a "connection_error" event ([7096e98](https://github.com/socketio/engine.io/commit/7096e98a02295a62c8ea2aa56461d4875887092d))
+* add the "initial_headers" and "headers" events ([2527543](https://github.com/socketio/engine.io/commit/252754353a0e88eb036ebb3082e9d6a9a5f497db))
+
+
+### Performance Improvements
+
+* **websocket:** add a "wsPreEncoded" writing option ([7706b12](https://github.com/socketio/engine.io/commit/7706b123df914777d19c8179b45ab6932f82916c))
+* **websocket:** fix write back-pressure ([#618](https://github.com/socketio/engine.io/issues/618)) ([ad5306a](https://github.com/socketio/engine.io/commit/ad5306aeaedf06ac7a49f791e1b76e55c35a564e))
+
+
+# [5.0.0](https://github.com/socketio/engine.io/compare/4.1.1...5.0.0) (2021-03-10)
+
+
+### Bug Fixes
+
+* set default protocol version to 3 ([#616](https://github.com/socketio/engine.io/issues/616)) ([868d891](https://github.com/socketio/engine.io/commit/868d89111de0ab5bd0e147ecaff7983afbf5d087))
+
+
+### Features
+
+* increase the default value of pingTimeout ([5a7fa13](https://github.com/socketio/engine.io/commit/5a7fa132c442bc1e7eefa1cf38168ee951575ded))
+* remove dynamic require() with wsEngine ([edb7343](https://github.com/socketio/engine.io/commit/edb734316f143bf0f1bbc344e966d18e2676b934))
+
+
+### BREAKING CHANGES
+
+* the syntax of the "wsEngine" option is updated
+
+Before:
+
+```js
+const eioServer = require("engine.io")(httpServer, {
+  wsEngine: "eiows"
+});
+```
+
+After:
+
+```js
+const eioServer = require("engine.io")(httpServer, {
+  wsEngine: require("eiows").Server
+});
+```
+
+
 ## [4.1.1](https://github.com/socketio/engine.io/compare/4.1.0...4.1.1) (2021-02-02)
 
Index: trip-planner-front/node_modules/engine.io/README.md
===================================================================
--- trip-planner-front/node_modules/engine.io/README.md	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/engine.io/README.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -2,5 +2,5 @@
 # Engine.IO: the realtime engine
 
-[![Build Status](https://github.com/socketio/engine.io/workflows/CI/badge.svg?branch=master))](https://github.com/socketio/engine.io/actions)
+[![Build Status](https://github.com/socketio/engine.io/workflows/CI/badge.svg?branch=master)](https://github.com/socketio/engine.io/actions)
 [![NPM version](https://badge.fury.io/js/engine.io.svg)](http://badge.fury.io/js/engine.io)
 
@@ -189,5 +189,5 @@
 const httpServer = require('http').createServer().listen(3000);
 const server = engine.attach(httpServer, {
-  wsEngine: 'uws' // requires having uws as dependency
+  wsEngine: require('eiows').Server // requires having eiows as dependency
 });
 
@@ -205,4 +205,35 @@
     - **Arguments**
       - `Socket`: a Socket object
+
+- `initial_headers`
+    - Fired on the first request of the connection, before writing the response headers
+    - **Arguments**
+      - `headers` (`Object`): a hash of headers
+      - `req` (`http.IncomingMessage`): the request
+
+- `headers`
+    - Fired on the all requests of the connection, before writing the response headers
+    - **Arguments**
+      - `headers` (`Object`): a hash of headers
+      - `req` (`http.IncomingMessage`): the request
+
+- `connection_error`
+    - Fired when an error occurs when establishing the connection.
+    - **Arguments**
+      - `error`: an object with following properties:
+        - `req` (`http.IncomingMessage`): the request that was dropped
+        - `code` (`Number`): one of `Server.errors`
+        - `message` (`string`): one of `Server.errorMessages`
+        - `context` (`Object`): extra info about the error
+
+| Code | Message |
+| ---- | ------- |
+| 0 | "Transport unknown"
+| 1 | "Session ID unknown"
+| 2 | "Bad handshake method"
+| 3 | "Bad request"
+| 4 | "Forbidden"
+| 5 | "Unsupported protocol version"
+
 
 ##### Properties
@@ -223,5 +254,5 @@
     - **Options**
       - `pingTimeout` (`Number`): how many ms without a pong packet to
-        consider the connection closed (`5000`)
+        consider the connection closed (`20000`)
       - `pingInterval` (`Number`): how many ms before sending a new ping
         packet (`25000`)
@@ -250,5 +281,5 @@
         headers. This cookie might be used for sticky-session. Defaults to not sending any cookie (`false`).
         See [here](https://github.com/jshttp/cookie#options-1) for all supported options.
-      - `wsEngine` (`String`): what WebSocket server implementation to use. Specified module must conform to the `ws` interface (see [ws module api docs](https://github.com/websockets/ws/blob/master/doc/ws.md)). Default value is `ws`. An alternative c++ addon is also available by installing `uws` module.
+      - `wsEngine` (`Function`): what WebSocket server implementation to use. Specified module must conform to the `ws` interface (see [ws module api docs](https://github.com/websockets/ws/blob/master/doc/ws.md)). Default value is `ws`. An alternative c++ addon is also available by installing `eiows` module.
       - `cors` (`Object`): the options that will be forwarded to the cors module. See [there](https://github.com/expressjs/cors#configuration-options) for all available options. Defaults to no CORS allowed.
       - `initialPacket` (`Object`): an optional packet which will be concatenated to the handshake packet emitted by Engine.IO.
@@ -325,4 +356,6 @@
       - `type`: packet type
       - `data`: packet data (if type is message)
+- `heartbeat`
+    - Called when `ping` or `pong` packed is received (depends of client version)
 
 ##### Properties
Index: trip-planner-front/node_modules/engine.io/build/engine.io.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/engine.io.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/engine.io.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,28 @@
+import { Server, AttachOptions, ServerOptions } from "./server";
+import transports from "./transports/index";
+import * as parser from "engine.io-parser";
+export { Server, transports, listen, attach, parser };
+export { AttachOptions, ServerOptions } from "./server";
+export { uServer } from "./userver";
+export { Socket } from "./socket";
+export { Transport } from "./transport";
+export declare const protocol = 4;
+/**
+ * Creates an http.Server exclusively used for WS upgrades.
+ *
+ * @param {Number} port
+ * @param {Function} callback
+ * @param {Object} options
+ * @return {Server} websocket.io server
+ * @api public
+ */
+declare function listen(port: any, options: AttachOptions & ServerOptions, fn: any): Server;
+/**
+ * Captures upgrade requests for a http.Server.
+ *
+ * @param {http.Server} server
+ * @param {Object} options
+ * @return {Server} engine server
+ * @api public
+ */
+declare function attach(server: any, options: AttachOptions & ServerOptions): Server;
Index: trip-planner-front/node_modules/engine.io/build/engine.io.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/engine.io.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/engine.io.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocol = exports.Transport = exports.Socket = exports.uServer = exports.parser = exports.attach = exports.listen = exports.transports = exports.Server = void 0;
+const http_1 = require("http");
+const server_1 = require("./server");
+Object.defineProperty(exports, "Server", { enumerable: true, get: function () { return server_1.Server; } });
+const index_1 = require("./transports/index");
+exports.transports = index_1.default;
+const parser = require("engine.io-parser");
+exports.parser = parser;
+var userver_1 = require("./userver");
+Object.defineProperty(exports, "uServer", { enumerable: true, get: function () { return userver_1.uServer; } });
+var socket_1 = require("./socket");
+Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_1.Socket; } });
+var transport_1 = require("./transport");
+Object.defineProperty(exports, "Transport", { enumerable: true, get: function () { return transport_1.Transport; } });
+exports.protocol = parser.protocol;
+/**
+ * Creates an http.Server exclusively used for WS upgrades.
+ *
+ * @param {Number} port
+ * @param {Function} callback
+ * @param {Object} options
+ * @return {Server} websocket.io server
+ * @api public
+ */
+function listen(port, options, fn) {
+    if ("function" === typeof options) {
+        fn = options;
+        options = {};
+    }
+    const server = (0, http_1.createServer)(function (req, res) {
+        res.writeHead(501);
+        res.end("Not Implemented");
+    });
+    // create engine server
+    const engine = attach(server, options);
+    engine.httpServer = server;
+    server.listen(port, fn);
+    return engine;
+}
+exports.listen = listen;
+/**
+ * Captures upgrade requests for a http.Server.
+ *
+ * @param {http.Server} server
+ * @param {Object} options
+ * @return {Server} engine server
+ * @api public
+ */
+function attach(server, options) {
+    const engine = new server_1.Server(options);
+    engine.attach(server, options);
+    return engine;
+}
+exports.attach = attach;
Index: trip-planner-front/node_modules/engine.io/build/parser-v3/index.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/parser-v3/index.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/parser-v3/index.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,95 @@
+/// <reference types="node" />
+/**
+ * Current protocol version.
+ */
+export declare const protocol = 3;
+/**
+ * Packet types.
+ */
+export declare const packets: {
+    open: number;
+    close: number;
+    ping: number;
+    pong: number;
+    message: number;
+    upgrade: number;
+    noop: number;
+};
+/**
+ * Encodes a packet.
+ *
+ *     <packet type id> [ <data> ]
+ *
+ * Example:
+ *
+ *     5hello world
+ *     3
+ *     4
+ *
+ * Binary is encoded in an identical principle
+ *
+ * @api private
+ */
+export declare function encodePacket(packet: any, supportsBinary: any, utf8encode: any, callback: any): any;
+/**
+ * Encodes a packet with binary data in a base64 string
+ *
+ * @param {Object} packet, has `type` and `data`
+ * @return {String} base64 encoded message
+ */
+export declare function encodeBase64Packet(packet: any, callback: any): any;
+/**
+ * Decodes a packet. Data also available as an ArrayBuffer if requested.
+ *
+ * @return {Object} with `type` and `data` (if any)
+ * @api private
+ */
+export declare function decodePacket(data: any, binaryType: any, utf8decode: any): {
+    type: string;
+    data: any;
+} | {
+    type: string;
+    data?: undefined;
+};
+/**
+ * Decodes a packet encoded in a base64 string.
+ *
+ * @param {String} base64 encoded message
+ * @return {Object} with `type` and `data` (if any)
+ */
+export declare function decodeBase64Packet(msg: any, binaryType: any): {
+    type: string;
+    data: Buffer;
+};
+/**
+ * Encodes multiple messages (payload).
+ *
+ *     <length>:data
+ *
+ * Example:
+ *
+ *     11:hello world2:hi
+ *
+ * If any contents are binary, they will be encoded as base64 strings. Base64
+ * encoded strings are marked with a b before the length specifier
+ *
+ * @param {Array} packets
+ * @api private
+ */
+export declare function encodePayload(packets: any, supportsBinary: any, callback: any): any;
+export declare function decodePayload(data: any, binaryType: any, callback: any): any;
+/**
+ * Encodes multiple messages (payload) as binary.
+ *
+ * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
+ * 255><data>
+ *
+ * Example:
+ * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
+ *
+ * @param {Array} packets
+ * @return {Buffer} encoded payload
+ * @api private
+ */
+export declare function encodePayloadAsBinary(packets: any, callback: any): any;
+export declare function decodePayloadAsBinary(data: any, binaryType: any, callback: any): any;
Index: trip-planner-front/node_modules/engine.io/build/parser-v3/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/parser-v3/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/parser-v3/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,424 @@
+"use strict";
+// imported from https://github.com/socketio/engine.io-parser/tree/2.2.x
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodePayloadAsBinary = exports.encodePayloadAsBinary = exports.decodePayload = exports.encodePayload = exports.decodeBase64Packet = exports.decodePacket = exports.encodeBase64Packet = exports.encodePacket = exports.packets = exports.protocol = void 0;
+/**
+ * Module dependencies.
+ */
+var utf8 = require('./utf8');
+/**
+ * Current protocol version.
+ */
+exports.protocol = 3;
+const hasBinary = (packets) => {
+    for (const packet of packets) {
+        if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Packet types.
+ */
+exports.packets = {
+    open: 0 // non-ws
+    ,
+    close: 1 // non-ws
+    ,
+    ping: 2,
+    pong: 3,
+    message: 4,
+    upgrade: 5,
+    noop: 6
+};
+var packetslist = Object.keys(exports.packets);
+/**
+ * Premade error packet.
+ */
+var err = { type: 'error', data: 'parser error' };
+const EMPTY_BUFFER = Buffer.concat([]);
+/**
+ * Encodes a packet.
+ *
+ *     <packet type id> [ <data> ]
+ *
+ * Example:
+ *
+ *     5hello world
+ *     3
+ *     4
+ *
+ * Binary is encoded in an identical principle
+ *
+ * @api private
+ */
+function encodePacket(packet, supportsBinary, utf8encode, callback) {
+    if (typeof supportsBinary === 'function') {
+        callback = supportsBinary;
+        supportsBinary = null;
+    }
+    if (typeof utf8encode === 'function') {
+        callback = utf8encode;
+        utf8encode = null;
+    }
+    if (Buffer.isBuffer(packet.data)) {
+        return encodeBuffer(packet, supportsBinary, callback);
+    }
+    else if (packet.data && (packet.data.buffer || packet.data) instanceof ArrayBuffer) {
+        return encodeBuffer({ type: packet.type, data: arrayBufferToBuffer(packet.data) }, supportsBinary, callback);
+    }
+    // Sending data as a utf-8 string
+    var encoded = exports.packets[packet.type];
+    // data fragment is optional
+    if (undefined !== packet.data) {
+        encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);
+    }
+    return callback('' + encoded);
+}
+exports.encodePacket = encodePacket;
+;
+/**
+ * Encode Buffer data
+ */
+function encodeBuffer(packet, supportsBinary, callback) {
+    if (!supportsBinary) {
+        return encodeBase64Packet(packet, callback);
+    }
+    var data = packet.data;
+    var typeBuffer = Buffer.allocUnsafe(1);
+    typeBuffer[0] = exports.packets[packet.type];
+    return callback(Buffer.concat([typeBuffer, data]));
+}
+/**
+ * Encodes a packet with binary data in a base64 string
+ *
+ * @param {Object} packet, has `type` and `data`
+ * @return {String} base64 encoded message
+ */
+function encodeBase64Packet(packet, callback) {
+    var data = Buffer.isBuffer(packet.data) ? packet.data : arrayBufferToBuffer(packet.data);
+    var message = 'b' + exports.packets[packet.type];
+    message += data.toString('base64');
+    return callback(message);
+}
+exports.encodeBase64Packet = encodeBase64Packet;
+;
+/**
+ * Decodes a packet. Data also available as an ArrayBuffer if requested.
+ *
+ * @return {Object} with `type` and `data` (if any)
+ * @api private
+ */
+function decodePacket(data, binaryType, utf8decode) {
+    if (data === undefined) {
+        return err;
+    }
+    var type;
+    // String data
+    if (typeof data === 'string') {
+        type = data.charAt(0);
+        if (type === 'b') {
+            return decodeBase64Packet(data.substr(1), binaryType);
+        }
+        if (utf8decode) {
+            data = tryDecode(data);
+            if (data === false) {
+                return err;
+            }
+        }
+        if (Number(type) != type || !packetslist[type]) {
+            return err;
+        }
+        if (data.length > 1) {
+            return { type: packetslist[type], data: data.substring(1) };
+        }
+        else {
+            return { type: packetslist[type] };
+        }
+    }
+    // Binary data
+    if (binaryType === 'arraybuffer') {
+        // wrap Buffer/ArrayBuffer data into an Uint8Array
+        var intArray = new Uint8Array(data);
+        type = intArray[0];
+        return { type: packetslist[type], data: intArray.buffer.slice(1) };
+    }
+    if (data instanceof ArrayBuffer) {
+        data = arrayBufferToBuffer(data);
+    }
+    type = data[0];
+    return { type: packetslist[type], data: data.slice(1) };
+}
+exports.decodePacket = decodePacket;
+;
+function tryDecode(data) {
+    try {
+        data = utf8.decode(data, { strict: false });
+    }
+    catch (e) {
+        return false;
+    }
+    return data;
+}
+/**
+ * Decodes a packet encoded in a base64 string.
+ *
+ * @param {String} base64 encoded message
+ * @return {Object} with `type` and `data` (if any)
+ */
+function decodeBase64Packet(msg, binaryType) {
+    var type = packetslist[msg.charAt(0)];
+    var data = Buffer.from(msg.substr(1), 'base64');
+    if (binaryType === 'arraybuffer') {
+        var abv = new Uint8Array(data.length);
+        for (var i = 0; i < abv.length; i++) {
+            abv[i] = data[i];
+        }
+        // @ts-ignore
+        data = abv.buffer;
+    }
+    return { type: type, data: data };
+}
+exports.decodeBase64Packet = decodeBase64Packet;
+;
+/**
+ * Encodes multiple messages (payload).
+ *
+ *     <length>:data
+ *
+ * Example:
+ *
+ *     11:hello world2:hi
+ *
+ * If any contents are binary, they will be encoded as base64 strings. Base64
+ * encoded strings are marked with a b before the length specifier
+ *
+ * @param {Array} packets
+ * @api private
+ */
+function encodePayload(packets, supportsBinary, callback) {
+    if (typeof supportsBinary === 'function') {
+        callback = supportsBinary;
+        supportsBinary = null;
+    }
+    if (supportsBinary && hasBinary(packets)) {
+        return encodePayloadAsBinary(packets, callback);
+    }
+    if (!packets.length) {
+        return callback('0:');
+    }
+    function encodeOne(packet, doneCallback) {
+        encodePacket(packet, supportsBinary, false, function (message) {
+            doneCallback(null, setLengthHeader(message));
+        });
+    }
+    map(packets, encodeOne, function (err, results) {
+        return callback(results.join(''));
+    });
+}
+exports.encodePayload = encodePayload;
+;
+function setLengthHeader(message) {
+    return message.length + ':' + message;
+}
+/**
+ * Async array map using after
+ */
+function map(ary, each, done) {
+    const results = new Array(ary.length);
+    let count = 0;
+    for (let i = 0; i < ary.length; i++) {
+        each(ary[i], (error, msg) => {
+            results[i] = msg;
+            if (++count === ary.length) {
+                done(null, results);
+            }
+        });
+    }
+}
+/*
+ * Decodes data when a payload is maybe expected. Possible binary contents are
+ * decoded from their base64 representation
+ *
+ * @param {String} data, callback method
+ * @api public
+ */
+function decodePayload(data, binaryType, callback) {
+    if (typeof data !== 'string') {
+        return decodePayloadAsBinary(data, binaryType, callback);
+    }
+    if (typeof binaryType === 'function') {
+        callback = binaryType;
+        binaryType = null;
+    }
+    if (data === '') {
+        // parser error - ignoring payload
+        return callback(err, 0, 1);
+    }
+    var length = '', n, msg, packet;
+    for (var i = 0, l = data.length; i < l; i++) {
+        var chr = data.charAt(i);
+        if (chr !== ':') {
+            length += chr;
+            continue;
+        }
+        // @ts-ignore
+        if (length === '' || (length != (n = Number(length)))) {
+            // parser error - ignoring payload
+            return callback(err, 0, 1);
+        }
+        msg = data.substr(i + 1, n);
+        if (length != msg.length) {
+            // parser error - ignoring payload
+            return callback(err, 0, 1);
+        }
+        if (msg.length) {
+            packet = decodePacket(msg, binaryType, false);
+            if (err.type === packet.type && err.data === packet.data) {
+                // parser error in individual packet - ignoring payload
+                return callback(err, 0, 1);
+            }
+            var more = callback(packet, i + n, l);
+            if (false === more)
+                return;
+        }
+        // advance cursor
+        i += n;
+        length = '';
+    }
+    if (length !== '') {
+        // parser error - ignoring payload
+        return callback(err, 0, 1);
+    }
+}
+exports.decodePayload = decodePayload;
+;
+/**
+ *
+ * Converts a buffer to a utf8.js encoded string
+ *
+ * @api private
+ */
+function bufferToString(buffer) {
+    var str = '';
+    for (var i = 0, l = buffer.length; i < l; i++) {
+        str += String.fromCharCode(buffer[i]);
+    }
+    return str;
+}
+/**
+ *
+ * Converts a utf8.js encoded string to a buffer
+ *
+ * @api private
+ */
+function stringToBuffer(string) {
+    var buf = Buffer.allocUnsafe(string.length);
+    for (var i = 0, l = string.length; i < l; i++) {
+        buf.writeUInt8(string.charCodeAt(i), i);
+    }
+    return buf;
+}
+/**
+ *
+ * Converts an ArrayBuffer to a Buffer
+ *
+ * @api private
+ */
+function arrayBufferToBuffer(data) {
+    // data is either an ArrayBuffer or ArrayBufferView.
+    var length = data.byteLength || data.length;
+    var offset = data.byteOffset || 0;
+    return Buffer.from(data.buffer || data, offset, length);
+}
+/**
+ * Encodes multiple messages (payload) as binary.
+ *
+ * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
+ * 255><data>
+ *
+ * Example:
+ * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
+ *
+ * @param {Array} packets
+ * @return {Buffer} encoded payload
+ * @api private
+ */
+function encodePayloadAsBinary(packets, callback) {
+    if (!packets.length) {
+        return callback(EMPTY_BUFFER);
+    }
+    map(packets, encodeOneBinaryPacket, function (err, results) {
+        return callback(Buffer.concat(results));
+    });
+}
+exports.encodePayloadAsBinary = encodePayloadAsBinary;
+;
+function encodeOneBinaryPacket(p, doneCallback) {
+    function onBinaryPacketEncode(packet) {
+        var encodingLength = '' + packet.length;
+        var sizeBuffer;
+        if (typeof packet === 'string') {
+            sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
+            sizeBuffer[0] = 0; // is a string (not true binary = 0)
+            for (var i = 0; i < encodingLength.length; i++) {
+                sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
+            }
+            sizeBuffer[sizeBuffer.length - 1] = 255;
+            return doneCallback(null, Buffer.concat([sizeBuffer, stringToBuffer(packet)]));
+        }
+        sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
+        sizeBuffer[0] = 1; // is binary (true binary = 1)
+        for (var i = 0; i < encodingLength.length; i++) {
+            sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
+        }
+        sizeBuffer[sizeBuffer.length - 1] = 255;
+        doneCallback(null, Buffer.concat([sizeBuffer, packet]));
+    }
+    encodePacket(p, true, true, onBinaryPacketEncode);
+}
+/*
+ * Decodes data when a payload is maybe expected. Strings are decoded by
+ * interpreting each byte as a key code for entries marked to start with 0. See
+ * description of encodePayloadAsBinary
+
+ * @param {Buffer} data, callback method
+ * @api public
+ */
+function decodePayloadAsBinary(data, binaryType, callback) {
+    if (typeof binaryType === 'function') {
+        callback = binaryType;
+        binaryType = null;
+    }
+    var bufferTail = data;
+    var buffers = [];
+    var i;
+    while (bufferTail.length > 0) {
+        var strLen = '';
+        var isString = bufferTail[0] === 0;
+        for (i = 1;; i++) {
+            if (bufferTail[i] === 255)
+                break;
+            // 310 = char length of Number.MAX_VALUE
+            if (strLen.length > 310) {
+                return callback(err, 0, 1);
+            }
+            strLen += '' + bufferTail[i];
+        }
+        bufferTail = bufferTail.slice(strLen.length + 1);
+        var msgLength = parseInt(strLen, 10);
+        var msg = bufferTail.slice(1, msgLength + 1);
+        if (isString)
+            msg = bufferToString(msg);
+        buffers.push(msg);
+        bufferTail = bufferTail.slice(msgLength + 1);
+    }
+    var total = buffers.length;
+    for (i = 0; i < total; i++) {
+        var buffer = buffers[i];
+        callback(decodePacket(buffer, binaryType, true), i, total);
+    }
+}
+exports.decodePayloadAsBinary = decodePayloadAsBinary;
+;
Index: trip-planner-front/node_modules/engine.io/build/parser-v3/utf8.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/parser-v3/utf8.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/parser-v3/utf8.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,14 @@
+/*! https://mths.be/utf8js v2.1.2 by @mathias */
+declare var stringFromCharCode: (...codes: number[]) => string;
+declare function ucs2decode(string: any): any[];
+declare function ucs2encode(array: any): string;
+declare function checkScalarValue(codePoint: any, strict: any): boolean;
+declare function createByte(codePoint: any, shift: any): string;
+declare function encodeCodePoint(codePoint: any, strict: any): string;
+declare function utf8encode(string: any, opts: any): string;
+declare function readContinuationByte(): number;
+declare function decodeSymbol(strict: any): any;
+declare var byteArray: any;
+declare var byteCount: any;
+declare var byteIndex: any;
+declare function utf8decode(byteString: any, opts: any): string;
Index: trip-planner-front/node_modules/engine.io/build/parser-v3/utf8.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/parser-v3/utf8.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/parser-v3/utf8.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,187 @@
+/*! https://mths.be/utf8js v2.1.2 by @mathias */
+var stringFromCharCode = String.fromCharCode;
+// Taken from https://mths.be/punycode
+function ucs2decode(string) {
+    var output = [];
+    var counter = 0;
+    var length = string.length;
+    var value;
+    var extra;
+    while (counter < length) {
+        value = string.charCodeAt(counter++);
+        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+            // high surrogate, and there is a next character
+            extra = string.charCodeAt(counter++);
+            if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+            }
+            else {
+                // unmatched surrogate; only append this code unit, in case the next
+                // code unit is the high surrogate of a surrogate pair
+                output.push(value);
+                counter--;
+            }
+        }
+        else {
+            output.push(value);
+        }
+    }
+    return output;
+}
+// Taken from https://mths.be/punycode
+function ucs2encode(array) {
+    var length = array.length;
+    var index = -1;
+    var value;
+    var output = '';
+    while (++index < length) {
+        value = array[index];
+        if (value > 0xFFFF) {
+            value -= 0x10000;
+            output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+            value = 0xDC00 | value & 0x3FF;
+        }
+        output += stringFromCharCode(value);
+    }
+    return output;
+}
+function checkScalarValue(codePoint, strict) {
+    if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
+        if (strict) {
+            throw Error('Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
+                ' is not a scalar value');
+        }
+        return false;
+    }
+    return true;
+}
+/*--------------------------------------------------------------------------*/
+function createByte(codePoint, shift) {
+    return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
+}
+function encodeCodePoint(codePoint, strict) {
+    if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
+        return stringFromCharCode(codePoint);
+    }
+    var symbol = '';
+    if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
+        symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
+    }
+    else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
+        if (!checkScalarValue(codePoint, strict)) {
+            codePoint = 0xFFFD;
+        }
+        symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
+        symbol += createByte(codePoint, 6);
+    }
+    else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
+        symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
+        symbol += createByte(codePoint, 12);
+        symbol += createByte(codePoint, 6);
+    }
+    symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
+    return symbol;
+}
+function utf8encode(string, opts) {
+    opts = opts || {};
+    var strict = false !== opts.strict;
+    var codePoints = ucs2decode(string);
+    var length = codePoints.length;
+    var index = -1;
+    var codePoint;
+    var byteString = '';
+    while (++index < length) {
+        codePoint = codePoints[index];
+        byteString += encodeCodePoint(codePoint, strict);
+    }
+    return byteString;
+}
+/*--------------------------------------------------------------------------*/
+function readContinuationByte() {
+    if (byteIndex >= byteCount) {
+        throw Error('Invalid byte index');
+    }
+    var continuationByte = byteArray[byteIndex] & 0xFF;
+    byteIndex++;
+    if ((continuationByte & 0xC0) == 0x80) {
+        return continuationByte & 0x3F;
+    }
+    // If we end up here, it’s not a continuation byte
+    throw Error('Invalid continuation byte');
+}
+function decodeSymbol(strict) {
+    var byte1;
+    var byte2;
+    var byte3;
+    var byte4;
+    var codePoint;
+    if (byteIndex > byteCount) {
+        throw Error('Invalid byte index');
+    }
+    if (byteIndex == byteCount) {
+        return false;
+    }
+    // Read first byte
+    byte1 = byteArray[byteIndex] & 0xFF;
+    byteIndex++;
+    // 1-byte sequence (no continuation bytes)
+    if ((byte1 & 0x80) == 0) {
+        return byte1;
+    }
+    // 2-byte sequence
+    if ((byte1 & 0xE0) == 0xC0) {
+        byte2 = readContinuationByte();
+        codePoint = ((byte1 & 0x1F) << 6) | byte2;
+        if (codePoint >= 0x80) {
+            return codePoint;
+        }
+        else {
+            throw Error('Invalid continuation byte');
+        }
+    }
+    // 3-byte sequence (may include unpaired surrogates)
+    if ((byte1 & 0xF0) == 0xE0) {
+        byte2 = readContinuationByte();
+        byte3 = readContinuationByte();
+        codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
+        if (codePoint >= 0x0800) {
+            return checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;
+        }
+        else {
+            throw Error('Invalid continuation byte');
+        }
+    }
+    // 4-byte sequence
+    if ((byte1 & 0xF8) == 0xF0) {
+        byte2 = readContinuationByte();
+        byte3 = readContinuationByte();
+        byte4 = readContinuationByte();
+        codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
+            (byte3 << 0x06) | byte4;
+        if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
+            return codePoint;
+        }
+    }
+    throw Error('Invalid UTF-8 detected');
+}
+var byteArray;
+var byteCount;
+var byteIndex;
+function utf8decode(byteString, opts) {
+    opts = opts || {};
+    var strict = false !== opts.strict;
+    byteArray = ucs2decode(byteString);
+    byteCount = byteArray.length;
+    byteIndex = 0;
+    var codePoints = [];
+    var tmp;
+    while ((tmp = decodeSymbol(strict)) !== false) {
+        codePoints.push(tmp);
+    }
+    return ucs2encode(codePoints);
+}
+module.exports = {
+    version: '2.1.2',
+    encode: utf8encode,
+    decode: utf8decode
+};
Index: trip-planner-front/node_modules/engine.io/build/server.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/server.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/server.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,223 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { IncomingMessage, Server as HttpServer } from "http";
+import { CookieSerializeOptions } from "cookie";
+import { CorsOptions } from "cors";
+declare type Transport = "polling" | "websocket";
+export interface AttachOptions {
+    /**
+     * name of the path to capture
+     * @default "/engine.io"
+     */
+    path?: string;
+    /**
+     * destroy unhandled upgrade requests
+     * @default true
+     */
+    destroyUpgrade?: boolean;
+    /**
+     * milliseconds after which unhandled requests are ended
+     * @default 1000
+     */
+    destroyUpgradeTimeout?: number;
+}
+export interface ServerOptions {
+    /**
+     * how many ms without a pong packet to consider the connection closed
+     * @default 20000
+     */
+    pingTimeout?: number;
+    /**
+     * how many ms before sending a new ping packet
+     * @default 25000
+     */
+    pingInterval?: number;
+    /**
+     * how many ms before an uncompleted transport upgrade is cancelled
+     * @default 10000
+     */
+    upgradeTimeout?: number;
+    /**
+     * how many bytes or characters a message can be, before closing the session (to avoid DoS).
+     * @default 1e5 (100 KB)
+     */
+    maxHttpBufferSize?: number;
+    /**
+     * A function that receives a given handshake or upgrade request as its first parameter,
+     * and can decide whether to continue or not. The second argument is a function that needs
+     * to be called with the decided information: fn(err, success), where success is a boolean
+     * value where false means that the request is rejected, and err is an error code.
+     */
+    allowRequest?: (req: IncomingMessage, fn: (err: string | null | undefined, success: boolean) => void) => void;
+    /**
+     * the low-level transports that are enabled
+     * @default ["polling", "websocket"]
+     */
+    transports?: Transport[];
+    /**
+     * whether to allow transport upgrades
+     * @default true
+     */
+    allowUpgrades?: boolean;
+    /**
+     * parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable.
+     * @default false
+     */
+    perMessageDeflate?: boolean | object;
+    /**
+     * parameters of the http compression for the polling transports (see zlib api docs). Set to false to disable.
+     * @default true
+     */
+    httpCompression?: boolean | object;
+    /**
+     * what WebSocket server implementation to use. Specified module must
+     * conform to the ws interface (see ws module api docs).
+     * An alternative c++ addon is also available by installing eiows module.
+     *
+     * @default `require("ws").Server`
+     */
+    wsEngine?: any;
+    /**
+     * an optional packet which will be concatenated to the handshake packet emitted by Engine.IO.
+     */
+    initialPacket?: any;
+    /**
+     * configuration of the cookie that contains the client sid to send as part of handshake response headers. This cookie
+     * might be used for sticky-session. Defaults to not sending any cookie.
+     * @default false
+     */
+    cookie?: (CookieSerializeOptions & {
+        name: string;
+    }) | boolean;
+    /**
+     * the options that will be forwarded to the cors module
+     */
+    cors?: CorsOptions;
+    /**
+     * whether to enable compatibility with Socket.IO v2 clients
+     * @default false
+     */
+    allowEIO3?: boolean;
+}
+export declare abstract class BaseServer extends EventEmitter {
+    opts: ServerOptions;
+    protected clients: any;
+    private clientsCount;
+    protected corsMiddleware: Function;
+    /**
+     * Server constructor.
+     *
+     * @param {Object} opts - options
+     * @api public
+     */
+    constructor(opts?: ServerOptions);
+    protected abstract init(): any;
+    /**
+     * Returns a list of available transports for upgrade given a certain transport.
+     *
+     * @return {Array}
+     * @api public
+     */
+    upgrades(transport: any): any;
+    /**
+     * Verifies a request.
+     *
+     * @param {http.IncomingMessage}
+     * @return {Boolean} whether the request is valid
+     * @api private
+     */
+    protected verify(req: any, upgrade: any, fn: any): any;
+    /**
+     * Closes all clients.
+     *
+     * @api public
+     */
+    close(): this;
+    protected abstract cleanup(): any;
+    /**
+     * generate a socket id.
+     * Overwrite this method to generate your custom socket id
+     *
+     * @param {Object} request object
+     * @api public
+     */
+    generateId(req: any): any;
+    /**
+     * Handshakes a new client.
+     *
+     * @param {String} transport name
+     * @param {Object} request object
+     * @param {Function} closeConnection
+     *
+     * @api protected
+     */
+    protected handshake(transportName: any, req: any, closeConnection: any): Promise<any>;
+    protected abstract createTransport(transportName: any, req: any): any;
+    /**
+     * Protocol errors mappings.
+     */
+    static errors: {
+        UNKNOWN_TRANSPORT: number;
+        UNKNOWN_SID: number;
+        BAD_HANDSHAKE_METHOD: number;
+        BAD_REQUEST: number;
+        FORBIDDEN: number;
+        UNSUPPORTED_PROTOCOL_VERSION: number;
+    };
+    static errorMessages: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+    };
+}
+export declare class Server extends BaseServer {
+    httpServer?: HttpServer;
+    private ws;
+    /**
+     * Initialize websocket server
+     *
+     * @api protected
+     */
+    protected init(): void;
+    protected cleanup(): void;
+    /**
+     * Prepares a request by processing the query string.
+     *
+     * @api private
+     */
+    private prepare;
+    protected createTransport(transportName: any, req: any): any;
+    /**
+     * Handles an Engine.IO HTTP request.
+     *
+     * @param {http.IncomingMessage} request
+     * @param {http.ServerResponse|http.OutgoingMessage} response
+     * @api public
+     */
+    handleRequest(req: any, res: any): void;
+    /**
+     * Handles an Engine.IO HTTP Upgrade.
+     *
+     * @api public
+     */
+    handleUpgrade(req: any, socket: any, upgradeHead: any): void;
+    /**
+     * Called upon a ws.io connection.
+     *
+     * @param {ws.Socket} websocket
+     * @api private
+     */
+    private onWebSocket;
+    /**
+     * Captures upgrade requests for a http.Server.
+     *
+     * @param {http.Server} server
+     * @param {Object} options
+     * @api public
+     */
+    attach(server: HttpServer, options?: AttachOptions): void;
+}
+export {};
Index: trip-planner-front/node_modules/engine.io/build/server.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/server.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/server.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,622 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = exports.BaseServer = void 0;
+const qs = require("querystring");
+const url_1 = require("url");
+const base64id = require("base64id");
+const transports_1 = require("./transports");
+const events_1 = require("events");
+const socket_1 = require("./socket");
+const debug_1 = require("debug");
+const cookie_1 = require("cookie");
+const ws_1 = require("ws");
+const debug = (0, debug_1.default)("engine");
+class BaseServer extends events_1.EventEmitter {
+    /**
+     * Server constructor.
+     *
+     * @param {Object} opts - options
+     * @api public
+     */
+    constructor(opts = {}) {
+        super();
+        this.clients = {};
+        this.clientsCount = 0;
+        this.opts = Object.assign({
+            wsEngine: ws_1.Server,
+            pingTimeout: 20000,
+            pingInterval: 25000,
+            upgradeTimeout: 10000,
+            maxHttpBufferSize: 1e6,
+            transports: Object.keys(transports_1.default),
+            allowUpgrades: true,
+            httpCompression: {
+                threshold: 1024
+            },
+            cors: false,
+            allowEIO3: false
+        }, opts);
+        if (opts.cookie) {
+            this.opts.cookie = Object.assign({
+                name: "io",
+                path: "/",
+                // @ts-ignore
+                httpOnly: opts.cookie.path !== false,
+                sameSite: "lax"
+            }, opts.cookie);
+        }
+        if (this.opts.cors) {
+            this.corsMiddleware = require("cors")(this.opts.cors);
+        }
+        if (opts.perMessageDeflate) {
+            this.opts.perMessageDeflate = Object.assign({
+                threshold: 1024
+            }, opts.perMessageDeflate);
+        }
+        this.init();
+    }
+    /**
+     * Returns a list of available transports for upgrade given a certain transport.
+     *
+     * @return {Array}
+     * @api public
+     */
+    upgrades(transport) {
+        if (!this.opts.allowUpgrades)
+            return [];
+        return transports_1.default[transport].upgradesTo || [];
+    }
+    /**
+     * Verifies a request.
+     *
+     * @param {http.IncomingMessage}
+     * @return {Boolean} whether the request is valid
+     * @api private
+     */
+    verify(req, upgrade, fn) {
+        // transport check
+        const transport = req._query.transport;
+        if (!~this.opts.transports.indexOf(transport)) {
+            debug('unknown transport "%s"', transport);
+            return fn(Server.errors.UNKNOWN_TRANSPORT, { transport });
+        }
+        // 'Origin' header check
+        const isOriginInvalid = checkInvalidHeaderChar(req.headers.origin);
+        if (isOriginInvalid) {
+            const origin = req.headers.origin;
+            req.headers.origin = null;
+            debug("origin header invalid");
+            return fn(Server.errors.BAD_REQUEST, {
+                name: "INVALID_ORIGIN",
+                origin
+            });
+        }
+        // sid check
+        const sid = req._query.sid;
+        if (sid) {
+            if (!this.clients.hasOwnProperty(sid)) {
+                debug('unknown sid "%s"', sid);
+                return fn(Server.errors.UNKNOWN_SID, {
+                    sid
+                });
+            }
+            const previousTransport = this.clients[sid].transport.name;
+            if (!upgrade && previousTransport !== transport) {
+                debug("bad request: unexpected transport without upgrade");
+                return fn(Server.errors.BAD_REQUEST, {
+                    name: "TRANSPORT_MISMATCH",
+                    transport,
+                    previousTransport
+                });
+            }
+        }
+        else {
+            // handshake is GET only
+            if ("GET" !== req.method) {
+                return fn(Server.errors.BAD_HANDSHAKE_METHOD, {
+                    method: req.method
+                });
+            }
+            if (!this.opts.allowRequest)
+                return fn();
+            return this.opts.allowRequest(req, (message, success) => {
+                if (!success) {
+                    return fn(Server.errors.FORBIDDEN, {
+                        message
+                    });
+                }
+                fn();
+            });
+        }
+        fn();
+    }
+    /**
+     * Closes all clients.
+     *
+     * @api public
+     */
+    close() {
+        debug("closing all open clients");
+        for (let i in this.clients) {
+            if (this.clients.hasOwnProperty(i)) {
+                this.clients[i].close(true);
+            }
+        }
+        this.cleanup();
+        return this;
+    }
+    /**
+     * generate a socket id.
+     * Overwrite this method to generate your custom socket id
+     *
+     * @param {Object} request object
+     * @api public
+     */
+    generateId(req) {
+        return base64id.generateId();
+    }
+    /**
+     * Handshakes a new client.
+     *
+     * @param {String} transport name
+     * @param {Object} request object
+     * @param {Function} closeConnection
+     *
+     * @api protected
+     */
+    async handshake(transportName, req, closeConnection) {
+        const protocol = req._query.EIO === "4" ? 4 : 3; // 3rd revision by default
+        if (protocol === 3 && !this.opts.allowEIO3) {
+            debug("unsupported protocol version");
+            this.emit("connection_error", {
+                req,
+                code: Server.errors.UNSUPPORTED_PROTOCOL_VERSION,
+                message: Server.errorMessages[Server.errors.UNSUPPORTED_PROTOCOL_VERSION],
+                context: {
+                    protocol
+                }
+            });
+            closeConnection(Server.errors.UNSUPPORTED_PROTOCOL_VERSION);
+            return;
+        }
+        let id;
+        try {
+            id = await this.generateId(req);
+        }
+        catch (e) {
+            debug("error while generating an id");
+            this.emit("connection_error", {
+                req,
+                code: Server.errors.BAD_REQUEST,
+                message: Server.errorMessages[Server.errors.BAD_REQUEST],
+                context: {
+                    name: "ID_GENERATION_ERROR",
+                    error: e
+                }
+            });
+            closeConnection(Server.errors.BAD_REQUEST);
+            return;
+        }
+        debug('handshaking client "%s"', id);
+        try {
+            var transport = this.createTransport(transportName, req);
+            if ("polling" === transportName) {
+                transport.maxHttpBufferSize = this.opts.maxHttpBufferSize;
+                transport.httpCompression = this.opts.httpCompression;
+            }
+            else if ("websocket" === transportName) {
+                transport.perMessageDeflate = this.opts.perMessageDeflate;
+            }
+            if (req._query && req._query.b64) {
+                transport.supportsBinary = false;
+            }
+            else {
+                transport.supportsBinary = true;
+            }
+        }
+        catch (e) {
+            debug('error handshaking to transport "%s"', transportName);
+            this.emit("connection_error", {
+                req,
+                code: Server.errors.BAD_REQUEST,
+                message: Server.errorMessages[Server.errors.BAD_REQUEST],
+                context: {
+                    name: "TRANSPORT_HANDSHAKE_ERROR",
+                    error: e
+                }
+            });
+            closeConnection(Server.errors.BAD_REQUEST);
+            return;
+        }
+        const socket = new socket_1.Socket(id, this, transport, req, protocol);
+        transport.on("headers", (headers, req) => {
+            const isInitialRequest = !req._query.sid;
+            if (isInitialRequest) {
+                if (this.opts.cookie) {
+                    headers["Set-Cookie"] = [
+                        // @ts-ignore
+                        (0, cookie_1.serialize)(this.opts.cookie.name, id, this.opts.cookie)
+                    ];
+                }
+                this.emit("initial_headers", headers, req);
+            }
+            this.emit("headers", headers, req);
+        });
+        transport.onRequest(req);
+        this.clients[id] = socket;
+        this.clientsCount++;
+        socket.once("close", () => {
+            delete this.clients[id];
+            this.clientsCount--;
+        });
+        this.emit("connection", socket);
+        return transport;
+    }
+}
+exports.BaseServer = BaseServer;
+/**
+ * Protocol errors mappings.
+ */
+BaseServer.errors = {
+    UNKNOWN_TRANSPORT: 0,
+    UNKNOWN_SID: 1,
+    BAD_HANDSHAKE_METHOD: 2,
+    BAD_REQUEST: 3,
+    FORBIDDEN: 4,
+    UNSUPPORTED_PROTOCOL_VERSION: 5
+};
+BaseServer.errorMessages = {
+    0: "Transport unknown",
+    1: "Session ID unknown",
+    2: "Bad handshake method",
+    3: "Bad request",
+    4: "Forbidden",
+    5: "Unsupported protocol version"
+};
+class Server extends BaseServer {
+    /**
+     * Initialize websocket server
+     *
+     * @api protected
+     */
+    init() {
+        if (!~this.opts.transports.indexOf("websocket"))
+            return;
+        if (this.ws)
+            this.ws.close();
+        this.ws = new this.opts.wsEngine({
+            noServer: true,
+            clientTracking: false,
+            perMessageDeflate: this.opts.perMessageDeflate,
+            maxPayload: this.opts.maxHttpBufferSize
+        });
+        if (typeof this.ws.on === "function") {
+            this.ws.on("headers", (headersArray, req) => {
+                // note: 'ws' uses an array of headers, while Engine.IO uses an object (response.writeHead() accepts both formats)
+                // we could also try to parse the array and then sync the values, but that will be error-prone
+                const additionalHeaders = {};
+                const isInitialRequest = !req._query.sid;
+                if (isInitialRequest) {
+                    this.emit("initial_headers", additionalHeaders, req);
+                }
+                this.emit("headers", additionalHeaders, req);
+                Object.keys(additionalHeaders).forEach(key => {
+                    headersArray.push(`${key}: ${additionalHeaders[key]}`);
+                });
+            });
+        }
+    }
+    cleanup() {
+        if (this.ws) {
+            debug("closing webSocketServer");
+            this.ws.close();
+            // don't delete this.ws because it can be used again if the http server starts listening again
+        }
+    }
+    /**
+     * Prepares a request by processing the query string.
+     *
+     * @api private
+     */
+    prepare(req) {
+        // try to leverage pre-existing `req._query` (e.g: from connect)
+        if (!req._query) {
+            req._query = ~req.url.indexOf("?") ? qs.parse((0, url_1.parse)(req.url).query) : {};
+        }
+    }
+    createTransport(transportName, req) {
+        return new transports_1.default[transportName](req);
+    }
+    /**
+     * Handles an Engine.IO HTTP request.
+     *
+     * @param {http.IncomingMessage} request
+     * @param {http.ServerResponse|http.OutgoingMessage} response
+     * @api public
+     */
+    handleRequest(req, res) {
+        debug('handling "%s" http request "%s"', req.method, req.url);
+        this.prepare(req);
+        req.res = res;
+        const callback = (errorCode, errorContext) => {
+            if (errorCode !== undefined) {
+                this.emit("connection_error", {
+                    req,
+                    code: errorCode,
+                    message: Server.errorMessages[errorCode],
+                    context: errorContext
+                });
+                abortRequest(res, errorCode, errorContext);
+                return;
+            }
+            if (req._query.sid) {
+                debug("setting new request for existing client");
+                this.clients[req._query.sid].transport.onRequest(req);
+            }
+            else {
+                const closeConnection = (errorCode, errorContext) => abortRequest(res, errorCode, errorContext);
+                this.handshake(req._query.transport, req, closeConnection);
+            }
+        };
+        if (this.corsMiddleware) {
+            this.corsMiddleware.call(null, req, res, () => {
+                this.verify(req, false, callback);
+            });
+        }
+        else {
+            this.verify(req, false, callback);
+        }
+    }
+    /**
+     * Handles an Engine.IO HTTP Upgrade.
+     *
+     * @api public
+     */
+    handleUpgrade(req, socket, upgradeHead) {
+        this.prepare(req);
+        this.verify(req, true, (errorCode, errorContext) => {
+            if (errorCode) {
+                this.emit("connection_error", {
+                    req,
+                    code: errorCode,
+                    message: Server.errorMessages[errorCode],
+                    context: errorContext
+                });
+                abortUpgrade(socket, errorCode, errorContext);
+                return;
+            }
+            const head = Buffer.from(upgradeHead); // eslint-disable-line node/no-deprecated-api
+            upgradeHead = null;
+            // delegate to ws
+            this.ws.handleUpgrade(req, socket, head, websocket => {
+                this.onWebSocket(req, socket, websocket);
+            });
+        });
+    }
+    /**
+     * Called upon a ws.io connection.
+     *
+     * @param {ws.Socket} websocket
+     * @api private
+     */
+    onWebSocket(req, socket, websocket) {
+        websocket.on("error", onUpgradeError);
+        if (transports_1.default[req._query.transport] !== undefined &&
+            !transports_1.default[req._query.transport].prototype.handlesUpgrades) {
+            debug("transport doesnt handle upgraded requests");
+            websocket.close();
+            return;
+        }
+        // get client id
+        const id = req._query.sid;
+        // keep a reference to the ws.Socket
+        req.websocket = websocket;
+        if (id) {
+            const client = this.clients[id];
+            if (!client) {
+                debug("upgrade attempt for closed client");
+                websocket.close();
+            }
+            else if (client.upgrading) {
+                debug("transport has already been trying to upgrade");
+                websocket.close();
+            }
+            else if (client.upgraded) {
+                debug("transport had already been upgraded");
+                websocket.close();
+            }
+            else {
+                debug("upgrading existing transport");
+                // transport error handling takes over
+                websocket.removeListener("error", onUpgradeError);
+                const transport = this.createTransport(req._query.transport, req);
+                if (req._query && req._query.b64) {
+                    transport.supportsBinary = false;
+                }
+                else {
+                    transport.supportsBinary = true;
+                }
+                transport.perMessageDeflate = this.opts.perMessageDeflate;
+                client.maybeUpgrade(transport);
+            }
+        }
+        else {
+            // transport error handling takes over
+            websocket.removeListener("error", onUpgradeError);
+            const closeConnection = (errorCode, errorContext) => abortUpgrade(socket, errorCode, errorContext);
+            this.handshake(req._query.transport, req, closeConnection);
+        }
+        function onUpgradeError() {
+            debug("websocket error before upgrade");
+            // websocket.close() not needed
+        }
+    }
+    /**
+     * Captures upgrade requests for a http.Server.
+     *
+     * @param {http.Server} server
+     * @param {Object} options
+     * @api public
+     */
+    attach(server, options = {}) {
+        let path = (options.path || "/engine.io").replace(/\/$/, "");
+        const destroyUpgradeTimeout = options.destroyUpgradeTimeout || 1000;
+        // normalize path
+        path += "/";
+        function check(req) {
+            return path === req.url.substr(0, path.length);
+        }
+        // cache and clean up listeners
+        const listeners = server.listeners("request").slice(0);
+        server.removeAllListeners("request");
+        server.on("close", this.close.bind(this));
+        server.on("listening", this.init.bind(this));
+        // add request handler
+        server.on("request", (req, res) => {
+            if (check(req)) {
+                debug('intercepting request for path "%s"', path);
+                this.handleRequest(req, res);
+            }
+            else {
+                let i = 0;
+                const l = listeners.length;
+                for (; i < l; i++) {
+                    listeners[i].call(server, req, res);
+                }
+            }
+        });
+        if (~this.opts.transports.indexOf("websocket")) {
+            server.on("upgrade", (req, socket, head) => {
+                if (check(req)) {
+                    this.handleUpgrade(req, socket, head);
+                }
+                else if (false !== options.destroyUpgrade) {
+                    // default node behavior is to disconnect when no handlers
+                    // but by adding a handler, we prevent that
+                    // and if no eio thing handles the upgrade
+                    // then the socket needs to die!
+                    setTimeout(function () {
+                        // @ts-ignore
+                        if (socket.writable && socket.bytesWritten <= 0) {
+                            return socket.end();
+                        }
+                    }, destroyUpgradeTimeout);
+                }
+            });
+        }
+    }
+}
+exports.Server = Server;
+/**
+ * Close the HTTP long-polling request
+ *
+ * @param res - the response object
+ * @param errorCode - the error code
+ * @param errorContext - additional error context
+ *
+ * @api private
+ */
+function abortRequest(res, errorCode, errorContext) {
+    const statusCode = errorCode === Server.errors.FORBIDDEN ? 403 : 400;
+    const message = errorContext && errorContext.message
+        ? errorContext.message
+        : Server.errorMessages[errorCode];
+    res.writeHead(statusCode, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+        code: errorCode,
+        message
+    }));
+}
+/**
+ * Close the WebSocket connection
+ *
+ * @param {net.Socket} socket
+ * @param {string} errorCode - the error code
+ * @param {object} errorContext - additional error context
+ *
+ * @api private
+ */
+function abortUpgrade(socket, errorCode, errorContext = {}) {
+    socket.on("error", () => {
+        debug("ignoring error from closed connection");
+    });
+    if (socket.writable) {
+        const message = errorContext.message || Server.errorMessages[errorCode];
+        const length = Buffer.byteLength(message);
+        socket.write("HTTP/1.1 400 Bad Request\r\n" +
+            "Connection: close\r\n" +
+            "Content-type: text/html\r\n" +
+            "Content-Length: " +
+            length +
+            "\r\n" +
+            "\r\n" +
+            message);
+    }
+    socket.destroy();
+}
+/* eslint-disable */
+/**
+ * From https://github.com/nodejs/node/blob/v8.4.0/lib/_http_common.js#L303-L354
+ *
+ * True if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ *
+ * checkInvalidHeaderChar() is currently designed to be inlinable by v8,
+ * so take care when making changes to the implementation so that the source
+ * code size does not exceed v8's default max_inlined_source_size setting.
+ **/
+// prettier-ignore
+const validHdrChars = [
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // ... 255
+];
+function checkInvalidHeaderChar(val) {
+    val += "";
+    if (val.length < 1)
+        return false;
+    if (!validHdrChars[val.charCodeAt(0)]) {
+        debug('invalid header, index 0, char "%s"', val.charCodeAt(0));
+        return true;
+    }
+    if (val.length < 2)
+        return false;
+    if (!validHdrChars[val.charCodeAt(1)]) {
+        debug('invalid header, index 1, char "%s"', val.charCodeAt(1));
+        return true;
+    }
+    if (val.length < 3)
+        return false;
+    if (!validHdrChars[val.charCodeAt(2)]) {
+        debug('invalid header, index 2, char "%s"', val.charCodeAt(2));
+        return true;
+    }
+    if (val.length < 4)
+        return false;
+    if (!validHdrChars[val.charCodeAt(3)]) {
+        debug('invalid header, index 3, char "%s"', val.charCodeAt(3));
+        return true;
+    }
+    for (let i = 4; i < val.length; ++i) {
+        if (!validHdrChars[val.charCodeAt(i)]) {
+            debug('invalid header, index "%i", char "%s"', i, val.charCodeAt(i));
+            return true;
+        }
+    }
+    return false;
+}
Index: trip-planner-front/node_modules/engine.io/build/socket.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/socket.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/socket.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,143 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { IncomingMessage } from "http";
+import { Transport } from "./transport";
+export declare class Socket extends EventEmitter {
+    readonly protocol: number;
+    readonly request: IncomingMessage;
+    readonly remoteAddress: string;
+    _readyState: string;
+    transport: Transport;
+    private server;
+    private upgrading;
+    private upgraded;
+    private writeBuffer;
+    private packetsFn;
+    private sentCallbackFn;
+    private cleanupFn;
+    private checkIntervalTimer;
+    private upgradeTimeoutTimer;
+    private pingTimeoutTimer;
+    private pingIntervalTimer;
+    private readonly id;
+    get readyState(): string;
+    set readyState(state: string);
+    /**
+     * Client class (abstract).
+     *
+     * @api private
+     */
+    constructor(id: any, server: any, transport: any, req: any, protocol: any);
+    /**
+     * Called upon transport considered open.
+     *
+     * @api private
+     */
+    private onOpen;
+    /**
+     * Called upon transport packet.
+     *
+     * @param {Object} packet
+     * @api private
+     */
+    private onPacket;
+    /**
+     * Called upon transport error.
+     *
+     * @param {Error} error object
+     * @api private
+     */
+    private onError;
+    /**
+     * Pings client every `this.pingInterval` and expects response
+     * within `this.pingTimeout` or closes connection.
+     *
+     * @api private
+     */
+    private schedulePing;
+    /**
+     * Resets ping timeout.
+     *
+     * @api private
+     */
+    private resetPingTimeout;
+    /**
+     * Attaches handlers for the given transport.
+     *
+     * @param {Transport} transport
+     * @api private
+     */
+    private setTransport;
+    /**
+     * Upgrades socket to the given transport
+     *
+     * @param {Transport} transport
+     * @api private
+     */
+    private maybeUpgrade;
+    /**
+     * Clears listeners and timers associated with current transport.
+     *
+     * @api private
+     */
+    private clearTransport;
+    /**
+     * Called upon transport considered closed.
+     * Possible reasons: `ping timeout`, `client error`, `parse error`,
+     * `transport error`, `server close`, `transport close`
+     */
+    private onClose;
+    /**
+     * Setup and manage send callback
+     *
+     * @api private
+     */
+    private setupSendCallback;
+    /**
+     * Sends a message packet.
+     *
+     * @param {String} message
+     * @param {Object} options
+     * @param {Function} callback
+     * @return {Socket} for chaining
+     * @api public
+     */
+    send(data: any, options: any, callback?: any): this;
+    write(data: any, options: any, callback?: any): this;
+    /**
+     * Sends a packet.
+     *
+     * @param {String} packet type
+     * @param {String} optional, data
+     * @param {Object} options
+     * @api private
+     */
+    private sendPacket;
+    /**
+     * Attempts to flush the packets buffer.
+     *
+     * @api private
+     */
+    private flush;
+    /**
+     * Get available upgrades for this socket.
+     *
+     * @api private
+     */
+    private getAvailableUpgrades;
+    /**
+     * Closes the socket and underlying transport.
+     *
+     * @param {Boolean} discard - optional, discard the transport
+     * @return {Socket} for chaining
+     * @api public
+     */
+    close(discard?: boolean): void;
+    /**
+     * Closes the underlying transport.
+     *
+     * @param {Boolean} discard
+     * @api private
+     */
+    private closeTransport;
+}
Index: trip-planner-front/node_modules/engine.io/build/socket.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/socket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/socket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Socket = void 0;
+const events_1 = require("events");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)("engine:socket");
+class Socket extends events_1.EventEmitter {
+    /**
+     * Client class (abstract).
+     *
+     * @api private
+     */
+    constructor(id, server, transport, req, protocol) {
+        super();
+        this.id = id;
+        this.server = server;
+        this.upgrading = false;
+        this.upgraded = false;
+        this.readyState = "opening";
+        this.writeBuffer = [];
+        this.packetsFn = [];
+        this.sentCallbackFn = [];
+        this.cleanupFn = [];
+        this.request = req;
+        this.protocol = protocol;
+        // Cache IP since it might not be in the req later
+        if (req.websocket && req.websocket._socket) {
+            this.remoteAddress = req.websocket._socket.remoteAddress;
+        }
+        else {
+            this.remoteAddress = req.connection.remoteAddress;
+        }
+        this.checkIntervalTimer = null;
+        this.upgradeTimeoutTimer = null;
+        this.pingTimeoutTimer = null;
+        this.pingIntervalTimer = null;
+        this.setTransport(transport);
+        this.onOpen();
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    set readyState(state) {
+        debug("readyState updated from %s to %s", this._readyState, state);
+        this._readyState = state;
+    }
+    /**
+     * Called upon transport considered open.
+     *
+     * @api private
+     */
+    onOpen() {
+        this.readyState = "open";
+        // sends an `open` packet
+        this.transport.sid = this.id;
+        this.sendPacket("open", JSON.stringify({
+            sid: this.id,
+            upgrades: this.getAvailableUpgrades(),
+            pingInterval: this.server.opts.pingInterval,
+            pingTimeout: this.server.opts.pingTimeout
+        }));
+        if (this.server.opts.initialPacket) {
+            this.sendPacket("message", this.server.opts.initialPacket);
+        }
+        this.emit("open");
+        if (this.protocol === 3) {
+            // in protocol v3, the client sends a ping, and the server answers with a pong
+            this.resetPingTimeout(this.server.opts.pingInterval + this.server.opts.pingTimeout);
+        }
+        else {
+            // in protocol v4, the server sends a ping, and the client answers with a pong
+            this.schedulePing();
+        }
+    }
+    /**
+     * Called upon transport packet.
+     *
+     * @param {Object} packet
+     * @api private
+     */
+    onPacket(packet) {
+        if ("open" !== this.readyState) {
+            return debug("packet received with closed socket");
+        }
+        // export packet event
+        debug(`received packet ${packet.type}`);
+        this.emit("packet", packet);
+        // Reset ping timeout on any packet, incoming data is a good sign of
+        // other side's liveness
+        this.resetPingTimeout(this.server.opts.pingInterval + this.server.opts.pingTimeout);
+        switch (packet.type) {
+            case "ping":
+                if (this.transport.protocol !== 3) {
+                    this.onError("invalid heartbeat direction");
+                    return;
+                }
+                debug("got ping");
+                this.sendPacket("pong");
+                this.emit("heartbeat");
+                break;
+            case "pong":
+                if (this.transport.protocol === 3) {
+                    this.onError("invalid heartbeat direction");
+                    return;
+                }
+                debug("got pong");
+                this.pingIntervalTimer.refresh();
+                this.emit("heartbeat");
+                break;
+            case "error":
+                this.onClose("parse error");
+                break;
+            case "message":
+                this.emit("data", packet.data);
+                this.emit("message", packet.data);
+                break;
+        }
+    }
+    /**
+     * Called upon transport error.
+     *
+     * @param {Error} error object
+     * @api private
+     */
+    onError(err) {
+        debug("transport error");
+        this.onClose("transport error", err);
+    }
+    /**
+     * Pings client every `this.pingInterval` and expects response
+     * within `this.pingTimeout` or closes connection.
+     *
+     * @api private
+     */
+    schedulePing() {
+        this.pingIntervalTimer = setTimeout(() => {
+            debug("writing ping packet - expecting pong within %sms", this.server.opts.pingTimeout);
+            this.sendPacket("ping");
+            this.resetPingTimeout(this.server.opts.pingTimeout);
+        }, this.server.opts.pingInterval);
+    }
+    /**
+     * Resets ping timeout.
+     *
+     * @api private
+     */
+    resetPingTimeout(timeout) {
+        clearTimeout(this.pingTimeoutTimer);
+        this.pingTimeoutTimer = setTimeout(() => {
+            if (this.readyState === "closed")
+                return;
+            this.onClose("ping timeout");
+        }, timeout);
+    }
+    /**
+     * Attaches handlers for the given transport.
+     *
+     * @param {Transport} transport
+     * @api private
+     */
+    setTransport(transport) {
+        const onError = this.onError.bind(this);
+        const onPacket = this.onPacket.bind(this);
+        const flush = this.flush.bind(this);
+        const onClose = this.onClose.bind(this, "transport close");
+        this.transport = transport;
+        this.transport.once("error", onError);
+        this.transport.on("packet", onPacket);
+        this.transport.on("drain", flush);
+        this.transport.once("close", onClose);
+        // this function will manage packet events (also message callbacks)
+        this.setupSendCallback();
+        this.cleanupFn.push(function () {
+            transport.removeListener("error", onError);
+            transport.removeListener("packet", onPacket);
+            transport.removeListener("drain", flush);
+            transport.removeListener("close", onClose);
+        });
+    }
+    /**
+     * Upgrades socket to the given transport
+     *
+     * @param {Transport} transport
+     * @api private
+     */
+    maybeUpgrade(transport) {
+        debug('might upgrade socket transport from "%s" to "%s"', this.transport.name, transport.name);
+        this.upgrading = true;
+        // set transport upgrade timer
+        this.upgradeTimeoutTimer = setTimeout(() => {
+            debug("client did not complete upgrade - closing transport");
+            cleanup();
+            if ("open" === transport.readyState) {
+                transport.close();
+            }
+        }, this.server.opts.upgradeTimeout);
+        const onPacket = packet => {
+            if ("ping" === packet.type && "probe" === packet.data) {
+                debug("got probe ping packet, sending pong");
+                transport.send([{ type: "pong", data: "probe" }]);
+                this.emit("upgrading", transport);
+                clearInterval(this.checkIntervalTimer);
+                this.checkIntervalTimer = setInterval(check, 100);
+            }
+            else if ("upgrade" === packet.type && this.readyState !== "closed") {
+                debug("got upgrade packet - upgrading");
+                cleanup();
+                this.transport.discard();
+                this.upgraded = true;
+                this.clearTransport();
+                this.setTransport(transport);
+                this.emit("upgrade", transport);
+                this.flush();
+                if (this.readyState === "closing") {
+                    transport.close(() => {
+                        this.onClose("forced close");
+                    });
+                }
+            }
+            else {
+                cleanup();
+                transport.close();
+            }
+        };
+        // we force a polling cycle to ensure a fast upgrade
+        const check = () => {
+            if ("polling" === this.transport.name && this.transport.writable) {
+                debug("writing a noop packet to polling for fast upgrade");
+                this.transport.send([{ type: "noop" }]);
+            }
+        };
+        const cleanup = () => {
+            this.upgrading = false;
+            clearInterval(this.checkIntervalTimer);
+            this.checkIntervalTimer = null;
+            clearTimeout(this.upgradeTimeoutTimer);
+            this.upgradeTimeoutTimer = null;
+            transport.removeListener("packet", onPacket);
+            transport.removeListener("close", onTransportClose);
+            transport.removeListener("error", onError);
+            this.removeListener("close", onClose);
+        };
+        const onError = err => {
+            debug("client did not complete upgrade - %s", err);
+            cleanup();
+            transport.close();
+            transport = null;
+        };
+        const onTransportClose = () => {
+            onError("transport closed");
+        };
+        const onClose = () => {
+            onError("socket closed");
+        };
+        transport.on("packet", onPacket);
+        transport.once("close", onTransportClose);
+        transport.once("error", onError);
+        this.once("close", onClose);
+    }
+    /**
+     * Clears listeners and timers associated with current transport.
+     *
+     * @api private
+     */
+    clearTransport() {
+        let cleanup;
+        const toCleanUp = this.cleanupFn.length;
+        for (let i = 0; i < toCleanUp; i++) {
+            cleanup = this.cleanupFn.shift();
+            cleanup();
+        }
+        // silence further transport errors and prevent uncaught exceptions
+        this.transport.on("error", function () {
+            debug("error triggered by discarded transport");
+        });
+        // ensure transport won't stay open
+        this.transport.close();
+        clearTimeout(this.pingTimeoutTimer);
+    }
+    /**
+     * Called upon transport considered closed.
+     * Possible reasons: `ping timeout`, `client error`, `parse error`,
+     * `transport error`, `server close`, `transport close`
+     */
+    onClose(reason, description) {
+        if ("closed" !== this.readyState) {
+            this.readyState = "closed";
+            // clear timers
+            clearTimeout(this.pingIntervalTimer);
+            clearTimeout(this.pingTimeoutTimer);
+            clearInterval(this.checkIntervalTimer);
+            this.checkIntervalTimer = null;
+            clearTimeout(this.upgradeTimeoutTimer);
+            // clean writeBuffer in next tick, so developers can still
+            // grab the writeBuffer on 'close' event
+            process.nextTick(() => {
+                this.writeBuffer = [];
+            });
+            this.packetsFn = [];
+            this.sentCallbackFn = [];
+            this.clearTransport();
+            this.emit("close", reason, description);
+        }
+    }
+    /**
+     * Setup and manage send callback
+     *
+     * @api private
+     */
+    setupSendCallback() {
+        // the message was sent successfully, execute the callback
+        const onDrain = () => {
+            if (this.sentCallbackFn.length > 0) {
+                const seqFn = this.sentCallbackFn.splice(0, 1)[0];
+                if ("function" === typeof seqFn) {
+                    debug("executing send callback");
+                    seqFn(this.transport);
+                }
+                else if (Array.isArray(seqFn)) {
+                    debug("executing batch send callback");
+                    const l = seqFn.length;
+                    let i = 0;
+                    for (; i < l; i++) {
+                        if ("function" === typeof seqFn[i]) {
+                            seqFn[i](this.transport);
+                        }
+                    }
+                }
+            }
+        };
+        this.transport.on("drain", onDrain);
+        this.cleanupFn.push(() => {
+            this.transport.removeListener("drain", onDrain);
+        });
+    }
+    /**
+     * Sends a message packet.
+     *
+     * @param {String} message
+     * @param {Object} options
+     * @param {Function} callback
+     * @return {Socket} for chaining
+     * @api public
+     */
+    send(data, options, callback) {
+        this.sendPacket("message", data, options, callback);
+        return this;
+    }
+    write(data, options, callback) {
+        this.sendPacket("message", data, options, callback);
+        return this;
+    }
+    /**
+     * Sends a packet.
+     *
+     * @param {String} packet type
+     * @param {String} optional, data
+     * @param {Object} options
+     * @api private
+     */
+    sendPacket(type, data, options, callback) {
+        if ("function" === typeof options) {
+            callback = options;
+            options = null;
+        }
+        options = options || {};
+        options.compress = false !== options.compress;
+        if ("closing" !== this.readyState && "closed" !== this.readyState) {
+            debug('sending packet "%s" (%s)', type, data);
+            const packet = {
+                type: type,
+                options: options
+            };
+            if (data)
+                packet.data = data;
+            // exports packetCreate event
+            this.emit("packetCreate", packet);
+            this.writeBuffer.push(packet);
+            // add send callback to object, if defined
+            if (callback)
+                this.packetsFn.push(callback);
+            this.flush();
+        }
+    }
+    /**
+     * Attempts to flush the packets buffer.
+     *
+     * @api private
+     */
+    flush() {
+        if ("closed" !== this.readyState &&
+            this.transport.writable &&
+            this.writeBuffer.length) {
+            debug("flushing buffer to transport");
+            this.emit("flush", this.writeBuffer);
+            this.server.emit("flush", this, this.writeBuffer);
+            const wbuf = this.writeBuffer;
+            this.writeBuffer = [];
+            if (!this.transport.supportsFraming) {
+                this.sentCallbackFn.push(this.packetsFn);
+            }
+            else {
+                this.sentCallbackFn.push.apply(this.sentCallbackFn, this.packetsFn);
+            }
+            this.packetsFn = [];
+            this.transport.send(wbuf);
+            this.emit("drain");
+            this.server.emit("drain", this);
+        }
+    }
+    /**
+     * Get available upgrades for this socket.
+     *
+     * @api private
+     */
+    getAvailableUpgrades() {
+        const availableUpgrades = [];
+        const allUpgrades = this.server.upgrades(this.transport.name);
+        let i = 0;
+        const l = allUpgrades.length;
+        for (; i < l; ++i) {
+            const upg = allUpgrades[i];
+            if (this.server.opts.transports.indexOf(upg) !== -1) {
+                availableUpgrades.push(upg);
+            }
+        }
+        return availableUpgrades;
+    }
+    /**
+     * Closes the socket and underlying transport.
+     *
+     * @param {Boolean} discard - optional, discard the transport
+     * @return {Socket} for chaining
+     * @api public
+     */
+    close(discard) {
+        if ("open" !== this.readyState)
+            return;
+        this.readyState = "closing";
+        if (this.writeBuffer.length) {
+            this.once("drain", this.closeTransport.bind(this, discard));
+            return;
+        }
+        this.closeTransport(discard);
+    }
+    /**
+     * Closes the underlying transport.
+     *
+     * @param {Boolean} discard
+     * @api private
+     */
+    closeTransport(discard) {
+        if (discard)
+            this.transport.discard();
+        this.transport.close(this.onClose.bind(this, "forced close"));
+    }
+}
+exports.Socket = Socket;
Index: trip-planner-front/node_modules/engine.io/build/transport.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transport.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transport.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { IncomingMessage } from "http";
+export declare abstract class Transport extends EventEmitter {
+    sid: string;
+    writable: boolean;
+    protocol: number;
+    protected _readyState: string;
+    protected discarded: boolean;
+    protected parser: any;
+    protected req: IncomingMessage & {
+        cleanup: Function;
+    };
+    protected supportsBinary: boolean;
+    get readyState(): string;
+    set readyState(state: string);
+    /**
+     * Transport constructor.
+     *
+     * @param {http.IncomingMessage} request
+     * @api public
+     */
+    constructor(req: any);
+    /**
+     * Flags the transport as discarded.
+     *
+     * @api private
+     */
+    discard(): void;
+    /**
+     * Called with an incoming HTTP request.
+     *
+     * @param {http.IncomingMessage} request
+     * @api protected
+     */
+    protected onRequest(req: any): void;
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    close(fn?: any): void;
+    /**
+     * Called with a transport error.
+     *
+     * @param {String} message error
+     * @param {Object} error description
+     * @api protected
+     */
+    protected onError(msg: string, desc?: any): void;
+    /**
+     * Called with parsed out a packets from the data stream.
+     *
+     * @param {Object} packet
+     * @api protected
+     */
+    protected onPacket(packet: any): void;
+    /**
+     * Called with the encoded packet data.
+     *
+     * @param {String} data
+     * @api protected
+     */
+    protected onData(data: any): void;
+    /**
+     * Called upon transport close.
+     *
+     * @api protected
+     */
+    protected onClose(): void;
+    abstract get supportsFraming(): any;
+    abstract get name(): any;
+    abstract send(packets: any): any;
+    abstract doClose(fn?: any): any;
+}
Index: trip-planner-front/node_modules/engine.io/build/transport.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transport.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transport.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+const events_1 = require("events");
+const parser_v4 = require("engine.io-parser");
+const parser_v3 = require("./parser-v3/index");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)("engine:transport");
+/**
+ * Noop function.
+ *
+ * @api private
+ */
+function noop() { }
+class Transport extends events_1.EventEmitter {
+    /**
+     * Transport constructor.
+     *
+     * @param {http.IncomingMessage} request
+     * @api public
+     */
+    constructor(req) {
+        super();
+        this.readyState = "open";
+        this.discarded = false;
+        this.protocol = req._query.EIO === "4" ? 4 : 3; // 3rd revision by default
+        this.parser = this.protocol === 4 ? parser_v4 : parser_v3;
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    set readyState(state) {
+        debug("readyState updated from %s to %s (%s)", this._readyState, state, this.name);
+        this._readyState = state;
+    }
+    /**
+     * Flags the transport as discarded.
+     *
+     * @api private
+     */
+    discard() {
+        this.discarded = true;
+    }
+    /**
+     * Called with an incoming HTTP request.
+     *
+     * @param {http.IncomingMessage} request
+     * @api protected
+     */
+    onRequest(req) {
+        debug("setting request");
+        this.req = req;
+    }
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    close(fn) {
+        if ("closed" === this.readyState || "closing" === this.readyState)
+            return;
+        this.readyState = "closing";
+        this.doClose(fn || noop);
+    }
+    /**
+     * Called with a transport error.
+     *
+     * @param {String} message error
+     * @param {Object} error description
+     * @api protected
+     */
+    onError(msg, desc) {
+        if (this.listeners("error").length) {
+            const err = new Error(msg);
+            // @ts-ignore
+            err.type = "TransportError";
+            // @ts-ignore
+            err.description = desc;
+            this.emit("error", err);
+        }
+        else {
+            debug("ignored transport error %s (%s)", msg, desc);
+        }
+    }
+    /**
+     * Called with parsed out a packets from the data stream.
+     *
+     * @param {Object} packet
+     * @api protected
+     */
+    onPacket(packet) {
+        this.emit("packet", packet);
+    }
+    /**
+     * Called with the encoded packet data.
+     *
+     * @param {String} data
+     * @api protected
+     */
+    onData(data) {
+        this.onPacket(this.parser.decodePacket(data));
+    }
+    /**
+     * Called upon transport close.
+     *
+     * @api protected
+     */
+    onClose() {
+        this.readyState = "closed";
+        this.emit("close");
+    }
+}
+exports.Transport = Transport;
Index: trip-planner-front/node_modules/engine.io/build/transports-uws/index.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports-uws/index.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports-uws/index.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,7 @@
+import { Polling } from "./polling";
+import { WebSocket } from "./websocket";
+declare const _default: {
+    polling: typeof Polling;
+    websocket: typeof WebSocket;
+};
+export default _default;
Index: trip-planner-front/node_modules/engine.io/build/transports-uws/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports-uws/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports-uws/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const polling_1 = require("./polling");
+const websocket_1 = require("./websocket");
+exports.default = {
+    polling: polling_1.Polling,
+    websocket: websocket_1.WebSocket
+};
Index: trip-planner-front/node_modules/engine.io/build/transports-uws/polling.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports-uws/polling.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports-uws/polling.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,97 @@
+import { Transport } from "../transport";
+export declare class Polling extends Transport {
+    maxHttpBufferSize: number;
+    httpCompression: any;
+    private res;
+    private dataReq;
+    private dataRes;
+    private shouldClose;
+    private readonly closeTimeout;
+    /**
+     * HTTP polling constructor.
+     *
+     * @api public.
+     */
+    constructor(req: any);
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name(): string;
+    get supportsFraming(): boolean;
+    /**
+     * Overrides onRequest.
+     *
+     * @param req
+     *
+     * @api private
+     */
+    onRequest(req: any): void;
+    /**
+     * The client sends a request awaiting for us to send data.
+     *
+     * @api private
+     */
+    onPollRequest(req: any, res: any): void;
+    /**
+     * The client sends a request with data.
+     *
+     * @api private
+     */
+    onDataRequest(req: any, res: any): void;
+    /**
+     * Processes the incoming data payload.
+     *
+     * @param {String} encoded payload
+     * @api private
+     */
+    onData(data: any): void;
+    /**
+     * Overrides onClose.
+     *
+     * @api private
+     */
+    onClose(): void;
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Object} packet
+     * @api private
+     */
+    send(packets: any): void;
+    /**
+     * Writes data as response to poll request.
+     *
+     * @param {String} data
+     * @param {Object} options
+     * @api private
+     */
+    write(data: any, options: any): void;
+    /**
+     * Performs the write.
+     *
+     * @api private
+     */
+    doWrite(data: any, options: any, callback: any): void;
+    /**
+     * Compresses data.
+     *
+     * @api private
+     */
+    compress(data: any, encoding: any, callback: any): void;
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn: any): void;
+    /**
+     * Returns headers for a response.
+     *
+     * @param req - request
+     * @param {Object} extra headers
+     * @api private
+     */
+    headers(req: any, headers: any): any;
+}
Index: trip-planner-front/node_modules/engine.io/build/transports-uws/polling.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports-uws/polling.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports-uws/polling.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polling = void 0;
+const transport_1 = require("../transport");
+const zlib_1 = require("zlib");
+const accepts = require("accepts");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)("engine:polling");
+const compressionMethods = {
+    gzip: zlib_1.createGzip,
+    deflate: zlib_1.createDeflate
+};
+class Polling extends transport_1.Transport {
+    /**
+     * HTTP polling constructor.
+     *
+     * @api public.
+     */
+    constructor(req) {
+        super(req);
+        this.closeTimeout = 30 * 1000;
+    }
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name() {
+        return "polling";
+    }
+    get supportsFraming() {
+        return false;
+    }
+    /**
+     * Overrides onRequest.
+     *
+     * @param req
+     *
+     * @api private
+     */
+    onRequest(req) {
+        const res = req.res;
+        if (req.getMethod() === "get") {
+            this.onPollRequest(req, res);
+        }
+        else if (req.getMethod() === "post") {
+            this.onDataRequest(req, res);
+        }
+        else {
+            res.writeStatus("500 Internal Server Error");
+            res.end();
+        }
+    }
+    /**
+     * The client sends a request awaiting for us to send data.
+     *
+     * @api private
+     */
+    onPollRequest(req, res) {
+        if (this.req) {
+            debug("request overlap");
+            // assert: this.res, '.req and .res should be (un)set together'
+            this.onError("overlap from client");
+            res.writeStatus("500 Internal Server Error");
+            res.end();
+            return;
+        }
+        debug("setting request");
+        this.req = req;
+        this.res = res;
+        const onClose = () => {
+            this.writable = false;
+            this.onError("poll connection closed prematurely");
+        };
+        const cleanup = () => {
+            this.req = this.res = null;
+        };
+        req.cleanup = cleanup;
+        res.onAborted(onClose);
+        this.writable = true;
+        this.emit("drain");
+        // if we're still writable but had a pending close, trigger an empty send
+        if (this.writable && this.shouldClose) {
+            debug("triggering empty send to append close packet");
+            this.send([{ type: "noop" }]);
+        }
+    }
+    /**
+     * The client sends a request with data.
+     *
+     * @api private
+     */
+    onDataRequest(req, res) {
+        if (this.dataReq) {
+            // assert: this.dataRes, '.dataReq and .dataRes should be (un)set together'
+            this.onError("data request overlap from client");
+            res.writeStatus("500 Internal Server Error");
+            res.end();
+            return;
+        }
+        const isBinary = "application/octet-stream" === req.headers["content-type"];
+        if (isBinary && this.protocol === 4) {
+            return this.onError("invalid content");
+        }
+        this.dataReq = req;
+        this.dataRes = res;
+        let chunks = [];
+        let contentLength = 0;
+        const cleanup = () => {
+            this.dataReq = this.dataRes = chunks = null;
+        };
+        const onClose = () => {
+            cleanup();
+            this.onError("data request connection closed prematurely");
+        };
+        const headers = {
+            // text/html is required instead of text/plain to avoid an
+            // unwanted download dialog on certain user-agents (GH-43)
+            "Content-Type": "text/html"
+        };
+        this.headers(req, headers);
+        Object.keys(headers).forEach(key => {
+            res.writeHeader(key, String(headers[key]));
+        });
+        const onEnd = () => {
+            this.onData(Buffer.concat(chunks).toString());
+            if (this.readyState !== "closing") {
+                res.end("ok");
+            }
+            cleanup();
+        };
+        res.onAborted(onClose);
+        res.onData((chunk, isLast) => {
+            chunks.push(Buffer.from(chunk));
+            contentLength += Buffer.byteLength(chunk);
+            if (contentLength > this.maxHttpBufferSize) {
+                this.onError("payload too large");
+                res.writeStatus("413 Payload Too Large");
+                res.end();
+                return;
+            }
+            if (isLast) {
+                onEnd();
+            }
+        });
+    }
+    /**
+     * Processes the incoming data payload.
+     *
+     * @param {String} encoded payload
+     * @api private
+     */
+    onData(data) {
+        debug('received "%s"', data);
+        const callback = packet => {
+            if ("close" === packet.type) {
+                debug("got xhr close packet");
+                this.onClose();
+                return false;
+            }
+            this.onPacket(packet);
+        };
+        if (this.protocol === 3) {
+            this.parser.decodePayload(data, callback);
+        }
+        else {
+            this.parser.decodePayload(data).forEach(callback);
+        }
+    }
+    /**
+     * Overrides onClose.
+     *
+     * @api private
+     */
+    onClose() {
+        if (this.writable) {
+            // close pending poll request
+            this.send([{ type: "noop" }]);
+        }
+        super.onClose();
+    }
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Object} packet
+     * @api private
+     */
+    send(packets) {
+        this.writable = false;
+        if (this.shouldClose) {
+            debug("appending close packet to payload");
+            packets.push({ type: "close" });
+            this.shouldClose();
+            this.shouldClose = null;
+        }
+        const doWrite = data => {
+            const compress = packets.some(packet => {
+                return packet.options && packet.options.compress;
+            });
+            this.write(data, { compress });
+        };
+        if (this.protocol === 3) {
+            this.parser.encodePayload(packets, this.supportsBinary, doWrite);
+        }
+        else {
+            this.parser.encodePayload(packets, doWrite);
+        }
+    }
+    /**
+     * Writes data as response to poll request.
+     *
+     * @param {String} data
+     * @param {Object} options
+     * @api private
+     */
+    write(data, options) {
+        debug('writing "%s"', data);
+        this.doWrite(data, options, () => {
+            this.req.cleanup();
+        });
+    }
+    /**
+     * Performs the write.
+     *
+     * @api private
+     */
+    doWrite(data, options, callback) {
+        // explicit UTF-8 is required for pages not served under utf
+        const isString = typeof data === "string";
+        const contentType = isString
+            ? "text/plain; charset=UTF-8"
+            : "application/octet-stream";
+        const headers = {
+            "Content-Type": contentType
+        };
+        const respond = data => {
+            this.headers(this.req, headers);
+            Object.keys(headers).forEach(key => {
+                this.res.writeHeader(key, String(headers[key]));
+            });
+            this.res.end(data);
+            callback();
+        };
+        if (!this.httpCompression || !options.compress) {
+            respond(data);
+            return;
+        }
+        const len = isString ? Buffer.byteLength(data) : data.length;
+        if (len < this.httpCompression.threshold) {
+            respond(data);
+            return;
+        }
+        const encoding = accepts(this.req).encodings(["gzip", "deflate"]);
+        if (!encoding) {
+            respond(data);
+            return;
+        }
+        this.compress(data, encoding, (err, data) => {
+            if (err) {
+                this.res.writeStatus("500 Internal Server Error");
+                this.res.end();
+                callback(err);
+                return;
+            }
+            headers["Content-Encoding"] = encoding;
+            respond(data);
+        });
+    }
+    /**
+     * Compresses data.
+     *
+     * @api private
+     */
+    compress(data, encoding, callback) {
+        debug("compressing");
+        const buffers = [];
+        let nread = 0;
+        compressionMethods[encoding](this.httpCompression)
+            .on("error", callback)
+            .on("data", function (chunk) {
+            buffers.push(chunk);
+            nread += chunk.length;
+        })
+            .on("end", function () {
+            callback(null, Buffer.concat(buffers, nread));
+        })
+            .end(data);
+    }
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn) {
+        debug("closing");
+        let closeTimeoutTimer;
+        const onClose = () => {
+            clearTimeout(closeTimeoutTimer);
+            fn();
+            this.onClose();
+        };
+        if (this.writable) {
+            debug("transport writable - closing right away");
+            this.send([{ type: "close" }]);
+            onClose();
+        }
+        else if (this.discarded) {
+            debug("transport discarded - closing right away");
+            onClose();
+        }
+        else {
+            debug("transport not writable - buffering orderly close");
+            this.shouldClose = onClose;
+            closeTimeoutTimer = setTimeout(onClose, this.closeTimeout);
+        }
+    }
+    /**
+     * Returns headers for a response.
+     *
+     * @param req - request
+     * @param {Object} extra headers
+     * @api private
+     */
+    headers(req, headers) {
+        headers = headers || {};
+        // prevent XSS warnings on IE
+        // https://github.com/LearnBoost/socket.io/pull/1333
+        const ua = req.headers["user-agent"];
+        if (ua && (~ua.indexOf(";MSIE") || ~ua.indexOf("Trident/"))) {
+            headers["X-XSS-Protection"] = "0";
+        }
+        this.emit("headers", headers, req);
+        return headers;
+    }
+}
+exports.Polling = Polling;
Index: trip-planner-front/node_modules/engine.io/build/transports-uws/websocket.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports-uws/websocket.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports-uws/websocket.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,43 @@
+import { Transport } from "../transport";
+export declare class WebSocket extends Transport {
+    protected perMessageDeflate: any;
+    private socket;
+    /**
+     * WebSocket transport
+     *
+     * @param req
+     * @api public
+     */
+    constructor(req: any);
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name(): string;
+    /**
+     * Advertise upgrade support.
+     *
+     * @api public
+     */
+    get handlesUpgrades(): boolean;
+    /**
+     * Advertise framing support.
+     *
+     * @api public
+     */
+    get supportsFraming(): boolean;
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Array} packets
+     * @api private
+     */
+    send(packets: any): void;
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn: any): void;
+}
Index: trip-planner-front/node_modules/engine.io/build/transports-uws/websocket.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports-uws/websocket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports-uws/websocket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocket = void 0;
+const transport_1 = require("../transport");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)("engine:ws");
+class WebSocket extends transport_1.Transport {
+    /**
+     * WebSocket transport
+     *
+     * @param req
+     * @api public
+     */
+    constructor(req) {
+        super(req);
+        this.writable = false;
+        this.perMessageDeflate = null;
+    }
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name() {
+        return "websocket";
+    }
+    /**
+     * Advertise upgrade support.
+     *
+     * @api public
+     */
+    get handlesUpgrades() {
+        return true;
+    }
+    /**
+     * Advertise framing support.
+     *
+     * @api public
+     */
+    get supportsFraming() {
+        return true;
+    }
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Array} packets
+     * @api private
+     */
+    send(packets) {
+        const packet = packets.shift();
+        if (typeof packet === "undefined") {
+            this.writable = true;
+            this.emit("drain");
+            return;
+        }
+        // always creates a new object since ws modifies it
+        const opts = {};
+        if (packet.options) {
+            opts.compress = packet.options.compress;
+        }
+        const send = data => {
+            const isBinary = typeof data !== "string";
+            const compress = this.perMessageDeflate &&
+                Buffer.byteLength(data) > this.perMessageDeflate.threshold;
+            debug('writing "%s"', data);
+            this.writable = false;
+            this.socket.send(data, isBinary, compress);
+            this.send(packets);
+        };
+        if (packet.options && typeof packet.options.wsPreEncoded === "string") {
+            send(packet.options.wsPreEncoded);
+        }
+        else {
+            this.parser.encodePacket(packet, this.supportsBinary, send);
+        }
+    }
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn) {
+        debug("closing");
+        fn && fn();
+        // call fn first since socket.close() immediately emits a "close" event
+        this.socket.close();
+    }
+}
+exports.WebSocket = WebSocket;
Index: trip-planner-front/node_modules/engine.io/build/transports/index.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/index.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/index.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,16 @@
+import { Polling as XHR } from "./polling";
+import { WebSocket } from "./websocket";
+declare const _default: {
+    polling: typeof polling;
+    websocket: typeof WebSocket;
+};
+export default _default;
+/**
+ * Polling polymorphic constructor.
+ *
+ * @api private
+ */
+declare function polling(req: any): XHR;
+declare namespace polling {
+    var upgradesTo: string[];
+}
Index: trip-planner-front/node_modules/engine.io/build/transports/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const polling_1 = require("./polling");
+const polling_jsonp_1 = require("./polling-jsonp");
+const websocket_1 = require("./websocket");
+exports.default = {
+    polling: polling,
+    websocket: websocket_1.WebSocket
+};
+/**
+ * Polling polymorphic constructor.
+ *
+ * @api private
+ */
+function polling(req) {
+    if ("string" === typeof req._query.j) {
+        return new polling_jsonp_1.JSONP(req);
+    }
+    else {
+        return new polling_1.Polling(req);
+    }
+}
+polling.upgradesTo = ["websocket"];
Index: trip-planner-front/node_modules/engine.io/build/transports/polling-jsonp.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/polling-jsonp.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/polling-jsonp.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,24 @@
+import { Polling } from "./polling";
+export declare class JSONP extends Polling {
+    private readonly head;
+    private readonly foot;
+    /**
+     * JSON-P polling transport.
+     *
+     * @api public
+     */
+    constructor(req: any);
+    /**
+     * Handles incoming data.
+     * Due to a bug in \n handling by browsers, we expect a escaped string.
+     *
+     * @api private
+     */
+    onData(data: any): void;
+    /**
+     * Performs the write.
+     *
+     * @api private
+     */
+    doWrite(data: any, options: any, callback: any): void;
+}
Index: trip-planner-front/node_modules/engine.io/build/transports/polling-jsonp.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/polling-jsonp.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/polling-jsonp.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONP = void 0;
+const polling_1 = require("./polling");
+const qs = require("querystring");
+const rDoubleSlashes = /\\\\n/g;
+const rSlashes = /(\\)?\\n/g;
+class JSONP extends polling_1.Polling {
+    /**
+     * JSON-P polling transport.
+     *
+     * @api public
+     */
+    constructor(req) {
+        super(req);
+        this.head = "___eio[" + (req._query.j || "").replace(/[^0-9]/g, "") + "](";
+        this.foot = ");";
+    }
+    /**
+     * Handles incoming data.
+     * Due to a bug in \n handling by browsers, we expect a escaped string.
+     *
+     * @api private
+     */
+    onData(data) {
+        // we leverage the qs module so that we get built-in DoS protection
+        // and the fast alternative to decodeURIComponent
+        data = qs.parse(data).d;
+        if ("string" === typeof data) {
+            // client will send already escaped newlines as \\\\n and newlines as \\n
+            // \\n must be replaced with \n and \\\\n with \\n
+            data = data.replace(rSlashes, function (match, slashes) {
+                return slashes ? match : "\n";
+            });
+            super.onData(data.replace(rDoubleSlashes, "\\n"));
+        }
+    }
+    /**
+     * Performs the write.
+     *
+     * @api private
+     */
+    doWrite(data, options, callback) {
+        // we must output valid javascript, not valid json
+        // see: http://timelessrepo.com/json-isnt-a-javascript-subset
+        const js = JSON.stringify(data)
+            .replace(/\u2028/g, "\\u2028")
+            .replace(/\u2029/g, "\\u2029");
+        // prepare response
+        data = this.head + js + this.foot;
+        super.doWrite(data, options, callback);
+    }
+}
+exports.JSONP = JSONP;
Index: trip-planner-front/node_modules/engine.io/build/transports/polling.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/polling.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/polling.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,96 @@
+import { Transport } from "../transport";
+export declare class Polling extends Transport {
+    maxHttpBufferSize: number;
+    httpCompression: any;
+    private res;
+    private dataReq;
+    private dataRes;
+    private shouldClose;
+    private readonly closeTimeout;
+    /**
+     * HTTP polling constructor.
+     *
+     * @api public.
+     */
+    constructor(req: any);
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name(): string;
+    get supportsFraming(): boolean;
+    /**
+     * Overrides onRequest.
+     *
+     * @param {http.IncomingMessage}
+     * @api private
+     */
+    onRequest(req: any): void;
+    /**
+     * The client sends a request awaiting for us to send data.
+     *
+     * @api private
+     */
+    onPollRequest(req: any, res: any): void;
+    /**
+     * The client sends a request with data.
+     *
+     * @api private
+     */
+    onDataRequest(req: any, res: any): void;
+    /**
+     * Processes the incoming data payload.
+     *
+     * @param {String} encoded payload
+     * @api private
+     */
+    onData(data: any): void;
+    /**
+     * Overrides onClose.
+     *
+     * @api private
+     */
+    onClose(): void;
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Object} packet
+     * @api private
+     */
+    send(packets: any): void;
+    /**
+     * Writes data as response to poll request.
+     *
+     * @param {String} data
+     * @param {Object} options
+     * @api private
+     */
+    write(data: any, options: any): void;
+    /**
+     * Performs the write.
+     *
+     * @api private
+     */
+    doWrite(data: any, options: any, callback: any): void;
+    /**
+     * Compresses data.
+     *
+     * @api private
+     */
+    compress(data: any, encoding: any, callback: any): void;
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn: any): void;
+    /**
+     * Returns headers for a response.
+     *
+     * @param {http.IncomingMessage} request
+     * @param {Object} extra headers
+     * @api private
+     */
+    headers(req: any, headers: any): any;
+}
Index: trip-planner-front/node_modules/engine.io/build/transports/polling.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/polling.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/polling.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polling = void 0;
+const transport_1 = require("../transport");
+const zlib_1 = require("zlib");
+const accepts = require("accepts");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)("engine:polling");
+const compressionMethods = {
+    gzip: zlib_1.createGzip,
+    deflate: zlib_1.createDeflate
+};
+class Polling extends transport_1.Transport {
+    /**
+     * HTTP polling constructor.
+     *
+     * @api public.
+     */
+    constructor(req) {
+        super(req);
+        this.closeTimeout = 30 * 1000;
+    }
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name() {
+        return "polling";
+    }
+    get supportsFraming() {
+        return false;
+    }
+    /**
+     * Overrides onRequest.
+     *
+     * @param {http.IncomingMessage}
+     * @api private
+     */
+    onRequest(req) {
+        const res = req.res;
+        if ("GET" === req.method) {
+            this.onPollRequest(req, res);
+        }
+        else if ("POST" === req.method) {
+            this.onDataRequest(req, res);
+        }
+        else {
+            res.writeHead(500);
+            res.end();
+        }
+    }
+    /**
+     * The client sends a request awaiting for us to send data.
+     *
+     * @api private
+     */
+    onPollRequest(req, res) {
+        if (this.req) {
+            debug("request overlap");
+            // assert: this.res, '.req and .res should be (un)set together'
+            this.onError("overlap from client");
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        debug("setting request");
+        this.req = req;
+        this.res = res;
+        const onClose = () => {
+            this.onError("poll connection closed prematurely");
+        };
+        const cleanup = () => {
+            req.removeListener("close", onClose);
+            this.req = this.res = null;
+        };
+        req.cleanup = cleanup;
+        req.on("close", onClose);
+        this.writable = true;
+        this.emit("drain");
+        // if we're still writable but had a pending close, trigger an empty send
+        if (this.writable && this.shouldClose) {
+            debug("triggering empty send to append close packet");
+            this.send([{ type: "noop" }]);
+        }
+    }
+    /**
+     * The client sends a request with data.
+     *
+     * @api private
+     */
+    onDataRequest(req, res) {
+        if (this.dataReq) {
+            // assert: this.dataRes, '.dataReq and .dataRes should be (un)set together'
+            this.onError("data request overlap from client");
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        const isBinary = "application/octet-stream" === req.headers["content-type"];
+        if (isBinary && this.protocol === 4) {
+            return this.onError("invalid content");
+        }
+        this.dataReq = req;
+        this.dataRes = res;
+        let chunks = isBinary ? Buffer.concat([]) : "";
+        const cleanup = () => {
+            req.removeListener("data", onData);
+            req.removeListener("end", onEnd);
+            req.removeListener("close", onClose);
+            this.dataReq = this.dataRes = chunks = null;
+        };
+        const onClose = () => {
+            cleanup();
+            this.onError("data request connection closed prematurely");
+        };
+        const onData = data => {
+            let contentLength;
+            if (isBinary) {
+                chunks = Buffer.concat([chunks, data]);
+                contentLength = chunks.length;
+            }
+            else {
+                chunks += data;
+                contentLength = Buffer.byteLength(chunks);
+            }
+            if (contentLength > this.maxHttpBufferSize) {
+                chunks = isBinary ? Buffer.concat([]) : "";
+                req.connection.destroy();
+            }
+        };
+        const onEnd = () => {
+            this.onData(chunks);
+            const headers = {
+                // text/html is required instead of text/plain to avoid an
+                // unwanted download dialog on certain user-agents (GH-43)
+                "Content-Type": "text/html",
+                "Content-Length": 2
+            };
+            res.writeHead(200, this.headers(req, headers));
+            res.end("ok");
+            cleanup();
+        };
+        req.on("close", onClose);
+        if (!isBinary)
+            req.setEncoding("utf8");
+        req.on("data", onData);
+        req.on("end", onEnd);
+    }
+    /**
+     * Processes the incoming data payload.
+     *
+     * @param {String} encoded payload
+     * @api private
+     */
+    onData(data) {
+        debug('received "%s"', data);
+        const callback = packet => {
+            if ("close" === packet.type) {
+                debug("got xhr close packet");
+                this.onClose();
+                return false;
+            }
+            this.onPacket(packet);
+        };
+        if (this.protocol === 3) {
+            this.parser.decodePayload(data, callback);
+        }
+        else {
+            this.parser.decodePayload(data).forEach(callback);
+        }
+    }
+    /**
+     * Overrides onClose.
+     *
+     * @api private
+     */
+    onClose() {
+        if (this.writable) {
+            // close pending poll request
+            this.send([{ type: "noop" }]);
+        }
+        super.onClose();
+    }
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Object} packet
+     * @api private
+     */
+    send(packets) {
+        this.writable = false;
+        if (this.shouldClose) {
+            debug("appending close packet to payload");
+            packets.push({ type: "close" });
+            this.shouldClose();
+            this.shouldClose = null;
+        }
+        const doWrite = data => {
+            const compress = packets.some(packet => {
+                return packet.options && packet.options.compress;
+            });
+            this.write(data, { compress });
+        };
+        if (this.protocol === 3) {
+            this.parser.encodePayload(packets, this.supportsBinary, doWrite);
+        }
+        else {
+            this.parser.encodePayload(packets, doWrite);
+        }
+    }
+    /**
+     * Writes data as response to poll request.
+     *
+     * @param {String} data
+     * @param {Object} options
+     * @api private
+     */
+    write(data, options) {
+        debug('writing "%s"', data);
+        this.doWrite(data, options, () => {
+            this.req.cleanup();
+        });
+    }
+    /**
+     * Performs the write.
+     *
+     * @api private
+     */
+    doWrite(data, options, callback) {
+        // explicit UTF-8 is required for pages not served under utf
+        const isString = typeof data === "string";
+        const contentType = isString
+            ? "text/plain; charset=UTF-8"
+            : "application/octet-stream";
+        const headers = {
+            "Content-Type": contentType
+        };
+        const respond = data => {
+            headers["Content-Length"] =
+                "string" === typeof data ? Buffer.byteLength(data) : data.length;
+            this.res.writeHead(200, this.headers(this.req, headers));
+            this.res.end(data);
+            callback();
+        };
+        if (!this.httpCompression || !options.compress) {
+            respond(data);
+            return;
+        }
+        const len = isString ? Buffer.byteLength(data) : data.length;
+        if (len < this.httpCompression.threshold) {
+            respond(data);
+            return;
+        }
+        const encoding = accepts(this.req).encodings(["gzip", "deflate"]);
+        if (!encoding) {
+            respond(data);
+            return;
+        }
+        this.compress(data, encoding, (err, data) => {
+            if (err) {
+                this.res.writeHead(500);
+                this.res.end();
+                callback(err);
+                return;
+            }
+            headers["Content-Encoding"] = encoding;
+            respond(data);
+        });
+    }
+    /**
+     * Compresses data.
+     *
+     * @api private
+     */
+    compress(data, encoding, callback) {
+        debug("compressing");
+        const buffers = [];
+        let nread = 0;
+        compressionMethods[encoding](this.httpCompression)
+            .on("error", callback)
+            .on("data", function (chunk) {
+            buffers.push(chunk);
+            nread += chunk.length;
+        })
+            .on("end", function () {
+            callback(null, Buffer.concat(buffers, nread));
+        })
+            .end(data);
+    }
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn) {
+        debug("closing");
+        let closeTimeoutTimer;
+        if (this.dataReq) {
+            debug("aborting ongoing data request");
+            this.dataReq.destroy();
+        }
+        const onClose = () => {
+            clearTimeout(closeTimeoutTimer);
+            fn();
+            this.onClose();
+        };
+        if (this.writable) {
+            debug("transport writable - closing right away");
+            this.send([{ type: "close" }]);
+            onClose();
+        }
+        else if (this.discarded) {
+            debug("transport discarded - closing right away");
+            onClose();
+        }
+        else {
+            debug("transport not writable - buffering orderly close");
+            this.shouldClose = onClose;
+            closeTimeoutTimer = setTimeout(onClose, this.closeTimeout);
+        }
+    }
+    /**
+     * Returns headers for a response.
+     *
+     * @param {http.IncomingMessage} request
+     * @param {Object} extra headers
+     * @api private
+     */
+    headers(req, headers) {
+        headers = headers || {};
+        // prevent XSS warnings on IE
+        // https://github.com/LearnBoost/socket.io/pull/1333
+        const ua = req.headers["user-agent"];
+        if (ua && (~ua.indexOf(";MSIE") || ~ua.indexOf("Trident/"))) {
+            headers["X-XSS-Protection"] = "0";
+        }
+        this.emit("headers", headers, req);
+        return headers;
+    }
+}
+exports.Polling = Polling;
Index: trip-planner-front/node_modules/engine.io/build/transports/websocket.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/websocket.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/websocket.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,43 @@
+import { Transport } from "../transport";
+export declare class WebSocket extends Transport {
+    protected perMessageDeflate: any;
+    private socket;
+    /**
+     * WebSocket transport
+     *
+     * @param {http.IncomingMessage}
+     * @api public
+     */
+    constructor(req: any);
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name(): string;
+    /**
+     * Advertise upgrade support.
+     *
+     * @api public
+     */
+    get handlesUpgrades(): boolean;
+    /**
+     * Advertise framing support.
+     *
+     * @api public
+     */
+    get supportsFraming(): boolean;
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Array} packets
+     * @api private
+     */
+    send(packets: any): void;
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn: any): void;
+}
Index: trip-planner-front/node_modules/engine.io/build/transports/websocket.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/transports/websocket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/transports/websocket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocket = void 0;
+const transport_1 = require("../transport");
+const debug_1 = require("debug");
+const debug = (0, debug_1.default)("engine:ws");
+class WebSocket extends transport_1.Transport {
+    /**
+     * WebSocket transport
+     *
+     * @param {http.IncomingMessage}
+     * @api public
+     */
+    constructor(req) {
+        super(req);
+        this.socket = req.websocket;
+        this.socket.on("message", (data, isBinary) => {
+            const message = isBinary ? data : data.toString();
+            debug('received "%s"', message);
+            super.onData(message);
+        });
+        this.socket.once("close", this.onClose.bind(this));
+        this.socket.on("error", this.onError.bind(this));
+        this.writable = true;
+        this.perMessageDeflate = null;
+    }
+    /**
+     * Transport name
+     *
+     * @api public
+     */
+    get name() {
+        return "websocket";
+    }
+    /**
+     * Advertise upgrade support.
+     *
+     * @api public
+     */
+    get handlesUpgrades() {
+        return true;
+    }
+    /**
+     * Advertise framing support.
+     *
+     * @api public
+     */
+    get supportsFraming() {
+        return true;
+    }
+    /**
+     * Writes a packet payload.
+     *
+     * @param {Array} packets
+     * @api private
+     */
+    send(packets) {
+        const packet = packets.shift();
+        if (typeof packet === "undefined") {
+            this.writable = true;
+            this.emit("drain");
+            return;
+        }
+        // always creates a new object since ws modifies it
+        const opts = {};
+        if (packet.options) {
+            opts.compress = packet.options.compress;
+        }
+        const send = data => {
+            if (this.perMessageDeflate) {
+                const len = "string" === typeof data ? Buffer.byteLength(data) : data.length;
+                if (len < this.perMessageDeflate.threshold) {
+                    opts.compress = false;
+                }
+            }
+            debug('writing "%s"', data);
+            this.writable = false;
+            this.socket.send(data, opts, err => {
+                if (err)
+                    return this.onError("write error", err.stack);
+                this.send(packets);
+            });
+        };
+        if (packet.options && typeof packet.options.wsPreEncoded === "string") {
+            send(packet.options.wsPreEncoded);
+        }
+        else {
+            this.parser.encodePacket(packet, this.supportsBinary, send);
+        }
+    }
+    /**
+     * Closes the transport.
+     *
+     * @api private
+     */
+    doClose(fn) {
+        debug("closing");
+        this.socket.close();
+        fn && fn();
+    }
+}
+exports.WebSocket = WebSocket;
Index: trip-planner-front/node_modules/engine.io/build/userver.d.ts
===================================================================
--- trip-planner-front/node_modules/engine.io/build/userver.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/userver.d.ts	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,21 @@
+import { AttachOptions, BaseServer } from "./server";
+export declare class uServer extends BaseServer {
+    protected init(): void;
+    protected cleanup(): void;
+    /**
+     * Prepares a request by processing the query string.
+     *
+     * @api private
+     */
+    private prepare;
+    protected createTransport(transportName: any, req: any): any;
+    /**
+     * Attach the engine to a µWebSockets.js server
+     * @param app
+     * @param options
+     */
+    attach(app: any, options?: AttachOptions): void;
+    private handleRequest;
+    private handleUpgrade;
+    private abortRequest;
+}
Index: trip-planner-front/node_modules/engine.io/build/userver.js
===================================================================
--- trip-planner-front/node_modules/engine.io/build/userver.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/build/userver.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uServer = void 0;
+const debug_1 = require("debug");
+const server_1 = require("./server");
+const transports_uws_1 = require("./transports-uws");
+const debug = (0, debug_1.default)("engine:uws");
+class uServer extends server_1.BaseServer {
+    init() { }
+    cleanup() { }
+    /**
+     * Prepares a request by processing the query string.
+     *
+     * @api private
+     */
+    prepare(req, res) {
+        req.method = req.getMethod().toUpperCase();
+        const params = new URLSearchParams(req.getQuery());
+        req._query = Object.fromEntries(params.entries());
+        req.headers = {};
+        req.forEach((key, value) => {
+            req.headers[key] = value;
+        });
+        req.connection = {
+            remoteAddress: Buffer.from(res.getRemoteAddressAsText()).toString()
+        };
+    }
+    createTransport(transportName, req) {
+        return new transports_uws_1.default[transportName](req);
+    }
+    /**
+     * Attach the engine to a µWebSockets.js server
+     * @param app
+     * @param options
+     */
+    attach(app /* : TemplatedApp */, options = {}) {
+        const path = (options.path || "/engine.io").replace(/\/$/, "") + "/";
+        app
+            .any(path, this.handleRequest.bind(this))
+            //
+            .ws(path, {
+            maxPayloadLength: this.opts.maxHttpBufferSize,
+            upgrade: this.handleUpgrade.bind(this),
+            open: ws => {
+                ws.transport.socket = ws;
+                ws.transport.writable = true;
+                ws.transport.emit("drain");
+            },
+            message: (ws, message, isBinary) => {
+                ws.transport.onData(isBinary ? message : Buffer.from(message).toString());
+            },
+            close: (ws, code, message) => {
+                ws.transport.onClose(code, message);
+            }
+        });
+    }
+    handleRequest(res, req) {
+        debug('handling "%s" http request "%s"', req.getMethod(), req.getUrl());
+        this.prepare(req, res);
+        req.res = res;
+        const callback = (errorCode, errorContext) => {
+            if (errorCode !== undefined) {
+                this.emit("connection_error", {
+                    req,
+                    code: errorCode,
+                    message: server_1.Server.errorMessages[errorCode],
+                    context: errorContext
+                });
+                this.abortRequest(req.res, errorCode, errorContext);
+                return;
+            }
+            if (req._query.sid) {
+                debug("setting new request for existing client");
+                this.clients[req._query.sid].transport.onRequest(req);
+            }
+            else {
+                const closeConnection = (errorCode, errorContext) => this.abortRequest(res, errorCode, errorContext);
+                this.handshake(req._query.transport, req, closeConnection);
+            }
+        };
+        if (this.corsMiddleware) {
+            // needed to buffer headers until the status is computed
+            req.res = new ResponseWrapper(res);
+            this.corsMiddleware.call(null, req, req.res, () => {
+                this.verify(req, false, callback);
+            });
+        }
+        else {
+            this.verify(req, false, callback);
+        }
+    }
+    handleUpgrade(res, req, context) {
+        debug("on upgrade");
+        this.prepare(req, res);
+        // @ts-ignore
+        req.res = res;
+        this.verify(req, true, async (errorCode, errorContext) => {
+            if (errorCode) {
+                this.emit("connection_error", {
+                    req,
+                    code: errorCode,
+                    message: server_1.Server.errorMessages[errorCode],
+                    context: errorContext
+                });
+                this.abortRequest(res, errorCode, errorContext);
+                return;
+            }
+            const id = req._query.sid;
+            let transport;
+            if (id) {
+                const client = this.clients[id];
+                if (!client) {
+                    debug("upgrade attempt for closed client");
+                    res.close();
+                }
+                else if (client.upgrading) {
+                    debug("transport has already been trying to upgrade");
+                    res.close();
+                }
+                else if (client.upgraded) {
+                    debug("transport had already been upgraded");
+                    res.close();
+                }
+                else {
+                    debug("upgrading existing transport");
+                    transport = this.createTransport(req._query.transport, req);
+                    client.maybeUpgrade(transport);
+                }
+            }
+            else {
+                transport = await this.handshake(req._query.transport, req, (errorCode, errorContext) => this.abortRequest(res, errorCode, errorContext));
+                if (!transport) {
+                    return;
+                }
+            }
+            res.upgrade({
+                transport
+            }, req.getHeader("sec-websocket-key"), req.getHeader("sec-websocket-protocol"), req.getHeader("sec-websocket-extensions"), context);
+        });
+    }
+    abortRequest(res, errorCode, errorContext) {
+        const statusCode = errorCode === server_1.Server.errors.FORBIDDEN
+            ? "403 Forbidden"
+            : "400 Bad Request";
+        const message = errorContext && errorContext.message
+            ? errorContext.message
+            : server_1.Server.errorMessages[errorCode];
+        res.writeStatus(statusCode);
+        res.writeHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+            code: errorCode,
+            message
+        }));
+    }
+}
+exports.uServer = uServer;
+class ResponseWrapper {
+    constructor(res) {
+        this.res = res;
+        this.statusWritten = false;
+        this.headers = [];
+    }
+    set statusCode(status) {
+        this.writeStatus(status === 200 ? "200 OK" : "204 No Content");
+    }
+    setHeader(key, value) {
+        this.writeHeader(key, value);
+    }
+    // needed by vary: https://github.com/jshttp/vary/blob/5d725d059b3871025cf753e9dfa08924d0bcfa8f/index.js#L134
+    getHeader() { }
+    writeStatus(status) {
+        this.res.writeStatus(status);
+        this.statusWritten = true;
+        this.writeBufferedHeaders();
+    }
+    writeHeader(key, value) {
+        if (key === "Content-Length") {
+            // the content length is automatically added by uWebSockets.js
+            return;
+        }
+        if (this.statusWritten) {
+            this.res.writeHeader(key, value);
+        }
+        else {
+            this.headers.push([key, value]);
+        }
+    }
+    writeBufferedHeaders() {
+        this.headers.forEach(([key, value]) => {
+            this.res.writeHeader(key, value);
+        });
+    }
+    end(data) {
+        if (!this.statusWritten) {
+            // status will be inferred as "200 OK"
+            this.writeBufferedHeaders();
+        }
+        this.res.end(data);
+    }
+    onAborted(fn) {
+        this.res.onAborted(fn);
+    }
+}
Index: trip-planner-front/node_modules/engine.io/lib/engine.io.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/engine.io.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,127 +1,0 @@
-/**
- * Module dependencies.
- */
-
-const http = require("http");
-const Server = require("./server");
-
-/**
- * Invoking the library as a function delegates to attach if the first argument
- * is an `http.Server`.
- *
- * If there are no arguments or the first argument is an options object, then
- * a new Server instance is returned.
- *
- * @param {http.Server} server (if specified, will be attached to by the new Server instance)
- * @param {Object} options
- * @return {Server} engine server
- * @api public
- */
-
-exports = module.exports = function() {
-  // backwards compatible use as `.attach`
-  // if first argument is an http server
-  if (arguments.length && arguments[0] instanceof http.Server) {
-    return attach.apply(this, arguments);
-  }
-
-  // if first argument is not an http server, then just make a regular eio server
-  return new Server(...arguments);
-};
-
-/**
- * Protocol revision number.
- *
- * @api public
- */
-
-exports.protocol = 1;
-
-/**
- * Expose Server constructor.
- *
- * @api public
- */
-
-exports.Server = Server;
-
-/**
- * Expose Socket constructor.
- *
- * @api public
- */
-
-exports.Socket = require("./socket");
-
-/**
- * Expose Transport constructor.
- *
- * @api public
- */
-
-exports.Transport = require("./transport");
-
-/**
- * Expose mutable list of available transports.
- *
- * @api public
- */
-
-exports.transports = require("./transports");
-
-/**
- * Exports parser.
- *
- * @api public
- */
-
-exports.parser = require("engine.io-parser");
-
-/**
- * Creates an http.Server exclusively used for WS upgrades.
- *
- * @param {Number} port
- * @param {Function} callback
- * @param {Object} options
- * @return {Server} websocket.io server
- * @api public
- */
-
-exports.listen = listen;
-
-function listen(port, options, fn) {
-  if ("function" === typeof options) {
-    fn = options;
-    options = {};
-  }
-
-  const server = http.createServer(function(req, res) {
-    res.writeHead(501);
-    res.end("Not Implemented");
-  });
-
-  // create engine server
-  const engine = exports.attach(server, options);
-  engine.httpServer = server;
-
-  server.listen(port, fn);
-
-  return engine;
-}
-
-/**
- * Captures upgrade requests for a http.Server.
- *
- * @param {http.Server} server
- * @param {Object} options
- * @return {Server} engine server
- * @api public
- */
-
-exports.attach = attach;
-
-function attach(server, options) {
-  const engine = new Server(options);
-  engine.attach(server, options);
-  return engine;
-}
Index: trip-planner-front/node_modules/engine.io/lib/parser-v3/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/parser-v3/index.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,483 +1,0 @@
-// imported from https://github.com/socketio/engine.io-parser/tree/2.2.x
-
-/**
- * Module dependencies.
- */
-
-var utf8 = require('./utf8');
-
-/**
- * Current protocol version.
- */
-exports.protocol = 3;
-
-const hasBinary = (packets) => {
-  for (const packet of packets) {
-    if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Packet types.
- */
-
-var packets = exports.packets = {
-    open:     0    // non-ws
-  , close:    1    // non-ws
-  , ping:     2
-  , pong:     3
-  , message:  4
-  , upgrade:  5
-  , noop:     6
-};
-
-var packetslist = Object.keys(packets);
-
-/**
- * Premade error packet.
- */
-
-var err = { type: 'error', data: 'parser error' };
-
-const EMPTY_BUFFER = Buffer.concat([]);
-
-/**
- * Encodes a packet.
- *
- *     <packet type id> [ <data> ]
- *
- * Example:
- *
- *     5hello world
- *     3
- *     4
- *
- * Binary is encoded in an identical principle
- *
- * @api private
- */
-
-exports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {
-  if (typeof supportsBinary === 'function') {
-    callback = supportsBinary;
-    supportsBinary = null;
-  }
-
-  if (typeof utf8encode === 'function') {
-    callback = utf8encode;
-    utf8encode = null;
-  }
-
-  if (Buffer.isBuffer(packet.data)) {
-    return encodeBuffer(packet, supportsBinary, callback);
-  } else if (packet.data && (packet.data.buffer || packet.data) instanceof ArrayBuffer) {
-    return encodeBuffer({ type: packet.type, data: arrayBufferToBuffer(packet.data) }, supportsBinary, callback);
-  }
-
-  // Sending data as a utf-8 string
-  var encoded = packets[packet.type];
-
-  // data fragment is optional
-  if (undefined !== packet.data) {
-    encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);
-  }
-
-  return callback('' + encoded);
-};
-
-/**
- * Encode Buffer data
- */
-
-function encodeBuffer(packet, supportsBinary, callback) {
-  if (!supportsBinary) {
-    return exports.encodeBase64Packet(packet, callback);
-  }
-
-  var data = packet.data;
-  var typeBuffer = Buffer.allocUnsafe(1);
-  typeBuffer[0] = packets[packet.type];
-  return callback(Buffer.concat([typeBuffer, data]));
-}
-
-/**
- * Encodes a packet with binary data in a base64 string
- *
- * @param {Object} packet, has `type` and `data`
- * @return {String} base64 encoded message
- */
-
-exports.encodeBase64Packet = function(packet, callback){
-  var data = Buffer.isBuffer(packet.data) ? packet.data : arrayBufferToBuffer(packet.data);
-  var message = 'b' + packets[packet.type];
-  message += data.toString('base64');
-  return callback(message);
-};
-
-/**
- * Decodes a packet. Data also available as an ArrayBuffer if requested.
- *
- * @return {Object} with `type` and `data` (if any)
- * @api private
- */
-
-exports.decodePacket = function (data, binaryType, utf8decode) {
-  if (data === undefined) {
-    return err;
-  }
-
-  var type;
-
-  // String data
-  if (typeof data === 'string') {
-
-    type = data.charAt(0);
-
-    if (type === 'b') {
-      return exports.decodeBase64Packet(data.substr(1), binaryType);
-    }
-
-    if (utf8decode) {
-      data = tryDecode(data);
-      if (data === false) {
-        return err;
-      }
-    }
-
-    if (Number(type) != type || !packetslist[type]) {
-      return err;
-    }
-
-    if (data.length > 1) {
-      return { type: packetslist[type], data: data.substring(1) };
-    } else {
-      return { type: packetslist[type] };
-    }
-  }
-
-  // Binary data
-  if (binaryType === 'arraybuffer') {
-    // wrap Buffer/ArrayBuffer data into an Uint8Array
-    var intArray = new Uint8Array(data);
-    type = intArray[0];
-    return { type: packetslist[type], data: intArray.buffer.slice(1) };
-  }
-
-  if (data instanceof ArrayBuffer) {
-    data = arrayBufferToBuffer(data);
-  }
-  type = data[0];
-  return { type: packetslist[type], data: data.slice(1) };
-};
-
-function tryDecode(data) {
-  try {
-    data = utf8.decode(data, { strict: false });
-  } catch (e) {
-    return false;
-  }
-  return data;
-}
-
-/**
- * Decodes a packet encoded in a base64 string.
- *
- * @param {String} base64 encoded message
- * @return {Object} with `type` and `data` (if any)
- */
-
-exports.decodeBase64Packet = function(msg, binaryType) {
-  var type = packetslist[msg.charAt(0)];
-  var data = Buffer.from(msg.substr(1), 'base64');
-  if (binaryType === 'arraybuffer') {
-    var abv = new Uint8Array(data.length);
-    for (var i = 0; i < abv.length; i++){
-      abv[i] = data[i];
-    }
-    data = abv.buffer;
-  }
-  return { type: type, data: data };
-};
-
-/**
- * Encodes multiple messages (payload).
- *
- *     <length>:data
- *
- * Example:
- *
- *     11:hello world2:hi
- *
- * If any contents are binary, they will be encoded as base64 strings. Base64
- * encoded strings are marked with a b before the length specifier
- *
- * @param {Array} packets
- * @api private
- */
-
-exports.encodePayload = function (packets, supportsBinary, callback) {
-  if (typeof supportsBinary === 'function') {
-    callback = supportsBinary;
-    supportsBinary = null;
-  }
-
-  if (supportsBinary && hasBinary(packets)) {
-    return exports.encodePayloadAsBinary(packets, callback);
-  }
-
-  if (!packets.length) {
-    return callback('0:');
-  }
-
-  function encodeOne(packet, doneCallback) {
-    exports.encodePacket(packet, supportsBinary, false, function(message) {
-      doneCallback(null, setLengthHeader(message));
-    });
-  }
-
-  map(packets, encodeOne, function(err, results) {
-    return callback(results.join(''));
-  });
-};
-
-function setLengthHeader(message) {
-  return message.length + ':' + message;
-}
-
-/**
- * Async array map using after
- */
-
-function map(ary, each, done) {
-  const results = new Array(ary.length);
-  let count = 0;
-
-  for (let i = 0; i < ary.length; i++) {
-    each(ary[i], (error, msg) => {
-      results[i] = msg;
-      if (++count === ary.length) {
-        done(null, results);
-      }
-    });
-  }
-}
-
-/*
- * Decodes data when a payload is maybe expected. Possible binary contents are
- * decoded from their base64 representation
- *
- * @param {String} data, callback method
- * @api public
- */
-
-exports.decodePayload = function (data, binaryType, callback) {
-  if (typeof data !== 'string') {
-    return exports.decodePayloadAsBinary(data, binaryType, callback);
-  }
-
-  if (typeof binaryType === 'function') {
-    callback = binaryType;
-    binaryType = null;
-  }
-
-  if (data === '') {
-    // parser error - ignoring payload
-    return callback(err, 0, 1);
-  }
-
-  var length = '', n, msg, packet;
-
-  for (var i = 0, l = data.length; i < l; i++) {
-    var chr = data.charAt(i);
-
-    if (chr !== ':') {
-      length += chr;
-      continue;
-    }
-
-    if (length === '' || (length != (n = Number(length)))) {
-      // parser error - ignoring payload
-      return callback(err, 0, 1);
-    }
-
-    msg = data.substr(i + 1, n);
-
-    if (length != msg.length) {
-      // parser error - ignoring payload
-      return callback(err, 0, 1);
-    }
-
-    if (msg.length) {
-      packet = exports.decodePacket(msg, binaryType, false);
-
-      if (err.type === packet.type && err.data === packet.data) {
-        // parser error in individual packet - ignoring payload
-        return callback(err, 0, 1);
-      }
-
-      var more = callback(packet, i + n, l);
-      if (false === more) return;
-    }
-
-    // advance cursor
-    i += n;
-    length = '';
-  }
-
-  if (length !== '') {
-    // parser error - ignoring payload
-    return callback(err, 0, 1);
-  }
-
-};
-
-/**
- *
- * Converts a buffer to a utf8.js encoded string
- *
- * @api private
- */
-
-function bufferToString(buffer) {
-  var str = '';
-  for (var i = 0, l = buffer.length; i < l; i++) {
-    str += String.fromCharCode(buffer[i]);
-  }
-  return str;
-}
-
-/**
- *
- * Converts a utf8.js encoded string to a buffer
- *
- * @api private
- */
-
-function stringToBuffer(string) {
-  var buf = Buffer.allocUnsafe(string.length);
-  for (var i = 0, l = string.length; i < l; i++) {
-    buf.writeUInt8(string.charCodeAt(i), i);
-  }
-  return buf;
-}
-
-/**
- *
- * Converts an ArrayBuffer to a Buffer
- *
- * @api private
- */
-
-function arrayBufferToBuffer(data) {
-  // data is either an ArrayBuffer or ArrayBufferView.
-  var length = data.byteLength || data.length;
-  var offset = data.byteOffset || 0;
-
-  return Buffer.from(data.buffer || data, offset, length);
-}
-
-/**
- * Encodes multiple messages (payload) as binary.
- *
- * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
- * 255><data>
- *
- * Example:
- * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
- *
- * @param {Array} packets
- * @return {Buffer} encoded payload
- * @api private
- */
-
-exports.encodePayloadAsBinary = function (packets, callback) {
-  if (!packets.length) {
-    return callback(EMPTY_BUFFER);
-  }
-
-  map(packets, encodeOneBinaryPacket, function(err, results) {
-    return callback(Buffer.concat(results));
-  });
-};
-
-function encodeOneBinaryPacket(p, doneCallback) {
-
-  function onBinaryPacketEncode(packet) {
-
-    var encodingLength = '' + packet.length;
-    var sizeBuffer;
-
-    if (typeof packet === 'string') {
-      sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
-      sizeBuffer[0] = 0; // is a string (not true binary = 0)
-      for (var i = 0; i < encodingLength.length; i++) {
-        sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
-      }
-      sizeBuffer[sizeBuffer.length - 1] = 255;
-      return doneCallback(null, Buffer.concat([sizeBuffer, stringToBuffer(packet)]));
-    }
-
-    sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
-    sizeBuffer[0] = 1; // is binary (true binary = 1)
-    for (var i = 0; i < encodingLength.length; i++) {
-      sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
-    }
-    sizeBuffer[sizeBuffer.length - 1] = 255;
-
-    doneCallback(null, Buffer.concat([sizeBuffer, packet]));
-  }
-
-  exports.encodePacket(p, true, true, onBinaryPacketEncode);
-
-}
-
-
-/*
- * Decodes data when a payload is maybe expected. Strings are decoded by
- * interpreting each byte as a key code for entries marked to start with 0. See
- * description of encodePayloadAsBinary
-
- * @param {Buffer} data, callback method
- * @api public
- */
-
-exports.decodePayloadAsBinary = function (data, binaryType, callback) {
-  if (typeof binaryType === 'function') {
-    callback = binaryType;
-    binaryType = null;
-  }
-
-  var bufferTail = data;
-  var buffers = [];
-  var i;
-
-  while (bufferTail.length > 0) {
-    var strLen = '';
-    var isString = bufferTail[0] === 0;
-    for (i = 1; ; i++) {
-      if (bufferTail[i] === 255)  break;
-      // 310 = char length of Number.MAX_VALUE
-      if (strLen.length > 310) {
-        return callback(err, 0, 1);
-      }
-      strLen += '' + bufferTail[i];
-    }
-    bufferTail = bufferTail.slice(strLen.length + 1);
-
-    var msgLength = parseInt(strLen, 10);
-
-    var msg = bufferTail.slice(1, msgLength + 1);
-    if (isString) msg = bufferToString(msg);
-    buffers.push(msg);
-    bufferTail = bufferTail.slice(msgLength + 1);
-  }
-
-  var total = buffers.length;
-  for (i = 0; i < total; i++) {
-    var buffer = buffers[i];
-    callback(exports.decodePacket(buffer, binaryType, true), i, total);
-  }
-};
Index: trip-planner-front/node_modules/engine.io/lib/parser-v3/utf8.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/parser-v3/utf8.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,210 +1,0 @@
-/*! https://mths.be/utf8js v2.1.2 by @mathias */
-
-var stringFromCharCode = String.fromCharCode;
-
-// Taken from https://mths.be/punycode
-function ucs2decode(string) {
-	var output = [];
-	var counter = 0;
-	var length = string.length;
-	var value;
-	var extra;
-	while (counter < length) {
-		value = string.charCodeAt(counter++);
-		if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-			// high surrogate, and there is a next character
-			extra = string.charCodeAt(counter++);
-			if ((extra & 0xFC00) == 0xDC00) { // low surrogate
-				output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-			} else {
-				// unmatched surrogate; only append this code unit, in case the next
-				// code unit is the high surrogate of a surrogate pair
-				output.push(value);
-				counter--;
-			}
-		} else {
-			output.push(value);
-		}
-	}
-	return output;
-}
-
-// Taken from https://mths.be/punycode
-function ucs2encode(array) {
-	var length = array.length;
-	var index = -1;
-	var value;
-	var output = '';
-	while (++index < length) {
-		value = array[index];
-		if (value > 0xFFFF) {
-			value -= 0x10000;
-			output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
-			value = 0xDC00 | value & 0x3FF;
-		}
-		output += stringFromCharCode(value);
-	}
-	return output;
-}
-
-function checkScalarValue(codePoint, strict) {
-	if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
-		if (strict) {
-			throw Error(
-				'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
-				' is not a scalar value'
-			);
-		}
-		return false;
-	}
-	return true;
-}
-/*--------------------------------------------------------------------------*/
-
-function createByte(codePoint, shift) {
-	return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
-}
-
-function encodeCodePoint(codePoint, strict) {
-	if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
-		return stringFromCharCode(codePoint);
-	}
-	var symbol = '';
-	if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
-		symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
-	}
-	else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
-		if (!checkScalarValue(codePoint, strict)) {
-			codePoint = 0xFFFD;
-		}
-		symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
-		symbol += createByte(codePoint, 6);
-	}
-	else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
-		symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
-		symbol += createByte(codePoint, 12);
-		symbol += createByte(codePoint, 6);
-	}
-	symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
-	return symbol;
-}
-
-function utf8encode(string, opts) {
-	opts = opts || {};
-	var strict = false !== opts.strict;
-
-	var codePoints = ucs2decode(string);
-	var length = codePoints.length;
-	var index = -1;
-	var codePoint;
-	var byteString = '';
-	while (++index < length) {
-		codePoint = codePoints[index];
-		byteString += encodeCodePoint(codePoint, strict);
-	}
-	return byteString;
-}
-
-/*--------------------------------------------------------------------------*/
-
-function readContinuationByte() {
-	if (byteIndex >= byteCount) {
-		throw Error('Invalid byte index');
-	}
-
-	var continuationByte = byteArray[byteIndex] & 0xFF;
-	byteIndex++;
-
-	if ((continuationByte & 0xC0) == 0x80) {
-		return continuationByte & 0x3F;
-	}
-
-	// If we end up here, it’s not a continuation byte
-	throw Error('Invalid continuation byte');
-}
-
-function decodeSymbol(strict) {
-	var byte1;
-	var byte2;
-	var byte3;
-	var byte4;
-	var codePoint;
-
-	if (byteIndex > byteCount) {
-		throw Error('Invalid byte index');
-	}
-
-	if (byteIndex == byteCount) {
-		return false;
-	}
-
-	// Read first byte
-	byte1 = byteArray[byteIndex] & 0xFF;
-	byteIndex++;
-
-	// 1-byte sequence (no continuation bytes)
-	if ((byte1 & 0x80) == 0) {
-		return byte1;
-	}
-
-	// 2-byte sequence
-	if ((byte1 & 0xE0) == 0xC0) {
-		byte2 = readContinuationByte();
-		codePoint = ((byte1 & 0x1F) << 6) | byte2;
-		if (codePoint >= 0x80) {
-			return codePoint;
-		} else {
-			throw Error('Invalid continuation byte');
-		}
-	}
-
-	// 3-byte sequence (may include unpaired surrogates)
-	if ((byte1 & 0xF0) == 0xE0) {
-		byte2 = readContinuationByte();
-		byte3 = readContinuationByte();
-		codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
-		if (codePoint >= 0x0800) {
-			return checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;
-		} else {
-			throw Error('Invalid continuation byte');
-		}
-	}
-
-	// 4-byte sequence
-	if ((byte1 & 0xF8) == 0xF0) {
-		byte2 = readContinuationByte();
-		byte3 = readContinuationByte();
-		byte4 = readContinuationByte();
-		codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
-			(byte3 << 0x06) | byte4;
-		if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
-			return codePoint;
-		}
-	}
-
-	throw Error('Invalid UTF-8 detected');
-}
-
-var byteArray;
-var byteCount;
-var byteIndex;
-function utf8decode(byteString, opts) {
-	opts = opts || {};
-	var strict = false !== opts.strict;
-
-	byteArray = ucs2decode(byteString);
-	byteCount = byteArray.length;
-	byteIndex = 0;
-	var codePoints = [];
-	var tmp;
-	while ((tmp = decodeSymbol(strict)) !== false) {
-		codePoints.push(tmp);
-	}
-	return ucs2encode(codePoints);
-}
-
-module.exports = {
-	version: '2.1.2',
-	encode: utf8encode,
-	decode: utf8decode
-};
Index: trip-planner-front/node_modules/engine.io/lib/server.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/server.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,599 +1,0 @@
-const qs = require("querystring");
-const parse = require("url").parse;
-const base64id = require("base64id");
-const transports = require("./transports");
-const EventEmitter = require("events").EventEmitter;
-const Socket = require("./socket");
-const debug = require("debug")("engine");
-const cookieMod = require("cookie");
-
-class Server extends EventEmitter {
-  /**
-   * Server constructor.
-   *
-   * @param {Object} options
-   * @api public
-   */
-  constructor(opts = {}) {
-    super();
-
-    this.clients = {};
-    this.clientsCount = 0;
-
-    this.opts = Object.assign(
-      {
-        wsEngine: process.env.EIO_WS_ENGINE || "ws",
-        pingTimeout: 5000,
-        pingInterval: 25000,
-        upgradeTimeout: 10000,
-        maxHttpBufferSize: 1e6,
-        transports: Object.keys(transports),
-        allowUpgrades: true,
-        httpCompression: {
-          threshold: 1024
-        },
-        cors: false,
-        allowEIO3: false
-      },
-      opts
-    );
-
-    if (opts.cookie) {
-      this.opts.cookie = Object.assign(
-        {
-          name: "io",
-          path: "/",
-          httpOnly: opts.cookie.path !== false,
-          sameSite: "lax"
-        },
-        opts.cookie
-      );
-    }
-
-    if (this.opts.cors) {
-      this.corsMiddleware = require("cors")(this.opts.cors);
-    }
-
-    if (opts.perMessageDeflate) {
-      this.opts.perMessageDeflate = Object.assign(
-        {
-          threshold: 1024
-        },
-        opts.perMessageDeflate
-      );
-    }
-
-    this.init();
-  }
-
-  /**
-   * Initialize websocket server
-   *
-   * @api private
-   */
-  init() {
-    if (!~this.opts.transports.indexOf("websocket")) return;
-
-    if (this.ws) this.ws.close();
-
-    // add explicit require for bundlers like webpack
-    const wsModule =
-      this.opts.wsEngine === "ws" ? require("ws") : require(this.opts.wsEngine);
-    this.ws = new wsModule.Server({
-      noServer: true,
-      clientTracking: false,
-      perMessageDeflate: this.opts.perMessageDeflate,
-      maxPayload: this.opts.maxHttpBufferSize
-    });
-  }
-
-  /**
-   * Returns a list of available transports for upgrade given a certain transport.
-   *
-   * @return {Array}
-   * @api public
-   */
-  upgrades(transport) {
-    if (!this.opts.allowUpgrades) return [];
-    return transports[transport].upgradesTo || [];
-  }
-
-  /**
-   * Verifies a request.
-   *
-   * @param {http.IncomingMessage}
-   * @return {Boolean} whether the request is valid
-   * @api private
-   */
-  verify(req, upgrade, fn) {
-    // transport check
-    const transport = req._query.transport;
-    if (!~this.opts.transports.indexOf(transport)) {
-      debug('unknown transport "%s"', transport);
-      return fn(Server.errors.UNKNOWN_TRANSPORT, false);
-    }
-
-    // 'Origin' header check
-    const isOriginInvalid = checkInvalidHeaderChar(req.headers.origin);
-    if (isOriginInvalid) {
-      req.headers.origin = null;
-      debug("origin header invalid");
-      return fn(Server.errors.BAD_REQUEST, false);
-    }
-
-    // sid check
-    const sid = req._query.sid;
-    if (sid) {
-      if (!this.clients.hasOwnProperty(sid)) {
-        debug('unknown sid "%s"', sid);
-        return fn(Server.errors.UNKNOWN_SID, false);
-      }
-      if (!upgrade && this.clients[sid].transport.name !== transport) {
-        debug("bad request: unexpected transport without upgrade");
-        return fn(Server.errors.BAD_REQUEST, false);
-      }
-    } else {
-      // handshake is GET only
-      if ("GET" !== req.method)
-        return fn(Server.errors.BAD_HANDSHAKE_METHOD, false);
-      if (!this.opts.allowRequest) return fn(null, true);
-      return this.opts.allowRequest(req, fn);
-    }
-
-    fn(null, true);
-  }
-
-  /**
-   * Prepares a request by processing the query string.
-   *
-   * @api private
-   */
-  prepare(req) {
-    // try to leverage pre-existing `req._query` (e.g: from connect)
-    if (!req._query) {
-      req._query = ~req.url.indexOf("?") ? qs.parse(parse(req.url).query) : {};
-    }
-  }
-
-  /**
-   * Closes all clients.
-   *
-   * @api public
-   */
-  close() {
-    debug("closing all open clients");
-    for (let i in this.clients) {
-      if (this.clients.hasOwnProperty(i)) {
-        this.clients[i].close(true);
-      }
-    }
-    if (this.ws) {
-      debug("closing webSocketServer");
-      this.ws.close();
-      // don't delete this.ws because it can be used again if the http server starts listening again
-    }
-    return this;
-  }
-
-  /**
-   * Handles an Engine.IO HTTP request.
-   *
-   * @param {http.IncomingMessage} request
-   * @param {http.ServerResponse|http.OutgoingMessage} response
-   * @api public
-   */
-  handleRequest(req, res) {
-    debug('handling "%s" http request "%s"', req.method, req.url);
-    this.prepare(req);
-    req.res = res;
-
-    const callback = (err, success) => {
-      if (!success) {
-        sendErrorMessage(req, res, err);
-        return;
-      }
-
-      if (req._query.sid) {
-        debug("setting new request for existing client");
-        this.clients[req._query.sid].transport.onRequest(req);
-      } else {
-        this.handshake(req._query.transport, req);
-      }
-    };
-
-    if (this.corsMiddleware) {
-      this.corsMiddleware.call(null, req, res, () => {
-        this.verify(req, false, callback);
-      });
-    } else {
-      this.verify(req, false, callback);
-    }
-  }
-
-  /**
-   * generate a socket id.
-   * Overwrite this method to generate your custom socket id
-   *
-   * @param {Object} request object
-   * @api public
-   */
-  generateId(req) {
-    return base64id.generateId();
-  }
-
-  /**
-   * Handshakes a new client.
-   *
-   * @param {String} transport name
-   * @param {Object} request object
-   * @api private
-   */
-  async handshake(transportName, req) {
-    const protocol = req._query.EIO === "3" ? 3 : 4; // 4th revision by default
-    if (protocol === 3 && !this.opts.allowEIO3) {
-      debug("unsupported protocol version");
-      sendErrorMessage(
-        req,
-        req.res,
-        Server.errors.UNSUPPORTED_PROTOCOL_VERSION
-      );
-      return;
-    }
-
-    let id;
-    try {
-      id = await this.generateId(req);
-    } catch (e) {
-      debug("error while generating an id");
-      sendErrorMessage(req, req.res, Server.errors.BAD_REQUEST);
-      return;
-    }
-
-    debug('handshaking client "%s"', id);
-
-    try {
-      var transport = new transports[transportName](req);
-      if ("polling" === transportName) {
-        transport.maxHttpBufferSize = this.opts.maxHttpBufferSize;
-        transport.httpCompression = this.opts.httpCompression;
-      } else if ("websocket" === transportName) {
-        transport.perMessageDeflate = this.opts.perMessageDeflate;
-      }
-
-      if (req._query && req._query.b64) {
-        transport.supportsBinary = false;
-      } else {
-        transport.supportsBinary = true;
-      }
-    } catch (e) {
-      debug('error handshaking to transport "%s"', transportName);
-      sendErrorMessage(req, req.res, Server.errors.BAD_REQUEST);
-      return;
-    }
-    const socket = new Socket(id, this, transport, req, protocol);
-    const self = this;
-
-    if (this.opts.cookie) {
-      transport.on("headers", headers => {
-        headers["Set-Cookie"] = cookieMod.serialize(
-          this.opts.cookie.name,
-          id,
-          this.opts.cookie
-        );
-      });
-    }
-
-    transport.onRequest(req);
-
-    this.clients[id] = socket;
-    this.clientsCount++;
-
-    socket.once("close", function() {
-      delete self.clients[id];
-      self.clientsCount--;
-    });
-
-    this.emit("connection", socket);
-  }
-
-  /**
-   * Handles an Engine.IO HTTP Upgrade.
-   *
-   * @api public
-   */
-  handleUpgrade(req, socket, upgradeHead) {
-    this.prepare(req);
-
-    const self = this;
-    this.verify(req, true, function(err, success) {
-      if (!success) {
-        abortConnection(socket, err);
-        return;
-      }
-
-      const head = Buffer.from(upgradeHead); // eslint-disable-line node/no-deprecated-api
-      upgradeHead = null;
-
-      // delegate to ws
-      self.ws.handleUpgrade(req, socket, head, function(conn) {
-        self.onWebSocket(req, conn);
-      });
-    });
-  }
-
-  /**
-   * Called upon a ws.io connection.
-   *
-   * @param {ws.Socket} websocket
-   * @api private
-   */
-  onWebSocket(req, socket) {
-    socket.on("error", onUpgradeError);
-
-    if (
-      transports[req._query.transport] !== undefined &&
-      !transports[req._query.transport].prototype.handlesUpgrades
-    ) {
-      debug("transport doesnt handle upgraded requests");
-      socket.close();
-      return;
-    }
-
-    // get client id
-    const id = req._query.sid;
-
-    // keep a reference to the ws.Socket
-    req.websocket = socket;
-
-    if (id) {
-      const client = this.clients[id];
-      if (!client) {
-        debug("upgrade attempt for closed client");
-        socket.close();
-      } else if (client.upgrading) {
-        debug("transport has already been trying to upgrade");
-        socket.close();
-      } else if (client.upgraded) {
-        debug("transport had already been upgraded");
-        socket.close();
-      } else {
-        debug("upgrading existing transport");
-
-        // transport error handling takes over
-        socket.removeListener("error", onUpgradeError);
-
-        const transport = new transports[req._query.transport](req);
-        if (req._query && req._query.b64) {
-          transport.supportsBinary = false;
-        } else {
-          transport.supportsBinary = true;
-        }
-        transport.perMessageDeflate = this.perMessageDeflate;
-        client.maybeUpgrade(transport);
-      }
-    } else {
-      // transport error handling takes over
-      socket.removeListener("error", onUpgradeError);
-
-      this.handshake(req._query.transport, req);
-    }
-
-    function onUpgradeError() {
-      debug("websocket error before upgrade");
-      // socket.close() not needed
-    }
-  }
-
-  /**
-   * Captures upgrade requests for a http.Server.
-   *
-   * @param {http.Server} server
-   * @param {Object} options
-   * @api public
-   */
-  attach(server, options) {
-    const self = this;
-    options = options || {};
-    let path = (options.path || "/engine.io").replace(/\/$/, "");
-
-    const destroyUpgradeTimeout = options.destroyUpgradeTimeout || 1000;
-
-    // normalize path
-    path += "/";
-
-    function check(req) {
-      return path === req.url.substr(0, path.length);
-    }
-
-    // cache and clean up listeners
-    const listeners = server.listeners("request").slice(0);
-    server.removeAllListeners("request");
-    server.on("close", self.close.bind(self));
-    server.on("listening", self.init.bind(self));
-
-    // add request handler
-    server.on("request", function(req, res) {
-      if (check(req)) {
-        debug('intercepting request for path "%s"', path);
-        self.handleRequest(req, res);
-      } else {
-        let i = 0;
-        const l = listeners.length;
-        for (; i < l; i++) {
-          listeners[i].call(server, req, res);
-        }
-      }
-    });
-
-    if (~self.opts.transports.indexOf("websocket")) {
-      server.on("upgrade", function(req, socket, head) {
-        if (check(req)) {
-          self.handleUpgrade(req, socket, head);
-        } else if (false !== options.destroyUpgrade) {
-          // default node behavior is to disconnect when no handlers
-          // but by adding a handler, we prevent that
-          // and if no eio thing handles the upgrade
-          // then the socket needs to die!
-          setTimeout(function() {
-            if (socket.writable && socket.bytesWritten <= 0) {
-              return socket.end();
-            }
-          }, destroyUpgradeTimeout);
-        }
-      });
-    }
-  }
-}
-
-/**
- * Protocol errors mappings.
- */
-
-Server.errors = {
-  UNKNOWN_TRANSPORT: 0,
-  UNKNOWN_SID: 1,
-  BAD_HANDSHAKE_METHOD: 2,
-  BAD_REQUEST: 3,
-  FORBIDDEN: 4,
-  UNSUPPORTED_PROTOCOL_VERSION: 5
-};
-
-Server.errorMessages = {
-  0: "Transport unknown",
-  1: "Session ID unknown",
-  2: "Bad handshake method",
-  3: "Bad request",
-  4: "Forbidden",
-  5: "Unsupported protocol version"
-};
-
-/**
- * Sends an Engine.IO Error Message
- *
- * @param {http.ServerResponse} response
- * @param {code} error code
- * @api private
- */
-
-function sendErrorMessage(req, res, code) {
-  const headers = { "Content-Type": "application/json" };
-
-  const isForbidden = !Server.errorMessages.hasOwnProperty(code);
-  if (isForbidden) {
-    res.writeHead(403, headers);
-    res.end(
-      JSON.stringify({
-        code: Server.errors.FORBIDDEN,
-        message: code || Server.errorMessages[Server.errors.FORBIDDEN]
-      })
-    );
-    return;
-  }
-  if (res !== undefined) {
-    res.writeHead(400, headers);
-    res.end(
-      JSON.stringify({
-        code: code,
-        message: Server.errorMessages[code]
-      })
-    );
-  }
-}
-
-/**
- * Closes the connection
- *
- * @param {net.Socket} socket
- * @param {code} error code
- * @api private
- */
-
-function abortConnection(socket, code) {
-  socket.on("error", () => {
-    debug("ignoring error from closed connection");
-  });
-  if (socket.writable) {
-    const message = Server.errorMessages.hasOwnProperty(code)
-      ? Server.errorMessages[code]
-      : String(code || "");
-    const length = Buffer.byteLength(message);
-    socket.write(
-      "HTTP/1.1 400 Bad Request\r\n" +
-        "Connection: close\r\n" +
-        "Content-type: text/html\r\n" +
-        "Content-Length: " +
-        length +
-        "\r\n" +
-        "\r\n" +
-        message
-    );
-  }
-  socket.destroy();
-}
-
-module.exports = Server;
-
-/* eslint-disable */
-
-/**
- * From https://github.com/nodejs/node/blob/v8.4.0/lib/_http_common.js#L303-L354
- *
- * True if val contains an invalid field-vchar
- *  field-value    = *( field-content / obs-fold )
- *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
- *  field-vchar    = VCHAR / obs-text
- *
- * checkInvalidHeaderChar() is currently designed to be inlinable by v8,
- * so take care when making changes to the implementation so that the source
- * code size does not exceed v8's default max_inlined_source_size setting.
- **/
-// prettier-ignore
-const validHdrChars = [
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // 0 - 15
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 - 47
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 - 63
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 - 95
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 - 127
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 ...
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1  // ... 255
-]
-
-function checkInvalidHeaderChar(val) {
-  val += "";
-  if (val.length < 1) return false;
-  if (!validHdrChars[val.charCodeAt(0)]) {
-    debug('invalid header, index 0, char "%s"', val.charCodeAt(0));
-    return true;
-  }
-  if (val.length < 2) return false;
-  if (!validHdrChars[val.charCodeAt(1)]) {
-    debug('invalid header, index 1, char "%s"', val.charCodeAt(1));
-    return true;
-  }
-  if (val.length < 3) return false;
-  if (!validHdrChars[val.charCodeAt(2)]) {
-    debug('invalid header, index 2, char "%s"', val.charCodeAt(2));
-    return true;
-  }
-  if (val.length < 4) return false;
-  if (!validHdrChars[val.charCodeAt(3)]) {
-    debug('invalid header, index 3, char "%s"', val.charCodeAt(3));
-    return true;
-  }
-  for (let i = 4; i < val.length; ++i) {
-    if (!validHdrChars[val.charCodeAt(i)]) {
-      debug('invalid header, index "%i", char "%s"', i, val.charCodeAt(i));
-      return true;
-    }
-  }
-  return false;
-}
Index: trip-planner-front/node_modules/engine.io/lib/socket.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/socket.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,522 +1,0 @@
-const EventEmitter = require("events");
-const debug = require("debug")("engine:socket");
-
-class Socket extends EventEmitter {
-  /**
-   * Client class (abstract).
-   *
-   * @api private
-   */
-  constructor(id, server, transport, req, protocol) {
-    super();
-    this.id = id;
-    this.server = server;
-    this.upgrading = false;
-    this.upgraded = false;
-    this.readyState = "opening";
-    this.writeBuffer = [];
-    this.packetsFn = [];
-    this.sentCallbackFn = [];
-    this.cleanupFn = [];
-    this.request = req;
-    this.protocol = protocol;
-
-    // Cache IP since it might not be in the req later
-    if (req.websocket && req.websocket._socket) {
-      this.remoteAddress = req.websocket._socket.remoteAddress;
-    } else {
-      this.remoteAddress = req.connection.remoteAddress;
-    }
-
-    this.checkIntervalTimer = null;
-    this.upgradeTimeoutTimer = null;
-    this.pingTimeoutTimer = null;
-    this.pingIntervalTimer = null;
-
-    this.setTransport(transport);
-    this.onOpen();
-  }
-
-  /**
-   * Called upon transport considered open.
-   *
-   * @api private
-   */
-  onOpen() {
-    this.readyState = "open";
-
-    // sends an `open` packet
-    this.transport.sid = this.id;
-    this.sendPacket(
-      "open",
-      JSON.stringify({
-        sid: this.id,
-        upgrades: this.getAvailableUpgrades(),
-        pingInterval: this.server.opts.pingInterval,
-        pingTimeout: this.server.opts.pingTimeout
-      })
-    );
-
-    if (this.server.opts.initialPacket) {
-      this.sendPacket("message", this.server.opts.initialPacket);
-    }
-
-    this.emit("open");
-
-    if (this.protocol === 3) {
-      // in protocol v3, the client sends a ping, and the server answers with a pong
-      this.resetPingTimeout(
-        this.server.opts.pingInterval + this.server.opts.pingTimeout
-      );
-    } else {
-      // in protocol v4, the server sends a ping, and the client answers with a pong
-      this.schedulePing();
-    }
-  }
-
-  /**
-   * Called upon transport packet.
-   *
-   * @param {Object} packet
-   * @api private
-   */
-  onPacket(packet) {
-    if ("open" === this.readyState) {
-      // export packet event
-      debug("packet");
-      this.emit("packet", packet);
-
-      // Reset ping timeout on any packet, incoming data is a good sign of
-      // other side's liveness
-      this.resetPingTimeout(
-        this.server.opts.pingInterval + this.server.opts.pingTimeout
-      );
-
-      switch (packet.type) {
-        case "ping":
-          if (this.transport.protocol !== 3) {
-            this.onError("invalid heartbeat direction");
-            return;
-          }
-          debug("got ping");
-          this.sendPacket("pong");
-          this.emit("heartbeat");
-          break;
-
-        case "pong":
-          if (this.transport.protocol === 3) {
-            this.onError("invalid heartbeat direction");
-            return;
-          }
-          debug("got pong");
-          this.schedulePing();
-          this.emit("heartbeat");
-          break;
-
-        case "error":
-          this.onClose("parse error");
-          break;
-
-        case "message":
-          this.emit("data", packet.data);
-          this.emit("message", packet.data);
-          break;
-      }
-    } else {
-      debug("packet received with closed socket");
-    }
-  }
-
-  /**
-   * Called upon transport error.
-   *
-   * @param {Error} error object
-   * @api private
-   */
-  onError(err) {
-    debug("transport error");
-    this.onClose("transport error", err);
-  }
-
-  /**
-   * Pings client every `this.pingInterval` and expects response
-   * within `this.pingTimeout` or closes connection.
-   *
-   * @api private
-   */
-  schedulePing() {
-    clearTimeout(this.pingIntervalTimer);
-    this.pingIntervalTimer = setTimeout(() => {
-      debug(
-        "writing ping packet - expecting pong within %sms",
-        this.server.opts.pingTimeout
-      );
-      this.sendPacket("ping");
-      this.resetPingTimeout(this.server.opts.pingTimeout);
-    }, this.server.opts.pingInterval);
-  }
-
-  /**
-   * Resets ping timeout.
-   *
-   * @api private
-   */
-  resetPingTimeout(timeout) {
-    clearTimeout(this.pingTimeoutTimer);
-    this.pingTimeoutTimer = setTimeout(() => {
-      if (this.readyState === "closed") return;
-      this.onClose("ping timeout");
-    }, timeout);
-  }
-
-  /**
-   * Attaches handlers for the given transport.
-   *
-   * @param {Transport} transport
-   * @api private
-   */
-  setTransport(transport) {
-    const onError = this.onError.bind(this);
-    const onPacket = this.onPacket.bind(this);
-    const flush = this.flush.bind(this);
-    const onClose = this.onClose.bind(this, "transport close");
-
-    this.transport = transport;
-    this.transport.once("error", onError);
-    this.transport.on("packet", onPacket);
-    this.transport.on("drain", flush);
-    this.transport.once("close", onClose);
-    // this function will manage packet events (also message callbacks)
-    this.setupSendCallback();
-
-    this.cleanupFn.push(function() {
-      transport.removeListener("error", onError);
-      transport.removeListener("packet", onPacket);
-      transport.removeListener("drain", flush);
-      transport.removeListener("close", onClose);
-    });
-  }
-
-  /**
-   * Upgrades socket to the given transport
-   *
-   * @param {Transport} transport
-   * @api private
-   */
-  maybeUpgrade(transport) {
-    debug(
-      'might upgrade socket transport from "%s" to "%s"',
-      this.transport.name,
-      transport.name
-    );
-
-    this.upgrading = true;
-
-    const self = this;
-
-    // set transport upgrade timer
-    self.upgradeTimeoutTimer = setTimeout(function() {
-      debug("client did not complete upgrade - closing transport");
-      cleanup();
-      if ("open" === transport.readyState) {
-        transport.close();
-      }
-    }, this.server.opts.upgradeTimeout);
-
-    function onPacket(packet) {
-      if ("ping" === packet.type && "probe" === packet.data) {
-        transport.send([{ type: "pong", data: "probe" }]);
-        self.emit("upgrading", transport);
-        clearInterval(self.checkIntervalTimer);
-        self.checkIntervalTimer = setInterval(check, 100);
-      } else if ("upgrade" === packet.type && self.readyState !== "closed") {
-        debug("got upgrade packet - upgrading");
-        cleanup();
-        self.transport.discard();
-        self.upgraded = true;
-        self.clearTransport();
-        self.setTransport(transport);
-        self.emit("upgrade", transport);
-        self.flush();
-        if (self.readyState === "closing") {
-          transport.close(function() {
-            self.onClose("forced close");
-          });
-        }
-      } else {
-        cleanup();
-        transport.close();
-      }
-    }
-
-    // we force a polling cycle to ensure a fast upgrade
-    function check() {
-      if ("polling" === self.transport.name && self.transport.writable) {
-        debug("writing a noop packet to polling for fast upgrade");
-        self.transport.send([{ type: "noop" }]);
-      }
-    }
-
-    function cleanup() {
-      self.upgrading = false;
-
-      clearInterval(self.checkIntervalTimer);
-      self.checkIntervalTimer = null;
-
-      clearTimeout(self.upgradeTimeoutTimer);
-      self.upgradeTimeoutTimer = null;
-
-      transport.removeListener("packet", onPacket);
-      transport.removeListener("close", onTransportClose);
-      transport.removeListener("error", onError);
-      self.removeListener("close", onClose);
-    }
-
-    function onError(err) {
-      debug("client did not complete upgrade - %s", err);
-      cleanup();
-      transport.close();
-      transport = null;
-    }
-
-    function onTransportClose() {
-      onError("transport closed");
-    }
-
-    function onClose() {
-      onError("socket closed");
-    }
-
-    transport.on("packet", onPacket);
-    transport.once("close", onTransportClose);
-    transport.once("error", onError);
-
-    self.once("close", onClose);
-  }
-
-  /**
-   * Clears listeners and timers associated with current transport.
-   *
-   * @api private
-   */
-  clearTransport() {
-    let cleanup;
-
-    const toCleanUp = this.cleanupFn.length;
-
-    for (let i = 0; i < toCleanUp; i++) {
-      cleanup = this.cleanupFn.shift();
-      cleanup();
-    }
-
-    // silence further transport errors and prevent uncaught exceptions
-    this.transport.on("error", function() {
-      debug("error triggered by discarded transport");
-    });
-
-    // ensure transport won't stay open
-    this.transport.close();
-
-    clearTimeout(this.pingTimeoutTimer);
-  }
-
-  /**
-   * Called upon transport considered closed.
-   * Possible reasons: `ping timeout`, `client error`, `parse error`,
-   * `transport error`, `server close`, `transport close`
-   */
-  onClose(reason, description) {
-    if ("closed" !== this.readyState) {
-      this.readyState = "closed";
-
-      // clear timers
-      clearTimeout(this.pingIntervalTimer);
-      clearTimeout(this.pingTimeoutTimer);
-
-      clearInterval(this.checkIntervalTimer);
-      this.checkIntervalTimer = null;
-      clearTimeout(this.upgradeTimeoutTimer);
-      const self = this;
-      // clean writeBuffer in next tick, so developers can still
-      // grab the writeBuffer on 'close' event
-      process.nextTick(function() {
-        self.writeBuffer = [];
-      });
-      this.packetsFn = [];
-      this.sentCallbackFn = [];
-      this.clearTransport();
-      this.emit("close", reason, description);
-    }
-  }
-
-  /**
-   * Setup and manage send callback
-   *
-   * @api private
-   */
-  setupSendCallback() {
-    const self = this;
-    this.transport.on("drain", onDrain);
-
-    this.cleanupFn.push(function() {
-      self.transport.removeListener("drain", onDrain);
-    });
-
-    // the message was sent successfully, execute the callback
-    function onDrain() {
-      if (self.sentCallbackFn.length > 0) {
-        const seqFn = self.sentCallbackFn.splice(0, 1)[0];
-        if ("function" === typeof seqFn) {
-          debug("executing send callback");
-          seqFn(self.transport);
-        } else if (Array.isArray(seqFn)) {
-          debug("executing batch send callback");
-          const l = seqFn.length;
-          let i = 0;
-          for (; i < l; i++) {
-            if ("function" === typeof seqFn[i]) {
-              seqFn[i](self.transport);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Sends a message packet.
-   *
-   * @param {String} message
-   * @param {Object} options
-   * @param {Function} callback
-   * @return {Socket} for chaining
-   * @api public
-   */
-  send(data, options, callback) {
-    this.sendPacket("message", data, options, callback);
-    return this;
-  }
-
-  write(data, options, callback) {
-    this.sendPacket("message", data, options, callback);
-    return this;
-  }
-
-  /**
-   * Sends a packet.
-   *
-   * @param {String} packet type
-   * @param {String} optional, data
-   * @param {Object} options
-   * @api private
-   */
-  sendPacket(type, data, options, callback) {
-    if ("function" === typeof options) {
-      callback = options;
-      options = null;
-    }
-
-    options = options || {};
-    options.compress = false !== options.compress;
-
-    if ("closing" !== this.readyState && "closed" !== this.readyState) {
-      debug('sending packet "%s" (%s)', type, data);
-
-      const packet = {
-        type: type,
-        options: options
-      };
-      if (data) packet.data = data;
-
-      // exports packetCreate event
-      this.emit("packetCreate", packet);
-
-      this.writeBuffer.push(packet);
-
-      // add send callback to object, if defined
-      if (callback) this.packetsFn.push(callback);
-
-      this.flush();
-    }
-  }
-
-  /**
-   * Attempts to flush the packets buffer.
-   *
-   * @api private
-   */
-  flush() {
-    if (
-      "closed" !== this.readyState &&
-      this.transport.writable &&
-      this.writeBuffer.length
-    ) {
-      debug("flushing buffer to transport");
-      this.emit("flush", this.writeBuffer);
-      this.server.emit("flush", this, this.writeBuffer);
-      const wbuf = this.writeBuffer;
-      this.writeBuffer = [];
-      if (!this.transport.supportsFraming) {
-        this.sentCallbackFn.push(this.packetsFn);
-      } else {
-        this.sentCallbackFn.push.apply(this.sentCallbackFn, this.packetsFn);
-      }
-      this.packetsFn = [];
-      this.transport.send(wbuf);
-      this.emit("drain");
-      this.server.emit("drain", this);
-    }
-  }
-
-  /**
-   * Get available upgrades for this socket.
-   *
-   * @api private
-   */
-  getAvailableUpgrades() {
-    const availableUpgrades = [];
-    const allUpgrades = this.server.upgrades(this.transport.name);
-    let i = 0;
-    const l = allUpgrades.length;
-    for (; i < l; ++i) {
-      const upg = allUpgrades[i];
-      if (this.server.opts.transports.indexOf(upg) !== -1) {
-        availableUpgrades.push(upg);
-      }
-    }
-    return availableUpgrades;
-  }
-
-  /**
-   * Closes the socket and underlying transport.
-   *
-   * @param {Boolean} optional, discard
-   * @return {Socket} for chaining
-   * @api public
-   */
-  close(discard) {
-    if ("open" !== this.readyState) return;
-
-    this.readyState = "closing";
-
-    if (this.writeBuffer.length) {
-      this.once("drain", this.closeTransport.bind(this, discard));
-      return;
-    }
-
-    this.closeTransport(discard);
-  }
-
-  /**
-   * Closes the underlying transport.
-   *
-   * @param {Boolean} discard
-   * @api private
-   */
-  closeTransport(discard) {
-    if (discard) this.transport.discard();
-    this.transport.close(this.onClose.bind(this, "forced close"));
-  }
-}
-
-module.exports = Socket;
Index: trip-planner-front/node_modules/engine.io/lib/transport.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/transport.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,110 +1,0 @@
-const EventEmitter = require("events");
-const parser_v4 = require("engine.io-parser");
-const parser_v3 = require("./parser-v3/index");
-const debug = require("debug")("engine:transport");
-
-/**
- * Noop function.
- *
- * @api private
- */
-
-function noop() {}
-
-class Transport extends EventEmitter {
-  /**
-   * Transport constructor.
-   *
-   * @param {http.IncomingMessage} request
-   * @api public
-   */
-  constructor(req) {
-    super();
-    this.readyState = "open";
-    this.discarded = false;
-    this.protocol = req._query.EIO === "3" ? 3 : 4; // 4th revision by default
-    this.parser = this.protocol === 3 ? parser_v3 : parser_v4;
-  }
-
-  /**
-   * Flags the transport as discarded.
-   *
-   * @api private
-   */
-  discard() {
-    this.discarded = true;
-  }
-
-  /**
-   * Called with an incoming HTTP request.
-   *
-   * @param {http.IncomingMessage} request
-   * @api private
-   */
-  onRequest(req) {
-    debug("setting request");
-    this.req = req;
-  }
-
-  /**
-   * Closes the transport.
-   *
-   * @api private
-   */
-  close(fn) {
-    if ("closed" === this.readyState || "closing" === this.readyState) return;
-
-    this.readyState = "closing";
-    this.doClose(fn || noop);
-  }
-
-  /**
-   * Called with a transport error.
-   *
-   * @param {String} message error
-   * @param {Object} error description
-   * @api private
-   */
-  onError(msg, desc) {
-    if (this.listeners("error").length) {
-      const err = new Error(msg);
-      err.type = "TransportError";
-      err.description = desc;
-      this.emit("error", err);
-    } else {
-      debug("ignored transport error %s (%s)", msg, desc);
-    }
-  }
-
-  /**
-   * Called with parsed out a packets from the data stream.
-   *
-   * @param {Object} packet
-   * @api private
-   */
-  onPacket(packet) {
-    this.emit("packet", packet);
-  }
-
-  /**
-   * Called with the encoded packet data.
-   *
-   * @param {String} data
-   * @api private
-   */
-  onData(data) {
-    this.onPacket(this.parser.decodePacket(data));
-  }
-
-  /**
-   * Called upon transport close.
-   *
-   * @api private
-   */
-  onClose() {
-    this.readyState = "closed";
-    this.emit("close");
-  }
-}
-
-module.exports = Transport;
Index: trip-planner-front/node_modules/engine.io/lib/transports/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/transports/index.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,31 +1,0 @@
-const XHR = require("./polling");
-const JSONP = require("./polling-jsonp");
-
-/**
- * Export transports.
- */
-
-module.exports = exports = {
-  polling: polling,
-  websocket: require("./websocket")
-};
-
-/**
- * Export upgrades map.
- */
-
-exports.polling.upgradesTo = ["websocket"];
-
-/**
- * Polling polymorphic constructor.
- *
- * @api private
- */
-
-function polling(req) {
-  if ("string" === typeof req._query.j) {
-    return new JSONP(req);
-  } else {
-    return new XHR(req);
-  }
-}
Index: trip-planner-front/node_modules/engine.io/lib/transports/polling-jsonp.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/transports/polling-jsonp.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,58 +1,0 @@
-const Polling = require("./polling");
-const qs = require("querystring");
-const rDoubleSlashes = /\\\\n/g;
-const rSlashes = /(\\)?\\n/g;
-
-class JSONP extends Polling {
-  /**
-   * JSON-P polling transport.
-   *
-   * @api public
-   */
-  constructor(req) {
-    super(req);
-
-    this.head = "___eio[" + (req._query.j || "").replace(/[^0-9]/g, "") + "](";
-    this.foot = ");";
-  }
-
-  /**
-   * Handles incoming data.
-   * Due to a bug in \n handling by browsers, we expect a escaped string.
-   *
-   * @api private
-   */
-  onData(data) {
-    // we leverage the qs module so that we get built-in DoS protection
-    // and the fast alternative to decodeURIComponent
-    data = qs.parse(data).d;
-    if ("string" === typeof data) {
-      // client will send already escaped newlines as \\\\n and newlines as \\n
-      // \\n must be replaced with \n and \\\\n with \\n
-      data = data.replace(rSlashes, function(match, slashes) {
-        return slashes ? match : "\n";
-      });
-      super.onData(data.replace(rDoubleSlashes, "\\n"));
-    }
-  }
-
-  /**
-   * Performs the write.
-   *
-   * @api private
-   */
-  doWrite(data, options, callback) {
-    // we must output valid javascript, not valid json
-    // see: http://timelessrepo.com/json-isnt-a-javascript-subset
-    const js = JSON.stringify(data)
-      .replace(/\u2028/g, "\\u2028")
-      .replace(/\u2029/g, "\\u2029");
-
-    // prepare response
-    data = this.head + js + this.foot;
-
-    super.doWrite(data, options, callback);
-  }
-}
-
-module.exports = JSONP;
Index: trip-planner-front/node_modules/engine.io/lib/transports/polling.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/transports/polling.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,393 +1,0 @@
-const Transport = require("../transport");
-const zlib = require("zlib");
-const accepts = require("accepts");
-const debug = require("debug")("engine:polling");
-
-const compressionMethods = {
-  gzip: zlib.createGzip,
-  deflate: zlib.createDeflate
-};
-
-class Polling extends Transport {
-  /**
-   * HTTP polling constructor.
-   *
-   * @api public.
-   */
-  constructor(req) {
-    super(req);
-
-    this.closeTimeout = 30 * 1000;
-    this.maxHttpBufferSize = null;
-    this.httpCompression = null;
-  }
-
-  /**
-   * Transport name
-   *
-   * @api public
-   */
-  get name() {
-    return "polling";
-  }
-
-  /**
-   * Overrides onRequest.
-   *
-   * @param {http.IncomingMessage}
-   * @api private
-   */
-  onRequest(req) {
-    const res = req.res;
-
-    if ("GET" === req.method) {
-      this.onPollRequest(req, res);
-    } else if ("POST" === req.method) {
-      this.onDataRequest(req, res);
-    } else {
-      res.writeHead(500);
-      res.end();
-    }
-  }
-
-  /**
-   * The client sends a request awaiting for us to send data.
-   *
-   * @api private
-   */
-  onPollRequest(req, res) {
-    if (this.req) {
-      debug("request overlap");
-      // assert: this.res, '.req and .res should be (un)set together'
-      this.onError("overlap from client");
-      res.writeHead(500);
-      res.end();
-      return;
-    }
-
-    debug("setting request");
-
-    this.req = req;
-    this.res = res;
-
-    const self = this;
-
-    function onClose() {
-      self.onError("poll connection closed prematurely");
-    }
-
-    function cleanup() {
-      req.removeListener("close", onClose);
-      self.req = self.res = null;
-    }
-
-    req.cleanup = cleanup;
-    req.on("close", onClose);
-
-    this.writable = true;
-    this.emit("drain");
-
-    // if we're still writable but had a pending close, trigger an empty send
-    if (this.writable && this.shouldClose) {
-      debug("triggering empty send to append close packet");
-      this.send([{ type: "noop" }]);
-    }
-  }
-
-  /**
-   * The client sends a request with data.
-   *
-   * @api private
-   */
-  onDataRequest(req, res) {
-    if (this.dataReq) {
-      // assert: this.dataRes, '.dataReq and .dataRes should be (un)set together'
-      this.onError("data request overlap from client");
-      res.writeHead(500);
-      res.end();
-      return;
-    }
-
-    const isBinary = "application/octet-stream" === req.headers["content-type"];
-
-    if (isBinary && this.protocol === 4) {
-      return this.onError("invalid content");
-    }
-
-    this.dataReq = req;
-    this.dataRes = res;
-
-    let chunks = isBinary ? Buffer.concat([]) : "";
-    const self = this;
-
-    function cleanup() {
-      req.removeListener("data", onData);
-      req.removeListener("end", onEnd);
-      req.removeListener("close", onClose);
-      self.dataReq = self.dataRes = chunks = null;
-    }
-
-    function onClose() {
-      cleanup();
-      self.onError("data request connection closed prematurely");
-    }
-
-    function onData(data) {
-      let contentLength;
-      if (isBinary) {
-        chunks = Buffer.concat([chunks, data]);
-        contentLength = chunks.length;
-      } else {
-        chunks += data;
-        contentLength = Buffer.byteLength(chunks);
-      }
-
-      if (contentLength > self.maxHttpBufferSize) {
-        chunks = isBinary ? Buffer.concat([]) : "";
-        req.connection.destroy();
-      }
-    }
-
-    function onEnd() {
-      self.onData(chunks);
-
-      const headers = {
-        // text/html is required instead of text/plain to avoid an
-        // unwanted download dialog on certain user-agents (GH-43)
-        "Content-Type": "text/html",
-        "Content-Length": 2
-      };
-
-      res.writeHead(200, self.headers(req, headers));
-      res.end("ok");
-      cleanup();
-    }
-
-    req.on("close", onClose);
-    if (!isBinary) req.setEncoding("utf8");
-    req.on("data", onData);
-    req.on("end", onEnd);
-  }
-
-  /**
-   * Processes the incoming data payload.
-   *
-   * @param {String} encoded payload
-   * @api private
-   */
-  onData(data) {
-    debug('received "%s"', data);
-    const self = this;
-    const callback = function(packet) {
-      if ("close" === packet.type) {
-        debug("got xhr close packet");
-        self.onClose();
-        return false;
-      }
-
-      self.onPacket(packet);
-    };
-
-    if (this.protocol === 3) {
-      this.parser.decodePayload(data, callback);
-    } else {
-      this.parser.decodePayload(data).forEach(callback);
-    }
-  }
-
-  /**
-   * Overrides onClose.
-   *
-   * @api private
-   */
-  onClose() {
-    if (this.writable) {
-      // close pending poll request
-      this.send([{ type: "noop" }]);
-    }
-    super.onClose();
-  }
-
-  /**
-   * Writes a packet payload.
-   *
-   * @param {Object} packet
-   * @api private
-   */
-  send(packets) {
-    this.writable = false;
-
-    if (this.shouldClose) {
-      debug("appending close packet to payload");
-      packets.push({ type: "close" });
-      this.shouldClose();
-      this.shouldClose = null;
-    }
-
-    const doWrite = data => {
-      const compress = packets.some(packet => {
-        return packet.options && packet.options.compress;
-      });
-      this.write(data, { compress });
-    };
-
-    if (this.protocol === 3) {
-      this.parser.encodePayload(packets, this.supportsBinary, doWrite);
-    } else {
-      this.parser.encodePayload(packets, doWrite);
-    }
-  }
-
-  /**
-   * Writes data as response to poll request.
-   *
-   * @param {String} data
-   * @param {Object} options
-   * @api private
-   */
-  write(data, options) {
-    debug('writing "%s"', data);
-    const self = this;
-    this.doWrite(data, options, function() {
-      self.req.cleanup();
-    });
-  }
-
-  /**
-   * Performs the write.
-   *
-   * @api private
-   */
-  doWrite(data, options, callback) {
-    const self = this;
-
-    // explicit UTF-8 is required for pages not served under utf
-    const isString = typeof data === "string";
-    const contentType = isString
-      ? "text/plain; charset=UTF-8"
-      : "application/octet-stream";
-
-    const headers = {
-      "Content-Type": contentType
-    };
-
-    if (!this.httpCompression || !options.compress) {
-      respond(data);
-      return;
-    }
-
-    const len = isString ? Buffer.byteLength(data) : data.length;
-    if (len < this.httpCompression.threshold) {
-      respond(data);
-      return;
-    }
-
-    const encoding = accepts(this.req).encodings(["gzip", "deflate"]);
-    if (!encoding) {
-      respond(data);
-      return;
-    }
-
-    this.compress(data, encoding, function(err, data) {
-      if (err) {
-        self.res.writeHead(500);
-        self.res.end();
-        callback(err);
-        return;
-      }
-
-      headers["Content-Encoding"] = encoding;
-      respond(data);
-    });
-
-    function respond(data) {
-      headers["Content-Length"] =
-        "string" === typeof data ? Buffer.byteLength(data) : data.length;
-      self.res.writeHead(200, self.headers(self.req, headers));
-      self.res.end(data);
-      callback();
-    }
-  }
-
-  /**
-   * Compresses data.
-   *
-   * @api private
-   */
-  compress(data, encoding, callback) {
-    debug("compressing");
-
-    const buffers = [];
-    let nread = 0;
-
-    compressionMethods[encoding](this.httpCompression)
-      .on("error", callback)
-      .on("data", function(chunk) {
-        buffers.push(chunk);
-        nread += chunk.length;
-      })
-      .on("end", function() {
-        callback(null, Buffer.concat(buffers, nread));
-      })
-      .end(data);
-  }
-
-  /**
-   * Closes the transport.
-   *
-   * @api private
-   */
-  doClose(fn) {
-    debug("closing");
-
-    const self = this;
-    let closeTimeoutTimer;
-
-    if (this.dataReq) {
-      debug("aborting ongoing data request");
-      this.dataReq.destroy();
-    }
-
-    if (this.writable) {
-      debug("transport writable - closing right away");
-      this.send([{ type: "close" }]);
-      onClose();
-    } else if (this.discarded) {
-      debug("transport discarded - closing right away");
-      onClose();
-    } else {
-      debug("transport not writable - buffering orderly close");
-      this.shouldClose = onClose;
-      closeTimeoutTimer = setTimeout(onClose, this.closeTimeout);
-    }
-
-    function onClose() {
-      clearTimeout(closeTimeoutTimer);
-      fn();
-      self.onClose();
-    }
-  }
-
-  /**
-   * Returns headers for a response.
-   *
-   * @param {http.IncomingMessage} request
-   * @param {Object} extra headers
-   * @api private
-   */
-  headers(req, headers) {
-    headers = headers || {};
-
-    // prevent XSS warnings on IE
-    // https://github.com/LearnBoost/socket.io/pull/1333
-    const ua = req.headers["user-agent"];
-    if (ua && (~ua.indexOf(";MSIE") || ~ua.indexOf("Trident/"))) {
-      headers["X-XSS-Protection"] = "0";
-    }
-
-    this.emit("headers", headers);
-    return headers;
-  }
-}
-
-module.exports = Polling;
Index: trip-planner-front/node_modules/engine.io/lib/transports/websocket.js
===================================================================
--- trip-planner-front/node_modules/engine.io/lib/transports/websocket.js	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ 	(revision )
@@ -1,116 +1,0 @@
-const Transport = require("../transport");
-const debug = require("debug")("engine:ws");
-
-class WebSocket extends Transport {
-  /**
-   * WebSocket transport
-   *
-   * @param {http.IncomingMessage}
-   * @api public
-   */
-  constructor(req) {
-    super(req);
-    this.socket = req.websocket;
-    this.socket.on("message", this.onData.bind(this));
-    this.socket.once("close", this.onClose.bind(this));
-    this.socket.on("error", this.onError.bind(this));
-    this.socket.on("headers", headers => {
-      this.emit("headers", headers);
-    });
-    this.writable = true;
-    this.perMessageDeflate = null;
-  }
-
-  /**
-   * Transport name
-   *
-   * @api public
-   */
-  get name() {
-    return "websocket";
-  }
-
-  /**
-   * Advertise upgrade support.
-   *
-   * @api public
-   */
-  get handlesUpgrades() {
-    return true;
-  }
-
-  /**
-   * Advertise framing support.
-   *
-   * @api public
-   */
-  get supportsFraming() {
-    return true;
-  }
-
-  /**
-   * Processes the incoming data.
-   *
-   * @param {String} encoded packet
-   * @api private
-   */
-  onData(data) {
-    debug('received "%s"', data);
-    super.onData(data);
-  }
-
-  /**
-   * Writes a packet payload.
-   *
-   * @param {Array} packets
-   * @api private
-   */
-  send(packets) {
-    var self = this;
-
-    for (var i = 0; i < packets.length; i++) {
-      var packet = packets[i];
-      this.parser.encodePacket(packet, self.supportsBinary, send);
-    }
-
-    function send(data) {
-      debug('writing "%s"', data);
-
-      // always creates a new object since ws modifies it
-      var opts = {};
-      if (packet.options) {
-        opts.compress = packet.options.compress;
-      }
-
-      if (self.perMessageDeflate) {
-        var len =
-          "string" === typeof data ? Buffer.byteLength(data) : data.length;
-        if (len < self.perMessageDeflate.threshold) {
-          opts.compress = false;
-        }
-      }
-
-      self.writable = false;
-      self.socket.send(data, opts, onEnd);
-    }
-
-    function onEnd(err) {
-      if (err) return self.onError("write error", err.stack);
-      self.writable = true;
-      self.emit("drain");
-    }
-  }
-
-  /**
-   * Closes the transport.
-   *
-   * @api private
-   */
-  doClose(fn) {
-    debug("closing");
-    this.socket.close();
-    fn && fn();
-  }
-}
-
-module.exports = WebSocket;
Index: trip-planner-front/node_modules/engine.io/node_modules/cookie/HISTORY.md
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/cookie/HISTORY.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/cookie/HISTORY.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,128 @@
+0.4.1 / 2020-04-21
+==================
+
+  * Fix `maxAge` option to reject invalid values
+
+0.4.0 / 2019-05-15
+==================
+
+  * Add `SameSite=None` support
+
+0.3.1 / 2016-05-26
+==================
+
+  * Fix `sameSite: true` to work with draft-7 clients
+    - `true` now sends `SameSite=Strict` instead of `SameSite`
+
+0.3.0 / 2016-05-26
+==================
+
+  * Add `sameSite` option
+    - Replaces `firstPartyOnly` option, never implemented by browsers
+  * Improve error message when `encode` is not a function
+  * Improve error message when `expires` is not a `Date`
+
+0.2.4 / 2016-05-20
+==================
+
+  * perf: enable strict mode
+  * perf: use for loop in parse
+  * perf: use string concatination for serialization
+
+0.2.3 / 2015-10-25
+==================
+
+  * Fix cookie `Max-Age` to never be a floating point number
+
+0.2.2 / 2015-09-17
+==================
+
+  * Fix regression when setting empty cookie value
+    - Ease the new restriction, which is just basic header-level validation
+  * Fix typo in invalid value errors
+
+0.2.1 / 2015-09-17
+==================
+
+  * Throw on invalid values provided to `serialize`
+    - Ensures the resulting string is a valid HTTP header value
+
+0.2.0 / 2015-08-13
+==================
+
+  * Add `firstPartyOnly` option
+  * Throw better error for invalid argument to parse
+  * perf: hoist regular expression
+
+0.1.5 / 2015-09-17
+==================
+
+  * Fix regression when setting empty cookie value
+    - Ease the new restriction, which is just basic header-level validation
+  * Fix typo in invalid value errors
+
+0.1.4 / 2015-09-17
+==================
+
+  * Throw better error for invalid argument to parse
+  * Throw on invalid values provided to `serialize`
+    - Ensures the resulting string is a valid HTTP header value
+
+0.1.3 / 2015-05-19
+==================
+
+  * Reduce the scope of try-catch deopt
+  * Remove argument reassignments
+
+0.1.2 / 2014-04-16
+==================
+
+  * Remove unnecessary files from npm package
+
+0.1.1 / 2014-02-23
+==================
+
+  * Fix bad parse when cookie value contained a comma
+  * Fix support for `maxAge` of `0`
+
+0.1.0 / 2013-05-01
+==================
+
+  * Add `decode` option
+  * Add `encode` option
+
+0.0.6 / 2013-04-08
+==================
+
+  * Ignore cookie parts missing `=`
+
+0.0.5 / 2012-10-29
+==================
+
+  * Return raw cookie value if value unescape errors
+
+0.0.4 / 2012-06-21
+==================
+
+  * Use encode/decodeURIComponent for cookie encoding/decoding
+    - Improve server/client interoperability
+
+0.0.3 / 2012-06-06
+==================
+
+  * Only escape special characters per the cookie RFC
+
+0.0.2 / 2012-06-01
+==================
+
+  * Fix `maxAge` option to not throw error
+
+0.0.1 / 2012-05-28
+==================
+
+  * Add more tests
+
+0.0.0 / 2012-05-28
+==================
+
+  * Initial release
Index: trip-planner-front/node_modules/engine.io/node_modules/cookie/LICENSE
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/cookie/LICENSE	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/cookie/LICENSE	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,24 @@
+(The MIT License)
+
+Copyright (c) 2012-2014 Roman Shtylman <shtylman@gmail.com>
+Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
Index: trip-planner-front/node_modules/engine.io/node_modules/cookie/README.md
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/cookie/README.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/cookie/README.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,257 @@
+# cookie
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Basic HTTP cookie parser and serializer for HTTP servers.
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install cookie
+```
+
+## API
+
+```js
+var cookie = require('cookie');
+```
+
+### cookie.parse(str, options)
+
+Parse an HTTP `Cookie` header string and returning an object of all cookie name-value pairs.
+The `str` argument is the string representing a `Cookie` header value and `options` is an
+optional object containing additional parsing options.
+
+```js
+var cookies = cookie.parse('foo=bar; equation=E%3Dmc%5E2');
+// { foo: 'bar', equation: 'E=mc^2' }
+```
+
+#### Options
+
+`cookie.parse` accepts these properties in the options object.
+
+##### decode
+
+Specifies a function that will be used to decode a cookie's value. Since the value of a cookie
+has a limited character set (and must be a simple string), this function can be used to decode
+a previously-encoded cookie value into a JavaScript string or other object.
+
+The default function is the global `decodeURIComponent`, which will decode any URL-encoded
+sequences into their byte representations.
+
+**note** if an error is thrown from this function, the original, non-decoded cookie value will
+be returned as the cookie's value.
+
+### cookie.serialize(name, value, options)
+
+Serialize a cookie name-value pair into a `Set-Cookie` header string. The `name` argument is the
+name for the cookie, the `value` argument is the value to set the cookie to, and the `options`
+argument is an optional object containing additional serialization options.
+
+```js
+var setCookie = cookie.serialize('foo', 'bar');
+// foo=bar
+```
+
+#### Options
+
+`cookie.serialize` accepts these properties in the options object.
+
+##### domain
+
+Specifies the value for the [`Domain` `Set-Cookie` attribute][rfc-6265-5.2.3]. By default, no
+domain is set, and most clients will consider the cookie to apply to only the current domain.
+
+##### encode
+
+Specifies a function that will be used to encode a cookie's value. Since value of a cookie
+has a limited character set (and must be a simple string), this function can be used to encode
+a value into a string suited for a cookie's value.
+
+The default function is the global `encodeURIComponent`, which will encode a JavaScript string
+into UTF-8 byte sequences and then URL-encode any that fall outside of the cookie range.
+
+##### expires
+
+Specifies the `Date` object to be the value for the [`Expires` `Set-Cookie` attribute][rfc-6265-5.2.1].
+By default, no expiration is set, and most clients will consider this a "non-persistent cookie" and
+will delete it on a condition like exiting a web browser application.
+
+**note** the [cookie storage model specification][rfc-6265-5.3] states that if both `expires` and
+`maxAge` are set, then `maxAge` takes precedence, but it is possible not all clients by obey this,
+so if both are set, they should point to the same date and time.
+
+##### httpOnly
+
+Specifies the `boolean` value for the [`HttpOnly` `Set-Cookie` attribute][rfc-6265-5.2.6]. When truthy,
+the `HttpOnly` attribute is set, otherwise it is not. By default, the `HttpOnly` attribute is not set.
+
+**note** be careful when setting this to `true`, as compliant clients will not allow client-side
+JavaScript to see the cookie in `document.cookie`.
+
+##### maxAge
+
+Specifies the `number` (in seconds) to be the value for the [`Max-Age` `Set-Cookie` attribute][rfc-6265-5.2.2].
+The given number will be converted to an integer by rounding down. By default, no maximum age is set.
+
+**note** the [cookie storage model specification][rfc-6265-5.3] states that if both `expires` and
+`maxAge` are set, then `maxAge` takes precedence, but it is possible not all clients by obey this,
+so if both are set, they should point to the same date and time.
+
+##### path
+
+Specifies the value for the [`Path` `Set-Cookie` attribute][rfc-6265-5.2.4]. By default, the path
+is considered the ["default path"][rfc-6265-5.1.4].
+
+##### sameSite
+
+Specifies the `boolean` or `string` to be the value for the [`SameSite` `Set-Cookie` attribute][rfc-6265bis-03-4.1.2.7].
+
+  - `true` will set the `SameSite` attribute to `Strict` for strict same site enforcement.
+  - `false` will not set the `SameSite` attribute.
+  - `'lax'` will set the `SameSite` attribute to `Lax` for lax same site enforcement.
+  - `'none'` will set the `SameSite` attribute to `None` for an explicit cross-site cookie.
+  - `'strict'` will set the `SameSite` attribute to `Strict` for strict same site enforcement.
+
+More information about the different enforcement levels can be found in
+[the specification][rfc-6265bis-03-4.1.2.7].
+
+**note** This is an attribute that has not yet been fully standardized, and may change in the future.
+This also means many clients may ignore this attribute until they understand it.
+
+##### secure
+
+Specifies the `boolean` value for the [`Secure` `Set-Cookie` attribute][rfc-6265-5.2.5]. When truthy,
+the `Secure` attribute is set, otherwise it is not. By default, the `Secure` attribute is not set.
+
+**note** be careful when setting this to `true`, as compliant clients will not send the cookie back to
+the server in the future if the browser does not have an HTTPS connection.
+
+## Example
+
+The following example uses this module in conjunction with the Node.js core HTTP server
+to prompt a user for their name and display it back on future visits.
+
+```js
+var cookie = require('cookie');
+var escapeHtml = require('escape-html');
+var http = require('http');
+var url = require('url');
+
+function onRequest(req, res) {
+  // Parse the query string
+  var query = url.parse(req.url, true, true).query;
+
+  if (query && query.name) {
+    // Set a new cookie with the name
+    res.setHeader('Set-Cookie', cookie.serialize('name', String(query.name), {
+      httpOnly: true,
+      maxAge: 60 * 60 * 24 * 7 // 1 week
+    }));
+
+    // Redirect back after setting cookie
+    res.statusCode = 302;
+    res.setHeader('Location', req.headers.referer || '/');
+    res.end();
+    return;
+  }
+
+  // Parse the cookies on the request
+  var cookies = cookie.parse(req.headers.cookie || '');
+
+  // Get the visitor name set in the cookie
+  var name = cookies.name;
+
+  res.setHeader('Content-Type', 'text/html; charset=UTF-8');
+
+  if (name) {
+    res.write('<p>Welcome back, <b>' + escapeHtml(name) + '</b>!</p>');
+  } else {
+    res.write('<p>Hello, new visitor!</p>');
+  }
+
+  res.write('<form method="GET">');
+  res.write('<input placeholder="enter your name" name="name"> <input type="submit" value="Set Name">');
+  res.end('</form>');
+}
+
+http.createServer(onRequest).listen(3000);
+```
+
+## Testing
+
+```sh
+$ npm test
+```
+
+## Benchmark
+
+```
+$ npm run bench
+
+> cookie@0.3.1 bench cookie
+> node benchmark/index.js
+
+  http_parser@2.8.0
+  node@6.14.2
+  v8@5.1.281.111
+  uv@1.16.1
+  zlib@1.2.11
+  ares@1.10.1-DEV
+  icu@58.2
+  modules@48
+  napi@3
+  openssl@1.0.2o
+
+> node benchmark/parse.js
+
+  cookie.parse
+
+  6 tests completed.
+
+  simple      x 1,200,691 ops/sec ±1.12% (189 runs sampled)
+  decode      x 1,012,994 ops/sec ±0.97% (186 runs sampled)
+  unquote     x 1,074,174 ops/sec ±2.43% (186 runs sampled)
+  duplicates  x   438,424 ops/sec ±2.17% (184 runs sampled)
+  10 cookies  x   147,154 ops/sec ±1.01% (186 runs sampled)
+  100 cookies x    14,274 ops/sec ±1.07% (187 runs sampled)
+```
+
+## References
+
+- [RFC 6265: HTTP State Management Mechanism][rfc-6265]
+- [Same-site Cookies][rfc-6265bis-03-4.1.2.7]
+
+[rfc-6265bis-03-4.1.2.7]: https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7
+[rfc-6265]: https://tools.ietf.org/html/rfc6265
+[rfc-6265-5.1.4]: https://tools.ietf.org/html/rfc6265#section-5.1.4
+[rfc-6265-5.2.1]: https://tools.ietf.org/html/rfc6265#section-5.2.1
+[rfc-6265-5.2.2]: https://tools.ietf.org/html/rfc6265#section-5.2.2
+[rfc-6265-5.2.3]: https://tools.ietf.org/html/rfc6265#section-5.2.3
+[rfc-6265-5.2.4]: https://tools.ietf.org/html/rfc6265#section-5.2.4
+[rfc-6265-5.2.5]: https://tools.ietf.org/html/rfc6265#section-5.2.5
+[rfc-6265-5.2.6]: https://tools.ietf.org/html/rfc6265#section-5.2.6
+[rfc-6265-5.3]: https://tools.ietf.org/html/rfc6265#section-5.3
+
+## License
+
+[MIT](LICENSE)
+
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/cookie/master
+[coveralls-url]: https://coveralls.io/r/jshttp/cookie?branch=master
+[node-version-image]: https://badgen.net/npm/node/cookie
+[node-version-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/cookie
+[npm-url]: https://npmjs.org/package/cookie
+[npm-version-image]: https://badgen.net/npm/v/cookie
+[travis-image]: https://badgen.net/travis/jshttp/cookie/master
+[travis-url]: https://travis-ci.org/jshttp/cookie
Index: trip-planner-front/node_modules/engine.io/node_modules/cookie/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/cookie/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/cookie/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,202 @@
+/*!
+ * cookie
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Module exports.
+ * @public
+ */
+
+exports.parse = parse;
+exports.serialize = serialize;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var decode = decodeURIComponent;
+var encode = encodeURIComponent;
+var pairSplitRegExp = /; */;
+
+/**
+ * RegExp to match field-content in RFC 7230 sec 3.2
+ *
+ * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ * field-vchar   = VCHAR / obs-text
+ * obs-text      = %x80-FF
+ */
+
+var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ *
+ * @param {string} str
+ * @param {object} [options]
+ * @return {object}
+ * @public
+ */
+
+function parse(str, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('argument str must be a string');
+  }
+
+  var obj = {}
+  var opt = options || {};
+  var pairs = str.split(pairSplitRegExp);
+  var dec = opt.decode || decode;
+
+  for (var i = 0; i < pairs.length; i++) {
+    var pair = pairs[i];
+    var eq_idx = pair.indexOf('=');
+
+    // skip things that don't look like key=value
+    if (eq_idx < 0) {
+      continue;
+    }
+
+    var key = pair.substr(0, eq_idx).trim()
+    var val = pair.substr(++eq_idx, pair.length).trim();
+
+    // quoted values
+    if ('"' == val[0]) {
+      val = val.slice(1, -1);
+    }
+
+    // only assign once
+    if (undefined == obj[key]) {
+      obj[key] = tryDecode(val, dec);
+    }
+  }
+
+  return obj;
+}
+
+/**
+ * Serialize data into a cookie header.
+ *
+ * Serialize the a name value pair into a cookie string suitable for
+ * http headers. An optional options object specified cookie parameters.
+ *
+ * serialize('foo', 'bar', { httpOnly: true })
+ *   => "foo=bar; httpOnly"
+ *
+ * @param {string} name
+ * @param {string} val
+ * @param {object} [options]
+ * @return {string}
+ * @public
+ */
+
+function serialize(name, val, options) {
+  var opt = options || {};
+  var enc = opt.encode || encode;
+
+  if (typeof enc !== 'function') {
+    throw new TypeError('option encode is invalid');
+  }
+
+  if (!fieldContentRegExp.test(name)) {
+    throw new TypeError('argument name is invalid');
+  }
+
+  var value = enc(val);
+
+  if (value && !fieldContentRegExp.test(value)) {
+    throw new TypeError('argument val is invalid');
+  }
+
+  var str = name + '=' + value;
+
+  if (null != opt.maxAge) {
+    var maxAge = opt.maxAge - 0;
+
+    if (isNaN(maxAge) || !isFinite(maxAge)) {
+      throw new TypeError('option maxAge is invalid')
+    }
+
+    str += '; Max-Age=' + Math.floor(maxAge);
+  }
+
+  if (opt.domain) {
+    if (!fieldContentRegExp.test(opt.domain)) {
+      throw new TypeError('option domain is invalid');
+    }
+
+    str += '; Domain=' + opt.domain;
+  }
+
+  if (opt.path) {
+    if (!fieldContentRegExp.test(opt.path)) {
+      throw new TypeError('option path is invalid');
+    }
+
+    str += '; Path=' + opt.path;
+  }
+
+  if (opt.expires) {
+    if (typeof opt.expires.toUTCString !== 'function') {
+      throw new TypeError('option expires is invalid');
+    }
+
+    str += '; Expires=' + opt.expires.toUTCString();
+  }
+
+  if (opt.httpOnly) {
+    str += '; HttpOnly';
+  }
+
+  if (opt.secure) {
+    str += '; Secure';
+  }
+
+  if (opt.sameSite) {
+    var sameSite = typeof opt.sameSite === 'string'
+      ? opt.sameSite.toLowerCase() : opt.sameSite;
+
+    switch (sameSite) {
+      case true:
+        str += '; SameSite=Strict';
+        break;
+      case 'lax':
+        str += '; SameSite=Lax';
+        break;
+      case 'strict':
+        str += '; SameSite=Strict';
+        break;
+      case 'none':
+        str += '; SameSite=None';
+        break;
+      default:
+        throw new TypeError('option sameSite is invalid');
+    }
+  }
+
+  return str;
+}
+
+/**
+ * Try decoding a string using a decoding function.
+ *
+ * @param {string} str
+ * @param {function} decode
+ * @private
+ */
+
+function tryDecode(str, decode) {
+  try {
+    return decode(str);
+  } catch (e) {
+    return str;
+  }
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/cookie/package.json
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/cookie/package.json	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/cookie/package.json	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,78 @@
+{
+  "_from": "cookie@~0.4.1",
+  "_id": "cookie@0.4.1",
+  "_inBundle": false,
+  "_integrity": "sha512-ZwrFkGJxUR3EIoXtO+yVE69Eb7KlixbaeAWfBQB9vVsNn/o+Yw69gBWSSDK825hQNdN+wF8zELf3dFNl/kxkUA==",
+  "_location": "/engine.io/cookie",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "cookie@~0.4.1",
+    "name": "cookie",
+    "escapedName": "cookie",
+    "rawSpec": "~0.4.1",
+    "saveSpec": null,
+    "fetchSpec": "~0.4.1"
+  },
+  "_requiredBy": [
+    "/engine.io"
+  ],
+  "_resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.1.tgz",
+  "_shasum": "afd713fe26ebd21ba95ceb61f9a8116e50a537d1",
+  "_spec": "cookie@~0.4.1",
+  "_where": "C:\\Users\\DELL\\Desktop\\bachelor-thesis\\trip-planner-front\\node_modules\\engine.io",
+  "author": {
+    "name": "Roman Shtylman",
+    "email": "shtylman@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/jshttp/cookie/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Douglas Christopher Wilson",
+      "email": "doug@somethingdoug.com"
+    }
+  ],
+  "deprecated": false,
+  "description": "HTTP server cookie parsing and serialization",
+  "devDependencies": {
+    "beautify-benchmark": "0.2.4",
+    "benchmark": "2.1.4",
+    "eslint": "6.8.0",
+    "eslint-plugin-markdown": "1.0.2",
+    "mocha": "7.1.1",
+    "nyc": "15.0.1"
+  },
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "README.md",
+    "index.js"
+  ],
+  "homepage": "https://github.com/jshttp/cookie#readme",
+  "keywords": [
+    "cookie",
+    "cookies"
+  ],
+  "license": "MIT",
+  "name": "cookie",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jshttp/cookie.git"
+  },
+  "scripts": {
+    "bench": "node benchmark/index.js",
+    "lint": "eslint --plugin markdown --ext js,md .",
+    "test": "mocha --reporter spec --bail --check-leaks --ui qunit test/",
+    "test-ci": "nyc --reporter=text npm test",
+    "test-cov": "nyc --reporter=html --reporter=text npm test",
+    "version": "node scripts/version-history.js && git add HISTORY.md"
+  },
+  "version": "0.4.1"
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/LICENSE
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/LICENSE	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/LICENSE	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,19 @@
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/README.md
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/README.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/README.md	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,493 @@
+# ws: a Node.js WebSocket library
+
+[![Version npm](https://img.shields.io/npm/v/ws.svg?logo=npm)](https://www.npmjs.com/package/ws)
+[![CI](https://img.shields.io/github/workflow/status/websockets/ws/CI/master?label=CI&logo=github)](https://github.com/websockets/ws/actions?query=workflow%3ACI+branch%3Amaster)
+[![Coverage Status](https://img.shields.io/coveralls/websockets/ws/master.svg?logo=coveralls)](https://coveralls.io/github/websockets/ws)
+
+ws is a simple to use, blazing fast, and thoroughly tested WebSocket client and
+server implementation.
+
+Passes the quite extensive Autobahn test suite: [server][server-report],
+[client][client-report].
+
+**Note**: This module does not work in the browser. The client in the docs is a
+reference to a back end with the role of a client in the WebSocket
+communication. Browser clients must use the native
+[`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
+object. To make the same code work seamlessly on Node.js and the browser, you
+can use one of the many wrappers available on npm, like
+[isomorphic-ws](https://github.com/heineiuo/isomorphic-ws).
+
+## Table of Contents
+
+- [Protocol support](#protocol-support)
+- [Installing](#installing)
+  - [Opt-in for performance](#opt-in-for-performance)
+- [API docs](#api-docs)
+- [WebSocket compression](#websocket-compression)
+- [Usage examples](#usage-examples)
+  - [Sending and receiving text data](#sending-and-receiving-text-data)
+  - [Sending binary data](#sending-binary-data)
+  - [Simple server](#simple-server)
+  - [External HTTP/S server](#external-https-server)
+  - [Multiple servers sharing a single HTTP/S server](#multiple-servers-sharing-a-single-https-server)
+  - [Client authentication](#client-authentication)
+  - [Server broadcast](#server-broadcast)
+  - [echo.websocket.org demo](#echowebsocketorg-demo)
+  - [Use the Node.js streams API](#use-the-nodejs-streams-api)
+  - [Other examples](#other-examples)
+- [FAQ](#faq)
+  - [How to get the IP address of the client?](#how-to-get-the-ip-address-of-the-client)
+  - [How to detect and close broken connections?](#how-to-detect-and-close-broken-connections)
+  - [How to connect via a proxy?](#how-to-connect-via-a-proxy)
+- [Changelog](#changelog)
+- [License](#license)
+
+## Protocol support
+
+- **HyBi drafts 07-12** (Use the option `protocolVersion: 8`)
+- **HyBi drafts 13-17** (Current default, alternatively option
+  `protocolVersion: 13`)
+
+## Installing
+
+```
+npm install ws
+```
+
+### Opt-in for performance
+
+There are 2 optional modules that can be installed along side with the ws
+module. These modules are binary addons which improve certain operations.
+Prebuilt binaries are available for the most popular platforms so you don't
+necessarily need to have a C++ compiler installed on your machine.
+
+- `npm install --save-optional bufferutil`: Allows to efficiently perform
+  operations such as masking and unmasking the data payload of the WebSocket
+  frames.
+- `npm install --save-optional utf-8-validate`: Allows to efficiently check if a
+  message contains valid UTF-8.
+
+## API docs
+
+See [`/doc/ws.md`](./doc/ws.md) for Node.js-like documentation of ws classes and
+utility functions.
+
+## WebSocket compression
+
+ws supports the [permessage-deflate extension][permessage-deflate] which enables
+the client and server to negotiate a compression algorithm and its parameters,
+and then selectively apply it to the data payloads of each WebSocket message.
+
+The extension is disabled by default on the server and enabled by default on the
+client. It adds a significant overhead in terms of performance and memory
+consumption so we suggest to enable it only if it is really needed.
+
+Note that Node.js has a variety of issues with high-performance compression,
+where increased concurrency, especially on Linux, can lead to [catastrophic
+memory fragmentation][node-zlib-bug] and slow performance. If you intend to use
+permessage-deflate in production, it is worthwhile to set up a test
+representative of your workload and ensure Node.js/zlib will handle it with
+acceptable performance and memory usage.
+
+Tuning of permessage-deflate can be done via the options defined below. You can
+also use `zlibDeflateOptions` and `zlibInflateOptions`, which is passed directly
+into the creation of [raw deflate/inflate streams][node-zlib-deflaterawdocs].
+
+See [the docs][ws-server-options] for more options.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({
+  port: 8080,
+  perMessageDeflate: {
+    zlibDeflateOptions: {
+      // See zlib defaults.
+      chunkSize: 1024,
+      memLevel: 7,
+      level: 3
+    },
+    zlibInflateOptions: {
+      chunkSize: 10 * 1024
+    },
+    // Other options settable:
+    clientNoContextTakeover: true, // Defaults to negotiated value.
+    serverNoContextTakeover: true, // Defaults to negotiated value.
+    serverMaxWindowBits: 10, // Defaults to negotiated value.
+    // Below options specified as default values.
+    concurrencyLimit: 10, // Limits zlib concurrency for perf.
+    threshold: 1024 // Size (in bytes) below which messages
+    // should not be compressed if context takeover is disabled.
+  }
+});
+```
+
+The client will only use the extension if it is supported and enabled on the
+server. To always disable the extension on the client set the
+`perMessageDeflate` option to `false`.
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path', {
+  perMessageDeflate: false
+});
+```
+
+## Usage examples
+
+### Sending and receiving text data
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('open', function open() {
+  ws.send('something');
+});
+
+ws.on('message', function incoming(message) {
+  console.log('received: %s', message);
+});
+```
+
+### Sending binary data
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('open', function open() {
+  const array = new Float32Array(5);
+
+  for (var i = 0; i < array.length; ++i) {
+    array[i] = i / 2;
+  }
+
+  ws.send(array);
+});
+```
+
+### Simple server
+
+```js
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(message) {
+    console.log('received: %s', message);
+  });
+
+  ws.send('something');
+});
+```
+
+### External HTTP/S server
+
+```js
+import { createServer } from 'https';
+import { readFileSync } from 'fs';
+import { WebSocketServer } from 'ws';
+
+const server = createServer({
+  cert: readFileSync('/path/to/cert.pem'),
+  key: readFileSync('/path/to/key.pem')
+});
+const wss = new WebSocketServer({ server });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(message) {
+    console.log('received: %s', message);
+  });
+
+  ws.send('something');
+});
+
+server.listen(8080);
+```
+
+### Multiple servers sharing a single HTTP/S server
+
+```js
+import { createServer } from 'http';
+import { parse } from 'url';
+import { WebSocketServer } from 'ws';
+
+const server = createServer();
+const wss1 = new WebSocketServer({ noServer: true });
+const wss2 = new WebSocketServer({ noServer: true });
+
+wss1.on('connection', function connection(ws) {
+  // ...
+});
+
+wss2.on('connection', function connection(ws) {
+  // ...
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  const { pathname } = parse(request.url);
+
+  if (pathname === '/foo') {
+    wss1.handleUpgrade(request, socket, head, function done(ws) {
+      wss1.emit('connection', ws, request);
+    });
+  } else if (pathname === '/bar') {
+    wss2.handleUpgrade(request, socket, head, function done(ws) {
+      wss2.emit('connection', ws, request);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+server.listen(8080);
+```
+
+### Client authentication
+
+```js
+import WebSocket from 'ws';
+import { createServer } from 'http';
+
+const server = createServer();
+const wss = new WebSocketServer({ noServer: true });
+
+wss.on('connection', function connection(ws, request, client) {
+  ws.on('message', function message(msg) {
+    console.log(`Received message ${msg} from user ${client}`);
+  });
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  // This function is not defined on purpose. Implement it with your own logic.
+  authenticate(request, (err, client) => {
+    if (err || !client) {
+      socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+      socket.destroy();
+      return;
+    }
+
+    wss.handleUpgrade(request, socket, head, function done(ws) {
+      wss.emit('connection', ws, request, client);
+    });
+  });
+});
+
+server.listen(8080);
+```
+
+Also see the provided [example][session-parse-example] using `express-session`.
+
+### Server broadcast
+
+A client WebSocket broadcasting to all connected WebSocket clients, including
+itself.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(data, isBinary) {
+    wss.clients.forEach(function each(client) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data, { binary: isBinary });
+      }
+    });
+  });
+});
+```
+
+A client WebSocket broadcasting to every other connected WebSocket clients,
+excluding itself.
+
+```js
+import WebSocket, { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(data, isBinary) {
+    wss.clients.forEach(function each(client) {
+      if (client !== ws && client.readyState === WebSocket.OPEN) {
+        client.send(data, { binary: isBinary });
+      }
+    });
+  });
+});
+```
+
+### echo.websocket.org demo
+
+```js
+import WebSocket from 'ws';
+
+const ws = new WebSocket('wss://echo.websocket.org/', {
+  origin: 'https://websocket.org'
+});
+
+ws.on('open', function open() {
+  console.log('connected');
+  ws.send(Date.now());
+});
+
+ws.on('close', function close() {
+  console.log('disconnected');
+});
+
+ws.on('message', function incoming(data) {
+  console.log(`Roundtrip time: ${Date.now() - data} ms`);
+
+  setTimeout(function timeout() {
+    ws.send(Date.now());
+  }, 500);
+});
+```
+
+### Use the Node.js streams API
+
+```js
+import WebSocket, { createWebSocketStream } from 'ws';
+
+const ws = new WebSocket('wss://echo.websocket.org/', {
+  origin: 'https://websocket.org'
+});
+
+const duplex = createWebSocketStream(ws, { encoding: 'utf8' });
+
+duplex.pipe(process.stdout);
+process.stdin.pipe(duplex);
+```
+
+### Other examples
+
+For a full example with a browser client communicating with a ws server, see the
+examples folder.
+
+Otherwise, see the test cases.
+
+## FAQ
+
+### How to get the IP address of the client?
+
+The remote IP address can be obtained from the raw socket.
+
+```js
+import { WebSocketServer } from 'ws';
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws, req) {
+  const ip = req.socket.remoteAddress;
+});
+```
+
+When the server runs behind a proxy like NGINX, the de-facto standard is to use
+the `X-Forwarded-For` header.
+
+```js
+wss.on('connection', function connection(ws, req) {
+  const ip = req.headers['x-forwarded-for'].split(',')[0].trim();
+});
+```
+
+### How to detect and close broken connections?
+
+Sometimes the link between the server and the client can be interrupted in a way
+that keeps both the server and the client unaware of the broken state of the
+connection (e.g. when pulling the cord).
+
+In these cases ping messages can be used as a means to verify that the remote
+endpoint is still responsive.
+
+```js
+import { WebSocketServer } from 'ws';
+
+function heartbeat() {
+  this.isAlive = true;
+}
+
+const wss = new WebSocketServer({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.isAlive = true;
+  ws.on('pong', heartbeat);
+});
+
+const interval = setInterval(function ping() {
+  wss.clients.forEach(function each(ws) {
+    if (ws.isAlive === false) return ws.terminate();
+
+    ws.isAlive = false;
+    ws.ping();
+  });
+}, 30000);
+
+wss.on('close', function close() {
+  clearInterval(interval);
+});
+```
+
+Pong messages are automatically sent in response to ping messages as required by
+the spec.
+
+Just like the server example above your clients might as well lose connection
+without knowing it. You might want to add a ping listener on your clients to
+prevent that. A simple implementation would be:
+
+```js
+import WebSocket from 'ws';
+
+function heartbeat() {
+  clearTimeout(this.pingTimeout);
+
+  // Use `WebSocket#terminate()`, which immediately destroys the connection,
+  // instead of `WebSocket#close()`, which waits for the close timer.
+  // Delay should be equal to the interval at which your server
+  // sends out pings plus a conservative assumption of the latency.
+  this.pingTimeout = setTimeout(() => {
+    this.terminate();
+  }, 30000 + 1000);
+}
+
+const client = new WebSocket('wss://echo.websocket.org/');
+
+client.on('open', heartbeat);
+client.on('ping', heartbeat);
+client.on('close', function clear() {
+  clearTimeout(this.pingTimeout);
+});
+```
+
+### How to connect via a proxy?
+
+Use a custom `http.Agent` implementation like [https-proxy-agent][] or
+[socks-proxy-agent][].
+
+## Changelog
+
+We're using the GitHub [releases][changelog] for changelog entries.
+
+## License
+
+[MIT](LICENSE)
+
+[changelog]: https://github.com/websockets/ws/releases
+[client-report]: http://websockets.github.io/ws/autobahn/clients/
+[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
+[node-zlib-bug]: https://github.com/nodejs/node/issues/8871
+[node-zlib-deflaterawdocs]:
+  https://nodejs.org/api/zlib.html#zlib_zlib_createdeflateraw_options
+[permessage-deflate]: https://tools.ietf.org/html/rfc7692
+[server-report]: http://websockets.github.io/ws/autobahn/servers/
+[session-parse-example]: ./examples/express-session-parse
+[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
+[ws-server-options]:
+  https://github.com/websockets/ws/blob/master/doc/ws.md#new-websocketserveroptions-callback
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/browser.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/browser.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/browser.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function () {
+  throw new Error(
+    'ws does not work in the browser. Browser clients must use the native ' +
+      'WebSocket object'
+  );
+};
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/index.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/index.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,13 @@
+'use strict';
+
+const WebSocket = require('./lib/websocket');
+
+WebSocket.createWebSocketStream = require('./lib/stream');
+WebSocket.Server = require('./lib/websocket-server');
+WebSocket.Receiver = require('./lib/receiver');
+WebSocket.Sender = require('./lib/sender');
+
+WebSocket.WebSocket = WebSocket;
+WebSocket.WebSocketServer = WebSocket.Server;
+
+module.exports = WebSocket;
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/buffer-util.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/buffer-util.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/buffer-util.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,126 @@
+'use strict';
+
+const { EMPTY_BUFFER } = require('./constants');
+
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+  if (list.length === 0) return EMPTY_BUFFER;
+  if (list.length === 1) return list[0];
+
+  const target = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    target.set(buf, offset);
+    offset += buf.length;
+  }
+
+  if (offset < totalLength) return target.slice(0, offset);
+
+  return target;
+}
+
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+  for (let i = 0; i < length; i++) {
+    output[offset + i] = source[i] ^ mask[i & 3];
+  }
+}
+
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] ^= mask[i & 3];
+  }
+}
+
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+  if (buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+  toBuffer.readOnly = true;
+
+  if (Buffer.isBuffer(data)) return data;
+
+  let buf;
+
+  if (data instanceof ArrayBuffer) {
+    buf = Buffer.from(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    buf = Buffer.from(data);
+    toBuffer.readOnly = false;
+  }
+
+  return buf;
+}
+
+try {
+  const bufferUtil = require('bufferutil');
+
+  module.exports = {
+    concat,
+    mask(source, mask, output, offset, length) {
+      if (length < 48) _mask(source, mask, output, offset, length);
+      else bufferUtil.mask(source, mask, output, offset, length);
+    },
+    toArrayBuffer,
+    toBuffer,
+    unmask(buffer, mask) {
+      if (buffer.length < 32) _unmask(buffer, mask);
+      else bufferUtil.unmask(buffer, mask);
+    }
+  };
+} catch (e) /* istanbul ignore next */ {
+  module.exports = {
+    concat,
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask
+  };
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/constants.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/constants.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/constants.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = {
+  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+  EMPTY_BUFFER: Buffer.alloc(0),
+  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+  kListener: Symbol('kListener'),
+  kStatusCode: Symbol('status-code'),
+  kWebSocket: Symbol('websocket'),
+  NOOP: () => {}
+};
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/event-target.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/event-target.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/event-target.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,266 @@
+'use strict';
+
+const { kForOnEventAttribute, kListener } = require('./constants');
+
+const kCode = Symbol('kCode');
+const kData = Symbol('kData');
+const kError = Symbol('kError');
+const kMessage = Symbol('kMessage');
+const kReason = Symbol('kReason');
+const kTarget = Symbol('kTarget');
+const kType = Symbol('kType');
+const kWasClean = Symbol('kWasClean');
+
+/**
+ * Class representing an event.
+ */
+class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @throws {TypeError} If the `type` argument is not specified
+   */
+  constructor(type) {
+    this[kTarget] = null;
+    this[kType] = type;
+  }
+
+  /**
+   * @type {*}
+   */
+  get target() {
+    return this[kTarget];
+  }
+
+  /**
+   * @type {String}
+   */
+  get type() {
+    return this[kType];
+  }
+}
+
+Object.defineProperty(Event.prototype, 'target', { enumerable: true });
+Object.defineProperty(Event.prototype, 'type', { enumerable: true });
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ */
+class CloseEvent extends Event {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {Number} [options.code=0] The status code explaining why the
+   *     connection was closed
+   * @param {String} [options.reason=''] A human-readable string explaining why
+   *     the connection was closed
+   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+   *     connection was cleanly closed
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kCode] = options.code === undefined ? 0 : options.code;
+    this[kReason] = options.reason === undefined ? '' : options.reason;
+    this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get code() {
+    return this[kCode];
+  }
+
+  /**
+   * @type {String}
+   */
+  get reason() {
+    return this[kReason];
+  }
+
+  /**
+   * @type {Boolean}
+   */
+  get wasClean() {
+    return this[kWasClean];
+  }
+}
+
+Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
+
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+class ErrorEvent extends Event {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.error=null] The error that generated this event
+   * @param {String} [options.message=''] The error message
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kError] = options.error === undefined ? null : options.error;
+    this[kMessage] = options.message === undefined ? '' : options.message;
+  }
+
+  /**
+   * @type {*}
+   */
+  get error() {
+    return this[kError];
+  }
+
+  /**
+   * @type {String}
+   */
+  get message() {
+    return this[kMessage];
+  }
+}
+
+Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
+Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+class MessageEvent extends Event {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.data=null] The message content
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kData] = options.data === undefined ? null : options.data;
+  }
+
+  /**
+   * @type {*}
+   */
+  get data() {
+    return this[kData];
+  }
+}
+
+Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} type A string representing the event type to listen for
+   * @param {Function} listener The listener to add
+   * @param {Object} [options] An options object specifies characteristics about
+   *     the event listener
+   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+   *     listener should be invoked at most once after being added. If `true`,
+   *     the listener would be automatically removed when invoked.
+   * @public
+   */
+  addEventListener(type, listener, options = {}) {
+    let wrapper;
+
+    if (type === 'message') {
+      wrapper = function onMessage(data, isBinary) {
+        const event = new MessageEvent('message', {
+          data: isBinary ? data : data.toString()
+        });
+
+        event[kTarget] = this;
+        listener.call(this, event);
+      };
+    } else if (type === 'close') {
+      wrapper = function onClose(code, message) {
+        const event = new CloseEvent('close', {
+          code,
+          reason: message.toString(),
+          wasClean: this._closeFrameReceived && this._closeFrameSent
+        });
+
+        event[kTarget] = this;
+        listener.call(this, event);
+      };
+    } else if (type === 'error') {
+      wrapper = function onError(error) {
+        const event = new ErrorEvent('error', {
+          error,
+          message: error.message
+        });
+
+        event[kTarget] = this;
+        listener.call(this, event);
+      };
+    } else if (type === 'open') {
+      wrapper = function onOpen() {
+        const event = new Event('open');
+
+        event[kTarget] = this;
+        listener.call(this, event);
+      };
+    } else {
+      return;
+    }
+
+    wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+    wrapper[kListener] = listener;
+
+    if (options.once) {
+      this.once(type, wrapper);
+    } else {
+      this.on(type, wrapper);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} type A string representing the event type to remove
+   * @param {Function} handler The listener to remove
+   * @public
+   */
+  removeEventListener(type, handler) {
+    for (const listener of this.listeners(type)) {
+      if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+        this.removeListener(type, listener);
+        break;
+      }
+    }
+  }
+};
+
+module.exports = {
+  CloseEvent,
+  ErrorEvent,
+  Event,
+  EventTarget,
+  MessageEvent
+};
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/extension.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/extension.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/extension.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,203 @@
+'use strict';
+
+const { tokenChars } = require('./validation');
+
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ *     parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+  if (dest[name] === undefined) dest[name] = [elem];
+  else dest[name].push(elem);
+}
+
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+function parse(header) {
+  const offers = Object.create(null);
+  let params = Object.create(null);
+  let mustUnescape = false;
+  let isEscaping = false;
+  let inQuotes = false;
+  let extensionName;
+  let paramName;
+  let start = -1;
+  let code = -1;
+  let end = -1;
+  let i = 0;
+
+  for (; i < header.length; i++) {
+    code = header.charCodeAt(i);
+
+    if (extensionName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (
+        i !== 0 &&
+        (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+      ) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        const name = header.slice(start, end);
+        if (code === 0x2c) {
+          push(offers, name, params);
+          params = Object.create(null);
+        } else {
+          extensionName = name;
+        }
+
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else if (paramName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 || code === 0x09) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        push(params, header.slice(start, end), true);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        start = end = -1;
+      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+        paramName = header.slice(start, i);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else {
+      //
+      // The value of a quoted-string after unescaping must conform to the
+      // token ABNF, so only token characters are valid.
+      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+      //
+      if (isEscaping) {
+        if (tokenChars[code] !== 1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (start === -1) start = i;
+        else if (!mustUnescape) mustUnescape = true;
+        isEscaping = false;
+      } else if (inQuotes) {
+        if (tokenChars[code] === 1) {
+          if (start === -1) start = i;
+        } else if (code === 0x22 /* '"' */ && start !== -1) {
+          inQuotes = false;
+          end = i;
+        } else if (code === 0x5c /* '\' */) {
+          isEscaping = true;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+        inQuotes = true;
+      } else if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+        if (end === -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        let value = header.slice(start, end);
+        if (mustUnescape) {
+          value = value.replace(/\\/g, '');
+          mustUnescape = false;
+        }
+        push(params, paramName, value);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        paramName = undefined;
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+  }
+
+  if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  if (end === -1) end = i;
+  const token = header.slice(start, end);
+  if (extensionName === undefined) {
+    push(offers, token, params);
+  } else {
+    if (paramName === undefined) {
+      push(params, token, true);
+    } else if (mustUnescape) {
+      push(params, paramName, token.replace(/\\/g, ''));
+    } else {
+      push(params, paramName, token);
+    }
+    push(offers, extensionName, params);
+  }
+
+  return offers;
+}
+
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format(extensions) {
+  return Object.keys(extensions)
+    .map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations)) configurations = [configurations];
+      return configurations
+        .map((params) => {
+          return [extension]
+            .concat(
+              Object.keys(params).map((k) => {
+                let values = params[k];
+                if (!Array.isArray(values)) values = [values];
+                return values
+                  .map((v) => (v === true ? k : `${k}=${v}`))
+                  .join('; ');
+              })
+            )
+            .join('; ');
+        })
+        .join(', ');
+    })
+    .join(', ');
+}
+
+module.exports = { format, parse };
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/limiter.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/limiter.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/limiter.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,55 @@
+'use strict';
+
+const kDone = Symbol('kDone');
+const kRun = Symbol('kRun');
+
+/**
+ * A very simple job queue with adjustable concurrency. Adapted from
+ * https://github.com/STRML/async-limiter
+ */
+class Limiter {
+  /**
+   * Creates a new `Limiter`.
+   *
+   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+   *     to run concurrently
+   */
+  constructor(concurrency) {
+    this[kDone] = () => {
+      this.pending--;
+      this[kRun]();
+    };
+    this.concurrency = concurrency || Infinity;
+    this.jobs = [];
+    this.pending = 0;
+  }
+
+  /**
+   * Adds a job to the queue.
+   *
+   * @param {Function} job The job to run
+   * @public
+   */
+  add(job) {
+    this.jobs.push(job);
+    this[kRun]();
+  }
+
+  /**
+   * Removes a job from the queue and runs it if possible.
+   *
+   * @private
+   */
+  [kRun]() {
+    if (this.pending === this.concurrency) return;
+
+    if (this.jobs.length) {
+      const job = this.jobs.shift();
+
+      this.pending++;
+      job(this[kDone]);
+    }
+  }
+}
+
+module.exports = Limiter;
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/permessage-deflate.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/permessage-deflate.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/permessage-deflate.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,511 @@
+'use strict';
+
+const zlib = require('zlib');
+
+const bufferUtil = require('./buffer-util');
+const Limiter = require('./limiter');
+const { kStatusCode } = require('./constants');
+
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const kPerMessageDeflate = Symbol('permessage-deflate');
+const kTotalLength = Symbol('total-length');
+const kCallback = Symbol('callback');
+const kBuffers = Symbol('buffers');
+const kError = Symbol('error');
+
+//
+// We limit zlib concurrency, which prevents severe memory fragmentation
+// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+// and https://github.com/websockets/ws/issues/1202
+//
+// Intentionally global; it's the global thread pool that's an issue.
+//
+let zlibLimiter;
+
+/**
+ * permessage-deflate implementation.
+ */
+class PerMessageDeflate {
+  /**
+   * Creates a PerMessageDeflate instance.
+   *
+   * @param {Object} [options] Configuration options
+   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+   *     for, or request, a custom client window size
+   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+   *     acknowledge disabling of client context takeover
+   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+   *     calls to zlib
+   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+   *     use of a custom server window size
+   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+   *     disabling of server context takeover
+   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+   *     messages should not be compressed if context takeover is disabled
+   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+   *     deflate
+   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+   *     inflate
+   * @param {Boolean} [isServer=false] Create the instance in either server or
+   *     client mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(options, isServer, maxPayload) {
+    this._maxPayload = maxPayload | 0;
+    this._options = options || {};
+    this._threshold =
+      this._options.threshold !== undefined ? this._options.threshold : 1024;
+    this._isServer = !!isServer;
+    this._deflate = null;
+    this._inflate = null;
+
+    this.params = null;
+
+    if (!zlibLimiter) {
+      const concurrency =
+        this._options.concurrencyLimit !== undefined
+          ? this._options.concurrencyLimit
+          : 10;
+      zlibLimiter = new Limiter(concurrency);
+    }
+  }
+
+  /**
+   * @type {String}
+   */
+  static get extensionName() {
+    return 'permessage-deflate';
+  }
+
+  /**
+   * Create an extension negotiation offer.
+   *
+   * @return {Object} Extension parameters
+   * @public
+   */
+  offer() {
+    const params = {};
+
+    if (this._options.serverNoContextTakeover) {
+      params.server_no_context_takeover = true;
+    }
+    if (this._options.clientNoContextTakeover) {
+      params.client_no_context_takeover = true;
+    }
+    if (this._options.serverMaxWindowBits) {
+      params.server_max_window_bits = this._options.serverMaxWindowBits;
+    }
+    if (this._options.clientMaxWindowBits) {
+      params.client_max_window_bits = this._options.clientMaxWindowBits;
+    } else if (this._options.clientMaxWindowBits == null) {
+      params.client_max_window_bits = true;
+    }
+
+    return params;
+  }
+
+  /**
+   * Accept an extension negotiation offer/response.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Object} Accepted configuration
+   * @public
+   */
+  accept(configurations) {
+    configurations = this.normalizeParams(configurations);
+
+    this.params = this._isServer
+      ? this.acceptAsServer(configurations)
+      : this.acceptAsClient(configurations);
+
+    return this.params;
+  }
+
+  /**
+   * Releases all resources used by the extension.
+   *
+   * @public
+   */
+  cleanup() {
+    if (this._inflate) {
+      this._inflate.close();
+      this._inflate = null;
+    }
+
+    if (this._deflate) {
+      const callback = this._deflate[kCallback];
+
+      this._deflate.close();
+      this._deflate = null;
+
+      if (callback) {
+        callback(
+          new Error(
+            'The deflate stream was closed while data was being processed'
+          )
+        );
+      }
+    }
+  }
+
+  /**
+   *  Accept an extension negotiation offer.
+   *
+   * @param {Array} offers The extension negotiation offers
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsServer(offers) {
+    const opts = this._options;
+    const accepted = offers.find((params) => {
+      if (
+        (opts.serverNoContextTakeover === false &&
+          params.server_no_context_takeover) ||
+        (params.server_max_window_bits &&
+          (opts.serverMaxWindowBits === false ||
+            (typeof opts.serverMaxWindowBits === 'number' &&
+              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
+        (typeof opts.clientMaxWindowBits === 'number' &&
+          !params.client_max_window_bits)
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+
+    if (!accepted) {
+      throw new Error('None of the extension offers can be accepted');
+    }
+
+    if (opts.serverNoContextTakeover) {
+      accepted.server_no_context_takeover = true;
+    }
+    if (opts.clientNoContextTakeover) {
+      accepted.client_no_context_takeover = true;
+    }
+    if (typeof opts.serverMaxWindowBits === 'number') {
+      accepted.server_max_window_bits = opts.serverMaxWindowBits;
+    }
+    if (typeof opts.clientMaxWindowBits === 'number') {
+      accepted.client_max_window_bits = opts.clientMaxWindowBits;
+    } else if (
+      accepted.client_max_window_bits === true ||
+      opts.clientMaxWindowBits === false
+    ) {
+      delete accepted.client_max_window_bits;
+    }
+
+    return accepted;
+  }
+
+  /**
+   * Accept the extension negotiation response.
+   *
+   * @param {Array} response The extension negotiation response
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsClient(response) {
+    const params = response[0];
+
+    if (
+      this._options.clientNoContextTakeover === false &&
+      params.client_no_context_takeover
+    ) {
+      throw new Error('Unexpected parameter "client_no_context_takeover"');
+    }
+
+    if (!params.client_max_window_bits) {
+      if (typeof this._options.clientMaxWindowBits === 'number') {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      }
+    } else if (
+      this._options.clientMaxWindowBits === false ||
+      (typeof this._options.clientMaxWindowBits === 'number' &&
+        params.client_max_window_bits > this._options.clientMaxWindowBits)
+    ) {
+      throw new Error(
+        'Unexpected or invalid parameter "client_max_window_bits"'
+      );
+    }
+
+    return params;
+  }
+
+  /**
+   * Normalize parameters.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Array} The offers/response with normalized parameters
+   * @private
+   */
+  normalizeParams(configurations) {
+    configurations.forEach((params) => {
+      Object.keys(params).forEach((key) => {
+        let value = params[key];
+
+        if (value.length > 1) {
+          throw new Error(`Parameter "${key}" must have only a single value`);
+        }
+
+        value = value[0];
+
+        if (key === 'client_max_window_bits') {
+          if (value !== true) {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(
+                `Invalid value for parameter "${key}": ${value}`
+              );
+            }
+            value = num;
+          } else if (!this._isServer) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else if (key === 'server_max_window_bits') {
+          const num = +value;
+          if (!Number.isInteger(num) || num < 8 || num > 15) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+          value = num;
+        } else if (
+          key === 'client_no_context_takeover' ||
+          key === 'server_no_context_takeover'
+        ) {
+          if (value !== true) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else {
+          throw new Error(`Unknown parameter "${key}"`);
+        }
+
+        params[key] = value;
+      });
+    });
+
+    return configurations;
+  }
+
+  /**
+   * Decompress data. Concurrency limited.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._decompress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Compress data. Concurrency limited.
+   *
+   * @param {Buffer} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  compress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._compress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _decompress(data, fin, callback) {
+    const endpoint = this._isServer ? 'client' : 'server';
+
+    if (!this._inflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._inflate = zlib.createInflateRaw({
+        ...this._options.zlibInflateOptions,
+        windowBits
+      });
+      this._inflate[kPerMessageDeflate] = this;
+      this._inflate[kTotalLength] = 0;
+      this._inflate[kBuffers] = [];
+      this._inflate.on('error', inflateOnError);
+      this._inflate.on('data', inflateOnData);
+    }
+
+    this._inflate[kCallback] = callback;
+
+    this._inflate.write(data);
+    if (fin) this._inflate.write(TRAILER);
+
+    this._inflate.flush(() => {
+      const err = this._inflate[kError];
+
+      if (err) {
+        this._inflate.close();
+        this._inflate = null;
+        callback(err);
+        return;
+      }
+
+      const data = bufferUtil.concat(
+        this._inflate[kBuffers],
+        this._inflate[kTotalLength]
+      );
+
+      if (this._inflate._readableState.endEmitted) {
+        this._inflate.close();
+        this._inflate = null;
+      } else {
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._inflate.reset();
+        }
+      }
+
+      callback(null, data);
+    });
+  }
+
+  /**
+   * Compress data.
+   *
+   * @param {Buffer} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _compress(data, fin, callback) {
+    const endpoint = this._isServer ? 'server' : 'client';
+
+    if (!this._deflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._deflate = zlib.createDeflateRaw({
+        ...this._options.zlibDeflateOptions,
+        windowBits
+      });
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      this._deflate.on('data', deflateOnData);
+    }
+
+    this._deflate[kCallback] = callback;
+
+    this._deflate.write(data);
+    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+      if (!this._deflate) {
+        //
+        // The deflate stream was closed while data was being processed.
+        //
+        return;
+      }
+
+      let data = bufferUtil.concat(
+        this._deflate[kBuffers],
+        this._deflate[kTotalLength]
+      );
+
+      if (fin) data = data.slice(0, data.length - 4);
+
+      //
+      // Ensure that the callback will not be called again in
+      // `PerMessageDeflate#cleanup()`.
+      //
+      this._deflate[kCallback] = null;
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+        this._deflate.reset();
+      }
+
+      callback(null, data);
+    });
+  }
+}
+
+module.exports = PerMessageDeflate;
+
+/**
+ * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function deflateOnData(chunk) {
+  this[kBuffers].push(chunk);
+  this[kTotalLength] += chunk.length;
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function inflateOnData(chunk) {
+  this[kTotalLength] += chunk.length;
+
+  if (
+    this[kPerMessageDeflate]._maxPayload < 1 ||
+    this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+  ) {
+    this[kBuffers].push(chunk);
+    return;
+  }
+
+  this[kError] = new RangeError('Max payload size exceeded');
+  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
+  this[kError][kStatusCode] = 1009;
+  this.removeListener('data', inflateOnData);
+  this.reset();
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ *
+ * @param {Error} err The emitted error
+ * @private
+ */
+function inflateOnError(err) {
+  //
+  // There is no need to call `Zlib#close()` as the handle is automatically
+  // closed when an error is emitted.
+  //
+  this[kPerMessageDeflate]._inflate = null;
+  err[kStatusCode] = 1007;
+  this[kCallback](err);
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/receiver.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/receiver.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/receiver.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,612 @@
+'use strict';
+
+const { Writable } = require('stream');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  kStatusCode,
+  kWebSocket
+} = require('./constants');
+const { concat, toArrayBuffer, unmask } = require('./buffer-util');
+const { isValidStatusCode, isValidUTF8 } = require('./validation');
+
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends Writable
+ */
+class Receiver extends Writable {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {Object} [options] Options object
+   * @param {String} [options.binaryType=nodebuffer] The type for binary data
+   * @param {Object} [options.extensions] An object containing the negotiated
+   *     extensions
+   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+   *     client or server mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   */
+  constructor(options = {}) {
+    super();
+
+    this._binaryType = options.binaryType || BINARY_TYPES[0];
+    this._extensions = options.extensions || {};
+    this._isServer = !!options.isServer;
+    this._maxPayload = options.maxPayload | 0;
+    this._skipUTF8Validation = !!options.skipUTF8Validation;
+    this[kWebSocket] = undefined;
+
+    this._bufferedBytes = 0;
+    this._buffers = [];
+
+    this._compressed = false;
+    this._payloadLength = 0;
+    this._mask = undefined;
+    this._fragmented = 0;
+    this._masked = false;
+    this._fin = false;
+    this._opcode = 0;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragments = [];
+
+    this._state = GET_INFO;
+    this._loop = false;
+  }
+
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   * @private
+   */
+  _write(chunk, encoding, cb) {
+    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
+
+    this._bufferedBytes += chunk.length;
+    this._buffers.push(chunk);
+    this.startLoop(cb);
+  }
+
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(n) {
+    this._bufferedBytes -= n;
+
+    if (n === this._buffers[0].length) return this._buffers.shift();
+
+    if (n < this._buffers[0].length) {
+      const buf = this._buffers[0];
+      this._buffers[0] = buf.slice(n);
+      return buf.slice(0, n);
+    }
+
+    const dst = Buffer.allocUnsafe(n);
+
+    do {
+      const buf = this._buffers[0];
+      const offset = dst.length - n;
+
+      if (n >= buf.length) {
+        dst.set(this._buffers.shift(), offset);
+      } else {
+        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+        this._buffers[0] = buf.slice(n);
+      }
+
+      n -= buf.length;
+    } while (n > 0);
+
+    return dst;
+  }
+
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(cb) {
+    let err;
+    this._loop = true;
+
+    do {
+      switch (this._state) {
+        case GET_INFO:
+          err = this.getInfo();
+          break;
+        case GET_PAYLOAD_LENGTH_16:
+          err = this.getPayloadLength16();
+          break;
+        case GET_PAYLOAD_LENGTH_64:
+          err = this.getPayloadLength64();
+          break;
+        case GET_MASK:
+          this.getMask();
+          break;
+        case GET_DATA:
+          err = this.getData(cb);
+          break;
+        default:
+          // `INFLATING`
+          this._loop = false;
+          return;
+      }
+    } while (this._loop);
+
+    cb(err);
+  }
+
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getInfo() {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(2);
+
+    if ((buf[0] & 0x30) !== 0x00) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'RSV2 and RSV3 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_2_3'
+      );
+    }
+
+    const compressed = (buf[0] & 0x40) === 0x40;
+
+    if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'RSV1 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_1'
+      );
+    }
+
+    this._fin = (buf[0] & 0x80) === 0x80;
+    this._opcode = buf[0] & 0x0f;
+    this._payloadLength = buf[1] & 0x7f;
+
+    if (this._opcode === 0x00) {
+      if (compressed) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+      }
+
+      if (!this._fragmented) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'invalid opcode 0',
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+      }
+
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+      if (this._fragmented) {
+        this._loop = false;
+        return error(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+      }
+
+      this._compressed = compressed;
+    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+      if (!this._fin) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'FIN must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_FIN'
+        );
+      }
+
+      if (compressed) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+      }
+
+      if (this._payloadLength > 0x7d) {
+        this._loop = false;
+        return error(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+      }
+    } else {
+      this._loop = false;
+      return error(
+        RangeError,
+        `invalid opcode ${this._opcode}`,
+        true,
+        1002,
+        'WS_ERR_INVALID_OPCODE'
+      );
+    }
+
+    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+    this._masked = (buf[1] & 0x80) === 0x80;
+
+    if (this._isServer) {
+      if (!this._masked) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'MASK must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_MASK'
+        );
+      }
+    } else if (this._masked) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'MASK must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_MASK'
+      );
+    }
+
+    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+    else return this.haveLength();
+  }
+
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength16() {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    this._payloadLength = this.consume(2).readUInt16BE(0);
+    return this.haveLength();
+  }
+
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength64() {
+    if (this._bufferedBytes < 8) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(8);
+    const num = buf.readUInt32BE(0);
+
+    //
+    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+    // if payload length is greater than this number.
+    //
+    if (num > Math.pow(2, 53 - 32) - 1) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'Unsupported WebSocket frame: payload length > 2^53 - 1',
+        false,
+        1009,
+        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+      );
+    }
+
+    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+    return this.haveLength();
+  }
+
+  /**
+   * Payload length has been read.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  haveLength() {
+    if (this._payloadLength && this._opcode < 0x08) {
+      this._totalPayloadLength += this._payloadLength;
+      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'Max payload size exceeded',
+          false,
+          1009,
+          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+        );
+      }
+    }
+
+    if (this._masked) this._state = GET_MASK;
+    else this._state = GET_DATA;
+  }
+
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = false;
+      return;
+    }
+
+    this._mask = this.consume(4);
+    this._state = GET_DATA;
+  }
+
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  getData(cb) {
+    let data = EMPTY_BUFFER;
+
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = false;
+        return;
+      }
+
+      data = this.consume(this._payloadLength);
+      if (this._masked) unmask(data, this._mask);
+    }
+
+    if (this._opcode > 0x07) return this.controlMessage(data);
+
+    if (this._compressed) {
+      this._state = INFLATING;
+      this.decompress(data, cb);
+      return;
+    }
+
+    if (data.length) {
+      //
+      // This message is not compressed so its length is the sum of the payload
+      // length of all fragments.
+      //
+      this._messageLength = this._totalPayloadLength;
+      this._fragments.push(data);
+    }
+
+    return this.dataMessage();
+  }
+
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(data, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+      if (err) return cb(err);
+
+      if (buf.length) {
+        this._messageLength += buf.length;
+        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+          return cb(
+            error(
+              RangeError,
+              'Max payload size exceeded',
+              false,
+              1009,
+              'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+            )
+          );
+        }
+
+        this._fragments.push(buf);
+      }
+
+      const er = this.dataMessage();
+      if (er) return cb(er);
+
+      this.startLoop(cb);
+    });
+  }
+
+  /**
+   * Handles a data message.
+   *
+   * @return {(Error|undefined)} A possible error
+   * @private
+   */
+  dataMessage() {
+    if (this._fin) {
+      const messageLength = this._messageLength;
+      const fragments = this._fragments;
+
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragmented = 0;
+      this._fragments = [];
+
+      if (this._opcode === 2) {
+        let data;
+
+        if (this._binaryType === 'nodebuffer') {
+          data = concat(fragments, messageLength);
+        } else if (this._binaryType === 'arraybuffer') {
+          data = toArrayBuffer(concat(fragments, messageLength));
+        } else {
+          data = fragments;
+        }
+
+        this.emit('message', data, true);
+      } else {
+        const buf = concat(fragments, messageLength);
+
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          this._loop = false;
+          return error(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+        }
+
+        this.emit('message', buf, false);
+      }
+    }
+
+    this._state = GET_INFO;
+  }
+
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(data) {
+    if (this._opcode === 0x08) {
+      this._loop = false;
+
+      if (data.length === 0) {
+        this.emit('conclude', 1005, EMPTY_BUFFER);
+        this.end();
+      } else if (data.length === 1) {
+        return error(
+          RangeError,
+          'invalid payload length 1',
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+      } else {
+        const code = data.readUInt16BE(0);
+
+        if (!isValidStatusCode(code)) {
+          return error(
+            RangeError,
+            `invalid status code ${code}`,
+            true,
+            1002,
+            'WS_ERR_INVALID_CLOSE_CODE'
+          );
+        }
+
+        const buf = data.slice(2);
+
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          return error(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+        }
+
+        this.emit('conclude', code, buf);
+        this.end();
+      }
+    } else if (this._opcode === 0x09) {
+      this.emit('ping', data);
+    } else {
+      this.emit('pong', data);
+    }
+
+    this._state = GET_INFO;
+  }
+}
+
+module.exports = Receiver;
+
+/**
+ * Builds an error object.
+ *
+ * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+ * @param {String} message The error message
+ * @param {Boolean} prefix Specifies whether or not to add a default prefix to
+ *     `message`
+ * @param {Number} statusCode The status code
+ * @param {String} errorCode The exposed error code
+ * @return {(Error|RangeError)} The error
+ * @private
+ */
+function error(ErrorCtor, message, prefix, statusCode, errorCode) {
+  const err = new ErrorCtor(
+    prefix ? `Invalid WebSocket frame: ${message}` : message
+  );
+
+  Error.captureStackTrace(err, error);
+  err.code = errorCode;
+  err[kStatusCode] = statusCode;
+  return err;
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/sender.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/sender.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/sender.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,422 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls$" }] */
+
+'use strict';
+
+const net = require('net');
+const tls = require('tls');
+const { randomFillSync } = require('crypto');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const { EMPTY_BUFFER } = require('./constants');
+const { isValidStatusCode } = require('./validation');
+const { mask: applyMask, toBuffer } = require('./buffer-util');
+
+const mask = Buffer.alloc(4);
+
+/**
+ * HyBi Sender implementation.
+ */
+class Sender {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {(net.Socket|tls.Socket)} socket The connection socket
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   */
+  constructor(socket, extensions) {
+    this._extensions = extensions || {};
+    this._socket = socket;
+
+    this._firstFragment = true;
+    this._compress = false;
+
+    this._bufferedBytes = 0;
+    this._deflating = false;
+    this._queue = [];
+  }
+
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {Buffer} data The data to frame
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @return {Buffer[]} The framed data as a list of `Buffer` instances
+   * @public
+   */
+  static frame(data, options) {
+    const merge = options.mask && options.readOnly;
+    let offset = options.mask ? 6 : 2;
+    let payloadLength = data.length;
+
+    if (data.length >= 65536) {
+      offset += 8;
+      payloadLength = 127;
+    } else if (data.length > 125) {
+      offset += 2;
+      payloadLength = 126;
+    }
+
+    const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+
+    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+    if (options.rsv1) target[0] |= 0x40;
+
+    target[1] = payloadLength;
+
+    if (payloadLength === 126) {
+      target.writeUInt16BE(data.length, 2);
+    } else if (payloadLength === 127) {
+      target.writeUInt32BE(0, 2);
+      target.writeUInt32BE(data.length, 6);
+    }
+
+    if (!options.mask) return [target, data];
+
+    randomFillSync(mask, 0, 4);
+
+    target[1] |= 0x80;
+    target[offset - 4] = mask[0];
+    target[offset - 3] = mask[1];
+    target[offset - 2] = mask[2];
+    target[offset - 1] = mask[3];
+
+    if (merge) {
+      applyMask(data, mask, target, offset, data.length);
+      return [target];
+    }
+
+    applyMask(data, mask, data, 0, data.length);
+    return [target, data];
+  }
+
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {Number} [code] The status code component of the body
+   * @param {(String|Buffer)} [data] The message component of the body
+   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(code, data, mask, cb) {
+    let buf;
+
+    if (code === undefined) {
+      buf = EMPTY_BUFFER;
+    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+      throw new TypeError('First argument must be a valid error code number');
+    } else if (data === undefined || !data.length) {
+      buf = Buffer.allocUnsafe(2);
+      buf.writeUInt16BE(code, 0);
+    } else {
+      const length = Buffer.byteLength(data);
+
+      if (length > 123) {
+        throw new RangeError('The message must not be greater than 123 bytes');
+      }
+
+      buf = Buffer.allocUnsafe(2 + length);
+      buf.writeUInt16BE(code, 0);
+
+      if (typeof data === 'string') {
+        buf.write(data, 2);
+      } else {
+        buf.set(data, 2);
+      }
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doClose, buf, mask, cb]);
+    } else {
+      this.doClose(buf, mask, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a close message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  doClose(data, mask, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x08,
+        mask,
+        readOnly: false
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  ping(data, mask, cb) {
+    const buf = toBuffer(data);
+
+    if (buf.length > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doPing, buf, mask, toBuffer.readOnly, cb]);
+    } else {
+      this.doPing(buf, mask, toBuffer.readOnly, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a ping message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  doPing(data, mask, readOnly, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x09,
+        mask,
+        readOnly
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  pong(data, mask, cb) {
+    const buf = toBuffer(data);
+
+    if (buf.length > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doPong, buf, mask, toBuffer.readOnly, cb]);
+    } else {
+      this.doPong(buf, mask, toBuffer.readOnly, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a pong message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  doPong(data, mask, readOnly, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x0a,
+        mask,
+        readOnly
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+   *     or text
+   * @param {Boolean} [options.compress=false] Specifies whether or not to
+   *     compress `data`
+   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  send(data, options, cb) {
+    const buf = toBuffer(data);
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+    let opcode = options.binary ? 2 : 1;
+    let rsv1 = options.compress;
+
+    if (this._firstFragment) {
+      this._firstFragment = false;
+      if (
+        rsv1 &&
+        perMessageDeflate &&
+        perMessageDeflate.params[
+          perMessageDeflate._isServer
+            ? 'server_no_context_takeover'
+            : 'client_no_context_takeover'
+        ]
+      ) {
+        rsv1 = buf.length >= perMessageDeflate._threshold;
+      }
+      this._compress = rsv1;
+    } else {
+      rsv1 = false;
+      opcode = 0;
+    }
+
+    if (options.fin) this._firstFragment = true;
+
+    if (perMessageDeflate) {
+      const opts = {
+        fin: options.fin,
+        rsv1,
+        opcode,
+        mask: options.mask,
+        readOnly: toBuffer.readOnly
+      };
+
+      if (this._deflating) {
+        this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+      } else {
+        this.dispatch(buf, this._compress, opts, cb);
+      }
+    } else {
+      this.sendFrame(
+        Sender.frame(buf, {
+          fin: options.fin,
+          rsv1: false,
+          opcode,
+          mask: options.mask,
+          readOnly: toBuffer.readOnly
+        }),
+        cb
+      );
+    }
+  }
+
+  /**
+   * Dispatches a data message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     `data`
+   * @param {Object} options Options object
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  dispatch(data, compress, options, cb) {
+    if (!compress) {
+      this.sendFrame(Sender.frame(data, options), cb);
+      return;
+    }
+
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    this._bufferedBytes += data.length;
+    this._deflating = true;
+    perMessageDeflate.compress(data, options.fin, (_, buf) => {
+      if (this._socket.destroyed) {
+        const err = new Error(
+          'The socket was closed while data was being compressed'
+        );
+
+        if (typeof cb === 'function') cb(err);
+
+        for (let i = 0; i < this._queue.length; i++) {
+          const callback = this._queue[i][4];
+
+          if (typeof callback === 'function') callback(err);
+        }
+
+        return;
+      }
+
+      this._bufferedBytes -= data.length;
+      this._deflating = false;
+      options.readOnly = false;
+      this.sendFrame(Sender.frame(buf, options), cb);
+      this.dequeue();
+    });
+  }
+
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    while (!this._deflating && this._queue.length) {
+      const params = this._queue.shift();
+
+      this._bufferedBytes -= params[1].length;
+      Reflect.apply(params[0], this, params.slice(1));
+    }
+  }
+
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(params) {
+    this._bufferedBytes += params[1].length;
+    this._queue.push(params);
+  }
+
+  /**
+   * Sends a frame.
+   *
+   * @param {Buffer[]} list The frame to send
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  sendFrame(list, cb) {
+    if (list.length === 2) {
+      this._socket.cork();
+      this._socket.write(list[0]);
+      this._socket.write(list[1], cb);
+      this._socket.uncork();
+    } else {
+      this._socket.write(list[0], cb);
+    }
+  }
+}
+
+module.exports = Sender;
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/stream.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/stream.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/stream.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,180 @@
+'use strict';
+
+const { Duplex } = require('stream');
+
+/**
+ * Emits the `'close'` event on a stream.
+ *
+ * @param {Duplex} stream The stream.
+ * @private
+ */
+function emitClose(stream) {
+  stream.emit('close');
+}
+
+/**
+ * The listener of the `'end'` event.
+ *
+ * @private
+ */
+function duplexOnEnd() {
+  if (!this.destroyed && this._writableState.finished) {
+    this.destroy();
+  }
+}
+
+/**
+ * The listener of the `'error'` event.
+ *
+ * @param {Error} err The error
+ * @private
+ */
+function duplexOnError(err) {
+  this.removeListener('error', duplexOnError);
+  this.destroy();
+  if (this.listenerCount('error') === 0) {
+    // Do not suppress the throwing behavior.
+    this.emit('error', err);
+  }
+}
+
+/**
+ * Wraps a `WebSocket` in a duplex stream.
+ *
+ * @param {WebSocket} ws The `WebSocket` to wrap
+ * @param {Object} [options] The options for the `Duplex` constructor
+ * @return {Duplex} The duplex stream
+ * @public
+ */
+function createWebSocketStream(ws, options) {
+  let resumeOnReceiverDrain = true;
+  let terminateOnDestroy = true;
+
+  function receiverOnDrain() {
+    if (resumeOnReceiverDrain) ws._socket.resume();
+  }
+
+  if (ws.readyState === ws.CONNECTING) {
+    ws.once('open', function open() {
+      ws._receiver.removeAllListeners('drain');
+      ws._receiver.on('drain', receiverOnDrain);
+    });
+  } else {
+    ws._receiver.removeAllListeners('drain');
+    ws._receiver.on('drain', receiverOnDrain);
+  }
+
+  const duplex = new Duplex({
+    ...options,
+    autoDestroy: false,
+    emitClose: false,
+    objectMode: false,
+    writableObjectMode: false
+  });
+
+  ws.on('message', function message(msg, isBinary) {
+    const data =
+      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+
+    if (!duplex.push(data)) {
+      resumeOnReceiverDrain = false;
+      ws._socket.pause();
+    }
+  });
+
+  ws.once('error', function error(err) {
+    if (duplex.destroyed) return;
+
+    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+    //
+    // - If the `'error'` event is emitted before the `'open'` event, then
+    //   `ws.terminate()` is a noop as no socket is assigned.
+    // - Otherwise, the error is re-emitted by the listener of the `'error'`
+    //   event of the `Receiver` object. The listener already closes the
+    //   connection by calling `ws.close()`. This allows a close frame to be
+    //   sent to the other peer. If `ws.terminate()` is called right after this,
+    //   then the close frame might not be sent.
+    terminateOnDestroy = false;
+    duplex.destroy(err);
+  });
+
+  ws.once('close', function close() {
+    if (duplex.destroyed) return;
+
+    duplex.push(null);
+  });
+
+  duplex._destroy = function (err, callback) {
+    if (ws.readyState === ws.CLOSED) {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+      return;
+    }
+
+    let called = false;
+
+    ws.once('error', function error(err) {
+      called = true;
+      callback(err);
+    });
+
+    ws.once('close', function close() {
+      if (!called) callback(err);
+      process.nextTick(emitClose, duplex);
+    });
+
+    if (terminateOnDestroy) ws.terminate();
+  };
+
+  duplex._final = function (callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._final(callback);
+      });
+      return;
+    }
+
+    // If the value of the `_socket` property is `null` it means that `ws` is a
+    // client websocket and the handshake failed. In fact, when this happens, a
+    // socket is never assigned to the websocket. Wait for the `'error'` event
+    // that will be emitted by the websocket.
+    if (ws._socket === null) return;
+
+    if (ws._socket._writableState.finished) {
+      callback();
+      if (duplex._readableState.endEmitted) duplex.destroy();
+    } else {
+      ws._socket.once('finish', function finish() {
+        // `duplex` is not destroyed here because the `'end'` event will be
+        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+        callback();
+      });
+      ws.close();
+    }
+  };
+
+  duplex._read = function () {
+    if (ws.readyState === ws.OPEN && !resumeOnReceiverDrain) {
+      resumeOnReceiverDrain = true;
+      if (!ws._receiver._writableState.needDrain) ws._socket.resume();
+    }
+  };
+
+  duplex._write = function (chunk, encoding, callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._write(chunk, encoding, callback);
+      });
+      return;
+    }
+
+    ws.send(chunk, callback);
+  };
+
+  duplex.on('end', duplexOnEnd);
+  duplex.on('error', duplexOnError);
+  return duplex;
+}
+
+module.exports = createWebSocketStream;
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/subprotocol.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/subprotocol.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/subprotocol.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,62 @@
+'use strict';
+
+const { tokenChars } = require('./validation');
+
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+ *
+ * @param {String} header The field value of the header
+ * @return {Set} The subprotocol names
+ * @public
+ */
+function parse(header) {
+  const protocols = new Set();
+  let start = -1;
+  let end = -1;
+  let i = 0;
+
+  for (i; i < header.length; i++) {
+    const code = header.charCodeAt(i);
+
+    if (end === -1 && tokenChars[code] === 1) {
+      if (start === -1) start = i;
+    } else if (
+      i !== 0 &&
+      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+    ) {
+      if (end === -1 && start !== -1) end = i;
+    } else if (code === 0x2c /* ',' */) {
+      if (start === -1) {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+
+      if (end === -1) end = i;
+
+      const protocol = header.slice(start, end);
+
+      if (protocols.has(protocol)) {
+        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+      }
+
+      protocols.add(protocol);
+      start = end = -1;
+    } else {
+      throw new SyntaxError(`Unexpected character at index ${i}`);
+    }
+  }
+
+  if (start === -1 || end !== -1) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  const protocol = header.slice(start, i);
+
+  if (protocols.has(protocol)) {
+    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+  }
+
+  protocols.add(protocol);
+  return protocols;
+}
+
+module.exports = { parse };
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/validation.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/validation.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/validation.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,124 @@
+'use strict';
+
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+
+/**
+ * Checks if a status code is allowed in a close frame.
+ *
+ * @param {Number} code The status code
+ * @return {Boolean} `true` if the status code is valid, else `false`
+ * @public
+ */
+function isValidStatusCode(code) {
+  return (
+    (code >= 1000 &&
+      code <= 1014 &&
+      code !== 1004 &&
+      code !== 1005 &&
+      code !== 1006) ||
+    (code >= 3000 && code <= 4999)
+  );
+}
+
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function _isValidUTF8(buf) {
+  const len = buf.length;
+  let i = 0;
+
+  while (i < len) {
+    if ((buf[i] & 0x80) === 0) {
+      // 0xxxxxxx
+      i++;
+    } else if ((buf[i] & 0xe0) === 0xc0) {
+      // 110xxxxx 10xxxxxx
+      if (
+        i + 1 === len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i] & 0xfe) === 0xc0 // Overlong
+      ) {
+        return false;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) === 0xe0) {
+      // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
+        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
+      ) {
+        return false;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) === 0xf0) {
+      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i + 3] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
+        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
+        buf[i] > 0xf4 // > U+10FFFF
+      ) {
+        return false;
+      }
+
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+try {
+  const isValidUTF8 = require('utf-8-validate');
+
+  module.exports = {
+    isValidStatusCode,
+    isValidUTF8(buf) {
+      return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
+    },
+    tokenChars
+  };
+} catch (e) /* istanbul ignore next */ {
+  module.exports = {
+    isValidStatusCode,
+    isValidUTF8: _isValidUTF8,
+    tokenChars
+  };
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/websocket-server.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/websocket-server.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/websocket-server.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,485 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls|https$" }] */
+
+'use strict';
+
+const EventEmitter = require('events');
+const http = require('http');
+const https = require('https');
+const net = require('net');
+const tls = require('tls');
+const { createHash } = require('crypto');
+
+const extension = require('./extension');
+const PerMessageDeflate = require('./permessage-deflate');
+const subprotocol = require('./subprotocol');
+const WebSocket = require('./websocket');
+const { GUID, kWebSocket } = require('./constants');
+
+const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+
+const RUNNING = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+
+/**
+ * Class representing a WebSocket server.
+ *
+ * @extends EventEmitter
+ */
+class WebSocketServer extends EventEmitter {
+  /**
+   * Create a `WebSocketServer` instance.
+   *
+   * @param {Object} options Configuration options
+   * @param {Number} [options.backlog=511] The maximum length of the queue of
+   *     pending connections
+   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+   *     track clients
+   * @param {Function} [options.handleProtocols] A hook to handle protocols
+   * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+   *     size
+   * @param {Boolean} [options.noServer=false] Enable no server mode
+   * @param {String} [options.path] Accept only connections matching this path
+   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+   *     permessage-deflate
+   * @param {Number} [options.port] The port where to bind the server
+   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+   *     server to use
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [callback] A listener for the `listening` event
+   */
+  constructor(options, callback) {
+    super();
+
+    options = {
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: false,
+      perMessageDeflate: false,
+      handleProtocols: null,
+      clientTracking: true,
+      verifyClient: null,
+      noServer: false,
+      backlog: null, // use default (511 as implemented in net.js)
+      server: null,
+      host: null,
+      path: null,
+      port: null,
+      ...options
+    };
+
+    if (
+      (options.port == null && !options.server && !options.noServer) ||
+      (options.port != null && (options.server || options.noServer)) ||
+      (options.server && options.noServer)
+    ) {
+      throw new TypeError(
+        'One and only one of the "port", "server", or "noServer" options ' +
+          'must be specified'
+      );
+    }
+
+    if (options.port != null) {
+      this._server = http.createServer((req, res) => {
+        const body = http.STATUS_CODES[426];
+
+        res.writeHead(426, {
+          'Content-Length': body.length,
+          'Content-Type': 'text/plain'
+        });
+        res.end(body);
+      });
+      this._server.listen(
+        options.port,
+        options.host,
+        options.backlog,
+        callback
+      );
+    } else if (options.server) {
+      this._server = options.server;
+    }
+
+    if (this._server) {
+      const emitConnection = this.emit.bind(this, 'connection');
+
+      this._removeListeners = addListeners(this._server, {
+        listening: this.emit.bind(this, 'listening'),
+        error: this.emit.bind(this, 'error'),
+        upgrade: (req, socket, head) => {
+          this.handleUpgrade(req, socket, head, emitConnection);
+        }
+      });
+    }
+
+    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+    if (options.clientTracking) {
+      this.clients = new Set();
+      this._shouldEmitClose = false;
+    }
+
+    this.options = options;
+    this._state = RUNNING;
+  }
+
+  /**
+   * Returns the bound address, the address family name, and port of the server
+   * as reported by the operating system if listening on an IP socket.
+   * If the server is listening on a pipe or UNIX domain socket, the name is
+   * returned as a string.
+   *
+   * @return {(Object|String|null)} The address of the server
+   * @public
+   */
+  address() {
+    if (this.options.noServer) {
+      throw new Error('The server is operating in "noServer" mode');
+    }
+
+    if (!this._server) return null;
+    return this._server.address();
+  }
+
+  /**
+   * Stop the server from accepting new connections and emit the `'close'` event
+   * when all existing connections are closed.
+   *
+   * @param {Function} [cb] A one-time listener for the `'close'` event
+   * @public
+   */
+  close(cb) {
+    if (this._state === CLOSED) {
+      if (cb) {
+        this.once('close', () => {
+          cb(new Error('The server is not running'));
+        });
+      }
+
+      process.nextTick(emitClose, this);
+      return;
+    }
+
+    if (cb) this.once('close', cb);
+
+    if (this._state === CLOSING) return;
+    this._state = CLOSING;
+
+    if (this.options.noServer || this.options.server) {
+      if (this._server) {
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+      }
+
+      if (this.clients) {
+        if (!this.clients.size) {
+          process.nextTick(emitClose, this);
+        } else {
+          this._shouldEmitClose = true;
+        }
+      } else {
+        process.nextTick(emitClose, this);
+      }
+    } else {
+      const server = this._server;
+
+      this._removeListeners();
+      this._removeListeners = this._server = null;
+
+      //
+      // The HTTP/S server was created internally. Close it, and rely on its
+      // `'close'` event.
+      //
+      server.close(() => {
+        emitClose(this);
+      });
+    }
+  }
+
+  /**
+   * See if a given request should be handled by this server instance.
+   *
+   * @param {http.IncomingMessage} req Request object to inspect
+   * @return {Boolean} `true` if the request is valid, else `false`
+   * @public
+   */
+  shouldHandle(req) {
+    if (this.options.path) {
+      const index = req.url.indexOf('?');
+      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+
+      if (pathname !== this.options.path) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Handle a HTTP Upgrade request.
+   *
+   * @param {http.IncomingMessage} req The request object
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @public
+   */
+  handleUpgrade(req, socket, head, cb) {
+    socket.on('error', socketOnError);
+
+    const key =
+      req.headers['sec-websocket-key'] !== undefined
+        ? req.headers['sec-websocket-key']
+        : false;
+    const version = +req.headers['sec-websocket-version'];
+
+    if (
+      req.method !== 'GET' ||
+      req.headers.upgrade.toLowerCase() !== 'websocket' ||
+      !key ||
+      !keyRegex.test(key) ||
+      (version !== 8 && version !== 13) ||
+      !this.shouldHandle(req)
+    ) {
+      return abortHandshake(socket, 400);
+    }
+
+    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
+    let protocols = new Set();
+
+    if (secWebSocketProtocol !== undefined) {
+      try {
+        protocols = subprotocol.parse(secWebSocketProtocol);
+      } catch (err) {
+        return abortHandshake(socket, 400);
+      }
+    }
+
+    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
+    const extensions = {};
+
+    if (
+      this.options.perMessageDeflate &&
+      secWebSocketExtensions !== undefined
+    ) {
+      const perMessageDeflate = new PerMessageDeflate(
+        this.options.perMessageDeflate,
+        true,
+        this.options.maxPayload
+      );
+
+      try {
+        const offers = extension.parse(secWebSocketExtensions);
+
+        if (offers[PerMessageDeflate.extensionName]) {
+          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+        }
+      } catch (err) {
+        return abortHandshake(socket, 400);
+      }
+    }
+
+    //
+    // Optionally call external client verification handler.
+    //
+    if (this.options.verifyClient) {
+      const info = {
+        origin:
+          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+        secure: !!(req.socket.authorized || req.socket.encrypted),
+        req
+      };
+
+      if (this.options.verifyClient.length === 2) {
+        this.options.verifyClient(info, (verified, code, message, headers) => {
+          if (!verified) {
+            return abortHandshake(socket, code || 401, message, headers);
+          }
+
+          this.completeUpgrade(
+            extensions,
+            key,
+            protocols,
+            req,
+            socket,
+            head,
+            cb
+          );
+        });
+        return;
+      }
+
+      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+    }
+
+    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+  }
+
+  /**
+   * Upgrade the connection to WebSocket.
+   *
+   * @param {Object} extensions The accepted extensions
+   * @param {String} key The value of the `Sec-WebSocket-Key` header
+   * @param {Set} protocols The subprotocols
+   * @param {http.IncomingMessage} req The request object
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @throws {Error} If called more than once with the same socket
+   * @private
+   */
+  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+    //
+    // Destroy the socket if the client has already sent a FIN packet.
+    //
+    if (!socket.readable || !socket.writable) return socket.destroy();
+
+    if (socket[kWebSocket]) {
+      throw new Error(
+        'server.handleUpgrade() was called more than once with the same ' +
+          'socket, possibly due to a misconfiguration'
+      );
+    }
+
+    if (this._state > RUNNING) return abortHandshake(socket, 503);
+
+    const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+    const headers = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${digest}`
+    ];
+
+    const ws = new WebSocket(null);
+
+    if (protocols.size) {
+      //
+      // Optionally call external protocol selection handler.
+      //
+      const protocol = this.options.handleProtocols
+        ? this.options.handleProtocols(protocols, req)
+        : protocols.values().next().value;
+
+      if (protocol) {
+        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+        ws._protocol = protocol;
+      }
+    }
+
+    if (extensions[PerMessageDeflate.extensionName]) {
+      const params = extensions[PerMessageDeflate.extensionName].params;
+      const value = extension.format({
+        [PerMessageDeflate.extensionName]: [params]
+      });
+      headers.push(`Sec-WebSocket-Extensions: ${value}`);
+      ws._extensions = extensions;
+    }
+
+    //
+    // Allow external modification/inspection of handshake headers.
+    //
+    this.emit('headers', headers, req);
+
+    socket.write(headers.concat('\r\n').join('\r\n'));
+    socket.removeListener('error', socketOnError);
+
+    ws.setSocket(socket, head, {
+      maxPayload: this.options.maxPayload,
+      skipUTF8Validation: this.options.skipUTF8Validation
+    });
+
+    if (this.clients) {
+      this.clients.add(ws);
+      ws.on('close', () => {
+        this.clients.delete(ws);
+
+        if (this._shouldEmitClose && !this.clients.size) {
+          process.nextTick(emitClose, this);
+        }
+      });
+    }
+
+    cb(ws, req);
+  }
+}
+
+module.exports = WebSocketServer;
+
+/**
+ * Add event listeners on an `EventEmitter` using a map of <event, listener>
+ * pairs.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @param {Object.<String, Function>} map The listeners to add
+ * @return {Function} A function that will remove the added listeners when
+ *     called
+ * @private
+ */
+function addListeners(server, map) {
+  for (const event of Object.keys(map)) server.on(event, map[event]);
+
+  return function removeListeners() {
+    for (const event of Object.keys(map)) {
+      server.removeListener(event, map[event]);
+    }
+  };
+}
+
+/**
+ * Emit a `'close'` event on an `EventEmitter`.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @private
+ */
+function emitClose(server) {
+  server._state = CLOSED;
+  server.emit('close');
+}
+
+/**
+ * Handle premature socket errors.
+ *
+ * @private
+ */
+function socketOnError() {
+  this.destroy();
+}
+
+/**
+ * Close the connection when preconditions are not fulfilled.
+ *
+ * @param {(net.Socket|tls.Socket)} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} [message] The HTTP response body
+ * @param {Object} [headers] Additional HTTP response headers
+ * @private
+ */
+function abortHandshake(socket, code, message, headers) {
+  if (socket.writable) {
+    message = message || http.STATUS_CODES[code];
+    headers = {
+      Connection: 'close',
+      'Content-Type': 'text/html',
+      'Content-Length': Buffer.byteLength(message),
+      ...headers
+    };
+
+    socket.write(
+      `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+        Object.keys(headers)
+          .map((h) => `${h}: ${headers[h]}`)
+          .join('\r\n') +
+        '\r\n\r\n' +
+        message
+    );
+  }
+
+  socket.removeListener('error', socketOnError);
+  socket.destroy();
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/lib/websocket.js
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/lib/websocket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/lib/websocket.js	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,1149 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Readable$" }] */
+
+'use strict';
+
+const EventEmitter = require('events');
+const https = require('https');
+const http = require('http');
+const net = require('net');
+const tls = require('tls');
+const { randomBytes, createHash } = require('crypto');
+const { Readable } = require('stream');
+const { URL } = require('url');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const Receiver = require('./receiver');
+const Sender = require('./sender');
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  GUID,
+  kForOnEventAttribute,
+  kListener,
+  kStatusCode,
+  kWebSocket,
+  NOOP
+} = require('./constants');
+const {
+  EventTarget: { addEventListener, removeEventListener }
+} = require('./event-target');
+const { format, parse } = require('./extension');
+const { toBuffer } = require('./buffer-util');
+
+const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+const protocolVersions = [8, 13];
+const closeTimeout = 30 * 1000;
+
+/**
+ * Class representing a WebSocket.
+ *
+ * @extends EventEmitter
+ */
+class WebSocket extends EventEmitter {
+  /**
+   * Create a new `WebSocket`.
+   *
+   * @param {(String|URL)} address The URL to which to connect
+   * @param {(String|String[])} [protocols] The subprotocols
+   * @param {Object} [options] Connection options
+   */
+  constructor(address, protocols, options) {
+    super();
+
+    this._binaryType = BINARY_TYPES[0];
+    this._closeCode = 1006;
+    this._closeFrameReceived = false;
+    this._closeFrameSent = false;
+    this._closeMessage = EMPTY_BUFFER;
+    this._closeTimer = null;
+    this._extensions = {};
+    this._protocol = '';
+    this._readyState = WebSocket.CONNECTING;
+    this._receiver = null;
+    this._sender = null;
+    this._socket = null;
+
+    if (address !== null) {
+      this._bufferedAmount = 0;
+      this._isServer = false;
+      this._redirects = 0;
+
+      if (protocols === undefined) {
+        protocols = [];
+      } else if (!Array.isArray(protocols)) {
+        if (typeof protocols === 'object' && protocols !== null) {
+          options = protocols;
+          protocols = [];
+        } else {
+          protocols = [protocols];
+        }
+      }
+
+      initAsClient(this, address, protocols, options);
+    } else {
+      this._isServer = true;
+    }
+  }
+
+  /**
+   * This deviates from the WHATWG interface since ws doesn't support the
+   * required default "blob" type (instead we define a custom "nodebuffer"
+   * type).
+   *
+   * @type {String}
+   */
+  get binaryType() {
+    return this._binaryType;
+  }
+
+  set binaryType(type) {
+    if (!BINARY_TYPES.includes(type)) return;
+
+    this._binaryType = type;
+
+    //
+    // Allow to change `binaryType` on the fly.
+    //
+    if (this._receiver) this._receiver._binaryType = type;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get bufferedAmount() {
+    if (!this._socket) return this._bufferedAmount;
+
+    return this._socket._writableState.length + this._sender._bufferedBytes;
+  }
+
+  /**
+   * @type {String}
+   */
+  get extensions() {
+    return Object.keys(this._extensions).join();
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onclose() {
+    return null;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onerror() {
+    return null;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onopen() {
+    return null;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onmessage() {
+    return null;
+  }
+
+  /**
+   * @type {String}
+   */
+  get protocol() {
+    return this._protocol;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get readyState() {
+    return this._readyState;
+  }
+
+  /**
+   * @type {String}
+   */
+  get url() {
+    return this._url;
+  }
+
+  /**
+   * Set up the socket and the internal resources.
+   *
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Object} options Options object
+   * @param {Number} [options.maxPayload=0] The maximum allowed message size
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @private
+   */
+  setSocket(socket, head, options) {
+    const receiver = new Receiver({
+      binaryType: this.binaryType,
+      extensions: this._extensions,
+      isServer: this._isServer,
+      maxPayload: options.maxPayload,
+      skipUTF8Validation: options.skipUTF8Validation
+    });
+
+    this._sender = new Sender(socket, this._extensions);
+    this._receiver = receiver;
+    this._socket = socket;
+
+    receiver[kWebSocket] = this;
+    socket[kWebSocket] = this;
+
+    receiver.on('conclude', receiverOnConclude);
+    receiver.on('drain', receiverOnDrain);
+    receiver.on('error', receiverOnError);
+    receiver.on('message', receiverOnMessage);
+    receiver.on('ping', receiverOnPing);
+    receiver.on('pong', receiverOnPong);
+
+    socket.setTimeout(0);
+    socket.setNoDelay();
+
+    if (head.length > 0) socket.unshift(head);
+
+    socket.on('close', socketOnClose);
+    socket.on('data', socketOnData);
+    socket.on('end', socketOnEnd);
+    socket.on('error', socketOnError);
+
+    this._readyState = WebSocket.OPEN;
+    this.emit('open');
+  }
+
+  /**
+   * Emit the `'close'` event.
+   *
+   * @private
+   */
+  emitClose() {
+    if (!this._socket) {
+      this._readyState = WebSocket.CLOSED;
+      this.emit('close', this._closeCode, this._closeMessage);
+      return;
+    }
+
+    if (this._extensions[PerMessageDeflate.extensionName]) {
+      this._extensions[PerMessageDeflate.extensionName].cleanup();
+    }
+
+    this._receiver.removeAllListeners();
+    this._readyState = WebSocket.CLOSED;
+    this.emit('close', this._closeCode, this._closeMessage);
+  }
+
+  /**
+   * Start a closing handshake.
+   *
+   *          +----------+   +-----------+   +----------+
+   *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+   *    |     +----------+   +-----------+   +----------+     |
+   *          +----------+   +-----------+         |
+   * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
+   *          +----------+   +-----------+   |
+   *    |           |                        |   +---+        |
+   *                +------------------------+-->|fin| - - - -
+   *    |         +---+                      |   +---+
+   *     - - - - -|fin|<---------------------+
+   *              +---+
+   *
+   * @param {Number} [code] Status code explaining why the connection is closing
+   * @param {(String|Buffer)} [data] The reason why the connection is
+   *     closing
+   * @public
+   */
+  close(code, data) {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.readyState === WebSocket.CONNECTING) {
+      const msg = 'WebSocket was closed before the connection was established';
+      return abortHandshake(this, this._req, msg);
+    }
+
+    if (this.readyState === WebSocket.CLOSING) {
+      if (
+        this._closeFrameSent &&
+        (this._closeFrameReceived || this._receiver._writableState.errorEmitted)
+      ) {
+        this._socket.end();
+      }
+
+      return;
+    }
+
+    this._readyState = WebSocket.CLOSING;
+    this._sender.close(code, data, !this._isServer, (err) => {
+      //
+      // This error is handled by the `'error'` listener on the socket. We only
+      // want to know if the close frame has been sent here.
+      //
+      if (err) return;
+
+      this._closeFrameSent = true;
+
+      if (
+        this._closeFrameReceived ||
+        this._receiver._writableState.errorEmitted
+      ) {
+        this._socket.end();
+      }
+    });
+
+    //
+    // Specify a timeout for the closing handshake to complete.
+    //
+    this._closeTimer = setTimeout(
+      this._socket.destroy.bind(this._socket),
+      closeTimeout
+    );
+  }
+
+  /**
+   * Send a ping.
+   *
+   * @param {*} [data] The data to send
+   * @param {Boolean} [mask] Indicates whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when the ping is sent
+   * @public
+   */
+  ping(data, mask, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof data === 'function') {
+      cb = data;
+      data = mask = undefined;
+    } else if (typeof mask === 'function') {
+      cb = mask;
+      mask = undefined;
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    if (mask === undefined) mask = !this._isServer;
+    this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+  }
+
+  /**
+   * Send a pong.
+   *
+   * @param {*} [data] The data to send
+   * @param {Boolean} [mask] Indicates whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when the pong is sent
+   * @public
+   */
+  pong(data, mask, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof data === 'function') {
+      cb = data;
+      data = mask = undefined;
+    } else if (typeof mask === 'function') {
+      cb = mask;
+      mask = undefined;
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    if (mask === undefined) mask = !this._isServer;
+    this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+  }
+
+  /**
+   * Send a data message.
+   *
+   * @param {*} data The message to send
+   * @param {Object} [options] Options object
+   * @param {Boolean} [options.binary] Specifies whether `data` is binary or
+   *     text
+   * @param {Boolean} [options.compress] Specifies whether or not to compress
+   *     `data`
+   * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when data is written out
+   * @public
+   */
+  send(data, options, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof options === 'function') {
+      cb = options;
+      options = {};
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    const opts = {
+      binary: typeof data !== 'string',
+      mask: !this._isServer,
+      compress: true,
+      fin: true,
+      ...options
+    };
+
+    if (!this._extensions[PerMessageDeflate.extensionName]) {
+      opts.compress = false;
+    }
+
+    this._sender.send(data || EMPTY_BUFFER, opts, cb);
+  }
+
+  /**
+   * Forcibly close the connection.
+   *
+   * @public
+   */
+  terminate() {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.readyState === WebSocket.CONNECTING) {
+      const msg = 'WebSocket was closed before the connection was established';
+      return abortHandshake(this, this._req, msg);
+    }
+
+    if (this._socket) {
+      this._readyState = WebSocket.CLOSING;
+      this._socket.destroy();
+    }
+  }
+}
+
+/**
+ * @constant {Number} CONNECTING
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'CONNECTING', {
+  enumerable: true,
+  value: readyStates.indexOf('CONNECTING')
+});
+
+/**
+ * @constant {Number} CONNECTING
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'CONNECTING', {
+  enumerable: true,
+  value: readyStates.indexOf('CONNECTING')
+});
+
+/**
+ * @constant {Number} OPEN
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'OPEN', {
+  enumerable: true,
+  value: readyStates.indexOf('OPEN')
+});
+
+/**
+ * @constant {Number} OPEN
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'OPEN', {
+  enumerable: true,
+  value: readyStates.indexOf('OPEN')
+});
+
+/**
+ * @constant {Number} CLOSING
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'CLOSING', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSING')
+});
+
+/**
+ * @constant {Number} CLOSING
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'CLOSING', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSING')
+});
+
+/**
+ * @constant {Number} CLOSED
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket, 'CLOSED', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSED')
+});
+
+/**
+ * @constant {Number} CLOSED
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket.prototype, 'CLOSED', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSED')
+});
+
+[
+  'binaryType',
+  'bufferedAmount',
+  'extensions',
+  'protocol',
+  'readyState',
+  'url'
+].forEach((property) => {
+  Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+});
+
+//
+// Add the `onopen`, `onerror`, `onclose`, and `onmessage` attributes.
+// See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface
+//
+['open', 'error', 'close', 'message'].forEach((method) => {
+  Object.defineProperty(WebSocket.prototype, `on${method}`, {
+    enumerable: true,
+    get() {
+      for (const listener of this.listeners(method)) {
+        if (listener[kForOnEventAttribute]) return listener[kListener];
+      }
+
+      return null;
+    },
+    set(handler) {
+      for (const listener of this.listeners(method)) {
+        if (listener[kForOnEventAttribute]) {
+          this.removeListener(method, listener);
+          break;
+        }
+      }
+
+      if (typeof handler !== 'function') return;
+
+      this.addEventListener(method, handler, {
+        [kForOnEventAttribute]: true
+      });
+    }
+  });
+});
+
+WebSocket.prototype.addEventListener = addEventListener;
+WebSocket.prototype.removeEventListener = removeEventListener;
+
+module.exports = WebSocket;
+
+/**
+ * Initialize a WebSocket client.
+ *
+ * @param {WebSocket} websocket The client to initialize
+ * @param {(String|URL)} address The URL to which to connect
+ * @param {Array} protocols The subprotocols
+ * @param {Object} [options] Connection options
+ * @param {Boolean} [options.followRedirects=false] Whether or not to follow
+ *     redirects
+ * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
+ *     handshake request
+ * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+ *     size
+ * @param {Number} [options.maxRedirects=10] The maximum number of redirects
+ *     allowed
+ * @param {String} [options.origin] Value of the `Origin` or
+ *     `Sec-WebSocket-Origin` header
+ * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
+ *     permessage-deflate
+ * @param {Number} [options.protocolVersion=13] Value of the
+ *     `Sec-WebSocket-Version` header
+ * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+ *     not to skip UTF-8 validation for text and close messages
+ * @private
+ */
+function initAsClient(websocket, address, protocols, options) {
+  const opts = {
+    protocolVersion: protocolVersions[1],
+    maxPayload: 100 * 1024 * 1024,
+    skipUTF8Validation: false,
+    perMessageDeflate: true,
+    followRedirects: false,
+    maxRedirects: 10,
+    ...options,
+    createConnection: undefined,
+    socketPath: undefined,
+    hostname: undefined,
+    protocol: undefined,
+    timeout: undefined,
+    method: undefined,
+    host: undefined,
+    path: undefined,
+    port: undefined
+  };
+
+  if (!protocolVersions.includes(opts.protocolVersion)) {
+    throw new RangeError(
+      `Unsupported protocol version: ${opts.protocolVersion} ` +
+        `(supported versions: ${protocolVersions.join(', ')})`
+    );
+  }
+
+  let parsedUrl;
+
+  if (address instanceof URL) {
+    parsedUrl = address;
+    websocket._url = address.href;
+  } else {
+    try {
+      parsedUrl = new URL(address);
+    } catch (e) {
+      throw new SyntaxError(`Invalid URL: ${address}`);
+    }
+
+    websocket._url = address;
+  }
+
+  const isSecure = parsedUrl.protocol === 'wss:';
+  const isUnixSocket = parsedUrl.protocol === 'ws+unix:';
+
+  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isUnixSocket) {
+    throw new SyntaxError(
+      'The URL\'s protocol must be one of "ws:", "wss:", or "ws+unix:"'
+    );
+  }
+
+  if (isUnixSocket && !parsedUrl.pathname) {
+    throw new SyntaxError("The URL's pathname is empty");
+  }
+
+  if (parsedUrl.hash) {
+    throw new SyntaxError('The URL contains a fragment identifier');
+  }
+
+  const defaultPort = isSecure ? 443 : 80;
+  const key = randomBytes(16).toString('base64');
+  const get = isSecure ? https.get : http.get;
+  const protocolSet = new Set();
+  let perMessageDeflate;
+
+  opts.createConnection = isSecure ? tlsConnect : netConnect;
+  opts.defaultPort = opts.defaultPort || defaultPort;
+  opts.port = parsedUrl.port || defaultPort;
+  opts.host = parsedUrl.hostname.startsWith('[')
+    ? parsedUrl.hostname.slice(1, -1)
+    : parsedUrl.hostname;
+  opts.headers = {
+    'Sec-WebSocket-Version': opts.protocolVersion,
+    'Sec-WebSocket-Key': key,
+    Connection: 'Upgrade',
+    Upgrade: 'websocket',
+    ...opts.headers
+  };
+  opts.path = parsedUrl.pathname + parsedUrl.search;
+  opts.timeout = opts.handshakeTimeout;
+
+  if (opts.perMessageDeflate) {
+    perMessageDeflate = new PerMessageDeflate(
+      opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
+      false,
+      opts.maxPayload
+    );
+    opts.headers['Sec-WebSocket-Extensions'] = format({
+      [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+    });
+  }
+  if (protocols.length) {
+    for (const protocol of protocols) {
+      if (
+        typeof protocol !== 'string' ||
+        !subprotocolRegex.test(protocol) ||
+        protocolSet.has(protocol)
+      ) {
+        throw new SyntaxError(
+          'An invalid or duplicated subprotocol was specified'
+        );
+      }
+
+      protocolSet.add(protocol);
+    }
+
+    opts.headers['Sec-WebSocket-Protocol'] = protocols.join(',');
+  }
+  if (opts.origin) {
+    if (opts.protocolVersion < 13) {
+      opts.headers['Sec-WebSocket-Origin'] = opts.origin;
+    } else {
+      opts.headers.Origin = opts.origin;
+    }
+  }
+  if (parsedUrl.username || parsedUrl.password) {
+    opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+  }
+
+  if (isUnixSocket) {
+    const parts = opts.path.split(':');
+
+    opts.socketPath = parts[0];
+    opts.path = parts[1];
+  }
+
+  let req = (websocket._req = get(opts));
+
+  if (opts.timeout) {
+    req.on('timeout', () => {
+      abortHandshake(websocket, req, 'Opening handshake has timed out');
+    });
+  }
+
+  req.on('error', (err) => {
+    if (req === null || req.aborted) return;
+
+    req = websocket._req = null;
+    websocket._readyState = WebSocket.CLOSING;
+    websocket.emit('error', err);
+    websocket.emitClose();
+  });
+
+  req.on('response', (res) => {
+    const location = res.headers.location;
+    const statusCode = res.statusCode;
+
+    if (
+      location &&
+      opts.followRedirects &&
+      statusCode >= 300 &&
+      statusCode < 400
+    ) {
+      if (++websocket._redirects > opts.maxRedirects) {
+        abortHandshake(websocket, req, 'Maximum redirects exceeded');
+        return;
+      }
+
+      req.abort();
+
+      const addr = new URL(location, address);
+
+      initAsClient(websocket, addr, protocols, options);
+    } else if (!websocket.emit('unexpected-response', req, res)) {
+      abortHandshake(
+        websocket,
+        req,
+        `Unexpected server response: ${res.statusCode}`
+      );
+    }
+  });
+
+  req.on('upgrade', (res, socket, head) => {
+    websocket.emit('upgrade', res);
+
+    //
+    // The user may have closed the connection from a listener of the `upgrade`
+    // event.
+    //
+    if (websocket.readyState !== WebSocket.CONNECTING) return;
+
+    req = websocket._req = null;
+
+    const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+    if (res.headers['sec-websocket-accept'] !== digest) {
+      abortHandshake(websocket, socket, 'Invalid Sec-WebSocket-Accept header');
+      return;
+    }
+
+    const serverProt = res.headers['sec-websocket-protocol'];
+    let protError;
+
+    if (serverProt !== undefined) {
+      if (!protocolSet.size) {
+        protError = 'Server sent a subprotocol but none was requested';
+      } else if (!protocolSet.has(serverProt)) {
+        protError = 'Server sent an invalid subprotocol';
+      }
+    } else if (protocolSet.size) {
+      protError = 'Server sent no subprotocol';
+    }
+
+    if (protError) {
+      abortHandshake(websocket, socket, protError);
+      return;
+    }
+
+    if (serverProt) websocket._protocol = serverProt;
+
+    const secWebSocketExtensions = res.headers['sec-websocket-extensions'];
+
+    if (secWebSocketExtensions !== undefined) {
+      if (!perMessageDeflate) {
+        const message =
+          'Server sent a Sec-WebSocket-Extensions header but no extension ' +
+          'was requested';
+        abortHandshake(websocket, socket, message);
+        return;
+      }
+
+      let extensions;
+
+      try {
+        extensions = parse(secWebSocketExtensions);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Extensions header';
+        abortHandshake(websocket, socket, message);
+        return;
+      }
+
+      const extensionNames = Object.keys(extensions);
+
+      if (
+        extensionNames.length !== 1 ||
+        extensionNames[0] !== PerMessageDeflate.extensionName
+      ) {
+        const message = 'Server indicated an extension that was not requested';
+        abortHandshake(websocket, socket, message);
+        return;
+      }
+
+      try {
+        perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Extensions header';
+        abortHandshake(websocket, socket, message);
+        return;
+      }
+
+      websocket._extensions[PerMessageDeflate.extensionName] =
+        perMessageDeflate;
+    }
+
+    websocket.setSocket(socket, head, {
+      maxPayload: opts.maxPayload,
+      skipUTF8Validation: opts.skipUTF8Validation
+    });
+  });
+}
+
+/**
+ * Create a `net.Socket` and initiate a connection.
+ *
+ * @param {Object} options Connection options
+ * @return {net.Socket} The newly created socket used to start the connection
+ * @private
+ */
+function netConnect(options) {
+  options.path = options.socketPath;
+  return net.connect(options);
+}
+
+/**
+ * Create a `tls.TLSSocket` and initiate a connection.
+ *
+ * @param {Object} options Connection options
+ * @return {tls.TLSSocket} The newly created socket used to start the connection
+ * @private
+ */
+function tlsConnect(options) {
+  options.path = undefined;
+
+  if (!options.servername && options.servername !== '') {
+    options.servername = net.isIP(options.host) ? '' : options.host;
+  }
+
+  return tls.connect(options);
+}
+
+/**
+ * Abort the handshake and emit an error.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
+ *     abort or the socket to destroy
+ * @param {String} message The error message
+ * @private
+ */
+function abortHandshake(websocket, stream, message) {
+  websocket._readyState = WebSocket.CLOSING;
+
+  const err = new Error(message);
+  Error.captureStackTrace(err, abortHandshake);
+
+  if (stream.setHeader) {
+    stream.abort();
+
+    if (stream.socket && !stream.socket.destroyed) {
+      //
+      // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if
+      // called after the request completed. See
+      // https://github.com/websockets/ws/issues/1869.
+      //
+      stream.socket.destroy();
+    }
+
+    stream.once('abort', websocket.emitClose.bind(websocket));
+    websocket.emit('error', err);
+  } else {
+    stream.destroy(err);
+    stream.once('error', websocket.emit.bind(websocket, 'error'));
+    stream.once('close', websocket.emitClose.bind(websocket));
+  }
+}
+
+/**
+ * Handle cases where the `ping()`, `pong()`, or `send()` methods are called
+ * when the `readyState` attribute is `CLOSING` or `CLOSED`.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {*} [data] The data to send
+ * @param {Function} [cb] Callback
+ * @private
+ */
+function sendAfterClose(websocket, data, cb) {
+  if (data) {
+    const length = toBuffer(data).length;
+
+    //
+    // The `_bufferedAmount` property is used only when the peer is a client and
+    // the opening handshake fails. Under these circumstances, in fact, the
+    // `setSocket()` method is not called, so the `_socket` and `_sender`
+    // properties are set to `null`.
+    //
+    if (websocket._socket) websocket._sender._bufferedBytes += length;
+    else websocket._bufferedAmount += length;
+  }
+
+  if (cb) {
+    const err = new Error(
+      `WebSocket is not open: readyState ${websocket.readyState} ` +
+        `(${readyStates[websocket.readyState]})`
+    );
+    cb(err);
+  }
+}
+
+/**
+ * The listener of the `Receiver` `'conclude'` event.
+ *
+ * @param {Number} code The status code
+ * @param {Buffer} reason The reason for closing
+ * @private
+ */
+function receiverOnConclude(code, reason) {
+  const websocket = this[kWebSocket];
+
+  websocket._closeFrameReceived = true;
+  websocket._closeMessage = reason;
+  websocket._closeCode = code;
+
+  if (websocket._socket[kWebSocket] === undefined) return;
+
+  websocket._socket.removeListener('data', socketOnData);
+  process.nextTick(resume, websocket._socket);
+
+  if (code === 1005) websocket.close();
+  else websocket.close(code, reason);
+}
+
+/**
+ * The listener of the `Receiver` `'drain'` event.
+ *
+ * @private
+ */
+function receiverOnDrain() {
+  this[kWebSocket]._socket.resume();
+}
+
+/**
+ * The listener of the `Receiver` `'error'` event.
+ *
+ * @param {(RangeError|Error)} err The emitted error
+ * @private
+ */
+function receiverOnError(err) {
+  const websocket = this[kWebSocket];
+
+  if (websocket._socket[kWebSocket] !== undefined) {
+    websocket._socket.removeListener('data', socketOnData);
+
+    //
+    // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
+    // https://github.com/websockets/ws/issues/1940.
+    //
+    process.nextTick(resume, websocket._socket);
+
+    websocket.close(err[kStatusCode]);
+  }
+
+  websocket.emit('error', err);
+}
+
+/**
+ * The listener of the `Receiver` `'finish'` event.
+ *
+ * @private
+ */
+function receiverOnFinish() {
+  this[kWebSocket].emitClose();
+}
+
+/**
+ * The listener of the `Receiver` `'message'` event.
+ *
+ * @param {Buffer|ArrayBuffer|Buffer[])} data The message
+ * @param {Boolean} isBinary Specifies whether the message is binary or not
+ * @private
+ */
+function receiverOnMessage(data, isBinary) {
+  this[kWebSocket].emit('message', data, isBinary);
+}
+
+/**
+ * The listener of the `Receiver` `'ping'` event.
+ *
+ * @param {Buffer} data The data included in the ping frame
+ * @private
+ */
+function receiverOnPing(data) {
+  const websocket = this[kWebSocket];
+
+  websocket.pong(data, !websocket._isServer, NOOP);
+  websocket.emit('ping', data);
+}
+
+/**
+ * The listener of the `Receiver` `'pong'` event.
+ *
+ * @param {Buffer} data The data included in the pong frame
+ * @private
+ */
+function receiverOnPong(data) {
+  this[kWebSocket].emit('pong', data);
+}
+
+/**
+ * Resume a readable stream
+ *
+ * @param {Readable} stream The readable stream
+ * @private
+ */
+function resume(stream) {
+  stream.resume();
+}
+
+/**
+ * The listener of the `net.Socket` `'close'` event.
+ *
+ * @private
+ */
+function socketOnClose() {
+  const websocket = this[kWebSocket];
+
+  this.removeListener('close', socketOnClose);
+  this.removeListener('data', socketOnData);
+  this.removeListener('end', socketOnEnd);
+
+  websocket._readyState = WebSocket.CLOSING;
+
+  let chunk;
+
+  //
+  // The close frame might not have been received or the `'end'` event emitted,
+  // for example, if the socket was destroyed due to an error. Ensure that the
+  // `receiver` stream is closed after writing any remaining buffered data to
+  // it. If the readable side of the socket is in flowing mode then there is no
+  // buffered data as everything has been already written and `readable.read()`
+  // will return `null`. If instead, the socket is paused, any possible buffered
+  // data will be read as a single chunk.
+  //
+  if (
+    !this._readableState.endEmitted &&
+    !websocket._closeFrameReceived &&
+    !websocket._receiver._writableState.errorEmitted &&
+    (chunk = websocket._socket.read()) !== null
+  ) {
+    websocket._receiver.write(chunk);
+  }
+
+  websocket._receiver.end();
+
+  this[kWebSocket] = undefined;
+
+  clearTimeout(websocket._closeTimer);
+
+  if (
+    websocket._receiver._writableState.finished ||
+    websocket._receiver._writableState.errorEmitted
+  ) {
+    websocket.emitClose();
+  } else {
+    websocket._receiver.on('error', receiverOnFinish);
+    websocket._receiver.on('finish', receiverOnFinish);
+  }
+}
+
+/**
+ * The listener of the `net.Socket` `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function socketOnData(chunk) {
+  if (!this[kWebSocket]._receiver.write(chunk)) {
+    this.pause();
+  }
+}
+
+/**
+ * The listener of the `net.Socket` `'end'` event.
+ *
+ * @private
+ */
+function socketOnEnd() {
+  const websocket = this[kWebSocket];
+
+  websocket._readyState = WebSocket.CLOSING;
+  websocket._receiver.end();
+  this.end();
+}
+
+/**
+ * The listener of the `net.Socket` `'error'` event.
+ *
+ * @private
+ */
+function socketOnError() {
+  const websocket = this[kWebSocket];
+
+  this.removeListener('error', socketOnError);
+  this.on('error', NOOP);
+
+  if (websocket) {
+    websocket._readyState = WebSocket.CLOSING;
+    this.destroy();
+  }
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/package.json
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/package.json	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/package.json	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,95 @@
+{
+  "_from": "ws@~8.2.3",
+  "_id": "ws@8.2.3",
+  "_inBundle": false,
+  "_integrity": "sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==",
+  "_location": "/engine.io/ws",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "ws@~8.2.3",
+    "name": "ws",
+    "escapedName": "ws",
+    "rawSpec": "~8.2.3",
+    "saveSpec": null,
+    "fetchSpec": "~8.2.3"
+  },
+  "_requiredBy": [
+    "/engine.io"
+  ],
+  "_resolved": "https://registry.npmjs.org/ws/-/ws-8.2.3.tgz",
+  "_shasum": "63a56456db1b04367d0b721a0b80cae6d8becbba",
+  "_spec": "ws@~8.2.3",
+  "_where": "C:\\Users\\DELL\\Desktop\\bachelor-thesis\\trip-planner-front\\node_modules\\engine.io",
+  "author": {
+    "name": "Einar Otto Stangvik",
+    "email": "einaros@gmail.com",
+    "url": "http://2x.io"
+  },
+  "browser": "browser.js",
+  "bugs": {
+    "url": "https://github.com/websockets/ws/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "bufferutil": "^4.0.1",
+    "eslint": "^7.2.0",
+    "eslint-config-prettier": "^8.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "mocha": "^8.4.0",
+    "nyc": "^15.0.0",
+    "prettier": "^2.0.5",
+    "utf-8-validate": "^5.0.2"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "exports": {
+    "import": "./wrapper.mjs",
+    "require": "./index.js"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "lib/*.js",
+    "wrapper.mjs"
+  ],
+  "homepage": "https://github.com/websockets/ws",
+  "keywords": [
+    "HyBi",
+    "Push",
+    "RFC-6455",
+    "WebSocket",
+    "WebSockets",
+    "real-time"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "ws",
+  "peerDependencies": {
+    "bufferutil": "^4.0.1",
+    "utf-8-validate": "^5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/websockets/ws.git"
+  },
+  "scripts": {
+    "integration": "mocha --throw-deprecation test/*.integration.js",
+    "lint": "eslint --ignore-path .gitignore . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\"",
+    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js"
+  },
+  "version": "8.2.3"
+}
Index: trip-planner-front/node_modules/engine.io/node_modules/ws/wrapper.mjs
===================================================================
--- trip-planner-front/node_modules/engine.io/node_modules/ws/wrapper.mjs	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/node_modules/ws/wrapper.mjs	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,8 @@
+import createWebSocketStream from './lib/stream.js';
+import Receiver from './lib/receiver.js';
+import Sender from './lib/sender.js';
+import WebSocket from './lib/websocket.js';
+import WebSocketServer from './lib/websocket-server.js';
+
+export { createWebSocketStream, Receiver, Sender, WebSocket, WebSocketServer };
+export default WebSocket;
Index: trip-planner-front/node_modules/engine.io/package.json
===================================================================
--- trip-planner-front/node_modules/engine.io/package.json	(revision 59329aad30ff25ec5095bb7ffb78ddb59b7dc111)
+++ trip-planner-front/node_modules/engine.io/package.json	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -1,32 +1,26 @@
 {
-  "_args": [
-    [
-      "engine.io@4.1.1",
-      "C:\\Users\\DELL\\Desktop\\bachelor-thesis\\trip-planner-front"
-    ]
-  ],
-  "_development": true,
-  "_from": "engine.io@4.1.1",
-  "_id": "engine.io@4.1.1",
+  "_from": "engine.io@~6.1.0",
+  "_id": "engine.io@6.1.0",
   "_inBundle": false,
-  "_integrity": "sha512-t2E9wLlssQjGw0nluF6aYyfX8LwYU8Jj0xct+pAhfWfv/YrBn6TSNtEYsgxHIfaMqfrLx07czcMg9bMN6di+3w==",
+  "_integrity": "sha512-ErhZOVu2xweCjEfYcTdkCnEYUiZgkAcBBAhW4jbIvNG8SLU3orAqoJCiytZjYF7eTpVmmCrLDjLIEaPlUAs1uw==",
   "_location": "/engine.io",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "engine.io@4.1.1",
+    "raw": "engine.io@~6.1.0",
     "name": "engine.io",
     "escapedName": "engine.io",
-    "rawSpec": "4.1.1",
+    "rawSpec": "~6.1.0",
     "saveSpec": null,
-    "fetchSpec": "4.1.1"
+    "fetchSpec": "~6.1.0"
   },
   "_requiredBy": [
     "/socket.io"
   ],
-  "_resolved": "https://registry.npmjs.org/engine.io/-/engine.io-4.1.1.tgz",
-  "_spec": "4.1.1",
-  "_where": "C:\\Users\\DELL\\Desktop\\bachelor-thesis\\trip-planner-front",
+  "_resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.1.0.tgz",
+  "_shasum": "459eab0c3724899d7b63a20c3a6835cf92857939",
+  "_spec": "engine.io@~6.1.0",
+  "_where": "C:\\Users\\DELL\\Desktop\\bachelor-thesis\\trip-planner-front\\node_modules\\socket.io",
   "author": {
     "name": "Guillermo Rauch",
@@ -36,4 +30,5 @@
     "url": "https://github.com/socketio/engine.io/issues"
   },
+  "bundleDependencies": false,
   "contributors": [
     {
@@ -55,4 +50,7 @@
   ],
   "dependencies": {
+    "@types/cookie": "^0.4.1",
+    "@types/cors": "^2.8.12",
+    "@types/node": ">=10.0.0",
     "accepts": "~1.3.4",
     "base64id": "2.0.0",
@@ -60,30 +58,36 @@
     "cors": "~2.8.5",
     "debug": "~4.3.1",
-    "engine.io-parser": "~4.0.0",
-    "ws": "~7.4.2"
+    "engine.io-parser": "~5.0.0",
+    "ws": "~8.2.3"
   },
+  "deprecated": false,
   "description": "The realtime engine behind Socket.IO. Provides the foundation of a bidirectional connection between client and server",
   "devDependencies": {
     "babel-eslint": "^8.0.2",
     "eiows": "^3.3.0",
-    "engine.io-client": "4.1.1",
-    "engine.io-client-v3": "npm:engine.io-client@3.5.0",
-    "eslint": "^4.19.1",
-    "eslint-config-prettier": "^6.9.0",
+    "engine.io-client": "6.1.0",
+    "engine.io-client-v3": "npm:engine.io-client@3.5.2",
     "expect.js": "^0.3.1",
-    "mocha": "^4.0.1",
+    "mocha": "^9.1.3",
     "prettier": "^1.19.1",
-    "s": "0.1.1",
-    "superagent": "^3.8.1"
+    "rimraf": "^3.0.2",
+    "superagent": "^3.8.1",
+    "typescript": "^4.4.3",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.0.0"
   },
   "engines": {
     "node": ">=10.0.0"
   },
+  "exports": {
+    "import": "./wrapper.mjs",
+    "require": "./build/engine.io.js"
+  },
   "files": [
-    "lib/"
+    "build/",
+    "wrapper.mjs"
   ],
   "homepage": "https://github.com/socketio/engine.io",
   "license": "MIT",
-  "main": "lib/engine.io.js",
+  "main": "./build/engine.io.js",
   "name": "engine.io",
   "repository": {
@@ -92,9 +96,16 @@
   },
   "scripts": {
-    "format:check": "prettier --check 'lib/**/*.js' 'test/**/*.js'",
-    "format:fix": "prettier --write 'lib/**/*.js' 'test/**/*.js'",
-    "lint": "eslint lib/ test/ *.js",
-    "test": "npm run lint && npm run format:check && mocha && EIO_CLIENT=3 mocha && EIO_WS_ENGINE=eiows mocha"
+    "compile": "rimraf ./build && tsc",
+    "format:check": "prettier --check 'lib/**/*.ts' 'test/**/*.js'",
+    "format:fix": "prettier --write 'lib/**/*.ts' 'test/**/*.js'",
+    "prepack": "npm run compile",
+    "test": "npm run compile && npm run format:check && npm run test:default && npm run test:compat-v3 && npm run test:eiows && npm run test:uws",
+    "test:compat-v3": "EIO_CLIENT=3 mocha --exit",
+    "test:default": "mocha --bail --exit",
+    "test:eiows": "EIO_WS_ENGINE=eiows mocha --exit",
+    "test:uws": "EIO_WS_ENGINE=uws mocha --exit"
   },
-  "version": "4.1.1"
+  "type": "commonjs",
+  "types": "./build/engine.io.d.ts",
+  "version": "6.1.0"
 }
Index: trip-planner-front/node_modules/engine.io/wrapper.mjs
===================================================================
--- trip-planner-front/node_modules/engine.io/wrapper.mjs	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
+++ trip-planner-front/node_modules/engine.io/wrapper.mjs	(revision e29cc2ea91f8c99a4329f6d20188305dfd752279)
@@ -0,0 +1,3 @@
+import lib from "./build/engine.io.js";
+
+export const { Server, Socket, Transport, transports, listen, attach, parser, protocol } = lib;
