@etothepii/satisfactory-file-parser 0.0.10 → 0.0.11

package/build/index.d.ts

@@ -0,0 +1,11 @@
+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 type * from './parser/satisfactory/satisfactory-save';
+export { StaticData } from './parser/satisfactory/static-data';
+export type * from './parser/satisfactory/structs/util.types';
+export { SaveEntity } from './parser/satisfactory/objects/SaveEntity';
+export { CompressionLibraryError, CorruptSaveError, ParserError, UnsupportedVersionError } from './parser/error/parser.error';
+export { SaveParser } from './parser/parser';

package/build/index.js

@@ -0,0 +1,12 @@
+// types & classes for convenience
+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';
+// should better be removed
+export { SaveEntity } from './parser/satisfactory/objects/SaveEntity';
+// errors
+export { CompressionLibraryError, CorruptSaveError, ParserError, UnsupportedVersionError } from './parser/error/parser.error';
+// facade
+export { SaveParser } from './parser/parser';

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,128 @@
+import Pako from "pako";
+import { Alignment } from "./byte/alignment.enum";
+import { ByteReader } from "./byte/byte-reader.class";
+import { ParserError } from "./error/parser.error";
+import { Level } from "./satisfactory/level.class";
+import { ParseCol4RGBA, ParseVec3 } from "./satisfactory/structs/util.types";
+export class BlueprintReader extends ByteReader {
+    constructor(bluePrintBuffer) {
+        super(bluePrintBuffer, 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 = 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.LITTLE_ENDIAN);
+            }
+            if (this.compressionInfo.maxChunkContentSize <= 0) {
+                this.compressionInfo.maxChunkContentSize = chunkHeader.getInt32(8, this.alignment === Alignment.LITTLE_ENDIAN); //00 00 02 00 = 131072
+            }
+            const chunkCompressedLength = chunkHeader.getInt32(32, this.alignment === Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = chunkHeader.getInt32(40, this.alignment === 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.inflate(currentChunk);
+                currentChunks.push(currentInflatedChunk);
+            }
+            catch (err) {
+                throw new 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.ReadObjectHeaders(reader, objects, () => { });
+        // objects contents
+        Level.ReadObjectContents(reader, objects, 0, () => { });
+        return objects;
+    }
+}
+export class BlueprintConfigReader extends ByteReader {
+    constructor(bluePrintConfigBuffer) {
+        super(bluePrintConfigBuffer, 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 = ParseCol4RGBA(reader); // LinearColor, which is 4x float32 as RGBA
+        return {
+            description,
+            color: colorMaybe,
+            iconID: unk3
+        };
+    }
+}

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,64 @@
+import { Level } from "../parser/satisfactory/level.class";
+import { SerializeCol4RGBA } from "../parser/satisfactory/structs/util.types";
+import { Alignment } from "./byte/alignment.enum";
+import { ByteWriter } from "./byte/byte-writer.class";
+import { ParserError } from "./error/parser.error";
+import { SaveWriter } from "./save-writer";
+export class BlueprintWriter extends ByteWriter {
+    constructor() {
+        super(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 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);
+        SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, this.alignment);
+    }
+    static SerializeObjects(writer, objects) {
+        // object headers
+        const headersLenIndicator = writer.getBufferPosition();
+        writer.writeInt32(0);
+        Level.SerializeObjectHeaders(writer, objects);
+        writer.writeBinarySizeFromPosition(headersLenIndicator, headersLenIndicator + 4);
+        // objects contents
+        Level.SerializeObjectContents(writer, objects, 0);
+    }
+}
+export class BlueprintConfigWriter extends ByteWriter {
+    constructor() {
+        super(Alignment.LITTLE_ENDIAN);
+    }
+    static SerializeConfig(writer, config) {
+        writer.writeInt32(2); // unknown, seems to always be 02.
+        writer.writeString(config.description);
+        writer.writeInt32(config.iconID);
+        SerializeCol4RGBA(writer, config.color);
+    }
+}

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,5 @@
+export var Alignment;
+(function (Alignment) {
+    Alignment[Alignment["BIG_ENDIAN"] = 0] = "BIG_ENDIAN";
+    Alignment[Alignment["LITTLE_ENDIAN"] = 1] = "LITTLE_ENDIAN";
+})(Alignment || (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,128 @@
+import { Alignment } from "./alignment.enum";
+export 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.LITTLE_ENDIAN);
+        this.currentByte += 2;
+        return data;
+    }
+    readInt32() {
+        let data = this.bufferView.getInt32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readUint32() {
+        let data = this.bufferView.getUint32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readLong() {
+        let data = this.bufferView.getBigInt64(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+        return data;
+    }
+    readFloat() {
+        let data = this.bufferView.getFloat32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+        return data;
+    }
+    readDouble() {
+        let data = this.bufferView.getFloat64(this.currentByte, this.alignment === 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.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;
+        }
+    }
+}

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;
+}

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

@@ -0,0 +1,146 @@
+import { Alignment } from "./alignment.enum";
+class ByteWriter {
+    constructor(alignment, bufferSize = 500) {
+        this.getBufferPosition = () => this.currentByte;
+        this.getBufferSlice = (start, end) => this.bufferArray.slice(start, end);
+        this.alignment = alignment;
+        this.bufferArray = new ArrayBuffer(bufferSize);
+        this.bufferView = new DataView(this.bufferArray);
+        this.currentByte = 0;
+    }
+    /*
+     * Byte Manipulation
+     */
+    skipBytes(count = 1) {
+        this.extendBufferIfNeeded(count);
+        this.currentByte += count;
+    }
+    jumpTo(pos) {
+        const count = pos - this.getBufferPosition();
+        this.skipBytes(count);
+    }
+    writeByte(value) {
+        this.extendBufferIfNeeded(1);
+        this.bufferView.setUint8(this.currentByte, value);
+        this.currentByte += 1;
+    }
+    writeBytesArray(bytes) {
+        this.writeBytes(new Uint8Array(bytes));
+    }
+    writeBytes(bytes) {
+        this.extendBufferIfNeeded(bytes.length);
+        bytes.forEach(byte => this.bufferView.setUint8(this.currentByte++, byte));
+    }
+    writeInt8(value) {
+        this.extendBufferIfNeeded(1);
+        this.bufferView.setInt8(this.currentByte, value);
+        this.currentByte += 1;
+    }
+    writeUint8(value) {
+        this.writeByte(value);
+    }
+    writeInt16(value) {
+        this.extendBufferIfNeeded(2);
+        this.bufferView.setInt16(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+    }
+    writeUint16(value) {
+        this.extendBufferIfNeeded(2);
+        this.bufferView.setUint16(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+    }
+    writeInt32(value) {
+        this.extendBufferIfNeeded(4);
+        this.bufferView.setInt32(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+    }
+    writeUint32(value) {
+        this.extendBufferIfNeeded(4);
+        this.bufferView.setUint32(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+    }
+    writeInt64(value) {
+        this.extendBufferIfNeeded(8);
+        this.bufferView.setBigInt64(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+    }
+    writeUint64(value) {
+        this.extendBufferIfNeeded(8);
+        this.bufferView.setBigUint64(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+    }
+    writeFloat(value) {
+        this.extendBufferIfNeeded(4);
+        this.bufferView.setFloat32(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+    }
+    writeDouble(value) {
+        this.extendBufferIfNeeded(8);
+        this.bufferView.setFloat64(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+    }
+    writeString(value) {
+        if (value.length === 0) {
+            this.writeInt32(0);
+            return;
+        }
+        // if it's safe to use ASCII, use UTF8.
+        if (ByteWriter.IsASCIICompatible(value)) {
+            this.writeInt32(value.length + 1);
+            for (let i = 0; i < value.length; i++) {
+                this.writeByte(value.charCodeAt(i));
+            }
+            this.writeUint8(0);
+        }
+        // write UTF16
+        else {
+            this.writeInt32(-value.length - 1);
+            for (let i = 0; i < value.length; i++) {
+                this.writeUint16(value.charCodeAt(i));
+            }
+            this.writeUint16(0);
+        }
+    }
+    writeBinarySizeFromPosition(lenIndicatorPos, start) {
+        const after = this.getBufferPosition();
+        const writtenBytes = after - start;
+        this.jumpTo(lenIndicatorPos);
+        this.writeInt32(writtenBytes);
+        this.jumpTo(after);
+    }
+    /**
+     * 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.
+     */
+    extendBufferIfNeeded(countNeededBytes, factor = 1.5) {
+        if (this.currentByte + countNeededBytes > this.bufferView.byteLength) {
+            this.bufferArray = ByteWriter.AppendBuffer(this.bufferArray, new ArrayBuffer(factor * this.bufferArray.byteLength));
+            this.bufferView = new DataView(this.bufferArray);
+        }
+    }
+    truncateBuffer() {
+        this.bufferArray = this.bufferArray.slice(0, this.currentByte);
+    }
+    endWriting() {
+        this.truncateBuffer();
+        return this.bufferArray;
+    }
+    static ToInt32(num) {
+        return new Uint8Array([
+            (num & 0xff000000) >> 24,
+            (num & 0x00ff0000) >> 16,
+            (num & 0x0000ff00) >> 8,
+            (num & 0x000000ff)
+        ]);
+    }
+    static AppendBuffer(buffer1, buffer2) {
+        var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
+        tmp.set(new Uint8Array(buffer1), 0);
+        tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
+        return tmp.buffer;
+    }
+    ;
+}
+ByteWriter.IsASCIICompatible = (value) => /^[\x00-\x7F]*$/.test(value);
+export { ByteWriter };

package/build/parser/error/parser.error.d.ts

@@ -0,0 +1,12 @@
+export declare class ParserError extends Error {
+    constructor(name: string, message: string);
+}
+export declare class UnsupportedVersionError extends ParserError {
+    constructor(message?: string);
+}
+export declare class CorruptSaveError extends ParserError {
+    constructor(message?: string);
+}
+export declare class CompressionLibraryError extends ParserError {
+    constructor(message?: string);
+}

package/build/parser/error/parser.error.js

@@ -0,0 +1,21 @@
+export class ParserError extends Error {
+    constructor(name, message) {
+        super(message);
+        this.name = name;
+    }
+}
+export class UnsupportedVersionError extends ParserError {
+    constructor(message) {
+        super('UnsupportedVersionError', message ?? 'This save version is not supported.');
+    }
+}
+export class CorruptSaveError extends ParserError {
+    constructor(message) {
+        super('CorruptSaveError', message ?? 'This save data is most likely corrupt.');
+    }
+}
+export class CompressionLibraryError extends ParserError {
+    constructor(message) {
+        super('CompressionLibraryError', message ?? 'Failed to compress/decompress save data.');
+    }
+}