{"version":3,"file":"socket.io-parser-44417fca.js","sources":["../../node_modules/socket.io-parser/build/esm/is-binary.js","../../node_modules/socket.io-parser/build/esm/binary.js","../../node_modules/socket.io-parser/build/esm/index.js"],"sourcesContent":["const withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nconst isView = (obj) => {\n    return typeof ArrayBuffer.isView === \"function\"\n        ? ArrayBuffer.isView(obj)\n        : obj.buffer instanceof ArrayBuffer;\n};\nconst toString = Object.prototype.toString;\nconst withNativeBlob = typeof Blob === \"function\" ||\n    (typeof Blob !== \"undefined\" &&\n        toString.call(Blob) === \"[object BlobConstructor]\");\nconst withNativeFile = typeof File === \"function\" ||\n    (typeof File !== \"undefined\" &&\n        toString.call(File) === \"[object FileConstructor]\");\n/**\n * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.\n *\n * @private\n */\nexport function isBinary(obj) {\n    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||\n        (withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File));\n}\nexport function hasBinary(obj, toJSON) {\n    if (!obj || typeof obj !== \"object\") {\n        return false;\n    }\n    if (Array.isArray(obj)) {\n        for (let i = 0, l = obj.length; i < l; i++) {\n            if (hasBinary(obj[i])) {\n                return true;\n            }\n        }\n        return false;\n    }\n    if (isBinary(obj)) {\n        return true;\n    }\n    if (obj.toJSON &&\n        typeof obj.toJSON === \"function\" &&\n        arguments.length === 1) {\n        return hasBinary(obj.toJSON(), true);\n    }\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n            return true;\n        }\n    }\n    return false;\n}\n","import { isBinary } from \"./is-binary.js\";\n/**\n * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @public\n */\nexport function deconstructPacket(packet) {\n    const buffers = [];\n    const packetData = packet.data;\n    const pack = packet;\n    pack.data = _deconstructPacket(packetData, buffers);\n    pack.attachments = buffers.length; // number of binary 'attachments'\n    return { packet: pack, buffers: buffers };\n}\nfunction _deconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (isBinary(data)) {\n        const placeholder = { _placeholder: true, num: buffers.length };\n        buffers.push(data);\n        return placeholder;\n    }\n    else if (Array.isArray(data)) {\n        const newData = new Array(data.length);\n        for (let i = 0; i < data.length; i++) {\n            newData[i] = _deconstructPacket(data[i], buffers);\n        }\n        return newData;\n    }\n    else if (typeof data === \"object\" && !(data instanceof Date)) {\n        const newData = {};\n        for (const key in data) {\n            if (Object.prototype.hasOwnProperty.call(data, key)) {\n                newData[key] = _deconstructPacket(data[key], buffers);\n            }\n        }\n        return newData;\n    }\n    return data;\n}\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @public\n */\nexport function reconstructPacket(packet, buffers) {\n    packet.data = _reconstructPacket(packet.data, buffers);\n    delete packet.attachments; // no longer useful\n    return packet;\n}\nfunction _reconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (data && data._placeholder === true) {\n        const isIndexValid = typeof data.num === \"number\" &&\n            data.num >= 0 &&\n            data.num < buffers.length;\n        if (isIndexValid) {\n            return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n        }\n        else {\n            throw new Error(\"illegal attachments\");\n        }\n    }\n    else if (Array.isArray(data)) {\n        for (let i = 0; i < data.length; i++) {\n            data[i] = _reconstructPacket(data[i], buffers);\n        }\n    }\n    else if (typeof data === \"object\") {\n        for (const key in data) {\n            if (Object.prototype.hasOwnProperty.call(data, key)) {\n                data[key] = _reconstructPacket(data[key], buffers);\n            }\n        }\n    }\n    return data;\n}\n","import { Emitter } from \"@socket.io/component-emitter\";\nimport { deconstructPacket, reconstructPacket } from \"./binary.js\";\nimport { isBinary, hasBinary } from \"./is-binary.js\";\n/**\n * These strings must not be used as event names, as they have a special meaning.\n */\nconst RESERVED_EVENTS = [\n    \"connect\",\n    \"connect_error\",\n    \"disconnect\",\n    \"disconnecting\",\n    \"newListener\",\n    \"removeListener\", // used by the Node.js EventEmitter\n];\n/**\n * Protocol version.\n *\n * @public\n */\nexport const protocol = 5;\nexport var PacketType;\n(function (PacketType) {\n    PacketType[PacketType[\"CONNECT\"] = 0] = \"CONNECT\";\n    PacketType[PacketType[\"DISCONNECT\"] = 1] = \"DISCONNECT\";\n    PacketType[PacketType[\"EVENT\"] = 2] = \"EVENT\";\n    PacketType[PacketType[\"ACK\"] = 3] = \"ACK\";\n    PacketType[PacketType[\"CONNECT_ERROR\"] = 4] = \"CONNECT_ERROR\";\n    PacketType[PacketType[\"BINARY_EVENT\"] = 5] = \"BINARY_EVENT\";\n    PacketType[PacketType[\"BINARY_ACK\"] = 6] = \"BINARY_ACK\";\n})(PacketType || (PacketType = {}));\n/**\n * A socket.io Encoder instance\n */\nexport class Encoder {\n    /**\n     * Encoder constructor\n     *\n     * @param {function} replacer - custom replacer to pass down to JSON.parse\n     */\n    constructor(replacer) {\n        this.replacer = replacer;\n    }\n    /**\n     * Encode a packet as a single string if non-binary, or as a\n     * buffer sequence, depending on packet type.\n     *\n     * @param {Object} obj - packet object\n     */\n    encode(obj) {\n        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {\n            if (hasBinary(obj)) {\n                return this.encodeAsBinary({\n                    type: obj.type === PacketType.EVENT\n                        ? PacketType.BINARY_EVENT\n                        : PacketType.BINARY_ACK,\n                    nsp: obj.nsp,\n                    data: obj.data,\n                    id: obj.id,\n                });\n            }\n        }\n        return [this.encodeAsString(obj)];\n    }\n    /**\n     * Encode packet as string.\n     */\n    encodeAsString(obj) {\n        // first is type\n        let str = \"\" + obj.type;\n        // attachments if we have them\n        if (obj.type === PacketType.BINARY_EVENT ||\n            obj.type === PacketType.BINARY_ACK) {\n            str += obj.attachments + \"-\";\n        }\n        // if we have a namespace other than `/`\n        // we append it followed by a comma `,`\n        if (obj.nsp && \"/\" !== obj.nsp) {\n            str += obj.nsp + \",\";\n        }\n        // immediately followed by the id\n        if (null != obj.id) {\n            str += obj.id;\n        }\n        // json data\n        if (null != obj.data) {\n            str += JSON.stringify(obj.data, this.replacer);\n        }\n        return str;\n    }\n    /**\n     * Encode packet as 'buffer sequence' by removing blobs, and\n     * deconstructing packet into object with placeholders and\n     * a list of buffers.\n     */\n    encodeAsBinary(obj) {\n        const deconstruction = deconstructPacket(obj);\n        const pack = this.encodeAsString(deconstruction.packet);\n        const buffers = deconstruction.buffers;\n        buffers.unshift(pack); // add packet info to beginning of data list\n        return buffers; // write all the buffers\n    }\n}\n// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript\nfunction isObject(value) {\n    return Object.prototype.toString.call(value) === \"[object Object]\";\n}\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n */\nexport class Decoder extends Emitter {\n    /**\n     * Decoder constructor\n     *\n     * @param {function} reviver - custom reviver to pass down to JSON.stringify\n     */\n    constructor(reviver) {\n        super();\n        this.reviver = reviver;\n    }\n    /**\n     * Decodes an encoded packet string into packet JSON.\n     *\n     * @param {String} obj - encoded packet\n     */\n    add(obj) {\n        let packet;\n        if (typeof obj === \"string\") {\n            if (this.reconstructor) {\n                throw new Error(\"got plaintext data when reconstructing a packet\");\n            }\n            packet = this.decodeString(obj);\n            const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;\n            if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {\n                packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;\n                // binary packet's json\n                this.reconstructor = new BinaryReconstructor(packet);\n                // no attachments, labeled binary but no binary data to follow\n                if (packet.attachments === 0) {\n                    super.emitReserved(\"decoded\", packet);\n                }\n            }\n            else {\n                // non-binary full packet\n                super.emitReserved(\"decoded\", packet);\n            }\n        }\n        else if (isBinary(obj) || obj.base64) {\n            // raw binary data\n            if (!this.reconstructor) {\n                throw new Error(\"got binary data when not reconstructing a packet\");\n            }\n            else {\n                packet = this.reconstructor.takeBinaryData(obj);\n                if (packet) {\n                    // received final buffer\n                    this.reconstructor = null;\n                    super.emitReserved(\"decoded\", packet);\n                }\n            }\n        }\n        else {\n            throw new Error(\"Unknown type: \" + obj);\n        }\n    }\n    /**\n     * Decode a packet String (JSON data)\n     *\n     * @param {String} str\n     * @return {Object} packet\n     */\n    decodeString(str) {\n        let i = 0;\n        // look up type\n        const p = {\n            type: Number(str.charAt(0)),\n        };\n        if (PacketType[p.type] === undefined) {\n            throw new Error(\"unknown packet type \" + p.type);\n        }\n        // look up attachments if type binary\n        if (p.type === PacketType.BINARY_EVENT ||\n            p.type === PacketType.BINARY_ACK) {\n            const start = i + 1;\n            while (str.charAt(++i) !== \"-\" && i != str.length) { }\n            const buf = str.substring(start, i);\n            if (buf != Number(buf) || str.charAt(i) !== \"-\") {\n                throw new Error(\"Illegal attachments\");\n            }\n            p.attachments = Number(buf);\n        }\n        // look up namespace (if any)\n        if (\"/\" === str.charAt(i + 1)) {\n            const start = i + 1;\n            while (++i) {\n                const c = str.charAt(i);\n                if (\",\" === c)\n                    break;\n                if (i === str.length)\n                    break;\n            }\n            p.nsp = str.substring(start, i);\n        }\n        else {\n            p.nsp = \"/\";\n        }\n        // look up id\n        const next = str.charAt(i + 1);\n        if (\"\" !== next && Number(next) == next) {\n            const start = i + 1;\n            while (++i) {\n                const c = str.charAt(i);\n                if (null == c || Number(c) != c) {\n                    --i;\n                    break;\n                }\n                if (i === str.length)\n                    break;\n            }\n            p.id = Number(str.substring(start, i + 1));\n        }\n        // look up json data\n        if (str.charAt(++i)) {\n            const payload = this.tryParse(str.substr(i));\n            if (Decoder.isPayloadValid(p.type, payload)) {\n                p.data = payload;\n            }\n            else {\n                throw new Error(\"invalid payload\");\n            }\n        }\n        return p;\n    }\n    tryParse(str) {\n        try {\n            return JSON.parse(str, this.reviver);\n        }\n        catch (e) {\n            return false;\n        }\n    }\n    static isPayloadValid(type, payload) {\n        switch (type) {\n            case PacketType.CONNECT:\n                return isObject(payload);\n            case PacketType.DISCONNECT:\n                return payload === undefined;\n            case PacketType.CONNECT_ERROR:\n                return typeof payload === \"string\" || isObject(payload);\n            case PacketType.EVENT:\n            case PacketType.BINARY_EVENT:\n                return (Array.isArray(payload) &&\n                    (typeof payload[0] === \"number\" ||\n                        (typeof payload[0] === \"string\" &&\n                            RESERVED_EVENTS.indexOf(payload[0]) === -1)));\n            case PacketType.ACK:\n            case PacketType.BINARY_ACK:\n                return Array.isArray(payload);\n        }\n    }\n    /**\n     * Deallocates a parser's resources\n     */\n    destroy() {\n        if (this.reconstructor) {\n            this.reconstructor.finishedReconstruction();\n            this.reconstructor = null;\n        }\n    }\n}\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n */\nclass BinaryReconstructor {\n    constructor(packet) {\n        this.packet = packet;\n        this.buffers = [];\n        this.reconPack = packet;\n    }\n    /**\n     * Method to be called when binary data received from connection\n     * after a BINARY_EVENT packet.\n     *\n     * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n     * @return {null | Object} returns null if more binary data is expected or\n     *   a reconstructed packet object if all buffers have been received.\n     */\n    takeBinaryData(binData) {\n        this.buffers.push(binData);\n        if (this.buffers.length === this.reconPack.attachments) {\n            // done with buffer list\n            const packet = reconstructPacket(this.reconPack, this.buffers);\n            this.finishedReconstruction();\n            return packet;\n        }\n        return null;\n    }\n    /**\n     * Cleans up binary packet reconstruction variables.\n     */\n    finishedReconstruction() {\n        this.reconPack = null;\n        this.buffers = [];\n    }\n}\n"],"names":["withNativeArrayBuffer","isView","obj","toString","withNativeBlob","withNativeFile","isBinary","hasBinary","toJSON","i","l","key","deconstructPacket","packet","buffers","packetData","pack","_deconstructPacket","data","placeholder","newData","reconstructPacket","_reconstructPacket","RESERVED_EVENTS","protocol","PacketType","Encoder","replacer","str","deconstruction","isObject","value","Decoder","Emitter","reviver","isBinaryEvent","BinaryReconstructor","p","start","buf","next","payload","type","binData"],"mappings":"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","x_google_ignoreList":[0,1,2]}