@etothepii/satisfactory-file-parser 0.0.10 → 0.0.11

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

@@ -0,0 +1,16 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { SaveObject } from "./SaveObject";
+export declare const isSaveComponent: (obj: any) => obj is SaveComponent;
+export declare class SaveComponent extends SaveObject {
+    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: ByteReader, obj: SaveComponent): void;
+    static SerializeHeader(writer: ByteWriter, component: SaveComponent): void;
+    static ParseData(component: SaveComponent, length: number, reader: ByteReader, buildVersion: number): void;
+}

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

@@ -0,0 +1,27 @@
+import { SaveObject } from "./SaveObject";
+export const isSaveComponent = (obj) => {
+    return obj.type === 'SaveComponent';
+};
+class SaveComponent extends 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.ParseHeader(reader, obj);
+        obj.parentEntityName = reader.readString();
+    }
+    static SerializeHeader(writer, component) {
+        SaveObject.SerializeHeader(writer, component);
+        writer.writeString(component.parentEntityName);
+    }
+    static ParseData(component, length, reader, buildVersion) {
+        SaveObject.ParseData(component, length, reader, buildVersion);
+    }
+}
+SaveComponent.TypeID = 0;
+export { SaveComponent };

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

@@ -0,0 +1,25 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { Transform } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
+import { SaveObject } from "./SaveObject";
+export declare const isSaveEntity: (obj: any) => obj is SaveEntity;
+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: ByteReader, obj: SaveEntity): void;
+    static ParseData(entity: SaveEntity, length: number, reader: ByteReader, buildVersion: number): 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,66 @@
+import { ParseTransform, SerializeTransform } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
+import { SaveObject } from "./SaveObject";
+export const isSaveEntity = (obj) => {
+    return obj.type === 'SaveEntity';
+};
+class SaveEntity extends 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.ParseHeader(reader, obj);
+        obj.needTransform = reader.readInt32() == 1;
+        obj.transform = ParseTransform(reader);
+        obj.wasPlacedInLevel = reader.readInt32() == 1;
+    }
+    static ParseData(entity, length, reader, buildVersion) {
+        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.Parse(reader);
+            entity.components.push(componentRef);
+            newLen -= 10 + componentRef.levelName.length + componentRef.pathName.length;
+        }
+        SaveObject.ParseData(entity, newLen, reader, buildVersion);
+    }
+    static SerializeHeader(writer, entity) {
+        SaveObject.SerializeHeader(writer, entity);
+        writer.writeInt32(entity.needTransform ? 1 : 0);
+        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.SerializeData(writer, entity, buildVersion);
+    }
+}
+SaveEntity.TypeID = 1;
+export { SaveEntity };

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

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

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

@@ -0,0 +1,25 @@
+import { DataFields } from "./DataFields";
+export class SaveObject {
+    constructor(typePath, rootObject, instanceName) {
+        this.typePath = typePath;
+        this.rootObject = rootObject;
+        this.instanceName = instanceName;
+        this.dataFields = new 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) {
+        obj.dataFields = DataFields.Parse(length, reader, buildVersion);
+    }
+    static SerializeData(writer, obj, buildVersion) {
+        DataFields.Serialize(writer, obj.dataFields, buildVersion);
+    }
+}

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

@@ -0,0 +1,57 @@
+import { Level } from "./level.class";
+import { ObjectReference } from "./objects/ObjectReference";
+export interface ModData {
+    Reference: string;
+    Name: string;
+    Version: string;
+}
+export interface SatisfactoryModMetadata {
+    Mods: ModData[];
+}
+export interface SatisfactorySaveHeader {
+    saveHeaderType: number;
+    saveVersion: number;
+    buildVersion: number;
+    mapName: string;
+    mapOptions: string;
+    sessionName: string;
+    playDurationSeconds: number;
+    saveDateTime: string;
+    sessionVisibility: number;
+    rawModMetadataString?: string;
+    modMetadata?: SatisfactoryModMetadata;
+    isModdedSave?: number;
+    saveIdentifier?: string;
+    fEditorObjectVersion?: number;
+}
+export type ResourceNodeEntry = {
+    purity: string;
+    pathName: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: string;
+};
+export type CollectibleEntry = {
+    pathName: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: string;
+};
+export type ChunkCompressionInfo = {
+    chunkHeaderSize: number;
+    packageFileTag: number;
+    maxChunkContentSize: number;
+};
+export declare class SatisfactorySave {
+    header: SatisfactorySaveHeader;
+    levels: Level[];
+    trailingCollectedObjects: ObjectReference[];
+    compressionInfo?: ChunkCompressionInfo;
+    constructor(header: SatisfactorySaveHeader);
+}

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

