@wabot-dev/framework 0.0.14 → 0.0.16

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

@@ -1,73 +0,0 @@
-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

@@ -1,429 +0,0 @@
-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

@@ -1,198 +0,0 @@
-/*! 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 };