@etothepii/satisfactory-file-parser 0.0.30 → 0.0.32

package/build/parser/satisfactory/objects/SaveComponent.d.ts

@@ -0,0 +1,19 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { SaveObject, SaveObjectHeader } from "./SaveObject";
+export declare const isSaveComponent: (obj: any) => obj is SaveComponent;
+export interface SaveComponentHeader extends SaveObjectHeader {
+    parentEntityName: string;
+}
+export declare class SaveComponent extends SaveObject implements SaveComponentHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+    parentEntityName: string;
+    static readonly TypeID = 0;
+    readonly type = "SaveComponent";
+    constructor(typePath: string, rootObject: string, instanceName: string, parentEntityName?: string);
+    static ParseHeader(reader: BinaryReadable, obj: SaveComponent): void;
+    static SerializeHeader(writer: ByteWriter, component: SaveComponent): void;
+    static ParseData(component: SaveComponent, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
+}

package/build/parser/satisfactory/objects/SaveComponent.js

@@ -0,0 +1,41 @@
+(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", "./SaveObject"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveComponent = exports.isSaveComponent = void 0;
+    const SaveObject_1 = require("./SaveObject");
+    const isSaveComponent = (obj) => {
+        return obj.type === 'SaveComponent';
+    };
+    exports.isSaveComponent = isSaveComponent;
+    class SaveComponent extends SaveObject_1.SaveObject {
+        constructor(typePath, rootObject, instanceName, parentEntityName = '') {
+            super(typePath, rootObject, instanceName);
+            this.typePath = typePath;
+            this.rootObject = rootObject;
+            this.instanceName = instanceName;
+            this.parentEntityName = parentEntityName;
+            this.type = 'SaveComponent';
+        }
+        static ParseHeader(reader, obj) {
+            SaveObject_1.SaveObject.ParseHeader(reader, obj);
+            obj.parentEntityName = reader.readString();
+        }
+        static SerializeHeader(writer, component) {
+            SaveObject_1.SaveObject.SerializeHeader(writer, component);
+            writer.writeString(component.parentEntityName);
+        }
+        static ParseData(component, length, reader, buildVersion, typePath) {
+            SaveObject_1.SaveObject.ParseData(component, length, reader, buildVersion, typePath);
+        }
+    }
+    SaveComponent.TypeID = 0;
+    exports.SaveComponent = SaveComponent;
+});

package/build/parser/satisfactory/objects/SaveEntity.d.ts

