first commit

assets/socket.io/dist/broadcast-operator.d.ts

@@ -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, SocketData> 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, SocketData>;
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param room
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    except(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return a new BroadcastOperator instance
+     * @public
+     */
+    compress(compress: boolean): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * 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, SocketData>;
+    /**
+     * 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, SocketData>;
+    /**
+     * 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<SocketData = any>(): Promise<RemoteSocket<EmitEvents, SocketData>[]>;
+    /**
+     * 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<SocketData> {
+    id: SocketId;
+    handshake: Handshake;
+    rooms: Room[];
+    data: SocketData;
+}
+/**
+ * Expose of subset of the attributes and methods of the Socket class
+ */
+export declare class RemoteSocket<EmitEvents extends EventsMap, SocketData> implements TypedEventBroadcaster<EmitEvents> {
+    readonly id: SocketId;
+    readonly handshake: Handshake;
+    readonly rooms: Set<Room>;
+    readonly data: SocketData;
+    private readonly operator;
+    constructor(adapter: Adapter, details: SocketDetails<SocketData>);
+    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 {};

assets/socket.io/dist/broadcast-operator.js

@@ -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;

assets/socket.io/dist/client.d.ts

@@ -0,0 +1,119 @@
+/// <reference types="node" />
+import { Packet } from "socket.io-parser";
+import type { IncomingMessage } from "http";
+import type { Server } from "./index";
+import type { EventsMap } from "./typed-events";
+import type { Socket } from "./socket";
+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;
+    private readonly encoder;
+    private readonly decoder;
+    private sockets;
+    private nsps;
+    private connectTimeout?;
+    /**
+     * Client constructor.
+     *
+     * @param server instance
+     * @param conn
+     * @package
+     */
+    constructor(server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, conn: any);
+    /**
+     * @return the reference to the request that originated the Engine.IO connection
+     *
+     * @public
+     */
+    get request(): IncomingMessage;
+    /**
+     * Sets up event listeners.
+     *
+     * @private
+     */
+    private setup;
+    /**
+     * Connects a client to a namespace.
+     *
+     * @param {String} name - the namespace
+     * @param {Object} auth - the auth parameters
+     * @private
+     */
+    private connect;
+    /**
+     * Connects a client to a namespace.
+     *
+     * @param name - the namespace
+     * @param {Object} auth - the auth parameters
+     *
+     * @private
+     */
+    private doConnect;
+    /**
+     * Disconnects from all namespaces and closes transport.
+     *
+     * @private
+     */
+    _disconnect(): void;
+    /**
+     * Removes a socket. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>): void;
+    /**
+     * Closes the underlying connection.
+     *
+     * @private
+     */
+    private close;
+    /**
+     * Writes a packet to the transport.
+     *
+     * @param {Object} packet object
+     * @param {Object} opts
+     * @private
+     */
+    _packet(packet: Packet | any[], opts?: WriteOptions): void;
+    private writeToEngine;
+    /**
+     * Called with incoming transport data.
+     *
+     * @private
+     */
+    private ondata;
+    /**
+     * Called when parser fully decodes a packet.
+     *
+     * @private
+     */
+    private ondecoded;
+    /**
+     * Handles an error.
+     *
+     * @param {Object} err object
+     * @private
+     */
+    private onerror;
+    /**
+     * Called upon transport close.
+     *
+     * @param reason
+     * @private
+     */
+    private onclose;
+    /**
+     * Cleans up event listeners.
+     * @private
+     */
+    private destroy;
+}
+export {};

assets/socket.io/dist/client.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const socket_io_parser_1 = require("socket.io-parser");
+const debugModule = require("debug");
+const url = require("url");
+const debug = debugModule("socket.io:client");
+class Client {
+    /**
+     * Client constructor.
+     *
+     * @param server instance
+     * @param conn
+     * @package
+     */
+    constructor(server, conn) {
+        this.sockets = new Map();
+        this.nsps = new Map();
+        this.server = server;
+        this.conn = conn;
+        this.encoder = server.encoder;
+        this.decoder = new server._parser.Decoder();
+        this.id = conn.id;
+        this.setup();
+    }
+    /**
+     * @return the reference to the request that originated the Engine.IO connection
+     *
+     * @public
+     */
+    get request() {
+        return this.conn.request;
+    }
+    /**
+     * Sets up event listeners.
+     *
+     * @private
+     */
+    setup() {
+        this.onclose = this.onclose.bind(this);
+        this.ondata = this.ondata.bind(this);
+        this.onerror = this.onerror.bind(this);
+        this.ondecoded = this.ondecoded.bind(this);
+        // @ts-ignore
+        this.decoder.on("decoded", this.ondecoded);
+        this.conn.on("data", this.ondata);
+        this.conn.on("error", this.onerror);
+        this.conn.on("close", this.onclose);
+        this.connectTimeout = setTimeout(() => {
+            if (this.nsps.size === 0) {
+                debug("no namespace joined yet, close the client");
+                this.close();
+            }
+            else {
+                debug("the client has already joined a namespace, nothing to do");
+            }
+        }, this.server._connectTimeout);
+    }
+    /**
+     * Connects a client to a namespace.
+     *
+     * @param {String} name - the namespace
+     * @param {Object} auth - the auth parameters
+     * @private
+     */
+    connect(name, auth = {}) {
+        if (this.server._nsps.has(name)) {
+            debug("connecting to namespace %s", name);
+            return this.doConnect(name, auth);
+        }
+        this.server._checkNamespace(name, auth, (dynamicNspName) => {
+            if (dynamicNspName) {
+                this.doConnect(name, auth);
+            }
+            else {
+                debug("creation of namespace %s was denied", name);
+                this._packet({
+                    type: socket_io_parser_1.PacketType.CONNECT_ERROR,
+                    nsp: name,
+                    data: {
+                        message: "Invalid namespace",
+                    },
+                });
+            }
+        });
+    }
+    /**
+     * Connects a client to a namespace.
+     *
+     * @param name - the namespace
+     * @param {Object} auth - the auth parameters
+     *
+     * @private
+     */
+    doConnect(name, auth) {
+        const nsp = this.server.of(name);
+        const socket = nsp._add(this, auth, () => {
+            this.sockets.set(socket.id, socket);
+            this.nsps.set(nsp.name, socket);
+            if (this.connectTimeout) {
+                clearTimeout(this.connectTimeout);
+                this.connectTimeout = undefined;
+            }
+        });
+    }
+    /**
+     * Disconnects from all namespaces and closes transport.
+     *
+     * @private
+     */
+    _disconnect() {
+        for (const socket of this.sockets.values()) {
+            socket.disconnect();
+        }
+        this.sockets.clear();
+        this.close();
+    }
+    /**
+     * Removes a socket. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket) {
+        if (this.sockets.has(socket.id)) {
+            const nsp = this.sockets.get(socket.id).nsp.name;
+            this.sockets.delete(socket.id);
+            this.nsps.delete(nsp);
+        }
+        else {
+            debug("ignoring remove for %s", socket.id);
+        }
+    }
+    /**
+     * Closes the underlying connection.
+     *
+     * @private
+     */
+    close() {
+        if ("open" === this.conn.readyState) {
+            debug("forcing transport close");
+            this.conn.close();
+            this.onclose("forced server close");
+        }
+    }
+    /**
+     * Writes a packet to the transport.
+     *
+     * @param {Object} packet object
+     * @param {Object} opts
+     * @private
+     */
+    _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);
+        }
+    }
+    /**
+     * Called with incoming transport data.
+     *
+     * @private
+     */
+    ondata(data) {
+        // try/catch is needed for protocol violations (GH-1880)
+        try {
+            this.decoder.add(data);
+        }
+        catch (e) {
+            this.onerror(e);
+        }
+    }
+    /**
+     * Called when parser fully decodes a packet.
+     *
+     * @private
+     */
+    ondecoded(packet) {
+        if (socket_io_parser_1.PacketType.CONNECT === packet.type) {
+            if (this.conn.protocol === 3) {
+                const parsed = url.parse(packet.nsp, true);
+                this.connect(parsed.pathname, parsed.query);
+            }
+            else {
+                this.connect(packet.nsp, packet.data);
+            }
+        }
+        else {
+            const socket = this.nsps.get(packet.nsp);
+            if (socket) {
+                process.nextTick(function () {
+                    socket._onpacket(packet);
+                });
+            }
+            else {
+                debug("no socket for namespace %s", packet.nsp);
+            }
+        }
+    }
+    /**
+     * Handles an error.
+     *
+     * @param {Object} err object
+     * @private
+     */
+    onerror(err) {
+        for (const socket of this.sockets.values()) {
+            socket._onerror(err);
+        }
+        this.conn.close();
+    }
+    /**
+     * Called upon transport close.
+     *
+     * @param reason
+     * @private
+     */
+    onclose(reason) {
+        debug("client close with reason %s", reason);
+        // ignore a potential subsequent `close` event
+        this.destroy();
+        // `nsps` and `sockets` are cleaned up seamlessly
+        for (const socket of this.sockets.values()) {
+            socket._onclose(reason);
+        }
+        this.sockets.clear();
+        this.decoder.destroy(); // clean up decoder
+    }
+    /**
+     * Cleans up event listeners.
+     * @private
+     */
+    destroy() {
+        this.conn.removeListener("data", this.ondata);
+        this.conn.removeListener("error", this.onerror);
+        this.conn.removeListener("close", this.onclose);
+        // @ts-ignore
+        this.decoder.removeListener("decoded", this.ondecoded);
+        if (this.connectTimeout) {
+            clearTimeout(this.connectTimeout);
+            this.connectTimeout = undefined;
+        }
+    }
+}
+exports.Client = Client;

