@etothepii/satisfactory-file-parser 0.0.10 → 0.0.12

package/index.js

@@ -1,2364 +0,0 @@
-'use strict';
-
-var Pako = require('pako');
-
-class ObjectReference {
-    constructor(levelName, pathName) {
-        this.levelName = levelName;
-        this.pathName = pathName;
-    }
-    static Parse(reader) {
-        return new ObjectReference(reader.readString(), reader.readString());
-    }
-    static Serialize(writer, ref) {
-        writer.writeString(ref.levelName);
-        writer.writeString(ref.pathName);
-    }
-}
-
-const SerializeCol4RGBA = (writer, value) => {
-    writer.writeFloat(value.r);
-    writer.writeFloat(value.g);
-    writer.writeFloat(value.b);
-    writer.writeFloat(value.a);
-};
-const ParseCol4RGBA = (reader) => {
-    return {
-        r: reader.readFloat(),
-        g: reader.readFloat(),
-        b: reader.readFloat(),
-        a: reader.readFloat(),
-    };
-};
-const SerializeCol4BGRA = (writer, value) => {
-    writer.writeByte(value.b);
-    writer.writeByte(value.g);
-    writer.writeByte(value.r);
-    writer.writeByte(value.a);
-};
-const ParseCol4BGRA = (reader) => {
-    return {
-        b: reader.readByte(),
-        g: reader.readByte(),
-        r: reader.readByte(),
-        a: reader.readByte(),
-    };
-};
-const ParseVec4 = (reader) => {
-    return {
-        ...ParseVec3(reader),
-        w: reader.readFloat()
-    };
-};
-const SerializeVec4 = (writer, vec) => {
-    SerializeVec3(writer, vec);
-    writer.writeFloat(vec.w);
-};
-const ParseVec3 = (reader) => {
-    return {
-        ...ParseVec2(reader),
-        z: reader.readFloat()
-    };
-};
-const SerializeVec3 = (writer, vec) => {
-    SerializeVec2(writer, vec);
-    writer.writeFloat(vec.z);
-};
-const ParseVec2 = (reader) => {
-    return {
-        x: reader.readFloat(),
-        y: reader.readFloat(),
-    };
-};
-const SerializeVec2 = (writer, vec) => {
-    writer.writeFloat(vec.x);
-    writer.writeFloat(vec.y);
-};
-const ParseTransform = (reader) => {
-    return {
-        rotation: ParseVec4(reader),
-        translation: ParseVec3(reader),
-        scale3d: ParseVec3(reader),
-    };
-};
-const SerializeTransform = (writer, transform) => {
-    SerializeVec4(writer, transform.rotation);
-    SerializeVec3(writer, transform.translation);
-    SerializeVec3(writer, transform.scale3d);
-};
-
-class AbstractProperty {
-    constructor(type, index) {
-        this.type = type;
-        this.index = index;
-    }
-}
-class AbstractBaseProperty extends AbstractProperty {
-    // overhead like Guid is not calculated into property size
-    constructor(type, ueType, index) {
-        super(type, index && index !== 0 ? index : undefined);
-        this.ueType = ueType;
-        this.name = '';
-    }
-}
-class BasicProperty extends AbstractBaseProperty {
-    constructor(type, ueType, guidInfo, index = 0) {
-        super(type, ueType, index);
-        this.guidInfo = guidInfo;
-    }
-}
-const ParseGUID = (reader) => {
-    const hasGuid = reader.readByte() === 1;
-    let guid;
-    if (hasGuid) {
-        throw new Error('Unexpected!');
-    }
-    return guid;
-};
-const SerializeGUID = (writer, guid) => {
-    writer.writeByte(guid ? 1 : 0);
-    if (guid) {
-        writer.writeBytes(guid);
-    }
-};
-class BoolProperty extends BasicProperty {
-    constructor(value, ueType = 'BoolProperty', guidInfo = undefined, index = 0) {
-        super('BoolProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const value = BoolProperty.ReadValue(reader);
-        const guidInfo = ParseGUID(reader);
-        return new BoolProperty(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readByte() > 0;
-    }
-    static CalcOverhead(property) {
-        return 2;
-    }
-    static Serialize(writer, property) {
-        BoolProperty.SerializeValue(writer, property.value);
-        SerializeGUID(writer, property.guidInfo);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeByte(value ? 1 : 0);
-    }
-}
-class ByteProperty extends BasicProperty {
-    constructor(value, ueType = 'ByteProperty', guidInfo = undefined, index = 0) {
-        super('ByteProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const type = reader.readString();
-        const guidInfo = ParseGUID(reader);
-        let value;
-        if (type === 'None') {
-            value = {
-                type,
-                value: ByteProperty.ReadValue(reader)
-            };
-        }
-        else {
-            value = {
-                type,
-                value: reader.readString()
-            };
-        }
-        const property = new ByteProperty(value, ueType, guidInfo, index);
-        return property;
-    }
-    static ReadValue(reader) {
-        return reader.readByte();
-    }
-    static CalcOverhead(property) {
-        return property.value.type.length + 5 + 1;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.value.type);
-        SerializeGUID(writer, property.guidInfo);
-        if (property.value.type === 'None') {
-            ByteProperty.SerializeValue(writer, property.value.value);
-        }
-        else {
-            writer.writeString(property.value.value);
-        }
-    }
-    static SerializeValue(writer, value) {
-        writer.writeByte(value);
-    }
-}
-class Int8Property extends BasicProperty {
-    constructor(value, ueType = 'Int8Property', guidInfo = undefined, index = 0) {
-        super('Int8Property', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = Int8Property.ReadValue(reader);
-        return new Int8Property(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readInt8();
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        Int8Property.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeInt8(value);
-    }
-}
-class Uint8Property extends BasicProperty {
-    constructor(value, ueType = 'UInt8Property', guidInfo = undefined, index = 0) {
-        super('UInt8Property', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = Uint8Property.ReadValue(reader);
-        return new Uint8Property(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readUint8();
-    }
-    static CalcOverhead(property) {
-        throw new Error('Unimplemented.');
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        Uint8Property.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeUint8(value);
-    }
-}
-class Int32Property extends BasicProperty {
-    constructor(value, ueType = 'IntProperty', guidInfo = undefined, index = 0) {
-        super('Int32Property', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = Int32Property.ReadValue(reader);
-        return new Int32Property(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readInt32();
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        Int32Property.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeInt32(value);
-    }
-}
-class Uint32Property extends BasicProperty {
-    constructor(value, ueType = 'UInt32Property', guidInfo = undefined, index = 0) {
-        super('UInt32Property', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = Uint32Property.ReadValue(reader);
-        return new Uint32Property(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readUint32();
-    }
-    static CalcOverhead(property) {
-        throw new Error('unimplemented');
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        Uint32Property.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeUint32(value);
-    }
-}
-class Int64Property extends BasicProperty {
-    constructor(value, ueType = 'Int64Property', guidInfo = undefined, index = 0) {
-        super('Int64Property', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = Int64Property.ReadValue(reader);
-        return new Int64Property(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readLong().toString();
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        Int64Property.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeInt64(BigInt(value));
-    }
-}
-class FloatProperty extends BasicProperty {
-    constructor(value, ueType = 'FloatProperty', guidInfo = undefined, index = 0) {
-        super('FloatProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = FloatProperty.ReadValue(reader);
-        return new FloatProperty(value, ueType, guidInfo, index);
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static ReadValue(reader) {
-        return reader.readFloat();
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        FloatProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeFloat(value);
-    }
-}
-class DoubleProperty extends BasicProperty {
-    constructor(value, ueType = 'DoubleProperty', guidInfo = undefined, index = 0) {
-        super('DoubleProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = DoubleProperty.ReadValue(reader);
-        return new DoubleProperty(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readDouble();
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        DoubleProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeDouble(value);
-    }
-}
-class StrProperty extends BasicProperty {
-    constructor(value, ueType = 'StrProperty', guidInfo = undefined, index = 0) {
-        super('StrProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = StrProperty.ReadValue(reader);
-        return new StrProperty(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        return reader.readString();
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        StrProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeString(value);
-    }
-}
-class ObjectProperty extends BasicProperty {
-    constructor(value, ueType = 'ObjectProperty', guidInfo = undefined, index = 0) {
-        super('ObjectProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = ParseGUID(reader);
-        const value = ObjectProperty.ReadValue(reader);
-        return new ObjectProperty(value, ueType, guidInfo, index);
-    }
-    static ReadValue(reader) {
-        const x = {
-            levelName: reader.readString(),
-            pathName: reader.readString()
-        };
-        return x;
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        ObjectProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeString(value.levelName);
-        writer.writeString(value.pathName);
-    }
-}
-class EnumProperty extends BasicProperty {
-    constructor(value, ueType = 'EnumProperty', guidInfo = undefined, index = 0) {
-        super('EnumProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        let name = reader.readString();
-        const guidInfo = ParseGUID(reader);
-        const value = EnumProperty.ReadValue(reader);
-        const property = new EnumProperty({ name, value }, ueType, guidInfo, index);
-        return property;
-    }
-    static ReadValue(reader) {
-        return reader.readString();
-    }
-    static CalcOverhead(property) {
-        return property.value.name.length + 6;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.value.name);
-        SerializeGUID(writer, property.guidInfo);
-        EnumProperty.SerializeValue(writer, property.value.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeString(value);
-    }
-}
-class TextProperty extends BasicProperty {
-    constructor(value, ueType = 'TextProperty', guidInfo = undefined, index = 0) {
-        super('TextProperty', ueType, guidInfo, index);
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        //let name = reader.readString();
-        const guidInfo = ParseGUID(reader);
-        const value = TextProperty.ParseValue(reader);
-        return new TextProperty(value, ueType, guidInfo, index);
-    }
-    static ParseValue(reader) {
-        const prop = {
-            flags: reader.readInt32(),
-            historyType: reader.readByte()
-        };
-        switch (prop.historyType) {
-            // HISTORYTYPE_BASE
-            case 0:
-                prop.namespace = reader.readString();
-                prop.key = reader.readString();
-                prop.value = reader.readString();
-                break;
-            // HISTORYTYPE_NAMEDFORMAT
-            case 1:
-            // HISTORYTYPE_ARGUMENTFORMAT
-            case 3:
-                prop.sourceFmt = TextProperty.ParseValue(reader);
-                const argumentsCount = reader.readInt32();
-                prop.arguments = [];
-                for (let i = 0; i < argumentsCount; i++) {
-                    let currentArgumentsData = {};
-                    currentArgumentsData.name = reader.readString();
-                    currentArgumentsData.valueType = reader.readByte();
-                    switch (currentArgumentsData.valueType) {
-                        case 4:
-                            currentArgumentsData.argumentValue = TextProperty.ParseValue(reader);
-                            break;
-                        default:
-                            throw new Error('Unimplemented FormatArgumentType `' + currentArgumentsData.valueType);
-                    }
-                    prop.arguments.push(currentArgumentsData);
-                }
-                break;
-            // see https://github.com/EpicGames/UnrealEngine/blob/4.25/Engine/Source/Runtime/Core/Private/Internationalization/TextHistory.cpp#L2268
-            // HISTORYTYPE_TRANSFORM
-            case 10:
-                prop.sourceText = TextProperty.ParseValue(reader);
-                prop.transformType = reader.readByte();
-                break;
-            // HISTORYTYPE_NONE
-            case 255:
-                // See: https://github.com/EpicGames/UnrealEngine/blob/4.25/Engine/Source/Runtime/Core/Private/Internationalization/Text.cpp#L894
-                // TODO: do i need that? check with goz3rr
-                //if (this.header!.buildVersion >= 140822) {
-                prop.hasCultureInvariantString = reader.readInt32() === 1;
-                if (prop.hasCultureInvariantString) {
-                    prop.value = reader.readString();
-                }
-                //}
-                break;
-            default:
-                throw new Error('Unimplemented historyType `' + prop.historyType);
-        }
-        return prop;
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        SerializeGUID(writer, property.guidInfo);
-        TextProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeInt32(value.flags);
-        writer.writeByte(value.historyType);
-        switch (value.historyType) {
-            // HISTORYTYPE_BASE
-            case 0:
-                writer.writeString(value.namespace);
-                writer.writeString(value.key);
-                writer.writeString(value.value);
-                break;
-            // HISTORYTYPE_NAMEDFORMAT
-            case 1:
-            // HISTORYTYPE_ARGUMENTFORMAT
-            case 3:
-                TextProperty.SerializeValue(writer, value.sourceFmt);
-                writer.writeInt32(value.arguments.length);
-                for (const arg of value.arguments) {
-                    let currentArgumentsData = {};
-                    writer.writeString(arg.name);
-                    writer.writeByte(arg.valueType);
-                    switch (arg.valueType) {
-                        case 4:
-                            TextProperty.SerializeValue(writer, arg.argumentValue);
-                            break;
-                        default:
-                            throw new Error('Unimplemented FormatArgumentType `' + currentArgumentsData.valueType);
-                    }
-                }
-                break;
-            // see https://github.com/EpicGames/UnrealEngine/blob/4.25/Engine/Source/Runtime/Core/Private/Internationalization/TextHistory.cpp#L2268
-            // HISTORYTYPE_TRANSFORM
-            case 10:
-                TextProperty.SerializeValue(writer, value.sourceText);
-                writer.writeByte(value.transformType);
-                break;
-            // HISTORYTYPE_NONE
-            case 255:
-                // See: https://github.com/EpicGames/UnrealEngine/blob/4.25/Engine/Source/Runtime/Core/Private/Internationalization/Text.cpp#L894
-                // TODO: do i need that? check with goz3rr
-                //if (this.header!.buildVersion >= 140822) {
-                writer.writeInt32(value.hasCultureInvariantString ? 1 : 0);
-                if (value.hasCultureInvariantString) {
-                    writer.writeString(value.value);
-                }
-                //}
-                break;
-            default:
-                throw new Error('Unimplemented historyType `' + value.historyType);
-        }
-    }
-}
-class StructProperty extends AbstractBaseProperty {
-    constructor(subtype, ueType = 'StructProperty', index = 0, guid = 0) {
-        super('StructProperty', ueType, index);
-        this.subtype = subtype;
-        this.guid = guid;
-        this.value = { values: {} };
-    }
-    static Parse(reader, ueType, index, size) {
-        const struct = new StructProperty(reader.readString(), ueType, index, reader.readInt32());
-        const unk1 = reader.readInt32();
-        if (unk1 !== 0) {
-            struct.unk1 = unk1;
-        }
-        const unk2 = reader.readInt32();
-        if (unk2 !== 0) {
-            struct.unk2 = unk2;
-        }
-        const unk3 = reader.readInt32();
-        if (unk2 !== 0) {
-            struct.unk3 = unk3;
-        }
-        const unk4 = reader.readByte();
-        if (unk4 !== 0) {
-            struct.unk4 = unk4;
-        }
-        const before = reader.getBufferPosition();
-        struct.value = StructProperty.ParseValue(reader, struct.subtype, size);
-        const readBytes = reader.getBufferPosition() - before;
-        if (readBytes !== size) {
-            throw new Error(`possibly corrupt. Read ${readBytes} for StructProperty Content of ${struct.subtype}, but ${size} were indicated.`);
-        }
-        return struct;
-    }
-    static ParseValue(reader, subtype, size) {
-        let value;
-        switch (subtype) {
-            case 'Color':
-                value = ParseCol4BGRA(reader);
-                break;
-            case 'LinearColor':
-                value = ParseCol4RGBA(reader);
-                break;
-            case 'Vector':
-            case 'Rotator':
-            case 'Vector2D':
-                value = ParseVec3(reader);
-                break;
-            case 'Quat':
-            case 'Vector4':
-            case 'Vector4D':
-                value = ParseVec4(reader);
-                break;
-            case 'Box':
-                value = {
-                    min: ParseVec3(reader),
-                    max: ParseVec3(reader),
-                    isValid: reader.readByte() >= 1
-                };
-                break;
-            case 'RailroadTrackPosition':
-                value = {
-                    root: reader.readString(),
-                    instanceName: reader.readString(),
-                    offset: reader.readFloat(),
-                    forward: reader.readFloat()
-                };
-                break;
-            case 'TimerHandle':
-                value = reader.readString();
-                break;
-            case 'Guid':
-                value = reader.readString();
-                break;
-            case 'InventoryItem':
-                value = {
-                    unk1: reader.readInt32(),
-                    itemName: reader.readString(),
-                    unk2: reader.readString(),
-                    unk3: reader.readString(),
-                    properties: [],
-                };
-                //TODO - what is this? currentProperty.value.properties.push(reader.readProperty());
-                break;
-            case 'FluidBox':
-                value = {
-                    value: reader.readFloat()
-                };
-                break;
-            case 'SlateBrush':
-                value = reader.readString();
-                break;
-            case 'DateTime':
-                value = reader.readLong().toString();
-                break;
-            // MODS
-            case 'FINNetworkTrace':
-                value = ReadFINNetworkTrace(reader);
-                break;
-            case 'FINLuaProcessorStateStorage':
-                value = {
-                    values: ReadFINLuaProcessorStateStorage(reader, size)
-                };
-                break;
-            case 'FICFrameRange': // https://github.com/Panakotta00/FicsIt-Cam/blob/c55e254a84722c56e1badabcfaef1159cd7d2ef1/Source/FicsItCam/Public/Data/FICTypes.h#L34
-                value = {
-                    begin: reader.readLong().toString(),
-                    end: reader.readLong().toString(),
-                };
-                break;
-            default:
-                //TODO: use buildversion
-                value = ParseDynamicStructData(reader, 0, subtype);
-        }
-        return value;
-    }
-    static CalcOverhead(property) {
-        return property.subtype.length + 5 + 17;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.subtype);
-        writer.writeInt32(property.guid);
-        writer.writeInt32(property.unk1 ?? 0);
-        writer.writeInt32(property.unk2 ?? 0);
-        writer.writeInt32(property.unk3 ?? 0);
-        writer.writeByte(property.unk4 ?? 0);
-        StructProperty.SerializeValue(writer, property.subtype, property.value);
-    }
-    static SerializeValue(writer, subtype, value) {
-        switch (subtype) {
-            case 'Color':
-                value = value;
-                SerializeCol4BGRA(writer, value);
-                break;
-            case 'LinearColor':
-                value = value;
-                SerializeCol4RGBA(writer, value);
-                break;
-            case 'Vector':
-            case 'Rotator':
-            case 'Vector2D':
-                value = value;
-                SerializeVec3(writer, value);
-                break;
-            case 'Quat':
-            case 'Vector4':
-            case 'Vector4D':
-                value = value;
-                SerializeVec4(writer, value);
-                break;
-            case 'Box':
-                value = value;
-                SerializeVec3(writer, value.min);
-                SerializeVec3(writer, value.max);
-                writer.writeByte(value.isValid ? 1 : 0);
-                break;
-            case 'RailroadTrackPosition':
-                value = value;
-                writer.writeString(value.root);
-                writer.writeString(value.instanceName);
-                writer.writeFloat(value.offset);
-                writer.writeFloat(value.forward);
-                break;
-            case 'TimerHandle':
-                value = value;
-                writer.writeString(value);
-                break;
-            case 'Guid':
-                value = value;
-                writer.writeString(value);
-                break;
-            case 'InventoryItem':
-                value = value;
-                writer.writeInt32(value.unk1);
-                writer.writeString(value.itemName);
-                writer.writeString(value.unk2);
-                writer.writeString(value.unk3);
-                //TODO - how to write properties?
-                break;
-            case 'FluidBox':
-                value = value;
-                writer.writeFloat(value.value);
-                break;
-            case 'SlateBrush':
-                value = value;
-                writer.writeString(value);
-                break;
-            case 'DateTime':
-                value = value;
-                writer.writeInt64(BigInt(value));
-                break;
-            // MODS
-            case 'FINNetworkTrace':
-                value = value;
-                SerializeFINNetworkTrace(writer, value);
-                break;
-            case 'FINLuaProcessorStateStorage':
-                value = value;
-                SerializeFINLuaProcessorStateStorage(writer, value.values);
-                break;
-            case 'FICFrameRange': // https://github.com/Panakotta00/FicsIt-Cam/blob/c55e254a84722c56e1badabcfaef1159cd7d2ef1/Source/FicsItCam/Public/Data/FICTypes.h#L34
-                value = value;
-                writer.writeInt64(BigInt(value.begin));
-                writer.writeInt64(BigInt(value.end));
-                break;
-            default:
-                //TODO: use buildversion
-                value = value;
-                SerializeDynamicStructData(writer, 0, value);
-        }
-    }
-}
-class ArrayProperty extends BasicProperty {
-    constructor(subtype, values, ueType = 'ArrayProperty', index = 0, structValueFields) {
-        super('ArrayProperty', ueType, undefined, index);
-        this.subtype = subtype;
-        this.values = values;
-        this.structValueFields = structValueFields;
-    }
-    static Parse(reader, ueType, index, propertyName) {
-        const subtype = reader.readString();
-        reader.skipBytes(); // unk
-        let property;
-        const elementCount = reader.readInt32();
-        switch (subtype) {
-            case "FloatProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => FloatProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "BoolProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => BoolProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "IntProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => Int32Property.ReadValue(reader)), ueType, index);
-                break;
-            case "Int64Property":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => Int64Property.ReadValue(reader)), ueType, index);
-                break;
-            case "DoubleProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => DoubleProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "ByteProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => ByteProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "StrProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => StrProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "EnumProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => EnumProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "TextProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => TextProperty.ParseValue(reader)), ueType, index);
-                break;
-            case "InterfaceProperty":
-            case "ObjectProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => ObjectProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "StructProperty":
-                reader.readString(); // Same as currentProperty.name
-                const type = reader.readString(); // StructProperty
-                const binarySize = reader.readInt32(); // structureSize
-                const allIndex = reader.readInt32(); // 0
-                const allStructType = reader.readString();
-                const allGuid = reader.readInt32();
-                const allUnk1 = reader.readInt32();
-                const allUnk2 = reader.readInt32();
-                const allUnk3 = reader.readInt32();
-                const allUnk4 = reader.readByte();
-                const innerStructValueFields = { allStructType, allIndex, allGuid };
-                if (allUnk1 !== 0) {
-                    innerStructValueFields.allUnk1 = allUnk1;
-                }
-                if (allUnk2 !== 0) {
-                    innerStructValueFields.allUnk2 = allUnk2;
-                }
-                if (allUnk3 !== 0) {
-                    innerStructValueFields.allUnk3 = allUnk3;
-                }
-                if (allUnk4 !== 0) {
-                    innerStructValueFields.allUnk4 = allUnk4;
-                }
-                const before = reader.getBufferPosition();
-                const maArr = new Array(elementCount).fill(0).map(e => {
-                    const struct = new StructProperty(allStructType, type, allIndex, allGuid);
-                    // we do NOT assign individual unk's here. Since they are only serialized always on ArrayProperty's Level once for all elements.
-                    //struct.unk1 = allUnk1;
-                    //struct.unk2 = allUnk2;
-                    //struct.unk3 = allUnk3;
-                    //struct.unk4 = allUnk4;
-                    struct.value = StructProperty.ParseValue(reader, allStructType, binarySize);
-                    return struct;
-                });
-                const readBytees = reader.getBufferPosition() - before;
-                if (readBytees !== binarySize) {
-                    throw new Error('possibly corrupt in array of struct.');
-                }
-                // Array Properties with struct values have some more properties.
-                property = new ArrayProperty(subtype, maArr, ueType, index, innerStructValueFields);
-                break;
-            default:
-                console.log(subtype, ueType);
-                throw new Error();
-        }
-        return property;
-    }
-    static CalcOverhead(property) {
-        return property.subtype.length + 5 + 1;
-    }
-    static Serialize(writer, property, propertyName) {
-        writer.writeString(property.subtype);
-        writer.writeByte(0);
-        writer.writeInt32(property.values.length);
-        switch (property.subtype) {
-            case "FloatProperty":
-                property.values.forEach(v => FloatProperty.SerializeValue(writer, v));
-                break;
-            case "BoolProperty":
-                property.values.forEach(v => BoolProperty.SerializeValue(writer, v));
-                break;
-            case "IntProperty":
-                property.values.forEach(v => Int32Property.SerializeValue(writer, v));
-                break;
-            case "Int64Property":
-                property.values.forEach(v => Int64Property.SerializeValue(writer, v));
-                break;
-            case "DoubleProperty":
-                property.values.forEach(v => DoubleProperty.SerializeValue(writer, v));
-                break;
-            case "ByteProperty":
-                property.values.forEach(v => ByteProperty.SerializeValue(writer, v));
-                break;
-            case "StrProperty":
-                property.values.forEach(v => StrProperty.SerializeValue(writer, v));
-                break;
-            case "EnumProperty":
-                property.values.forEach(v => EnumProperty.SerializeValue(writer, v));
-                break;
-            case "TextProperty":
-                property.values.forEach(v => TextProperty.SerializeValue(writer, v));
-                break;
-            case "InterfaceProperty":
-            case "ObjectProperty":
-                property.values.forEach(v => ObjectProperty.SerializeValue(writer, v));
-                break;
-            case "StructProperty":
-                writer.writeString(propertyName);
-                writer.writeString(property.subtype);
-                const lenIndicator = writer.getBufferPosition();
-                writer.writeInt32(0);
-                writer.writeInt32(property.structValueFields.allIndex);
-                writer.writeString(property.structValueFields.allStructType);
-                writer.writeInt32(property.structValueFields.allGuid);
-                writer.writeInt32(property.structValueFields.allUnk1 ?? 0);
-                writer.writeInt32(property.structValueFields.allUnk2 ?? 0);
-                writer.writeInt32(property.structValueFields.allUnk3 ?? 0);
-                writer.writeByte(property.structValueFields.allUnk4 ?? 0);
-                const before = writer.getBufferPosition();
-                property.values.forEach(v => StructProperty.SerializeValue(writer, property.structValueFields.allStructType, v.value));
-                writer.writeBinarySizeFromPosition(lenIndicator, before);
-                break;
-            default:
-                console.log(property.type, property.ueType);
-                throw new Error();
-        }
-    }
-}
-class SetProperty extends BasicProperty {
-    constructor(subtype, values, ueType, index) {
-        super('SetProperty', ueType, undefined, index);
-        this.subtype = subtype;
-        this.values = values;
-    }
-    static Parse(reader, ueType, index, propertyName) {
-        const subtype = reader.readString();
-        reader.skipBytes(1); // unk
-        reader.skipBytes(4); // unk2
-        const elementCount = reader.readInt32();
-        let property;
-        switch (subtype) {
-            case "IntProperty":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => Int32Property.ReadValue(reader)), ueType, index);
-                break;
-            case "ObjectProperty":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => ObjectProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "NameProperty":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => StrProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "StructProperty":
-                if (propertyName === 'mRemovalLocations') {
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => ParseVec3(reader)), ueType, index);
-                }
-                break;
-            default:
-                throw new Error('Not Implemented.');
-        }
-        return property;
-    }
-    static CalcOverhead(property) {
-        return property.subtype.length + 5 + 1;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.subtype);
-        //TODO: what is that
-        writer.writeByte(0);
-        writer.writeInt32(0);
-        writer.writeInt32(property.values.length);
-        switch (property.subtype) {
-            case "IntProperty":
-                property.values.forEach(v => Int32Property.SerializeValue(writer, v));
-                break;
-            case "ObjectProperty":
-                property.values.forEach(v => ObjectProperty.SerializeValue(writer, v));
-                break;
-            case "NameProperty":
-                property.values.forEach(v => StrProperty.SerializeValue(writer, v));
-                break;
-            case "StructProperty":
-                //TODO: this would only work for mRemovalLocations. Get a way to check for propertyname at least.
-                property.values.forEach(v => SerializeVec3(writer, v));
-                break;
-            default:
-                throw new Error('Not Implemented.');
-        }
-    }
-}
-class MapProperty extends BasicProperty {
-    constructor(keyType, valueType, ueType, index) {
-        super('MapProperty', ueType, undefined, index);
-        this.keyType = keyType;
-        this.valueType = valueType;
-        this.modeType = 2;
-        this.modeUnk2 = '';
-        this.modeUnk3 = '';
-        this.remainingData = [];
-        this.values = [];
-    }
-    static Parse(reader, propertyName, buildVersion, size, ueType = 'MapProperty', index = 0) {
-        reader.getBufferPosition();
-        const property = new MapProperty(reader.readString(), reader.readString(), ueType, index);
-        reader.skipBytes(1);
-        property.modeType = reader.readInt32();
-        //property.remainingData = reader.readBytes(size - (reader.getBufferPosition() - start));
-        property.remainingData = Array.from(reader.readBytes(size - 4));
-        // TODO
-        /*
-
-        if (property.modeType === 2) {
-            property.modeUnk2 = reader.readString();
-            property.modeUnk3 = reader.readString();
-        } else if (property.modeType === 3) {
-            property.modeUnk1 = reader.readHex(9);
-            property.modeUnk2 = reader.readString();
-            property.modeUnk3 = reader.readString();
-        }
-
-        let elementCount = reader.readInt32();
-        for (let i = 0; i < elementCount; i++) {
-            let key: number | string | ObjectReferenceV2 | vec3 | any[] | boolean;
-            let value: number | string | ObjectReferenceV2 | any[] | boolean;
-
-            switch (property.keyType) {
-                case 'IntProperty':
-                    key = Int32Property.ReadValue(reader);
-                    break;
-                case 'Int64Property':
-                    key = Int64Property.ReadValue(reader);
-                    break;
-                case 'NameProperty':
-                case 'StrProperty':
-                    key = StrProperty.ReadValue(reader);
-                    break;
-                case 'ObjectProperty':
-                    key = ObjectProperty.ReadValue(reader);
-                    break;
-                case 'EnumProperty':
-                    key = EnumProperty.ReadValue(reader);
-                    break;
-                case 'StructProperty':
-                    if (propertyName === 'Destroyed_Foliage_Transform' || parentType === '/BuildGunUtilities/BGU_Subsystem.BGU_Subsystem_C') // Mod: Universal Destroyer/Factory Statistics
-                    {
-                        key = ParseVec3(reader);
-                        break;
-                    }
-
-                    key = [];
-                    while (true) {
-                        let singleValueProperty = DataFieldsV2.ParseProperty(reader, buildVersion, propertyName);
-                        if (singleValueProperty === null) {
-                            break;
-                        }
-
-                        key.push(singleValueProperty);
-                    }
-                    break;
-                default:
-                    throw new Error(`not implemented type ${property.keyType}`);
-            }
-
-
-            switch (property.valueType) {
-                case 'ByteProperty':
-                    if (property.keyType === 'StrProperty') {
-                        value = reader.readString();
-                    }
-                    else {
-                        value = reader.readByte();
-                    }
-                    break;
-                case 'BoolProperty':
-                    value = BoolProperty.ReadValue(reader);
-                    break;
-                case 'IntProperty':
-                    value = Int32Property.ReadValue(reader);
-                    break;
-                case 'FloatProperty':
-                    value = FloatProperty.ReadValue(reader);
-                    break;
-                case 'StrProperty':
-                    value = StrProperty.ReadValue(reader);
-                    break;
-                case 'ObjectProperty':
-                    value = ObjectProperty.ReadValue(reader);
-                    break;
-                case 'StructProperty':
-                    // TODO: what is this
-                    /*
-                    if (parentType === 'LBBalancerData') {
-                        mapPropertySubProperties.mNormalIndex = this.readInt32();
-                        mapPropertySubProperties.mOverflowIndex = this.readInt32();
-                        mapPropertySubProperties.mFilterIndex = this.readInt32();
-                    }
-                    else { }
-                    */
-        /*
-
-        value = [];
-        while (true) {
-            let singleValueProperty = DataFieldsV2.ParseProperty(reader, buildVersion, propertyName);
-            if (singleValueProperty === null) {
-                break;
-            }
-
-            value.push(singleValueProperty);
-        }
-        break;
-    default:
-        throw new Error(`not implemented type ${property.valueType}`);
-}
-
-property.values.push({
-    key, value
-});
-}
-*/
-        return property;
-    }
-    static CalcOverhead(property) {
-        return property.keyType.length + 5 + property.valueType.length + 5 + 1;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.keyType);
-        writer.writeString(property.valueType);
-        writer.writeByte(0);
-        writer.writeInt32(property.modeType);
-        writer.writeBytesArray(property.remainingData);
-        //TODO: do the actual serialization.
-    }
-}
-const ParseDynamicStructData = (reader, buildVersion, type) => {
-    const data = {
-        type, properties: {}
-    };
-    let propertyName = reader.readString();
-    while (propertyName !== 'None') {
-        const property = DataFields.ParseProperty(reader, buildVersion, propertyName);
-        data.properties[propertyName] = property;
-        propertyName = reader.readString();
-    }
-    return data;
-};
-const SerializeDynamicStructData = (writer, buildVersion, data) => {
-    for (const key in data.properties) {
-        writer.writeString(key);
-        DataFields.SerializeProperty(writer, data.properties[key], key, buildVersion);
-    }
-    writer.writeString('None');
-};
-const ReadFINNetworkTrace = (reader) => {
-    const networkTrace = {};
-    networkTrace.ref = ObjectReference.Parse(reader);
-    networkTrace.hasPrev = reader.readInt32();
-    if (networkTrace.hasPrev) {
-        networkTrace.prev = ReadFINNetworkTrace(reader);
-    }
-    networkTrace.hasStep = reader.readInt32();
-    if (networkTrace.hasStep) {
-        networkTrace.step = reader.readString();
-    }
-    return networkTrace;
-};
-const SerializeFINNetworkTrace = (writer, obj) => {
-    ObjectReference.Serialize(writer, obj.ref);
-    writer.writeInt32(obj.hasPrev);
-    if (obj.hasPrev) {
-        SerializeFINNetworkTrace(writer, obj.prev);
-    }
-    writer.writeInt32(obj.hasStep);
-    if (obj.hasStep) {
-        writer.writeString(obj.step);
-    }
-};
-const ReadFINLuaProcessorStateStorage = (reader, size) => {
-    const stateStorage = { traces: [], references: [], thread: '', globals: '', remainingStructData: {} };
-    const start = reader.getBufferPosition();
-    const traceCount = reader.readInt32();
-    for (let i = 0; i < traceCount; i++) {
-        stateStorage.traces.push(ReadFINNetworkTrace(reader));
-    }
-    const refCount = reader.readInt32();
-    for (let i = 0; i < refCount; i++) {
-        stateStorage.references.push(ObjectReference.Parse(reader));
-    }
-    stateStorage.thread = reader.readString();
-    stateStorage.globals = reader.readString();
-    const remaining = size - (reader.getBufferPosition() - start);
-    stateStorage.remainingStructData = reader.readBytes(remaining);
-    return stateStorage;
-};
-const SerializeFINLuaProcessorStateStorage = (writer, stateStorage) => {
-    writer.writeInt32(stateStorage.traces.length);
-    for (const trace of stateStorage.traces) {
-        SerializeFINNetworkTrace(writer, trace);
-    }
-    writer.writeInt32(stateStorage.references.length);
-    for (const ref of stateStorage.references) {
-        ObjectReference.Serialize(writer, ref);
-    }
-    writer.writeString(stateStorage.thread);
-    writer.writeString(stateStorage.globals);
-    writer.writeBytes(stateStorage.remainingStructData);
-};
-
-class DataFields {
-    constructor() {
-        this.properties = [];
-        this.trailingData = [];
-        this.shouldBeNulled = false;
-    }
-    static Parse(length, reader, buildVersion) {
-        const start = reader.getBufferPosition();
-        const fields = new DataFields();
-        if (length === 0) {
-            //WARNING
-            fields.shouldBeNulled = true;
-            return fields;
-        }
-        let propertyName = reader.readString();
-        while (propertyName !== 'None') {
-            const property = DataFields.ParseProperty(reader, buildVersion, propertyName);
-            fields.properties.push(property);
-            propertyName = reader.readString();
-        }
-        reader.readInt32();
-        const end = reader.getBufferPosition();
-        let remainingBytes = start + length - end;
-        fields.trailingData = Array.from(reader.readBytes(remainingBytes));
-        return fields;
-    }
-    static ParseProperty(reader, buildVersion, propertyName) {
-        let currentProperty = {};
-        if (currentProperty.name === 'None') {
-            return null;
-        }
-        //TODO: What is this extra byte that is appearing sometime?
-        // i dont think there is an extra byte.
-        /*
-        let extraByteTest = reader.readByte();
-        if (extraByteTest !== 0) {
-            reader.currentByte -= 1;
-        }
-        else {
-            console.log('Property extra byte', currentProperty);
-        }
-        */
-        //TODO assign type and index after parsing.
-        const propertyType = reader.readString();
-        const binarySize = reader.readInt32();
-        const index = reader.readInt32();
-        const before = reader.getBufferPosition();
-        let overhead = 0;
-        switch (propertyType) {
-            case 'BoolProperty':
-                currentProperty = BoolProperty.Parse(reader, propertyType, index);
-                overhead = BoolProperty.CalcOverhead(currentProperty);
-                break;
-            case 'ByteProperty':
-                currentProperty = ByteProperty.Parse(reader, propertyType, index);
-                overhead = ByteProperty.CalcOverhead(currentProperty);
-                break;
-            case 'Int8Property':
-                currentProperty = Int8Property.Parse(reader, propertyType, index);
-                overhead = Int8Property.CalcOverhead(currentProperty);
-                break;
-            case 'UInt8Property':
-                currentProperty = Uint8Property.Parse(reader, propertyType, index);
-                overhead = Uint8Property.CalcOverhead(currentProperty);
-                break;
-            case 'IntProperty':
-            case 'Int32Property':
-                currentProperty = Int32Property.Parse(reader, propertyType, index);
-                overhead = Int32Property.CalcOverhead(currentProperty);
-                break;
-            case 'UInt32Property':
-                currentProperty = Uint32Property.Parse(reader, propertyType, index);
-                overhead = Uint32Property.CalcOverhead(currentProperty);
-                break;
-            case 'Int64Property':
-                currentProperty = Int64Property.Parse(reader, propertyType, index);
-                overhead = Int64Property.CalcOverhead(currentProperty);
-                break;
-            // TODO
-            /*
-        case 'UInt64Property':
-            currentProperty = Int64Property.Parse(reader, propertyType, index);
-            break;
-            */
-            case 'SingleProperty':
-            case 'FloatProperty':
-                currentProperty = FloatProperty.Parse(reader, propertyType, index);
-                overhead = FloatProperty.CalcOverhead(currentProperty);
-                break;
-            case 'DoubleProperty':
-                currentProperty = DoubleProperty.Parse(reader, propertyType, index);
-                overhead = DoubleProperty.CalcOverhead(currentProperty);
-                break;
-            case 'StrProperty':
-            case 'NameProperty':
-                currentProperty = StrProperty.Parse(reader, propertyType, index);
-                overhead = StrProperty.CalcOverhead(currentProperty);
-                break;
-            case 'ObjectProperty':
-            case 'InterfaceProperty':
-                currentProperty = ObjectProperty.Parse(reader, propertyType, index);
-                overhead = ObjectProperty.CalcOverhead(currentProperty);
-                break;
-            case 'EnumProperty':
-                currentProperty = EnumProperty.Parse(reader, propertyType, index);
-                overhead = EnumProperty.CalcOverhead(currentProperty);
-                break;
-            case 'StructProperty':
-                currentProperty = StructProperty.Parse(reader, propertyType, index, binarySize);
-                overhead = StructProperty.CalcOverhead(currentProperty);
-                break;
-            case 'ArrayProperty':
-                currentProperty = ArrayProperty.Parse(reader, propertyType, index, propertyName);
-                overhead = ArrayProperty.CalcOverhead(currentProperty);
-                break;
-            case 'MapProperty':
-                //currentProperty = reader.readMapProperty(currentProperty, '');
-                currentProperty = MapProperty.Parse(reader, propertyName, buildVersion, binarySize);
-                overhead = MapProperty.CalcOverhead(currentProperty);
-                break;
-            case 'TextProperty':
-                currentProperty = TextProperty.Parse(reader, propertyType, index);
-                overhead = TextProperty.CalcOverhead(currentProperty);
-                break;
-            case 'SetProperty':
-                currentProperty = SetProperty.Parse(reader, propertyType, index, propertyName);
-                overhead = SetProperty.CalcOverhead(currentProperty);
-                break;
-            default:
-                throw new Error(`Unimplemented type ${propertyType}`);
-        }
-        currentProperty.name = propertyName;
-        const readBytes = reader.getBufferPosition() - before - overhead;
-        if (readBytes !== binarySize) {
-            throw new Error(`possibly corrupt. Read ${readBytes} for ${propertyType} ${propertyName}, but ${binarySize} were indicated.`);
-        }
-        return currentProperty;
-    }
-    static Serialize(writer, fields, buildVersion) {
-        for (const property of fields.properties) {
-            writer.writeString(property.name);
-            DataFields.SerializeProperty(writer, property, property.name, buildVersion);
-        }
-        writer.writeString('None');
-        writer.writeInt32(0);
-        writer.writeBytesArray(fields.trailingData);
-    }
-    static SerializeProperty(writer, property, propertyName, buildVersion) {
-        writer.writeString(property.ueType);
-        // binary length indicator
-        const lenIndicator = writer.getBufferPosition();
-        writer.writeInt32(0);
-        // write index if it is not 0. Since it normally is.
-        writer.writeInt32(property.index ?? 0);
-        const start = writer.getBufferPosition();
-        let overhead = 0;
-        switch (property.ueType) {
-            case 'BoolProperty':
-                overhead = BoolProperty.CalcOverhead(property);
-                BoolProperty.Serialize(writer, property);
-                break;
-            case 'ByteProperty':
-                overhead = ByteProperty.CalcOverhead(property);
-                ByteProperty.Serialize(writer, property);
-                break;
-            case 'Int8Property':
-                overhead = Int8Property.CalcOverhead(property);
-                Int8Property.Serialize(writer, property);
-                break;
-            case 'UInt8Property':
-                overhead = Uint8Property.CalcOverhead(property);
-                Uint8Property.Serialize(writer, property);
-                break;
-            case 'IntProperty':
-            case 'Int32Property':
-                overhead = Int32Property.CalcOverhead(property);
-                Int32Property.Serialize(writer, property);
-                break;
-            case 'UInt32Property':
-                overhead = Uint32Property.CalcOverhead(property);
-                Uint32Property.Serialize(writer, property);
-                break;
-            case 'Int64Property':
-                overhead = Int64Property.CalcOverhead(property);
-                Int64Property.Serialize(writer, property);
-                break;
-            // TODO: uint64Property
-            case 'SingleProperty':
-            case 'FloatProperty':
-                overhead = FloatProperty.CalcOverhead(property);
-                FloatProperty.Serialize(writer, property);
-                break;
-            case 'DoubleProperty':
-                overhead = DoubleProperty.CalcOverhead(property);
-                DoubleProperty.Serialize(writer, property);
-                break;
-            case 'StrProperty':
-            case 'NameProperty':
-                overhead = StrProperty.CalcOverhead(property);
-                StrProperty.Serialize(writer, property);
-                break;
-            case 'ObjectProperty':
-            case 'InterfaceProperty':
-                overhead = ObjectProperty.CalcOverhead(property);
-                ObjectProperty.Serialize(writer, property);
-                break;
-            case 'EnumProperty':
-                overhead = EnumProperty.CalcOverhead(property);
-                EnumProperty.Serialize(writer, property);
-                break;
-            case 'ByteProperty':
-                overhead = ByteProperty.CalcOverhead(property);
-                ByteProperty.Serialize(writer, property);
-                break;
-            case 'StructProperty':
-                overhead = StructProperty.CalcOverhead(property);
-                StructProperty.Serialize(writer, property);
-                break;
-            case 'ArrayProperty':
-                overhead = ArrayProperty.CalcOverhead(property);
-                ArrayProperty.Serialize(writer, property, propertyName);
-                break;
-            case 'MapProperty':
-                overhead = MapProperty.CalcOverhead(property);
-                MapProperty.Serialize(writer, property);
-                break;
-            case 'TextProperty':
-                overhead = TextProperty.CalcOverhead(property);
-                TextProperty.Serialize(writer, property);
-                break;
-            case 'SetProperty':
-                overhead = SetProperty.CalcOverhead(property);
-                SetProperty.Serialize(writer, property);
-                break;
-            default:
-                throw new Error(`Unimplemented type ${property.type}`);
-        }
-        // replace len indicator.
-        writer.writeBinarySizeFromPosition(lenIndicator, start + overhead);
-    }
-}
-
-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);
-    }
-}
-
-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;
-
-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;
-
-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.TypeID);
-                    SaveEntity.SerializeHeader(writer, obj);
-                    break;
-                case 'SaveComponent':
-                    writer.writeInt32(SaveComponent.TypeID);
-                    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);
-        // replace binary size from earlier for - object headers + collectables
-        writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 4);
-        // write entities
-        Level.SerializeObjectContents(writer, level.objects, buildVersion);
-        Level.SerializeCollectablesList(writer, level.collectables);
-    }
-    static SerializeObjectContents(writer, objects, buildVersion) {
-        const lenIndicatorEntities = writer.getBufferPosition();
-        writer.writeInt32(0);
-        writer.writeInt32(objects.length);
-        for (const obj of objects) {
-            const lenReplacementPosition = writer.getBufferPosition();
-            writer.writeInt32(0);
-            if (isSaveEntity(obj)) {
-                SaveEntity.SerializeData(writer, obj, buildVersion);
-            }
-            else if (isSaveComponent(obj)) {
-                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.TypeID:
-                    let object = new SaveEntity('', '', '', '');
-                    SaveEntity.ParseHeader(reader, object);
-                    objectsList.push(object);
-                    break;
-                case SaveComponent.TypeID:
-                    let component = new SaveComponent('', '', '', '');
-                    SaveComponent.ParseHeader(reader, component);
-                    objectsList.push(component);
-                    break;
-                default:
-                    console.log('Unknown object type', objectType);
-                    break;
-            }
-        }
-    }
-    static ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
-        const binarySize = reader.readInt32(); // entities binary length
-        const posBefore = reader.getBufferPosition();
-        const countEntities = reader.readInt32();
-        if (countEntities !== objectsList.length) {
-            throw new Error(`possibly corrupt. entity content count ${countEntities} does not object count of ${objectsList.length}`);
-        }
-        // definitely after i=25467
-        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 (isSaveEntity(obj)) {
-                SaveEntity.ParseData(obj, len, reader, buildVersion);
-            }
-            else if (isSaveComponent(obj)) {
-                SaveComponent.ParseData(obj, len, reader, buildVersion);
-            }
-            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) {
-            //WARNING
-            console.warn('save seems corrupt.', this.name);
-        }
-    }
-    static ReadLevel(reader, levelName, buildVersion) {
-        const level = new Level(levelName);
-        reader.readInt32(); // object headers + collectables binary length
-        // object headers
-        Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
-        // collectables
-        reader.onProgressCallback(reader.getBufferProgress());
-        level.collectables = Level.ReadCollectablesList(reader);
-        // objects contents
-        Level.ReadObjectContents(reader, level.objects, buildVersion, reader.onProgressCallback);
-        // collectables 2nd time.
-        reader.onProgressCallback(reader.getBufferProgress());
-        Level.ReadCollectablesList(reader);
-        return level;
-    }
-    // collected stuff
-    static SerializeCollectablesList(writer, collectables) {
-        writer.writeInt32(collectables.length);
-        for (const collectable of collectables) {
-            ObjectReference.Serialize(writer, collectable);
-        }
-    }
-    // collected stuff
-    static ReadCollectablesList(reader) {
-        let countCollected = reader.readInt32();
-        const collected = [];
-        for (let i = 0; i < countCollected; i++) {
-            const collectable = ObjectReference.Parse(reader);
-            collected.push(collectable);
-        }
-        return collected;
-    }
-}
-
-class SatisfactorySave {
-    constructor(header) {
-        this.levels = [];
-        this.trailingCollectedObjects = [];
-        this.header = header;
-    }
-}
-
-class ParserError extends Error {
-    constructor(name, message) {
-        super(message);
-        this.name = name;
-    }
-}
-class UnsupportedVersionError extends ParserError {
-    constructor(message) {
-        super('UnsupportedVersionError', message ?? 'This save version is not supported.');
-    }
-}
-class CorruptSaveError extends ParserError {
-    constructor(message) {
-        super('CorruptSaveError', message ?? 'This save data is most likely corrupt.');
-    }
-}
-class CompressionLibraryError extends ParserError {
-    constructor(message) {
-        super('CompressionLibraryError', message ?? 'Failed to compress/decompress save data.');
-    }
-}
-
-var Alignment;
-(function (Alignment) {
-    Alignment[Alignment["BIG_ENDIAN"] = 0] = "BIG_ENDIAN";
-    Alignment[Alignment["LITTLE_ENDIAN"] = 1] = "LITTLE_ENDIAN";
-})(Alignment || (Alignment = {}));
-
-class ByteReader {
-    constructor(fileBuffer, alignment) {
-        this.currentByte = 0;
-        this.handledByte = 0;
-        this.maxByte = 0;
-        this.lastStrRead = 0;
-        this.getBufferPosition = () => this.currentByte;
-        this.getBufferSlice = (begin, end) => this.bufferView.buffer.slice(begin, end);
-        this.getBufferProgress = () => this.currentByte / this.bufferView.buffer.byteLength;
-        this.getBufferLength = () => this.bufferView.buffer.byteLength;
-        this.getBuffer = () => this.bufferView.buffer;
-        this.alignment = alignment;
-        this.reset(fileBuffer);
-    }
-    /**
-     * 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));
-        this.maxByte = newFileBuffer.byteLength;
-        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) {
-        return new Uint8Array(new Array(count).fill(0).map(pl => this.bufferView.getUint8(this.currentByte++)));
-    }
-    readHex(hexLength) {
-        let hexPart = [];
-        for (let i = 0; i < hexLength; i++) {
-            let currentHex = String.fromCharCode(this.bufferView.getUint8(this.currentByte++));
-            hexPart.push(currentHex);
-        }
-        return hexPart.join('');
-    }
-    readInt8() {
-        let data = this.bufferView.getInt8(this.currentByte++);
-        return data;
-    }
-    readUint8() {
-        let data = this.bufferView.getUint8(this.currentByte++);
-        return data;
-    }
-    readUint16() {
-        let data = this.bufferView.getUint16(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 2;
-        return data;
-    }
-    readInt32() {
-        let data = this.bufferView.getInt32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 4;
-        return data;
-    }
-    readUint32() {
-        let data = this.bufferView.getUint32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 4;
-        return data;
-    }
-    readLong() {
-        let data = this.bufferView.getBigInt64(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 8;
-        return data;
-    }
-    readFloat() {
-        let data = this.bufferView.getFloat32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 4;
-        return data;
-    }
-    readDouble() {
-        let data = this.bufferView.getFloat64(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 8;
-        return data;
-    }
-    getStringInfo() {
-        let payload = '';
-        let counter = this.currentByte;
-        try {
-            let strLength = this.bufferView.getInt32(this.currentByte, this.alignment === Alignment.LITTLE_ENDIAN);
-            counter += 4;
-            payload = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.bufferView.getUint8(counter++))).join('');
-        }
-        catch (error) { }
-        this.currentByte -= counter;
-        return { payload, counter };
-    }
-    readString() {
-        let strLength = this.readInt32();
-        this.lastStrRead = strLength;
-        this.currentByte;
-        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;
-            return string.join('');
-        }
-        catch (error) {
-            let errorMessage = `Cannot read UTF8 string of length ${strLength} at position ${this.currentByte}.`;
-            console.log(errorMessage, error);
-            throw error;
-        }
-    }
-}
-
-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) ;
-        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;
-
-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;
-    }
-    /*
-     * Byte Manipulation
-     */
-    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.LITTLE_ENDIAN);
-        this.currentByte += 2;
-    }
-    writeUint16(value) {
-        this.extendBufferIfNeeded(2);
-        this.bufferView.setUint16(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 2;
-    }
-    writeInt32(value) {
-        this.extendBufferIfNeeded(4);
-        this.bufferView.setInt32(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 4;
-    }
-    writeUint32(value) {
-        this.extendBufferIfNeeded(4);
-        this.bufferView.setUint32(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 4;
-    }
-    writeInt64(value) {
-        this.extendBufferIfNeeded(8);
-        this.bufferView.setBigInt64(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 8;
-    }
-    writeUint64(value) {
-        this.extendBufferIfNeeded(8);
-        this.bufferView.setBigUint64(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 8;
-    }
-    writeFloat(value) {
-        this.extendBufferIfNeeded(4);
-        this.bufferView.setFloat32(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 4;
-    }
-    writeDouble(value) {
-        this.extendBufferIfNeeded(8);
-        this.bufferView.setFloat64(this.currentByte, value, this.alignment === Alignment.LITTLE_ENDIAN);
-        this.currentByte += 8;
-    }
-    writeString(value) {
-        if (value.length === 0) {
-            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++) {
-                this.writeByte(value.charCodeAt(i));
-            }
-            this.writeUint8(0);
-        }
-        // write UTF16
-        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);
-    }
-    /**
-     * 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));
-            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);
-
-class SaveWriter extends ByteWriter {
-    constructor() {
-        super(Alignment.LITTLE_ENDIAN);
-    }
-    static WriteHeader(writer, header) {
-        writer.writeInt32(header.saveHeaderType);
-        writer.writeInt32(header.saveVersion);
-        writer.writeInt32(header.buildVersion);
-        writer.writeString(header.mapName);
-        writer.writeString(header.mapOptions);
-        writer.writeString(header.sessionName);
-        writer.writeInt32(header.playDurationSeconds);
-        writer.writeInt64(BigInt(header.saveDateTime));
-        writer.writeByte(header.sessionVisibility);
-        if (header.saveHeaderType >= 7) {
-            writer.writeInt32(header.fEditorObjectVersion);
-        }
-        if (header.saveHeaderType >= 8) {
-            if (header.modMetadata) {
-                writer.writeString(JSON.stringify(header.modMetadata));
-            }
-            else {
-                writer.writeString(header.rawModMetadataString);
-            }
-            writer.writeInt32(header.isModdedSave);
-        }
-        if (header.saveHeaderType >= 10) {
-            writer.writeString(header.saveIdentifier);
-        }
-        if (header.saveVersion >= 21) ;
-        else {
-            throw new UnsupportedVersionError("The save version is too old to be supported currently.");
-        }
-    }
-    static WriteLevels(writer, save, buildVersion) {
-        writer.writeInt32(save.levels.length - 1);
-        for (const level of save.levels) {
-            if (level.name !== save.header.mapName) {
-                writer.writeString(level.name);
-            }
-            Level.WriteLevel(writer, level, buildVersion);
-        }
-        Level.SerializeCollectablesList(writer, save.trailingCollectedObjects);
-    }
-    static GenerateCompressedChunksFromData(bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, alignment = Alignment.LITTLE_ENDIAN) {
-        const errors = [];
-        const totalUncompressedSize = bufferArray.byteLength;
-        const saveBody = new Uint8Array(bufferArray.byteLength + 4);
-        saveBody.set(new Uint8Array(bufferArray), 4);
-        const miniView = new DataView(saveBody.buffer);
-        miniView.setInt32(0, totalUncompressedSize, alignment === Alignment.LITTLE_ENDIAN);
-        onBinaryBeforeCompressing(saveBody.buffer);
-        // collect slices of chunks with help of compression info for max chunk size
-        let handledByte = 0;
-        const chunkSummary = [];
-        while (handledByte < saveBody.byteLength) {
-            // create uncompressed chunk.
-            const uncompressedContentSize = Math.min(compressionInfo.maxChunkContentSize, saveBody.byteLength - handledByte);
-            const uncompressedChunk = saveBody.buffer.slice(handledByte, handledByte + uncompressedContentSize);
-            // deflate chunk while we're at it.
-            let compressedChunk = new Uint8Array(0);
-            try {
-                compressedChunk = Pako.deflate(uncompressedChunk);
-            }
-            catch (err) {
-                errors.push("An error occurred while calling pako deflate. -> " + err);
-            }
-            const chunk = new Uint8Array(compressionInfo.chunkHeaderSize + compressedChunk.byteLength);
-            chunk.set(compressedChunk, compressionInfo.chunkHeaderSize);
-            // write header
-            const view = new DataView(chunk.buffer);
-            view.setInt32(0, compressionInfo.packageFileTag, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(4, 0, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(8, compressionInfo.maxChunkContentSize, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(12, 0, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(16, compressedChunk.byteLength, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(20, 0, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(24, uncompressedContentSize, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(28, 0, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(32, compressedChunk.byteLength, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(36, 0, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(40, uncompressedContentSize, alignment === Alignment.LITTLE_ENDIAN);
-            view.setInt32(44, 0, alignment === Alignment.LITTLE_ENDIAN);
-            onChunk(chunk);
-            chunkSummary.push({
-                uncompressedSize: uncompressedContentSize + compressionInfo.chunkHeaderSize,
-                compressedSize: compressedChunk.byteLength + compressionInfo.chunkHeaderSize
-            });
-            handledByte += uncompressedContentSize;
-        }
-        onFinish({
-            errors,
-            chunkSummary
-        });
-    }
-    generateChunks(compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish) {
-        if (posAfterHeader <= 0) {
-            throw new ParserError('ParserError', 'Seems like this buffer has no header. Please write the header first before you can generate chunks.');
-        }
-        // send plain header first.
-        const header = new Uint8Array(this.bufferArray.slice(0, posAfterHeader));
-        onHeader(header);
-        // create save body
-        this.bufferArray = this.bufferArray.slice(posAfterHeader);
-        SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, this.alignment);
-    }
-}
-
-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) {
-        const writer = new SaveWriter();
-        SaveWriter.WriteHeader(writer, save.header);
-        const posAfterHeader = writer.getBufferPosition();
-        SaveWriter.WriteLevels(writer, save, save.header.buildVersion);
-        writer.endWriting();
-        writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish);
-    }
-    /**
-     * 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 SaveReader(file.buffer, onProgress);
-        // read header
-        const header = reader.readHeader();
-        const save = new SatisfactorySave(header);
-        // inflate chunks
-        reader.inflateChunks();
-        // call callback on decompressed save body
-        onSaveDecompressed(reader.getBuffer());
-        // parse levels
-        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 ProjectSave(save, config) {
-        return {
-            header: save.header,
-            trailingCollectedObjects: save.trailingCollectedObjects,
-            levels: save.levels.map(level => {
-                const lvl = new Level(level.name);
-                lvl.collectables = level.collectables;
-                lvl.objects = level.objects.filter(obj => projectionFilterApplies(config, obj));
-                return lvl;
-            })
-        };
-    }
-}
-/**
- * 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) => {
-    if (typeof value === 'bigint') {
-        return value.toString();
-    }
-    else if (value === 0 && 1 / value < 0) { // -0
-        return '-0';
-    }
-    return value;
-}, indent);
-
-exports.CompressionLibraryError = CompressionLibraryError;
-exports.CorruptSaveError = CorruptSaveError;
-exports.Level = Level;
-exports.ParserError = ParserError;
-exports.SatisfactorySave = SatisfactorySave;
-exports.SaveParser = SaveParser;
-exports.UnsupportedVersionError = UnsupportedVersionError;