Index: trip-planner-front/node_modules/socket.io/dist/broadcast-operator.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/broadcast-operator.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
+++ trip-planner-front/node_modules/socket.io/dist/broadcast-operator.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -0,0 +1,144 @@
+import type { BroadcastFlags, Room, SocketId } from "socket.io-adapter";
+import { Handshake } from "./socket";
+import type { Adapter } from "socket.io-adapter";
+import type { EventParams, EventNames, EventsMap, TypedEventBroadcaster } from "./typed-events";
+export declare class BroadcastOperator<EmitEvents extends EventsMap> implements TypedEventBroadcaster<EmitEvents> {
+    private readonly adapter;
+    private readonly rooms;
+    private readonly exceptRooms;
+    private readonly flags;
+    constructor(adapter: Adapter, rooms?: Set<Room>, exceptRooms?: Set<Room>, flags?: BroadcastFlags);
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    to(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    except(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    compress(compress: boolean): BroadcastOperator<EmitEvents>;
+    /**
+     * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
+     * receive messages (because of network slowness or other issues, or because they’re connected through long polling
+     * and is in the middle of a request-response cycle).
+     *
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    get volatile(): BroadcastOperator<EmitEvents>;
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    get local(): BroadcastOperator<EmitEvents>;
+    /**
+     * Emits to all clients.
+     *
+     * @return Always true
+     * @public
+     */
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    /**
+     * Gets a list of clients.
+     *
+     * @public
+     */
+    allSockets(): Promise<Set<SocketId>>;
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets(): Promise<RemoteSocket<EmitEvents>[]>;
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsJoin(room: Room | Room[]): void;
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsLeave(room: Room | Room[]): void;
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param close - whether to close the underlying connection
+     * @public
+     */
+    disconnectSockets(close?: boolean): void;
+}
+/**
+ * Format of the data when the Socket instance exists on another Socket.IO server
+ */
+interface SocketDetails {
+    id: SocketId;
+    handshake: Handshake;
+    rooms: Room[];
+    data: any;
+}
+/**
+ * Expose of subset of the attributes and methods of the Socket class
+ */
+export declare class RemoteSocket<EmitEvents extends EventsMap> implements TypedEventBroadcaster<EmitEvents> {
+    readonly id: SocketId;
+    readonly handshake: Handshake;
+    readonly rooms: Set<Room>;
+    readonly data: any;
+    private readonly operator;
+    constructor(adapter: Adapter, details: SocketDetails);
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    /**
+     * Joins a room.
+     *
+     * @param {String|Array} room - room or array of rooms
+     * @public
+     */
+    join(room: Room | Room[]): void;
+    /**
+     * Leaves a room.
+     *
+     * @param {String} room
+     * @public
+     */
+    leave(room: Room): void;
+    /**
+     * Disconnects this client.
+     *
+     * @param {Boolean} close - if `true`, closes the underlying connection
+     * @return {Socket} self
+     *
+     * @public
+     */
+    disconnect(close?: boolean): this;
+}
+export {};
Index: trip-planner-front/node_modules/socket.io/dist/broadcast-operator.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/broadcast-operator.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
+++ trip-planner-front/node_modules/socket.io/dist/broadcast-operator.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteSocket = exports.BroadcastOperator = void 0;
+const socket_1 = require("./socket");
+const socket_io_parser_1 = require("socket.io-parser");
+class BroadcastOperator {
+    constructor(adapter, rooms = new Set(), exceptRooms = new Set(), flags = {}) {
+        this.adapter = adapter;
+        this.rooms = rooms;
+        this.exceptRooms = exceptRooms;
+        this.flags = flags;
+    }
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    to(room) {
+        const rooms = new Set(this.rooms);
+        if (Array.isArray(room)) {
+            room.forEach((r) => rooms.add(r));
+        }
+        else {
+            rooms.add(room);
+        }
+        return new BroadcastOperator(this.adapter, rooms, this.exceptRooms, this.flags);
+    }
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    in(room) {
+        return this.to(room);
+    }
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    except(room) {
+        const exceptRooms = new Set(this.exceptRooms);
+        if (Array.isArray(room)) {
+            room.forEach((r) => exceptRooms.add(r));
+        }
+        else {
+            exceptRooms.add(room);
+        }
+        return new BroadcastOperator(this.adapter, this.rooms, exceptRooms, this.flags);
+    }
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    compress(compress) {
+        const flags = Object.assign({}, this.flags, { compress });
+        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
+     * receive messages (because of network slowness or other issues, or because they’re connected through long polling
+     * and is in the middle of a request-response cycle).
+     *
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    get volatile() {
+        const flags = Object.assign({}, this.flags, { volatile: true });
+        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    get local() {
+        const flags = Object.assign({}, this.flags, { local: true });
+        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+    }
+    /**
+     * Emits to all clients.
+     *
+     * @return Always true
+     * @public
+     */
+    emit(ev, ...args) {
+        if (socket_1.RESERVED_EVENTS.has(ev)) {
+            throw new Error(`"${ev}" is a reserved event name`);
+        }
+        // set up packet object
+        const data = [ev, ...args];
+        const packet = {
+            type: socket_io_parser_1.PacketType.EVENT,
+            data: data,
+        };
+        if ("function" == typeof data[data.length - 1]) {
+            throw new Error("Callbacks are not supported when broadcasting");
+        }
+        this.adapter.broadcast(packet, {
+            rooms: this.rooms,
+            except: this.exceptRooms,
+            flags: this.flags,
+        });
+        return true;
+    }
+    /**
+     * Gets a list of clients.
+     *
+     * @public
+     */
+    allSockets() {
+        if (!this.adapter) {
+            throw new Error("No adapter for this namespace, are you trying to get the list of clients of a dynamic namespace?");
+        }
+        return this.adapter.sockets(this.rooms);
+    }
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets() {
+        return this.adapter
+            .fetchSockets({
+            rooms: this.rooms,
+            except: this.exceptRooms,
+        })
+            .then((sockets) => {
+            return sockets.map((socket) => {
+                if (socket instanceof socket_1.Socket) {
+                    // FIXME the TypeScript compiler complains about missing private properties
+                    return socket;
+                }
+                else {
+                    return new RemoteSocket(this.adapter, socket);
+                }
+            });
+        });
+    }
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsJoin(room) {
+        this.adapter.addSockets({
+            rooms: this.rooms,
+            except: this.exceptRooms,
+        }, Array.isArray(room) ? room : [room]);
+    }
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsLeave(room) {
+        this.adapter.delSockets({
+            rooms: this.rooms,
+            except: this.exceptRooms,
+        }, Array.isArray(room) ? room : [room]);
+    }
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param close - whether to close the underlying connection
+     * @public
+     */
+    disconnectSockets(close = false) {
+        this.adapter.disconnectSockets({
+            rooms: this.rooms,
+            except: this.exceptRooms,
+        }, close);
+    }
+}
+exports.BroadcastOperator = BroadcastOperator;
+/**
+ * Expose of subset of the attributes and methods of the Socket class
+ */
+class RemoteSocket {
+    constructor(adapter, details) {
+        this.id = details.id;
+        this.handshake = details.handshake;
+        this.rooms = new Set(details.rooms);
+        this.data = details.data;
+        this.operator = new BroadcastOperator(adapter, new Set([this.id]));
+    }
+    emit(ev, ...args) {
+        return this.operator.emit(ev, ...args);
+    }
+    /**
+     * Joins a room.
+     *
+     * @param {String|Array} room - room or array of rooms
+     * @public
+     */
+    join(room) {
+        return this.operator.socketsJoin(room);
+    }
+    /**
+     * Leaves a room.
+     *
+     * @param {String} room
+     * @public
+     */
+    leave(room) {
+        return this.operator.socketsLeave(room);
+    }
+    /**
+     * Disconnects this client.
+     *
+     * @param {Boolean} close - if `true`, closes the underlying connection
+     * @return {Socket} self
+     *
+     * @public
+     */
+    disconnect(close = false) {
+        this.operator.disconnectSockets(close);
+        return this;
+    }
+}
+exports.RemoteSocket = RemoteSocket;
Index: trip-planner-front/node_modules/socket.io/dist/client.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/client.d.ts	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/client.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -3,7 +3,15 @@
 import type { IncomingMessage } from "http";
 import type { Server } from "./index";
+import type { EventsMap } from "./typed-events";
 import type { Socket } from "./socket";
-export declare class Client {
-    readonly conn: any;
+import type { Socket as RawSocket } from "engine.io";
+interface WriteOptions {
+    compress?: boolean;
+    volatile?: boolean;
+    preEncoded?: boolean;
+    wsPreEncoded?: string;
+}
+export declare class Client<ListenEvents extends EventsMap, EmitEvents extends EventsMap, ServerSideEvents extends EventsMap, SocketData = any> {
+    readonly conn: RawSocket;
     private readonly id;
     private readonly server;
@@ -20,5 +28,5 @@
      * @package
      */
-    constructor(server: Server, conn: Socket);
+    constructor(server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, conn: any);
     /**
      * @return the reference to the request that originated the Engine.IO connection
@@ -61,5 +69,5 @@
      * @private
      */
-    _remove(socket: Socket): void;
+    _remove(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>): void;
     /**
      * Closes the underlying connection.
@@ -75,5 +83,6 @@
      * @private
      */
-    _packet(packet: Packet, opts?: any): void;
+    _packet(packet: Packet | any[], opts?: WriteOptions): void;
+    private writeToEngine;
     /**
      * Called with incoming transport data.
@@ -108,2 +117,3 @@
     private destroy;
 }
+export {};
Index: trip-planner-front/node_modules/socket.io/dist/client.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/client.js	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/client.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -71,5 +71,4 @@
         this.server._checkNamespace(name, auth, (dynamicNspName) => {
             if (dynamicNspName) {
-                debug("dynamic namespace %s was created", dynamicNspName);
                 this.doConnect(name, auth);
             }
@@ -151,29 +150,24 @@
      * @private
      */
-    _packet(packet, opts) {
-        opts = opts || {};
-        const self = this;
-        // this writes to the actual connection
-        function writeToEngine(encodedPackets) {
-            // TODO clarify this.
-            if (opts.volatile && !self.conn.transport.writable)
-                return;
-            for (let i = 0; i < encodedPackets.length; i++) {
-                self.conn.write(encodedPackets[i], { compress: opts.compress });
-            }
-        }
-        if ("open" === this.conn.readyState) {
-            debug("writing packet %j", packet);
-            if (!opts.preEncoded) {
-                // not broadcasting, need to encode
-                writeToEngine(this.encoder.encode(packet)); // encode, then write results to engine
-            }
-            else {
-                // a broadcast pre-encodes a packet
-                writeToEngine(packet);
-            }
-        }
-        else {
+    _packet(packet, opts = {}) {
+        if (this.conn.readyState !== "open") {
             debug("ignoring packet write %j", packet);
+            return;
+        }
+        const encodedPackets = opts.preEncoded
+            ? packet // previous versions of the adapter incorrectly used socket.packet() instead of writeToEngine()
+            : this.encoder.encode(packet);
+        this.writeToEngine(encodedPackets, opts);
+    }
+    writeToEngine(encodedPackets, opts) {
+        if (opts.volatile && !this.conn.transport.writable) {
+            debug("volatile packet is discarded since the transport is not currently writable");
+            return;
+        }
+        const packets = Array.isArray(encodedPackets)
+            ? encodedPackets
+            : [encodedPackets];
+        for (const encodedPacket of packets) {
+            this.conn.write(encodedPacket, opts);
         }
     }
Index: trip-planner-front/node_modules/socket.io/dist/index.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/index.d.ts	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/index.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -1,110 +1,17 @@
 /// <reference types="node" />
 import http = require("http");
-import { EventEmitter } from "events";
-import { ExtendedError, Namespace } from "./namespace";
+import { ServerOptions as EngineOptions, AttachOptions } from "engine.io";
+import { ExtendedError, Namespace, ServerReservedEventsMap } from "./namespace";
 import { Adapter, Room, SocketId } from "socket.io-adapter";
 import * as parser from "socket.io-parser";
 import type { Encoder } from "socket.io-parser";
 import { Socket } from "./socket";
-import type { CookieSerializeOptions } from "cookie";
-import type { CorsOptions } from "cors";
-declare type Transport = "polling" | "websocket";
+import type { BroadcastOperator, RemoteSocket } from "./broadcast-operator";
+import { EventsMap, DefaultEventsMap, EventParams, StrictEventEmitter, EventNames } from "./typed-events";
 declare type ParentNspNameMatchFn = (name: string, auth: {
     [key: string]: any;
 }, fn: (err: Error | null, success: boolean) => void) => void;
-interface EngineOptions {
-    /**
-     * how many ms without a pong packet to consider the connection closed
-     * @default 5000
-     */
-    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: http.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). Default value is ws.
-     * An alternative c++ addon is also available by installing uws module.
-     */
-    wsEngine: string;
-    /**
-     * 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 | 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;
-}
-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;
-}
-interface EngineAttachOptions extends EngineOptions, AttachOptions {
-}
-interface ServerOptions extends EngineAttachOptions {
+declare type AdapterConstructor = typeof Adapter | ((nsp: Namespace) => Adapter);
+interface ServerOptions extends EngineOptions, AttachOptions {
     /**
      * name of the path to capture
@@ -121,5 +28,5 @@
      * @default the in-memory adapter (https://github.com/socketio/socket.io-adapter)
      */
-    adapter: any;
+    adapter: AdapterConstructor;
     /**
      * the parser to use
@@ -133,6 +40,17 @@
     connectTimeout: number;
 }
-export declare class Server extends EventEmitter {
-    readonly sockets: Namespace;
+export declare class Server<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents, ServerSideEvents extends EventsMap = DefaultEventsMap, SocketData = any> extends StrictEventEmitter<ServerSideEvents, EmitEvents, ServerReservedEventsMap<ListenEvents, EmitEvents, ServerSideEvents, SocketData>> {
+    readonly sockets: Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
+    /**
+     * A reference to the underlying Engine.IO server.
+     *
+     * Example:
+     *
+     * <code>
+     *   const clientsCount = io.engine.clientsCount;
+     * </code>
+     *
+     */
+    engine: any;
     /** @private */
     readonly _parser: typeof parser;
@@ -142,5 +60,5 @@
      * @private
      */
-    _nsps: Map<string, Namespace>;
+    _nsps: Map<string, Namespace<ListenEvents, EmitEvents, ServerSideEvents>>;
     private parentNsps;
     private _adapter?;
@@ -148,5 +66,4 @@
     private opts;
     private eio;
-    private engine;
     private _path;
     private clientPathRegex;
@@ -187,5 +104,5 @@
     _checkNamespace(name: string, auth: {
         [key: string]: any;
-    }, fn: (nsp: Namespace | false) => void): void;
+    }, fn: (nsp: Namespace<ListenEvents, EmitEvents, ServerSideEvents> | false) => void): void;
     /**
      * Sets the client serving path.
@@ -213,7 +130,6 @@
      * @public
      */
-    adapter(): typeof Adapter | undefined;
-    adapter(v: typeof Adapter): this;
-    adapter(v?: typeof Adapter): typeof Adapter | undefined | this;
+    adapter(): AdapterConstructor | undefined;
+    adapter(v: AdapterConstructor): this;
     /**
      * Attaches socket.io to a server or port.
@@ -234,4 +150,5 @@
      */
     attach(srv: http.Server | number, opts?: Partial<ServerOptions>): this;
+    attachApp(app: any, opts?: Partial<ServerOptions>): void;
     /**
      * Initialize engine
@@ -287,5 +204,5 @@
      * @public
      */
-    of(name: string | RegExp | ParentNspNameMatchFn, fn?: (socket: Socket) => void): Namespace;
+    of(name: string | RegExp | ParentNspNameMatchFn, fn?: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>) => void): Namespace<ListenEvents, EmitEvents, ServerSideEvents>;
     /**
      * Closes server connection
@@ -301,21 +218,29 @@
      * @public
      */
-    use(fn: (socket: Socket, next: (err?: ExtendedError) => void) => void): this;
+    use(fn: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, next: (err?: ExtendedError) => void) => void): this;
     /**
      * Targets a room when emitting.
      *
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Excludes a room when emitting.
+     *
      * @param name
      * @return self
      * @public
      */
-    to(name: Room): this;
-    /**
-     * Targets a room when emitting.
-     *
-     * @param name
-     * @return self
-     * @public
-     */
-    in(name: Room): this;
+    except(name: Room | Room[]): BroadcastOperator<EmitEvents>;
     /**
      * Sends a `message` event to all clients.
@@ -324,5 +249,5 @@
      * @public
      */
-    send(...args: readonly any[]): this;
+    send(...args: EventParams<EmitEvents, "message">): this;
     /**
      * Sends a `message` event to all clients.
@@ -331,5 +256,13 @@
      * @public
      */
-    write(...args: readonly any[]): this;
+    write(...args: EventParams<EmitEvents, "message">): this;
+    /**
+     * Emit a packet to other Socket.IO servers
+     *
+     * @param ev - the event name
+     * @param args - an array of arguments, which may include an acknowledgement callback at the end
+     * @public
+     */
+    serverSideEmit<Ev extends EventNames<ServerSideEvents>>(ev: Ev, ...args: EventParams<ServerSideEvents, Ev>): boolean;
     /**
      * Gets a list of socket ids.
@@ -345,5 +278,5 @@
      * @public
      */
-    compress(compress: boolean): this;
+    compress(compress: boolean): BroadcastOperator<EmitEvents>;
     /**
      * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
@@ -354,5 +287,5 @@
      * @public
      */
-    get volatile(): this;
+    get volatile(): BroadcastOperator<EmitEvents>;
     /**
      * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
@@ -361,5 +294,32 @@
      * @public
      */
-    get local(): this;
+    get local(): BroadcastOperator<EmitEvents>;
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets(): Promise<RemoteSocket<EmitEvents>[]>;
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsJoin(room: Room | Room[]): void;
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsLeave(room: Room | Room[]): void;
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param close - whether to close the underlying connection
+     * @public
+     */
+    disconnectSockets(close?: boolean): void;
 }
-export { Socket, ServerOptions, Namespace };
+export { Socket, ServerOptions, Namespace, BroadcastOperator, RemoteSocket };
Index: trip-planner-front/node_modules/socket.io/dist/index.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/index.js	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/index.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -30,5 +30,5 @@
 const stream_1 = require("stream");
 const path = require("path");
-const engine = require("engine.io");
+const engine_io_1 = require("engine.io");
 const client_1 = require("./client");
 const events_1 = require("events");
@@ -41,8 +41,10 @@
 const socket_1 = require("./socket");
 Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_1.Socket; } });
