@etothepii/satisfactory-file-parser 0.0.15 → 0.0.16

package/build/index.d.ts

@@ -1,15 +1,17 @@
-export { Level } from './parser/satisfactory/level.class';
+export type * 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 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 { Level } from './parser/satisfactory/save/level.class';
+export { SatisfactorySave } from './parser/satisfactory/save/satisfactory-save';
+export type * from './parser/satisfactory/save/save.types';
+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 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';
+export type * from './parser/file.types';
+export { Parser } from './parser/parser';

package/build/index.js

@@ -14,10 +14,7 @@ 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; } });
+exports.Parser = exports.UnsupportedVersionError = exports.ParserError = exports.CorruptSaveError = exports.CompressionLibraryError = exports.SaveWriter = exports.SaveReader = exports.BlueprintWriter = exports.BlueprintConfigWriter = exports.BlueprintReader = exports.BlueprintConfigReader = exports.SatisfactorySave = exports.Level = exports.SaveEntity = exports.SaveComponent = exports.ObjectReference = exports.DataFields = void 0;
 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");
@@ -27,23 +24,24 @@ 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");
+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; } });
+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/blueprint-writer");
+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/save-reader");
+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/save-writer");
+var save_writer_1 = require("./parser/satisfactory/save/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; } });
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });

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

@@ -1,38 +1 @@
-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;
-}
+export {};

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

@@ -16,10 +16,6 @@ class ByteReader {
         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));
@@ -27,14 +23,10 @@ class ByteReader {
         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) {
@@ -105,18 +97,15 @@ class ByteReader {
         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;

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

@@ -1,38 +1 @@
-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;
-}
+export {};

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

@@ -11,9 +11,6 @@ class ByteWriter {
         this.bufferView = new DataView(this.bufferArray);
         this.currentByte = 0;
     }
-    /*
-     * Byte Manipulation
-     */
     skipBytes(count = 1) {
         this.extendBufferIfNeeded(count);
         this.currentByte += count;
@@ -87,7 +84,6 @@ class ByteWriter {
             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++) {
@@ -95,7 +91,6 @@ class ByteWriter {
             }
             this.writeUint8(0);
         }
-        // write UTF16
         else {
             this.writeInt32(-value.length - 1);
             for (let i = 0; i < value.length; i++) {
@@ -111,11 +106,6 @@ class ByteWriter {
         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));

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,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/parser/parser.d.ts

@@ -1,44 +1,16 @@
 /// <reference types="node" />
-import { SatisfactorySave } from "./satisfactory/satisfactory-save";
-import { SaveProjectionConfig } from "./save-reader";
-export declare class SaveParser {
-    /**
-     * serializes a save file into binary and reports back on individual callbacks.
-     * @param save the save file to serialize into binary.
-     * @param onBinaryBeforeCompressing gets called on the binary save body before it is compressed.
-     * @param onHeader gets called on the binary save header, which is always uncompressed.
-     * @param onChunk gets called when a chunk of the compressed save body was generated. Often, files' save bodies consist of multiple chunks.
-     * @param onFinish gets called when all chunks have been generated. A summary of the chunk sizes and count is reported.
-     */
-    static WriteSave(save: SatisfactorySave, onBinaryBeforeCompressing: (buffer: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
-        errors: string[];
-        chunkSummary: {
-            uncompressedSize: number;
-            compressedSize: number;
-        }[];
-    }) => void): void;
-    /**
-     * parses a save object from a binary buffer and reports back on decompressing the save body in a callback.
-     * @param file the binary content to be parsed.
-     * @param additionalData additional static data that is not contained in save files. For example, power slugs and resource nodes.
-     * @param onSaveDecompressed gets called when the entire binary save body has been decompressed.
-     * @returns a brief summary
-     */
-    static ParseSaveFile(file: Buffer, onSaveDecompressed?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
-    /**
-     * Does Projection on a Save Object in order to reduce it's complexity.
-     * @param save the save object in question.
-     * @param config the projection config to apply.
-     * @returns a save object that has been projected / modified. Do not try to serialize it into an actual save tho! Since information has been transformed.
-     */
+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;
-    /**
-     * It JSON.stringifies any parsed content safely. The original JSON.stringify() has some flaws that get in the way, so it is custom wrapped. The original has some problems:
-     * 1. it cannot stringify bigints. So we help out by converting it into a string.
-     * 2. It cannot distinguish between 0 and -0. But a float32 is encoded in a uint8Array for 0 to be [0,0,0,0] (0x00000000) and -0 to be [0,0,0,128] (0x00000080) in little endian.
-     * @param obj
-     * @param indent
-     * @returns a string that is safely stringified.
-     */
     static JSONStringifyModified: (obj: any, indent?: number) => string;
 }

package/build/parser/parser.js

@@ -1,56 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveParser = void 0;
-const level_class_1 = require("./satisfactory/level.class");
-const satisfactory_save_1 = require("./satisfactory/satisfactory-save");
-const save_reader_1 = require("./save-reader");
-const save_writer_1 = require("./save-writer");
-class SaveParser {
-    /**
-     * serializes a save file into binary and reports back on individual callbacks.
-     * @param save the save file to serialize into binary.
-     * @param onBinaryBeforeCompressing gets called on the binary save body before it is compressed.
-     * @param onHeader gets called on the binary save header, which is always uncompressed.
-     * @param onChunk gets called when a chunk of the compressed save body was generated. Often, files' save bodies consist of multiple chunks.
-     * @param onFinish gets called when all chunks have been generated. A summary of the chunk sizes and count is reported.
-     */
-    static WriteSave(save, onBinaryBeforeCompressing, onHeader, onChunk, onFinish) {
+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();
-        writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish);
+        const chunkSummary = writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk);
+        return chunkSummary;
     }
-    /**
-     * parses a save object from a binary buffer and reports back on decompressing the save body in a callback.
-     * @param file the binary content to be parsed.
-     * @param additionalData additional static data that is not contained in save files. For example, power slugs and resource nodes.
-     * @param onSaveDecompressed gets called when the entire binary save body has been decompressed.
-     * @returns a brief summary
-     */
-    static ParseSaveFile(file, onSaveDecompressed = () => { }, onProgress = () => { }) {
-        const reader = new save_reader_1.SaveReader(file.buffer, onProgress);
-        // read header
+    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);
-        // inflate chunks
         const inflateResult = reader.inflateChunks();
-        // call callback on decompressed save body
-        onSaveDecompressed(reader.getBuffer());
-        // parse levels
+        onDecompressedSaveBody(reader.getBuffer());
         const levelParseResult = reader.readLevels();
         save.levels = reader.levels;
         save.compressionInfo = reader.compressionInfo;
         save.trailingCollectedObjects = reader.trailingCollectedObjects;
         return save;
     }
-    /**
-     * Does Projection on a Save Object in order to reduce it's complexity.
-     * @param save the save object in question.
-     * @param config the projection config to apply.
-     * @returns a save object that has been projected / modified. Do not try to serialize it into an actual save tho! Since information has been transformed.
-     */
+    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,
@@ -64,21 +76,13 @@ class SaveParser {
         };
     }
 }