assets/socket.io/dist/index.d.ts

@@ -0,0 +1,326 @@
+/// <reference types="node" />
+import http = require("http");
+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 { 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;
+declare type AdapterConstructor = typeof Adapter | ((nsp: Namespace) => Adapter);
+interface ServerOptions extends EngineOptions, AttachOptions {
+    /**
+     * name of the path to capture
+     * @default "/socket.io"
+     */
+    path: string;
+    /**
+     * whether to serve the client files
+     * @default true
+     */
+    serveClient: boolean;
+    /**
+     * the adapter to use
+     * @default the in-memory adapter (https://github.com/socketio/socket.io-adapter)
+     */
+    adapter: AdapterConstructor;
+    /**
+     * the parser to use
+     * @default the default parser (https://github.com/socketio/socket.io-parser)
+     */
+    parser: any;
+    /**
+     * how many ms before a client without namespace is closed
+     * @default 45000
+     */
+    connectTimeout: number;
+}
+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;
+    /** @private */
+    readonly encoder: Encoder;
+    /**
+     * @private
+     */
+    _nsps: Map<string, Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>>;
+    private parentNsps;
+    private _adapter?;
+    private _serveClient;
+    private opts;
+    private eio;
+    private _path;
+    private clientPathRegex;
+    /**
+     * @private
+     */
+    _connectTimeout: number;
+    private httpServer;
+    /**
+     * Server constructor.
+     *
+     * @param srv http server, port, or options
+     * @param [opts]
+     * @public
+     */
+    constructor(opts?: Partial<ServerOptions>);
+    constructor(srv?: http.Server | number, opts?: Partial<ServerOptions>);
+    constructor(srv: undefined | Partial<ServerOptions> | http.Server | number, opts?: Partial<ServerOptions>);
+    /**
+     * Sets/gets whether client code is being served.
+     *
+     * @param v - whether to serve client code
+     * @return self when setting or value when getting
+     * @public
+     */
+    serveClient(v: boolean): this;
+    serveClient(): boolean;
+    serveClient(v?: boolean): this | boolean;
+    /**
+     * Executes the middleware for an incoming namespace not already created on the server.
+     *
+     * @param name - name of incoming namespace
+     * @param auth - the auth parameters
+     * @param fn - callback
+     *
+     * @private
+     */
+    _checkNamespace(name: string, auth: {
+        [key: string]: any;
+    }, fn: (nsp: Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData> | false) => void): void;
+    /**
+     * Sets the client serving path.
+     *
+     * @param {String} v pathname
+     * @return {Server|String} self when setting or value when getting
+     * @public
+     */
+    path(v: string): this;
+    path(): string;
+    path(v?: string): this | string;
+    /**
+     * Set the delay after which a client without namespace is closed
+     * @param v
+     * @public
+     */
+    connectTimeout(v: number): this;
+    connectTimeout(): number;
+    connectTimeout(v?: number): this | number;
+    /**
+     * Sets the adapter for rooms.
+     *
+     * @param v pathname
+     * @return self when setting or value when getting
+     * @public
+     */
+    adapter(): AdapterConstructor | undefined;
+    adapter(v: AdapterConstructor): this;
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     * @public
+     */
+    listen(srv: http.Server | number, opts?: Partial<ServerOptions>): this;
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     * @public
+     */
+    attach(srv: http.Server | number, opts?: Partial<ServerOptions>): this;
+    attachApp(app: any, opts?: Partial<ServerOptions>): void;
+    /**
+     * Initialize engine
+     *
+     * @param srv - the server to attach to
+     * @param opts - options passed to engine.io
+     * @private
+     */
+    private initEngine;
+    /**
+     * Attaches the static file serving.
+     *
+     * @param srv http server
+     * @private
+     */
+    private attachServe;
+    /**
+     * Handles a request serving of client source and map
+     *
+     * @param req
+     * @param res
+     * @private
+     */
+    private serve;
+    /**
+     * @param filename
+     * @param req
+     * @param res
+     * @private
+     */
+    private static sendFile;
+    /**
+     * Binds socket.io to an engine.io instance.
+     *
+     * @param {engine.Server} engine engine.io (or compatible) server
+     * @return self
+     * @public
+     */
+    bind(engine: any): this;
+    /**
+     * Called with each incoming transport connection.
+     *
+     * @param {engine.Socket} conn
+     * @return self
+     * @private
+     */
+    private onconnection;
+    /**
+     * Looks up a namespace.
+     *
+     * @param {String|RegExp|Function} name nsp name
+     * @param fn optional, nsp `connection` ev handler
+     * @public
+     */
+    of(name: string | RegExp | ParentNspNameMatchFn, fn?: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>) => void): Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
+    /**
+     * Closes server connection
+     *
+     * @param [fn] optional, called as `fn([err])` on error OR all conns closed
+     * @public
+     */
+    close(fn?: (err?: Error) => void): void;
+    /**
+     * Sets up namespace middleware.
+     *
+     * @return self
+     * @public
+     */
+    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, SocketData>;
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param name
+     * @return self
+     * @public
+     */
+    except(name: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    send(...args: EventParams<EmitEvents, "message">): this;
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    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.
+     *
+     * @public
+     */
+    allSockets(): Promise<Set<SocketId>>;
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return self
+     * @public
+     */
+    compress(compress: boolean): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * 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 self
+     * @public
+     */
+    get volatile(): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return self
+     * @public
+     */
+    get local(): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets(): Promise<RemoteSocket<EmitEvents, SocketData>[]>;
+    /**
+     * 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, BroadcastOperator, RemoteSocket };
+export { Event } from "./socket";

assets/socket.io/dist/index.js

@@ -0,0 +1,582 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namespace = exports.Socket = exports.Server = void 0;
+const http = require("http");
+const fs_1 = require("fs");
+const zlib_1 = require("zlib");
+const accepts = require("accepts");
+const stream_1 = require("stream");
+const path = require("path");
+const engine_io_1 = require("engine.io");
+const client_1 = require("./client");
+const events_1 = require("events");
+const namespace_1 = require("./namespace");
+Object.defineProperty(exports, "Namespace", { enumerable: true, get: function () { return namespace_1.Namespace; } });
+const parent_namespace_1 = require("./parent-namespace");
+const socket_io_adapter_1 = require("socket.io-adapter");
+const parser = __importStar(require("socket.io-parser"));
+const debug_1 = __importDefault(require("debug"));
+const socket_1 = require("./socket");
+Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_1.Socket; } });
+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 typed_events_1.StrictEventEmitter {
+    constructor(srv, opts = {}) {
+        super();
+        /**
+         * @private
+         */
+        this._nsps = new Map();
+        this.parentNsps = new Map();
+        if ("object" === typeof srv &&
+            srv instanceof Object &&
+            !srv.listen) {
+            opts = srv;
+            srv = undefined;
+        }
+        this.path(opts.path || "/socket.io");
+        this.connectTimeout(opts.connectTimeout || 45000);
+        this.serveClient(false !== opts.serveClient);
+        this._parser = opts.parser || parser;
+        this.encoder = new this._parser.Encoder();
+        this.adapter(opts.adapter || socket_io_adapter_1.Adapter);
+        this.sockets = this.of("/");
+        this.opts = opts;
+        if (srv || typeof srv == "number")
+            this.attach(srv);
+    }
+    serveClient(v) {
+        if (!arguments.length)
+            return this._serveClient;
+        this._serveClient = v;
+        return this;
+    }
+    /**
+     * Executes the middleware for an incoming namespace not already created on the server.
+     *
+     * @param name - name of incoming namespace
+     * @param auth - the auth parameters
+     * @param fn - callback
+     *
+     * @private
+     */
+    _checkNamespace(name, auth, fn) {
+        if (this.parentNsps.size === 0)
+            return fn(false);
+        const keysIterator = this.parentNsps.keys();
+        const run = () => {
+            const nextFn = keysIterator.next();
+            if (nextFn.done) {
+                return fn(false);
+            }
+            nextFn.value(name, auth, (err, allow) => {
+                if (err || !allow) {
+                    return run();
+                }
+                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);
+            });
+        };
+        run();
+    }
+    path(v) {
+        if (!arguments.length)
+            return this._path;
+        this._path = v.replace(/\/$/, "");
+        const escapedPath = this._path.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+        this.clientPathRegex = new RegExp("^" +
+            escapedPath +
+            "/socket\\.io(\\.msgpack|\\.esm)?(\\.min)?\\.js(\\.map)?(?:\\?|$)");
+        return this;
+    }
+    connectTimeout(v) {
+        if (v === undefined)
+            return this._connectTimeout;
+        this._connectTimeout = v;
+        return this;
+    }
+    adapter(v) {
+        if (!arguments.length)
+            return this._adapter;
+        this._adapter = v;
+        for (const nsp of this._nsps.values()) {
+            nsp._initAdapter();
+        }
+        return this;
+    }
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     * @public
+     */
+    listen(srv, opts = {}) {
+        return this.attach(srv, opts);
+    }
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     * @public
+     */
+    attach(srv, opts = {}) {
+        if ("function" == typeof srv) {
+            const msg = "You are trying to attach socket.io to an express " +
+                "request handler function. Please pass a http.Server instance.";
+            throw new Error(msg);
+        }
+        // handle a port as a string
+        if (Number(srv) == srv) {
+            srv = Number(srv);
+        }
+        if ("number" == typeof srv) {
+            debug("creating http server and binding to %d", srv);
+            const port = srv;
+            srv = http.createServer((req, res) => {
+                res.writeHead(404);
+                res.end();
+            });
+            srv.listen(port);
+        }
+        // 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;
+        this.initEngine(srv, opts);
+        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
+     *
+     * @param srv - the server to attach to
+     * @param opts - options passed to engine.io
+     * @private
+     */
+    initEngine(srv, opts) {
+        // initialize engine
+        debug("creating engine.io instance with opts %j", opts);
+        this.eio = (0, engine_io_1.attach)(srv, opts);
+        // attach static file serving
+        if (this._serveClient)
+            this.attachServe(srv);
+        // Export http server
+        this.httpServer = srv;
+        // bind to engine events
+        this.bind(this.eio);
+    }
+    /**
+     * Attaches the static file serving.
+     *
+     * @param srv http server
+     * @private
+     */
+    attachServe(srv) {
+        debug("attaching client serving req handler");
+        const evs = srv.listeners("request").slice(0);
+        srv.removeAllListeners("request");
+        srv.on("request", (req, res) => {
+            if (this.clientPathRegex.test(req.url)) {
+                this.serve(req, res);
+            }
+            else {
+                for (let i = 0; i < evs.length; i++) {
+                    evs[i].call(srv, req, res);
+                }
+            }
+        });
+    }
+    /**
+     * Handles a request serving of client source and map
+     *
+     * @param req
+     * @param res
+     * @private
+     */
+    serve(req, res) {
+        const filename = req.url.replace(this._path, "").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.headers["if-none-match"];
+        if (etag) {
+            if (expectedEtag === etag || weakEtag === etag) {
+                debug("serve client %s 304", type);
+                res.writeHead(304);
+                res.end();
+                return;
+            }
+        }
+        debug("serve client %s", type);
+        res.setHeader("Cache-Control", "public, max-age=0");
+        res.setHeader("Content-Type", "application/" + (isMap ? "json" : "javascript"));
+        res.setHeader("ETag", expectedEtag);
+        Server.sendFile(filename, req, res);
+    }
+    /**
+     * @param filename
+     * @param req
+     * @param res
+     * @private
+     */
+    static sendFile(filename, req, res) {
+        const readStream = (0, fs_1.createReadStream)(path.join(__dirname, "../client-dist/", filename));
+        const encoding = accepts(req).encodings(["br", "gzip", "deflate"]);
+        const onError = (err) => {
+            if (err) {
+                res.end();
+            }
+        };
+        switch (encoding) {
+            case "br":
+                res.writeHead(200, { "content-encoding": "br" });
+                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" });
+                (0, stream_1.pipeline)(readStream, (0, zlib_1.createGzip)(), res, onError);
+                break;
+            case "deflate":
+                res.writeHead(200, { "content-encoding": "deflate" });
+                (0, stream_1.pipeline)(readStream, (0, zlib_1.createDeflate)(), res, onError);
+                break;
+            default:
+                res.writeHead(200);
+                (0, stream_1.pipeline)(readStream, res, onError);
+        }
+    }
+    /**
+     * Binds socket.io to an engine.io instance.
+     *
+     * @param {engine.Server} engine engine.io (or compatible) server
+     * @return self
+     * @public
+     */
+    bind(engine) {
+        this.engine = engine;
+        this.engine.on("connection", this.onconnection.bind(this));
+        return this;
+    }
+    /**
+     * Called with each incoming transport connection.
+     *
+     * @param {engine.Socket} conn
+     * @return self
+     * @private
+     */
+    onconnection(conn) {
+        debug("incoming connection with id %s", conn.id);
+        const client = new client_1.Client(this, conn);
+        if (conn.protocol === 3) {
+            // @ts-ignore
+            client.connect("/");
+        }
+        return this;
+    }
+    /**
+     * Looks up a namespace.
+     *
+     * @param {String|RegExp|Function} name nsp name
+     * @param fn optional, nsp `connection` ev handler
+     * @public
+     */
+    of(name, fn) {
+        if (typeof name === "function" || name instanceof RegExp) {
+            const parentNsp = new parent_namespace_1.ParentNamespace(this);
+            debug("initializing parent namespace %s", parentNsp.name);
+            if (typeof name === "function") {
+                this.parentNsps.set(name, parentNsp);
+            }
+            else {
+                this.parentNsps.set((nsp, conn, next) => next(null, name.test(nsp)), parentNsp);
+            }
+            if (fn) {
+                // @ts-ignore
+                parentNsp.on("connect", fn);
+            }
+            return parentNsp;
+        }
+        if (String(name)[0] !== "/")
+            name = "/" + name;
+        let nsp = this._nsps.get(name);
+        if (!nsp) {
+            debug("initializing namespace %s", name);
+            nsp = new namespace_1.Namespace(this, name);
+            this._nsps.set(name, nsp);
+            if (name !== "/") {
+                // @ts-ignore
+                this.sockets.emitReserved("new_namespace", nsp);
+            }
+        }
+        if (fn)
+            nsp.on("connect", fn);
+        return nsp;
+    }
+    /**
+     * Closes server connection
+     *
+     * @param [fn] optional, called as `fn([err])` on error OR all conns closed
+     * @public
+     */
+    close(fn) {
+        for (const socket of this.sockets.sockets.values()) {
+            socket._onclose("server shutting down");
+        }
+        this.engine.close();
+        // restore the Adapter prototype
+        (0, uws_js_1.restoreAdapter)();
+        if (this.httpServer) {
+            this.httpServer.close(fn);
+        }
+        else {
+            fn && fn();
+        }
+    }
+    /**
+     * Sets up namespace middleware.
+     *
+     * @return self
+     * @public
+     */
+    use(fn) {
+        this.sockets.use(fn);
+        return this;
+    }
+    /**
+     * 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
+     */
+    except(name) {
+        return this.sockets.except(name);
+    }
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    send(...args) {
+        this.sockets.emit("message", ...args);
+        return this;
+    }
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    write(...args) {
+        this.sockets.emit("message", ...args);
+        return 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, ...args) {
+        return this.sockets.serverSideEmit(ev, ...args);
+    }
+    /**
+     * Gets a list of socket ids.
+     *
+     * @public
+     */
+    allSockets() {
+        return this.sockets.allSockets();
+    }
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return self
+     * @public
+     */
+    compress(compress) {
+        return this.sockets.compress(compress);
+    }
+    /**
+     * 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 self
+     * @public
+     */
+    get volatile() {
+        return this.sockets.volatile;
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return self
+     * @public
+     */
+    get local() {
+        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);
+    }
+}
+exports.Server = Server;
+/**
+ * Expose main namespace (/).
+ */
+const emitterMethods = Object.keys(events_1.EventEmitter.prototype).filter(function (key) {
+    return typeof events_1.EventEmitter.prototype[key] === "function";
+});
+emitterMethods.forEach(function (fn) {
+    Server.prototype[fn] = function () {
+        return this.sockets[fn].apply(this.sockets, arguments);
+    };
+});
+module.exports = (srv, opts) => new Server(srv, opts);
+module.exports.Server = Server;
+module.exports.Namespace = namespace_1.Namespace;
+module.exports.Socket = socket_1.Socket;