-const debug = debug_1.default("socket.io:server");
+const typed_events_1 = require("./typed-events");
+const uws_js_1 = require("./uws.js");
+const debug = (0, debug_1.default)("socket.io:server");
 const clientVersion = require("../package.json").version;
 const dotMapRegex = /\.map/;
-class Server extends events_1.EventEmitter {
+class Server extends typed_events_1.StrictEventEmitter {
     constructor(srv, opts = {}) {
         super();
@@ -66,5 +68,5 @@
         this.sockets = this.of("/");
         this.opts = opts;
-        if (srv)
+        if (srv || typeof srv == "number")
             this.attach(srv);
     }
@@ -95,9 +97,16 @@
             nextFn.value(name, auth, (err, allow) => {
                 if (err || !allow) {
-                    run();
+                    return run();
                 }
-                else {
-                    fn(this.parentNsps.get(nextFn.value).createChild(name));
+                if (this._nsps.has(name)) {
+                    // the namespace was created in the meantime
+                    debug("dynamic namespace %s already exists", name);
+                    return fn(this._nsps.get(name));
                 }
+                const namespace = this.parentNsps.get(nextFn.value).createChild(name);
+                debug("dynamic namespace %s was created", name);
+                // @ts-ignore
+                this.sockets.emitReserved("new_namespace", namespace);
+                fn(namespace);
             });
         };
@@ -111,5 +120,5 @@
         this.clientPathRegex = new RegExp("^" +
             escapedPath +
-            "/socket\\.io(\\.min|\\.msgpack\\.min)?\\.js(\\.map)?$");
+            "/socket\\.io(\\.msgpack|\\.esm)?(\\.min)?\\.js(\\.map)?(?:\\?|$)");
         return this;
     }
