node_modules/socket.io/dist/namespace.js - devtools/devtools-frontend - Git at Google

 "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"]);
 /**
  * A Namespace is a communication channel that allows you to split the logic of your application over a single shared
  * connection.
  *
  * Each namespace has its own:
  *
  * - event handlers
  *
  * ```
  * io.of("/orders").on("connection", (socket) => {
  *   socket.on("order:list", () => {});
  *   socket.on("order:create", () => {});
  * });
  *
  * io.of("/users").on("connection", (socket) => {
  *   socket.on("user:list", () => {});
  * });
  * ```
  *
  * - rooms
  *
  * ```
  * const orderNamespace = io.of("/orders");
  *
  * orderNamespace.on("connection", (socket) => {
  *   socket.join("room1");
  *   orderNamespace.to("room1").emit("hello");
  * });
  *
  * const userNamespace = io.of("/users");
  *
  * userNamespace.on("connection", (socket) => {
  *   socket.join("room1"); // distinct from the room in the "orders" namespace
  *   userNamespace.to("room1").emit("holà");
  * });
  * ```
  *
  * - middlewares
  *
  * ```
  * const orderNamespace = io.of("/orders");
  *
  * orderNamespace.use((socket, next) => {
  *   // ensure the socket has access to the "orders" namespace
  * });
  *
  * const userNamespace = io.of("/users");
  *
  * userNamespace.use((socket, next) => {
  *   // ensure the socket has access to the "users" 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);
     }
     /**
      * Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.use((socket, next) => {
      *   // ...
      *   next();
      * });
      *
      * @param fn - the middleware function
      */
     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.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // the “foo” event will be broadcast to all connected clients in the “room-101” room
      * myNamespace.to("room-101").emit("foo", "bar");
      *
      * // with an array of rooms (a client will be notified at most once)
      * myNamespace.to(["room-101", "room-102"]).emit("foo", "bar");
      *
      * // with multiple chained calls
      * myNamespace.to("room-101").to("room-102").emit("foo", "bar");
      *
      * @param room - a room, or an array of rooms
      * @return a new {@link BroadcastOperator} instance for chaining
      */
     to(room) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).to(room);
     }
     /**
      * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // disconnect all clients in the "room-101" room
      * myNamespace.in("room-101").disconnectSockets();
      *
      * @param room - a room, or an array of rooms
      * @return a new {@link BroadcastOperator} instance for chaining
      */
     in(room) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).in(room);
     }
     /**
      * Excludes a room when emitting.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
      * myNamespace.except("room-101").emit("foo", "bar");
      *
      * // with an array of rooms
      * myNamespace.except(["room-101", "room-102"]).emit("foo", "bar");
      *
      * // with multiple chained calls
      * myNamespace.except("room-101").except("room-102").emit("foo", "bar");
      *
      * @param room - a room, or an array of rooms
      * @return a new {@link BroadcastOperator} instance for chaining
      */
     except(room) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).except(room);
     }
     /**
      * Adds a new client.
      *
      * @return {Socket}
      * @private
      */
     async _add(client, auth, fn) {
         var _a;
         debug("adding socket to nsp %s", this.name);
         const socket = await this._createSocket(client, auth);
         if (
         // @ts-ignore
         ((_a = this.server.opts.connectionStateRecovery) === null || _a === void 0 ? void 0 : _a.skipMiddlewares) &&
             socket.recovered &&
             client.conn.readyState === "open") {
             return this._doConnect(socket, fn);
         }
         this.run(socket, (err) => {
             process.nextTick(() => {
                 if ("open" !== client.conn.readyState) {
                     debug("next called after client was closed - ignoring socket");
                     socket._cleanup();
                     return;
                 }
                 if (err) {
                     debug("middleware error, sending CONNECT_ERROR packet to the client");
                     socket._cleanup();
                     if (client.conn.protocol === 3) {
                         return socket._error(err.data || err.message);
                     }
                     else {
                         return socket._error({
                             message: err.message,
                             data: err.data,
                         });
                     }
                 }
                 this._doConnect(socket, fn);
             });
         });
     }
     async _createSocket(client, auth) {
         const sessionId = auth.pid;
         const offset = auth.offset;
         if (
         // @ts-ignore
         this.server.opts.connectionStateRecovery &&
             typeof sessionId === "string" &&
             typeof offset === "string") {
             let session;
             try {
                 session = await this.adapter.restoreSession(sessionId, offset);
             }
             catch (e) {
                 debug("error while restoring session: %s", e);
             }
             if (session) {
                 debug("connection state recovered for sid %s", session.sid);
                 return new socket_1.Socket(this, client, auth, session);
             }
         }
         return new socket_1.Socket(this, client, auth);
     }
     _doConnect(socket, fn) {
         // 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(socket);
         // fire user-set events
         this.emitReserved("connect", socket);
         this.emitReserved("connection", 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 connected clients.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.emit("hello", "world");
      *
      * // all serializable datastructures are supported (no need to call JSON.stringify)
      * myNamespace.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
      *
      * // with an acknowledgement from the clients
      * myNamespace.timeout(1000).emit("some-event", (err, responses) => {
      *   if (err) {
      *     // some clients did not acknowledge the event in the given delay
      *   } else {
      *     console.log(responses); // one response per client
      *   }
      * });
      *
      * @return Always true
      */
     emit(ev, ...args) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).emit(ev, ...args);
     }
     /**
      * Emits an event and waits for an acknowledgement from all clients.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * try {
      *   const responses = await myNamespace.timeout(1000).emitWithAck("some-event");
      *   console.log(responses); // one response per client
      * } catch (e) {
      *   // some clients did not acknowledge the event in the given delay
      * }
      *
      * @return a Promise that will be fulfilled when all clients have acknowledged the event
      */
     emitWithAck(ev, ...args) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).emitWithAck(ev, ...args);
     }
     /**
      * Sends a `message` event to all clients.
      *
      * This method mimics the WebSocket.send() method.
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.send("hello");
      *
      * // this is equivalent to
      * myNamespace.emit("message", "hello");
      *
      * @return self
      */
     send(...args) {
         this.emit("message", ...args);
         return this;
     }
     /**
      * Sends a `message` event to all clients. Sends a `message` event. Alias of {@link send}.
      *
      * @return self
      */
     write(...args) {
         this.emit("message", ...args);
         return this;
     }
     /**
      * Sends a message to the other Socket.IO servers of the cluster.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.serverSideEmit("hello", "world");
      *
      * myNamespace.on("hello", (arg1) => {
      *   console.log(arg1); // prints "world"
      * });
      *
      * // acknowledgements (without binary content) are supported too:
      * myNamespace.serverSideEmit("ping", (err, responses) => {
      *  if (err) {
      *     // some servers did not acknowledge the event in the given delay
      *   } else {
      *     console.log(responses); // one response per server (except the current one)
      *   }
      * });
      *
      * myNamespace.on("ping", (cb) => {
      *   cb("pong");
      * });
      *
      * @param ev - the event name
      * @param args - an array of arguments, which may include an acknowledgement callback at the end
      */
     serverSideEmit(ev, ...args) {
         if (exports.RESERVED_EVENTS.has(ev)) {
             throw new Error(`"${String(ev)}" is a reserved event name`);
         }
         args.unshift(ev);
         this.adapter.serverSideEmit(args);
         return true;
     }
     /**
      * Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * try {
      *   const responses = await myNamespace.serverSideEmitWithAck("ping");
      *   console.log(responses); // one response per server (except the current one)
      * } catch (e) {
      *   // some servers did not acknowledge the event in the given delay
      * }
      *
      * @param ev - the event name
      * @param args - an array of arguments
      *
      * @return a Promise that will be fulfilled when all servers have acknowledged the event
      */
     serverSideEmitWithAck(ev, ...args) {
         return new Promise((resolve, reject) => {
             args.push((err, responses) => {
                 if (err) {
                     err.responses = responses;
                     return reject(err);
                 }
                 else {
                     return resolve(responses);
                 }
             });
             this.serverSideEmit(ev, ...args);
         });
     }
     /**
      * 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.
      *
      * @deprecated this method will be removed in the next major release, please use {@link Namespace#serverSideEmit} or
      * {@link Namespace#fetchSockets} instead.
      */
     allSockets() {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).allSockets();
     }
     /**
      * Sets the compress flag.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.compress(false).emit("hello");
      *
      * @param compress - if `true`, compresses the sending data
      * @return self
      */
     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).
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.volatile.emit("hello"); // the clients may or may not receive it
      *
      * @return self
      */
     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.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // the “foo” event will be broadcast to all connected clients on this node
      * myNamespace.local.emit("foo", "bar");
      *
      * @return a new {@link BroadcastOperator} instance for chaining
      */
     get local() {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).local;
     }
     /**
      * Adds a timeout in milliseconds for the next operation.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * myNamespace.timeout(1000).emit("some-event", (err, responses) => {
      *   if (err) {
      *     // some clients did not acknowledge the event in the given delay
      *   } else {
      *     console.log(responses); // one response per client
      *   }
      * });
      *
      * @param timeout
      */
     timeout(timeout) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).timeout(timeout);
     }
     /**
      * Returns the matching socket instances.
      *
      * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // return all Socket instances
      * const sockets = await myNamespace.fetchSockets();
      *
      * // return all Socket instances in the "room1" room
      * const sockets = await myNamespace.in("room1").fetchSockets();
      *
      * for (const socket of sockets) {
      *   console.log(socket.id);
      *   console.log(socket.handshake);
      *   console.log(socket.rooms);
      *   console.log(socket.data);
      *
      *   socket.emit("hello");
      *   socket.join("room1");
      *   socket.leave("room2");
      *   socket.disconnect();
      * }
      */
     fetchSockets() {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).fetchSockets();
     }
     /**
      * Makes the matching socket instances join the specified rooms.
      *
      * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // make all socket instances join the "room1" room
      * myNamespace.socketsJoin("room1");
      *
      * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
      * myNamespace.in("room1").socketsJoin(["room2", "room3"]);
      *
      * @param room - a room, or an array of rooms
      */
     socketsJoin(room) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsJoin(room);
     }
     /**
      * Makes the matching socket instances leave the specified rooms.
      *
      * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // make all socket instances leave the "room1" room
      * myNamespace.socketsLeave("room1");
      *
      * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
      * myNamespace.in("room1").socketsLeave(["room2", "room3"]);
      *
      * @param room - a room, or an array of rooms
      */
     socketsLeave(room) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsLeave(room);
     }
     /**
      * Makes the matching socket instances disconnect.
      *
      * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
      *
      * @example
      * const myNamespace = io.of("/my-namespace");
      *
      * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
      * myNamespace.disconnectSockets();
      *
      * // make all socket instances in the "room1" room disconnect and close the underlying connections
      * myNamespace.in("room1").disconnectSockets(true);
      *
      * @param close - whether to close the underlying connection
      */
     disconnectSockets(close = false) {
         return new broadcast_operator_1.BroadcastOperator(this.adapter).disconnectSockets(close);
     }
 }
 exports.Namespace = Namespace;
	"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"]);
	/**
	* A Namespace is a communication channel that allows you to split the logic of your application over a single shared
	* connection.
	*
	* Each namespace has its own:
	*
	* - event handlers
	*
	* ```
	* io.of("/orders").on("connection", (socket) => {
	* socket.on("order:list", () => {});
	* socket.on("order:create", () => {});
	* });
	*
	* io.of("/users").on("connection", (socket) => {
	* socket.on("user:list", () => {});
	* });
	* ```
	*
	* - rooms
	*
	* ```
	* const orderNamespace = io.of("/orders");
	*
	* orderNamespace.on("connection", (socket) => {
	* socket.join("room1");
	* orderNamespace.to("room1").emit("hello");
	* });
	*
	* const userNamespace = io.of("/users");
	*
	* userNamespace.on("connection", (socket) => {
	* socket.join("room1"); // distinct from the room in the "orders" namespace
	* userNamespace.to("room1").emit("holà");
	* });
	* ```
	*
	* - middlewares
	*
	* ```
	* const orderNamespace = io.of("/orders");
	*
	* orderNamespace.use((socket, next) => {
	* // ensure the socket has access to the "orders" namespace
	* });
	*
	* const userNamespace = io.of("/users");
	*
	* userNamespace.use((socket, next) => {
	* // ensure the socket has access to the "users" 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);
	}
	/**
	* Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.use((socket, next) => {
	* // ...
	* next();
	* });
	*
	* @param fn - the middleware function
	*/
	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.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // the “foo” event will be broadcast to all connected clients in the “room-101” room
	* myNamespace.to("room-101").emit("foo", "bar");
	*
	* // with an array of rooms (a client will be notified at most once)
	* myNamespace.to(["room-101", "room-102"]).emit("foo", "bar");
	*
	* // with multiple chained calls
	* myNamespace.to("room-101").to("room-102").emit("foo", "bar");
	*
	* @param room - a room, or an array of rooms
	* @return a new {@link BroadcastOperator} instance for chaining
	*/
	to(room) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).to(room);
	}
	/**
	* Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // disconnect all clients in the "room-101" room
	* myNamespace.in("room-101").disconnectSockets();
	*
	* @param room - a room, or an array of rooms
	* @return a new {@link BroadcastOperator} instance for chaining
	*/
	in(room) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).in(room);
	}
	/**
	* Excludes a room when emitting.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
	* myNamespace.except("room-101").emit("foo", "bar");
	*
	* // with an array of rooms
	* myNamespace.except(["room-101", "room-102"]).emit("foo", "bar");
	*
	* // with multiple chained calls
	* myNamespace.except("room-101").except("room-102").emit("foo", "bar");
	*
	* @param room - a room, or an array of rooms
	* @return a new {@link BroadcastOperator} instance for chaining
	*/
	except(room) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).except(room);
	}
	/**
	* Adds a new client.
	*
	* @return {Socket}
	* @private
	*/
	async _add(client, auth, fn) {
	var _a;
	debug("adding socket to nsp %s", this.name);
	const socket = await this._createSocket(client, auth);
	if (
	// @ts-ignore
	((_a = this.server.opts.connectionStateRecovery) === null \|\| _a === void 0 ? void 0 : _a.skipMiddlewares) &&
	socket.recovered &&
	client.conn.readyState === "open") {
	return this._doConnect(socket, fn);
	}
	this.run(socket, (err) => {
	process.nextTick(() => {
	if ("open" !== client.conn.readyState) {
	debug("next called after client was closed - ignoring socket");
	socket._cleanup();
	return;
	}
	if (err) {
	debug("middleware error, sending CONNECT_ERROR packet to the client");
	socket._cleanup();
	if (client.conn.protocol === 3) {
	return socket._error(err.data \|\| err.message);
	}
	else {
	return socket._error({
	message: err.message,
	data: err.data,
	});
	}
	}
	this._doConnect(socket, fn);
	});
	});
	}
	async _createSocket(client, auth) {
	const sessionId = auth.pid;
	const offset = auth.offset;
	if (
	// @ts-ignore
	this.server.opts.connectionStateRecovery &&
	typeof sessionId === "string" &&
	typeof offset === "string") {
	let session;
	try {
	session = await this.adapter.restoreSession(sessionId, offset);
	}
	catch (e) {
	debug("error while restoring session: %s", e);
	}
	if (session) {
	debug("connection state recovered for sid %s", session.sid);
	return new socket_1.Socket(this, client, auth, session);
	}
	}
	return new socket_1.Socket(this, client, auth);
	}
	_doConnect(socket, fn) {
	// 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(socket);
	// fire user-set events
	this.emitReserved("connect", socket);
	this.emitReserved("connection", 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 connected clients.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.emit("hello", "world");
	*
	* // all serializable datastructures are supported (no need to call JSON.stringify)
	* myNamespace.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
	*
	* // with an acknowledgement from the clients
	* myNamespace.timeout(1000).emit("some-event", (err, responses) => {
	* if (err) {
	* // some clients did not acknowledge the event in the given delay
	* } else {
	* console.log(responses); // one response per client
	* }
	* });
	*
	* @return Always true
	*/
	emit(ev, ...args) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).emit(ev, ...args);
	}
	/**
	* Emits an event and waits for an acknowledgement from all clients.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* try {
	* const responses = await myNamespace.timeout(1000).emitWithAck("some-event");
	* console.log(responses); // one response per client
	* } catch (e) {
	* // some clients did not acknowledge the event in the given delay
	* }
	*
	* @return a Promise that will be fulfilled when all clients have acknowledged the event
	*/
	emitWithAck(ev, ...args) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).emitWithAck(ev, ...args);
	}
	/**
	* Sends a `message` event to all clients.
	*
	* This method mimics the WebSocket.send() method.
	*
	* @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.send("hello");
	*
	* // this is equivalent to
	* myNamespace.emit("message", "hello");
	*
	* @return self
	*/
	send(...args) {
	this.emit("message", ...args);
	return this;
	}
	/**
	* Sends a `message` event to all clients. Sends a `message` event. Alias of {@link send}.
	*
	* @return self
	*/
	write(...args) {
	this.emit("message", ...args);
	return this;
	}
	/**
	* Sends a message to the other Socket.IO servers of the cluster.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.serverSideEmit("hello", "world");
	*
	* myNamespace.on("hello", (arg1) => {
	* console.log(arg1); // prints "world"
	* });
	*
	* // acknowledgements (without binary content) are supported too:
	* myNamespace.serverSideEmit("ping", (err, responses) => {
	* if (err) {
	* // some servers did not acknowledge the event in the given delay
	* } else {
	* console.log(responses); // one response per server (except the current one)
	* }
	* });
	*
	* myNamespace.on("ping", (cb) => {
	* cb("pong");
	* });
	*
	* @param ev - the event name
	* @param args - an array of arguments, which may include an acknowledgement callback at the end
	*/
	serverSideEmit(ev, ...args) {
	if (exports.RESERVED_EVENTS.has(ev)) {
	throw new Error(`"${String(ev)}" is a reserved event name`);
	}
	args.unshift(ev);
	this.adapter.serverSideEmit(args);
	return true;
	}
	/**
	* Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* try {
	* const responses = await myNamespace.serverSideEmitWithAck("ping");
	* console.log(responses); // one response per server (except the current one)
	* } catch (e) {
	* // some servers did not acknowledge the event in the given delay
	* }
	*
	* @param ev - the event name
	* @param args - an array of arguments
	*
	* @return a Promise that will be fulfilled when all servers have acknowledged the event
	*/
	serverSideEmitWithAck(ev, ...args) {
	return new Promise((resolve, reject) => {
	args.push((err, responses) => {
	if (err) {
	err.responses = responses;
	return reject(err);
	}
	else {
	return resolve(responses);
	}
	});
	this.serverSideEmit(ev, ...args);
	});
	}
	/**
	* 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.
	*
	* @deprecated this method will be removed in the next major release, please use {@link Namespace#serverSideEmit} or
	* {@link Namespace#fetchSockets} instead.
	*/
	allSockets() {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).allSockets();
	}
	/**
	* Sets the compress flag.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.compress(false).emit("hello");
	*
	* @param compress - if `true`, compresses the sending data
	* @return self
	*/
	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).
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.volatile.emit("hello"); // the clients may or may not receive it
	*
	* @return self
	*/
	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.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // the “foo” event will be broadcast to all connected clients on this node
	* myNamespace.local.emit("foo", "bar");
	*
	* @return a new {@link BroadcastOperator} instance for chaining
	*/
	get local() {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).local;
	}
	/**
	* Adds a timeout in milliseconds for the next operation.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* myNamespace.timeout(1000).emit("some-event", (err, responses) => {
	* if (err) {
	* // some clients did not acknowledge the event in the given delay
	* } else {
	* console.log(responses); // one response per client
	* }
	* });
	*
	* @param timeout
	*/
	timeout(timeout) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).timeout(timeout);
	}
	/**
	* Returns the matching socket instances.
	*
	* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // return all Socket instances
	* const sockets = await myNamespace.fetchSockets();
	*
	* // return all Socket instances in the "room1" room
	* const sockets = await myNamespace.in("room1").fetchSockets();
	*
	* for (const socket of sockets) {
	* console.log(socket.id);
	* console.log(socket.handshake);
	* console.log(socket.rooms);
	* console.log(socket.data);
	*
	* socket.emit("hello");
	* socket.join("room1");
	* socket.leave("room2");
	* socket.disconnect();
	* }
	*/
	fetchSockets() {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).fetchSockets();
	}
	/**
	* Makes the matching socket instances join the specified rooms.
	*
	* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // make all socket instances join the "room1" room
	* myNamespace.socketsJoin("room1");
	*
	* // make all socket instances in the "room1" room join the "room2" and "room3" rooms
	* myNamespace.in("room1").socketsJoin(["room2", "room3"]);
	*
	* @param room - a room, or an array of rooms
	*/
	socketsJoin(room) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsJoin(room);
	}
	/**
	* Makes the matching socket instances leave the specified rooms.
	*
	* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // make all socket instances leave the "room1" room
	* myNamespace.socketsLeave("room1");
	*
	* // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
	* myNamespace.in("room1").socketsLeave(["room2", "room3"]);
	*
	* @param room - a room, or an array of rooms
	*/
	socketsLeave(room) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsLeave(room);
	}
	/**
	* Makes the matching socket instances disconnect.
	*
	* Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
	*
	* @example
	* const myNamespace = io.of("/my-namespace");
	*
	* // make all socket instances disconnect (the connections might be kept alive for other namespaces)
	* myNamespace.disconnectSockets();
	*
	* // make all socket instances in the "room1" room disconnect and close the underlying connections
	* myNamespace.in("room1").disconnectSockets(true);
	*
	* @param close - whether to close the underlying connection
	*/
	disconnectSockets(close = false) {
	return new broadcast_operator_1.BroadcastOperator(this.adapter).disconnectSockets(close);
	}
	}
	exports.Namespace = Namespace;