@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/engine.io/build/engine.io.js

@@ -0,0 +1,73 @@
+import { __exports as engine_io } from '../../../_virtual/engine.io.js';
+import require$$2 from 'http';
+import { __require as requireServer } from './server.js';
+import { __require as requireTransports } from './transports/index.js';
+import { __require as requireCjs } from '../../engine.io-parser/build/cjs/index.js';
+import { __require as requireUserver } from './userver.js';
+import { __require as requireSocket } from './socket.js';
+import { __require as requireTransport } from './transport.js';
+
+var hasRequiredEngine_io;
+
+function requireEngine_io () {
+	if (hasRequiredEngine_io) return engine_io;
+	hasRequiredEngine_io = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.protocol = exports.Transport = exports.Socket = exports.uServer = exports.parser = exports.transports = exports.Server = void 0;
+		exports.listen = listen;
+		exports.attach = attach;
+		const http_1 = require$$2;
+		const server_1 = requireServer();
+		Object.defineProperty(exports, "Server", { enumerable: true, get: function () { return server_1.Server; } });
+		const index_1 = requireTransports();
+		exports.transports = index_1.default;
+		const parser = requireCjs();
+		exports.parser = parser;
+		var userver_1 = requireUserver();
+		Object.defineProperty(exports, "uServer", { enumerable: true, get: function () { return userver_1.uServer; } });
+		var socket_1 = requireSocket();
+		Object.defineProperty(exports, "Socket", { enumerable: true, get: function () { return socket_1.Socket; } });
+		var transport_1 = requireTransport();
+		Object.defineProperty(exports, "Transport", { enumerable: true, get: function () { return transport_1.Transport; } });
+		exports.protocol = parser.protocol;
+		/**
+		 * Creates an http.Server exclusively used for WS upgrades.
+		 *
+		 * @param {Number} port
+		 * @param {Function} callback
+		 * @param {Object} options
+		 * @return {Server} websocket.io server
+		 */
+		function listen(port, options, fn) {
+		    if ("function" === typeof options) {
+		        fn = options;
+		        options = {};
+		    }
+		    const server = (0, http_1.createServer)(function (req, res) {
+		        res.writeHead(501);
+		        res.end("Not Implemented");
+		    });
+		    // create engine server
+		    const engine = attach(server, options);
+		    engine.httpServer = server;
+		    server.listen(port, fn);
+		    return engine;
+		}
+		/**
+		 * Captures upgrade requests for a http.Server.
+		 *
+		 * @param {http.Server} server
+		 * @param {Object} options
+		 * @return {Server} engine server
+		 */
+		function attach(server, options) {
+		    const engine = new server_1.Server(options);
+		    engine.attach(server, options);
+		    return engine;
+		} 
+	} (engine_io));
+	return engine_io;
+}
+
+export { requireEngine_io as __require };

package/dist/src/node_modules/engine.io/build/parser-v3/index.js

