@etothepii/satisfactory-file-parser 0.0.10 → 0.0.12

package/build/index.d.ts

@@ -0,0 +1,15 @@
+export { Level } from './parser/satisfactory/level.class';
+export { DataFields } from './parser/satisfactory/objects/DataFields';
+export { ObjectReference } from './parser/satisfactory/objects/ObjectReference';
+export * from './parser/satisfactory/objects/Property';
+export { SaveComponent } from './parser/satisfactory/objects/SaveComponent';
+export { SaveEntity } from './parser/satisfactory/objects/SaveEntity';
+export type * from './parser/satisfactory/satisfactory-save';
+export { StaticData } from './parser/satisfactory/static-data';
+export { BlueprintConfigReader, BlueprintReader } from './parser/blueprint-reader';
+export { BlueprintConfigWriter, BlueprintWriter } from './parser/blueprint-writer';
+export type * from './parser/satisfactory/structs/util.types';
+export { SaveReader } from './parser/save-reader';
+export { SaveWriter } from './parser/save-writer';
+export { CompressionLibraryError, CorruptSaveError, ParserError, UnsupportedVersionError } from './parser/error/parser.error';
+export { SaveParser } from './parser/parser';

package/build/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveParser = exports.UnsupportedVersionError = exports.ParserError = exports.CorruptSaveError = exports.CompressionLibraryError = exports.SaveWriter = exports.SaveReader = exports.BlueprintWriter = exports.BlueprintConfigWriter = exports.BlueprintReader = exports.BlueprintConfigReader = exports.SaveEntity = exports.SaveComponent = exports.ObjectReference = exports.DataFields = exports.Level = void 0;
+// types & classes for convenience
+var level_class_1 = require("./parser/satisfactory/level.class");
+Object.defineProperty(exports, "Level", { enumerable: true, get: function () { return level_class_1.Level; } });
+var DataFields_1 = require("./parser/satisfactory/objects/DataFields");
+Object.defineProperty(exports, "DataFields", { enumerable: true, get: function () { return DataFields_1.DataFields; } });
+var ObjectReference_1 = require("./parser/satisfactory/objects/ObjectReference");
+Object.defineProperty(exports, "ObjectReference", { enumerable: true, get: function () { return ObjectReference_1.ObjectReference; } });
+__exportStar(require("./parser/satisfactory/objects/Property"), exports);
+var SaveComponent_1 = require("./parser/satisfactory/objects/SaveComponent");
+Object.defineProperty(exports, "SaveComponent", { enumerable: true, get: function () { return SaveComponent_1.SaveComponent; } });
+var SaveEntity_1 = require("./parser/satisfactory/objects/SaveEntity");
+Object.defineProperty(exports, "SaveEntity", { enumerable: true, get: function () { return SaveEntity_1.SaveEntity; } });
+// should better be removed in a future update to prevent shenanigans.
+var blueprint_reader_1 = require("./parser/blueprint-reader");
+Object.defineProperty(exports, "BlueprintConfigReader", { enumerable: true, get: function () { return blueprint_reader_1.BlueprintConfigReader; } });
+Object.defineProperty(exports, "BlueprintReader", { enumerable: true, get: function () { return blueprint_reader_1.BlueprintReader; } });
+var blueprint_writer_1 = require("./parser/blueprint-writer");
+Object.defineProperty(exports, "BlueprintConfigWriter", { enumerable: true, get: function () { return blueprint_writer_1.BlueprintConfigWriter; } });
+Object.defineProperty(exports, "BlueprintWriter", { enumerable: true, get: function () { return blueprint_writer_1.BlueprintWriter; } });
+var save_reader_1 = require("./parser/save-reader");
+Object.defineProperty(exports, "SaveReader", { enumerable: true, get: function () { return save_reader_1.SaveReader; } });
+var save_writer_1 = require("./parser/save-writer");
+Object.defineProperty(exports, "SaveWriter", { enumerable: true, get: function () { return save_writer_1.SaveWriter; } });
+// errors
+var parser_error_1 = require("./parser/error/parser.error");
+Object.defineProperty(exports, "CompressionLibraryError", { enumerable: true, get: function () { return parser_error_1.CompressionLibraryError; } });
+Object.defineProperty(exports, "CorruptSaveError", { enumerable: true, get: function () { return parser_error_1.CorruptSaveError; } });
+Object.defineProperty(exports, "ParserError", { enumerable: true, get: function () { return parser_error_1.ParserError; } });
+Object.defineProperty(exports, "UnsupportedVersionError", { enumerable: true, get: function () { return parser_error_1.UnsupportedVersionError; } });
+// facade
+var parser_1 = require("./parser/parser");
+Object.defineProperty(exports, "SaveParser", { enumerable: true, get: function () { return parser_1.SaveParser; } });