@@ -0,0 +1,7 @@
+export class SatisfactorySave {
+    constructor(header) {
+        this.levels = [];
+        this.trailingCollectedObjects = [];
+        this.header = header;
+    }
+}

package/build/parser/satisfactory/static-data.d.ts

@@ -0,0 +1,7 @@
+import { CollectibleEntry, ResourceNodeEntry } from "./satisfactory-save";
+export type StaticData = {
+    collectibles: CollectibleEntry[];
+    artifacts: CollectibleEntry[];
+    slugs: CollectibleEntry[];
+    resourceNodes: ResourceNodeEntry[];
+};

package/build/parser/satisfactory/static-data.js

@@ -0,0 +1 @@
+export {};

package/build/parser/satisfactory/structs/util.types.d.ts

@@ -0,0 +1,40 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+export type col4 = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export declare const SerializeCol4RGBA: (writer: ByteWriter, value: col4) => void;
+export declare const ParseCol4RGBA: (reader: ByteReader) => col4;
+export declare const SerializeCol4BGRA: (writer: ByteWriter, value: col4) => void;
+export declare const ParseCol4BGRA: (reader: ByteReader) => col4;
+export type vec4 = vec3 & {
+    w: number;
+};
+export declare const ParseVec4: (reader: ByteReader) => vec4;
+export declare const SerializeVec4: (writer: ByteWriter, vec: vec4) => void;
+export declare const sub: (other: vec3, vec: vec3) => vec3;
+export declare const add: (vec: vec3, other: vec3) => vec3;
+export declare const length: (vec: vec3) => number;
+export declare const mult: (vec: vec3, scale: number) => vec3;
+export declare const norm: (vec: vec3) => vec3;
+export type vec3 = vec2 & {
+    z: number;
+};
+export declare const ParseVec3: (reader: ByteReader) => vec3;
+export declare const SerializeVec3: (writer: ByteWriter, vec: vec3) => void;
+export type vec2 = {
+    x: number;
+    y: number;
+};
+export declare const ParseVec2: (reader: ByteReader) => vec2;
+export declare const SerializeVec2: (writer: ByteWriter, vec: vec2) => void;
+export type Transform = {
+    rotation: vec4;
+    translation: vec3;
+    scale3d: vec3;
+};
+export declare const ParseTransform: (reader: ByteReader) => Transform;
+export declare const SerializeTransform: (writer: ByteWriter, transform: Transform) => void;

package/build/parser/satisfactory/structs/util.types.js

@@ -0,0 +1,75 @@
+export const SerializeCol4RGBA = (writer, value) => {
+    writer.writeFloat(value.r);
+    writer.writeFloat(value.g);
+    writer.writeFloat(value.b);
+    writer.writeFloat(value.a);
+};
+export const ParseCol4RGBA = (reader) => {
+    return {
+        r: reader.readFloat(),
+        g: reader.readFloat(),
+        b: reader.readFloat(),
+        a: reader.readFloat(),
+    };
+};
+export const SerializeCol4BGRA = (writer, value) => {
+    writer.writeByte(value.b);
+    writer.writeByte(value.g);
+    writer.writeByte(value.r);
+    writer.writeByte(value.a);
+};
+export const ParseCol4BGRA = (reader) => {
+    return {
+        b: reader.readByte(),
+        g: reader.readByte(),
+        r: reader.readByte(),
+        a: reader.readByte(),
+    };
+};
+export const ParseVec4 = (reader) => {
+    return {
+        ...ParseVec3(reader),
+        w: reader.readFloat()
+    };
+};
+export const SerializeVec4 = (writer, vec) => {
+    SerializeVec3(writer, vec);
+    writer.writeFloat(vec.w);
+};
+export const sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
+export const add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
+export const length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
+export const mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
+export const norm = (vec) => mult(vec, 1. / length(vec));
+export const ParseVec3 = (reader) => {
+    return {
+        ...ParseVec2(reader),
+        z: reader.readFloat()
+    };
+};
+export const SerializeVec3 = (writer, vec) => {
+    SerializeVec2(writer, vec);
+    writer.writeFloat(vec.z);
+};
+export const ParseVec2 = (reader) => {
+    return {
+        x: reader.readFloat(),
+        y: reader.readFloat(),
+    };
+};
+export const SerializeVec2 = (writer, vec) => {
+    writer.writeFloat(vec.x);
+    writer.writeFloat(vec.y);
+};
+export const ParseTransform = (reader) => {
+    return {
+        rotation: ParseVec4(reader),
+        translation: ParseVec3(reader),
+        scale3d: ParseVec3(reader),
+    };
+};
+export const SerializeTransform = (writer, transform) => {
+    SerializeVec4(writer, transform.rotation);
+    SerializeVec3(writer, transform.translation);
+    SerializeVec3(writer, transform.scale3d);
+};

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