@@ -0,0 +1,30 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { Transform } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
+import { SaveObject, SaveObjectHeader } from "./SaveObject";
+export declare const isSaveEntity: (obj: any) => obj is SaveEntity;
+export interface SaveEntityHeader extends SaveObjectHeader {
+    needTransform: boolean;
+    transform: Transform;
+    wasPlacedInLevel: boolean;
+}
+export declare class SaveEntity extends SaveObject {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+    parentEntityName: string;
+    static readonly TypeID = 1;
+    readonly type = "SaveEntity";
+    needTransform: boolean;
+    transform: Transform;
+    wasPlacedInLevel: boolean;
+    parentObjectRoot: string;
+    parentObjectName: string;
+    components: ObjectReference[];
+    constructor(typePath: string, rootObject: string, instanceName: string, parentEntityName?: string, needsTransform?: boolean);
+    static ParseHeader(reader: BinaryReadable, obj: SaveEntity): void;
+    static ParseData(entity: SaveEntity, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
+    static SerializeHeader(writer: ByteWriter, entity: SaveEntity): void;
+    static SerializeData(writer: ByteWriter, entity: SaveEntity, buildVersion: number): void;
+}

package/build/parser/satisfactory/objects/SaveEntity.js

@@ -0,0 +1,80 @@
+(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", "../structs/util.types", "./ObjectReference", "./SaveObject"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveEntity = exports.isSaveEntity = void 0;
+    const util_types_1 = require("../structs/util.types");
+    const ObjectReference_1 = require("./ObjectReference");
+    const SaveObject_1 = require("./SaveObject");
+    const isSaveEntity = (obj) => {
+        return obj.type === 'SaveEntity';
+    };
+    exports.isSaveEntity = isSaveEntity;
+    class SaveEntity extends SaveObject_1.SaveObject {
+        constructor(typePath, rootObject, instanceName, parentEntityName = '', needsTransform = false) {
+            super(typePath, rootObject, instanceName);
+            this.typePath = typePath;
+            this.rootObject = rootObject;
+            this.instanceName = instanceName;
+            this.parentEntityName = parentEntityName;
+            this.type = 'SaveEntity';
+            this.needTransform = needsTransform;
+            this.wasPlacedInLevel = false;
+            this.parentObjectRoot = '';
+            this.parentObjectName = '';
+            this.transform = {
+                rotation: { x: 0, y: 0, z: 0, w: 1 },
+                translation: { x: 0, y: 0, z: 0 },
+                scale3d: { x: 1, y: 1, z: 1 }
+            };
+            this.components = [];
+        }
+        static ParseHeader(reader, obj) {
+            SaveObject_1.SaveObject.ParseHeader(reader, obj);
+            obj.needTransform = reader.readInt32() == 1;
+            obj.transform = (0, util_types_1.ParseTransform)(reader);
+            obj.wasPlacedInLevel = reader.readInt32() == 1;
+        }
+        static ParseData(entity, length, reader, buildVersion, typePath) {
+            var newLen = length - 12;
+            entity.parentObjectRoot = reader.readString();
+            if (entity.parentObjectRoot.length > 0)
+                newLen -= entity.parentObjectRoot.length + 1;
+            entity.parentObjectName = reader.readString();
+            if (entity.parentObjectName.length > 0)
+                newLen -= entity.parentObjectName.length + 1;
+            var componentCount = reader.readInt32();
+            for (let i = 0; i < componentCount; i++) {
+                var componentRef = ObjectReference_1.ObjectReference.Parse(reader);
+                entity.components.push(componentRef);
+                newLen -= 10 + componentRef.levelName.length + componentRef.pathName.length;
+            }
+            return SaveObject_1.SaveObject.ParseData(entity, newLen, reader, buildVersion, typePath);
+        }
+        static SerializeHeader(writer, entity) {
+            SaveObject_1.SaveObject.SerializeHeader(writer, entity);
+            writer.writeInt32(entity.needTransform ? 1 : 0);
+            (0, util_types_1.SerializeTransform)(writer, entity.transform);
+            writer.writeInt32(entity.wasPlacedInLevel ? 1 : 0);
+        }
+        static SerializeData(writer, entity, buildVersion) {
+            writer.writeString(entity.parentObjectRoot);
+            writer.writeString(entity.parentObjectName);
+            writer.writeInt32(entity.components.length);
+            for (const com of entity.components) {
+                writer.writeString(com.levelName);
+                writer.writeString(com.pathName);
+            }
+            SaveObject_1.SaveObject.SerializeData(writer, entity, buildVersion);
+        }
+    }
+    SaveEntity.TypeID = 1;
+    exports.SaveEntity = SaveEntity;
+});

package/build/parser/satisfactory/objects/SaveObject.d.ts

@@ -0,0 +1,19 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { DataFields } from "./DataFields";
+export interface SaveObjectHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+}
+export declare abstract class SaveObject implements SaveObjectHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+    dataFields: DataFields;
+    constructor(typePath: string, rootObject: string, instanceName: string);
+    protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;
+    protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;
+    static ParseData(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
+    static SerializeData(writer: any, obj: SaveObject, buildVersion: number): void;
+}

package/build/parser/satisfactory/objects/SaveObject.js

@@ -0,0 +1,39 @@
+(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", "./DataFields"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveObject = void 0;
+    const DataFields_1 = require("./DataFields");
+    class SaveObject {
+        constructor(typePath, rootObject, instanceName) {
+            this.typePath = typePath;
+            this.rootObject = rootObject;
+            this.instanceName = instanceName;
+            this.dataFields = new DataFields_1.DataFields();
+        }
+        static ParseHeader(reader, obj) {
+            obj.typePath = reader.readString();
+            obj.rootObject = reader.readString();
+            obj.instanceName = reader.readString();
+        }
+        static SerializeHeader(writer, obj) {
+            writer.writeString(obj.typePath);
+            writer.writeString(obj.rootObject);
+            writer.writeString(obj.instanceName);
+        }
+        static ParseData(obj, length, reader, buildVersion, typePath) {
+            obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion, typePath);
+        }
+        static SerializeData(writer, obj, buildVersion) {
+            DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion, obj.typePath);
+        }
+    }
+    exports.SaveObject = SaveObject;
+});

