@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/socket.io/dist/typed-events.js

@@ -0,0 +1,92 @@
+import { __exports as typedEvents } from '../../../_virtual/typed-events.js';
+import require$$0 from 'events';
+
+var hasRequiredTypedEvents;
+
+function requireTypedEvents () {
+	if (hasRequiredTypedEvents) return typedEvents;
+	hasRequiredTypedEvents = 1;
+	Object.defineProperty(typedEvents, "__esModule", { value: true });
+	typedEvents.StrictEventEmitter = void 0;
+	const events_1 = require$$0;
+	/**
+	 * 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);
+	    }
+	}
+	typedEvents.StrictEventEmitter = StrictEventEmitter;
+	return typedEvents;
+}
+
+export { requireTypedEvents as __require };

package/dist/src/node_modules/socket.io/dist/uws.js

@@ -0,0 +1,149 @@
+import { __exports as uws } from '../../../_virtual/uws.js';
+import { __require as requireDist } from '../../socket.io-adapter/dist/index.js';
+import require$$1 from 'fs';
+import { __require as requireSrc } from '../node_modules/debug/src/index.js';
+
+var hasRequiredUws;
+
+function requireUws () {
+	if (hasRequiredUws) return uws;
+	hasRequiredUws = 1;
+	var __importDefault = (uws && uws.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(uws, "__esModule", { value: true });
+	uws.patchAdapter = patchAdapter;
+	uws.restoreAdapter = restoreAdapter;
+	uws.serveFile = serveFile;
+	const socket_io_adapter_1 = requireDist();
+	const fs_1 = require$$1;
+	const debug_1 = __importDefault(requireSrc());
+	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) || this.nsp._preConnectSockets.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);
+	                if (rooms) {
+	                    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) || this.nsp._preConnectSockets.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);
+	            }
+	        });
+	    };
+	}
+	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;
+	}
+	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);
+	        res.cork(() => {
+	            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);
+	}
+	return uws;
+}
+
+export { requireUws as __require };

package/dist/src/node_modules/socket.io/node_modules/accepts/index.js

@@ -0,0 +1,250 @@
+import { __require as requireNegotiator } from '../negotiator/index.js';
+import { __require as requireMimeTypes } from '../mime-types/index.js';
+
+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var accepts;
+var hasRequiredAccepts;
+
+function requireAccepts () {
+	if (hasRequiredAccepts) return accepts;
+	hasRequiredAccepts = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var Negotiator = requireNegotiator();
+	var mime = requireMimeTypes();
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	accepts = Accepts;
+
+	/**
+	 * Create a new Accepts object for the given req.
+	 *
+	 * @param {object} req
+	 * @public
+	 */
+
+	function Accepts (req) {
+	  if (!(this instanceof Accepts)) {
+	    return new Accepts(req)
+	  }
+
+	  this.headers = req.headers;
+	  this.negotiator = new Negotiator(req);
+	}
+
+	/**
+	 * Check if the given `type(s)` is acceptable, returning
+	 * the best match when true, otherwise `undefined`, in which
+	 * case you should respond with 406 "Not Acceptable".
+	 *
+	 * The `type` value may be a single mime type string
+	 * such as "application/json", the extension name
+	 * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+	 * or array is given the _best_ match, if any is returned.
+	 *
+	 * Examples:
+	 *
+	 *     // Accept: text/html
+	 *     this.types('html');
+	 *     // => "html"
+	 *
+	 *     // Accept: text/*, application/json
+	 *     this.types('html');
+	 *     // => "html"
+	 *     this.types('text/html');
+	 *     // => "text/html"
+	 *     this.types('json', 'text');
+	 *     // => "json"
+	 *     this.types('application/json');
+	 *     // => "application/json"
+	 *
+	 *     // Accept: text/*, application/json
+	 *     this.types('image/png');
+	 *     this.types('png');
+	 *     // => undefined
+	 *
+	 *     // Accept: text/*;q=.5, application/json
+	 *     this.types(['html', 'json']);
+	 *     this.types('html', 'json');
+	 *     // => "json"
+	 *
+	 * @param {String|Array} types...
+	 * @return {String|Array|Boolean}
+	 * @public
+	 */
+
+	Accepts.prototype.type =
+	Accepts.prototype.types = function (types_) {
+	  var types = types_;
+
+	  // support flattened arguments
+	  if (types && !Array.isArray(types)) {
+	    types = new Array(arguments.length);
+	    for (var i = 0; i < types.length; i++) {
+	      types[i] = arguments[i];
+	    }
+	  }
+
+	  // no types, return all requested types
+	  if (!types || types.length === 0) {
+	    return this.negotiator.mediaTypes()
+	  }
+
+	  // no accept header, return first given type
+	  if (!this.headers.accept) {
+	    return types[0]
+	  }
+
+	  var mimes = types.map(extToMime);
+	  var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
+	  var first = accepts[0];
+
+	  return first
+	    ? types[mimes.indexOf(first)]
+	    : false
+	};
+
+	/**
+	 * Return accepted encodings or best fit based on `encodings`.
+	 *
+	 * Given `Accept-Encoding: gzip, deflate`
+	 * an array sorted by quality is returned:
+	 *
+	 *     ['gzip', 'deflate']
+	 *
+	 * @param {String|Array} encodings...
+	 * @return {String|Array}
+	 * @public
+	 */
+
+	Accepts.prototype.encoding =
+	Accepts.prototype.encodings = function (encodings_) {
+	  var encodings = encodings_;
+
+	  // support flattened arguments
+	  if (encodings && !Array.isArray(encodings)) {
+	    encodings = new Array(arguments.length);
+	    for (var i = 0; i < encodings.length; i++) {
+	      encodings[i] = arguments[i];
+	    }
+	  }
+
+	  // no encodings, return all requested encodings
+	  if (!encodings || encodings.length === 0) {
+	    return this.negotiator.encodings()
+	  }
+
+	  return this.negotiator.encodings(encodings)[0] || false
+	};
+
+	/**
+	 * Return accepted charsets or best fit based on `charsets`.
+	 *
+	 * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+	 * an array sorted by quality is returned:
+	 *
+	 *     ['utf-8', 'utf-7', 'iso-8859-1']
+	 *
+	 * @param {String|Array} charsets...
+	 * @return {String|Array}
+	 * @public
+	 */
+
+	Accepts.prototype.charset =
+	Accepts.prototype.charsets = function (charsets_) {
+	  var charsets = charsets_;
+
+	  // support flattened arguments
+	  if (charsets && !Array.isArray(charsets)) {
+	    charsets = new Array(arguments.length);
+	    for (var i = 0; i < charsets.length; i++) {
+	      charsets[i] = arguments[i];
+	    }
+	  }
+
+	  // no charsets, return all requested charsets
+	  if (!charsets || charsets.length === 0) {
+	    return this.negotiator.charsets()
+	  }
+
+	  return this.negotiator.charsets(charsets)[0] || false
+	};
+
+	/**
+	 * Return accepted languages or best fit based on `langs`.
+	 *
+	 * Given `Accept-Language: en;q=0.8, es, pt`
+	 * an array sorted by quality is returned:
+	 *
+	 *     ['es', 'pt', 'en']
+	 *
+	 * @param {String|Array} langs...
+	 * @return {Array|String}
+	 * @public
+	 */
+
+	Accepts.prototype.lang =
+	Accepts.prototype.langs =
+	Accepts.prototype.language =
+	Accepts.prototype.languages = function (languages_) {
+	  var languages = languages_;
+
+	  // support flattened arguments
+	  if (languages && !Array.isArray(languages)) {
+	    languages = new Array(arguments.length);
+	    for (var i = 0; i < languages.length; i++) {
+	      languages[i] = arguments[i];
+	    }
+	  }
+
+	  // no languages, return all requested languages
+	  if (!languages || languages.length === 0) {
+	    return this.negotiator.languages()
+	  }
+
+	  return this.negotiator.languages(languages)[0] || false
+	};
+
+	/**
+	 * Convert extnames to mime.
+	 *
+	 * @param {String} type
+	 * @return {String}
+	 * @private
+	 */
+
+	function extToMime (type) {
+	  return type.indexOf('/') === -1
+	    ? mime.lookup(type)
+	    : type
+	}
+
+	/**
+	 * Check if mime is valid.
+	 *
+	 * @param {String} type
+	 * @return {String}
+	 * @private
+	 */
+
+	function validMime (type) {
+	  return typeof type === 'string'
+	}
+	return accepts;
+}
+
+export { requireAccepts as __require };