@@ -174,4 +183,52 @@
         return this;
     }
+    attachApp(app /*: TemplatedApp */, opts = {}) {
+        // merge the options passed to the Socket.IO server
+        Object.assign(opts, this.opts);
+        // set engine.io path to `/socket.io`
+        opts.path = opts.path || this._path;
+        // initialize engine
+        debug("creating uWebSockets.js-based engine with opts %j", opts);
+        const engine = new engine_io_1.uServer(opts);
+        engine.attach(app, opts);
+        // bind to engine events
+        this.bind(engine);
+        if (this._serveClient) {
+            // attach static file serving
+            app.get(`${this._path}/*`, (res, req) => {
+                if (!this.clientPathRegex.test(req.getUrl())) {
+                    req.setYield(true);
+                    return;
+                }
+                const filename = req
+                    .getUrl()
+                    .replace(this._path, "")
+                    .replace(/\?.*$/, "")
+                    .replace(/^\//, "");
+                const isMap = dotMapRegex.test(filename);
+                const type = isMap ? "map" : "source";
+                // Per the standard, ETags must be quoted:
+                // https://tools.ietf.org/html/rfc7232#section-2.3
+                const expectedEtag = '"' + clientVersion + '"';
+                const weakEtag = "W/" + expectedEtag;
+                const etag = req.getHeader("if-none-match");
+                if (etag) {
+                    if (expectedEtag === etag || weakEtag === etag) {
+                        debug("serve client %s 304", type);
+                        res.writeStatus("304 Not Modified");
+                        res.end();
+                        return;
+                    }
+                }
+                debug("serve client %s", type);
+                res.writeHeader("cache-control", "public, max-age=0");
+                res.writeHeader("content-type", "application/" + (isMap ? "json" : "javascript"));
+                res.writeHeader("etag", expectedEtag);
+                const filepath = path.join(__dirname, "../client-dist/", filename);
+                (0, uws_js_1.serveFile)(res, filepath);
+            });
+        }
+        (0, uws_js_1.patchAdapter)(app);
+    }
     /**
      * Initialize engine
@@ -184,5 +241,5 @@
         // initialize engine
         debug("creating engine.io instance with opts %j", opts);
-        this.eio = engine.attach(srv, opts);
+        this.eio = (0, engine_io_1.attach)(srv, opts);
         // attach static file serving
         if (this._serveClient)
@@ -222,5 +279,5 @@
      */
     serve(req, res) {
-        const filename = req.url.replace(this._path, "");
+        const filename = req.url.replace(this._path, "").replace(/\?.*$/, "");
         const isMap = dotMapRegex.test(filename);
         const type = isMap ? "map" : "source";
@@ -242,7 +299,4 @@
         res.setHeader("Content-Type", "application/" + (isMap ? "json" : "javascript"));
         res.setHeader("ETag", expectedEtag);
-        if (!isMap) {
-            res.setHeader("X-SourceMap", filename.substring(1) + ".map");
-        }
         Server.sendFile(filename, req, res);
     }
@@ -254,5 +308,5 @@
      */
     static sendFile(filename, req, res) {
-        const readStream = fs_1.createReadStream(path.join(__dirname, "../client-dist/", filename));
+        const readStream = (0, fs_1.createReadStream)(path.join(__dirname, "../client-dist/", filename));
         const encoding = accepts(req).encodings(["br", "gzip", "deflate"]);
         const onError = (err) => {
@@ -264,18 +318,18 @@
             case "br":
                 res.writeHead(200, { "content-encoding": "br" });
-                readStream.pipe(zlib_1.createBrotliCompress()).pipe(res);
-                stream_1.pipeline(readStream, zlib_1.createBrotliCompress(), res, onError);
+                readStream.pipe((0, zlib_1.createBrotliCompress)()).pipe(res);
+                (0, stream_1.pipeline)(readStream, (0, zlib_1.createBrotliCompress)(), res, onError);
                 break;
             case "gzip":
                 res.writeHead(200, { "content-encoding": "gzip" });
-                stream_1.pipeline(readStream, zlib_1.createGzip(), res, onError);
+                (0, stream_1.pipeline)(readStream, (0, zlib_1.createGzip)(), res, onError);
                 break;
             case "deflate":
                 res.writeHead(200, { "content-encoding": "deflate" });
-                stream_1.pipeline(readStream, zlib_1.createDeflate(), res, onError);
+                (0, stream_1.pipeline)(readStream, (0, zlib_1.createDeflate)(), res, onError);
                 break;
             default:
                 res.writeHead(200);
-                stream_1.pipeline(readStream, res, onError);
+                (0, stream_1.pipeline)(readStream, res, onError);
         }
     }
@@ -338,4 +392,8 @@
             nsp = new namespace_1.Namespace(this, name);
             this._nsps.set(name, nsp);
+            if (name !== "/") {
+                // @ts-ignore
+                this.sockets.emitReserved("new_namespace", nsp);
+            }
         }
         if (fn)