-/**
- * It JSON.stringifies any parsed content safely. The original JSON.stringify() has some flaws that get in the way, so it is custom wrapped. The original has some problems:
- * 1. it cannot stringify bigints. So we help out by converting it into a string.
- * 2. It cannot distinguish between 0 and -0. But a float32 is encoded in a uint8Array for 0 to be [0,0,0,0] (0x00000000) and -0 to be [0,0,0,128] (0x00000080) in little endian.
- * @param obj
- * @param indent
- * @returns a string that is safely stringified.
- */
-SaveParser.JSONStringifyModified = (obj, indent = 0) => JSON.stringify(obj, (key, value) => {
+Parser.JSONStringifyModified = (obj, indent = 0) => JSON.stringify(obj, (key, value) => {
     if (typeof value === 'bigint') {
         return value.toString();
     }
-    else if (value === 0 && 1 / value < 0) { // -0
+    else if (value === 0 && 1 / value < 0) {
         return '-0';
     }
     return value;
 }, indent);
-exports.SaveParser = SaveParser;
+exports.Parser = Parser;

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

@@ -0,0 +1,18 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ChunkCompressionInfo } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { BlueprintConfig, BlueprintHeader } from "./blueprint.types";
+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/satisfactory/blueprint/blueprint-reader.js

@@ -0,0 +1,124 @@
+"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("../save/level.class");
+const util_types_1 = require("../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);
+        const positionThingOrWhat = (0, util_types_1.ParseVec3)(reader);
+        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];
+        }
+        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() {
+        this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+        this.handledByte = 0;
+        this.currentByte = 0;
+        this.maxByte = this.fileBuffer.byteLength;
+        let currentChunks = [];
+        let totalUncompressedBodySize = 0;
+        while (this.handledByte < this.maxByte) {
+            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);
+            }
+            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;
+            this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+            this.currentByte = 0;
+            try {
+                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);
+            }
+        }
+        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;
+        }
+        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();
+        const objectHeadersBinarySize = reader.readInt32();
+        let objects = [];
+        level_class_1.Level.ReadObjectHeaders(reader, objects, () => { });
+        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();
+        const description = reader.readString();
+        const unk3 = reader.readInt32();
+        const colorMaybe = (0, util_types_1.ParseCol4RGBA)(reader);
+        return {
+            description,
+            color: colorMaybe,
+            iconID: unk3
+        };
+    }
+}
+exports.BlueprintConfigReader = BlueprintConfigReader;

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

@@ -0,0 +1,15 @@
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { ChunkCompressionInfo, ChunkSummary } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { BlueprintConfig, BlueprintHeader } from "./blueprint.types";
+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): ChunkSummary[];
+    static SerializeObjects(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
+}
+export declare class BlueprintConfigWriter extends ByteWriter {
+    constructor();
+    static SerializeConfig(writer: ByteWriter, config: BlueprintConfig): void;
+}