"use strict";
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
// This is a mostly 1:1 feature complete implementation of node's Buffer class for browsers.
// It's missing some of the static stuff but everything in the object *should* be there.
class BrowserBuffer {
    constructor(dataOrSize) {
        if (typeof (dataOrSize) === "number") {
            this.buffer = new Uint8Array(dataOrSize);
        }
        else if (typeof (dataOrSize) === "object") {
            this.buffer = new Uint8Array(dataOrSize); // Convert whatever comes in to a Uint8Array.
        }
        else {
            this.buffer = new Uint8Array(0); // Fallback
        }
        this.dataView = new DataView(this.buffer.buffer);
    }
    static allocUnsafe(size) { return this.alloc(size); }
    static allocUnsafeSlow(size) { return this.alloc(size); }
    static alloc(size) {
        return new BrowserBuffer(size);
    }
    static concat(buffers, totalLength) {
        let joinedArrays;
        if (totalLength !== undefined) {
            joinedArrays = new Uint8Array(totalLength);
        }
        else {
            let arraysLength = 0;
            for (const buffer of buffers) {
                arraysLength += buffer.length;
            }
            joinedArrays = new Uint8Array(arraysLength);
        }
        let offset = 0;
        for (const buffer of buffers) {
            joinedArrays.set(buffer.buffer, offset);
            offset += buffer.length;
        }
        return new BrowserBuffer(joinedArrays);
    }
    static from(data) {
        if (typeof (data) === "string") {
            throw new Error("BrowserBuffer does not currently support creating buffers from strings.");
        }
        return new BrowserBuffer(data);
    }
    // TODO: Implement
    static of() { }
    static isBuffer() { }
    static isEncoding() { }
    static byteLength() { }
    static copyBytesFrom() { }
    static compare() { }
    get length() {
        return this.buffer.length;
    }
    checkRanged(value, valueName, lowRange, highRange) {
        if (value < lowRange || value > highRange) {
            throw new Error(`The value of "${valueName}" is out of range. It must be >= ${lowRange} and <= ${highRange}. Received ${value}`);
        }
    }
    checkValue(value, low, high) {
        this.checkRanged(value, "value", low, high);
    }
    checkOffset(offset) {
        if (offset) {
            this.checkRanged(offset, "offset", 0, this.buffer.length - 1);
        }
    }
    // Writing methods
    writeInt8(value, offset) {
        this.checkValue(value, -128, 127);
        this.checkOffset(offset);
        this.dataView.setInt8(offset, value);
        return this;
    }
    writeUInt8(value, offset) {
        this.checkValue(value, 0, 255);
        this.checkOffset(offset);
        this.dataView.setUint8(offset, value);
        return this;
    }
    // Little Endian
    writeInt16LE(value, offset) {
        this.checkValue(value, -32768, 32767);
        this.checkOffset(offset);
        this.dataView.setInt16(offset, value, true);
        return this;
    }
    writeUInt16LE(value, offset) {
        this.checkValue(value, 0, 65535);
        this.checkOffset(offset);
        this.dataView.setUint16(offset, value, true);
        return this;
    }
    writeInt32LE(value, offset) {
        this.checkValue(value, -2147483648, 2147483647);
        this.checkOffset(offset);
        this.dataView.setInt32(offset, value, true);
        return this;
    }
    writeUInt32LE(value, offset) {
        this.checkValue(value, 0, 4294967295);
        this.checkOffset(offset);
        this.dataView.setUint32(offset, value, true);
        return this;
    }
    writeBigInt64LE(value, offset) {
        if (typeof (value) === "number") {
            value = BigInt(value);
        }
        this.checkValue(value, -(2n ** 63n), 2n ** 63n);
        this.checkOffset(offset);
        this.dataView.setBigInt64(offset, value, true);
        return this;
    }
    writeBigUint64LE(value, offset) {
        if (typeof (value) === "number") {
            value = BigInt(value);
        }
        this.checkValue(value, 0n, 2n ** 64n);
        this.checkOffset(offset);
        this.dataView.setBigUint64(offset, value, true);
        return this;
    }
    writeFloatLE(value, offset) {
        this.checkOffset(offset);
        this.dataView.setFloat32(offset, value, true);
        return this;
    }
    writeDoubleLE(value, offset) {
        this.checkOffset(offset);
        this.dataView.setFloat64(offset, value, true);
        return this;
    }
    // Big Endian
    writeInt16BE(value, offset) {
        this.checkValue(value, -32768, 32767);
        this.checkOffset(offset);
        this.dataView.setInt16(offset, value, false);
        return this;
    }
    writeUInt16BE(value, offset) {
        this.checkValue(value, 0, 65535);
        this.checkOffset(offset);
        this.dataView.setUint16(offset, value, false);
        return this;
    }
    writeInt32BE(value, offset) {
        this.checkValue(value, -2147483648, 2147483647);
        this.checkOffset(offset);
        this.dataView.setInt32(offset, value, false);
        return this;
    }
    writeUInt32BE(value, offset) {
        this.checkValue(value, 0, 4294967295);
        this.checkOffset(offset);
        this.dataView.setUint32(offset, value, false);
        return this;
    }
    writeBigInt64BE(value, offset) {
        if (typeof (value) === "number") {
            value = BigInt(value);
        }
        this.checkValue(value, -(2n ** 63n), 2n ** 63n);
        this.checkOffset(offset);
        this.dataView.setBigInt64(offset, value, false);
        return this;
    }
    writeBigUint64BE(value, offset) {
        if (typeof (value) === "number") {
            value = BigInt(value);
        }
        this.checkValue(value, 0n, 2n ** 64n);
        this.checkOffset(offset);
        this.dataView.setBigUint64(offset, value, false);
        return this;
    }
    writeFloatBE(value, offset) {
        this.checkOffset(offset);
        this.dataView.setFloat32(offset, value, false);
        return this;
    }
    writeDoubleBE(value, offset) {
        this.checkOffset(offset);
        this.dataView.setFloat64(offset, value, false);
        return this;
    }
    // Reading methods
    readInt8(offset) {
        this.checkOffset(offset);
        return this.dataView.getInt8(offset);
    }
    readUInt8(offset) {
        this.checkOffset(offset);
        return this.dataView.getUint8(offset);
    }
    // Little Endian
    readInt16LE(offset) {
        this.checkOffset(offset);
        return this.dataView.getInt16(offset, true);
    }
    readUInt16LE(offset) {
        this.checkOffset(offset);
        return this.dataView.getUint16(offset, true);
    }
    readInt32LE(offset) {
        this.checkOffset(offset);
        return this.dataView.getInt32(offset, true);
    }
    readUInt32LE(offset) {
        this.checkOffset(offset);
        return this.dataView.getUint32(offset, true);
    }
    readBigInt64LE(offset) {
        this.checkOffset(offset);
        return this.dataView.getBigInt64(offset, true);
    }
    readBigUint64LE(offset) {
        this.checkOffset(offset);
        return this.dataView.getBigUint64(offset, true);
    }
    readFloatLE(offset) {
        this.checkOffset(offset);
        return this.dataView.getFloat32(offset, true);
    }
    readDoubleLE(offset) {
        this.checkOffset(offset);
        return this.dataView.getFloat64(offset, true);
    }
    // Big Endian
    readInt16BE(offset) {
        this.checkOffset(offset);
        return this.dataView.getInt16(offset, false);
    }
    readUInt16BE(offset) {
        this.checkOffset(offset);
        return this.dataView.getUint16(offset, false);
    }
    readInt32BE(offset) {
        this.checkOffset(offset);
        return this.dataView.getInt32(offset, false);
    }
    readUInt32BE(offset) {
        this.checkOffset(offset);
        return this.dataView.getUint32(offset, false);
    }
    readBigInt64BE(offset) {
        this.checkOffset(offset);
        return this.dataView.getBigInt64(offset, false);
    }
    readBigUint64BE(offset) {
        this.checkOffset(offset);
        return this.dataView.getBigUint64(offset, false);
    }
    readFloatBE(offset) {
        this.checkOffset(offset);
        return this.dataView.getFloat32(offset, false);
    }
    readDoubleBE(offset) {
        this.checkOffset(offset);
        return this.dataView.getFloat64(offset, false);
    }
}
// NOTE: Here to match node buffer, has no use.
BrowserBuffer.poolSize = 8192;
function getBufferClass() {
    if (typeof (Buffer) === "undefined") {
        // @ts-ignore
        return BrowserBuffer;
    }
    else {
        return Buffer;
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
class ReaderBase {
    constructor(buffer) {
        this.buffer = buffer;
        this.offset = 0;
    }
    get readOffset() {
        return this.offset;
    }
    get length() {
        return this.buffer.length;
    }
    readBuffer(bytes) {
        const value = this.buffer.subarray(this.offset, this.offset + bytes);
        this.offset += bytes;
        return value;
    }
    // NOTE: This has to be a copy as the subarray is only cropped & offset
    //		 Realistically this is what we want anyway.
    readUint8Array(bytes) {
        const croppedBuffer = this.readBuffer(bytes);
        const newArray = new Uint8Array(croppedBuffer.length);
        for (let i = 0; i < croppedBuffer.length; i++) {
            newArray[i] = croppedBuffer[i];
        }
        return newArray;
    }
    readByte() {
        const value = this.buffer.readInt8(this.offset);
        this.offset++;
        return value;
    }
    readUByte() {
        const value = this.buffer.readUInt8(this.offset);
        this.offset++;
        return value;
    }
    readBool() {
        return Boolean(this.readUByte());
    }
    readUShortString() {
        const length = this.readUByte();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readUByte());
        }
        return text;
    }
    readShortString() {
        const length = this.readByte();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readByte());
        }
        return text;
    }
    readBytesAsString(bytesToRead) {
        let text = "";
        for (let i = 0; i < bytesToRead; i++) {
            text += String.fromCharCode(this.readUByte());
        }
        return text;
    }
    readVarint() {
        let total = 0;
        let shift = 0;
        let byte = this.readUByte();
        if (!(byte & 0x80)) {
            return (byte & 0x7F);
        }
        else {
            let end = false;
            while (!end) {
                if (shift) {
                    byte = this.readUByte();
                }
                total |= ((byte & 0x7F) << shift);
                end = !(byte & 0x80);
                shift += 7;
            }
        }
        return total;
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
class WriterBase {
    constructor(size = 0) {
        this.buffer = getBufferClass().alloc(size);
        this.offset = 0;
        this.resizable = size === 0;
    }
    get writeOffset() {
        return this.offset;
    }
    get length() {
        return this.buffer.length;
    }
    toBuffer() {
        return this.buffer;
    }
    toString() {
        return this.buffer.toString();
    }
    writeBuffer(buffer) {
        this.buffer = getBufferClass().concat([this.buffer, buffer], this.buffer.length + buffer.length);
        this.offset += buffer.length;
        return this;
    }
    writeUint8Array(array) {
        this.writeBuffer(getBufferClass().from(array));
        return this;
    }
    writeByte(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(1);
            buffer.writeInt8(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeInt8(value, this.offset);
            this.offset++;
        }
        return this;
    }
    writeUByte(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(1);
            buffer.writeUInt8(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeUInt8(value, this.offset);
            this.offset++;
        }
        return this;
    }
    writeBool(value) {
        if (typeof (value) === "number") {
            value = Boolean(value);
        }
        this.writeUByte(value ? 1 : 0);
        return this;
    }
    writeStringAsBytes(text) {
        let buffer;
        if (this.resizable) {
            buffer = getBufferClass().alloc(text.length);
        }
        else {
            buffer = this.buffer;
        }
        for (let i = 0; i < text.length; i++) {
            buffer.writeUInt8(text.charCodeAt(i), i);
        }
        return this;
    }
    writeUShortString(text) {
        this.writeUByte(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeUByte(text.charCodeAt(i));
        }
        return this;
    }
    writeShortString(text) {
        this.writeByte(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeByte(text.charCodeAt(i));
        }
        return this;
    }
    writeVarint(value) {
        let temp;
        while (value > 0) {
            temp = value & 0x7F;
            if (!!(value >>= 7)) {
                temp |= 0xB4;
            }
            this.writeUByte(temp);
        }
        return this;
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
var Endian;
(function (Endian) {
    Endian[Endian["LE"] = 0] = "LE";
    Endian[Endian["BE"] = 1] = "BE";
})(Endian || (Endian = {}));
function createReader(endianness, buffer) {
    if (endianness === Endian.LE) {
        return new ReaderLE(buffer);
    }
    else {
        return new ReaderBE(buffer);
    }
}
function createWriter(endianness, size) {
    if (endianness === Endian.LE) {
        return new WriterLE(size);
    }
    else {
        return new WriterBE(size);
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
class ReaderBE extends ReaderBase {
    readShort() {
        const value = this.buffer.readInt16BE(this.offset);
        this.offset += 2;
        return value;
    }
    readUShort() {
        const value = this.buffer.readUInt16BE(this.offset);
        this.offset += 2;
        return value;
    }
    readInt() {
        const value = this.buffer.readInt32BE(this.offset);
        this.offset += 4;
        return value;
    }
    readUInt() {
        const value = this.buffer.readUInt32BE(this.offset);
        this.offset += 4;
        return value;
    }
    readLong() {
        const value = this.buffer.readBigInt64BE(this.offset);
        this.offset += 8;
        return value;
    }
    readULong() {
        const value = this.buffer.readBigUInt64BE(this.offset);
        this.offset += 8;
        return value;
    }
    readFloat() {
        const value = this.buffer.readFloatBE(this.offset);
        this.offset += 4;
        return value;
    }
    readDouble() {
        const value = this.buffer.readDoubleBE(this.offset);
        this.offset += 8;
        return value;
    }
    readUString() {
        const length = this.readUShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readUByte());
        }
        return text;
    }
    readString() {
        const length = this.readShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readByte());
        }
        return text;
    }
    readUString16() {
        const length = this.readUShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readUShort());
        }
        return text;
    }
    readString16() {
        const length = this.readShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readUShort());
        }
        return text;
    }
    readShortsAsString(shortsToRead) {
        let text = "";
        for (let i = 0; i < shortsToRead; i++) {
            text += String.fromCharCode(this.readUShort());
        }
        return text;
    }
    readArbInt(length) {
        const value = this.buffer.readIntBE(this.offset, length);
        this.offset += length;
        return value;
    }
    readArbUInt(length) {
        const value = this.buffer.readUIntBE(this.offset, length);
        this.offset += length;
        return value;
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
class ReaderLE extends ReaderBase {
    readShort() {
        const value = this.buffer.readInt16LE(this.offset);
        this.offset += 2;
        return value;
    }
    readUShort() {
        const value = this.buffer.readUInt16LE(this.offset);
        this.offset += 2;
        return value;
    }
    readInt() {
        const value = this.buffer.readInt32LE(this.offset);
        this.offset += 4;
        return value;
    }
    readUInt() {
        const value = this.buffer.readUInt32LE(this.offset);
        this.offset += 4;
        return value;
    }
    readLong() {
        const value = this.buffer.readBigInt64LE(this.offset);
        this.offset += 8;
        return value;
    }
    readULong() {
        const value = this.buffer.readBigUInt64LE(this.offset);
        this.offset += 8;
        return value;
    }
    readFloat() {
        const value = this.buffer.readFloatLE(this.offset);
        this.offset += 4;
        return value;
    }
    readDouble() {
        const value = this.buffer.readDoubleLE(this.offset);
        this.offset += 8;
        return value;
    }
    readUString() {
        const length = this.readUShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readUByte());
        }
        return text;
    }
    readString() {
        const length = this.readShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readByte());
        }
        return text;
    }
    readUString16() {
        const length = this.readUShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readUShort());
        }
        return text;
    }
    readString16() {
        const length = this.readShort();
        let text = "";
        for (let i = 0; i < length; i++) {
            text += String.fromCharCode(this.readShort());
        }
        return text;
    }
    readShortsAsString(shortsToRead) {
        let text = "";
        for (let i = 0; i < shortsToRead; i++) {
            text += String.fromCharCode(this.readUShort());
        }
        return text;
    }
    readArbInt(length) {
        const value = this.buffer.readIntLE(this.offset, length);
        this.offset += length;
        return value;
    }
    readArbUInt(length) {
        const value = this.buffer.readUIntLE(this.offset, length);
        this.offset += length;
        return value;
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
class WriterBE extends WriterBase {
    writeShort(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(2);
            buffer.writeInt16BE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeInt16BE(value, this.offset);
            this.offset += 2;
        }
        return this;
    }
    writeUShort(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(2);
            buffer.writeUInt16BE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeUInt16BE(value, this.offset);
            this.offset += 2;
        }
        return this;
    }
    writeInt(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(4);
            buffer.writeInt32BE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeInt32BE(value, this.offset);
            this.offset += 4;
        }
        return this;
    }
    writeUInt(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(4);
            buffer.writeUInt32BE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeUInt32BE(value, this.offset);
            this.offset += 4;
        }
        return this;
    }
    writeLong(value) {
        if (typeof (value) !== "bigint") {
            value = BigInt(value);
        }
        if (this.resizable) {
            const buffer = getBufferClass().alloc(8);
            buffer.writeBigInt64BE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeBigInt64BE(value, this.offset);
            this.offset += 8;
        }
        return this;
    }
    writeULong(value) {
        if (typeof (value) !== "bigint") {
            value = BigInt(value);
        }
        if (this.resizable) {
            const buffer = getBufferClass().alloc(8);
            buffer.writeBigUint64BE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeBigUInt64BE(value, this.offset);
            this.offset += 8;
        }
        return this;
    }
    writeFloat(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(4);
            buffer.writeFloatBE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeFloatBE(value, this.offset);
            this.offset += 4;
        }
        return this;
    }
    writeDouble(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(8);
            buffer.writeDoubleBE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeDoubleBE(value, this.offset);
            this.offset += 8;
        }
        return this;
    }
    writeUString(text) {
        this.writeUShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeUByte(text.charCodeAt(i));
        }
        return this;
    }
    writeString(text) {
        this.writeShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeByte(text.charCodeAt(i));
        }
        return this;
    }
    writeUString16(text) {
        this.writeUShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeUShort(text.charCodeAt(i));
        }
        return this;
    }
    writeString16(text) {
        this.writeShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeShort(text.charCodeAt(i));
        }
        return this;
    }
    writeStringAsShorts(text) {
        let buffer;
        if (this.resizable) {
            buffer = getBufferClass().alloc(text.length * 2);
        }
        else {
            buffer = this.buffer;
        }
        for (let i = 0; i < text.length; i++) {
            buffer.writeUInt16BE(text.charCodeAt(i), i);
        }
        return this;
    }
    // ! TODO: Implement this properly. This was a quick, hacky implementation for mc-beta-server
    // !       as it is used in one single place in the whole game's protocol.
    writeJavaUTF(text) {
        const dataWriter = new WriterBE();
        for (let i = 0; i < text.length; i++) {
            const val = text.charCodeAt(i);
            if (val === 0) {
                dataWriter.writeByte(0xC0);
                dataWriter.writeByte(0X80);
            }
            else {
                dataWriter.writeByte(val);
            }
        }
        this.writeUShort(text.length);
        this.writeBuffer(dataWriter.toBuffer());
        return this;
    }
}
// Copyright (c) Holly Stubbs (tgpholly) - Licensed under MIT
// Check LICENSE in repository root for more information.
class WriterLE extends WriterBase {
    writeShort(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(2);
            buffer.writeInt16LE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeInt16LE(value, this.offset);
            this.offset += 2;
        }
        return this;
    }
    writeUShort(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(2);
            buffer.writeUInt16LE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeUInt16LE(value, this.offset);
            this.offset += 2;
        }
        return this;
    }
    writeInt(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(4);
            buffer.writeInt32LE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeInt32LE(value, this.offset);
            this.offset += 4;
        }
        return this;
    }
    writeUInt(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(4);
            buffer.writeUInt32LE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeUInt32LE(value, this.offset);
            this.offset += 4;
        }
        return this;
    }
    writeLong(value) {
        if (typeof (value) !== "bigint") {
            value = BigInt(value);
        }
        if (this.resizable) {
            const buffer = getBufferClass().alloc(8);
            buffer.writeBigInt64LE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeBigInt64LE(value, this.offset);
            this.offset += 8;
        }
        return this;
    }
    writeULong(value) {
        if (typeof (value) !== "bigint") {
            value = BigInt(value);
        }
        if (this.resizable) {
            const buffer = getBufferClass().alloc(8);
            buffer.writeBigUint64LE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeBigUInt64LE(value, this.offset);
            this.offset += 8;
        }
        return this;
    }
    writeFloat(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(4);
            buffer.writeFloatLE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeFloatLE(value, this.offset);
            this.offset += 4;
        }
        return this;
    }
    writeDouble(value) {
        if (this.resizable) {
            const buffer = getBufferClass().alloc(8);
            buffer.writeDoubleLE(value);
            this.writeBuffer(buffer);
        }
        else {
            this.buffer.writeDoubleLE(value, this.offset);
            this.offset += 8;
        }
        return this;
    }
    writeUString(text) {
        this.writeUShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeUByte(text.charCodeAt(i));
        }
        return this;
    }
    writeString(text) {
        this.writeShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeByte(text.charCodeAt(i));
        }
        return this;
    }
    writeUString16(text) {
        this.writeUShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeUShort(text.charCodeAt(i));
        }
        return this;
    }
    writeString16(text) {
        this.writeShort(text.length);
        for (let i = 0; i < text.length; i++) {
            this.writeShort(text.charCodeAt(i));
        }
        return this;
    }
    writeStringAsShorts(text) {
        let buffer;
        if (this.resizable) {
            buffer = getBufferClass().alloc(text.length * 2);
        }
        else {
            buffer = this.buffer;
        }
        for (let i = 0; i < text.length; i++) {
            buffer.writeUInt16LE(text.charCodeAt(i), i);
        }
        return this;
    }
    writeJavaUTF(text) {
        throw "Not implemented in Little-Endian Writer";
        return this;
    }
}