{"version":3,"file":"engine.io-parser-b13552ae.js","sources":["../../node_modules/engine.io-parser/build/esm/commons.js","../../node_modules/engine.io-parser/build/esm/encodePacket.browser.js","../../node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.js","../../node_modules/engine.io-parser/build/esm/decodePacket.browser.js","../../node_modules/engine.io-parser/build/esm/index.js"],"sourcesContent":["const PACKET_TYPES = Object.create(null); // no Map = no polyfill\nPACKET_TYPES[\"open\"] = \"0\";\nPACKET_TYPES[\"close\"] = \"1\";\nPACKET_TYPES[\"ping\"] = \"2\";\nPACKET_TYPES[\"pong\"] = \"3\";\nPACKET_TYPES[\"message\"] = \"4\";\nPACKET_TYPES[\"upgrade\"] = \"5\";\nPACKET_TYPES[\"noop\"] = \"6\";\nconst PACKET_TYPES_REVERSE = Object.create(null);\nObject.keys(PACKET_TYPES).forEach((key) => {\n    PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;\n});\nconst ERROR_PACKET = { type: \"error\", data: \"parser error\" };\nexport { PACKET_TYPES, PACKET_TYPES_REVERSE, ERROR_PACKET };\n","import { PACKET_TYPES } from \"./commons.js\";\nconst withNativeBlob = typeof Blob === \"function\" ||\n    (typeof Blob !== \"undefined\" &&\n        Object.prototype.toString.call(Blob) === \"[object BlobConstructor]\");\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\n// ArrayBuffer.isView method is not defined in IE10\nconst isView = (obj) => {\n    return typeof ArrayBuffer.isView === \"function\"\n        ? ArrayBuffer.isView(obj)\n        : obj && obj.buffer instanceof ArrayBuffer;\n};\nconst encodePacket = ({ type, data }, supportsBinary, callback) => {\n    if (withNativeBlob && data instanceof Blob) {\n        if (supportsBinary) {\n            return callback(data);\n        }\n        else {\n            return encodeBlobAsBase64(data, callback);\n        }\n    }\n    else if (withNativeArrayBuffer &&\n        (data instanceof ArrayBuffer || isView(data))) {\n        if (supportsBinary) {\n            return callback(data);\n        }\n        else {\n            return encodeBlobAsBase64(new Blob([data]), callback);\n        }\n    }\n    // plain string\n    return callback(PACKET_TYPES[type] + (data || \"\"));\n};\nconst encodeBlobAsBase64 = (data, callback) => {\n    const fileReader = new FileReader();\n    fileReader.onload = function () {\n        const content = fileReader.result.split(\",\")[1];\n        callback(\"b\" + (content || \"\"));\n    };\n    return fileReader.readAsDataURL(data);\n};\nfunction toArray(data) {\n    if (data instanceof Uint8Array) {\n        return data;\n    }\n    else if (data instanceof ArrayBuffer) {\n        return new Uint8Array(data);\n    }\n    else {\n        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n    }\n}\nlet TEXT_ENCODER;\nexport function encodePacketToBinary(packet, callback) {\n    if (withNativeBlob && packet.data instanceof Blob) {\n        return packet.data.arrayBuffer().then(toArray).then(callback);\n    }\n    else if (withNativeArrayBuffer &&\n        (packet.data instanceof ArrayBuffer || isView(packet.data))) {\n        return callback(toArray(packet.data));\n    }\n    encodePacket(packet, false, (encoded) => {\n        if (!TEXT_ENCODER) {\n            TEXT_ENCODER = new TextEncoder();\n        }\n        callback(TEXT_ENCODER.encode(encoded));\n    });\n}\nexport { encodePacket };\n","// imported from https://github.com/socketio/base64-arraybuffer\nconst chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n// Use a lookup table to find the index.\nconst lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);\nfor (let i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n}\nexport const encode = (arraybuffer) => {\n    let bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';\n    for (i = 0; i < len; i += 3) {\n        base64 += chars[bytes[i] >> 2];\n        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n        base64 += chars[bytes[i + 2] & 63];\n    }\n    if (len % 3 === 2) {\n        base64 = base64.substring(0, base64.length - 1) + '=';\n    }\n    else if (len % 3 === 1) {\n        base64 = base64.substring(0, base64.length - 2) + '==';\n    }\n    return base64;\n};\nexport const decode = (base64) => {\n    let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;\n    if (base64[base64.length - 1] === '=') {\n        bufferLength--;\n        if (base64[base64.length - 2] === '=') {\n            bufferLength--;\n        }\n    }\n    const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);\n    for (i = 0; i < len; i += 4) {\n        encoded1 = lookup[base64.charCodeAt(i)];\n        encoded2 = lookup[base64.charCodeAt(i + 1)];\n        encoded3 = lookup[base64.charCodeAt(i + 2)];\n        encoded4 = lookup[base64.charCodeAt(i + 3)];\n        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n    return arraybuffer;\n};\n","import { ERROR_PACKET, PACKET_TYPES_REVERSE, } from \"./commons.js\";\nimport { decode } from \"./contrib/base64-arraybuffer.js\";\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nexport const decodePacket = (encodedPacket, binaryType) => {\n    if (typeof encodedPacket !== \"string\") {\n        return {\n            type: \"message\",\n            data: mapBinary(encodedPacket, binaryType),\n        };\n    }\n    const type = encodedPacket.charAt(0);\n    if (type === \"b\") {\n        return {\n            type: \"message\",\n            data: decodeBase64Packet(encodedPacket.substring(1), binaryType),\n        };\n    }\n    const packetType = PACKET_TYPES_REVERSE[type];\n    if (!packetType) {\n        return ERROR_PACKET;\n    }\n    return encodedPacket.length > 1\n        ? {\n            type: PACKET_TYPES_REVERSE[type],\n            data: encodedPacket.substring(1),\n        }\n        : {\n            type: PACKET_TYPES_REVERSE[type],\n        };\n};\nconst decodeBase64Packet = (data, binaryType) => {\n    if (withNativeArrayBuffer) {\n        const decoded = decode(data);\n        return mapBinary(decoded, binaryType);\n    }\n    else {\n        return { base64: true, data }; // fallback for old browsers\n    }\n};\nconst mapBinary = (data, binaryType) => {\n    switch (binaryType) {\n        case \"blob\":\n            if (data instanceof Blob) {\n                // from WebSocket + binaryType \"blob\"\n                return data;\n            }\n            else {\n                // from HTTP long-polling or WebTransport\n                return new Blob([data]);\n            }\n        case \"arraybuffer\":\n        default:\n            if (data instanceof ArrayBuffer) {\n                // from HTTP long-polling (base64) or WebSocket + binaryType \"arraybuffer\"\n                return data;\n            }\n            else {\n                // from WebTransport (Uint8Array)\n                return data.buffer;\n            }\n    }\n};\n","import { encodePacket, encodePacketToBinary } from \"./encodePacket.js\";\nimport { decodePacket } from \"./decodePacket.js\";\nimport { ERROR_PACKET, } from \"./commons.js\";\nconst SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text\nconst encodePayload = (packets, callback) => {\n    // some packets may be added to the array while encoding, so the initial length must be saved\n    const length = packets.length;\n    const encodedPackets = new Array(length);\n    let count = 0;\n    packets.forEach((packet, i) => {\n        // force base64 encoding for binary packets\n        encodePacket(packet, false, (encodedPacket) => {\n            encodedPackets[i] = encodedPacket;\n            if (++count === length) {\n                callback(encodedPackets.join(SEPARATOR));\n            }\n        });\n    });\n};\nconst decodePayload = (encodedPayload, binaryType) => {\n    const encodedPackets = encodedPayload.split(SEPARATOR);\n    const packets = [];\n    for (let i = 0; i < encodedPackets.length; i++) {\n        const decodedPacket = decodePacket(encodedPackets[i], binaryType);\n        packets.push(decodedPacket);\n        if (decodedPacket.type === \"error\") {\n            break;\n        }\n    }\n    return packets;\n};\nexport function createPacketEncoderStream() {\n    // @ts-expect-error\n    return new TransformStream({\n        transform(packet, controller) {\n            encodePacketToBinary(packet, (encodedPacket) => {\n                const payloadLength = encodedPacket.length;\n                let header;\n                // inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length\n                if (payloadLength < 126) {\n                    header = new Uint8Array(1);\n                    new DataView(header.buffer).setUint8(0, payloadLength);\n                }\n                else if (payloadLength < 65536) {\n                    header = new Uint8Array(3);\n                    const view = new DataView(header.buffer);\n                    view.setUint8(0, 126);\n                    view.setUint16(1, payloadLength);\n                }\n                else {\n                    header = new Uint8Array(9);\n                    const view = new DataView(header.buffer);\n                    view.setUint8(0, 127);\n                    view.setBigUint64(1, BigInt(payloadLength));\n                }\n                // first bit indicates whether the payload is plain text (0) or binary (1)\n                if (packet.data && typeof packet.data !== \"string\") {\n                    header[0] |= 0x80;\n                }\n                controller.enqueue(header);\n                controller.enqueue(encodedPacket);\n            });\n        },\n    });\n}\nlet TEXT_DECODER;\nfunction totalLength(chunks) {\n    return chunks.reduce((acc, chunk) => acc + chunk.length, 0);\n}\nfunction concatChunks(chunks, size) {\n    if (chunks[0].length === size) {\n        return chunks.shift();\n    }\n    const buffer = new Uint8Array(size);\n    let j = 0;\n    for (let i = 0; i < size; i++) {\n        buffer[i] = chunks[0][j++];\n        if (j === chunks[0].length) {\n            chunks.shift();\n            j = 0;\n        }\n    }\n    if (chunks.length && j < chunks[0].length) {\n        chunks[0] = chunks[0].slice(j);\n    }\n    return buffer;\n}\nexport function createPacketDecoderStream(maxPayload, binaryType) {\n    if (!TEXT_DECODER) {\n        TEXT_DECODER = new TextDecoder();\n    }\n    const chunks = [];\n    let state = 0 /* READ_HEADER */;\n    let expectedLength = -1;\n    let isBinary = false;\n    // @ts-expect-error\n    return new TransformStream({\n        transform(chunk, controller) {\n            chunks.push(chunk);\n            while (true) {\n                if (state === 0 /* READ_HEADER */) {\n                    if (totalLength(chunks) < 1) {\n                        break;\n                    }\n                    const header = concatChunks(chunks, 1);\n                    isBinary = (header[0] & 0x80) === 0x80;\n                    expectedLength = header[0] & 0x7f;\n                    if (expectedLength < 126) {\n                        state = 3 /* READ_PAYLOAD */;\n                    }\n                    else if (expectedLength === 126) {\n                        state = 1 /* READ_EXTENDED_LENGTH_16 */;\n                    }\n                    else {\n                        state = 2 /* READ_EXTENDED_LENGTH_64 */;\n                    }\n                }\n                else if (state === 1 /* READ_EXTENDED_LENGTH_16 */) {\n                    if (totalLength(chunks) < 2) {\n                        break;\n                    }\n                    const headerArray = concatChunks(chunks, 2);\n                    expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);\n                    state = 3 /* READ_PAYLOAD */;\n                }\n                else if (state === 2 /* READ_EXTENDED_LENGTH_64 */) {\n                    if (totalLength(chunks) < 8) {\n                        break;\n                    }\n                    const headerArray = concatChunks(chunks, 8);\n                    const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);\n                    const n = view.getUint32(0);\n                    if (n > Math.pow(2, 53 - 32) - 1) {\n                        // the maximum safe integer in JavaScript is 2^53 - 1\n                        controller.enqueue(ERROR_PACKET);\n                        break;\n                    }\n                    expectedLength = n * Math.pow(2, 32) + view.getUint32(4);\n                    state = 3 /* READ_PAYLOAD */;\n                }\n                else {\n                    if (totalLength(chunks) < expectedLength) {\n                        break;\n                    }\n                    const data = concatChunks(chunks, expectedLength);\n                    controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));\n                    state = 0 /* READ_HEADER */;\n                }\n                if (expectedLength === 0 || expectedLength > maxPayload) {\n                    controller.enqueue(ERROR_PACKET);\n                    break;\n                }\n            }\n        },\n    });\n}\nexport const protocol = 4;\nexport { encodePacket, encodePayload, decodePacket, decodePayload, };\n"],"names":["PACKET_TYPES","PACKET_TYPES_REVERSE","key","ERROR_PACKET","withNativeBlob","withNativeArrayBuffer","isView","obj","encodePacket","type","data","supportsBinary","callback","encodeBlobAsBase64","fileReader","content","toArray","TEXT_ENCODER","encodePacketToBinary","packet","encoded","chars","lookup","i","decode","base64","bufferLength","len","p","encoded1","encoded2","encoded3","encoded4","arraybuffer","bytes","decodePacket","encodedPacket","binaryType","mapBinary","decodeBase64Packet","decoded","SEPARATOR","encodePayload","packets","length","encodedPackets","count","decodePayload","encodedPayload","decodedPacket","createPacketEncoderStream","controller","payloadLength","header","view","TEXT_DECODER","totalLength","chunks","acc","chunk","concatChunks","size","buffer","j","createPacketDecoderStream","maxPayload","state","expectedLength","isBinary","headerArray","n","protocol"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4]}