assets/socket.io/dist/namespace.d.ts

@@ -0,0 +1,190 @@
+import { Socket } from "./socket";
+import type { Server } from "./index";
+import { EventParams, EventNames, EventsMap, StrictEventEmitter, DefaultEventsMap } from "./typed-events";
+import type { Client } from "./client";
+import type { Adapter, Room, SocketId } from "socket.io-adapter";
+import { BroadcastOperator, RemoteSocket } from "./broadcast-operator";
+export interface ExtendedError extends Error {
+    data?: any;
+}
+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<ListenEvents, EmitEvents, ServerSideEvents, SocketData>>;
+    adapter: Adapter;
+    /** @private */
+    readonly server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
+    /** @private */
+    _fns: Array<(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, next: (err?: ExtendedError) => void) => void>;
+    /** @private */
+    _ids: number;
+    /**
+     * Namespace constructor.
+     *
+     * @param server instance
+     * @param name
+     */
+    constructor(server: Server<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, name: string);
+    /**
+     * Initializes the `Adapter` for this nsp.
+     * Run upon changing adapter by `Server#adapter`
+     * in addition to the constructor.
+     *
+     * @private
+     */
+    _initAdapter(): void;
+    /**
+     * Sets up namespace middleware.
+     *
+     * @return self
+     * @public
+     */
+    use(fn: (socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>, next: (err?: ExtendedError) => void) => void): this;
+    /**
+     * Executes the middleware for an incoming client.
+     *
+     * @param socket - the socket that will get added
+     * @param fn - last fn call in the middleware
+     * @private
+     */
+    private run;
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Excludes a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Adds a new client.
+     *
+     * @return {Socket}
+     * @private
+     */
+    _add(client: Client<ListenEvents, EmitEvents, ServerSideEvents>, query: any, fn?: () => void): Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
+    /**
+     * Removes a client. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket: Socket<ListenEvents, EmitEvents, ServerSideEvents, SocketData>): void;
+    /**
+     * Emits to all clients.
+     *
+     * @return Always true
+     * @public
+     */
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    send(...args: EventParams<EmitEvents, "message">): this;
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    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.
+     *
+     * @return self
+     * @public
+     */
+    allSockets(): Promise<Set<SocketId>>;
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return self
+     * @public
+     */
+    compress(compress: boolean): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * 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 self
+     * @public
+     */
+    get volatile(): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return self
+     * @public
+     */
+    get local(): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Returns the matching socket instances
+     *
+     * @public
+     */
+    fetchSockets(): Promise<RemoteSocket<EmitEvents, SocketData>[]>;
+    /**
+     * 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;
+}

assets/socket.io/dist/namespace.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namespace = exports.RESERVED_EVENTS = void 0;
+const socket_1 = require("./socket");
+const typed_events_1 = require("./typed-events");
+const debug_1 = __importDefault(require("debug"));
+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.
+     *
+     * @param server instance
+     * @param name
+     */
+    constructor(server, name) {
+        super();
+        this.sockets = new Map();
+        /** @private */
+        this._fns = [];
+        /** @private */
+        this._ids = 0;
+        this.server = server;
+        this.name = name;
+        this._initAdapter();
+    }
+    /**
+     * Initializes the `Adapter` for this nsp.
+     * Run upon changing adapter by `Server#adapter`
+     * in addition to the constructor.
+     *
+     * @private
+     */
+    _initAdapter() {
+        // @ts-ignore
+        this.adapter = new (this.server.adapter())(this);
+    }
+    /**
+     * Sets up namespace middleware.
+     *
+     * @return self
+     * @public
+     */
+    use(fn) {
+        this._fns.push(fn);
+        return this;
+    }
+    /**
+     * Executes the middleware for an incoming client.
+     *
+     * @param socket - the socket that will get added
+     * @param fn - last fn call in the middleware
+     * @private
+     */
+    run(socket, fn) {
+        const fns = this._fns.slice(0);
+        if (!fns.length)
+            return fn(null);
+        function run(i) {
+            fns[i](socket, function (err) {
+                // upon error, short-circuit
+                if (err)
+                    return fn(err);
+                // if no middleware left, summon callback
+                if (!fns[i + 1])
+                    return fn(null);
+                // go on to next
+                run(i + 1);
+            });
+        }
+        run(0);
+    }
+    /**
+     * Targets a room when emitting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).to(room);
+    }
+    /**
+     * Targets a room when emitting.
+     *
+     * @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);
+    }
+    /**
+     * Adds a new client.
+     *
+     * @return {Socket}
+     * @private
+     */
+    _add(client, query, fn) {
+        debug("adding socket to nsp %s", this.name);
+        const socket = new socket_1.Socket(this, client, query);
+        this.run(socket, (err) => {
+            process.nextTick(() => {
+                if ("open" == client.conn.readyState) {
+                    if (err) {
+                        if (client.conn.protocol === 3) {
+                            return socket._error(err.data || err.message);
+                        }
+                        else {
+                            return socket._error({
+                                message: err.message,
+                                data: err.data,
+                            });
+                        }
+                    }
+                    // track socket
+                    this.sockets.set(socket.id, socket);
+                    // it's paramount that the internal `onconnect` logic
+                    // fires before user-set events to prevent state order
+                    // violations (such as a disconnection before the connection
+                    // logic is complete)
+                    socket._onconnect();
+                    if (fn)
+                        fn();
+                    // fire user-set events
+                    this.emitReserved("connect", socket);
+                    this.emitReserved("connection", socket);
+                }
+                else {
+                    debug("next called after client was closed - ignoring socket");
+                }
+            });
+        });
+        return socket;
+    }
+    /**
+     * Removes a client. Called by each `Socket`.
+     *
+     * @private
+     */
+    _remove(socket) {
+        if (this.sockets.has(socket.id)) {
+            this.sockets.delete(socket.id);
+        }
+        else {
+            debug("ignoring remove for %s", socket.id);
+        }
+    }
+    /**
+     * Emits to all clients.
+     *
+     * @return Always true
+     * @public
+     */
+    emit(ev, ...args) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).emit(ev, ...args);
+    }
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    send(...args) {
+        this.emit("message", ...args);
+        return this;
+    }
+    /**
+     * Sends a `message` event to all clients.
+     *
+     * @return self
+     * @public
+     */
+    write(...args) {
+        this.emit("message", ...args);
+        return 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, ...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.
+     *
+     * @return self
+     * @public
+     */
+    allSockets() {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).allSockets();
+    }
+    /**
+     * Sets the compress flag.
+     *
+     * @param compress - if `true`, compresses the sending data
+     * @return self
+     * @public
+     */
+    compress(compress) {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).compress(compress);
+    }
+    /**
+     * 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 self
+     * @public
+     */
+    get volatile() {
+        return new broadcast_operator_1.BroadcastOperator(this.adapter).volatile;
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return self
+     * @public
+     */
+    get local() {
+        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);
+    }
+}
+exports.Namespace = Namespace;

