@ironm00n/nbt-ts

An easy to use encoder and decoder for the NBT format.

NBT compound tags are represented as plain JavaScript objects. The Byte, Short, Int and Float number types are wrapped in custom classes since JavaScript does not support them directly.

Node 10.4 or higher is required for BigInts, which are used to represent 64 bit integers.

Usage

1import { encode, decode, Byte, Short, Int, Float } from "@ironm00n/nbt-ts";
2
3const buffer = encode("root", {
4	byte: new Byte(-1),
5	short: new Short(65535),
6	int: new Int(-2147483648),
7	long: 0x7fffffffffffffffn,
8	float: new Float(0.75),
9	double: 0.1 + 0.2,
10	string: "Hello world",
11	list: ["item 1", "item 2"],
12	compound: {
13		byteArray: Buffer.from([0x80, 0x40, 0x20]),
14		// Int8Array does work here too
15		intArray: new Int32Array([1, 2, 3, 4]),
16		longArray: new BigInt64Array([1n, 2n, 3n, 4n]),
17	},
18});
19
20decode(Buffer.from("02000973686F7274546573747FFF", "hex"));
21// → { name: 'shortTest', value: Short { value: 32767 }, length: 14 }
22
23// Encode unnamed tag
24encode(null, "a");
25// → <Buffer 08 00 01 61>
26
27// Decode unnamed tag
28decode(Buffer.from("08000161", "hex"), { unnamed: true });
29// → { name: null, value: 'a', length: 4 }

Note that the encode function accepts both unsigned numbers such as 255 and signed numbers like -1 which are essentially the same in the case of a 8 bit integer. However when decoded, they will always have the signed representation. If you want to convert a number to the unsigned representation, you might do something like this:

1value & 0xff; // for bytes
2value & 0xffff; // for shorts
3value >>> 0; // for ints
4BigInt.asUintN(64, value); // for longs
5// or
6value & 0xffffffffffffffffn;

SNBT

The NBT format also has a more user-friendly variant in plain text. This format is referred to as SNBT, short for stringified NBT. Here are all the types represented in SNBT:

{
    byte: 1b, short: 1s, int: 1, long: 1l,
    float: 0.5f, double: 0.5,
    string: "Hello world",
    list: [{}, {}],
    compound: {
        byteArray: [B; 128, 64, 32],
        intArray: [I; 1, 2, 3, 4],
        longArray: [L; 1, 2, 3, 4]
    }
}

Here is an example how you can stringify or parse SNBT:

1import { stringify, parse } from "ironm00n/nbt-ts";
2
3const tag = parse(`{'Flying' :1b , unquoted: hello} `);
4// → { Flying: Byte { value: 1 }, unquoted: 'hello' }
5
6stringify(tag);
7// → '{Flying:1b,unquoted:"hello"}'

Changes in this fork

• Added support for indexed arrays in SNBT

Related projects

• mc-chat-format. Converts and formats Minecraft's JSON Chat components.
• mcproto (Minecraft protocol implementation)
• rcon-client