package/build/parser/satisfactory/save/asynchronous-level.class.d.ts

@@ -0,0 +1,9 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
+import { SaveObject } from "../objects/SaveObject";
+import { Level } from "./level.class";
+import { SaveReader } from "./save-reader";
+export declare class AsynchronousLevel {
+    static StreamReadObjectContents(reader: ByteReader, objectsList: SaveObject[], buildVersion: number, writer: SaveStreamWriter, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
+    static StreamReadLevel(reader: SaveReader, levelName: string, buildVersion: number, writer: SaveStreamWriter): Promise<Level>;
+}

package/build/parser/satisfactory/save/asynchronous-level.class.js

@@ -0,0 +1,76 @@
+(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", "../objects/SaveComponent", "../objects/SaveEntity", "./level.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsynchronousLevel = void 0;
+    const SaveComponent_1 = require("../objects/SaveComponent");
+    const SaveEntity_1 = require("../objects/SaveEntity");
+    const level_class_1 = require("./level.class");
+    class AsynchronousLevel {
+        static async StreamReadObjectContents(reader, objectsList, buildVersion, writer, onProgressCallback) {
+            const binarySize = reader.readInt32();
+            const posBefore = reader.getBufferPosition();
+            await reader.allocate(binarySize);
+            const countEntities = reader.readInt32();
+            if (countEntities !== objectsList.length) {
+                throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
+            }
+            let dynamicObjectBatch = [];
+            for (let i = 0; i < countEntities; i++) {
+                if (i % 1000 === 0) {
+                    console.log(`having some objects, writing ${i + 1}/${countEntities}.`);
+                    onProgressCallback(reader.getBufferProgress());
+                    await writer.writeObjects(...dynamicObjectBatch);
+                    dynamicObjectBatch = [];
+                }
+                const len = reader.readInt32();
+                const before = reader.getBufferPosition();
+                if (len < reader.getAmountAllocatedLeft()) {
+                    await reader.allocate(Math.max(before - binarySize, 300 * 1000 * 1000));
+                }
+                const obj = objectsList[i];
+                if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                dynamicObjectBatch.push(obj);
+                const after = reader.getBufferPosition();
+                if (after - before !== len) {
+                    console.warn('entity may be corrupt', this.name, i);
+                }
+            }
+            await writer.writeObjects(...dynamicObjectBatch);
+            const posAfter = reader.getBufferPosition();
+            if (posAfter - posBefore !== binarySize) {
+                console.warn('save seems corrupt.', this.name);
+            }
+        }
+        static async StreamReadLevel(reader, levelName, buildVersion, writer) {
+            const level = new level_class_1.Level(levelName);
+            const binaryLength = reader.readInt32();
+            await reader.allocate(binaryLength);
+            await writer.openLevel(levelName);
+            level_class_1.Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level.collectables = level_class_1.Level.ReadCollectablesList(reader);
+            console.log(`before object contents buffer pos ${reader.getBufferPosition()}`);
+            await AsynchronousLevel.StreamReadObjectContents(reader, level.objects, buildVersion, writer, reader.onProgressCallback);
+            await writer.switchInLevelToCollectables();
+            await writer.writeCollectables(...level.collectables);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level_class_1.Level.ReadCollectablesList(reader);
+            await writer.endLevel();
+            return level;
+        }
+    }
+    exports.AsynchronousLevel = AsynchronousLevel;
+});

package/build/parser/satisfactory/save/level.class.d.ts

