@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/socket.io-client/build/esm/url.js

@@ -0,0 +1,63 @@
+import '../../../engine.io-client/build/esm/index.js';
+import { parse } from '../../../engine.io-client/build/esm/contrib/parseuri.js';
+
+/**
+ * URL parser.
+ *
+ * @param uri - url
+ * @param path - the request path of the connection
+ * @param loc - An object meant to mimic window.location.
+ *        Defaults to window.location.
+ * @public
+ */
+function url(uri, path = "", loc) {
+    let obj = uri;
+    // default to window.location
+    loc = loc || (typeof location !== "undefined" && location);
+    if (null == uri)
+        uri = loc.protocol + "//" + loc.host;
+    // relative path support
+    if (typeof uri === "string") {
+        if ("/" === uri.charAt(0)) {
+            if ("/" === uri.charAt(1)) {
+                uri = loc.protocol + uri;
+            }
+            else {
+                uri = loc.host + uri;
+            }
+        }
+        if (!/^(https?|wss?):\/\//.test(uri)) {
+            if ("undefined" !== typeof loc) {
+                uri = loc.protocol + "//" + uri;
+            }
+            else {
+                uri = "https://" + uri;
+            }
+        }
+        // parse
+        obj = parse(uri);
+    }
+    // make sure we treat `localhost:80` and `localhost` equally
+    if (!obj.port) {
+        if (/^(http|ws)$/.test(obj.protocol)) {
+            obj.port = "80";
+        }
+        else if (/^(http|ws)s$/.test(obj.protocol)) {
+            obj.port = "443";
+        }
+    }
+    obj.path = obj.path || "/";
+    const ipv6 = obj.host.indexOf(":") !== -1;
+    const host = ipv6 ? "[" + obj.host + "]" : obj.host;
+    // define unique id
+    obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
+    // define href
+    obj.href =
+        obj.protocol +
+            "://" +
+            host +
+            (loc && loc.port === obj.port ? "" : ":" + obj.port);
+    return obj;
+}
+
+export { url };

package/dist/src/node_modules/socket.io-parser/build/cjs/binary.js

@@ -0,0 +1,99 @@
+import { __exports as binary } from '../../../../_virtual/binary.js';
+import { __require as requireIsBinary } from './is-binary.js';
+
+var hasRequiredBinary;
+
+function requireBinary () {
+	if (hasRequiredBinary) return binary;
+	hasRequiredBinary = 1;
+	Object.defineProperty(binary, "__esModule", { value: true });
+	binary.reconstructPacket = binary.deconstructPacket = void 0;
+	const is_binary_js_1 = requireIsBinary();
+	/**
+	 * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
+	 *
+	 * @param {Object} packet - socket.io event packet
+	 * @return {Object} with deconstructed packet and list of buffers
+	 * @public
+	 */
+	function deconstructPacket(packet) {
+	    const buffers = [];
+	    const packetData = packet.data;
+	    const pack = packet;
+	    pack.data = _deconstructPacket(packetData, buffers);
+	    pack.attachments = buffers.length; // number of binary 'attachments'
+	    return { packet: pack, buffers: buffers };
+	}
+	binary.deconstructPacket = deconstructPacket;
+	function _deconstructPacket(data, buffers) {
+	    if (!data)
+	        return data;
+	    if ((0, is_binary_js_1.isBinary)(data)) {
+	        const placeholder = { _placeholder: true, num: buffers.length };
+	        buffers.push(data);
+	        return placeholder;
+	    }
+	    else if (Array.isArray(data)) {
+	        const newData = new Array(data.length);
+	        for (let i = 0; i < data.length; i++) {
+	            newData[i] = _deconstructPacket(data[i], buffers);
+	        }
+	        return newData;
+	    }
+	    else if (typeof data === "object" && !(data instanceof Date)) {
+	        const newData = {};
+	        for (const key in data) {
+	            if (Object.prototype.hasOwnProperty.call(data, key)) {
+	                newData[key] = _deconstructPacket(data[key], buffers);
+	            }
+	        }
+	        return newData;
+	    }
+	    return data;
+	}
+	/**
+	 * Reconstructs a binary packet from its placeholder packet and buffers
+	 *
+	 * @param {Object} packet - event packet with placeholders
+	 * @param {Array} buffers - binary buffers to put in placeholder positions
+	 * @return {Object} reconstructed packet
+	 * @public
+	 */
+	function reconstructPacket(packet, buffers) {
+	    packet.data = _reconstructPacket(packet.data, buffers);
+	    delete packet.attachments; // no longer useful
+	    return packet;
+	}
+	binary.reconstructPacket = reconstructPacket;
+	function _reconstructPacket(data, buffers) {
+	    if (!data)
+	        return data;
+	    if (data && data._placeholder === true) {
+	        const isIndexValid = typeof data.num === "number" &&
+	            data.num >= 0 &&
+	            data.num < buffers.length;
+	        if (isIndexValid) {
+	            return buffers[data.num]; // appropriate buffer (should be natural order anyway)
+	        }
+	        else {
+	            throw new Error("illegal attachments");
+	        }
+	    }
+	    else if (Array.isArray(data)) {
+	        for (let i = 0; i < data.length; i++) {
+	            data[i] = _reconstructPacket(data[i], buffers);
+	        }
+	    }
+	    else if (typeof data === "object") {
+	        for (const key in data) {
+	            if (Object.prototype.hasOwnProperty.call(data, key)) {
+	                data[key] = _reconstructPacket(data[key], buffers);
+	            }
+	        }
+	    }
+	    return data;
+	}
+	return binary;
+}
+
+export { requireBinary as __require };