@@ -354,4 +412,6 @@
         }
         this.engine.close();
+        // restore the Adapter prototype
+        (0, uws_js_1.restoreAdapter)();
         if (this.httpServer) {
             this.httpServer.close(fn);
@@ -374,22 +434,30 @@
      * Targets a room when emitting.
      *
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room) {
+        return this.sockets.to(room);
+    }
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room) {
+        return this.sockets.in(room);
+    }
+    /**
+     * Excludes a room when emitting.
+     *
      * @param name
      * @return self
      * @public
      */
-    to(name) {
-        this.sockets.to(name);
-        return this;
-    }
-    /**
-     * Targets a room when emitting.
-     *
-     * @param name
-     * @return self
-     * @public
-     */
-    in(name) {
-        this.sockets.in(name);
-        return this;
+    except(name) {
+        return this.sockets.except(name);
     }
     /**
@@ -414,4 +482,14 @@
     }
     /**
+     * Emit a packet to other Socket.IO servers
+     *
+     * @param ev - the event name
+     * @param args - an array of arguments, which may include an acknowledgement callback at the end
+     * @public
+     */
+    serverSideEmit(ev, ...args) {
+        return this.sockets.serverSideEmit(ev, ...args);
+    }
+    /**
      * Gets a list of socket ids.
      *
@@ -429,6 +507,5 @@
      */
     compress(compress) {
-        this.sockets.compress(compress);
-        return this;
+        return this.sockets.compress(compress);
     }
     /**
@@ -441,6 +518,5 @@
      */
     get volatile() {
-        this.sockets.volatile;
-        return this;
+        return this.sockets.volatile;
     }
     /**
@@ -451,6 +527,40 @@
      */
     get local() {
-        this.sockets.local;
-        return this;
+        return this.sockets.local;
+    }
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets() {
+        return this.sockets.fetchSockets();
+    }
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsJoin(room) {
+        return this.sockets.socketsJoin(room);
+    }
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsLeave(room) {
+        return this.sockets.socketsLeave(room);
+    }
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param close - whether to close the underlying connection
+     * @public
+     */
+    disconnectSockets(close = false) {
+        return this.sockets.disconnectSockets(close);
     }
 }
@@ -469,2 +579,4 @@
 module.exports = (srv, opts) => new Server(srv, opts);
 module.exports.Server = Server;
+module.exports.Namespace = namespace_1.Namespace;
+module.exports.Socket = socket_1.Socket;
Index: trip-planner-front/node_modules/socket.io/dist/namespace.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/namespace.d.ts	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/namespace.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -1,23 +1,27 @@
-/// <reference types="node" />
 import { Socket } from "./socket";
 import type { Server } from "./index";
+import { EventParams, EventNames, EventsMap, StrictEventEmitter, DefaultEventsMap } from "./typed-events";
 import type { Client } from "./client";
-import { EventEmitter } from "events";
 import type { Adapter, Room, SocketId } from "socket.io-adapter";
+import { BroadcastOperator, RemoteSocket } from "./broadcast-operator";
 export interface ExtendedError extends Error {
     data?: any;
 }
-export declare class Namespace extends EventEmitter {
+export interface NamespaceReservedEventsMap<ListenEvents extends EventsMap, EmitEvents extends EventsMap, ServerSideEvents extends EventsMap, SocketData> {
+    connect: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>) => void;
+    connection: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>) => void;
+}
+export interface ServerReservedEventsMap<ListenEvents, EmitEvents, ServerSideEvents, SocketData> extends NamespaceReservedEventsMap<ListenEvents, EmitEvents, ServerSideEvents, SocketData> {
+    new_namespace: (namespace: Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>) => void;
+}
+export declare const RESERVED_EVENTS: ReadonlySet<string | Symbol>;
+export declare class Namespace<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents, ServerSideEvents extends EventsMap = DefaultEventsMap, SocketData = any> extends StrictEventEmitter<ServerSideEvents, EmitEvents, NamespaceReservedEventsMap<ListenEvents, EmitEvents, ServerSideEvents, SocketData>> {
     readonly name: string;
-    readonly sockets: Map<SocketId, Socket>;
+    readonly sockets: Map<SocketId, Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>>;
     adapter: Adapter;
     /** @private */
-    readonly server: Server;
+    readonly server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
     /** @private */
-    _fns: Array<(socket: Socket, next: (err?: ExtendedError) => void) => void>;
-    /** @private */
-    _rooms: Set<Room>;
-    /** @private */
-    _flags: any;
+    _fns: Array<(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, next: (err?: ExtendedError) => void) => void>;
     /** @private */
     _ids: number;
@@ -28,5 +32,5 @@
      * @param name
      */
-    constructor(server: Server, name: string);
+    constructor(server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, name: string);
     /**
      * Initializes the `Adapter` for this nsp.
@@ -43,5 +47,5 @@
      * @public
      */
-    use(fn: (socket: Socket, next: (err?: ExtendedError) => void) => void): this;
+    use(fn: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, next: (err?: ExtendedError) => void) => void): this;
     /**
      * Executes the middleware for an incoming client.
@@ -55,17 +59,25 @@
      * Targets a room when emitting.
      *
-     * @param name
+     * @param room
      * @return self
      * @public
      */
-    to(name: Room): this;
+    to(room: Room | Room[]): BroadcastOperator<EmitEvents>;
     /**
      * Targets a room when emitting.
      *
-     * @param name
+     * @param room
      * @return self
      * @public
      */
-    in(name: Room): this;
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room: Room | Room[]): BroadcastOperator<EmitEvents>;
     /**
      * Adds a new client.
@@ -74,5 +86,5 @@
      * @private
      */
-    _add(client: Client, query: any, fn?: () => void): Socket;
+    _add(client: Client<ListenEvents, EmitEvents, ServerSideEvents>, query: any, fn?: () => void): Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
     /**
      * Removes a client. Called by each `Socket`.
@@ -80,5 +92,5 @@
      * @private
      */
-    _remove(socket: Socket): void;
+    _remove(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>): void;
     /**
      * Emits to all clients.
@@ -87,5 +99,5 @@
      * @public
      */
-    emit(ev: string | Symbol, ...args: any[]): true;
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
     /**
      * Sends a `message` event to all clients.
@@ -94,5 +106,5 @@
      * @public
      */
-    send(...args: readonly any[]): this;
+    send(...args: EventParams<EmitEvents, "message">): this;
     /**
      * Sends a `message` event to all clients.
@@ -101,5 +113,21 @@
      * @public
      */
-    write(...args: readonly any[]): this;
+    write(...args: EventParams<EmitEvents, "message">): this;
+    /**
+     * Emit a packet to other Socket.IO servers
+     *
+     * @param ev - the event name
+     * @param args - an array of arguments, which may include an acknowledgement callback at the end
+     * @public
+     */
+    serverSideEmit<Ev extends EventNames<ServerSideEvents>>(ev: Ev, ...args: EventParams<ServerSideEvents, Ev>): boolean;
+    /**
+     * Called when a packet is received from another Socket.IO server
+     *
+     * @param args - an array of arguments, which may include an acknowledgement callback at the end
+     *
+     * @private
+     */
+    _onServerSideEmit(args: [string, ...any[]]): void;
     /**
      * Gets a list of clients.
@@ -116,5 +144,5 @@
      * @public
      */
-    compress(compress: boolean): this;
+    compress(compress: boolean): BroadcastOperator<EmitEvents>;
     /**
      * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
@@ -125,5 +153,5 @@
      * @public
      */
-    get volatile(): this;
+    get volatile(): BroadcastOperator<EmitEvents>;
     /**
      * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
@@ -132,4 +160,31 @@
      * @public
      */
-    get local(): this;
+    get local(): BroadcastOperator<EmitEvents>;
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets(): Promise<RemoteSocket<EmitEvents>[]>;
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsJoin(room: Room | Room[]): void;
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsLeave(room: Room | Room[]): void;
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param close - whether to close the underlying connection
+     * @public
+     */
+    disconnectSockets(close?: boolean): void;
 }