@@ -0,0 +1,21 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { ObjectReference } from "../objects/ObjectReference";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { SaveObject } from "../objects/SaveObject";
+import { SaveReader } from "./save-reader";
+export declare class Level {
+    name: string;
+    objects: (SaveEntity | SaveComponent)[];
+    collectables: ObjectReference[];
+    constructor(name: string);
+    static SerializeObjectHeaders(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
+    static WriteLevel(writer: ByteWriter, level: Level, buildVersion: number): void;
+    static SerializeObjectContents(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[], buildVersion: number, levelName: string): void;
+    static ReadObjectHeaders(reader: BinaryReadable, objectsList: SaveObject[], onProgressCallback: (progress: number, msg?: string) => void): void;
+    static ReadObjectContents(reader: BinaryReadable, objectsList: SaveObject[], buildVersion: number, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
+    static ReadLevel(reader: SaveReader, levelName: string, buildVersion: number): Level;
+    static SerializeCollectablesList(writer: ByteWriter, collectables: ObjectReference[]): void;
+    static ReadCollectablesList(reader: BinaryReadable): ObjectReference[];
+}

package/build/parser/satisfactory/save/level.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", "../objects/ObjectReference", "../objects/SaveComponent", "../objects/SaveEntity"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Level = void 0;
+    const ObjectReference_1 = require("../objects/ObjectReference");
+    const SaveComponent_1 = require("../objects/SaveComponent");
+    const SaveEntity_1 = require("../objects/SaveEntity");
+    class Level {
+        constructor(name) {
+            this.name = name;
+            this.objects = [];
+            this.collectables = [];
+        }
+        static SerializeObjectHeaders(writer, objects) {
+            writer.writeInt32(objects.length);
+            for (const obj of objects) {
+                switch (obj.type) {
+                    case 'SaveEntity':
+                        writer.writeInt32(SaveEntity_1.SaveEntity.TypeID);
+                        SaveEntity_1.SaveEntity.SerializeHeader(writer, obj);
+                        break;
+                    case 'SaveComponent':
+                        writer.writeInt32(SaveComponent_1.SaveComponent.TypeID);
+                        SaveComponent_1.SaveComponent.SerializeHeader(writer, obj);
+                        break;
+                    default:
+                        console.log('Unknown object type', obj);
+                        break;
+                }
+            }
+        }
+        static WriteLevel(writer, level, buildVersion) {
+            const lenIndicatorHeaderAndCollectableSize = writer.getBufferPosition();
+            writer.writeInt32(0);
+            Level.SerializeObjectHeaders(writer, level.objects);
+            Level.SerializeCollectablesList(writer, level.collectables);
+            writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 4);
+            Level.SerializeObjectContents(writer, level.objects, buildVersion, level.name);
+            Level.SerializeCollectablesList(writer, level.collectables);
+        }
+        static SerializeObjectContents(writer, objects, buildVersion, levelName) {
+            const lenIndicatorEntities = writer.getBufferPosition();
+            writer.writeInt32(0);
+            writer.writeInt32(objects.length);
+            for (const obj of objects) {
+                const lenReplacementPosition = writer.getBufferPosition();
+                writer.writeInt32(0);
+                if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                    SaveEntity_1.SaveEntity.SerializeData(writer, obj, buildVersion);
+                }
+                else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                    SaveComponent_1.SaveComponent.SerializeData(writer, obj, buildVersion);
+                }
+                writer.writeBinarySizeFromPosition(lenReplacementPosition, lenReplacementPosition + 4);
+            }
+            writer.writeBinarySizeFromPosition(lenIndicatorEntities, lenIndicatorEntities + 4);
+        }
+        static ReadObjectHeaders(reader, objectsList, onProgressCallback) {
+            let countObjectHeaders = reader.readInt32();
+            for (let i = 0; i < countObjectHeaders; i++) {
+                if (i % 1000 === 0) {
+                    onProgressCallback(reader.getBufferProgress());
+                }
+                let objectType = reader.readInt32();
+                switch (objectType) {
+                    case SaveEntity_1.SaveEntity.TypeID:
+                        let object = new SaveEntity_1.SaveEntity('', '', '', '');
+                        SaveEntity_1.SaveEntity.ParseHeader(reader, object);
+                        objectsList.push(object);
+                        break;
+                    case SaveComponent_1.SaveComponent.TypeID:
+                        let component = new SaveComponent_1.SaveComponent('', '', '', '');
+                        SaveComponent_1.SaveComponent.ParseHeader(reader, component);
+                        objectsList.push(component);
+                        break;
+                    default:
+                        console.log('Unknown object type', objectType);
+                        break;
+                }
+            }
+        }
+        static async ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
+            const binarySize = reader.readInt32();
+            const posBefore = reader.getBufferPosition();
+            const countEntities = reader.readInt32();
+            if (countEntities !== objectsList.length) {
+                throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
+            }
+            for (let i = 0; i < countEntities; i++) {
+                if (i % 1000 === 0) {
+                    onProgressCallback(reader.getBufferProgress());
+                }
+                const len = reader.readInt32();
+                const before = reader.getBufferPosition();
+                const obj = objectsList[i];
+                if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                const after = reader.getBufferPosition();
+                if (after - before !== len) {
+                    console.warn('entity may be corrupt', this.name, i);
+                }
+            }
+            const posAfter = reader.getBufferPosition();
+            if (posAfter - posBefore !== binarySize) {
+                console.warn('save seems corrupt.', this.name);
+            }
+        }
+        static ReadLevel(reader, levelName, buildVersion) {
+            const level = new Level(levelName);
+            reader.readInt32();
+            Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level.collectables = Level.ReadCollectablesList(reader);
+            console.log(`before object contents buffer pos ${reader.getBufferPosition()}`);
+            Level.ReadObjectContents(reader, level.objects, buildVersion, reader.onProgressCallback);
+            reader.onProgressCallback(reader.getBufferProgress());
+            Level.ReadCollectablesList(reader);
+            return level;
+        }
+        static SerializeCollectablesList(writer, collectables) {
+            writer.writeInt32(collectables.length);
+            for (const collectable of collectables) {
+                ObjectReference_1.ObjectReference.Serialize(writer, collectable);
+            }
+        }
+        static ReadCollectablesList(reader) {
+            let countCollected = reader.readInt32();
+            const collected = [];
+            for (let i = 0; i < countCollected; i++) {
+                const collectable = ObjectReference_1.ObjectReference.Parse(reader);
+                collected.push(collectable);
+            }
+            return collected;
+        }
+    }
+    exports.Level = Level;
+});