package/dist/src/node_modules/socket.io-parser/build/cjs/index.js

@@ -0,0 +1,337 @@
+import { __exports as cjs } from '../../../../_virtual/index7.js';
+import require$$0 from '../../../../_virtual/index8.js';
+import { __require as requireBinary } from './binary.js';
+import { __require as requireIsBinary } from './is-binary.js';
+import { __require as requireSrc } from '../../node_modules/debug/src/index.js';
+
+var hasRequiredCjs;
+
+function requireCjs () {
+	if (hasRequiredCjs) return cjs;
+	hasRequiredCjs = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.Decoder = exports.Encoder = exports.PacketType = exports.protocol = void 0;
+		const component_emitter_1 = require$$0;
+		const binary_js_1 = requireBinary();
+		const is_binary_js_1 = requireIsBinary();
+		const debug_1 = requireSrc(); // debug()
+		const debug = (0, debug_1.default)("socket.io-parser"); // debug()
+		/**
+		 * These strings must not be used as event names, as they have a special meaning.
+		 */
+		const RESERVED_EVENTS = [
+		    "connect",
+		    "connect_error",
+		    "disconnect",
+		    "disconnecting",
+		    "newListener",
+		    "removeListener", // used by the Node.js EventEmitter
+		];
+		/**
+		 * Protocol version.
+		 *
+		 * @public
+		 */
+		exports.protocol = 5;
+		var PacketType;
+		(function (PacketType) {
+		    PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
+		    PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
+		    PacketType[PacketType["EVENT"] = 2] = "EVENT";
+		    PacketType[PacketType["ACK"] = 3] = "ACK";
+		    PacketType[PacketType["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
+		    PacketType[PacketType["BINARY_EVENT"] = 5] = "BINARY_EVENT";
+		    PacketType[PacketType["BINARY_ACK"] = 6] = "BINARY_ACK";
+		})(PacketType = exports.PacketType || (exports.PacketType = {}));
+		/**
+		 * A socket.io Encoder instance
+		 */
+		class Encoder {
+		    /**
+		     * Encoder constructor
+		     *
+		     * @param {function} replacer - custom replacer to pass down to JSON.parse
+		     */
+		    constructor(replacer) {
+		        this.replacer = replacer;
+		    }
+		    /**
+		     * Encode a packet as a single string if non-binary, or as a
+		     * buffer sequence, depending on packet type.
+		     *
+		     * @param {Object} obj - packet object
+		     */
+		    encode(obj) {
+		        debug("encoding packet %j", obj);
+		        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
+		            if ((0, is_binary_js_1.hasBinary)(obj)) {
+		                return this.encodeAsBinary({
+		                    type: obj.type === PacketType.EVENT
+		                        ? PacketType.BINARY_EVENT
+		                        : PacketType.BINARY_ACK,
+		                    nsp: obj.nsp,
+		                    data: obj.data,
+		                    id: obj.id,
+		                });
+		            }
+		        }
+		        return [this.encodeAsString(obj)];
+		    }
+		    /**
+		     * Encode packet as string.
+		     */
+		    encodeAsString(obj) {
+		        // first is type
+		        let str = "" + obj.type;
+		        // attachments if we have them
+		        if (obj.type === PacketType.BINARY_EVENT ||
+		            obj.type === PacketType.BINARY_ACK) {
+		            str += obj.attachments + "-";
+		        }
+		        // if we have a namespace other than `/`
+		        // we append it followed by a comma `,`
+		        if (obj.nsp && "/" !== obj.nsp) {
+		            str += obj.nsp + ",";
+		        }
+		        // immediately followed by the id
+		        if (null != obj.id) {
+		            str += obj.id;
+		        }
+		        // json data
+		        if (null != obj.data) {
+		            str += JSON.stringify(obj.data, this.replacer);
+		        }
+		        debug("encoded %j as %s", obj, str);
+		        return str;
+		    }
+		    /**
+		     * Encode packet as 'buffer sequence' by removing blobs, and
+		     * deconstructing packet into object with placeholders and
+		     * a list of buffers.
+		     */
+		    encodeAsBinary(obj) {
+		        const deconstruction = (0, binary_js_1.deconstructPacket)(obj);
+		        const pack = this.encodeAsString(deconstruction.packet);
+		        const buffers = deconstruction.buffers;
+		        buffers.unshift(pack); // add packet info to beginning of data list
+		        return buffers; // write all the buffers
+		    }
+		}
+		exports.Encoder = Encoder;
+		// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript
+		function isObject(value) {
+		    return Object.prototype.toString.call(value) === "[object Object]";
+		}
+		/**
+		 * A socket.io Decoder instance
+		 *
+		 * @return {Object} decoder
+		 */
+		class Decoder extends component_emitter_1.Emitter {
+		    /**
+		     * Decoder constructor
+		     *
+		     * @param {function} reviver - custom reviver to pass down to JSON.stringify
+		     */
+		    constructor(reviver) {
+		        super();
+		        this.reviver = reviver;
+		    }
+		    /**
+		     * Decodes an encoded packet string into packet JSON.
+		     *
+		     * @param {String} obj - encoded packet
+		     */
+		    add(obj) {
+		        let packet;
+		        if (typeof obj === "string") {
+		            if (this.reconstructor) {
+		                throw new Error("got plaintext data when reconstructing a packet");
+		            }
+		            packet = this.decodeString(obj);
+		            const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
+		            if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
+		                packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
+		                // binary packet's json
+		                this.reconstructor = new BinaryReconstructor(packet);
+		                // no attachments, labeled binary but no binary data to follow
+		                if (packet.attachments === 0) {
+		                    super.emitReserved("decoded", packet);
+		                }
+		            }
+		            else {
+		                // non-binary full packet
+		                super.emitReserved("decoded", packet);
+		            }
+		        }
+		        else if ((0, is_binary_js_1.isBinary)(obj) || obj.base64) {
+		            // raw binary data
+		            if (!this.reconstructor) {
+		                throw new Error("got binary data when not reconstructing a packet");
+		            }
+		            else {
+		                packet = this.reconstructor.takeBinaryData(obj);
+		                if (packet) {
+		                    // received final buffer
+		                    this.reconstructor = null;
+		                    super.emitReserved("decoded", packet);
+		                }
+		            }
+		        }
+		        else {
+		            throw new Error("Unknown type: " + obj);
+		        }
+		    }
+		    /**
+		     * Decode a packet String (JSON data)
+		     *
+		     * @param {String} str
+		     * @return {Object} packet
+		     */
+		    decodeString(str) {
+		        let i = 0;
+		        // look up type
+		        const p = {
+		            type: Number(str.charAt(0)),
+		        };
+		        if (PacketType[p.type] === undefined) {
+		            throw new Error("unknown packet type " + p.type);
+		        }
+		        // look up attachments if type binary
+		        if (p.type === PacketType.BINARY_EVENT ||
+		            p.type === PacketType.BINARY_ACK) {
+		            const start = i + 1;
+		            while (str.charAt(++i) !== "-" && i != str.length) { }
+		            const buf = str.substring(start, i);
+		            if (buf != Number(buf) || str.charAt(i) !== "-") {
+		                throw new Error("Illegal attachments");
+		            }
+		            p.attachments = Number(buf);
+		        }
+		        // look up namespace (if any)
+		        if ("/" === str.charAt(i + 1)) {
+		            const start = i + 1;
+		            while (++i) {
+		                const c = str.charAt(i);
+		                if ("," === c)
+		                    break;
+		                if (i === str.length)
+		                    break;
+		            }
+		            p.nsp = str.substring(start, i);
+		        }
+		        else {
+		            p.nsp = "/";
+		        }
+		        // look up id
+		        const next = str.charAt(i + 1);
+		        if ("" !== next && Number(next) == next) {
+		            const start = i + 1;
+		            while (++i) {
+		                const c = str.charAt(i);
+		                if (null == c || Number(c) != c) {
+		                    --i;
+		                    break;
+		                }
+		                if (i === str.length)
+		                    break;
+		            }
+		            p.id = Number(str.substring(start, i + 1));
+		        }
+		        // look up json data
+		        if (str.charAt(++i)) {
+		            const payload = this.tryParse(str.substr(i));
+		            if (Decoder.isPayloadValid(p.type, payload)) {
+		                p.data = payload;
+		            }
+		            else {
+		                throw new Error("invalid payload");
+		            }
+		        }
+		        debug("decoded %s as %j", str, p);
+		        return p;
+		    }
+		    tryParse(str) {
+		        try {
+		            return JSON.parse(str, this.reviver);
+		        }
+		        catch (e) {
+		            return false;
+		        }
+		    }
+		    static isPayloadValid(type, payload) {
+		        switch (type) {
+		            case PacketType.CONNECT:
+		                return isObject(payload);
+		            case PacketType.DISCONNECT:
+		                return payload === undefined;
+		            case PacketType.CONNECT_ERROR:
+		                return typeof payload === "string" || isObject(payload);
+		            case PacketType.EVENT:
+		            case PacketType.BINARY_EVENT:
+		                return (Array.isArray(payload) &&
+		                    (typeof payload[0] === "number" ||
+		                        (typeof payload[0] === "string" &&
+		                            RESERVED_EVENTS.indexOf(payload[0]) === -1)));
+		            case PacketType.ACK:
+		            case PacketType.BINARY_ACK:
+		                return Array.isArray(payload);
+		        }
+		    }
+		    /**
+		     * Deallocates a parser's resources
+		     */
+		    destroy() {
+		        if (this.reconstructor) {
+		            this.reconstructor.finishedReconstruction();
+		            this.reconstructor = null;
+		        }
+		    }
+		}
+		exports.Decoder = Decoder;
+		/**
+		 * A manager of a binary event's 'buffer sequence'. Should
+		 * be constructed whenever a packet of type BINARY_EVENT is
+		 * decoded.
+		 *
+		 * @param {Object} packet
+		 * @return {BinaryReconstructor} initialized reconstructor
+		 */
+		class BinaryReconstructor {
+		    constructor(packet) {
+		        this.packet = packet;
+		        this.buffers = [];
+		        this.reconPack = packet;
+		    }
+		    /**
+		     * Method to be called when binary data received from connection
+		     * after a BINARY_EVENT packet.
+		     *
+		     * @param {Buffer | ArrayBuffer} binData - the raw binary data received
+		     * @return {null | Object} returns null if more binary data is expected or
+		     *   a reconstructed packet object if all buffers have been received.
+		     */
+		    takeBinaryData(binData) {
+		        this.buffers.push(binData);
+		        if (this.buffers.length === this.reconPack.attachments) {
+		            // done with buffer list
+		            const packet = (0, binary_js_1.reconstructPacket)(this.reconPack, this.buffers);
+		            this.finishedReconstruction();
+		            return packet;
+		        }
+		        return null;
+		    }
+		    /**
+		     * Cleans up binary packet reconstruction variables.
+		     */
+		    finishedReconstruction() {
+		        this.reconPack = null;
+		        this.buffers = [];
+		    }
+		} 
+	} (cjs));
+	return cjs;
+}
+
+export { requireCjs as __require };

