@etothepii/satisfactory-file-parser 0.0.29 → 0.0.31

package/build/index.d.ts

@@ -0,0 +1,19 @@
+export * from './parser/satisfactory/blueprint/blueprint.types';
+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 { Level } from './parser/satisfactory/save/level.class';
+export { SatisfactorySave } from './parser/satisfactory/save/satisfactory-save';
+export * from './parser/satisfactory/save/save.types';
+export { ByteReader } from './parser/byte/byte-reader.class';
+export { ByteWriter } from './parser/byte/byte-writer.class';
+export { BlueprintConfigReader, BlueprintReader } from './parser/satisfactory/blueprint/blueprint-reader';
+export { BlueprintConfigWriter, BlueprintWriter } from './parser/satisfactory/blueprint/blueprint-writer';
+export { SaveReader } from './parser/satisfactory/save/save-reader';
+export { SaveWriter } from './parser/satisfactory/save/save-writer';
+export * from './parser/satisfactory/structs/util.types';
+export { CompressionLibraryError, CorruptSaveError, ParserError, UnsupportedVersionError } from './parser/error/parser.error';
+export * from './parser/file.types';
+export { Parser } from './parser/parser';

package/build/index.js

@@ -0,0 +1,65 @@
+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);
+};
+(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", "./parser/satisfactory/blueprint/blueprint.types", "./parser/satisfactory/objects/DataFields", "./parser/satisfactory/objects/ObjectReference", "./parser/satisfactory/objects/Property", "./parser/satisfactory/objects/SaveComponent", "./parser/satisfactory/objects/SaveEntity", "./parser/satisfactory/save/level.class", "./parser/satisfactory/save/satisfactory-save", "./parser/satisfactory/save/save.types", "./parser/byte/byte-reader.class", "./parser/byte/byte-writer.class", "./parser/satisfactory/blueprint/blueprint-reader", "./parser/satisfactory/blueprint/blueprint-writer", "./parser/satisfactory/save/save-reader", "./parser/satisfactory/save/save-writer", "./parser/satisfactory/structs/util.types", "./parser/error/parser.error", "./parser/file.types", "./parser/parser"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Parser = exports.UnsupportedVersionError = exports.ParserError = exports.CorruptSaveError = exports.CompressionLibraryError = exports.SaveWriter = exports.SaveReader = exports.BlueprintWriter = exports.BlueprintConfigWriter = exports.BlueprintReader = exports.BlueprintConfigReader = exports.ByteWriter = exports.ByteReader = exports.SatisfactorySave = exports.Level = exports.SaveEntity = exports.SaveComponent = exports.ObjectReference = exports.DataFields = void 0;
+    __exportStar(require("./parser/satisfactory/blueprint/blueprint.types"), exports);
+    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; } });
+    var level_class_1 = require("./parser/satisfactory/save/level.class");
+    Object.defineProperty(exports, "Level", { enumerable: true, get: function () { return level_class_1.Level; } });
+    var satisfactory_save_1 = require("./parser/satisfactory/save/satisfactory-save");
+    Object.defineProperty(exports, "SatisfactorySave", { enumerable: true, get: function () { return satisfactory_save_1.SatisfactorySave; } });
+    __exportStar(require("./parser/satisfactory/save/save.types"), exports);
+    var byte_reader_class_1 = require("./parser/byte/byte-reader.class");
+    Object.defineProperty(exports, "ByteReader", { enumerable: true, get: function () { return byte_reader_class_1.ByteReader; } });
+    var byte_writer_class_1 = require("./parser/byte/byte-writer.class");
+    Object.defineProperty(exports, "ByteWriter", { enumerable: true, get: function () { return byte_writer_class_1.ByteWriter; } });
+    var blueprint_reader_1 = require("./parser/satisfactory/blueprint/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/satisfactory/blueprint/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/satisfactory/save/save-reader");
+    Object.defineProperty(exports, "SaveReader", { enumerable: true, get: function () { return save_reader_1.SaveReader; } });
+    var save_writer_1 = require("./parser/satisfactory/save/save-writer");
+    Object.defineProperty(exports, "SaveWriter", { enumerable: true, get: function () { return save_writer_1.SaveWriter; } });
+    __exportStar(require("./parser/satisfactory/structs/util.types"), exports);
+    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; } });
+    __exportStar(require("./parser/file.types"), exports);
+    var parser_1 = require("./parser/parser");
+    Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
+});

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,18 @@
+(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.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,34 @@
+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);
+    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,131 @@
+(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", "./alignment.enum"], factory);
+    }
+})(function (require, exports) {
+    "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);
+        }
+        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;
+        }
+        skipBytes(byteLength = 1) {
+            this.currentByte += byteLength;
+        }
+        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 '';
+            }
+            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);
+            }
+            if (strLength < 0) {
+                const string = new Array(-strLength - 1).fill('').map(c => String.fromCharCode(this.readUint16()));
+                this.currentByte += 2;
+                return string.join('');
+            }
+            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,33 @@
+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;
+    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,149 @@
+(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", "./alignment.enum"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ByteWriter = void 0;
+    const alignment_enum_1 = require("./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;
+        }
+        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_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 2;
+        }
+        writeUint16(value) {
+            this.extendBufferIfNeeded(2);
+            this.bufferView.setUint16(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 2;
+        }
+        writeInt32(value) {
+            this.extendBufferIfNeeded(4);
+            this.bufferView.setInt32(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 4;
+        }
+        writeUint32(value) {
+            this.extendBufferIfNeeded(4);
+            this.bufferView.setUint32(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 4;
+        }
+        writeInt64(value) {
+            this.extendBufferIfNeeded(8);
+            this.bufferView.setBigInt64(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 8;
+        }
+        writeUint64(value) {
+            this.extendBufferIfNeeded(8);
+            this.bufferView.setBigUint64(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 8;
+        }
+        writeFloat(value) {
+            this.extendBufferIfNeeded(4);
+            this.bufferView.setFloat32(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 4;
+        }
+        writeDouble(value) {
+            this.extendBufferIfNeeded(8);
+            this.bufferView.setFloat64(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 8;
+        }
+        writeString(value) {
+            if (value.length === 0) {
+                this.writeInt32(0);
+                return;
+            }
+            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);
+            }
+            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);
+        }
+        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);
+    exports.ByteWriter = 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,38 @@
+(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.CompressionLibraryError = exports.CorruptSaveError = exports.UnsupportedVersionError = exports.ParserError = void 0;
+    class ParserError extends Error {
+        constructor(name, message) {
+            super(message);
+            this.name = name;
+        }
+    }
+    exports.ParserError = ParserError;
+    class UnsupportedVersionError extends ParserError {
+        constructor(message) {
+            super('UnsupportedVersionError', message ?? 'This save version is not supported.');
+        }
+    }
+    exports.UnsupportedVersionError = UnsupportedVersionError;
+    class CorruptSaveError extends ParserError {
+        constructor(message) {
+            super('CorruptSaveError', message ?? 'This save data is most likely corrupt.');
+        }
+    }
+    exports.CorruptSaveError = CorruptSaveError;
+    class CompressionLibraryError extends ParserError {
+        constructor(message) {
+            super('CompressionLibraryError', message ?? 'Failed to compress/decompress save data.');
+        }
+    }
+    exports.CompressionLibraryError = CompressionLibraryError;
+});

package/build/parser/file.types.d.ts

@@ -0,0 +1,9 @@
+export type ChunkCompressionInfo = {
+    chunkHeaderSize: number;
+    packageFileTag: number;
+    maxChunkContentSize: number;
+};
+export type ChunkSummary = {
+    uncompressedSize: number;
+    compressedSize: number;
+};

package/build/parser/file.types.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/build/parser/parser.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ChunkSummary } from "./file.types";
+import { Blueprint } from "./satisfactory/blueprint/blueprint.types";
+import { SatisfactorySave } from "./satisfactory/save/satisfactory-save";
+import { SaveProjectionConfig } from "./satisfactory/save/save-reader";
+export declare class Parser {
+    static WriteSave(save: SatisfactorySave, onBinaryBeforeCompressing: (buffer: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
+    static ParseSaveFile(file: Buffer, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
+    static WriteBlueprintFiles(blueprint: Blueprint, onMainFileBinaryBeforeCompressing?: (binary: ArrayBuffer) => void, onMainFileHeader?: (header: Uint8Array) => void, onMainFileChunk?: (chunk: Uint8Array) => void): {
+        mainFileChunkSummary: ChunkSummary[];
+        configFileBinary: ArrayBuffer;
+    };
+    static ParseBlueprintFiles(name: string, blueprintFile: Buffer, blueprintConfigFile: Buffer, onDecompressedBlueprintBody?: (buffer: ArrayBuffer) => void): Blueprint;
+    static ProjectSave(save: SatisfactorySave, config: SaveProjectionConfig): SatisfactorySave;
+    static JSONStringifyModified: (obj: any, indent?: number) => string;
+}

package/build/parser/parser.js

@@ -0,0 +1,98 @@
+(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", "./satisfactory/blueprint/blueprint-reader", "./satisfactory/blueprint/blueprint-writer", "./satisfactory/save/level.class", "./satisfactory/save/satisfactory-save", "./satisfactory/save/save-reader", "./satisfactory/save/save-writer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Parser = void 0;
+    const blueprint_reader_1 = require("./satisfactory/blueprint/blueprint-reader");
+    const blueprint_writer_1 = require("./satisfactory/blueprint/blueprint-writer");
+    const level_class_1 = require("./satisfactory/save/level.class");
+    const satisfactory_save_1 = require("./satisfactory/save/satisfactory-save");
+    const save_reader_1 = require("./satisfactory/save/save-reader");
+    const save_writer_1 = require("./satisfactory/save/save-writer");
+    class Parser {
+        static WriteSave(save, onBinaryBeforeCompressing, onHeader, onChunk) {
+            const writer = new save_writer_1.SaveWriter();
+            save_writer_1.SaveWriter.WriteHeader(writer, save.header);
+            const posAfterHeader = writer.getBufferPosition();
+            save_writer_1.SaveWriter.WriteLevels(writer, save, save.header.buildVersion);
+            writer.endWriting();
+            const chunkSummary = writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk);
+            return chunkSummary;
+        }
+        static ParseSaveFile(file, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
+            const reader = new save_reader_1.SaveReader(new Uint8Array(file).buffer, onProgress);
+            const header = reader.readHeader();
+            const save = new satisfactory_save_1.SatisfactorySave(header);
+            const inflateResult = reader.inflateChunks();
+            onDecompressedSaveBody(reader.getBuffer());
+            const levelParseResult = reader.readLevels();
+            save.levels = reader.levels;
+            save.compressionInfo = reader.compressionInfo;
+            save.trailingCollectedObjects = reader.trailingCollectedObjects;
+            return save;
+        }
+        static WriteBlueprintFiles(blueprint, onMainFileBinaryBeforeCompressing = () => { }, onMainFileHeader = () => { }, onMainFileChunk = () => { }) {
+            const blueprintWriter = new blueprint_writer_1.BlueprintWriter();
+            blueprint_writer_1.BlueprintWriter.SerializeHeader(blueprintWriter, blueprint.header);
+            const saveBodyPos = blueprintWriter.getBufferPosition();
+            blueprint_writer_1.BlueprintWriter.SerializeObjects(blueprintWriter, blueprint.objects);
+            blueprintWriter.endWriting();
+            let binaryChunks = [];
+            let binaryHeader;
+            const mainFileChunkSummary = blueprintWriter.generateChunks(blueprint.compressionInfo, saveBodyPos, onMainFileBinaryBeforeCompressing, onMainFileHeader, onMainFileChunk);
+            const configWriter = new blueprint_writer_1.BlueprintConfigWriter();
+            blueprint_writer_1.BlueprintConfigWriter.SerializeConfig(configWriter, blueprint.config);
+            const configFileBinary = configWriter.endWriting();
+            return {
+                mainFileChunkSummary,
+                configFileBinary
+            };
+        }
+        static ParseBlueprintFiles(name, blueprintFile, blueprintConfigFile, onDecompressedBlueprintBody = () => { }) {
+            const blueprintConfigReader = new blueprint_reader_1.BlueprintConfigReader(new Uint8Array(blueprintConfigFile).buffer);
+            const config = blueprint_reader_1.BlueprintConfigReader.ParseConfig(blueprintConfigReader);
+            const blueprintReader = new blueprint_reader_1.BlueprintReader(new Uint8Array(blueprintFile).buffer);
+            const header = blueprint_reader_1.BlueprintReader.ReadHeader(blueprintReader);
+            const inflateResult = blueprintReader.inflateChunks();
+            onDecompressedBlueprintBody(inflateResult.inflatedData);
+            const blueprintObjects = blueprint_reader_1.BlueprintReader.ParseObjects(blueprintReader);
+            const blueprint = {
+                name,
+                compressionInfo: blueprintReader.compressionInfo,
+                header: header,
+                config,
+                objects: blueprintObjects
+            };
+            return blueprint;
+        }
+        static ProjectSave(save, config) {
+            return {
+                header: save.header,
+                trailingCollectedObjects: save.trailingCollectedObjects,
+                levels: save.levels.map(level => {
+                    const lvl = new level_class_1.Level(level.name);
+                    lvl.collectables = level.collectables;
+                    lvl.objects = level.objects.filter(obj => (0, save_reader_1.projectionFilterApplies)(config, obj));
+                    return lvl;
+                })
+            };
+        }
+    }
+    Parser.JSONStringifyModified = (obj, indent = 0) => JSON.stringify(obj, (key, value) => {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        else if (value === 0 && 1 / value < 0) {
+            return '-0';
+        }
+        return value;
+    }, indent);
+    exports.Parser = Parser;
+});