Index: trip-planner-front/node_modules/socket.io/dist/namespace.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/namespace.js	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/namespace.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -4,11 +4,12 @@
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Namespace = void 0;
+exports.Namespace = exports.RESERVED_EVENTS = void 0;
 const socket_1 = require("./socket");
-const events_1 = require("events");
-const socket_io_parser_1 = require("socket.io-parser");
+const typed_events_1 = require("./typed-events");
 const debug_1 = __importDefault(require("debug"));
-const debug = debug_1.default("socket.io:namespace");
-class Namespace extends events_1.EventEmitter {
+const broadcast_operator_1 = require("./broadcast-operator");
+const debug = (0, debug_1.default)("socket.io:namespace");
+exports.RESERVED_EVENTS = new Set(["connect", "connection", "new_namespace"]);
+class Namespace extends typed_events_1.StrictEventEmitter {
     /**
      * Namespace constructor.
@@ -23,8 +24,4 @@
         this._fns = [];
         /** @private */
-        this._rooms = new Set();
-        /** @private */
-        this._flags = {};
-        /** @private */
         this._ids = 0;
         this.server = server;
@@ -40,4 +37,5 @@
      */
     _initAdapter() {
+        // @ts-ignore
         this.adapter = new (this.server.adapter())(this);
     }
@@ -80,22 +78,30 @@
      * Targets a room when emitting.
      *
-     * @param name
-     * @return self
-     * @public
-     */
-    to(name) {
-        this._rooms.add(name);
-        return this;
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).to(room);
     }
     /**
      * Targets a room when emitting.
      *
-     * @param name
-     * @return self
-     * @public
-     */
-    in(name) {
-        this._rooms.add(name);
-        return this;
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).in(room);
+    }
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).except(room);
     }
     /**
@@ -132,6 +138,6 @@
                         fn();
                     // fire user-set events
-                    super.emit("connect", socket);
-                    super.emit("connection", socket);
+                    this.emitReserved("connect", socket);
+                    this.emitReserved("connection", socket);
                 }
                 else {
@@ -162,26 +168,5 @@
      */
     emit(ev, ...args) {
-        if (socket_1.RESERVED_EVENTS.has(ev)) {
-            throw new Error(`"${ev}" is a reserved event name`);
-        }
-        // set up packet object
-        args.unshift(ev);
-        const packet = {
-            type: socket_io_parser_1.PacketType.EVENT,
-            data: args,
-        };
-        if ("function" == typeof args[args.length - 1]) {
-            throw new Error("Callbacks are not supported when broadcasting");
-        }
-        const rooms = new Set(this._rooms);
-        const flags = Object.assign({}, this._flags);
-        // reset flags
-        this._rooms.clear();
-        this._flags = {};
-        this.adapter.broadcast(packet, {
-            rooms: rooms,
-            flags: flags,
-        });
-        return true;
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).emit(ev, ...args);
     }
     /**
@@ -206,4 +191,29 @@
     }
     /**
+     * Emit a packet to other Socket.IO servers
+     *
+     * @param ev - the event name
+     * @param args - an array of arguments, which may include an acknowledgement callback at the end
+     * @public
+     */
+    serverSideEmit(ev, ...args) {
+        if (exports.RESERVED_EVENTS.has(ev)) {
+            throw new Error(`"${ev}" is a reserved event name`);
+        }
+        args.unshift(ev);
+        this.adapter.serverSideEmit(args);
+        return true;
+    }
+    /**
+     * Called when a packet is received from another Socket.IO server
+     *
+     * @param args - an array of arguments, which may include an acknowledgement callback at the end
+     *
+     * @private
+     */
+    _onServerSideEmit(args) {
+        super.emitUntyped.apply(this, args);
+    }
+    /**
      * Gets a list of clients.
      *
@@ -212,10 +222,5 @@
      */
     allSockets() {
-        if (!this.adapter) {
-            throw new Error("No adapter for this namespace, are you trying to get the list of clients of a dynamic namespace?");
-        }
-        const rooms = new Set(this._rooms);
-        this._rooms.clear();
-        return this.adapter.sockets(rooms);
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).allSockets();
     }
     /**
@@ -227,6 +232,5 @@
      */
     compress(compress) {
-        this._flags.compress = compress;
-        return this;
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).compress(compress);
     }
     /**
@@ -239,6 +243,5 @@
      */
     get volatile() {
-        this._flags.volatile = true;
-        return this;
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).volatile;
     }
     /**
@@ -249,6 +252,40 @@
      */
     get local() {
-        this._flags.local = true;
-        return this;
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).local;
+    }
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets() {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).fetchSockets();
+    }
+    /**
+     * Makes the matching socket instances join the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsJoin(room) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsJoin(room);
+    }
+    /**
+     * Makes the matching socket instances leave the specified rooms
+     *
+     * @param room
+     * @public
+     */
+    socketsLeave(room) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsLeave(room);
+    }
+    /**
+     * Makes the matching socket instances disconnect
+     *
+     * @param close - whether to close the underlying connection
+     * @public
+     */
+    disconnectSockets(close = false) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).disconnectSockets(close);
     }
 }
Index: trip-planner-front/node_modules/socket.io/dist/parent-namespace.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/parent-namespace.d.ts	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/parent-namespace.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -1,13 +1,14 @@
 import { Namespace } from "./namespace";
 import type { Server } from "./index";
-export declare class ParentNamespace extends Namespace {
+import type { EventParams, EventNames, EventsMap, DefaultEventsMap } from "./typed-events";
+export declare class ParentNamespace<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents, ServerSideEvents extends EventsMap = DefaultEventsMap, SocketData = any> extends Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData> {
     private static count;
     private children;
-    constructor(server: Server);
+    constructor(server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>);
     /**
      * @private
      */
     _initAdapter(): void;
-    emit(ev: string | Symbol, ...args: [...any]): true;
-    createChild(name: string): Namespace;
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    createChild(name: string): Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
 }
Index: trip-planner-front/node_modules/socket.io/dist/parent-namespace.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/parent-namespace.js	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/parent-namespace.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -12,14 +12,16 @@
      */
     _initAdapter() {
-        /* no-op */
+        const broadcast = (packet, opts) => {
+            this.children.forEach((nsp) => {
+                nsp.adapter.broadcast(packet, opts);
+            });
+        };
+        // @ts-ignore FIXME is there a way to declare an inner class in TypeScript?
+        this.adapter = { broadcast };
     }
     emit(ev, ...args) {
         this.children.forEach((nsp) => {
-            nsp._rooms = this._rooms;
-            nsp._flags = this._flags;
             nsp.emit(ev, ...args);
         });
-        this._rooms.clear();
-        this._flags = {};
         return true;
     }
Index: trip-planner-front/node_modules/socket.io/dist/socket.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/socket.d.ts	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/socket.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { EventEmitter } from "events";
 import { Packet } from "socket.io-parser";
+import { EventParams, EventNames, EventsMap, StrictEventEmitter, DefaultEventsMap } from "./typed-events";
 import type { Client } from "./client";
 import type { Namespace } from "./namespace";
@@ -7,4 +7,14 @@
 import type { Room, SocketId } from "socket.io-adapter";
 import type { ParsedUrlQuery } from "querystring";
+import { BroadcastOperator } from "./broadcast-operator";
+export interface SocketReservedEventsMap {
+    disconnect: (reason: string) => void;
+    disconnecting: (reason: string) => void;
+    error: (err: Error) => void;
+}
+export interface EventEmitterReservedEventsMap {
+    newListener: (eventName: string | Symbol, listener: (...args: any[]) => void) => void;
+    removeListener: (eventName: string | Symbol, listener: (...args: any[]) => void) => void;
+}
 export declare const RESERVED_EVENTS: ReadonlySet<string | Symbol>;
 /**
@@ -51,11 +61,15 @@
     };
 }
-export declare class Socket extends EventEmitter {
-    readonly nsp: Namespace;
-    readonly client: Client;
+declare type Event = [eventName: string, ...args: any[]];
+export declare class Socket<ListenEvents extends EventsMap = DefaultEventsMap, EmitEvents extends EventsMap = ListenEvents, ServerSideEvents extends EventsMap = DefaultEventsMap, SocketData = any> extends StrictEventEmitter<ListenEvents, EmitEvents, SocketReservedEventsMap> {
+    readonly nsp: Namespace<ListenEvents, EmitEvents, ServerSideEvents>;
+    readonly client: Client<ListenEvents, EmitEvents, ServerSideEvents>;
     readonly id: SocketId;
     readonly handshake: Handshake;
+    /**
+     * Additional information that can be attached to the Socket instance and which will be used in the fetchSockets method
+     */
+    data: Partial<SocketData>;
     connected: boolean;
-    disconnected: boolean;
     private readonly server;
     private readonly adapter;
@@ -63,5 +77,4 @@
     private fns;
     private flags;
-    private _rooms;
     private _anyListeners?;
     /**
@@ -73,5 +86,5 @@
      * @package
      */
-    constructor(nsp: Namespace, client: Client, auth: object);
+    constructor(nsp: Namespace<ListenEvents, EmitEvents, ServerSideEvents>, client: Client<ListenEvents, EmitEvents, ServerSideEvents>, auth: object);
     /**
      * Builds the `handshake` BC object
@@ -86,21 +99,33 @@
      * @public
      */
-    emit(ev: string, ...args: any[]): boolean;
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    /**
+     * @private
+     */
+    private registerAckCallback;
     /**
      * Targets a room when broadcasting.
      *
-     * @param name
-     * @return self
-     * @public
-     */
-    to(name: Room): this;
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room: Room | Room[]): BroadcastOperator<EmitEvents>;
     /**
      * Targets a room when broadcasting.
      *
-     * @param name
-     * @return self
-     * @public
-     */
-    in(name: Room): this;
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents>;
+    /**
+     * Excludes a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room: Room | Room[]): BroadcastOperator<EmitEvents>;
     /**
      * Sends a `message` event.
@@ -109,5 +134,5 @@
      * @public
      */
