nodejs-insta-private-api-mqt 1.3.82 → 1.3.84

package/dist-ts/dist/thrift/thrift.reading.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferReader = exports.thriftReadToObject = exports.thriftRead = void 0;
+const thrift_1 = require("./thrift");
+const errors_1 = require("../errors");
+/**
+ * Thrift Compact Protocol reader (subset) for MQTT-over-Thrift payloads.
+ * Fixes / improvements:
+ * - fixes infinite loop in thriftRead()
+ * - correct INT_64 list decoding (BigInt zigzag varint)
+ * - faster descriptor lookup via Map in thriftReadSingleLevel()
+ * - keeps existing INT_64 return shape: { int: BigInt, num: Number, safe?: boolean }
+ */
+function thriftRead(message) {
+    const reader = new BufferReader(message);
+    const messages = [];
+    let context = "";
+    // FIX: iterate using reader.position, not a constant local var
+    while (reader.position < message.length) {
+        const type = reader.readField();
+        if (type === thrift_1.ThriftTypes.STOP) {
+            if (reader.stack.length === 0)
+                return messages;
+            reader.popStack();
+            context = reader.stack.join("/");
+            continue;
+        }
+        else if (type === thrift_1.ThriftTypes.STRUCT) {
+            reader.pushStack();
+            context = reader.stack.join("/");
+            continue;
+        }
+        messages.push(getReadFunction(type)({ reader, context }));
+    }
+    return messages;
+}
+exports.thriftRead = thriftRead;
+function getReadFunction(type) {
+    switch (type) {
+        case thrift_1.ThriftTypes.STRUCT:
+        case thrift_1.ThriftTypes.STOP: {
+            throw new errors_1.InvalidStateError(`Invalid state: got type ${type}`);
+        }
+        case thrift_1.ThriftTypes.TRUE:
+        case thrift_1.ThriftTypes.FALSE:
+            return ({ reader, context }) => ({
+                context,
+                field: reader.field,
+                value: type === thrift_1.ThriftTypes.TRUE,
+                type,
+            });
+        case thrift_1.ThriftTypes.BYTE:
+            return ({ reader, context }) => ({
+                context,
+                field: reader.field,
+                value: reader.readSByte(),
+                type,
+            });
+        case thrift_1.ThriftTypes.INT_16:
+        case thrift_1.ThriftTypes.INT_32:
+            return ({ reader, context }) => ({
+                context,
+                field: reader.field,
+                value: reader.readSmallInt(),
+                type,
+            });
+        case thrift_1.ThriftTypes.INT_64:
+            return ({ reader, context }) => ({
+                context,
+                field: reader.field,
+                value: reader.readBigint(),
+                type,
+            });
+        case thrift_1.ThriftTypes.BINARY:
+            return ({ reader, context }) => ({
+                context,
+                field: reader.field,
+                value: reader.readString(reader.readVarInt()),
+                type,
+            });
+        case thrift_1.ThriftTypes.SET:
+        case thrift_1.ThriftTypes.LIST:
+            return ({ reader, context }) => {
+                const byte = reader.readByte();
+                let size = byte >> 4;
+                const listType = byte & 0x0f;
+                if (size === 0x0f)
+                    size = reader.readVarInt();
+                return {
+                    context,
+                    field: reader.field,
+                    value: reader.readList(size, listType),
+                    type: (listType << 8) | type,
+                };
+            };
+        case thrift_1.ThriftTypes.MAP:
+            return ({ reader, context }) => {
+                const size = reader.readVarInt();
+                const kvType = size ? reader.readByte() : 0;
+                const keyType = (kvType & 0xf0) >> 4;
+                const valueType = kvType & 0x0f;
+                if (size && keyType && valueType) {
+                    const keyFunc = getReadFunction(keyType);
+                    const valueFunc = getReadFunction(valueType);
+                    const entries = [];
+                    for (let i = 0; i < size; i++) {
+                        entries.push({
+                            key: keyFunc({ reader, context }),
+                            value: valueFunc({ reader, context }),
+                        });
+                    }
+                    return {
+                        context,
+                        field: reader.field,
+                        value: entries,
+                        type: (kvType << 8) | type,
+                    };
+                }
+                return {
+                    context,
+                    field: reader.field,
+                    value: [],
+                    type: (kvType << 8) | type,
+                };
+            };
+        default: {
+            throw new errors_1.ThriftError(`Unknown type: ${type}`);
+        }
+    }
+}
+function thriftReadToObject(message, descriptors) {
+    var _a, _b;
+    const readResult = thriftRead(message);
+    const topLevel = readResult.filter((x) => x.context.length === 0);
+    const result = thriftReadSingleLevel(topLevel, descriptors);
+    const structs = [];
+    for (const readData of readResult) {
+        if (readData.context.length === 0)
+            continue;
+        const fieldPath = readData.context.split("/").map((c) => Number(c));
+        const possible = structs.findIndex((s) => equalArrays(s.fieldPath, fieldPath));
+        if (possible !== -1) {
+            structs[possible].items.push(readData);
+        }
+        else {
+            structs.push({ fieldPath, items: [readData] });
+        }
+    }
+    for (const struct of structs) {
+        let descriptor;
+        for (const level of struct.fieldPath) {
+            if (descriptor)
+                descriptor = (_a = descriptor.structDescriptors) === null || _a === void 0 ? void 0 : _a.find((x) => x.field === level);
+            else
+                descriptor = descriptors.find((x) => x.field === level);
+            if (!descriptor)
+                break;
+        }
+        if (descriptor) {
+            defineEnumerableProperty(result, descriptor.fieldName, thriftReadSingleLevel(struct.items, (_b = descriptor.structDescriptors) !== null && _b !== void 0 ? _b : []));
+        }
+        else {
+            if (result.otherFindings)
+                result.otherFindings.push(struct);
+            else
+                result.otherFindings = [struct];
+        }
+    }
+    return result;
+}
+exports.thriftReadToObject = thriftReadToObject;
+function thriftReadSingleLevel(readResults, descriptors) {
+    const result = {};
+    const otherFindings = [];
+    // PERF: build lookup map once
+    const byField = new Map();
+    for (const d of descriptors) {
+        // multiple descriptors could share field? keep first
+        if (!byField.has(d.field))
+            byField.set(d.field, []);
+        byField.get(d.field).push(d);
+    }
+    for (const message of readResults) {
+        const candidates = byField.get(message.field) || [];
+        const descriptor = candidates.find((d) => d.type === message.type ||
+            ((0, thrift_1.isThriftBoolean)(message.type) && (0, thrift_1.isThriftBoolean)(d.type)));
+        if (descriptor) {
+            // special checks for maps
+            if (descriptor.type === thrift_1.ThriftTypes.MAP_BINARY_BINARY) {
+                const res = {};
+                for (const pair of message.value) {
+                    defineEnumerableProperty(res, pair.key.value, pair.value.value);
+                }
+                defineEnumerableProperty(result, descriptor.fieldName, res);
+                continue;
+            }
+            defineEnumerableProperty(result, descriptor.fieldName, message.value);
+        }
+        else {
+            otherFindings.push(message);
+        }
+    }
+    return otherFindings.length > 0 ? { ...result, otherFindings } : result;
+}
+const defineEnumerableProperty = (object, name, value) => Object.defineProperty(object, name, { value, enumerable: true });
+class BufferReader {
+    get stack() {
+        return this._stack;
+    }
+    get position() {
+        return this._position;
+    }
+    get length() {
+        return this.buffer.length;
+    }
+    get field() {
+        return this._field;
+    }
+    constructor(buffer) {
+        this._stack = [];
+        this._position = 0;
+        this._field = 0;
+        this.readInt16 = this.readSmallInt;
+        this.readInt32 = this.readSmallInt;
+        this.readByte = () => this.buffer.readUInt8(this.move(1));
+        this.readSByte = () => this.buffer.readInt8(this.move(1));
+        this.readString = (len) => this.buffer.toString("utf8", this.move(len), this._position);
+        this.buffer = buffer;
+    }
+    move(bytes) {
+        this._position = Math.min(Math.max(this._position + bytes, 0), this.buffer.length);
+        return this._position - bytes;
+    }
+    readVarInt() {
+        let shift = 0;
+        let result = 0;
+        while (this._position < this.length) {
+            const byte = this.readByte();
+            result |= (byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0)
+                break;
+            shift += 7;
+        }
+        return result;
+    }
+    readVarBigint() {
+        let shift = BigInt(0);
+        let result = BigInt(0);
+        while (true) {
+            const byte = this.readByte();
+            result = result | ((BigInt(byte) & BigInt(0x7f)) << shift);
+            if ((byte & 0x80) !== 0x80)
+                break;
+            shift += BigInt(7);
+        }
+        return result;
+    }
+    zigzagToBigint(n) {
+        return (n >> BigInt(1)) ^ -(n & BigInt(1));
+    }
+    readBigint() {
+        const int = this.zigzagToBigint(this.readVarBigint());
+        const num = Number(int);
+        // keep backward shape, add a hint without breaking callers
+        const safe = int <= BigInt(Number.MAX_SAFE_INTEGER) && int >= BigInt(Number.MIN_SAFE_INTEGER);
+        return safe ? { int, num } : { int, num, safe };
+    }
+    readSmallInt() {
+        return BufferReader.fromZigZag(this.readVarInt());
+    }
+    readField() {
+        const byte = this.readByte();
+        if (byte === 0)
+            return thrift_1.ThriftTypes.STOP;
+        const delta = (byte & 0xf0) >> 4;
+        if (delta === 0) {
+            this._field = BufferReader.fromZigZag(this.readVarInt());
+        }
+        else {
+            this._field += delta;
+        }
+        return byte & 0x0f;
+    }
+    readList(size, type) {
+        const arr = [];
+        switch (type) {
+            case thrift_1.ThriftTypes.TRUE:
+            case thrift_1.ThriftTypes.FALSE: {
+                for (let i = 0; i < size; i++)
+                    arr[i] = this.readSByte() === thrift_1.ThriftTypes.TRUE;
+                break;
+            }
+            case thrift_1.ThriftTypes.BYTE: {
+                for (let i = 0; i < size; i++)
+                    arr[i] = this.readSByte();
+                break;
+            }
+            case thrift_1.ThriftTypes.INT_16:
+            case thrift_1.ThriftTypes.INT_32: {
+                for (let i = 0; i < size; i++)
+                    arr[i] = BufferReader.fromZigZag(this.readVarInt());
+                break;
+            }
+            case thrift_1.ThriftTypes.INT_64: {
+                // FIX: proper bigint varint + zigzag
+                for (let i = 0; i < size; i++)
+                    arr[i] = this.readBigint();
+                break;
+            }
+            case thrift_1.ThriftTypes.BINARY: {
+                for (let i = 0; i < size; i++)
+                    arr[i] = this.readString(this.readVarInt());
+                break;
+            }
+            default: {
+                throw new errors_1.ThriftError(`Type ${type} not impl.`);
+            }
+        }
+        return arr;
+    }
+    pushStack() {
+        this._stack.push(this.field);
+        this._field = 0;
+    }
+    popStack() {
+        var _a;
+        this._field = (_a = this._stack.pop()) !== null && _a !== void 0 ? _a : -1;
+    }
+}
+exports.BufferReader = BufferReader;
+BufferReader.fromZigZag = (n) => (n >> 1) ^ -(n & 1);
+function equalArrays(left, right) {
+    if (!left || !right || left.length !== right.length)
+        return false;
+    for (let i = 0; i < left.length; i++)
+        if (left[i] !== right[i])
+            return false;
+    return true;
+}