@@ -0,0 +1,43 @@
+import { ByteReader } from "./byte/byte-reader.class";
+import { Level } from "./satisfactory/level.class";
+import { ObjectReference } from "./satisfactory/objects/ObjectReference";
+import { SaveComponent } from "./satisfactory/objects/SaveComponent";
+import { SaveEntity } from "./satisfactory/objects/SaveEntity";
+import { SaveObject } from "./satisfactory/objects/SaveObject";
+import { ChunkCompressionInfo, SatisfactorySaveHeader } from "./satisfactory/satisfactory-save";
+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 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[];
+}
+export declare class Conveyor {
+    static getConveyorBeltRegex(): RegExp;
+    static getConveyorLiftRegex(): RegExp;
+    static isAConveyorBelt(obj: SaveObject): boolean;
+    static isAConveyorLift(obj: SaveObject): boolean;
+    static get availableConnections(): string[];
+    static get availableConveyorBelts(): string[];
+    static get availableConveyorLifts(): string[];
+    static isConveyor(currentObject: any): boolean;
+    static isConveyorBelt(currentObject: any): boolean;
+    static isConveyorLift(currentObject: any): boolean;
+}

package/build/parser/save-reader.js

@@ -0,0 +1,243 @@
+import Pako from "pako";
+import { Alignment } from "./byte/alignment.enum";
+import { ByteReader } from "./byte/byte-reader.class";
+import { CompressionLibraryError, CorruptSaveError, ParserError, UnsupportedVersionError } from "./error/parser.error";
+import { Level } from "./satisfactory/level.class";
+import { isSaveComponent } from "./satisfactory/objects/SaveComponent";
+import { isSaveEntity } from "./satisfactory/objects/SaveEntity";
+export const projectionFilterApplies = (config, object) => {
+    let cond1 = false;
+    if (isSaveEntity(object) || (config.includeComponents && isSaveComponent(object))) {
+        cond1 = true;
+    }
+    let cond2 = true;
+    if (isSaveEntity(object)) {
+        cond2 = false;
+        if (config.entityPathFilter.behavior === 'whitelist') {
+            cond2 = config.entityPathFilter.list.find(en => object.typePath.startsWith(en)) !== undefined;
+        }
+        else if (config.entityPathFilter.behavior === 'blacklist') {
+            cond2 = config.entityPathFilter.list.find(en => object.typePath.startsWith(en)) === undefined;
+        }
+    }
+    return cond1 && cond2;
+};
+class SaveReader extends ByteReader {
+    constructor(fileBuffer, onProgressCallback = () => { }) {
+        super(fileBuffer, Alignment.LITTLE_ENDIAN);
+        this.onProgressCallback = onProgressCallback;
+        this.levels = [];
+        this.trailingCollectedObjects = [];
+        this.compressionInfo = {
+            packageFileTag: 0,
+            maxChunkContentSize: 0,
+            chunkHeaderSize: 48
+        };
+    }
+    readHeader() {
+        this.header = {
+            saveHeaderType: 0,
+            saveVersion: 0,
+            buildVersion: 0,
+            mapName: "DEFAULT",
+            mapOptions: "",
+            sessionName: "",
+            playDurationSeconds: 0,
+            saveDateTime: "0",
+            sessionVisibility: 0
+        };
+        this.header.saveHeaderType = this.readInt32();
+        this.header.saveVersion = this.readInt32();
+        this.header.buildVersion = this.readInt32();
+        this.header.mapName = this.readString();
+        this.header.mapOptions = this.readString();
+        this.header.sessionName = this.readString();
+        this.header.playDurationSeconds = this.readInt32();
+        const rawSaveDateTimeInTicks = this.readLong();
+        const unixMilliseconds = (rawSaveDateTimeInTicks - SaveReader.EPOCH_TICKS) / 10000n;
+        this.header.saveDateTime = unixMilliseconds.toString();
+        this.header.sessionVisibility = this.readByte();
+        if (this.header.saveHeaderType >= 7) {
+            this.header.fEditorObjectVersion = this.readInt32();
+        }
+        if (this.header.saveHeaderType >= 8) {
+            this.header.rawModMetadataString = this.readString();
+            try {
+                this.header.modMetadata = JSON.parse(this.header.rawModMetadataString);
+            }
+            catch (error) {
+                //
+            }
+            this.header.isModdedSave = this.readInt32();
+        }
+        if (this.header.saveHeaderType >= 10) {
+            this.header.saveIdentifier = this.readString();
+        }
+        if (this.header.saveVersion >= 21) {
+            // all good, ready to read chunks now.
+        }
+        else {
+            throw new UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
+        }
+        return this.header;
+    }
+    inflateChunks() {
+        // free memory
+        this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+        this.handledByte = 0;
+        this.currentByte = 0;
+        this.maxByte = this.fileBuffer.byteLength;
+        let currentChunks = [];
+        let totalUncompressedBodySize = 0;
+        // read while we can handle
+        while (this.handledByte < this.maxByte) {
+            // Read chunk info size...
+            let chunkHeader = new DataView(this.fileBuffer.slice(0, this.compressionInfo.chunkHeaderSize));
+            this.currentByte = this.compressionInfo.chunkHeaderSize;
+            this.handledByte += this.compressionInfo.chunkHeaderSize;
+            if (this.compressionInfo.packageFileTag <= 0) {
+                this.compressionInfo.packageFileTag = chunkHeader.getInt32(0, this.alignment === Alignment.LITTLE_ENDIAN);
+            }
+            if (this.compressionInfo.maxChunkContentSize <= 0) {
+                this.compressionInfo.maxChunkContentSize = chunkHeader.getInt32(8, this.alignment === Alignment.LITTLE_ENDIAN);
+            }
+            const chunkCompressedLength = chunkHeader.getInt32(32, this.alignment === Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = chunkHeader.getInt32(40, this.alignment === Alignment.LITTLE_ENDIAN);
+            totalUncompressedBodySize += chunkUncompressedLength;
+            const currentChunkSize = chunkCompressedLength;
+            let currentChunk = this.fileBuffer.slice(this.currentByte, this.currentByte + currentChunkSize);
+            this.handledByte += currentChunkSize;
+            this.currentByte += currentChunkSize;
+            // Free memory from previous chunk...
+            this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+            this.currentByte = 0;
+            // Unzip!
+            try {
+                // Inflate current chunk
+                let currentInflatedChunk = null;
+                currentInflatedChunk = Pako.inflate(currentChunk);
+                currentChunks.push(currentInflatedChunk);
+            }
+            catch (err) {
+                throw new CompressionLibraryError("Failed to inflate compressed save data. " + err);
+            }
+        }
+        //TODO we can get rid of file buffer here.
+        // Create one big chunk out of the little chunks
+        let newChunkLength = currentChunks.map(cc => cc.length).reduce((prev, cur) => prev + cur);
+        const bigWholeChunk = new Uint8Array(newChunkLength);
+        let currentLength = 0;
+        for (let i = 0; i < currentChunks.length; i++) {
+            bigWholeChunk.set(currentChunks[i], currentLength);
+            currentLength += currentChunks[i].length;
+        }
+        this.currentByte = 0;
+        this.maxByte = bigWholeChunk.buffer.byteLength;
+        this.bufferView = new DataView(bigWholeChunk.buffer);
+        const dataLength = this.readInt32();
+        if (totalUncompressedBodySize !== dataLength + 4) {
+            throw new CorruptSaveError(`Possibly corrupt. Indicated size of total save body (${dataLength}) does not match the uncompressed real size of ${totalUncompressedBodySize}.`);
+        }
+        return {
+            concatenatedChunkLength: newChunkLength,
+            numChunks: currentChunks.length
+        };
+    }
+    readLevels() {
+        if (!this.header) {
+            throw new ParserError('ParserError', 'Header must be set before objects can be read.');
+        }
+        if (this.header.saveVersion < 29) {
+            throw new UnsupportedVersionError('Support for < U6 is not yet implemented.');
+        }
+        const numSubLevels = this.readInt32();
+        this.levels = new Array(numSubLevels + 1);
+        // read levels
+        for (let j = 0; j <= numSubLevels; j++) {
+            let levelName = (j === numSubLevels) ? '' + this.header.mapName : this.readString();
+            this.onProgressCallback(this.getBufferProgress(), `reading level [${(j + 1)}/${(numSubLevels + 1)}] ${levelName}`);
+            this.levels[j] = Level.ReadLevel(this, levelName, this.header.buildVersion);
+        }
+        // in U6/U7 there were more collectibles added that do not belong to a particular level
+        if (this.getBufferPosition() < this.bufferView.byteLength) {
+            this.trailingCollectedObjects = Level.ReadCollectablesList(this);
+        }
+        return this.levels;
+    }
+}
+// the number of .net ticks at the unix epoch
+SaveReader.EPOCH_TICKS = 621355968000000000n;
+export { SaveReader };
+export class Conveyor {
+    static getConveyorBeltRegex() {
+        return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorBeltMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
+    }
+    ;
+    static getConveyorLiftRegex() {
+        return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorLiftMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
+    }
+    ;
+    static isAConveyorBelt(obj) {
+        return obj.typePath.match(this.getConveyorBeltRegex()) !== null;
+    }
+    static isAConveyorLift(obj) {
+        return obj.typePath.match(this.getConveyorLiftRegex()) !== null;
+    }
+    static get availableConnections() { return ['.ConveyorAny0', '.ConveyorAny1', '.Input0', '.Input1', '.Input2', '.Input3', '.InPut3', '.Input4', '.Input5', '.Input6', '.Output0', '.Output1', '.Output2', '.Output3']; }
+    static get availableConveyorBelts() {
+        return [
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C'
+        ];
+    }
+    static get availableConveyorLifts() {
+        return [
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C',
+            '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C'
+        ];
+    }
+    /*
+     * BELT/LIFT LOOKUP, includes mods to avoid finding them everywhere
+     */
+    static isConveyor(currentObject) {
+        return Conveyor.isConveyorBelt(currentObject) || Conveyor.isConveyorLift(currentObject);
+    }
+    static isConveyorBelt(currentObject) {
+        if (Conveyor.availableConveyorBelts.includes(currentObject.className)) {
+            return true;
+        }
+        // Belts Mod
+        if (currentObject.className.startsWith('/Conveyors_Mod/Build_BeltMk')
+            || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_BeltMk')
+            || currentObject.className.startsWith('/UltraFastLogistics/Buildable/build_conveyorbeltMK')
+            || currentObject.className.startsWith('/FlexSplines/Conveyor/Build_Belt')
+            || currentObject.className.startsWith('/conveyorbeltmod/Belt/mk')
+            || currentObject.className.startsWith('/minerplus/content/buildable/Factory/belt_')
+            || currentObject.className.startsWith('/bamfp/content/buildable/Factory/belt_')) {
+            return true;
+        }
+        return false;
+    }
+    static isConveyorLift(currentObject) {
+        if (Conveyor.availableConveyorLifts.includes(currentObject.className)) {
+            return true;
+        }
+        // Lifts Mod
+        if (currentObject.className.startsWith('/minerplus/content/buildable/Factory/lift')
+            || currentObject.className.startsWith('/bamfp/content/buildable/Factory/lift')
+            || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_LiftMk')
+            || currentObject.className.startsWith('/Conveyors_Mod/Build_LiftMk')
+            || currentObject.className.startsWith('/Game/CoveredConveyor')
+            || currentObject.className.startsWith('/CoveredConveyor')
+            || currentObject.className.startsWith('/conveyorbeltmod/lift/')) {
+            return true;
+        }
+        return false;
+    }
+}