assets/socket.io/dist/parent-namespace.d.ts

@@ -0,0 +1,15 @@
+import { Namespace } from "./namespace";
+import type { Server, RemoteSocket } from "./index";
+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<ListenEvents, EmitEvents, ServerSideEvents, SocketData>);
+    /**
+     * @private
+     */
+    _initAdapter(): void;
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    createChild(name: string): Namespace<ListenEvents, EmitEvents, ServerSideEvents, SocketData>;
+    fetchSockets(): Promise<RemoteSocket<EmitEvents, SocketData>[]>;
+}

assets/socket.io/dist/parent-namespace.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParentNamespace = void 0;
+const namespace_1 = require("./namespace");
+class ParentNamespace extends namespace_1.Namespace {
+    constructor(server) {
+        super(server, "/_" + ParentNamespace.count++);
+        this.children = new Set();
+    }
+    /**
+     * @private
+     */
+    _initAdapter() {
+        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.emit(ev, ...args);
+        });
+        return true;
+    }
+    createChild(name) {
+        const namespace = new namespace_1.Namespace(this.server, name);
+        namespace._fns = this._fns.slice(0);
+        this.listeners("connect").forEach((listener) => namespace.on("connect", listener));
+        this.listeners("connection").forEach((listener) => namespace.on("connection", listener));
+        this.children.add(namespace);
+        this.server._nsps.set(name, namespace);
+        return namespace;
+    }
+    fetchSockets() {
+        // note: we could make the fetchSockets() method work for dynamic namespaces created with a regex (by sending the
+        // regex to the other Socket.IO servers, and returning the sockets of each matching namespace for example), but
+        // the behavior for namespaces created with a function is less clear
+        // note²: we cannot loop over each children namespace, because with multiple Socket.IO servers, a given namespace
+        // may exist on one node but not exist on another (since it is created upon client connection)
+        throw new Error("fetchSockets() is not supported on parent namespaces");
+    }
+}
+exports.ParentNamespace = ParentNamespace;
+ParentNamespace.count = 0;