@@ -0,0 +1,429 @@
+import { __exports as parserV3 } from '../../../../_virtual/index21.js';
+import { __require as requireUtf8 } from './utf8.js';
+
+var hasRequiredParserV3;
+
+function requireParserV3 () {
+	if (hasRequiredParserV3) return parserV3;
+	hasRequiredParserV3 = 1;
+	(function (exports) {
+		// imported from https://github.com/socketio/engine.io-parser/tree/2.2.x
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.packets = exports.protocol = void 0;
+		exports.encodePacket = encodePacket;
+		exports.encodeBase64Packet = encodeBase64Packet;
+		exports.decodePacket = decodePacket;
+		exports.decodeBase64Packet = decodeBase64Packet;
+		exports.encodePayload = encodePayload;
+		exports.decodePayload = decodePayload;
+		exports.encodePayloadAsBinary = encodePayloadAsBinary;
+		exports.decodePayloadAsBinary = decodePayloadAsBinary;
+		/**
+		 * Module dependencies.
+		 */
+		var utf8 = requireUtf8();
+		/**
+		 * Current protocol version.
+		 */
+		exports.protocol = 3;
+		const hasBinary = (packets) => {
+		    for (const packet of packets) {
+		        if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
+		            return true;
+		        }
+		    }
+		    return false;
+		};
+		/**
+		 * Packet types.
+		 */
+		exports.packets = {
+		    open: 0 // non-ws
+		    ,
+		    close: 1 // non-ws
+		    ,
+		    ping: 2,
+		    pong: 3,
+		    message: 4,
+		    upgrade: 5,
+		    noop: 6
+		};
+		var packetslist = Object.keys(exports.packets);
+		/**
+		 * Premade error packet.
+		 */
+		var err = { type: 'error', data: 'parser error' };
+		const EMPTY_BUFFER = Buffer.concat([]);
+		/**
+		 * Encodes a packet.
+		 *
+		 *     <packet type id> [ <data> ]
+		 *
+		 * Example:
+		 *
+		 *     5hello world
+		 *     3
+		 *     4
+		 *
+		 * Binary is encoded in an identical principle
+		 *
+		 * @api private
+		 */
+		function encodePacket(packet, supportsBinary, utf8encode, callback) {
+		    if (typeof supportsBinary === 'function') {
+		        callback = supportsBinary;
+		        supportsBinary = null;
+		    }
+		    if (typeof utf8encode === 'function') {
+		        callback = utf8encode;
+		        utf8encode = null;
+		    }
+		    if (Buffer.isBuffer(packet.data)) {
+		        return encodeBuffer(packet, supportsBinary, callback);
+		    }
+		    else if (packet.data && (packet.data.buffer || packet.data) instanceof ArrayBuffer) {
+		        return encodeBuffer({ type: packet.type, data: arrayBufferToBuffer(packet.data) }, supportsBinary, callback);
+		    }
+		    // Sending data as a utf-8 string
+		    var encoded = exports.packets[packet.type];
+		    // data fragment is optional
+		    if (undefined !== packet.data) {
+		        encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);
+		    }
+		    return callback('' + encoded);
+		}
+		/**
+		 * Encode Buffer data
+		 */
+		function encodeBuffer(packet, supportsBinary, callback) {
+		    if (!supportsBinary) {
+		        return encodeBase64Packet(packet, callback);
+		    }
+		    var data = packet.data;
+		    var typeBuffer = Buffer.allocUnsafe(1);
+		    typeBuffer[0] = exports.packets[packet.type];
+		    return callback(Buffer.concat([typeBuffer, data]));
+		}
+		/**
+		 * Encodes a packet with binary data in a base64 string
+		 *
+		 * @param {Object} packet, has `type` and `data`
+		 * @return {String} base64 encoded message
+		 */
+		function encodeBase64Packet(packet, callback) {
+		    var data = Buffer.isBuffer(packet.data) ? packet.data : arrayBufferToBuffer(packet.data);
+		    var message = 'b' + exports.packets[packet.type];
+		    message += data.toString('base64');
+		    return callback(message);
+		}
+		/**
+		 * Decodes a packet. Data also available as an ArrayBuffer if requested.
+		 *
+		 * @return {Object} with `type` and `data` (if any)
+		 * @api private
+		 */
+		function decodePacket(data, binaryType, utf8decode) {
+		    if (data === undefined) {
+		        return err;
+		    }
+		    var type;
+		    // String data
+		    if (typeof data === 'string') {
+		        type = data.charAt(0);
+		        if (type === 'b') {
+		            return decodeBase64Packet(data.slice(1), binaryType);
+		        }
+		        if (utf8decode) {
+		            data = tryDecode(data);
+		            if (data === false) {
+		                return err;
+		            }
+		        }
+		        if (Number(type) != type || !packetslist[type]) {
+		            return err;
+		        }
+		        if (data.length > 1) {
+		            return { type: packetslist[type], data: data.slice(1) };
+		        }
+		        else {
+		            return { type: packetslist[type] };
+		        }
+		    }
+		    // Binary data
+		    if (binaryType === 'arraybuffer') {
+		        // wrap Buffer/ArrayBuffer data into an Uint8Array
+		        var intArray = new Uint8Array(data);
+		        type = intArray[0];
+		        return { type: packetslist[type], data: intArray.buffer.slice(1) };
+		    }
+		    if (data instanceof ArrayBuffer) {
+		        data = arrayBufferToBuffer(data);
+		    }
+		    type = data[0];
+		    return { type: packetslist[type], data: data.slice(1) };
+		}
+		function tryDecode(data) {
+		    try {
+		        data = utf8.decode(data, { strict: false });
+		    }
+		    catch (e) {
+		        return false;
+		    }
+		    return data;
+		}
+		/**
+		 * Decodes a packet encoded in a base64 string.
+		 *
+		 * @param {String} base64 encoded message
+		 * @return {Object} with `type` and `data` (if any)
+		 */
+		function decodeBase64Packet(msg, binaryType) {
+		    var type = packetslist[msg.charAt(0)];
+		    var data = Buffer.from(msg.slice(1), 'base64');
+		    if (binaryType === 'arraybuffer') {
+		        var abv = new Uint8Array(data.length);
+		        for (var i = 0; i < abv.length; i++) {
+		            abv[i] = data[i];
+		        }
+		        // @ts-ignore
+		        data = abv.buffer;
+		    }
+		    return { type: type, data: data };
+		}
+		/**
+		 * Encodes multiple messages (payload).
+		 *
+		 *     <length>:data
+		 *
+		 * Example:
+		 *
+		 *     11:hello world2:hi
+		 *
+		 * If any contents are binary, they will be encoded as base64 strings. Base64
+		 * encoded strings are marked with a b before the length specifier
+		 *
+		 * @param {Array} packets
+		 * @api private
+		 */
+		function encodePayload(packets, supportsBinary, callback) {
+		    if (typeof supportsBinary === 'function') {
+		        callback = supportsBinary;
+		        supportsBinary = null;
+		    }
+		    if (supportsBinary && hasBinary(packets)) {
+		        return encodePayloadAsBinary(packets, callback);
+		    }
+		    if (!packets.length) {
+		        return callback('0:');
+		    }
+		    function encodeOne(packet, doneCallback) {
+		        encodePacket(packet, supportsBinary, false, function (message) {
+		            doneCallback(null, setLengthHeader(message));
+		        });
+		    }
+		    map(packets, encodeOne, function (err, results) {
+		        return callback(results.join(''));
+		    });
+		}
+		function setLengthHeader(message) {
+		    return message.length + ':' + message;
+		}
+		/**
+		 * Async array map using after
+		 */
+		function map(ary, each, done) {
+		    const results = new Array(ary.length);
+		    let count = 0;
+		    for (let i = 0; i < ary.length; i++) {
+		        each(ary[i], (error, msg) => {
+		            results[i] = msg;
+		            if (++count === ary.length) {
+		                done(null, results);
+		            }
+		        });
+		    }
+		}
+		/*
+		 * Decodes data when a payload is maybe expected. Possible binary contents are
+		 * decoded from their base64 representation
+		 *
+		 * @param {String} data, callback method
+		 * @api public
+		 */
+		function decodePayload(data, binaryType, callback) {
+		    if (typeof data !== 'string') {
+		        return decodePayloadAsBinary(data, binaryType, callback);
+		    }
+		    if (typeof binaryType === 'function') {
+		        callback = binaryType;
+		        binaryType = null;
+		    }
+		    if (data === '') {
+		        // parser error - ignoring payload
+		        return callback(err, 0, 1);
+		    }
+		    var length = '', n, msg, packet;
+		    for (var i = 0, l = data.length; i < l; i++) {
+		        var chr = data.charAt(i);
+		        if (chr !== ':') {
+		            length += chr;
+		            continue;
+		        }
+		        // @ts-ignore
+		        if (length === '' || (length != (n = Number(length)))) {
+		            // parser error - ignoring payload
+		            return callback(err, 0, 1);
+		        }
+		        msg = data.slice(i + 1, i + 1 + n);
+		        if (length != msg.length) {
+		            // parser error - ignoring payload
+		            return callback(err, 0, 1);
+		        }
+		        if (msg.length) {
+		            packet = decodePacket(msg, binaryType, false);
+		            if (err.type === packet.type && err.data === packet.data) {
+		                // parser error in individual packet - ignoring payload
+		                return callback(err, 0, 1);
+		            }
+		            var more = callback(packet, i + n, l);
+		            if (false === more)
+		                return;
+		        }
+		        // advance cursor
+		        i += n;
+		        length = '';
+		    }
+		    if (length !== '') {
+		        // parser error - ignoring payload
+		        return callback(err, 0, 1);
+		    }
+		}
+		/**
+		 *
+		 * Converts a buffer to a utf8.js encoded string
+		 *
+		 * @api private
+		 */
+		function bufferToString(buffer) {
+		    var str = '';
+		    for (var i = 0, l = buffer.length; i < l; i++) {
+		        str += String.fromCharCode(buffer[i]);
+		    }
+		    return str;
+		}
+		/**
+		 *
+		 * Converts a utf8.js encoded string to a buffer
+		 *
+		 * @api private
+		 */
+		function stringToBuffer(string) {
+		    var buf = Buffer.allocUnsafe(string.length);
+		    for (var i = 0, l = string.length; i < l; i++) {
+		        buf.writeUInt8(string.charCodeAt(i), i);
+		    }
+		    return buf;
+		}
+		/**
+		 *
+		 * Converts an ArrayBuffer to a Buffer
+		 *
+		 * @api private
+		 */
+		function arrayBufferToBuffer(data) {
+		    // data is either an ArrayBuffer or ArrayBufferView.
+		    var length = data.byteLength || data.length;
+		    var offset = data.byteOffset || 0;
+		    return Buffer.from(data.buffer || data, offset, length);
+		}
+		/**
+		 * Encodes multiple messages (payload) as binary.
+		 *
+		 * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
+		 * 255><data>
+		 *
+		 * Example:
+		 * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
+		 *
+		 * @param {Array} packets
+		 * @return {Buffer} encoded payload
+		 * @api private
+		 */
+		function encodePayloadAsBinary(packets, callback) {
+		    if (!packets.length) {
+		        return callback(EMPTY_BUFFER);
+		    }
+		    map(packets, encodeOneBinaryPacket, function (err, results) {
+		        return callback(Buffer.concat(results));
+		    });
+		}
+		function encodeOneBinaryPacket(p, doneCallback) {
+		    function onBinaryPacketEncode(packet) {
+		        var encodingLength = '' + packet.length;
+		        var sizeBuffer;
+		        if (typeof packet === 'string') {
+		            sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
+		            sizeBuffer[0] = 0; // is a string (not true binary = 0)
+		            for (var i = 0; i < encodingLength.length; i++) {
+		                sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
+		            }
+		            sizeBuffer[sizeBuffer.length - 1] = 255;
+		            return doneCallback(null, Buffer.concat([sizeBuffer, stringToBuffer(packet)]));
+		        }
+		        sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
+		        sizeBuffer[0] = 1; // is binary (true binary = 1)
+		        for (var i = 0; i < encodingLength.length; i++) {
+		            sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
+		        }
+		        sizeBuffer[sizeBuffer.length - 1] = 255;
+		        doneCallback(null, Buffer.concat([sizeBuffer, packet]));
+		    }
+		    encodePacket(p, true, true, onBinaryPacketEncode);
+		}
+		/*
+		 * Decodes data when a payload is maybe expected. Strings are decoded by
+		 * interpreting each byte as a key code for entries marked to start with 0. See
+		 * description of encodePayloadAsBinary
+
+		 * @param {Buffer} data, callback method
+		 * @api public
+		 */
+		function decodePayloadAsBinary(data, binaryType, callback) {
+		    if (typeof binaryType === 'function') {
+		        callback = binaryType;
+		        binaryType = null;
+		    }
+		    var bufferTail = data;
+		    var buffers = [];
+		    var i;
+		    while (bufferTail.length > 0) {
+		        var strLen = '';
+		        var isString = bufferTail[0] === 0;
+		        for (i = 1;; i++) {
+		            if (bufferTail[i] === 255)
+		                break;
+		            // 310 = char length of Number.MAX_VALUE
+		            if (strLen.length > 310) {
+		                return callback(err, 0, 1);
+		            }
+		            strLen += '' + bufferTail[i];
+		        }
+		        bufferTail = bufferTail.slice(strLen.length + 1);
+		        var msgLength = parseInt(strLen, 10);
+		        var msg = bufferTail.slice(1, msgLength + 1);
+		        if (isString)
+		            msg = bufferToString(msg);
+		        buffers.push(msg);
+		        bufferTail = bufferTail.slice(msgLength + 1);
+		    }
+		    var total = buffers.length;
+		    for (i = 0; i < total; i++) {
+		        var buffer = buffers[i];
+		        callback(decodePacket(buffer, binaryType, true), i, total);
+		    }
+		}
+	} (parserV3));
+	return parserV3;
+}
+
+export { requireParserV3 as __require };

