nodejs-insta-private-api-mqt 1.3.73 → 1.3.74

package/dist/thrift/thrift.reading.js

@@ -3,325 +3,366 @@ 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 = '';
-    const position = 0;
-    while (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 }));
+  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;
     }
-    return messages;
+
+    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,
+  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 }),
             });
-        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}`);
+          }
+          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) {
-    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] });
-        }
+  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 = descriptor.structDescriptors?.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, descriptor.structDescriptors ?? []));
-        }
-        else {
-            if (result.otherFindings)
-                result.otherFindings.push(struct);
-            else
-                result.otherFindings = [struct];
-        }
+  }
+
+  for (const struct of structs) {
+    let descriptor;
+    for (const level of struct.fieldPath) {
+      if (descriptor) descriptor = descriptor.structDescriptors?.find((x) => x.field === level);
+      else descriptor = descriptors.find((x) => x.field === level);
+      if (!descriptor) break;
     }
-    return result;
+
+    if (descriptor) {
+      defineEnumerableProperty(
+        result,
+        descriptor.fieldName,
+        thriftReadSingleLevel(struct.items, descriptor.structDescriptors ?? [])
+      );
+    } 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 = [];
-    for (const message of readResults) {
-        const descriptor = descriptors.find(d => d.field === message.field &&
-            (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);
+  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;
+  }
+
+  return otherFindings.length > 0 ? { ...result, otherFindings } : result;
 }
-const defineEnumerableProperty = (object, name, value) => Object.defineProperty(object, name, { value, enumerable: true });
+
+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 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;
     }
-    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 result = this.zigzagToBigint(this.readVarBigint());
-        return { int: result, num: Number(result) };
-    }
-    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:
-            case thrift_1.ThriftTypes.INT_64: {
-                for (let i = 0; i < size; i++) {
-                    arr[i] = BufferReader.fromZigZag(this.readVarInt());
-                }
-                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;
+    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);
     }
-    pushStack() {
-        this._stack.push(this.field);
-        this._field = 0;
+    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;
     }
-    popStack() {
-        this._field = this._stack.pop() ?? -1;
+
+    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() {
+    this._field = this._stack.pop() ?? -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;
+  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;
 }
-//# sourceMappingURL=thrift.reading.js.map