@etothepii/satisfactory-file-parser 0.0.30 → 0.0.32

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,18 @@
+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);
+}
+export declare class TimeoutError extends ParserError {
+    constructor(message?: string);
+}
+export declare class UnimplementedError extends ParserError {
+    constructor(message?: string);
+}

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

@@ -0,0 +1,50 @@
+(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.UnimplementedError = exports.TimeoutError = 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;
+    class TimeoutError extends ParserError {
+        constructor(message) {
+            super('TimeoutError', message ?? 'Operation timed out.');
+        }
+    }
+    exports.TimeoutError = TimeoutError;
+    class UnimplementedError extends ParserError {
+        constructor(message) {
+            super('UnimplementedError', message ?? 'Unimplemented Operation.');
+        }
+    }
+    exports.UnimplementedError = UnimplementedError;
+});

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,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { TransformStream, WritableStream } from "stream/web";
+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 PassthroughWebTransform extends TransformStream<Uint8Array, Uint8Array> {
+    constructor();
+}
+export declare class Parser {
+    static WriteSave(save: SatisfactorySave, onBinaryBeforeCompressing: (buffer: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
+    private static ParseSaveFileStream;
+    private static ParseStreamSave;
+    private static DecompressStreamSave;
+    static ParseSaveFile(file: Buffer, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
+    static ParseSaveFileAsynchronousToOutput(file: Buffer, outputJson: WritableStream<string>, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): Promise<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,196 @@
+(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", "stream/web", "./satisfactory/blueprint/blueprint-reader", "./satisfactory/blueprint/blueprint-writer", "./satisfactory/save/level.class", "./satisfactory/save/satisfactory-save", "./satisfactory/save/save-reader", "./satisfactory/save/save-writer", "./stream/save-stream-reader.class", "./stream/save-stream-writer.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Parser = exports.PassthroughWebTransform = void 0;
+    const web_1 = require("stream/web");
+    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");
+    const save_stream_reader_class_1 = require("./stream/save-stream-reader.class");
+    const save_stream_writer_class_1 = require("./stream/save-stream-writer.class");
+    class PassthroughWebTransform extends web_1.TransformStream {
+        constructor() {
+            super({
+                start: (controller) => {
+                },
+                transform: async (chunk, controller) => {
+                    chunk = await chunk;
+                    controller.enqueue(chunk);
+                },
+                flush: (controller) => {
+                    console.log('on passthrough dispose.');
+                }
+            });
+        }
+    }
+    exports.PassthroughWebTransform = PassthroughWebTransform;
+    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 async ParseSaveFileStream(input, output, binaryOutput) {
+            return new Promise(async (resolve, reject) => {
+                if (input.locked || output.locked || (binaryOutput !== undefined ? binaryOutput.locked : false)) {
+                    throw new Error('One of the input/output streams is locked. Aborting save parsing.');
+                }
+                const binaryOutWriter = binaryOutput ? binaryOutput.getWriter() : undefined;
+                const writer = new save_stream_writer_class_1.SaveStreamWriter(output.getWriter());
+                const reader = new save_stream_reader_class_1.SaveStreamReader(input.getReader(), 500 * 1000 * 1000);
+                const passthrough = new PassthroughWebTransform();
+                const passthroughWriter = passthrough.writable.getWriter();
+                const passthroughReader = new save_stream_reader_class_1.SaveStreamReader(passthrough.readable.getReader(), 3000 * 1000 * 1000);
+                await writer.beginSave();
+                const header = await reader.readHeader();
+                await writer.writeHeader(header);
+                let contentParsingPromise;
+                const decompressionPromise = Parser.DecompressStreamSave(reader, writer, passthroughWriter, async () => {
+                    console.log('start streaming content');
+                    passthroughReader.debug = true;
+                    contentParsingPromise = await Parser.ParseStreamSave(passthroughReader, writer, header);
+                    await writer.close();
+                    return resolve();
+                }, binaryOutWriter);
+            });
+        }
+        static async ParseStreamSave(reader, jsonWriter, header) {
+            return new Promise(async (resolve, reject) => {
+                reader.onCloseCallback = async () => {
+                    console.log('content reader closes.');
+                    await jsonWriter.endLevels();
+                    await jsonWriter.endSave();
+                    return resolve();
+                };
+                console.log('before open levels');
+                await jsonWriter.openLevels();
+                const dataLength = await reader.readInt32();
+                await reader.allocate(Math.min(1000, dataLength));
+                console.log(`incoming body size should be ${dataLength} bytes big.`);
+                await reader.streamLevelsToOutput(jsonWriter, header);
+                await reader.close();
+            });
+        }
+        static async DecompressStreamSave(reader, jsonWriter, outputWriter, onDecompressionInfoWritten, debugAdditionalBinaryOutputWriter) {
+            return new Promise(async (resolve, reject) => {
+                reader.onCloseCallback = async () => {
+                    console.log('decompress reader closes.');
+                    return resolve();
+                };
+                let first = true;
+                while (reader.hasInput()) {
+                    const decompressedChunk = await reader.readBodyChunk();
+                    if (first && reader.compressionInfo) {
+                        await jsonWriter.writeCompressionInfo(reader.compressionInfo);
+                        onDecompressionInfoWritten();
+                        first = false;
+                    }
+                    if (debugAdditionalBinaryOutputWriter) {
+                        debugAdditionalBinaryOutputWriter.write(decompressedChunk);
+                    }
+                    outputWriter.write(decompressedChunk);
+                }
+            });
+        }
+        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 async ParseSaveFileAsynchronousToOutput(file, outputJson, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
+            const reader = new save_reader_1.SaveReader(new Uint8Array(file).buffer, onProgress);
+            const writer = new save_stream_writer_class_1.SaveStreamWriter(outputJson.getWriter());
+            await writer.beginSave();
+            const header = reader.readHeader();
+            const save = new satisfactory_save_1.SatisfactorySave(header);
+            await writer.writeHeader(save.header);
+            await writer.writeCompressionInfo({});
+            const inflateResult = reader.inflateChunks();
+            onDecompressedSaveBody(reader.getBuffer());
+            const levelParseResult = await reader.readLevelsAsynchronously(writer);
+            save.levels = reader.levels;
+            save.compressionInfo = reader.compressionInfo;
+            save.trailingCollectedObjects = reader.trailingCollectedObjects;
+            await writer.endSave();
+            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;
+});

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

@@ -0,0 +1,19 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+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: BinaryReadable): 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: BinaryReadable): BlueprintConfig;
+}

package/build/parser/satisfactory/blueprint/blueprint-reader.js

@@ -0,0 +1,134 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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", "pako", "../../byte/alignment.enum", "../../byte/byte-reader.class", "../../error/parser.error", "../save/level.class", "../structs/util.types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    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;
+});