assets/socket.io/dist/socket.d.ts

@@ -0,0 +1,370 @@
+/// <reference types="node" />
+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";
+import type { IncomingMessage, IncomingHttpHeaders } from "http";
+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>;
+/**
+ * The handshake details
+ */
+export interface Handshake {
+    /**
+     * The headers sent as part of the handshake
+     */
+    headers: IncomingHttpHeaders;
+    /**
+     * The date of creation (as string)
+     */
+    time: string;
+    /**
+     * The ip of the client
+     */
+    address: string;
+    /**
+     * Whether the connection is cross-domain
+     */
+    xdomain: boolean;
+    /**
+     * Whether the connection is secure
+     */
+    secure: boolean;
+    /**
+     * The date of creation (as unix timestamp)
+     */
+    issued: number;
+    /**
+     * The request URL string
+     */
+    url: string;
+    /**
+     * The query object
+     */
+    query: ParsedUrlQuery;
+    /**
+     * The auth object
+     */
+    auth: {
+        [key: string]: any;
+    };
+}
+export 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;
+    private readonly server;
+    private readonly adapter;
+    private acks;
+    private fns;
+    private flags;
+    private _anyListeners?;
+    /**
+     * Interface to a `Client` for a given `Namespace`.
+     *
+     * @param {Namespace} nsp
+     * @param {Client} client
+     * @param {Object} auth
+     * @package
+     */
+    constructor(nsp: Namespace<ListenEvents, EmitEvents, ServerSideEvents>, client: Client<ListenEvents, EmitEvents, ServerSideEvents>, auth: object);
+    /**
+     * Builds the `handshake` BC object
+     *
+     * @private
+     */
+    private buildHandshake;
+    /**
+     * Emits to this client.
+     *
+     * @return Always returns `true`.
+     * @public
+     */
+    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
+    /**
+     * @private
+     */
+    private registerAckCallback;
+    /**
+     * Targets a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    to(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Targets a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Excludes a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Sends a `message` event.
+     *
+     * @return self
+     * @public
+     */
+    send(...args: EventParams<EmitEvents, "message">): this;
+    /**
+     * Sends a `message` event.
+     *
+     * @return self
+     * @public
+     */
+    write(...args: EventParams<EmitEvents, "message">): this;
+    /**
+     * Writes a packet.
+     *
+     * @param {Object} packet - packet object
+     * @param {Object} opts - options
+     * @private
+     */
+    private packet;
+    /**
+     * Joins a room.
+     *
+     * @param {String|Array} rooms - room or array of rooms
+     * @return a Promise or nothing, depending on the adapter
+     * @public
+     */
+    join(rooms: Room | Array<Room>): Promise<void> | void;
+    /**
+     * Leaves a room.
+     *
+     * @param {String} room
+     * @return a Promise or nothing, depending on the adapter
+     * @public
+     */
+    leave(room: string): Promise<void> | void;
+    /**
+     * Leave all rooms.
+     *
+     * @private
+     */
+    private leaveAll;
+    /**
+     * Called by `Namespace` upon successful
+     * middleware execution (ie: authorization).
+     * Socket is added to namespace array before
+     * call to join, so adapters can access it.
+     *
+     * @private
+     */
+    _onconnect(): void;
+    /**
+     * Called with each packet. Called by `Client`.
+     *
+     * @param {Object} packet
+     * @private
+     */
+    _onpacket(packet: Packet): void;
+    /**
+     * Called upon event packet.
+     *
+     * @param {Packet} packet - packet object
+     * @private
+     */
+    private onevent;
+    /**
+     * Produces an ack callback to emit with an event.
+     *
+     * @param {Number} id - packet id
+     * @private
+     */
+    private ack;
+    /**
+     * Called upon ack packet.
+     *
+     * @private
+     */
+    private onack;
+    /**
+     * Called upon client disconnect packet.
+     *
+     * @private
+     */
+    private ondisconnect;
+    /**
+     * Handles a client error.
+     *
+     * @private
+     */
+    _onerror(err: Error): void;
+    /**
+     * Called upon closing. Called by `Client`.
+     *
+     * @param {String} reason
+     * @throw {Error} optional error object
+     *
+     * @private
+     */
+    _onclose(reason: string): this | undefined;
+    /**
+     * Produces an `error` packet.
+     *
+     * @param {Object} err - error object
+     *
+     * @private
+     */
+    _error(err: any): void;
+    /**
+     * Disconnects this client.
+     *
+     * @param {Boolean} close - if `true`, closes the underlying connection
+     * @return {Socket} self
+     *
+     * @public
+     */
+    disconnect(close?: boolean): this;
+    /**
+     * Sets the compress flag.
+     *
+     * @param {Boolean} compress - if `true`, compresses the sending data
+     * @return {Socket} self
+     * @public
+     */
+    compress(compress: boolean): this;
+    /**
+     * 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 {Socket} self
+     * @public
+     */
+    get volatile(): this;
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the
+     * sender.
+     *
+     * @return {Socket} self
+     * @public
+     */
+    get broadcast(): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return {Socket} self
+     * @public
+     */
+    get local(): BroadcastOperator<EmitEvents, SocketData>;
+    /**
+     * 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.
+     *
+     * @param {Array} event - event that will get emitted
+     * @private
+     */
+    private dispatch;
+    /**
+     * Sets up socket middleware.
+     *
+     * @param {Function} fn - middleware function (event, next)
+     * @return {Socket} self
+     * @public
+     */
+    use(fn: (event: Event, next: (err?: Error) => void) => void): this;
+    /**
+     * Executes the middleware for an incoming event.
+     *
+     * @param {Array} event - event that will get emitted
+     * @param {Function} fn - last fn call in the middleware
+     * @private
+     */
+    private run;
+    /**
+     * Whether the socket is currently disconnected
+     */
+    get disconnected(): boolean;
+    /**
+     * A reference to the request that originated the underlying Engine.IO Socket.
+     *
+     * @public
+     */
+    get request(): IncomingMessage;
+    /**
+     * A reference to the underlying Client transport connection (Engine.IO Socket object).
+     *
+     * @public
+     */
+    get conn(): import("engine.io").Socket;
+    /**
+     * @public
+     */
+    get rooms(): Set<Room>;
+    /**
+     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+     * callback.
+     *
+     * @param listener
+     * @public
+     */
+    onAny(listener: (...args: any[]) => void): this;
+    /**
+     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+     * callback. The listener is added to the beginning of the listeners array.
+     *
+     * @param listener
+     * @public
+     */
+    prependAny(listener: (...args: any[]) => void): this;
+    /**
+     * Removes the listener that will be fired when any event is emitted.
+     *
+     * @param listener
+     * @public
+     */
+    offAny(listener?: (...args: any[]) => void): this;
+    /**
+     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+     * e.g. to remove listeners.
+     *
+     * @public
+     */
+    listenersAny(): ((...args: any[]) => void)[];
+    private newBroadcastOperator;
+}