package/build/parser/satisfactory/save/satisfactory-save.d.ts

@@ -0,0 +1,11 @@
+import { ChunkCompressionInfo } from "../../file.types";
+import { ObjectReference } from "../objects/ObjectReference";
+import { Level } from "./level.class";
+import { SatisfactorySaveHeader } from "./save.types";
+export declare class SatisfactorySave {
+    header: SatisfactorySaveHeader;
+    levels: Level[];
+    trailingCollectedObjects: ObjectReference[];
+    compressionInfo?: ChunkCompressionInfo;
+    constructor(header: SatisfactorySaveHeader);
+}

package/build/parser/satisfactory/save/satisfactory-save.js

@@ -0,0 +1,21 @@
+(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.SatisfactorySave = void 0;
+    class SatisfactorySave {
+        constructor(header) {
+            this.levels = [];
+            this.trailingCollectedObjects = [];
+            this.header = header;
+        }
+    }
+    exports.SatisfactorySave = SatisfactorySave;
+});

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

@@ -0,0 +1,35 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ChunkCompressionInfo } from "../../file.types";
+import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
+import { ObjectReference } from "../objects/ObjectReference";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { Level } from "./level.class";
+import { SatisfactorySaveHeader } from "./save.types";
+export type EntityPathFilter = {
+    behavior: 'whitelist' | 'blacklist';
+    list: string[];
+};
+export type SaveProjectionConfig = {
+    entityPathFilter: EntityPathFilter;
+    includeComponents: boolean;
+};
+export declare const projectionFilterApplies: (config: SaveProjectionConfig, object: SaveComponent | SaveEntity) => boolean;
+export type ReadMode = 'stream' | 'whole';
+export declare const DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
+export declare class SaveReader extends ByteReader {
+    onProgressCallback: (progress: number, msg?: string) => void;
+    header: SatisfactorySaveHeader | undefined;
+    levels: Level[];
+    trailingCollectedObjects: ObjectReference[];
+    compressionInfo: ChunkCompressionInfo;
+    static readonly EPOCH_TICKS = 621355968000000000n;
+    constructor(fileBuffer: ArrayBuffer, onProgressCallback?: (progress: number, msg?: string) => void);
+    readHeader(): SatisfactorySaveHeader;
+    inflateChunks(): {
+        concatenatedChunkLength: number;
+        numChunks: number;
+    };
+    readLevels(): Level[];
+    readLevelsAsynchronously(writer: SaveStreamWriter): Promise<Level[]>;
+}