package/build/parser/blueprint-reader.d.ts

@@ -0,0 +1,18 @@
+import { ByteReader } from "./byte/byte-reader.class";
+import { BlueprintConfig, BlueprintHeader } from "./satisfactory/blueprint/blueprint";
+import { SaveComponent } from "./satisfactory/objects/SaveComponent";
+import { SaveEntity } from "./satisfactory/objects/SaveEntity";
+import { ChunkCompressionInfo } from "./satisfactory/satisfactory-save";
+export declare class BlueprintReader extends ByteReader {
+    compressionInfo: ChunkCompressionInfo;
+    constructor(bluePrintBuffer: ArrayBuffer);
+    static ReadHeader(reader: ByteReader): BlueprintHeader;
+    inflateChunks(): any;
+    static ParseObjects(reader: ByteReader): (SaveEntity | SaveComponent)[];
+}
+export declare class BlueprintConfigReader extends ByteReader {
+    bluePrintConfigBuffer: ArrayBuffer;
+    constructor(bluePrintConfigBuffer: ArrayBuffer);
+    parse: () => BlueprintConfig;
+    static ParseConfig(reader: ByteReader): BlueprintConfig;
+}

package/build/parser/blueprint-reader.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueprintConfigReader = exports.BlueprintReader = void 0;
+const pako_1 = __importDefault(require("pako"));
+const alignment_enum_1 = require("./byte/alignment.enum");
+const byte_reader_class_1 = require("./byte/byte-reader.class");
+const parser_error_1 = require("./error/parser.error");
+const level_class_1 = require("./satisfactory/level.class");
+const util_types_1 = require("./satisfactory/structs/util.types");
+class BlueprintReader extends byte_reader_class_1.ByteReader {
+    constructor(bluePrintBuffer) {
+        super(bluePrintBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.compressionInfo = {
+            packageFileTag: 0,
+            maxChunkContentSize: 0,
+            chunkHeaderSize: 48
+        };
+    }
+    static ReadHeader(reader) {
+        const unk = reader.readBytes(3 * 4); // 02 00 00 00, 24 00 00 00, 7F 3B 03 00 - always
+        const positionThingOrWhat = (0, util_types_1.ParseVec3)(reader); // 04 00 00 00, 04 00 00 00, 04 00 00 00 - always
+        // list of item costs.
+        let itemTypeCount = reader.readInt32();
+        const itemCosts = new Array(itemTypeCount).fill(['', 0]);
+        for (let i = 0; i < itemTypeCount; i++) {
+            let indexOrWhat = reader.readInt32();
+            let itemPathName = reader.readString();
+            let itemCount = reader.readInt32();
+            itemCosts[i] = [itemPathName, itemCount];
+        }
+        // list of recipes
+        let recipeCount = reader.readInt32();
+        const recipeRefs = new Array(recipeCount).fill('');
+        for (let i = 0; i < recipeCount; i++) {
+            let indexOrWhat = reader.readInt32();
+            const recipeName = reader.readString();
+            recipeRefs[i] = recipeName;
+        }
+        return {
+            recipeReferences: recipeRefs,
+            itemCosts
+        };
+    }
+    inflateChunks() {
+        // free memory
+        this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+        this.handledByte = 0;
+        this.currentByte = 0;
+        this.maxByte = this.fileBuffer.byteLength;
+        let currentChunks = [];
+        let totalUncompressedBodySize = 0;
+        // read while we can handle
+        while (this.handledByte < this.maxByte) {
+            // Read chunk info size...
+            let chunkHeader = new DataView(this.fileBuffer.slice(0, this.compressionInfo.chunkHeaderSize));
+            this.currentByte = this.compressionInfo.chunkHeaderSize;
+            this.handledByte += this.compressionInfo.chunkHeaderSize;
+            if (this.compressionInfo.packageFileTag <= 0) {
+                this.compressionInfo.packageFileTag = chunkHeader.getUint32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            if (this.compressionInfo.maxChunkContentSize <= 0) {
+                this.compressionInfo.maxChunkContentSize = chunkHeader.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN); //00 00 02 00 = 131072
+            }
+            const chunkCompressedLength = chunkHeader.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = chunkHeader.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            totalUncompressedBodySize += chunkUncompressedLength;
+            const currentChunkSize = chunkCompressedLength;
+            let currentChunk = this.fileBuffer.slice(this.currentByte, this.currentByte + currentChunkSize);
+            this.handledByte += currentChunkSize;
+            this.currentByte += currentChunkSize;
+            // Free memory from previous chunk...
+            this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+            this.currentByte = 0;
+            try {
+                // Inflate current chunk
+                let currentInflatedChunk = null;
+                currentInflatedChunk = pako_1.default.inflate(currentChunk);
+                currentChunks.push(currentInflatedChunk);
+            }
+            catch (err) {
+                throw new parser_error_1.ParserError('ParserError', 'An error occurred while calling pako inflate.' + err);
+            }
+        }
+        //TODO we can get rid of file buffer here.
+        // Create one big chunk out of the little chunks
+        let newChunkLength = currentChunks.map(cc => cc.length).reduce((prev, cur) => prev + cur);
+        const bigWholeChunk = new Uint8Array(newChunkLength);
+        let currentLength = 0;
+        for (let i = 0; i < currentChunks.length; i++) {
+            bigWholeChunk.set(currentChunks[i], currentLength);
+            currentLength += currentChunks[i].length;
+        }
+        // reset reader on this body content.
+        this.currentByte = 0;
+        this.maxByte = bigWholeChunk.buffer.byteLength;
+        this.bufferView = new DataView(bigWholeChunk.buffer);
+        return {
+            newChunkLength,
+            numChunks: currentChunks.length,
+            inflatedData: bigWholeChunk
+        };
+    }
+    static ParseObjects(reader) {
+        const totalBodyRestSize = reader.readInt32();
+        // object headers
+        const objectHeadersBinarySize = reader.readInt32();
+        let objects = [];
+        level_class_1.Level.ReadObjectHeaders(reader, objects, () => { });
+        // objects contents
+        level_class_1.Level.ReadObjectContents(reader, objects, 0, () => { });
+        return objects;
+    }
+}
+exports.BlueprintReader = BlueprintReader;
+class BlueprintConfigReader extends byte_reader_class_1.ByteReader {
+    constructor(bluePrintConfigBuffer) {
+        super(bluePrintConfigBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.bluePrintConfigBuffer = bluePrintConfigBuffer;
+        this.parse = () => BlueprintConfigReader.ParseConfig(this);
+    }
+    static ParseConfig(reader) {
+        const unk = reader.readInt32(); // unknown, seems to always be 02.
+        const description = reader.readString();
+        const unk3 = reader.readInt32(); // iconID. default is 0x0E03 = 782
+        const colorMaybe = (0, util_types_1.ParseCol4RGBA)(reader); // LinearColor, which is 4x float32 as RGBA
+        return {
+            description,
+            color: colorMaybe,
+            iconID: unk3
+        };
+    }
+}
+exports.BlueprintConfigReader = BlueprintConfigReader;

package/build/parser/blueprint-writer.d.ts

@@ -0,0 +1,21 @@
+import { SaveComponent } from "../parser/satisfactory/objects/SaveComponent";
+import { SaveEntity } from "../parser/satisfactory/objects/SaveEntity";
+import { ByteWriter } from "./byte/byte-writer.class";
+import { BlueprintConfig, BlueprintHeader } from "./satisfactory/blueprint/blueprint";
+import { ChunkCompressionInfo } from "./satisfactory/satisfactory-save";
+export declare class BlueprintWriter extends ByteWriter {
+    constructor();
+    static SerializeHeader(writer: ByteWriter, header: BlueprintHeader): void;
+    generateChunks(compressionInfo: ChunkCompressionInfo, posAfterHeader: number, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
+        errors: string[];
+        chunkSummary: {
+            uncompressedSize: number;
+            compressedSize: number;
+        }[];
+    }) => void): void;
+    static SerializeObjects(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
+}
+export declare class BlueprintConfigWriter extends ByteWriter {
+    constructor();
+    static SerializeConfig(writer: ByteWriter, config: BlueprintConfig): void;
+}

package/build/parser/blueprint-writer.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueprintConfigWriter = exports.BlueprintWriter = void 0;
+const level_class_1 = require("../parser/satisfactory/level.class");
+const util_types_1 = require("../parser/satisfactory/structs/util.types");
+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");
+const save_writer_1 = require("./save-writer");
+class BlueprintWriter extends byte_writer_class_1.ByteWriter {
+    constructor() {
+        super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+    }
+    static SerializeHeader(writer, header) {
+        writer.writeInt32(2); // unknown, seems to always be 02.
+        writer.writeInt32(36); // TODO - unknown what it is, but its constant so far.
+        writer.writeInt32(211839); // TODO - unknown what it is, but its constant so far.
+        // TODO - whatever those are, but they are constant so far.
+        writer.writeInt32(4);
+        writer.writeInt32(4);
+        writer.writeInt32(4);
+        // list of item costs.
+        writer.writeInt32(header.itemCosts.length);
+        for (const itemCost of header.itemCosts) {
+            writer.writeInt32(0); //TODO: unk or what
+            writer.writeString(itemCost[0]);
+            writer.writeInt32(itemCost[1]);
+        }
+        // list of recipes.
+        writer.writeInt32(header.recipeReferences.length);
+        for (const recipeReference of header.recipeReferences) {
+            writer.writeInt32(0); //TODO: unk or what
+            writer.writeString(recipeReference);
+        }
+    }
+    generateChunks(compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish) {
+        if (posAfterHeader <= 0) {
+            throw new parser_error_1.ParserError('ParserError', 'seems like this buffer has no header. Please write the header first before you can generate chunks.');
+        }
+        // send plain header first.
+        const header = new Uint8Array(this.bufferArray.slice(0, posAfterHeader));
+        onHeader(header);
+        // create save body
+        this.bufferArray = this.bufferArray.slice(posAfterHeader);
+        save_writer_1.SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, this.alignment);
+    }
+    static SerializeObjects(writer, objects) {
+        // object headers
+        const headersLenIndicator = writer.getBufferPosition();
+        writer.writeInt32(0);
+        level_class_1.Level.SerializeObjectHeaders(writer, objects);
+        writer.writeBinarySizeFromPosition(headersLenIndicator, headersLenIndicator + 4);
+        // objects contents
+        level_class_1.Level.SerializeObjectContents(writer, objects, 0);
+    }
+}
+exports.BlueprintWriter = BlueprintWriter;
+class BlueprintConfigWriter extends byte_writer_class_1.ByteWriter {
+    constructor() {
+        super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+    }
+    static SerializeConfig(writer, config) {
+        writer.writeInt32(2); // unknown, seems to always be 02.
+        writer.writeString(config.description);
+        writer.writeInt32(config.iconID);
+        (0, util_types_1.SerializeCol4RGBA)(writer, config.color);
+    }
+}
+exports.BlueprintConfigWriter = BlueprintConfigWriter;