package/dist/src/node_modules/socket.io-parser/build/cjs/is-binary.js

@@ -0,0 +1,65 @@
+import { __exports as isBinary } from '../../../../_virtual/is-binary.js';
+
+var hasRequiredIsBinary;
+
+function requireIsBinary () {
+	if (hasRequiredIsBinary) return isBinary;
+	hasRequiredIsBinary = 1;
+	Object.defineProperty(isBinary, "__esModule", { value: true });
+	isBinary.hasBinary = isBinary.isBinary = void 0;
+	const withNativeArrayBuffer = typeof ArrayBuffer === "function";
+	const isView = (obj) => {
+	    return typeof ArrayBuffer.isView === "function"
+	        ? ArrayBuffer.isView(obj)
+	        : obj.buffer instanceof ArrayBuffer;
+	};
+	const toString = Object.prototype.toString;
+	const withNativeBlob = typeof Blob === "function" ||
+	    (typeof Blob !== "undefined" &&
+	        toString.call(Blob) === "[object BlobConstructor]");
+	const withNativeFile = typeof File === "function" ||
+	    (typeof File !== "undefined" &&
+	        toString.call(File) === "[object FileConstructor]");
+	/**
+	 * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.
+	 *
+	 * @private
+	 */
+	function isBinary$1(obj) {
+	    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||
+	        (withNativeBlob && obj instanceof Blob) ||
+	        (withNativeFile && obj instanceof File));
+	}
+	isBinary.isBinary = isBinary$1;
+	function hasBinary(obj, toJSON) {
+	    if (!obj || typeof obj !== "object") {
+	        return false;
+	    }
+	    if (Array.isArray(obj)) {
+	        for (let i = 0, l = obj.length; i < l; i++) {
+	            if (hasBinary(obj[i])) {
+	                return true;
+	            }
+	        }
+	        return false;
+	    }
+	    if (isBinary$1(obj)) {
+	        return true;
+	    }
+	    if (obj.toJSON &&
+	        typeof obj.toJSON === "function" &&
+	        arguments.length === 1) {
+	        return hasBinary(obj.toJSON(), true);
+	    }
+	    for (const key in obj) {
+	        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	isBinary.hasBinary = hasBinary;
+	return isBinary;
+}
+
+export { requireIsBinary as __require };

package/dist/src/node_modules/socket.io-parser/build/esm/binary.js

@@ -0,0 +1,86 @@
+import { isBinary } from './is-binary.js';
+
+/**
+ * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
+ *
+ * @param {Object} packet - socket.io event packet
+ * @return {Object} with deconstructed packet and list of buffers
+ * @public
+ */
+function deconstructPacket(packet) {
+    const buffers = [];
+    const packetData = packet.data;
+    const pack = packet;
+    pack.data = _deconstructPacket(packetData, buffers);
+    pack.attachments = buffers.length; // number of binary 'attachments'
+    return { packet: pack, buffers: buffers };
+}
+function _deconstructPacket(data, buffers) {
+    if (!data)
+        return data;
+    if (isBinary(data)) {
+        const placeholder = { _placeholder: true, num: buffers.length };
+        buffers.push(data);
+        return placeholder;
+    }
+    else if (Array.isArray(data)) {
+        const newData = new Array(data.length);
+        for (let i = 0; i < data.length; i++) {
+            newData[i] = _deconstructPacket(data[i], buffers);
+        }
+        return newData;
+    }
+    else if (typeof data === "object" && !(data instanceof Date)) {
+        const newData = {};
+        for (const key in data) {
+            if (Object.prototype.hasOwnProperty.call(data, key)) {
+                newData[key] = _deconstructPacket(data[key], buffers);
+            }
+        }
+        return newData;
+    }
+    return data;
+}
+/**
+ * Reconstructs a binary packet from its placeholder packet and buffers
+ *
+ * @param {Object} packet - event packet with placeholders
+ * @param {Array} buffers - binary buffers to put in placeholder positions
+ * @return {Object} reconstructed packet
+ * @public
+ */
+function reconstructPacket(packet, buffers) {
+    packet.data = _reconstructPacket(packet.data, buffers);
+    delete packet.attachments; // no longer useful
+    return packet;
+}
+function _reconstructPacket(data, buffers) {
+    if (!data)
+        return data;
+    if (data && data._placeholder === true) {
+        const isIndexValid = typeof data.num === "number" &&
+            data.num >= 0 &&
+            data.num < buffers.length;
+        if (isIndexValid) {
+            return buffers[data.num]; // appropriate buffer (should be natural order anyway)
+        }
+        else {
+            throw new Error("illegal attachments");
+        }
+    }
+    else if (Array.isArray(data)) {
+        for (let i = 0; i < data.length; i++) {
+            data[i] = _reconstructPacket(data[i], buffers);
+        }
+    }
+    else if (typeof data === "object") {
+        for (const key in data) {
+            if (Object.prototype.hasOwnProperty.call(data, key)) {
+                data[key] = _reconstructPacket(data[key], buffers);
+            }
+        }
+    }
+    return data;
+}
+
+export { deconstructPacket, reconstructPacket };