@serenityjs/nbt 0.0.0

package/README.md

@@ -0,0 +1,2 @@
+# Nbt
+

package/dist/index.d.ts

@@ -0,0 +1,304 @@
+import { BinaryStream, VarInt, Uint16 } from '@serenityjs/binarystream';
+
+declare abstract class NBTTag<T = unknown> {
+    /**
+     * The type of the tag.
+     */
+    static readonly type: Tag;
+    /**
+     * The name of the tag.
+     */
+    readonly name: string;
+    /**
+     * The value of the tag.
+     */
+    readonly value: T;
+    /**
+     * Creates a new NBTTag.
+     *
+     * @param name The name of the tag.
+     * @param value The value of the tag.
+     * @returns A new NBTTag.
+     */
+    constructor(name: string, value: T);
+    /**
+     * Returns the value of the tag.
+     *
+     * @returns The value of the tag.
+     */
+    valueOf(_snbt?: boolean): string | unknown;
+    /**
+     * Reads a tag from the stream.
+     *
+     * @param _stream The stream to read from.
+     * @param _type Whether or not to read the type of the tag.
+     * @returns The tag that was read.
+     */
+    static read(_stream: BinaryStream, _varint: unknown, _type: unknown): typeof this.prototype;
+    /**
+     * Writes a tag to the stream.
+     *
+     * @param _stream The stream to write to.
+     */
+    static write(_stream: BinaryStream, _tag: NBTTag<unknown>, _varint: unknown): void;
+    protected static readString(stream: BinaryStream, varint?: boolean): string;
+    protected static writeString(value: string, stream: BinaryStream, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a byte value.
+ */
+declare class ByteTag<T extends number = number> extends NBTTag<T> {
+    static readonly type = Tag.Byte;
+    valueOf(snbt?: boolean): number | string;
+    /**
+     * Reads a byte tag from the stream.
+     */
+    static read<T extends number>(stream: BinaryStream, varint?: boolean, type?: boolean): ByteTag<T>;
+    /**
+     * Writes a byte tag to the stream.
+     */
+    static write<T extends number>(stream: BinaryStream, tag: ByteTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a short value.
+ */
+declare class ShortTag<T extends number = number> extends NBTTag<T> {
+    static readonly type = Tag.Short;
+    valueOf(snbt?: boolean): number | string;
+    /**
+     * Reads a short tag from the stream.
+     */
+    static read<T extends number = number>(stream: BinaryStream, varint?: boolean, type?: boolean): ShortTag<T>;
+    /**
+     * Writes a short tag to the stream.
+     */
+    static write<T extends number = number>(stream: BinaryStream, tag: ShortTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a int value.
+ */
+declare class IntTag<T extends number = number> extends NBTTag<T> {
+    static readonly type = Tag.Int;
+    valueOf(snbt?: boolean): number | string;
+    /**
+     * Reads a int tag from the stream.
+     */
+    static read<T extends number = number>(stream: BinaryStream, varint?: boolean, type?: boolean): IntTag<T>;
+    /**
+     * Writes a int tag to the stream.
+     */
+    static write<T extends number = number>(stream: BinaryStream, tag: IntTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a long value.
+ */
+declare class LongTag<T extends bigint = bigint> extends NBTTag<T> {
+    static readonly type = Tag.Long;
+    valueOf(snbt?: boolean): bigint | string;
+    /**
+     * Reads a long tag from the stream.
+     */
+    static read<T extends bigint = bigint>(stream: BinaryStream, varint?: boolean, type?: boolean): LongTag<T>;
+    /**
+     * Writes a long tag to the stream.
+     */
+    static write<T extends bigint = bigint>(stream: BinaryStream, tag: LongTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a float value.
+ */
+declare class FloatTag<T extends number = number> extends NBTTag<T> {
+    static readonly type = Tag.Float;
+    valueOf(snbt?: boolean): number | string;
+    /**
+     * Reads a float tag from the stream.
+     */
+    static read<T extends number = number>(stream: BinaryStream, varint?: boolean, type?: boolean): FloatTag<T>;
+    /**
+     * Writes a float tag to the stream.
+     */
+    static write<T extends number = number>(stream: BinaryStream, tag: FloatTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a double value.
+ */
+declare class DoubleTag<T extends number = number> extends NBTTag<T> {
+    static readonly type = Tag.Double;
+    valueOf(snbt?: boolean): number | string;
+    /**
+     * Reads a double tag from the stream.
+     */
+    static read<T extends number = number>(stream: BinaryStream, varint?: boolean, type?: boolean): DoubleTag<T>;
+    /**
+     * Writes a double tag to the stream.
+     */
+    static write<T extends number = number>(stream: BinaryStream, tag: DoubleTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a byte list value.
+ */
+declare class ByteListTag extends NBTTag<Array<number>> {
+    static readonly type = Tag.ByteList;
+    /**
+     * Reads a byte list tag from the stream.
+     */
+    static read(stream: BinaryStream, varint?: boolean, type?: boolean): ByteListTag;
+    /**
+     * Writes a byte list tag to the stream.
+     */
+    static write(stream: BinaryStream, tag: ByteListTag, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a string value.
+ */
+declare class StringTag<T extends string = string> extends NBTTag<T> {
+    static readonly type = Tag.String;
+    /**
+     * Reads a string tag from the stream.
+     */
+    static read<T extends string = string>(stream: BinaryStream, varint?: boolean, type?: boolean): StringTag<T>;
+    /**
+     * Writes a string tag to the stream.
+     */
+    static write<T extends string = string>(stream: BinaryStream, tag: StringTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a compound list value.
+ */
+declare class CompoundTag<T = Record<string, NBTTag<unknown>>> extends NBTTag<T> {
+    static readonly type = Tag.Compound;
+    /**
+     * Creates a new compound tag.
+     *
+     * @param name The name of the tag.
+     * @param value The value of the tag.
+     * @returns A new compound tag.
+     */
+    addTag(...tags: Array<NBTTag<T>>): this;
+    /**
+     * Removes a tag from the compound tag.
+     *
+     * @param name The name of the tag to remove.
+     */
+    removeTag(name: string): this;
+    /**
+     * Returns a tag from the compound tag.
+     *
+     * @param name The name of the tag to get.
+     * @returns The tag that was found.
+     */
+    getTag(name: string): NBTTag<T> | undefined;
+    /**
+     * Returns a tag from the compound tag.
+     *
+     * @param name The name of the tag to get.
+     * @returns The tag that was found.
+     */
+    hasTag(name: string): boolean;
+    /**
+     * Returns all the tags in the compound tag.
+     *
+     * @returns All the tags in the compound tag.
+     */
+    getTags(): Array<NBTTag<T>>;
+    valueOf<K = unknown>(snbt?: boolean): K | string;
+    /**
+     * Reads a compound tag from the stream.
+     */
+    static read<T = Record<string, NBTTag<unknown>>>(stream: BinaryStream, varint?: boolean, type?: boolean): CompoundTag<T>;
+    /**
+     * Writes a compound tag to the stream.
+     */
+    static write<T = unknown>(stream: BinaryStream, tag: CompoundTag<T>, varint?: boolean): void;
+}
+
+/**
+ * A tag that contains a list value.
+ */
+declare class ListTag<T = unknown> extends NBTTag<Array<T>> {
+    static readonly type = Tag.List;
+    readonly type: Tag;
+    constructor(name: string, value: Array<T>, type: Tag);
+    valueOf(snbt?: boolean): string | unknown;
+    /**
+     * Reads a list tag from the stream.
+     */
+    static read<T>(stream: BinaryStream, varint?: boolean, type?: boolean): ListTag<T>;
+    /**
+     * Writes a list tag to the stream.
+     */
+    static write<T = unknown>(stream: BinaryStream, tag: ListTag<T>, varint?: boolean): void;
+}
+
+declare const NBT_TAGS: (typeof ByteTag | typeof ShortTag | typeof IntTag | typeof LongTag | typeof FloatTag | typeof DoubleTag | typeof ByteListTag | typeof StringTag | typeof CompoundTag | typeof ListTag)[];
+
+declare enum Tag {
+    End = 0,
+    Byte = 1,
+    Short = 2,
+    Int = 3,
+    Long = 4,
+    Float = 5,
+    Double = 6,
+    ByteList = 7,
+    String = 8,
+    List = 9,
+    Compound = 10,
+    IntList = 11,
+    LongList = 12
+}
+
+declare class NamedBinaryTag extends BinaryStream {
+    readonly varint: boolean;
+    protected readonly length: typeof VarInt | typeof Uint16;
+    constructor(buffer?: Buffer, varint?: boolean);
+    protected readLength(): number;
+    protected writeLength(value: number): void;
+    readString(): string;
+    writeString(value: string): void;
+    /**
+     * Reads a tag from the stream.
+     * @returns The tag that was read.
+     */
+    readByteTag(): ByteTag;
+    /**
+     * Writes a tag to the stream.
+     * @param tag The tag to write.
+     */
+    writeByteTag(tag: ByteTag): void;
+    /**
+     * Reads a tag from the stream.
+     * @returns The tag that was read.
+     */
+    readShortTag(): ShortTag;
+    /**
+     * Writes a tag to the stream.
+     * @param tag The tag to write.
+     */
+    writeShortTag(tag: ShortTag): void;
+    readIntTag(): IntTag;
+    writeIntTag(tag: IntTag): void;
+    readLongTag(): LongTag;
+    writeLongTag(tag: LongTag): void;
+    readFloatTag(): FloatTag;
+    writeFloatTag(tag: FloatTag): void;
+    readDoubleTag(): DoubleTag;
+    writeDoubleTag(tag: DoubleTag): void;
+    readStringTag(): StringTag;
+    writeStringTag(tag: StringTag): void;
+    readCompoundTag<T = unknown>(): CompoundTag<T>;
+    writeCompoundTag<T = unknown>(tag: CompoundTag<T>): void;
+    readListTag<T = unknown>(): ListTag;
+    writeListTag<T = unknown>(tag: ListTag<T>): void;
+}
+
+export { ByteListTag, ByteTag, CompoundTag, DoubleTag, FloatTag, IntTag, ListTag, LongTag, NBTTag, NBT_TAGS, NamedBinaryTag, ShortTag, StringTag, Tag };

package/dist/index.js

@@ -0,0 +1,766 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ByteListTag: () => ByteListTag,
+  ByteTag: () => ByteTag,
+  CompoundTag: () => CompoundTag,
+  DoubleTag: () => DoubleTag,
+  FloatTag: () => FloatTag,
+  IntTag: () => IntTag,
+  ListTag: () => ListTag,
+  LongTag: () => LongTag,
+  NBTTag: () => NBTTag,
+  NBT_TAGS: () => NBT_TAGS,
+  NamedBinaryTag: () => NamedBinaryTag,
+  ShortTag: () => ShortTag,
+  StringTag: () => StringTag,
+  Tag: () => Tag
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/named-binary-tag.ts
+var import_binarystream9 = require("@serenityjs/binarystream");
+
+// src/tags/tag.ts
+var import_binarystream = require("@serenityjs/binarystream");
+var NBTTag = class {
+  /**
+   * The type of the tag.
+   */
+  static type;
+  /**
+   * The name of the tag.
+   */
+  name;
+  /**
+   * The value of the tag.
+   */
+  value;
+  /**
+   * Creates a new NBTTag.
+   *
+   * @param name The name of the tag.
+   * @param value The value of the tag.
+   * @returns A new NBTTag.
+   */
+  constructor(name, value) {
+    this.name = name;
+    this.value = value;
+  }
+  /**
+   * Returns the value of the tag.
+   *
+   * @returns The value of the tag.
+   */
+  valueOf(_snbt) {
+    return this.value;
+  }
+  /**
+   * Reads a tag from the stream.
+   *
+   * @param _stream The stream to read from.
+   * @param _type Whether or not to read the type of the tag.
+   * @returns The tag that was read.
+   */
+  static read(_stream, _varint, _type) {
+    throw new Error("NBTTag.read() is not implemented.");
+  }
+  /**
+   * Writes a tag to the stream.
+   *
+   * @param _stream The stream to write to.
+   */
+  static write(_stream, _tag, _varint) {
+    throw new Error("NBTTag.write() is not implemented.");
+  }
+  static readString(stream, varint = false) {
+    const length = varint ? stream.readVarInt() : stream.readShort(import_binarystream.Endianness.Little);
+    const buffer = stream.readBuffer(length);
+    return String.fromCodePoint(...buffer);
+  }
+  static writeString(value, stream, varint = false) {
+    const buffer = Buffer.from(value);
+    varint ? stream.writeVarInt(buffer.length) : stream.writeShort(buffer.length, import_binarystream.Endianness.Little);
+    stream.writeBuffer(buffer);
+  }
+};
+
+// src/tags/byte.ts
+var ByteTag = class _ByteTag extends NBTTag {
+  static type = 1 /* Byte */;
+  valueOf(snbt) {
+    return snbt ? this.value + "b" : this.value;
+  }
+  /**
+   * Reads a byte tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = stream.readByte();
+    return new _ByteTag(name, value);
+  }
+  /**
+   * Writes a byte tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    stream.writeByte(tag.value);
+  }
+};
+
+// src/tags/short.ts
+var import_binarystream2 = require("@serenityjs/binarystream");
+var ShortTag = class _ShortTag extends NBTTag {
+  static type = 2 /* Short */;
+  valueOf(snbt) {
+    return snbt ? this.value + "s" : this.value;
+  }
+  /**
+   * Reads a short tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = stream.readShort(import_binarystream2.Endianness.Little);
+    return new _ShortTag(name, value);
+  }
+  /**
+   * Writes a short tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    stream.writeShort(tag.value, import_binarystream2.Endianness.Little);
+  }
+};
+
+// src/tags/int.ts
+var import_binarystream3 = require("@serenityjs/binarystream");
+var IntTag = class _IntTag extends NBTTag {
+  static type = 3 /* Int */;
+  valueOf(snbt) {
+    return snbt ? this.value + "i" : this.value;
+  }
+  /**
+   * Reads a int tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = varint ? stream.readVarInt() : stream.readInt32(import_binarystream3.Endianness.Little);
+    return new _IntTag(name, value);
+  }
+  /**
+   * Writes a int tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    varint ? stream.writeVarInt(tag.value) : stream.writeInt32(tag.value, import_binarystream3.Endianness.Little);
+  }
+};
+
+// src/tags/long.ts
+var import_binarystream4 = require("@serenityjs/binarystream");
+var LongTag = class _LongTag extends NBTTag {
+  static type = 4 /* Long */;
+  valueOf(snbt) {
+    return snbt ? this.value + "l" : this.value;
+  }
+  /**
+   * Reads a long tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = varint ? stream.readVarLong() : stream.readLong(import_binarystream4.Endianness.Little);
+    return new _LongTag(name, value);
+  }
+  /**
+   * Writes a long tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    varint ? stream.writeVarLong(tag.value) : stream.writeLong(tag.value, import_binarystream4.Endianness.Little);
+  }
+};
+
+// src/tags/float.ts
+var import_binarystream5 = require("@serenityjs/binarystream");
+var FloatTag = class _FloatTag extends NBTTag {
+  static type = 5 /* Float */;
+  valueOf(snbt) {
+    return snbt ? this.value + "f" : this.value;
+  }
+  /**
+   * Reads a float tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = stream.readFloat32(import_binarystream5.Endianness.Little);
+    return new _FloatTag(name, value);
+  }
+  /**
+   * Writes a float tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    stream.writeFloat32(tag.value, import_binarystream5.Endianness.Little);
+  }
+};
+
+// src/tags/double.ts
+var import_binarystream6 = require("@serenityjs/binarystream");
+var DoubleTag = class _DoubleTag extends NBTTag {
+  static type = 6 /* Double */;
+  valueOf(snbt) {
+    return snbt ? this.value + "d" : this.value;
+  }
+  /**
+   * Reads a double tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = stream.readFloat64(import_binarystream6.Endianness.Little);
+    return new _DoubleTag(name, value);
+  }
+  /**
+   * Writes a double tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    stream.writeFloat64(tag.value, import_binarystream6.Endianness.Little);
+  }
+};
+
+// src/tags/byte-list.ts
+var import_binarystream7 = require("@serenityjs/binarystream");
+var ByteListTag = class _ByteListTag extends NBTTag {
+  static type = 7 /* ByteList */;
+  /**
+   * Reads a byte list tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const length = varint ? stream.readVarInt() : stream.readInt32(import_binarystream7.Endianness.Little);
+    const value = stream.read(length);
+    return new _ByteListTag(name, value);
+  }
+  /**
+   * Writes a byte list tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    varint ? stream.writeVarInt(tag.value.length) : stream.writeInt32(tag.value.length, import_binarystream7.Endianness.Little);
+    stream.write(tag.value);
+  }
+};
+
+// src/tags/string.ts
+var StringTag = class _StringTag extends NBTTag {
+  static type = 8 /* String */;
+  /**
+   * Reads a string tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = this.readString(stream, varint);
+    return new _StringTag(name, value);
+  }
+  /**
+   * Writes a string tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    this.writeString(tag.value, stream, varint);
+  }
+};
+
+// src/tags/compound.ts
+var CompoundTag = class _CompoundTag extends NBTTag {
+  static type = 10 /* Compound */;
+  /**
+   * Creates a new compound tag.
+   *
+   * @param name The name of the tag.
+   * @param value The value of the tag.
+   * @returns A new compound tag.
+   */
+  addTag(...tags) {
+    for (const tag of tags) {
+      this.value[tag.name] = tag;
+    }
+    return this;
+  }
+  /**
+   * Removes a tag from the compound tag.
+   *
+   * @param name The name of the tag to remove.
+   */
+  removeTag(name) {
+    delete this.value[name];
+    return this;
+  }
+  /**
+   * Returns a tag from the compound tag.
+   *
+   * @param name The name of the tag to get.
+   * @returns The tag that was found.
+   */
+  getTag(name) {
+    return this.value[name];
+  }
+  /**
+   * Returns a tag from the compound tag.
+   *
+   * @param name The name of the tag to get.
+   * @returns The tag that was found.
+   */
+  hasTag(name) {
+    return name in this.value;
+  }
+  /**
+   * Returns all the tags in the compound tag.
+   *
+   * @returns All the tags in the compound tag.
+   */
+  getTags() {
+    return Object.values(this.value);
+  }
+  valueOf(snbt) {
+    if (snbt) {
+      const value = {};
+      for (const key in this.value) {
+        value[key] = this.value[key] instanceof _CompoundTag ? JSON.parse(
+          this.value[key].valueOf(
+            true
+          )
+        ) : this.value[key].valueOf(true);
+      }
+      return JSON.stringify(value);
+    } else {
+      const value = {};
+      for (const key in this.value) {
+        value[key] = this.value[key].valueOf();
+      }
+      return value;
+    }
+  }
+  /**
+   * Reads a compound tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const value = {};
+    do {
+      const type2 = stream.readByte();
+      if (type2 === 0 /* End */)
+        break;
+      const reader = NBT_TAGS.find((tag) => tag.type === type2);
+      if (!reader) {
+        throw new Error(`Unknown tag type: ${type2} at ${stream.offset}`);
+      }
+      const read = reader.read(stream, varint, false);
+      value[read.name] = read;
+    } while (!stream.cursorAtEnd());
+    return new _CompoundTag(name, value);
+  }
+  /**
+   * Writes a compound tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    for (const key in tag.value) {
+      const type = tag.value[key];
+      const writter = NBT_TAGS.find(
+        (tag2) => type instanceof tag2
+      );
+      if (!writter) {
+        throw new Error(`Unknown tag type: ${type}`);
+      }
+      writter.write(stream, type, varint);
+    }
+    stream.writeByte(0 /* End */);
+  }
+};
+
+// src/tags/list.ts
+var import_binarystream8 = require("@serenityjs/binarystream");
+var ListTag = class _ListTag extends NBTTag {
+  static type = 9 /* List */;
+  type;
+  constructor(name, value, type) {
+    super(name, value);
+    this.type = type;
+  }
+  valueOf(snbt) {
+    if (snbt) {
+      const values = [];
+      for (const key in this.value) {
+        values.push(this.value[key].valueOf() + "");
+      }
+      return JSON.stringify(values);
+    } else {
+      const values = [];
+      for (const key in this.value) {
+        values.push(this.value[key].valueOf());
+      }
+      return values;
+    }
+  }
+  /**
+   * Reads a list tag from the stream.
+   */
+  static read(stream, varint = false, type = true) {
+    if (type) {
+      const type2 = stream.readByte();
+      if (type2 !== this.type) {
+        throw new Error(`Expected tag type to be ${this.type} but got ${type2}`);
+      }
+    }
+    const name = this.readString(stream, varint);
+    const tag = stream.readByte();
+    const length = varint ? stream.readVarInt() : stream.readInt32(import_binarystream8.Endianness.Little);
+    const values = [];
+    for (let index = 0; index < length; index++) {
+      switch (tag) {
+        default: {
+          throw new Error(
+            `Tag type '${Tag[tag]}' has not been implemented for ListTag. ${stream.offset}`
+          );
+        }
+        case 1 /* Byte */: {
+          values.push(stream.readByte());
+          break;
+        }
+        case 2 /* Short */: {
+          values.push(stream.readInt16(import_binarystream8.Endianness.Little));
+          break;
+        }
+        case 3 /* Int */: {
+          values.push(
+            varint ? stream.readVarInt() : stream.readInt32(import_binarystream8.Endianness.Little)
+          );
+          break;
+        }
+        case 4 /* Long */: {
+          values.push(
+            varint ? stream.readVarLong() : stream.readLong(import_binarystream8.Endianness.Little)
+          );
+          break;
+        }
+        case 5 /* Float */: {
+          values.push(stream.readFloat32(import_binarystream8.Endianness.Little));
+          break;
+        }
+        case 6 /* Double */: {
+          values.push(stream.readFloat64(import_binarystream8.Endianness.Little));
+          break;
+        }
+        case 8 /* String */: {
+          values.push(this.readString(stream, varint));
+          break;
+        }
+        case 10 /* Compound */: {
+          const value = {};
+          do {
+            const type2 = stream.readByte();
+            if (type2 === 0 /* End */)
+              break;
+            const reader = NBT_TAGS.find(
+              (tag2) => tag2.type === type2
+            );
+            if (!reader) {
+              throw new Error(`Unknown tag type: ${type2} at ${stream.offset}`);
+            }
+            const read = reader.read(stream, varint, false);
+            value[read.name] = read;
+          } while (!stream.cursorAtEnd());
+          values.push(new CompoundTag("", value));
+        }
+      }
+    }
+    return new _ListTag(name, values, tag);
+  }
+  /**
+   * Writes a list tag to the stream.
+   */
+  static write(stream, tag, varint = false) {
+    stream.writeByte(this.type);
+    this.writeString(tag.name, stream, varint);
+    stream.writeByte(tag.type);
+    varint ? stream.writeVarInt(tag.value.length) : stream.writeInt32(tag.value.length, import_binarystream8.Endianness.Little);
+    for (const value of tag.value) {
+      switch (tag.type) {
+        default: {
+          throw new Error(
+            `Tag type '${Tag[tag.type]}' has not been implemented for ListTag.`
+          );
+        }
+        case 1 /* Byte */: {
+          stream.writeByte(value);
+          break;
+        }
+        case 2 /* Short */: {
+          stream.writeInt16(value, import_binarystream8.Endianness.Little);
+          break;
+        }
+        case 3 /* Int */: {
+          varint ? stream.writeVarInt(value) : stream.writeInt32(value, import_binarystream8.Endianness.Little);
+          break;
+        }
+        case 4 /* Long */: {
+          varint ? stream.writeVarLong(value) : stream.writeLong(value, import_binarystream8.Endianness.Little);
+          break;
+        }
+        case 5 /* Float */: {
+          stream.writeFloat32(value, import_binarystream8.Endianness.Little);
+          break;
+        }
+        case 6 /* Double */: {
+          stream.writeFloat64(value, import_binarystream8.Endianness.Little);
+          break;
+        }
+        case 8 /* String */: {
+          this.writeString(value, stream, varint);
+          break;
+        }
+        case 10 /* Compound */: {
+          const compound = value;
+          for (const key in compound.value) {
+            const type = compound.value[key];
+            const writter = NBT_TAGS.find(
+              (tag2) => type instanceof tag2
+            );
+            if (!writter) {
+              throw new Error(`Unknown tag type: ${type}`);
+            }
+            writter.write(stream, type, varint);
+          }
+          break;
+        }
+      }
+    }
+  }
+};
+
+// src/tags/tags.ts
+var NBT_TAGS = [
+  ByteTag,
+  ShortTag,
+  IntTag,
+  LongTag,
+  FloatTag,
+  DoubleTag,
+  ByteListTag,
+  StringTag,
+  ListTag,
+  CompoundTag
+];
+
+// src/named-binary-tag.ts
+var Tag = /* @__PURE__ */ ((Tag2) => {
+  Tag2[Tag2["End"] = 0] = "End";
+  Tag2[Tag2["Byte"] = 1] = "Byte";
+  Tag2[Tag2["Short"] = 2] = "Short";
+  Tag2[Tag2["Int"] = 3] = "Int";
+  Tag2[Tag2["Long"] = 4] = "Long";
+  Tag2[Tag2["Float"] = 5] = "Float";
+  Tag2[Tag2["Double"] = 6] = "Double";
+  Tag2[Tag2["ByteList"] = 7] = "ByteList";
+  Tag2[Tag2["String"] = 8] = "String";
+  Tag2[Tag2["List"] = 9] = "List";
+  Tag2[Tag2["Compound"] = 10] = "Compound";
+  Tag2[Tag2["IntList"] = 11] = "IntList";
+  Tag2[Tag2["LongList"] = 12] = "LongList";
+  return Tag2;
+})(Tag || {});
+var NamedBinaryTag = class extends import_binarystream9.BinaryStream {
+  varint;
+  length;
+  constructor(buffer, varint = false) {
+    super(buffer);
+    this.varint = varint;
+    this.length = varint ? import_binarystream9.VarInt : import_binarystream9.Uint16;
+  }
+  readLength() {
+    return this.length.read(this, import_binarystream9.Endianness.Little);
+  }
+  writeLength(value) {
+    this.length.write(this, value, import_binarystream9.Endianness.Little);
+  }
+  readString() {
+    const length = this.readLength();
+    const buffer = this.readBuffer(length);
+    return String.fromCodePoint(...buffer);
+  }
+  writeString(value) {
+    const buffer = Buffer.from(value);
+    this.writeLength(buffer.length);
+    this.writeBuffer(buffer);
+  }
+  /**
+   * Reads a tag from the stream.
+   * @returns The tag that was read.
+   */
+  readByteTag() {
+    return ByteTag.read(this);
+  }
+  /**
+   * Writes a tag to the stream.
+   * @param tag The tag to write.
+   */
+  writeByteTag(tag) {
+    ByteTag.write(this, tag);
+  }
+  /**
+   * Reads a tag from the stream.
+   * @returns The tag that was read.
+   */
+  readShortTag() {
+    return ShortTag.read(this);
+  }
+  /**
+   * Writes a tag to the stream.
+   * @param tag The tag to write.
+   */
+  writeShortTag(tag) {
+    ShortTag.write(this, tag);
+  }
+  readIntTag() {
+    return IntTag.read(this);
+  }
+  writeIntTag(tag) {
+    IntTag.write(this, tag);
+  }
+  readLongTag() {
+    return LongTag.read(this);
+  }
+  writeLongTag(tag) {
+    LongTag.write(this, tag);
+  }
+  readFloatTag() {
+    return FloatTag.read(this);
+  }
+  writeFloatTag(tag) {
+    FloatTag.write(this, tag);
+  }
+  readDoubleTag() {
+    return DoubleTag.read(this);
+  }
+  writeDoubleTag(tag) {
+    DoubleTag.write(this, tag);
+  }
+  readStringTag() {
+    return StringTag.read(this);
+  }
+  writeStringTag(tag) {
+    StringTag.write(this, tag);
+  }
+  readCompoundTag() {
+    return CompoundTag.read(this);
+  }
+  writeCompoundTag(tag) {
+    CompoundTag.write(this, tag);
+  }
+  readListTag() {
+    return ListTag.read(this);
+  }
+  writeListTag(tag) {
+    ListTag.write(this, tag);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ByteListTag,
+  ByteTag,
+  CompoundTag,
+  DoubleTag,
+  FloatTag,
+  IntTag,
+  ListTag,
+  LongTag,
+  NBTTag,
+  NBT_TAGS,
+  NamedBinaryTag,
+  ShortTag,
+  StringTag,
+  Tag
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@serenityjs/nbt",
+	"version": "0.0.0",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"repository": "https://github.com/SerenityJS/serenity",
+	"files": [
+		"dist/**"
+	],
+	"scripts": {
+		"build": "tsup",
+		"watch": "tsup --watch",
+		"lint": "eslint src/",
+		"typecheck": "tsc --noEmit",
+		"test": "jest"
+	},
+	"jest": {
+		"preset": "@serenityjs/jest-presets/jest/node"
+	},
+	"devDependencies": {
+		"@serenityjs/eslint-config": "*",
+		"@serenityjs/jest-presets": "*",
+		"@serenityjs/typescript-config": "*",
+		"@types/jest": "^29.5.12",
+		"@types/node": "^20.11.24",
+		"jest": "^29.7.0",
+		"tsup": "^8.0.2",
+		"typescript": "^5.4.2"
+	},
+	"dependencies": {
+		"@serenityjs/binarystream": "^2.5.2"
+	}
+}