package/build/parser/byte/alignment.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum Alignment {
+    BIG_ENDIAN = 0,
+    LITTLE_ENDIAN = 1
+}

package/build/parser/byte/alignment.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alignment = void 0;
+var Alignment;
+(function (Alignment) {
+    Alignment[Alignment["BIG_ENDIAN"] = 0] = "BIG_ENDIAN";
+    Alignment[Alignment["LITTLE_ENDIAN"] = 1] = "LITTLE_ENDIAN";
+})(Alignment = exports.Alignment || (exports.Alignment = {}));

package/build/parser/byte/byte-reader.class.d.ts

@@ -0,0 +1,38 @@
+import { Alignment } from "./alignment.enum";
+export declare abstract class ByteReader {
+    protected bufferView: DataView;
+    protected fileBuffer: ArrayBuffer;
+    protected alignment: Alignment;
+    protected currentByte: number;
+    protected handledByte: number;
+    protected maxByte: number;
+    protected lastStrRead: number;
+    constructor(fileBuffer: ArrayBuffer, alignment: Alignment);
+    /**
+     * Resets the reader on the given arraybuffer to start from the beginning.
+     * @param newFileBuffer the new array buffer to be read.
+     */
+    reset(newFileBuffer: ArrayBuffer): void;
+    skipBytes(byteLength?: number): void;
+    readByte(): number;
+    readBytes(count: number): Uint8Array;
+    readHex(hexLength: number): string;
+    readInt8(): number;
+    readUint8(): number;
+    readUint16(): number;
+    readInt32(): number;
+    readUint32(): number;
+    readLong(): bigint;
+    readFloat(): number;
+    readDouble(): number;
+    protected getStringInfo(): {
+        payload: string;
+        counter: number;
+    };
+    getBufferPosition: () => number;
+    getBufferSlice: (begin: number, end: number | undefined) => ArrayBuffer;
+    getBufferProgress: () => number;
+    getBufferLength: () => number;
+    getBuffer: () => ArrayBuffer;
+    readString(): string;
+}

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteReader = void 0;
+const alignment_enum_1 = require("./alignment.enum");
+class ByteReader {
+    constructor(fileBuffer, alignment) {
+        this.currentByte = 0;
+        this.handledByte = 0;
+        this.maxByte = 0;
+        this.lastStrRead = 0;
+        this.getBufferPosition = () => this.currentByte;
+        this.getBufferSlice = (begin, end) => this.bufferView.buffer.slice(begin, end);
+        this.getBufferProgress = () => this.currentByte / this.bufferView.buffer.byteLength;
+        this.getBufferLength = () => this.bufferView.buffer.byteLength;
+        this.getBuffer = () => this.bufferView.buffer;
+        this.alignment = alignment;
+        this.reset(fileBuffer);
+    }
+    /**
+     * Resets the reader on the given arraybuffer to start from the beginning.
+     * @param newFileBuffer the new array buffer to be read.
+     */
+    reset(newFileBuffer) {
+        this.fileBuffer = newFileBuffer;
+        this.bufferView = new DataView(newFileBuffer, 0, Math.min(102400, this.fileBuffer.byteLength));
+        this.maxByte = newFileBuffer.byteLength;
+        this.currentByte = 0;
+        this.handledByte = 0;
+    }
+    /*
+     * Byte Manipulation
+     */
+    skipBytes(byteLength = 1) {
+        this.currentByte += byteLength;
+    }
+    readByte() {
+        // TODO can i not just readByte() ??
+        return parseInt(this.bufferView.getUint8(this.currentByte++).toString());
+    }
+    readBytes(count) {
+        return new Uint8Array(new Array(count).fill(0).map(pl => this.bufferView.getUint8(this.currentByte++)));
+    }
+    readHex(hexLength) {
+        let hexPart = [];
+        for (let i = 0; i < hexLength; i++) {
+            let currentHex = String.fromCharCode(this.bufferView.getUint8(this.currentByte++));
+            hexPart.push(currentHex);
+        }
+        return hexPart.join('');
+    }
+    readInt8() {
+        let data = this.bufferView.getInt8(this.currentByte++);
+        return data;
+    }
+    readUint8() {
+        let data = this.bufferView.getUint8(this.currentByte++);
+        return data;
+    }
+    readUint16() {
+        let data = this.bufferView.getUint16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+        return data;
+    }
+    readInt32() {
+        let data = this.bufferView.getInt32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readUint32() {
+        let data = this.bufferView.getUint32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readLong() {
+        let data = this.bufferView.getBigInt64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readFloat() {
+        let data = this.bufferView.getFloat32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readDouble() {
+        let data = this.bufferView.getFloat64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    getStringInfo() {
+        let payload = '';
+        let counter = this.currentByte;
+        try {
+            let strLength = this.bufferView.getInt32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            counter += 4;
+            payload = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.bufferView.getUint8(counter++))).join('');
+        }
+        catch (error) { }
+        this.currentByte -= counter;
+        return { payload, counter };
+    }
+    readString() {
+        let strLength = this.readInt32();
+        this.lastStrRead = strLength;
+        let startBytes = this.currentByte;
+        if (strLength === 0) {
+            return '';
+        }
+        // Range error!
+        if (strLength > (this.bufferView.buffer.byteLength - this.currentByte)) {
+            let errorMessage = `Cannot read string of length ${strLength} at position ${this.currentByte} as it exceeds the end at ${this.bufferView.buffer.byteLength}`;
+            throw new Error(errorMessage);
+        }
+        // it uses UTF16 if text is non-ascii, even if it would fit into UTF8.
+        if (strLength < 0) {
+            const string = new Array(-strLength - 1).fill('').map(c => String.fromCharCode(this.readUint16()));
+            this.currentByte += 2;
+            return string.join('');
+        }
+        //default UTF-8
+        try {
+            const string = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.readUint8()));
+            this.currentByte += 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;
+        }
+    }
+}
+exports.ByteReader = ByteReader;

package/build/parser/byte/byte-writer.class.d.ts

@@ -0,0 +1,38 @@
+import { Alignment } from "./alignment.enum";
+export declare abstract class ByteWriter {
+    protected alignment: Alignment;
+    protected bufferArray: ArrayBuffer;
+    protected bufferView: DataView;
+    protected currentByte: number;
+    constructor(alignment: Alignment, bufferSize?: number);
+    skipBytes(count?: number): void;
+    jumpTo(pos: number): void;
+    writeByte(value: number): void;
+    writeBytesArray(bytes: number[]): void;
+    writeBytes(bytes: Uint8Array): void;
+    writeInt8(value: number): void;
+    writeUint8(value: number): void;
+    writeInt16(value: number): void;
+    writeUint16(value: number): void;
+    writeInt32(value: number): void;
+    writeUint32(value: number): void;
+    writeInt64(value: bigint): void;
+    writeUint64(value: bigint): void;
+    writeFloat(value: number): void;
+    writeDouble(value: number): void;
+    writeString(value: string): void;
+    static IsASCIICompatible: (value: string) => boolean;
+    getBufferPosition: () => number;
+    getBufferSlice: (start: number, end?: number) => ArrayBuffer;
+    writeBinarySizeFromPosition(lenIndicatorPos: number, start: number): void;
+    /**
+     * automatically extends the current buffer if the given space exceeds the available rest capacity of the current buffer.
+     * @param countNeededBytes the needed space
+     * @param factor how big the appended buffer should be in comparison to the current one. Values >= 1 make sense.
+     */
+    protected extendBufferIfNeeded(countNeededBytes: number, factor?: number): void;
+    protected truncateBuffer(): void;
+    endWriting(): ArrayBuffer;
+    static ToInt32(num: number): Uint8Array;
+    static AppendBuffer(buffer1: ArrayBuffer, buffer2: ArrayBuffer): ArrayBuffer;
+}