@vaitosoi/minejs 0.2.1 → 0.3.1

package/dist/packet/decoder.js

@@ -0,0 +1,668 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNBTDecoder = exports.NBTDecoder = exports.BinaryDecoder = void 0;
+exports.getTextFromTextComponent = getTextFromTextComponent;
+const direction_1 = require("../physics/direction");
+const static_1 = require("./static");
+const error_1 = require("../base/error");
+const static_2 = require("./static");
+const zlib_1 = require("zlib");
+const math_1 = require("../base/math");
+const util_1 = require("util");
+function getTextFromTextComponent(component) {
+    if (component === null || component === undefined)
+        return "null";
+    switch (typeof component) {
+        case "string":
+            return component;
+        case "object": {
+            if (Array.isArray(component))
+                return component.map(val => getTextFromTextComponent(val)).join();
+            else if ("text" in component) {
+                if ("extra" in component && Array.isArray(component["extra"]))
+                    return component["text"] + component["extra"].map(val => getTextFromTextComponent(val)).join("");
+                else
+                    return component["text"];
+            }
+            if ("translate" in component) {
+                if ("fallback" in component)
+                    return component["fallback"];
+                else
+                    return component["translate"];
+            }
+            else if ("keybind" in component)
+                return component["keybind"];
+            else
+                throw new error_1.UnexpectedValue("value of component", "text component object", (0, util_1.inspect)(component, undefined, null));
+        }
+        default:
+            throw new error_1.UnexpectedValue("type of component", "string or object", typeof component);
+    }
+}
+class BinaryDecoder {
+    buffer = Buffer.alloc(0);
+    offset = 0;
+    constructor(buffer, needDecompress = false) {
+        if (!needDecompress)
+            this.buffer = buffer;
+        else
+            this.buffer = (0, zlib_1.unzipSync)(buffer);
+    }
+    /**
+     * Read shortcut
+     *
+     * Read `size` bytes, use readFunc, then add `size` to internal offset
+     */
+    read(size, readFunc) {
+        const val = readFunc(this.buffer).bind(this.buffer)(this.offset);
+        this.offset += size;
+        return val;
+    }
+    /**
+     * Read 1 byte
+     * @returns signed 1-byte integer
+     */
+    readByte() { return this.read(1, (buffer) => buffer.readInt8); }
+    /**
+     * Read 1 byte
+     * @returns unsigned 1-byte integer
+     */
+    readUByte() { return this.read(1, (buffer) => buffer.readUint8); }
+    /**
+     * Read 2 bytes
+     * @returns signed 2-byte integer
+     */
+    readShort() { return this.read(2, (buffer) => buffer.readInt16BE); }
+    /**
+     * Read 2 bytes
+     * @returns unsigned 2-byte integer
+     */
+    readUShort() { return this.read(2, (buffer) => buffer.readUint16BE); }
+    /**
+     * Read 4 bytes
+     * @returns signed 4-byte integer
+     */
+    readInt() { return this.read(4, (buffer) => buffer.readInt32BE); }
+    /**
+     * Read 8 bytes
+     * @returns signed 8-byte integer
+     */
+    readLong() { return this.read(8, (buffer) => buffer.readBigInt64BE); }
+    /**
+     * Read 4 bytes
+     * @returns signed 4-bytes decimal
+     */
+    readFloat() { return this.read(4, (buffer) => buffer.readFloatBE); }
+    /**
+     * Read 8 bytes
+     * @returns signed 8-byte decimal
+     */
+    readDouble() { return this.read(8, (buffer) => buffer.readDoubleBE); }
+    /**
+     * Read 1 byte
+     * @returns a boolean
+     */
+    readBoolean() {
+        const value = this.readByte();
+        switch (value) {
+            case 0x01: return true;
+            case 0x00: return false;
+            default: throw new Error(`unexpect value of boolean type: ${value}`);
+        }
+    }
+    // Source: https://minecraft.wiki/w/Java_Edition_protocol/Packets#VarInt_and_VarLong
+    /**
+     * Read n bytes of integer
+     *
+     * A VarInt packet would look like this:
+     *
+     * `[7 bits of data][1 bit indicate if the VarInt ended here]`
+     *
+     * @returns signed n-bit integer
+     */
+    readVarInt() {
+        let value = 0;
+        let position = 0;
+        let currentByte;
+        while (true) {
+            currentByte = this.readUByte();
+            value |= (currentByte & static_1.SEGMENT_BITS) << position;
+            if ((currentByte & static_1.CONTINUE_BIT) == 0)
+                break;
+            position += 7;
+            if (position >= 32)
+                throw new Error("VarInt is too big");
+        }
+        return value;
+    }
+    /**
+     * Read n bytes of integer
+     *
+     * Similar to VarInt, A VarLong packet would look like this:
+     *
+     * `[7 bits of data][1 bit indicate if the VarLong ended here]`
+     *
+     * @returns signed n-bit integer
+     */
+    readVarLong() {
+        let value = BigInt(0);
+        let position = 0;
+        let currentByte;
+        while (true) {
+            currentByte = this.readUByte();
+            value |= BigInt((currentByte & static_1.SEGMENT_BITS) << position);
+            if ((currentByte & static_1.CONTINUE_BIT) == 0)
+                break;
+            position += 7;
+            if (position >= 64)
+                throw new Error("VarLong is too big");
+        }
+        return value;
+    }
+    /**
+     * Read a string
+     *
+     * A string packet would look like this:
+     *
+     * `[VarInt as length, if not provided][N bits of data]`
+     *
+     * @returns a string
+     */
+    readString(length) {
+        length ||= this.readVarInt();
+        if (length == 0)
+            return "";
+        if (this.offset + length > this.buffer.length)
+            throw new error_1.StringSizeExceedLimit();
+        const string = this.buffer.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return string.toString("utf-8");
+    }
+    /**
+     * Read a 16-byte UUID
+     */
+    readUUID() {
+        const buffer = this.buffer.subarray(this.offset, this.offset + 16);
+        this.offset += 16;
+        return buffer.toString('hex');
+    }
+    /**
+     * Read a Position
+     *
+     * A position packet is a 64-bit value, split into three signed integer parts:
+     * ```
+     * x: 26 MSBs
+     * z: 26 middle bits
+     * y: 12 LSBs
+     * ```
+     *
+     * @returns a Position
+     */
+    readPosition() {
+        const val = this.readLong(), x = val >> BigInt(38), y = val << BigInt(52) >> BigInt(52), z = val << BigInt(26) >> BigInt(38);
+        return {
+            x: Number(x),
+            y: Number(y),
+            z: Number(z),
+        };
+    }
+    /**
+     * Read an array with known length
+     *
+     * @returns an array
+     */
+    readArray(length, readFunc) {
+        return Array.from({ length }).map((_, ind) => readFunc(this, ind));
+    }
+    /**
+     * Read a length-prefixed array
+     *
+     * An array packet would look like this:
+     * `[VarInt as length][N bytes of data]`
+     *
+     * @returns a length-prefixed array
+     */
+    readPrefixedArray(readFunc) {
+        const length = this.readVarInt();
+        return this.readArray(length, readFunc);
+    }
+    /**
+     * Read an array with known length and return Buffer
+     *
+     * @param size size of the item, in byte
+     * @returns an array
+     */
+    readRawArray(length, size) {
+        const buffer = this.buffer.subarray(this.offset, this.offset + size * length);
+        this.offset += size * length;
+        return buffer;
+    }
+    /**
+     * Read a length-prefixed array and return the raw buffer
+     *
+     * An array packet would look like this:
+     * `[VarInt as length][N bytes of data]`
+     *
+     * @param size size of the item, in byte
+     * @returns a length-prefixed array
+     */
+    readRawPrefixedArray(size) {
+        const length = this.readVarInt();
+        return this.readRawArray(length, size);
+    }
+    /**
+     * Read a Teleport Flag packet
+     *
+     * A Teleport Flag packet, which is bit mask represented as an int, would look like this:
+     * | Hex Mask | Field                  |
+     * |----------|------------------------|
+     * | 0x0001   | Is X relative          |
+     * | 0x0002   | Is Y relative          |
+     * | 0x0004   | Is Z relative          |
+     * | 0x0008   | Is Yaw relative        |
+     * | 0x0010   | Is Pitch relative      |
+     * | 0x0020   | Is Velocity X relative |
+     * | 0x0040   | Is Velocity Y relative |
+     * | 0x0080   | Is Velocity Z relative |
+     * | 0x0100   | Rotate velocity        |
+     */
+    readTeleportFlag() {
+        const flags = this.readInt();
+        const x = (flags & 0x0001) === 1, y = (flags & 0x0002) === 1, z = (flags & 0x0004) === 1, yaw = (flags & 0x0008) === 1, pitch = (flags & 0x0010) === 1, velX = (flags & 0x0020) === 1, velY = (flags & 0x0040) === 1, velZ = (flags & 0x0080) === 1, rotateVelocity = (flags & 0x0100) === 1;
+        return {
+            x,
+            y,
+            z,
+            yaw,
+            pitch,
+            velX,
+            velY,
+            velZ,
+            rotateVelocity,
+        };
+    }
+    /**
+     * Read a Prefixed Optional field
+     *
+     * A Prefixed Optional would look like this:
+     * `[Boolean to indicate whenether the following field is presented][N bytes of data if the boolean before is true, or else empty]`
+     *
+     * @returns
+     */
+    readPrefixedOptional(readFunc) {
+        const isPresent = this.readBoolean();
+        if (!isPresent)
+            return null;
+        return readFunc(this);
+    }
+    /**
+     * Read a NBT
+     */
+    readNBT() {
+        const remainData = this.buffer.subarray(this.offset);
+        const nbtDecoder = new NBTDecoder(remainData);
+        const val = nbtDecoder.decode();
+        this.offset += nbtDecoder.offset;
+        return val;
+    }
+    // For reading LpVec3
+    unpack(value) {
+        return (0, math_1.minBigInt)(BigInt(BigInt(value) & 32767n), BigInt(static_1.MAX_QUANTIZED_VALUE)) * BigInt(2.0) / BigInt(static_1.MAX_QUANTIZED_VALUE) - 1n;
+    }
+    /**
+     * Read LpVec3
+     *
+     * Read this article for more information: https://minecraft.wiki/w/Java_Edition_protocol/Data_types#LpVec3
+     */
+    readLpVec3() {
+        const byte1 = this.readUByte();
+        if (byte1 === 0) {
+            return direction_1.Vec3.Zero;
+        }
+        const byte2 = this.readUByte();
+        const bytes3To6 = this.readInt(); // Should be UInt
+        const packed = BigInt(bytes3To6 << 16) | BigInt(byte2 << 8) | BigInt(byte1);
+        let scaleFactor = BigInt(byte1) & static_1.SCALE_BITS;
+        if ((BigInt(byte1) & static_1.CONTINUATION_FLAG) != 0n)
+            scaleFactor |= BigInt(this.readVarInt()) << 2n;
+        const scaleFactorD = BigInt(scaleFactor);
+        return new direction_1.Vec3(Number(this.unpack(packed >> 3n) * scaleFactorD), Number(this.unpack(packed >> 18n) * scaleFactorD), Number(this.unpack(packed >> 33n) * scaleFactorD));
+    }
+    /**
+     * Resolve a fixed point to a double
+     *
+     * A fixed point is a certain number of bits represent the signed integer part (number to the left of the decimal point)
+     * and the rest represent the fractional part (to the right).
+     *
+     * @param x number to resole
+     * @param n n fraction bits
+     */
+    readFixedPoint(x, n) {
+        return x / (1 << n);
+    }
+    /**
+     * Read an angle.
+     *
+     * An angle is a rotation angle in steps of 1/256 of a full turn
+     */
+    readAngle() {
+        return this.readByte();
+    }
+    /**
+     * Represents a data record of type X, either inline, or by reference to a registry implied by context
+     */
+    readIdOrX(readX) {
+        const id = this.readVarInt();
+        if (id !== 0)
+            return id;
+        return readX(this);
+    }
+    /**
+     * Read Chat Type Decoration
+     *
+     * The chat type decorations look like:
+     * | Name            | Type                          | Description                      |
+     * |-----------------|-------------------------------|----------------------------------|
+     * | Translation Key | String                        |                                  |
+     * | Parameters      | Prefixed Array of VarInt Enum | 0: sender, 1: target, 2: content |
+     * | Style           | NBT                           |                                  |
+     */
+    readChatTypeDecoration() {
+        const translationKey = this.readString(), parameters = this.readPrefixedArray(decoder => decoder.readVarInt()), style = this.readNBT();
+        return { translationKey, parameters, style };
+    }
+    /**
+     * Read Chat Type
+     */
+    readChatType() {
+        return {
+            chat: this.readChatTypeDecoration(),
+            narration: this.readChatTypeDecoration()
+        };
+    }
+}
+exports.BinaryDecoder = BinaryDecoder;
+class NBTDecoder extends BinaryDecoder {
+    /**
+     * Read a Compound string
+     *
+     * A string packet would look like this:
+     *
+     * `[2 bytes as length][N bits of data]`
+     *
+     * @returns a string
+     */
+    readCompoundString() {
+        const length = this.readUShort();
+        if (length == 0)
+            return "";
+        return this.readString(length);
+    }
+    /**
+     * Read a list / array of tag
+     *
+     * A list / array packet should look like this:
+     * [1 byte of type, if not provided][4 bytes of length][N bits of data]
+     *
+     * @returns
+     */
+    readCompoundList(type) {
+        type ||= this.readByte();
+        const length = this.readInt();
+        const array = Array.from({ length })
+            .map(() => this.readCompoundValue(type));
+        return array;
+    }
+    /**
+     * Read compound value base on provided tag
+     */
+    readCompoundValue(tag) {
+        switch (tag) {
+            case static_2.Tag.Byte: return this.readByte();
+            case static_2.Tag.Short: return this.readShort();
+            case static_2.Tag.Int: return this.readInt();
+            case static_2.Tag.Long: return this.readLong();
+            case static_2.Tag.Float: return this.readFloat();
+            case static_2.Tag.Double: return this.readDouble();
+            case static_2.Tag.ByteArray: return this.readCompoundList(static_2.Tag.Byte);
+            case static_2.Tag.String: return this.readCompoundString();
+            case static_2.Tag.List: return this.readCompoundList();
+            case static_2.Tag.Compound: return this.readCompound();
+            case static_2.Tag.IntArray: return this.readCompoundList(static_2.Tag.Int);
+            case static_2.Tag.LongArray: return this.readCompoundList(static_2.Tag.Long);
+            default: throw new error_1.UnexpectedValue("compound tag", tag.toString());
+        }
+    }
+    /**
+     * Read n bits
+     *
+     * A Compound entry would look like this:
+     *
+     * [1 byte of Type][2 byte of field name length][N bits of field length][N bits of data]
+     *
+     * @returns signed n-bit integer
+     */
+    readCompound() {
+        const obj = {};
+        while (true) {
+            const type = this.readByte();
+            if (type === static_2.Tag.End)
+                return obj;
+            const name = this.readCompoundString();
+            const value = this.readCompoundValue(type);
+            obj[name] = value;
+        }
+    }
+    /**
+     * Read an NBT
+     *
+     * Note that Network NBT slice some root data so I have to specified it through `isNetwork` param
+     *
+     * @param isNetwork
+     * @returns
+     */
+    decode(isNetwork = true) {
+        const type = this.readByte();
+        if (type === static_2.Tag.Compound || type === static_2.Tag.List) {
+            if (!isNetwork)
+                this.readCompoundString();
+            const value = this.readCompoundValue(type);
+            return value;
+        }
+        else if (type === static_2.Tag.End)
+            return {};
+        else {
+            if (!isNetwork)
+                this.readCompoundString();
+            const value = this.readCompoundValue(type);
+            return value;
+        }
+    }
+}
+exports.NBTDecoder = NBTDecoder;
+class SNBTDecoder {
+    source;
+    offset = 0;
+    constructor(source) {
+        this.source = source;
+    }
+    skipWhiteSpace() {
+        while (this.offset < this.source.length) {
+            // console.log({
+            //     off: this.offset,
+            //     ch: this.source[this.offset],
+            //     a: this.source[this.offset] !== " ",
+            //     b: this.source[this.offset] !== "\n"
+            // });
+            if (this.source[this.offset] !== " " &&
+                this.source[this.offset] !== "," &&
+                this.source[this.offset] !== "\n")
+                return;
+            this.offset += 1;
+        }
+        throw new error_1.UnexpectedValue("end of SNBT", "white space");
+    }
+    convertValue(val) {
+        if ((!isNaN(Number(val))) ||
+            val.endsWith("b") || val.endsWith("B") ||
+            val.endsWith("s") || val.endsWith("S") ||
+            val.endsWith("i") || val.endsWith("I") ||
+            val.endsWith("F") || val.endsWith("F"))
+            return Number(val);
+        if (val.endsWith("l") || val.endsWith("L") ||
+            val.endsWith("d") || val.endsWith("D") ||
+            BigInt(val) % BigInt(1) !== BigInt(0))
+            return BigInt(val);
+        if (val === "true")
+            return true;
+        if (val === "false")
+            return false;
+        if ((val.startsWith("'") && val.endsWith("'")) ||
+            (val.startsWith('"') && val.endsWith("'")))
+            return String(val.slice(1, -1));
+        return val;
+    }
+    // eoc = End Of Compound
+    seek() {
+        this.skipWhiteSpace();
+        if (this.source[this.offset] == "}")
+            return undefined;
+        let fieldName = "";
+        let sliceQuote = undefined;
+        let ch;
+        if (this.source[this.offset] === "'" || this.source[this.offset] === '"') {
+            sliceQuote = this.source[this.offset];
+            this.offset++;
+        }
+        while (true) {
+            ch = this.source[this.offset];
+            if (((sliceQuote == undefined && ch === ":") ||
+                (sliceQuote && ch === sliceQuote)) ||
+                this.offset >= this.source.length) {
+                this.offset++;
+                break;
+            }
+            fieldName += ch;
+            this.offset++;
+        }
+        if (sliceQuote)
+            this.offset++;
+        this.skipWhiteSpace();
+        let stringtifiedVal = "", convertedVal = undefined, type = "number";
+        outer: while (true) {
+            ch = this.source[this.offset];
+            switch (ch) {
+                case "[":
+                    type = "list";
+                    break;
+                // End of Array or Line
+                case "]":
+                    if (type === "array" || type === "list") {
+                        this.offset++;
+                        break outer;
+                    }
+                    stringtifiedVal += ch;
+                    break;
+                case ",":
+                    if (type !== "array" && type !== "list") {
+                        this.offset++;
+                        break outer;
+                    }
+                    stringtifiedVal += ch;
+                    break;
+                // String indicator, if found repeated mean it is the end of the string
+                case "'":
+                    if (stringtifiedVal.endsWith("\\") || type == "list") {
+                        stringtifiedVal += ch;
+                        break;
+                    }
+                    if (type == "string_1") {
+                        this.offset++;
+                        break outer;
+                    }
+                    type = "string_1";
+                    break;
+                case '"':
+                    if (stringtifiedVal.endsWith("\\") || type == "list") {
+                        stringtifiedVal += ch;
+                        break;
+                    }
+                    if (type == "string_2") {
+                        this.offset++;
+                        break outer;
+                    }
+                    type = "string_2";
+                    break;
+                // Array type indicator
+                case "B":
+                case "I":
+                case "L":
+                    type = "array";
+                    this.offset++;
+                    break;
+                case "{":
+                    if (type != "list") {
+                        convertedVal = this.obj();
+                        break outer;
+                    }
+                    else {
+                        stringtifiedVal += ch;
+                        break;
+                    }
+                default:
+                    if (ch === " " && type == "number")
+                        break outer;
+                    stringtifiedVal += ch;
+                    break;
+            }
+            this.offset++;
+        }
+        if (stringtifiedVal !== "" && !convertedVal) {
+            if (type == "array")
+                convertedVal = stringtifiedVal.split(",")
+                    .map(val => this.convertValue(val.trim()));
+            else if (type == "list") {
+                convertedVal = stringtifiedVal.split(",")
+                    .map(val => {
+                    val = val.trim();
+                    if (val.startsWith("{") && val.endsWith("}")) {
+                        const decoder = new SNBTDecoder(val);
+                        const obj = decoder.decode();
+                        if (Object.keys(obj).length != 1 ||
+                            !("" in obj))
+                            return obj;
+                        return obj[""];
+                    }
+                    else
+                        return this.convertValue(val);
+                });
+            }
+            else {
+                if (type == "string_1" || type == "string_2")
+                    convertedVal = stringtifiedVal;
+                else
+                    convertedVal = this.convertValue(stringtifiedVal);
+            }
+        }
+        return [fieldName, convertedVal];
+    }
+    obj() {
+        if (this.source[this.offset] !== "{")
+            throw new error_1.UnexpectedValue("start of compound", "{", this.source[this.offset]);
+        this.offset++;
+        const obj = {};
+        while (this.offset < this.source.length) {
+            const val = this.seek();
+            if (!val)
+                break;
+            const [fieldName, fieldVal] = val;
+            obj[fieldName] = fieldVal;
+        }
+        return obj;
+    }
+    decode() {
+        return this.obj();
+    }
+}
+exports.SNBTDecoder = SNBTDecoder;
+//# sourceMappingURL=decoder.js.map