-    send(...args: readonly any[]): this;
+    send(...args: EventParams<EmitEvents, "message">): this;
     /**
      * Sends a `message` event.
@@ -116,5 +141,5 @@
      * @public
      */
-    write(...args: readonly any[]): this;
+    write(...args: EventParams<EmitEvents, "message">): this;
     /**
      * Writes a packet.
@@ -194,5 +219,5 @@
      * @private
      */
-    _onerror(err: any): void;
+    _onerror(err: Error): void;
     /**
      * Called upon closing. Called by `Client`.
@@ -245,5 +270,5 @@
      * @public
      */
-    get broadcast(): this;
+    get broadcast(): BroadcastOperator<EmitEvents>;
     /**
      * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
@@ -252,5 +277,21 @@
      * @public
      */
-    get local(): this;
+    get local(): BroadcastOperator<EmitEvents>;
+    /**
+     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+     * given number of milliseconds have elapsed without an acknowledgement from the client:
+     *
+     * ```
+     * socket.timeout(5000).emit("my-event", (err) => {
+     *   if (err) {
+     *     // the client did not acknowledge the event in the given delay
+     *   }
+     * });
+     * ```
+     *
+     * @returns self
+     * @public
+     */
+    timeout(timeout: number): this;
     /**
      * Dispatch incoming event to socket listeners.
@@ -267,5 +308,5 @@
      * @public
      */
-    use(fn: (event: Array<any>, next: (err: Error) => void) => void): this;
+    use(fn: (event: Event, next: (err?: Error) => void) => void): this;
     /**
      * Executes the middleware for an incoming event.
@@ -277,4 +318,8 @@
     private run;
     /**
+     * Whether the socket is currently disconnected
+     */
+    get disconnected(): boolean;
+    /**
      * A reference to the request that originated the underlying Engine.IO Socket.
      *
@@ -287,5 +332,5 @@
      * @public
      */
-    get conn(): any;
+    get conn(): import("engine.io").Socket;
     /**
      * @public
@@ -322,3 +367,5 @@
      */
     listenersAny(): ((...args: any[]) => void)[];
+    private newBroadcastOperator;
 }
+export {};
Index: trip-planner-front/node_modules/socket.io/dist/socket.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/socket.js	(revision 6a3a178323fd905112b5392bd9d3cb83b66ef2d3)
+++ trip-planner-front/node_modules/socket.io/dist/socket.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -5,10 +5,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Socket = exports.RESERVED_EVENTS = void 0;
-const events_1 = require("events");
 const socket_io_parser_1 = require("socket.io-parser");
-const url = require("url");
 const debug_1 = __importDefault(require("debug"));
+const typed_events_1 = require("./typed-events");
 const base64id_1 = __importDefault(require("base64id"));
-const debug = debug_1.default("socket.io:socket");
+const broadcast_operator_1 = require("./broadcast-operator");
+const debug = (0, debug_1.default)("socket.io:socket");
 exports.RESERVED_EVENTS = new Set([
     "connect",
@@ -16,9 +16,8 @@
     "disconnect",
     "disconnecting",
-    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
     "newListener",
     "removeListener",
 ]);
-class Socket extends events_1.EventEmitter {
+class Socket extends typed_events_1.StrictEventEmitter {
     /**
      * Interface to a `Client` for a given `Namespace`.
@@ -33,8 +32,12 @@
         this.nsp = nsp;
         this.client = client;
+        /**
+         * Additional information that can be attached to the Socket instance and which will be used in the fetchSockets method
+         */
+        this.data = {};
+        this.connected = false;
         this.acks = new Map();
         this.fns = [];
         this.flags = {};
-        this._rooms = new Set();
         this.server = nsp.server;
         this.adapter = this.nsp.adapter;
@@ -46,6 +49,4 @@
             this.id = base64id_1.default.generateId(); // don't reuse the Engine.IO id because it's sensitive information
         }
-        this.connected = true;
-        this.disconnected = false;
         this.handshake = this.buildHandshake(auth);
     }
@@ -65,5 +66,6 @@
             issued: +new Date(),
             url: this.request.url,
-            query: url.parse(this.request.url, true).query,
+            // @ts-ignore
+            query: this.request._query,
             auth,
         };
@@ -79,57 +81,69 @@
             throw new Error(`"${ev}" is a reserved event name`);
         }
-        args.unshift(ev);
+        const data = [ev, ...args];
         const packet = {
             type: socket_io_parser_1.PacketType.EVENT,
-            data: args,
+            data: data,
         };
         // access last argument to see if it's an ACK callback
-        if (typeof args[args.length - 1] === "function") {
-            if (this._rooms.size || this.flags.broadcast) {
-                throw new Error("Callbacks are not supported when broadcasting");
-            }
-            debug("emitting packet with ack id %d", this.nsp._ids);
-            this.acks.set(this.nsp._ids, args.pop());
-            packet.id = this.nsp._ids++;
-        }
-        const rooms = new Set(this._rooms);
+        if (typeof data[data.length - 1] === "function") {
+            const id = this.nsp._ids++;
+            debug("emitting packet with ack id %d", id);
+            this.registerAckCallback(id, data.pop());
+            packet.id = id;
+        }
         const flags = Object.assign({}, this.flags);
-        // reset flags
-        this._rooms.clear();
         this.flags = {};
-        if (rooms.size || flags.broadcast) {
-            this.adapter.broadcast(packet, {
-                except: new Set([this.id]),
-                rooms: rooms,
-                flags: flags,
-            });
-        }
-        else {
-            // dispatch packet
-            this.packet(packet, flags);
-        }
+        this.packet(packet, flags);
         return true;
     }
     /**
+     * @private
+     */
+    registerAckCallback(id, ack) {
+        const timeout = this.flags.timeout;
+        if (timeout === undefined) {
+            this.acks.set(id, ack);
+            return;
+        }
+        const timer = setTimeout(() => {
+            debug("event with ack id %d has timed out after %d ms", id, timeout);
+            this.acks.delete(id);
+            ack.call(this, new Error("operation has timed out"));
+        }, timeout);
+        this.acks.set(id, (...args) => {
+            clearTimeout(timer);
+            ack.apply(this, [null, ...args]);
+        });
+    }
+    /**
      * Targets a room when broadcasting.
      *
-     * @param name
+     * @param room
      * @return self
      * @public
      */