assets/socket.io/dist/socket.js

@@ -0,0 +1,601 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Socket = exports.RESERVED_EVENTS = void 0;
+const socket_io_parser_1 = require("socket.io-parser");
+const debug_1 = __importDefault(require("debug"));
+const typed_events_1 = require("./typed-events");
+const base64id_1 = __importDefault(require("base64id"));
+const broadcast_operator_1 = require("./broadcast-operator");
+const debug = (0, debug_1.default)("socket.io:socket");
+exports.RESERVED_EVENTS = new Set([
+    "connect",
+    "connect_error",
+    "disconnect",
+    "disconnecting",
+    "newListener",
+    "removeListener",
+]);
+class Socket extends typed_events_1.StrictEventEmitter {
+    /**
+     * Interface to a `Client` for a given `Namespace`.
+     *
+     * @param {Namespace} nsp
+     * @param {Client} client
+     * @param {Object} auth
+     * @package
+     */
+    constructor(nsp, client, auth) {
+        super();
+        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.server = nsp.server;
+        this.adapter = this.nsp.adapter;
+        if (client.conn.protocol === 3) {
+            // @ts-ignore
+            this.id = nsp.name !== "/" ? nsp.name + "#" + client.id : client.id;
+        }
+        else {
+            this.id = base64id_1.default.generateId(); // don't reuse the Engine.IO id because it's sensitive information
+        }
+        this.handshake = this.buildHandshake(auth);
+    }
+    /**
+     * Builds the `handshake` BC object
+     *
+     * @private
+     */
+    buildHandshake(auth) {
+        return {
+            headers: this.request.headers,
+            time: new Date() + "",
+            address: this.conn.remoteAddress,
+            xdomain: !!this.request.headers.origin,
+            // @ts-ignore
+            secure: !!this.request.connection.encrypted,
+            issued: +new Date(),
+            url: this.request.url,
+            // @ts-ignore
+            query: this.request._query,
+            auth,
+        };
+    }
+    /**
+     * Emits to this client.
+     *
+     * @return Always returns `true`.
+     * @public
+     */
+    emit(ev, ...args) {
+        if (exports.RESERVED_EVENTS.has(ev)) {
+            throw new Error(`"${ev}" is a reserved event name`);
+        }
+        const data = [ev, ...args];
+        const packet = {
+            type: socket_io_parser_1.PacketType.EVENT,
+            data: data,
+        };
+        // access last argument to see if it's an ACK callback
+        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);
+        this.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 room
+     * @return self
+     * @public
+     */
+    to(room) {
+        return this.newBroadcastOperator().to(room);
+    }
+    /**
+     * Targets a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    in(room) {
+        return this.newBroadcastOperator().in(room);
+    }
+    /**
+     * Excludes a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room) {
+        return this.newBroadcastOperator().except(room);
+    }
+    /**
+     * Sends a `message` event.
+     *
+     * @return self
+     * @public
+     */
+    send(...args) {
+        this.emit("message", ...args);
+        return this;
+    }
+    /**
+     * Sends a `message` event.
+     *
+     * @return self
+     * @public
+     */
+    write(...args) {
+        this.emit("message", ...args);
+        return this;
+    }
+    /**
+     * Writes a packet.
+     *
+     * @param {Object} packet - packet object
+     * @param {Object} opts - options
+     * @private
+     */
+    packet(packet, opts = {}) {
+        packet.nsp = this.nsp.name;
+        opts.compress = false !== opts.compress;
+        this.client._packet(packet, opts);
+    }
+    /**
+     * Joins a room.
+     *
+     * @param {String|Array} rooms - room or array of rooms
+     * @return a Promise or nothing, depending on the adapter
+     * @public
+     */
+    join(rooms) {
+        debug("join room %s", rooms);
+        return this.adapter.addAll(this.id, new Set(Array.isArray(rooms) ? rooms : [rooms]));
+    }
+    /**
+     * Leaves a room.
+     *
+     * @param {String} room
+     * @return a Promise or nothing, depending on the adapter
+     * @public
+     */
+    leave(room) {
+        debug("leave room %s", room);
+        return this.adapter.del(this.id, room);
+    }
+    /**
+     * Leave all rooms.
+     *
+     * @private
+     */
+    leaveAll() {
+        this.adapter.delAll(this.id);
+    }
+    /**
+     * Called by `Namespace` upon successful
+     * middleware execution (ie: authorization).
+     * Socket is added to namespace array before
+     * call to join, so adapters can access it.
+     *
+     * @private
+     */
+    _onconnect() {
+        debug("socket connected - writing packet");
+        this.connected = true;
+        this.join(this.id);
+        if (this.conn.protocol === 3) {
+            this.packet({ type: socket_io_parser_1.PacketType.CONNECT });
+        }
+        else {
+            this.packet({ type: socket_io_parser_1.PacketType.CONNECT, data: { sid: this.id } });
+        }
+    }
+    /**
+     * Called with each packet. Called by `Client`.
+     *
+     * @param {Object} packet
+     * @private
+     */
+    _onpacket(packet) {
+        debug("got packet %j", packet);
+        switch (packet.type) {
+            case socket_io_parser_1.PacketType.EVENT:
+                this.onevent(packet);
+                break;
+            case socket_io_parser_1.PacketType.BINARY_EVENT:
+                this.onevent(packet);
+                break;
+            case socket_io_parser_1.PacketType.ACK:
+                this.onack(packet);
+                break;
+            case socket_io_parser_1.PacketType.BINARY_ACK:
+                this.onack(packet);
+                break;
+            case socket_io_parser_1.PacketType.DISCONNECT:
+                this.ondisconnect();
+                break;
+            case socket_io_parser_1.PacketType.CONNECT_ERROR:
+                this._onerror(new Error(packet.data));
+        }
+    }
+    /**
+     * Called upon event packet.
+     *
+     * @param {Packet} packet - packet object
+     * @private
+     */
+    onevent(packet) {
+        const args = packet.data || [];
+        debug("emitting event %j", args);
+        if (null != packet.id) {
+            debug("attaching ack callback to event");
+            args.push(this.ack(packet.id));
+        }
+        if (this._anyListeners && this._anyListeners.length) {
+            const listeners = this._anyListeners.slice();
+            for (const listener of listeners) {
+                listener.apply(this, args);
+            }
+        }
+        this.dispatch(args);
+    }
+    /**
+     * Produces an ack callback to emit with an event.
+     *
+     * @param {Number} id - packet id
+     * @private
+     */
+    ack(id) {
+        const self = this;
+        let sent = false;
+        return function () {
+            // prevent double callbacks
+            if (sent)
+                return;
+            const args = Array.prototype.slice.call(arguments);
+            debug("sending ack %j", args);
+            self.packet({
+                id: id,
+                type: socket_io_parser_1.PacketType.ACK,
+                data: args,
+            });
+            sent = true;
+        };
+    }
+    /**
+     * Called upon ack packet.
+     *
+     * @private
+     */
+    onack(packet) {
+        const ack = this.acks.get(packet.id);
+        if ("function" == typeof ack) {
+            debug("calling ack %s with %j", packet.id, packet.data);
+            ack.apply(this, packet.data);
+            this.acks.delete(packet.id);
+        }
+        else {
+            debug("bad ack %s", packet.id);
+        }
+    }
+    /**
+     * Called upon client disconnect packet.
+     *
+     * @private
+     */
+    ondisconnect() {
+        debug("got disconnect packet");
+        this._onclose("client namespace disconnect");
+    }
+    /**
+     * Handles a client error.
+     *
+     * @private
+     */
+    _onerror(err) {
+        if (this.listeners("error").length) {
+            this.emitReserved("error", err);
+        }
+        else {
+            console.error("Missing error handler on `socket`.");
+            console.error(err.stack);
+        }
+    }
+    /**
+     * Called upon closing. Called by `Client`.
+     *
+     * @param {String} reason
+     * @throw {Error} optional error object
+     *
+     * @private
+     */
+    _onclose(reason) {
+        if (!this.connected)
+            return this;
+        debug("closing socket - reason %s", reason);
+        this.emitReserved("disconnecting", reason);
+        this.leaveAll();
+        this.nsp._remove(this);
+        this.client._remove(this);
+        this.connected = false;
+        this.emitReserved("disconnect", reason);
+        return;
+    }
+    /**
+     * Produces an `error` packet.
+     *
+     * @param {Object} err - error object
+     *
+     * @private
+     */
+    _error(err) {
+        this.packet({ type: socket_io_parser_1.PacketType.CONNECT_ERROR, data: err });
+    }
+    /**
+     * Disconnects this client.
+     *
+     * @param {Boolean} close - if `true`, closes the underlying connection
+     * @return {Socket} self
+     *
+     * @public
+     */
+    disconnect(close = false) {
+        if (!this.connected)
+            return this;
+        if (close) {
+            this.client._disconnect();
+        }
+        else {
+            this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });
+            this._onclose("server namespace disconnect");
+        }
+        return this;
+    }
+    /**
+     * Sets the compress flag.
+     *
+     * @param {Boolean} compress - if `true`, compresses the sending data
+     * @return {Socket} self
+     * @public
+     */
+    compress(compress) {
+        this.flags.compress = compress;
+        return this;
+    }
+    /**
+     * 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 {Socket} self
+     * @public
+     */
+    get volatile() {
+        this.flags.volatile = true;
+        return this;
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the
+     * sender.
+     *
+     * @return {Socket} self
+     * @public
+     */
+    get broadcast() {
+        return this.newBroadcastOperator();
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+     *
+     * @return {Socket} self
+     * @public
+     */
+    get local() {
+        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;
+    }
+    /**
+     * Dispatch incoming event to socket listeners.
+     *
+     * @param {Array} event - event that will get emitted
+     * @private
+     */
+    dispatch(event) {
+        debug("dispatching an event %j", event);
+        this.run(event, (err) => {
+            process.nextTick(() => {
+                if (err) {
+                    return this._onerror(err);
+                }
+                if (this.connected) {
+                    super.emitUntyped.apply(this, event);
+                }
+                else {
+                    debug("ignore packet received after disconnection");
+                }
+            });
+        });
+    }
+    /**
+     * Sets up socket middleware.
+     *
+     * @param {Function} fn - middleware function (event, next)
+     * @return {Socket} self
+     * @public
+     */
+    use(fn) {
+        this.fns.push(fn);
+        return this;
+    }
+    /**
+     * Executes the middleware for an incoming event.
+     *
+     * @param {Array} event - event that will get emitted
+     * @param {Function} fn - last fn call in the middleware
+     * @private
+     */
+    run(event, fn) {
+        const fns = this.fns.slice(0);
+        if (!fns.length)
+            return fn(null);
+        function run(i) {
+            fns[i](event, function (err) {
+                // upon error, short-circuit
+                if (err)
+                    return fn(err);
+                // if no middleware left, summon callback
+                if (!fns[i + 1])
+                    return fn(null);
+                // go on to next
+                run(i + 1);
+            });
+        }
+        run(0);
+    }
+    /**
+     * Whether the socket is currently disconnected
+     */
+    get disconnected() {
+        return !this.connected;
+    }
+    /**
+     * A reference to the request that originated the underlying Engine.IO Socket.
+     *
+     * @public
+     */
+    get request() {
+        return this.client.request;
+    }
+    /**
+     * A reference to the underlying Client transport connection (Engine.IO Socket object).
+     *
+     * @public
+     */
+    get conn() {
+        return this.client.conn;
+    }
+    /**
+     * @public
+     */
+    get rooms() {
+        return this.adapter.socketRooms(this.id) || new Set();
+    }
+    /**
+     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+     * callback.
+     *
+     * @param listener
+     * @public
+     */
+    onAny(listener) {
+        this._anyListeners = this._anyListeners || [];
+        this._anyListeners.push(listener);
+        return this;
+    }
+    /**
+     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+     * callback. The listener is added to the beginning of the listeners array.
+     *
+     * @param listener
+     * @public
+     */
+    prependAny(listener) {
+        this._anyListeners = this._anyListeners || [];
+        this._anyListeners.unshift(listener);
+        return this;
+    }
+    /**
+     * Removes the listener that will be fired when any event is emitted.
+     *
+     * @param listener
+     * @public
+     */
+    offAny(listener) {
+        if (!this._anyListeners) {
+            return this;
+        }
+        if (listener) {
+            const listeners = this._anyListeners;
+            for (let i = 0; i < listeners.length; i++) {
+                if (listener === listeners[i]) {
+                    listeners.splice(i, 1);
+                    return this;
+                }
+            }
+        }
+        else {
+            this._anyListeners = [];
+        }
+        return this;
+    }
+    /**
+     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+     * e.g. to remove listeners.
+     *
+     * @public
+     */
+    listenersAny() {
+        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;

assets/socket.io/dist/typed-events.d.ts

@@ -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 {};

assets/socket.io/dist/typed-events.js

@@ -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;

assets/socket.io/dist/uws.d.ts

@@ -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;

assets/socket.io/dist/uws.js

@@ -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;