package/dist/src/node_modules/engine.io/build/parser-v3/utf8.js

@@ -0,0 +1,198 @@
+/*! https://mths.be/utf8js v2.1.2 by @mathias */
+
+var utf8;
+var hasRequiredUtf8;
+
+function requireUtf8 () {
+	if (hasRequiredUtf8) return utf8;
+	hasRequiredUtf8 = 1;
+	var stringFromCharCode = String.fromCharCode;
+	// Taken from https://mths.be/punycode
+	function ucs2decode(string) {
+	    var output = [];
+	    var counter = 0;
+	    var length = string.length;
+	    var value;
+	    var extra;
+	    while (counter < length) {
+	        value = string.charCodeAt(counter++);
+	        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+	            // high surrogate, and there is a next character
+	            extra = string.charCodeAt(counter++);
+	            if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+	                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+	            }
+	            else {
+	                // unmatched surrogate; only append this code unit, in case the next
+	                // code unit is the high surrogate of a surrogate pair
+	                output.push(value);
+	                counter--;
+	            }
+	        }
+	        else {
+	            output.push(value);
+	        }
+	    }
+	    return output;
+	}
+	// Taken from https://mths.be/punycode
+	function ucs2encode(array) {
+	    var length = array.length;
+	    var index = -1;
+	    var value;
+	    var output = '';
+	    while (++index < length) {
+	        value = array[index];
+	        if (value > 0xFFFF) {
+	            value -= 0x10000;
+	            output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+	            value = 0xDC00 | value & 0x3FF;
+	        }
+	        output += stringFromCharCode(value);
+	    }
+	    return output;
+	}
+	function checkScalarValue(codePoint, strict) {
+	    if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
+	        if (strict) {
+	            throw Error('Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
+	                ' is not a scalar value');
+	        }
+	        return false;
+	    }
+	    return true;
+	}
+	/*--------------------------------------------------------------------------*/
+	function createByte(codePoint, shift) {
+	    return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
+	}
+	function encodeCodePoint(codePoint, strict) {
+	    if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
+	        return stringFromCharCode(codePoint);
+	    }
+	    var symbol = '';
+	    if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
+	        symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
+	    }
+	    else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
+	        if (!checkScalarValue(codePoint, strict)) {
+	            codePoint = 0xFFFD;
+	        }
+	        symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
+	        symbol += createByte(codePoint, 6);
+	    }
+	    else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
+	        symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
+	        symbol += createByte(codePoint, 12);
+	        symbol += createByte(codePoint, 6);
+	    }
+	    symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
+	    return symbol;
+	}
+	function utf8encode(string, opts) {
+	    opts = opts || {};
+	    var strict = false !== opts.strict;
+	    var codePoints = ucs2decode(string);
+	    var length = codePoints.length;
+	    var index = -1;
+	    var codePoint;
+	    var byteString = '';
+	    while (++index < length) {
+	        codePoint = codePoints[index];
+	        byteString += encodeCodePoint(codePoint, strict);
+	    }
+	    return byteString;
+	}
+	/*--------------------------------------------------------------------------*/
+	function readContinuationByte() {
+	    if (byteIndex >= byteCount) {
+	        throw Error('Invalid byte index');
+	    }
+	    var continuationByte = byteArray[byteIndex] & 0xFF;
+	    byteIndex++;
+	    if ((continuationByte & 0xC0) == 0x80) {
+	        return continuationByte & 0x3F;
+	    }
+	    // If we end up here, it’s not a continuation byte
+	    throw Error('Invalid continuation byte');
+	}
+	function decodeSymbol(strict) {
+	    var byte1;
+	    var byte2;
+	    var byte3;
+	    var byte4;
+	    var codePoint;
+	    if (byteIndex > byteCount) {
+	        throw Error('Invalid byte index');
+	    }
+	    if (byteIndex == byteCount) {
+	        return false;
+	    }
+	    // Read first byte
+	    byte1 = byteArray[byteIndex] & 0xFF;
+	    byteIndex++;
+	    // 1-byte sequence (no continuation bytes)
+	    if ((byte1 & 0x80) == 0) {
+	        return byte1;
+	    }
+	    // 2-byte sequence
+	    if ((byte1 & 0xE0) == 0xC0) {
+	        byte2 = readContinuationByte();
+	        codePoint = ((byte1 & 0x1F) << 6) | byte2;
+	        if (codePoint >= 0x80) {
+	            return codePoint;
+	        }
+	        else {
+	            throw Error('Invalid continuation byte');
+	        }
+	    }
+	    // 3-byte sequence (may include unpaired surrogates)
+	    if ((byte1 & 0xF0) == 0xE0) {
+	        byte2 = readContinuationByte();
+	        byte3 = readContinuationByte();
+	        codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
+	        if (codePoint >= 0x0800) {
+	            return checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;
+	        }
+	        else {
+	            throw Error('Invalid continuation byte');
+	        }
+	    }
+	    // 4-byte sequence
+	    if ((byte1 & 0xF8) == 0xF0) {
+	        byte2 = readContinuationByte();
+	        byte3 = readContinuationByte();
+	        byte4 = readContinuationByte();
+	        codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
+	            (byte3 << 0x06) | byte4;
+	        if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
+	            return codePoint;
+	        }
+	    }
+	    throw Error('Invalid UTF-8 detected');
+	}
+	var byteArray;
+	var byteCount;
+	var byteIndex;
+	function utf8decode(byteString, opts) {
+	    opts = opts || {};
+	    var strict = false !== opts.strict;
+	    byteArray = ucs2decode(byteString);
+	    byteCount = byteArray.length;
+	    byteIndex = 0;
+	    var codePoints = [];
+	    var tmp;
+	    while ((tmp = decodeSymbol(strict)) !== false) {
+	        codePoints.push(tmp);
+	    }
+	    return ucs2encode(codePoints);
+	}
+	utf8 = {
+	    version: '2.1.2',
+	    encode: utf8encode,
+	    decode: utf8decode
+	};
+	return utf8;
+}
+
+export { requireUtf8 as __require };