-    to(name) {
-        this._rooms.add(name);
-        return this;
+    to(room) {
+        return this.newBroadcastOperator().to(room);
     }
     /**
      * Targets a room when broadcasting.
      *
-     * @param name
+     * @param room
      * @return self
      * @public
      */
-    in(name) {
-        this._rooms.add(name);
-        return this;
+    in(room) {
+        return this.newBroadcastOperator().in(room);
+    }
+    /**
+     * Excludes a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room) {
+        return this.newBroadcastOperator().except(room);
     }
     /**
@@ -205,4 +219,5 @@
     _onconnect() {
         debug("socket connected - writing packet");
+        this.connected = true;
         this.join(this.id);
         if (this.conn.protocol === 3) {
@@ -317,5 +332,5 @@
     _onerror(err) {
         if (this.listeners("error").length) {
-            super.emit("error", err);
+            this.emitReserved("error", err);
         }
         else {
@@ -336,11 +351,10 @@
             return this;
         debug("closing socket - reason %s", reason);
-        super.emit("disconnecting", reason);
+        this.emitReserved("disconnecting", reason);
         this.leaveAll();
         this.nsp._remove(this);
         this.client._remove(this);
         this.connected = false;
-        this.disconnected = true;
-        super.emit("disconnect", reason);
+        this.emitReserved("disconnect", reason);
         return;
     }
@@ -406,6 +420,5 @@
      */
     get broadcast() {
-        this.flags.broadcast = true;
-        return this;
+        return this.newBroadcastOperator();
     }
     /**
@@ -416,5 +429,23 @@
      */
     get local() {
-        this.flags.local = true;
+        return this.newBroadcastOperator().local;
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+     * given number of milliseconds have elapsed without an acknowledgement from the client:
+     *
+     * ```
+     * socket.timeout(5000).emit("my-event", (err) => {
+     *   if (err) {
+     *     // the client did not acknowledge the event in the given delay
+     *   }
+     * });
+     * ```
+     *
+     * @returns self
+     * @public
+     */
+    timeout(timeout) {
+        this.flags.timeout = timeout;
         return this;
     }
@@ -433,5 +464,5 @@
                 }
                 if (this.connected) {
-                    super.emit.apply(this, event);
+                    super.emitUntyped.apply(this, event);
                 }
                 else {
@@ -478,4 +509,10 @@
     }
     /**
+     * Whether the socket is currently disconnected
+     */
+    get disconnected() {
+        return !this.connected;
+    }
+    /**
      * A reference to the request that originated the underlying Engine.IO Socket.
      *
@@ -556,4 +593,9 @@
         return this._anyListeners || [];
     }
+    newBroadcastOperator() {
+        const flags = Object.assign({}, this.flags);
+        this.flags = {};
+        return new broadcast_operator_1.BroadcastOperator(this.adapter, new Set(), new Set([this.id]), flags);
+    }
 }
 exports.Socket = Socket;
Index: trip-planner-front/node_modules/socket.io/dist/typed-events.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/typed-events.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
+++ trip-planner-front/node_modules/socket.io/dist/typed-events.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -0,0 +1,110 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+/**
+ * An events map is an interface that maps event names to their value, which
+ * represents the type of the `on` listener.
+ */
+export interface EventsMap {
+    [event: string]: any;
+}
+/**
+ * The default events map, used if no EventsMap is given. Using this EventsMap
+ * is equivalent to accepting all event names, and any data.
+ */
+export interface DefaultEventsMap {
+    [event: string]: (...args: any[]) => void;
+}
+/**
+ * Returns a union type containing all the keys of an event map.
+ */
+export declare type EventNames<Map extends EventsMap> = keyof Map & (string | symbol);
+/** The tuple type representing the parameters of an event listener */
+export declare type EventParams<Map extends EventsMap, Ev extends EventNames<Map>> = Parameters<Map[Ev]>;
+/**
+ * The event names that are either in ReservedEvents or in UserEvents
+ */
+export declare type ReservedOrUserEventNames<ReservedEventsMap extends EventsMap, UserEvents extends EventsMap> = EventNames<ReservedEventsMap> | EventNames<UserEvents>;
+/**
+ * Type of a listener of a user event or a reserved event. If `Ev` is in
+ * `ReservedEvents`, the reserved event listener is returned.
+ */
+export declare type ReservedOrUserListener<ReservedEvents extends EventsMap, UserEvents extends EventsMap, Ev extends ReservedOrUserEventNames<ReservedEvents, UserEvents>> = FallbackToUntypedListener<Ev extends EventNames<ReservedEvents> ? ReservedEvents[Ev] : Ev extends EventNames<UserEvents> ? UserEvents[Ev] : never>;
+/**
+ * Returns an untyped listener type if `T` is `never`; otherwise, returns `T`.
+ *
+ * This is a hack to mitigate https://github.com/socketio/socket.io/issues/3833.
+ * Needed because of https://github.com/microsoft/TypeScript/issues/41778
+ */
+declare type FallbackToUntypedListener<T> = [T] extends [never] ? (...args: any[]) => void | Promise<void> : T;
+/**
+ * Interface for classes that aren't `EventEmitter`s, but still expose a
+ * strictly typed `emit` method.
+ */
+export interface TypedEventBroadcaster<EmitEvents extends EventsMap> {
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+}
+/**
+ * Strictly typed version of an `EventEmitter`. A `TypedEventEmitter` takes type
+ * parameters for mappings of event names to event data types, and strictly
+ * types method calls to the `EventEmitter` according to these event maps.
+ *
+ * @typeParam ListenEvents - `EventsMap` of user-defined events that can be
+ * listened to with `on` or `once`
+ * @typeParam EmitEvents - `EventsMap` of user-defined events that can be
+ * emitted with `emit`
+ * @typeParam ReservedEvents - `EventsMap` of reserved events, that can be
+ * emitted by socket.io with `emitReserved`, and can be listened to with
+ * `listen`.
+ */
+export declare abstract class StrictEventEmitter<ListenEvents extends EventsMap, EmitEvents extends EventsMap, ReservedEvents extends EventsMap = {}> extends EventEmitter implements TypedEventBroadcaster<EmitEvents> {
+    /**
+     * Adds the `listener` function as an event listener for `ev`.
+     *
+     * @param ev Name of the event
+     * @param listener Callback function
+     */
+    on<Ev extends ReservedOrUserEventNames<ReservedEvents, ListenEvents>>(ev: Ev, listener: ReservedOrUserListener<ReservedEvents, ListenEvents, Ev>): this;
+    /**
+     * Adds a one-time `listener` function as an event listener for `ev`.
+     *
+     * @param ev Name of the event
+     * @param listener Callback function
+     */
+    once<Ev extends ReservedOrUserEventNames<ReservedEvents, ListenEvents>>(ev: Ev, listener: ReservedOrUserListener<ReservedEvents, ListenEvents, Ev>): this;
+    /**
+     * Emits an event.
+     *
+     * @param ev Name of the event
+     * @param args Values to send to listeners of this event
+     */
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    /**
+     * Emits a reserved event.
+     *
+     * This method is `protected`, so that only a class extending
+     * `StrictEventEmitter` can emit its own reserved events.
+     *
+     * @param ev Reserved event name
+     * @param args Arguments to emit along with the event
+     */
+    protected emitReserved<Ev extends EventNames<ReservedEvents>>(ev: Ev, ...args: EventParams<ReservedEvents, Ev>): boolean;
+    /**
+     * Emits an event.
+     *
+     * This method is `protected`, so that only a class extending
+     * `StrictEventEmitter` can get around the strict typing. This is useful for
+     * calling `emit.apply`, which can be called as `emitUntyped.apply`.
+     *
+     * @param ev Event name
+     * @param args Arguments to emit along with the event
+     */
+    protected emitUntyped(ev: string, ...args: any[]): boolean;
+    /**
+     * Returns the listeners listening to an event.
+     *
+     * @param event Event name
+     * @returns Array of listeners subscribed to `event`
+     */
+    listeners<Ev extends ReservedOrUserEventNames<ReservedEvents, ListenEvents>>(event: Ev): ReservedOrUserListener<ReservedEvents, ListenEvents, Ev>[];
+}
+export {};
Index: trip-planner-front/node_modules/socket.io/dist/typed-events.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/typed-events.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
+++ trip-planner-front/node_modules/socket.io/dist/typed-events.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictEventEmitter = void 0;
+const events_1 = require("events");
+/**
+ * Strictly typed version of an `EventEmitter`. A `TypedEventEmitter` takes type
+ * parameters for mappings of event names to event data types, and strictly
+ * types method calls to the `EventEmitter` according to these event maps.
+ *
+ * @typeParam ListenEvents - `EventsMap` of user-defined events that can be
+ * listened to with `on` or `once`
+ * @typeParam EmitEvents - `EventsMap` of user-defined events that can be
+ * emitted with `emit`
+ * @typeParam ReservedEvents - `EventsMap` of reserved events, that can be
+ * emitted by socket.io with `emitReserved`, and can be listened to with
+ * `listen`.
+ */
+class StrictEventEmitter extends events_1.EventEmitter {
+    /**
+     * Adds the `listener` function as an event listener for `ev`.
+     *
+     * @param ev Name of the event
+     * @param listener Callback function
+     */
+    on(ev, listener) {
+        return super.on(ev, listener);
+    }
+    /**
+     * Adds a one-time `listener` function as an event listener for `ev`.
+     *
+     * @param ev Name of the event
+     * @param listener Callback function
+     */
+    once(ev, listener) {
+        return super.once(ev, listener);
+    }
+    /**
+     * Emits an event.
+     *
+     * @param ev Name of the event
+     * @param args Values to send to listeners of this event
+     */
+    emit(ev, ...args) {
+        return super.emit(ev, ...args);
+    }
+    /**
+     * Emits a reserved event.
+     *
+     * This method is `protected`, so that only a class extending
+     * `StrictEventEmitter` can emit its own reserved events.
+     *
+     * @param ev Reserved event name
+     * @param args Arguments to emit along with the event
+     */
+    emitReserved(ev, ...args) {
+        return super.emit(ev, ...args);
+    }
+    /**
+     * Emits an event.
+     *
+     * This method is `protected`, so that only a class extending
+     * `StrictEventEmitter` can get around the strict typing. This is useful for
+     * calling `emit.apply`, which can be called as `emitUntyped.apply`.
+     *
+     * @param ev Event name
+     * @param args Arguments to emit along with the event
+     */
+    emitUntyped(ev, ...args) {
+        return super.emit(ev, ...args);
+    }
+    /**
+     * Returns the listeners listening to an event.
+     *
+     * @param event Event name
+     * @returns Array of listeners subscribed to `event`
+     */
+    listeners(event) {
+        return super.listeners(event);
+    }
+}
+exports.StrictEventEmitter = StrictEventEmitter;
Index: trip-planner-front/node_modules/socket.io/dist/uws.d.ts
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/uws.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
+++ trip-planner-front/node_modules/socket.io/dist/uws.d.ts	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -0,0 +1,3 @@
+export declare function patchAdapter(app: any): void;
+export declare function restoreAdapter(): void;
+export declare function serveFile(res: any, filepath: string): void;
Index: trip-planner-front/node_modules/socket.io/dist/uws.js
===================================================================
--- trip-planner-front/node_modules/socket.io/dist/uws.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
+++ trip-planner-front/node_modules/socket.io/dist/uws.js	(revision bdd64917749115bbdd228a9569a675d590c112e3)
@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveFile = exports.restoreAdapter = exports.patchAdapter = void 0;
+const socket_io_adapter_1 = require("socket.io-adapter");
+const fs_1 = require("fs");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)("socket.io:adapter-uws");
+const SEPARATOR = "\x1f"; // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
+const { addAll, del, broadcast } = socket_io_adapter_1.Adapter.prototype;
+function patchAdapter(app /* : TemplatedApp */) {
+    socket_io_adapter_1.Adapter.prototype.addAll = function (id, rooms) {
+        const isNew = !this.sids.has(id);
+        addAll.call(this, id, rooms);
+        const socket = this.nsp.sockets.get(id);
+        if (!socket) {
+            return;
+        }
+        if (socket.conn.transport.name === "websocket") {
+            subscribe(this.nsp.name, socket, isNew, rooms);
+            return;
+        }
+        if (isNew) {
+            socket.conn.on("upgrade", () => {
+                const rooms = this.sids.get(id);
+                subscribe(this.nsp.name, socket, isNew, rooms);
+            });
+        }
+    };
+    socket_io_adapter_1.Adapter.prototype.del = function (id, room) {
+        del.call(this, id, room);
+        const socket = this.nsp.sockets.get(id);
+        if (socket && socket.conn.transport.name === "websocket") {
+            // @ts-ignore
+            const sessionId = socket.conn.id;
+            // @ts-ignore
+            const websocket = socket.conn.transport.socket;
+            const topic = `${this.nsp.name}${SEPARATOR}${room}`;
+            debug("unsubscribe connection %s from topic %s", sessionId, topic);
+            websocket.unsubscribe(topic);
+        }
+    };
+    socket_io_adapter_1.Adapter.prototype.broadcast = function (packet, opts) {
+        const useFastPublish = opts.rooms.size <= 1 && opts.except.size === 0;
+        if (!useFastPublish) {
+            broadcast.call(this, packet, opts);
+            return;
+        }
+        const flags = opts.flags || {};
+        const basePacketOpts = {
+            preEncoded: true,
+            volatile: flags.volatile,
+            compress: flags.compress,
+        };
+        packet.nsp = this.nsp.name;
+        const encodedPackets = this.encoder.encode(packet);
+        const topic = opts.rooms.size === 0
+            ? this.nsp.name
+            : `${this.nsp.name}${SEPARATOR}${opts.rooms.keys().next().value}`;
+        debug("fast publish to %s", topic);
+        // fast publish for clients connected with WebSocket
+        encodedPackets.forEach((encodedPacket) => {
+            const isBinary = typeof encodedPacket !== "string";
+            // "4" being the message type in the Engine.IO protocol, see https://github.com/socketio/engine.io-protocol
+            app.publish(topic, isBinary ? encodedPacket : "4" + encodedPacket, isBinary);
+        });
+        this.apply(opts, (socket) => {
+            if (socket.conn.transport.name !== "websocket") {
+                // classic publish for clients connected with HTTP long-polling
+                socket.client.writeToEngine(encodedPackets, basePacketOpts);
+            }
+        });
+    };
+}
+exports.patchAdapter = patchAdapter;
+function subscribe(namespaceName, socket, isNew, rooms) {
+    // @ts-ignore
+    const sessionId = socket.conn.id;
+    // @ts-ignore
+    const websocket = socket.conn.transport.socket;
+    if (isNew) {
+        debug("subscribe connection %s to topic %s", sessionId, namespaceName);
+        websocket.subscribe(namespaceName);
+    }
+    rooms.forEach((room) => {
+        const topic = `${namespaceName}${SEPARATOR}${room}`; // '#' can be used as wildcard
+        debug("subscribe connection %s to topic %s", sessionId, topic);
+        websocket.subscribe(topic);
+    });
+}
+function restoreAdapter() {
+    socket_io_adapter_1.Adapter.prototype.addAll = addAll;
+    socket_io_adapter_1.Adapter.prototype.del = del;
+    socket_io_adapter_1.Adapter.prototype.broadcast = broadcast;
+}
+exports.restoreAdapter = restoreAdapter;
+const toArrayBuffer = (buffer) => {
+    const { buffer: arrayBuffer, byteOffset, byteLength } = buffer;
+    return arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+};
+// imported from https://github.com/kolodziejczak-sz/uwebsocket-serve
+function serveFile(res /* : HttpResponse */, filepath) {
+    const { size } = (0, fs_1.statSync)(filepath);
+    const readStream = (0, fs_1.createReadStream)(filepath);
+    const destroyReadStream = () => !readStream.destroyed && readStream.destroy();
+    const onError = (error) => {
+        destroyReadStream();
+        throw error;
+    };
+    const onDataChunk = (chunk) => {
+        const arrayBufferChunk = toArrayBuffer(chunk);
+        const lastOffset = res.getWriteOffset();
+        const [ok, done] = res.tryEnd(arrayBufferChunk, size);
+        if (!done && !ok) {
+            readStream.pause();
+            res.onWritable((offset) => {
+                const [ok, done] = res.tryEnd(arrayBufferChunk.slice(offset - lastOffset), size);
+                if (!done && ok) {
+                    readStream.resume();
+                }
+                return ok;
+            });
+        }
+    };
+    res.onAborted(destroyReadStream);
+    readStream
+        .on("data", onDataChunk)
+        .on("error", onError)
+        .on("end", destroyReadStream);
+}
+exports.serveFile = serveFile;
