@etothepii/satisfactory-file-parser 0.0.33 → 0.0.34

package/build/parser/satisfactory/structs/util.types.js

@@ -1,105 +1,95 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.SerializeTransform = exports.ParseTransform = exports.SerializeVec2 = exports.ParseVec2 = exports.SerializeVec3 = exports.ParseVec3 = exports.norm = exports.mult = exports.length = exports.add = exports.sub = exports.SerializeVec4 = exports.ParseVec4 = exports.ParseCol4BGRA = exports.SerializeCol4BGRA = exports.ParseCol4RGBA = exports.SerializeCol4RGBA = void 0;
-    const SerializeCol4RGBA = (writer, value) => {
-        writer.writeFloat(value.r);
-        writer.writeFloat(value.g);
-        writer.writeFloat(value.b);
-        writer.writeFloat(value.a);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeTransform = exports.ParseTransform = exports.SerializeVec2 = exports.ParseVec2 = exports.SerializeVec3 = exports.ParseVec3 = exports.norm = exports.mult = exports.length = exports.add = exports.sub = exports.SerializeVec4 = exports.ParseVec4 = exports.ParseCol4BGRA = exports.SerializeCol4BGRA = exports.ParseCol4RGBA = exports.SerializeCol4RGBA = void 0;
+const SerializeCol4RGBA = (writer, value) => {
+    writer.writeFloat(value.r);
+    writer.writeFloat(value.g);
+    writer.writeFloat(value.b);
+    writer.writeFloat(value.a);
+};
+exports.SerializeCol4RGBA = SerializeCol4RGBA;
+const ParseCol4RGBA = (reader) => {
+    return {
+        r: reader.readFloat32(),
+        g: reader.readFloat32(),
+        b: reader.readFloat32(),
+        a: reader.readFloat32(),
     };
-    exports.SerializeCol4RGBA = SerializeCol4RGBA;
-    const ParseCol4RGBA = (reader) => {
-        return {
-            r: reader.readFloat32(),
-            g: reader.readFloat32(),
-            b: reader.readFloat32(),
-            a: reader.readFloat32(),
-        };
+};
+exports.ParseCol4RGBA = ParseCol4RGBA;
+const SerializeCol4BGRA = (writer, value) => {
+    writer.writeByte(value.b);
+    writer.writeByte(value.g);
+    writer.writeByte(value.r);
+    writer.writeByte(value.a);
+};
+exports.SerializeCol4BGRA = SerializeCol4BGRA;
+const ParseCol4BGRA = (reader) => {
+    return {
+        b: reader.readByte(),
+        g: reader.readByte(),
+        r: reader.readByte(),
+        a: reader.readByte(),
     };
-    exports.ParseCol4RGBA = ParseCol4RGBA;
-    const SerializeCol4BGRA = (writer, value) => {
-        writer.writeByte(value.b);
-        writer.writeByte(value.g);
-        writer.writeByte(value.r);
-        writer.writeByte(value.a);
+};
+exports.ParseCol4BGRA = ParseCol4BGRA;
+const ParseVec4 = (reader) => {
+    return {
+        ...((0, exports.ParseVec3)(reader)),
+        w: reader.readFloat32()
     };
-    exports.SerializeCol4BGRA = SerializeCol4BGRA;
-    const ParseCol4BGRA = (reader) => {
-        return {
-            b: reader.readByte(),
-            g: reader.readByte(),
-            r: reader.readByte(),
-            a: reader.readByte(),
-        };
+};
+exports.ParseVec4 = ParseVec4;
+const SerializeVec4 = (writer, vec) => {
+    (0, exports.SerializeVec3)(writer, vec);
+    writer.writeFloat(vec.w);
+};
+exports.SerializeVec4 = SerializeVec4;
+const sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
+exports.sub = sub;
+const add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
+exports.add = add;
+const length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
+exports.length = length;
+const mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
+exports.mult = mult;
+const norm = (vec) => (0, exports.mult)(vec, 1. / (0, exports.length)(vec));
+exports.norm = norm;
+const ParseVec3 = (reader) => {
+    return {
+        ...((0, exports.ParseVec2)(reader)),
+        z: reader.readFloat32()
     };
-    exports.ParseCol4BGRA = ParseCol4BGRA;
-    const ParseVec4 = (reader) => {
-        return {
-            ...((0, exports.ParseVec3)(reader)),
-            w: reader.readFloat32()
-        };
+};
+exports.ParseVec3 = ParseVec3;
+const SerializeVec3 = (writer, vec) => {
+    (0, exports.SerializeVec2)(writer, vec);
+    writer.writeFloat(vec.z);
+};
+exports.SerializeVec3 = SerializeVec3;
+const ParseVec2 = (reader) => {
+    return {
+        x: reader.readFloat32(),
+        y: reader.readFloat32(),
     };
-    exports.ParseVec4 = ParseVec4;
-    const SerializeVec4 = (writer, vec) => {
-        (0, exports.SerializeVec3)(writer, vec);
-        writer.writeFloat(vec.w);
+};
+exports.ParseVec2 = ParseVec2;
+const SerializeVec2 = (writer, vec) => {
+    writer.writeFloat(vec.x);
+    writer.writeFloat(vec.y);
+};
+exports.SerializeVec2 = SerializeVec2;
+const ParseTransform = (reader) => {
+    return {
+        rotation: (0, exports.ParseVec4)(reader),
+        translation: (0, exports.ParseVec3)(reader),
+        scale3d: (0, exports.ParseVec3)(reader),
     };
-    exports.SerializeVec4 = SerializeVec4;
-    const sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
-    exports.sub = sub;
-    const add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
-    exports.add = add;
-    const length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
-    exports.length = length;
-    const mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
-    exports.mult = mult;
-    const norm = (vec) => (0, exports.mult)(vec, 1. / (0, exports.length)(vec));
-    exports.norm = norm;
-    const ParseVec3 = (reader) => {
-        return {
-            ...((0, exports.ParseVec2)(reader)),
-            z: reader.readFloat32()
-        };
-    };
-    exports.ParseVec3 = ParseVec3;
-    const SerializeVec3 = (writer, vec) => {
-        (0, exports.SerializeVec2)(writer, vec);
-        writer.writeFloat(vec.z);
-    };
-    exports.SerializeVec3 = SerializeVec3;
-    const ParseVec2 = (reader) => {
-        return {
-            x: reader.readFloat32(),
-            y: reader.readFloat32(),
-        };
-    };
-    exports.ParseVec2 = ParseVec2;
-    const SerializeVec2 = (writer, vec) => {
-        writer.writeFloat(vec.x);
-        writer.writeFloat(vec.y);
-    };
-    exports.SerializeVec2 = SerializeVec2;
-    const ParseTransform = (reader) => {
-        return {
-            rotation: (0, exports.ParseVec4)(reader),
-            translation: (0, exports.ParseVec3)(reader),
-            scale3d: (0, exports.ParseVec3)(reader),
-        };
-    };
-    exports.ParseTransform = ParseTransform;
-    const SerializeTransform = (writer, transform) => {
-        (0, exports.SerializeVec4)(writer, transform.rotation);
-        (0, exports.SerializeVec3)(writer, transform.translation);
-        (0, exports.SerializeVec3)(writer, transform.scale3d);
-    };
-    exports.SerializeTransform = SerializeTransform;
-});
+};
+exports.ParseTransform = ParseTransform;
+const SerializeTransform = (writer, transform) => {
+    (0, exports.SerializeVec4)(writer, transform.rotation);
+    (0, exports.SerializeVec3)(writer, transform.translation);
+    (0, exports.SerializeVec3)(writer, transform.scale3d);
+};
+exports.SerializeTransform = SerializeTransform;

package/build/parser/stream/byte-stream-reader.class.js

@@ -1,251 +1,241 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../byte/alignment.enum", "../byte/byte-writer.class", "../error/parser.error"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ByteStreamReader = void 0;
-    const alignment_enum_1 = require("../byte/alignment.enum");
-    const byte_writer_class_1 = require("../byte/byte-writer.class");
-    const parser_error_1 = require("../error/parser.error");
-    class ByteStreamReader {
-        constructor(reader, onCloseCallback, timeout = 30000, maxBufferThreshold = 100 * 1000 * 1000, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
-            this.reader = reader;
-            this.onCloseCallback = onCloseCallback;
-            this.timeout = timeout;
-            this.maxBufferThreshold = maxBufferThreshold;
-            this.alignment = alignment;
-            this.debug = false;
-            this.closedAlready = false;
-            this.totalNumberOfBytesRead = 0;
-            this.trailingBufferSize = 0;
-            this.continuousRead = async () => {
-                while (!this.inputStreamIsDone && !this.paused) {
-                    const { done, value } = await this.reader.read();
-                    if (!this.inputStreamIsDone) {
-                        if (value) {
-                            const trailingPos = Math.max(0, this.currentByte - this.trailingBufferSize);
-                            this.operatingStreamBuffer = new Uint8Array(byte_writer_class_1.ByteWriter.AppendBuffer(this.operatingStreamBuffer.slice(trailingPos), value));
-                            this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
-                            this.currentByte = Math.min(this.currentByte, this.trailingBufferSize);
-                            if (this.operatingStreamBuffer.byteLength > this.maxBufferThreshold) {
-                                console.warn('pausing due to size.');
-                                this.pause();
-                            }
-                            if (this.callbackAfterRead) {
-                                this.callbackAfterRead();
-                            }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteStreamReader = void 0;
+const alignment_enum_1 = require("../byte/alignment.enum");
+const byte_writer_class_1 = require("../byte/byte-writer.class");
+const parser_error_1 = require("../error/parser.error");
+class ByteStreamReader {
+    constructor(reader, onCloseCallback, timeout = 30000, maxBufferThreshold = 100 * 1000 * 1000, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
+        this.reader = reader;
+        this.onCloseCallback = onCloseCallback;
+        this.timeout = timeout;
+        this.maxBufferThreshold = maxBufferThreshold;
+        this.alignment = alignment;
+        this.debug = false;
+        this.closedAlready = false;
+        this.totalNumberOfBytesRead = 0;
+        this.trailingBufferSize = 0;
+        this.continuousRead = async () => {
+            while (!this.inputStreamIsDone && !this.paused) {
+                const { done, value } = await this.reader.read();
+                if (!this.inputStreamIsDone) {
+                    if (value) {
+                        const trailingPos = Math.max(0, this.currentByte - this.trailingBufferSize);
+                        this.operatingStreamBuffer = new Uint8Array(byte_writer_class_1.ByteWriter.AppendBuffer(this.operatingStreamBuffer.slice(trailingPos), value));
+                        this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
+                        this.currentByte = Math.min(this.currentByte, this.trailingBufferSize);
+                        if (this.operatingStreamBuffer.byteLength > this.maxBufferThreshold) {
+                            console.warn('pausing due to size.');
+                            this.pause();
+                        }
+                        if (this.callbackAfterRead) {
+                            this.callbackAfterRead();
                         }
                     }
-                    else {
-                        this.close();
-                    }
-                    this.inputStreamIsDone = done;
                 }
-            };
-            this.operatingStreamBuffer = new Uint8Array();
-            this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
-            this.inputStreamIsDone = false;
-            this.currentByte = 0;
-            this.neededNextAmountOfBytes = 0;
+                else {
+                    this.close();
+                }
+                this.inputStreamIsDone = done;
+            }
+        };
+        this.operatingStreamBuffer = new Uint8Array();
+        this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
+        this.inputStreamIsDone = false;
+        this.currentByte = 0;
+        this.neededNextAmountOfBytes = 0;
+        this.paused = false;
+        this.trailingBufferSize = 2000;
+        this.readLoopHandle = setTimeout(this.continuousRead);
+        this.waitingTimeoutHandle = undefined;
+    }
+    pause() {
+        this.paused = true;
+        clearTimeout(this.readLoopHandle);
+        this.readLoopHandle = undefined;
+        if (this.waitingTimeoutHandle) {
+            clearTimeout(this.waitingTimeoutHandle);
+            this.waitingTimeoutHandle = undefined;
+        }
+    }
+    resume() {
+        if (this.paused) {
             this.paused = false;
-            this.trailingBufferSize = 2000;
             this.readLoopHandle = setTimeout(this.continuousRead);
-            this.waitingTimeoutHandle = undefined;
         }
-        pause() {
-            this.paused = true;
-            clearTimeout(this.readLoopHandle);
-            this.readLoopHandle = undefined;
-            if (this.waitingTimeoutHandle) {
-                clearTimeout(this.waitingTimeoutHandle);
-                this.waitingTimeoutHandle = undefined;
-            }
+    }
+    hasInput() {
+        return !this.inputStreamIsDone;
+    }
+    async close() {
+        this.inputStreamIsDone = true;
+        this.pause();
+        await this.onCloseCallback();
+        this.closedAlready = true;
+    }
+    async allocate(count) {
+        if (count > this.maxBufferThreshold * 0.5) {
+            console.warn(`you are waiting for a very big chunk here mate. ${count} bytes. U sure you have your numbers right?`);
         }
-        resume() {
+        if (this.getAmountAllocatedLeft() < count) {
+            if (this.inputStreamIsDone) {
+                throw new parser_error_1.CorruptSaveError('Input Stream has finished before needed data was received.');
+            }
             if (this.paused) {
-                this.paused = false;
-                this.readLoopHandle = setTimeout(this.continuousRead);
+                this.resume();
             }
+            await this.waitUntilNumBytesAvailable(count);
         }
-        hasInput() {
-            return !this.inputStreamIsDone;
-        }
-        async close() {
-            this.inputStreamIsDone = true;
-            this.pause();
-            await this.onCloseCallback();
-            this.closedAlready = true;
-        }
-        async allocate(count) {
-            if (count > this.maxBufferThreshold * 0.5) {
-                console.warn(`you are waiting for a very big chunk here mate. ${count} bytes. U sure you have your numbers right?`);
-            }
-            if (this.getAmountAllocatedLeft() < count) {
-                if (this.inputStreamIsDone) {
-                    throw new parser_error_1.CorruptSaveError('Input Stream has finished before needed data was received.');
-                }
-                if (this.paused) {
-                    this.resume();
-                }
-                await this.waitUntilNumBytesAvailable(count);
+    }
+    waitUntilNumBytesAvailable(count) {
+        this.neededNextAmountOfBytes = count;
+        return new Promise((resolve, reject) => {
+            if (this.getAmountAllocatedLeft() >= this.neededNextAmountOfBytes) {
+                this.neededNextAmountOfBytes = 0;
+                return resolve();
             }
-        }
-        waitUntilNumBytesAvailable(count) {
-            this.neededNextAmountOfBytes = count;
-            return new Promise((resolve, reject) => {
+            this.callbackAfterRead = () => {
                 if (this.getAmountAllocatedLeft() >= this.neededNextAmountOfBytes) {
+                    if (this.waitingTimeoutHandle) {
+                        clearTimeout(this.waitingTimeoutHandle);
+                    }
                     this.neededNextAmountOfBytes = 0;
+                    this.callbackAfterRead = undefined;
                     return resolve();
                 }
-                this.callbackAfterRead = () => {
-                    if (this.getAmountAllocatedLeft() >= this.neededNextAmountOfBytes) {
-                        if (this.waitingTimeoutHandle) {
-                            clearTimeout(this.waitingTimeoutHandle);
-                        }
-                        this.neededNextAmountOfBytes = 0;
-                        this.callbackAfterRead = undefined;
-                        return resolve();
-                    }
-                };
-                if (this.waitingTimeoutHandle) {
-                    clearTimeout(this.waitingTimeoutHandle);
-                }
-                this.waitingTimeoutHandle = setTimeout(() => {
-                    if (!this.inputStreamIsDone) {
-                        reject(new parser_error_1.TimeoutError(`Timed out before ${this.neededNextAmountOfBytes} bytes were available to read next.`));
-                    }
-                    return resolve();
-                }, this.timeout);
-            });
-        }
-        skipBytes(byteLength = 1) {
-            this.currentByte += byteLength;
-            this.totalNumberOfBytesRead += byteLength;
-            return;
-        }
-        readByte() {
-            this.totalNumberOfBytesRead += 1;
-            return this.operatingDataView.getUint8(this.currentByte++);
-        }
-        readBytes(count) {
-            this.totalNumberOfBytesRead += count;
-            return new Uint8Array(new Array(count).fill(0).map(pl => this.operatingDataView.getUint8(this.currentByte++)));
-        }
-        readHex(hexLength) {
-            let hexPart = [];
-            for (let i = 0; i < hexLength; i++) {
-                let currentHex = String.fromCharCode(this.operatingDataView.getUint8(this.currentByte++));
-                hexPart.push(currentHex);
+            };
+            if (this.waitingTimeoutHandle) {
+                clearTimeout(this.waitingTimeoutHandle);
             }
-            this.totalNumberOfBytesRead += hexLength;
-            return hexPart.join('');
-        }
-        readInt8() {
-            this.totalNumberOfBytesRead += 1;
-            let data = this.operatingDataView.getInt8(this.currentByte++);
-            return data;
+            this.waitingTimeoutHandle = setTimeout(() => {
+                if (!this.inputStreamIsDone) {
+                    reject(new parser_error_1.TimeoutError(`Timed out before ${this.neededNextAmountOfBytes} bytes were available to read next.`));
+                }
+                return resolve();
+            }, this.timeout);
+        });
+    }
+    skipBytes(byteLength = 1) {
+        this.currentByte += byteLength;
+        this.totalNumberOfBytesRead += byteLength;
+        return;
+    }
+    readByte() {
+        this.totalNumberOfBytesRead += 1;
+        return this.operatingDataView.getUint8(this.currentByte++);
+    }
+    readBytes(count) {
+        this.totalNumberOfBytesRead += count;
+        return new Uint8Array(new Array(count).fill(0).map(pl => this.operatingDataView.getUint8(this.currentByte++)));
+    }
+    readHex(hexLength) {
+        let hexPart = [];
+        for (let i = 0; i < hexLength; i++) {
+            let currentHex = String.fromCharCode(this.operatingDataView.getUint8(this.currentByte++));
+            hexPart.push(currentHex);
+        }
+        this.totalNumberOfBytesRead += hexLength;
+        return hexPart.join('');
+    }
+    readInt8() {
+        this.totalNumberOfBytesRead += 1;
+        let data = this.operatingDataView.getInt8(this.currentByte++);
+        return data;
+    }
+    readUint8() {
+        this.totalNumberOfBytesRead += 1;
+        let data = this.operatingDataView.getUint8(this.currentByte++);
+        return data;
+    }
+    readInt16() {
+        this.totalNumberOfBytesRead += 2;
+        let data = this.operatingDataView.getInt16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+        return data;
+    }
+    readUint16() {
+        this.totalNumberOfBytesRead += 2;
+        let data = this.operatingDataView.getUint16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+        return data;
+    }
+    readInt32() {
+        this.totalNumberOfBytesRead += 4;
+        let data = this.operatingDataView.getInt32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readUint32() {
+        this.totalNumberOfBytesRead += 4;
+        let data = this.operatingDataView.getUint32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readLong() {
+        this.totalNumberOfBytesRead += 8;
+        let data = this.operatingDataView.getBigInt64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readInt64() {
+        return this.readLong();
+    }
+    readUint64() {
+        this.totalNumberOfBytesRead += 8;
+        let data = this.operatingDataView.getBigUint64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readFloat32() {
+        this.totalNumberOfBytesRead += 4;
+        let data = this.operatingDataView.getFloat32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readDouble() {
+        this.totalNumberOfBytesRead += 8;
+        let data = this.operatingDataView.getFloat64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readString() {
+        let strLength = this.readInt32();
+        if (strLength === 0) {
+            return '';
         }
-        readUint8() {
-            this.totalNumberOfBytesRead += 1;
-            let data = this.operatingDataView.getUint8(this.currentByte++);
-            return data;
+        if (strLength > (this.operatingDataView.buffer.byteLength - this.currentByte)) {
+            let errorMessage = `Cannot read string of length ${strLength} at position ${this.currentByte} as it exceeds the end at ${this.operatingDataView.buffer.byteLength}`;
+            throw new Error(errorMessage);
         }
-        readInt16() {
-            this.totalNumberOfBytesRead += 2;
-            let data = this.operatingDataView.getInt16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        if (strLength < 0) {
+            const string = new Array(-strLength - 1).fill('').map(c => String.fromCharCode(this.readUint16()));
             this.currentByte += 2;
-            return data;
-        }
-        readUint16() {
             this.totalNumberOfBytesRead += 2;
-            let data = this.operatingDataView.getUint16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 2;
-            return data;
+            return string.join('');
         }
-        readInt32() {
-            this.totalNumberOfBytesRead += 4;
-            let data = this.operatingDataView.getInt32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 4;
-            return data;
-        }
-        readUint32() {
-            this.totalNumberOfBytesRead += 4;
-            let data = this.operatingDataView.getUint32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 4;
-            return data;
-        }
-        readLong() {
-            this.totalNumberOfBytesRead += 8;
-            let data = this.operatingDataView.getBigInt64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 8;
-            return data;
-        }
-        readInt64() {
-            return this.readLong();
-        }
-        readUint64() {
-            this.totalNumberOfBytesRead += 8;
-            let data = this.operatingDataView.getBigUint64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 8;
-            return data;
-        }
-        readFloat32() {
-            this.totalNumberOfBytesRead += 4;
-            let data = this.operatingDataView.getFloat32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 4;
-            return data;
-        }
-        readDouble() {
-            this.totalNumberOfBytesRead += 8;
-            let data = this.operatingDataView.getFloat64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
-            this.currentByte += 8;
-            return data;
-        }
-        readString() {
-            let strLength = this.readInt32();
-            if (strLength === 0) {
-                return '';
-            }
-            if (strLength > (this.operatingDataView.buffer.byteLength - this.currentByte)) {
-                let errorMessage = `Cannot read string of length ${strLength} at position ${this.currentByte} as it exceeds the end at ${this.operatingDataView.buffer.byteLength}`;
-                throw new Error(errorMessage);
-            }
-            if (strLength < 0) {
-                const string = new Array(-strLength - 1).fill('').map(c => String.fromCharCode(this.readUint16()));
-                this.currentByte += 2;
-                this.totalNumberOfBytesRead += 2;
-                return string.join('');
-            }
-            try {
-                const string = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.readUint8()));
-                this.currentByte += 1;
-                this.totalNumberOfBytesRead += 1;
-                return string.join('');
-            }
-            catch (error) {
-                let errorMessage = `Cannot read UTF8 string of length ${strLength} at position ${this.currentByte}.`;
-                console.log(errorMessage, error);
-                throw error;
-            }
-        }
-        getBufferPosition() {
-            return this.totalNumberOfBytesRead;
-        }
-        getBufferProgress() {
-            throw new parser_error_1.UnimplementedError();
-        }
-        getBufferLength() {
-            return this.operatingStreamBuffer.byteLength;
+        try {
+            const string = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.readUint8()));
+            this.currentByte += 1;
+            this.totalNumberOfBytesRead += 1;
+            return string.join('');
         }
-        getAmountAllocatedLeft() {
-            return this.operatingStreamBuffer.byteLength - this.currentByte;
+        catch (error) {
+            let errorMessage = `Cannot read UTF8 string of length ${strLength} at position ${this.currentByte}.`;
+            console.log(errorMessage, error);
+            throw error;
         }
     }
-    exports.ByteStreamReader = ByteStreamReader;
-});
+    getBufferPosition() {
+        return this.totalNumberOfBytesRead;
+    }
+    getBufferProgress() {
+        throw new parser_error_1.UnimplementedError();
+    }
+    getBufferLength() {
+        return this.operatingStreamBuffer.byteLength;
+    }
+    getAmountAllocatedLeft() {
+        return this.operatingStreamBuffer.byteLength - this.currentByte;
+    }
+}
+exports.ByteStreamReader = ByteStreamReader;