@etothepii/satisfactory-file-parser 0.0.32 → 0.0.34

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

@@ -1,1012 +1,1002 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../structs/util.types", "./DataFields", "./ObjectReference"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.SerializeFINLuaProcessorStateStorage = exports.ReadFINLuaProcessorStateStorage = exports.SerializeFINNetworkTrace = exports.ReadFINNetworkTrace = exports.SerializeDynamicStructData = exports.ParseDynamicStructData = exports.MapProperty = exports.SetProperty = exports.ArrayProperty = exports.StructProperty = exports.TextProperty = exports.EnumProperty = exports.ObjectProperty = exports.StrProperty = exports.DoubleProperty = exports.FloatProperty = exports.Int64Property = exports.Uint32Property = exports.Int32Property = exports.Uint8Property = exports.Int8Property = exports.ByteProperty = exports.BoolProperty = exports.SerializeGUID = exports.ParseGUID = exports.BasicProperty = exports.AbstractBaseProperty = exports.AbstractProperty = void 0;
-    const util_types_1 = require("../structs/util.types");
-    const DataFields_1 = require("./DataFields");
-    const ObjectReference_1 = require("./ObjectReference");
-    class AbstractProperty {
-        constructor(type, index) {
-            this.type = type;
-            this.index = index;
-        }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeFINLuaProcessorStateStorage = exports.ReadFINLuaProcessorStateStorage = exports.SerializeFINNetworkTrace = exports.ReadFINNetworkTrace = exports.SerializeDynamicStructData = exports.ParseDynamicStructData = exports.MapProperty = exports.SetProperty = exports.ArrayProperty = exports.StructProperty = exports.TextProperty = exports.EnumProperty = exports.ObjectProperty = exports.StrProperty = exports.DoubleProperty = exports.FloatProperty = exports.Int64Property = exports.Uint32Property = exports.Int32Property = exports.Uint8Property = exports.Int8Property = exports.ByteProperty = exports.BoolProperty = exports.SerializeGUID = exports.ParseGUID = exports.BasicProperty = exports.AbstractBaseProperty = exports.AbstractProperty = void 0;
+const util_types_1 = require("../structs/util.types");
+const DataFields_1 = require("./DataFields");
+const ObjectReference_1 = require("./ObjectReference");
+class AbstractProperty {
+    constructor(type, index) {
+        this.type = type;
+        this.index = index;
     }
-    exports.AbstractProperty = AbstractProperty;
-    class AbstractBaseProperty extends AbstractProperty {
-        constructor(type, ueType, index) {
-            super(type, index && index !== 0 ? index : undefined);
-            this.ueType = ueType;
-            this.name = '';
-        }
+}
+exports.AbstractProperty = AbstractProperty;
+class AbstractBaseProperty extends AbstractProperty {
+    constructor(type, ueType, index) {
+        super(type, index && index !== 0 ? index : undefined);
+        this.ueType = ueType;
+        this.name = '';
     }
-    exports.AbstractBaseProperty = AbstractBaseProperty;
-    class BasicProperty extends AbstractBaseProperty {
-        constructor(type, ueType, guidInfo, index = 0) {
-            super(type, ueType, index);
-            this.guidInfo = guidInfo;
-        }
+}
+exports.AbstractBaseProperty = AbstractBaseProperty;
+class BasicProperty extends AbstractBaseProperty {
+    constructor(type, ueType, guidInfo, index = 0) {
+        super(type, ueType, index);
+        this.guidInfo = guidInfo;
     }
-    exports.BasicProperty = BasicProperty;
-    const ParseGUID = (reader) => {
-        const hasGuid = reader.readByte() === 1;
-        let guid;
-        if (hasGuid) {
-            throw new Error('Unexpected!');
-            guid = reader.readBytes(16);
-        }
-        return guid;
-    };
-    exports.ParseGUID = ParseGUID;
-    const SerializeGUID = (writer, guid) => {
-        writer.writeByte(guid ? 1 : 0);
-        if (guid) {
-            writer.writeBytes(guid);
-        }
-    };
-    exports.SerializeGUID = SerializeGUID;
-    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 = (0, exports.ParseGUID)(reader);
-            return new BoolProperty(value, ueType, guidInfo, index);
+}
+exports.BasicProperty = BasicProperty;
+const ParseGUID = (reader) => {
+    const hasGuid = reader.readByte() === 1;
+    let guid;
+    if (hasGuid) {
+        throw new Error('Unexpected!');
+        guid = reader.readBytes(16);
+    }
+    return guid;
+};
+exports.ParseGUID = ParseGUID;
+const SerializeGUID = (writer, guid) => {
+    writer.writeByte(guid ? 1 : 0);
+    if (guid) {
+        writer.writeBytes(guid);
+    }
+};
+exports.SerializeGUID = SerializeGUID;
+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 = (0, exports.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);
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeByte(value ? 1 : 0);
+    }
+}
+exports.BoolProperty = BoolProperty;
+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 = (0, exports.ParseGUID)(reader);
+        let value;
+        if (type === 'None') {
+            value = {
+                type,
+                value: ByteProperty.ReadValue(reader)
+            };
         }
-        static ReadValue(reader) {
-            return reader.readByte() > 0;
+        else {
+            value = {
+                type,
+                value: reader.readString()
+            };
         }
-        static CalcOverhead(property) {
-            return 2;
+        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);
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        if (property.value.type === 'None') {
+            ByteProperty.SerializeValue(writer, property.value.value);
         }
-        static Serialize(writer, property) {
-            BoolProperty.SerializeValue(writer, property.value);
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
+        else {
+            writer.writeString(property.value.value);
         }
-        static SerializeValue(writer, value) {
-            writer.writeByte(value ? 1 : 0);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeByte(value);
+    }
+}
+exports.ByteProperty = ByteProperty;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        Int8Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt8(value);
+    }
+}
+exports.Int8Property = Int8Property;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        Uint8Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeUint8(value);
+    }
+}
+exports.Uint8Property = Uint8Property;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        Int32Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt32(value);
+    }
+}
+exports.Int32Property = Int32Property;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        Uint32Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeUint32(value);
+    }
+}
+exports.Uint32Property = Uint32Property;
+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 = (0, exports.ParseGUID)(reader);
+        const value = Int64Property.ReadValue(reader);
+        return new Int64Property(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readInt64().toString();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        Int64Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt64(BigInt(value));
+    }
+}
+exports.Int64Property = Int64Property;
+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 = (0, exports.ParseGUID)(reader);
+        const value = FloatProperty.ReadValue(reader);
+        return new FloatProperty(value, ueType, guidInfo, index);
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static ReadValue(reader) {
+        return reader.readFloat32();
+    }
+    static Serialize(writer, property) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        FloatProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeFloat(value);
+    }
+}
+exports.FloatProperty = FloatProperty;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        DoubleProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeDouble(value);
+    }
+}
+exports.DoubleProperty = DoubleProperty;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        StrProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeString(value);
+    }
+}
+exports.StrProperty = StrProperty;
+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 = (0, exports.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) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        ObjectProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeString(value.levelName);
+        writer.writeString(value.pathName);
+    }
+}
+exports.ObjectProperty = ObjectProperty;
+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 = (0, exports.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);
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        EnumProperty.SerializeValue(writer, property.value.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeString(value);
+    }
+}
+exports.EnumProperty = EnumProperty;
+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) {
+        const guidInfo = (0, exports.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) {
+            case 0:
+                prop.namespace = reader.readString();
+                prop.key = reader.readString();
+                prop.value = reader.readString();
+                break;
+            case 1:
+            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;
+            case 10:
+                prop.sourceText = TextProperty.ParseValue(reader);
+                prop.transformType = reader.readByte();
+                break;
+            case 255:
+                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;
     }
-    exports.BoolProperty = BoolProperty;
-    class ByteProperty extends BasicProperty {
-        constructor(value, ueType = 'ByteProperty', guidInfo = undefined, index = 0) {
-            super('ByteProperty', ueType, guidInfo, index);
-            this.value = value;
+    static Serialize(writer, property) {
+        (0, exports.SerializeGUID)(writer, property.guidInfo);
+        TextProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt32(value.flags);
+        writer.writeByte(value.historyType);
+        switch (value.historyType) {
+            case 0:
+                writer.writeString(value.namespace);
+                writer.writeString(value.key);
+                writer.writeString(value.value);
+                break;
+            case 1:
+            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;
+            case 10:
+                TextProperty.SerializeValue(writer, value.sourceText);
+                writer.writeByte(value.transformType);
+                break;
+            case 255:
+                writer.writeInt32(value.hasCultureInvariantString ? 1 : 0);
+                if (value.hasCultureInvariantString) {
+                    writer.writeString(value.value);
+                }
+                break;
+            default:
+                throw new Error('Unimplemented historyType `' + value.historyType);
         }
-        static Parse(reader, ueType, index = 0) {
-            const type = reader.readString();
-            const guidInfo = (0, exports.ParseGUID)(reader);
-            let value;
-            if (type === 'None') {
+    }
+}
+exports.TextProperty = TextProperty;
+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 = (0, util_types_1.ParseCol4BGRA)(reader);
+                break;
+            case 'LinearColor':
+                value = (0, util_types_1.ParseCol4RGBA)(reader);
+                break;
+            case 'Vector':
+            case 'Rotator':
+            case 'Vector2D':
+                value = (0, util_types_1.ParseVec3)(reader);
+                break;
+            case 'Quat':
+            case 'Vector4':
+            case 'Vector4D':
+                value = (0, util_types_1.ParseVec4)(reader);
+                break;
+            case 'Box':
                 value = {
-                    type,
-                    value: ByteProperty.ReadValue(reader)
+                    min: (0, util_types_1.ParseVec3)(reader),
+                    max: (0, util_types_1.ParseVec3)(reader),
+                    isValid: reader.readByte() >= 1
                 };
-            }
-            else {
+                break;
+            case 'RailroadTrackPosition':
                 value = {
-                    type,
-                    value: reader.readString()
+                    root: reader.readString(),
+                    instanceName: reader.readString(),
+                    offset: reader.readFloat32(),
+                    forward: reader.readFloat32()
                 };
-            }
-            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);
-            (0, exports.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);
+                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: [],
+                };
+                break;
+            case 'FluidBox':
+                value = {
+                    value: reader.readFloat32()
+                };
+                break;
+            case 'SlateBrush':
+                value = reader.readString();
+                break;
+            case 'DateTime':
+                value = reader.readInt64().toString();
+                break;
+            case 'FINNetworkTrace':
+                value = (0, exports.ReadFINNetworkTrace)(reader);
+                break;
+            case 'FINLuaProcessorStateStorage':
+                value = {
+                    values: (0, exports.ReadFINLuaProcessorStateStorage)(reader, size)
+                };
+                break;
+            case 'FICFrameRange':
+                value = {
+                    begin: reader.readInt64().toString(),
+                    end: reader.readInt64().toString(),
+                };
+                break;
+            default:
+                value = (0, exports.ParseDynamicStructData)(reader, 0, subtype);
         }
+        return value;
     }
-    exports.ByteProperty = ByteProperty;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            Int8Property.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeInt8(value);
-        }
+    static CalcOverhead(property) {
+        return property.subtype.length + 5 + 17;
     }
-    exports.Int8Property = Int8Property;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            Uint8Property.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeUint8(value);
-        }
+    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);
     }
-    exports.Uint8Property = Uint8Property;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            Int32Property.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeInt32(value);
+    static SerializeValue(writer, subtype, value) {
+        switch (subtype) {
+            case 'Color':
+                value = value;
+                (0, util_types_1.SerializeCol4BGRA)(writer, value);
+                break;
+            case 'LinearColor':
+                value = value;
+                (0, util_types_1.SerializeCol4RGBA)(writer, value);
+                break;
+            case 'Vector':
+            case 'Rotator':
+            case 'Vector2D':
+                value = value;
+                (0, util_types_1.SerializeVec3)(writer, value);
+                break;
+            case 'Quat':
+            case 'Vector4':
+            case 'Vector4D':
+                value = value;
+                (0, util_types_1.SerializeVec4)(writer, value);
+                break;
+            case 'Box':
+                value = value;
+                (0, util_types_1.SerializeVec3)(writer, value.min);
+                (0, util_types_1.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);
+                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;
+            case 'FINNetworkTrace':
+                value = value;
+                (0, exports.SerializeFINNetworkTrace)(writer, value);
+                break;
+            case 'FINLuaProcessorStateStorage':
+                value = value;
+                (0, exports.SerializeFINLuaProcessorStateStorage)(writer, value.values);
+                break;
+            case 'FICFrameRange':
+                value = value;
+                writer.writeInt64(BigInt(value.begin));
+                writer.writeInt64(BigInt(value.end));
+                break;
+            default:
+                value = value;
+                (0, exports.SerializeDynamicStructData)(writer, 0, value);
         }
     }
-    exports.Int32Property = Int32Property;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            Uint32Property.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeUint32(value);
-        }
+}
+exports.StructProperty = StructProperty;
+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;
     }
-    exports.Uint32Property = Uint32Property;
-    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 = (0, exports.ParseGUID)(reader);
-            const value = Int64Property.ReadValue(reader);
-            return new Int64Property(value, ueType, guidInfo, index);
-        }
-        static ReadValue(reader) {
-            return reader.readInt64().toString();
-        }
-        static CalcOverhead(property) {
-            return 1;
-        }
-        static Serialize(writer, property) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            Int64Property.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeInt64(BigInt(value));
-        }
+    static Parse(reader, ueType, index, propertyName) {
+        const subtype = reader.readString();
+        reader.skipBytes();
+        let property;
+        const elementCount = reader.readInt32();
+        switch (subtype) {
+            case "FloatProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => FloatProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "BoolProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => BoolProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "IntProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
+                break;
+            case "Int64Property":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int64Property.ReadValue(reader)), ueType, index);
+                break;
+            case "DoubleProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => DoubleProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "ByteProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ByteProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "StrProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "EnumProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "TextProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty.ParseValue(reader)), ueType, index);
+                break;
+            case "InterfaceProperty":
+            case "ObjectProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "StructProperty":
+                const name = reader.readString();
+                const type = reader.readString();
+                const binarySize = reader.readInt32();
+                const allIndex = reader.readInt32();
+                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(() => {
+                    const struct = new StructProperty(allStructType, type, allIndex, allGuid);
+                    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.');
+                }
+                property = new ArrayProperty(subtype, maArr, ueType, index, innerStructValueFields);
+                break;
+            default:
+                console.log(subtype, ueType);
+                throw new Error();
+        }
+        return property;
     }
-    exports.Int64Property = Int64Property;
-    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 = (0, exports.ParseGUID)(reader);
-            const value = FloatProperty.ReadValue(reader);
-            return new FloatProperty(value, ueType, guidInfo, index);
-        }
-        static CalcOverhead(property) {
-            return 1;
-        }
-        static ReadValue(reader) {
-            return reader.readFloat32();
-        }
-        static Serialize(writer, property) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            FloatProperty.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeFloat(value);
-        }
+    static CalcOverhead(property) {
+        return property.subtype.length + 5 + 1;
     }
-    exports.FloatProperty = FloatProperty;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            DoubleProperty.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeDouble(value);
+    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();
         }
     }
-    exports.DoubleProperty = DoubleProperty;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            StrProperty.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeString(value);
-        }
+}
+exports.ArrayProperty = ArrayProperty;
+class SetProperty extends BasicProperty {
+    constructor(subtype, values, ueType, index) {
+        super('SetProperty', ueType, undefined, index);
+        this.subtype = subtype;
+        this.values = values;
     }
-    exports.StrProperty = StrProperty;
-    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 = (0, exports.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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            ObjectProperty.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeString(value.levelName);
-            writer.writeString(value.pathName);
-        }
+    static Parse(reader, ueType, index, propertyName) {
+        const subtype = reader.readString();
+        reader.skipBytes(1);
+        reader.skipBytes(4);
+        const elementCount = reader.readInt32();
+        let property;
+        switch (subtype) {
+            case "IntProperty":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
+                break;
+            case "ObjectProperty":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "NameProperty":
+                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "StructProperty":
+                if (propertyName === 'mRemovalLocations') {
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => (0, util_types_1.ParseVec3)(reader)), ueType, index);
+                }
+                break;
+            default:
+                throw new Error('Not Implemented.');
+        }
+        return property;
     }
-    exports.ObjectProperty = ObjectProperty;
-    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 = (0, exports.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);
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            EnumProperty.SerializeValue(writer, property.value.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeString(value);
-        }
+    static CalcOverhead(property) {
+        return property.subtype.length + 5 + 1;
     }
-    exports.EnumProperty = EnumProperty;
-    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) {
-            const guidInfo = (0, exports.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) {
-                case 0:
-                    prop.namespace = reader.readString();
-                    prop.key = reader.readString();
-                    prop.value = reader.readString();
-                    break;
-                case 1:
-                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;
-                case 10:
-                    prop.sourceText = TextProperty.ParseValue(reader);
-                    prop.transformType = reader.readByte();
-                    break;
-                case 255:
-                    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) {
-            (0, exports.SerializeGUID)(writer, property.guidInfo);
-            TextProperty.SerializeValue(writer, property.value);
-        }
-        static SerializeValue(writer, value) {
-            writer.writeInt32(value.flags);
-            writer.writeByte(value.historyType);
-            switch (value.historyType) {
-                case 0:
-                    writer.writeString(value.namespace);
-                    writer.writeString(value.key);
-                    writer.writeString(value.value);
-                    break;
-                case 1:
-                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;
-                case 10:
-                    TextProperty.SerializeValue(writer, value.sourceText);
-                    writer.writeByte(value.transformType);
-                    break;
-                case 255:
-                    writer.writeInt32(value.hasCultureInvariantString ? 1 : 0);
-                    if (value.hasCultureInvariantString) {
-                        writer.writeString(value.value);
-                    }
-                    break;
-                default:
-                    throw new Error('Unimplemented historyType `' + value.historyType);
-            }
+    static Serialize(writer, property) {
+        writer.writeString(property.subtype);
+        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":
+                property.values.forEach(v => (0, util_types_1.SerializeVec3)(writer, v));
+                break;
+            default:
+                throw new Error('Not Implemented.');
         }
     }
-    exports.TextProperty = TextProperty;
-    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 = (0, util_types_1.ParseCol4BGRA)(reader);
-                    break;
-                case 'LinearColor':
-                    value = (0, util_types_1.ParseCol4RGBA)(reader);
-                    break;
-                case 'Vector':
-                case 'Rotator':
-                case 'Vector2D':
-                    value = (0, util_types_1.ParseVec3)(reader);
-                    break;
-                case 'Quat':
-                case 'Vector4':
-                case 'Vector4D':
-                    value = (0, util_types_1.ParseVec4)(reader);
-                    break;
-                case 'Box':
-                    value = {
-                        min: (0, util_types_1.ParseVec3)(reader),
-                        max: (0, util_types_1.ParseVec3)(reader),
-                        isValid: reader.readByte() >= 1
-                    };
-                    break;
-                case 'RailroadTrackPosition':
-                    value = {
-                        root: reader.readString(),
-                        instanceName: reader.readString(),
-                        offset: reader.readFloat32(),
-                        forward: reader.readFloat32()
-                    };
-                    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: [],
-                    };
-                    break;
-                case 'FluidBox':
-                    value = {
-                        value: reader.readFloat32()
-                    };
-                    break;
-                case 'SlateBrush':
-                    value = reader.readString();
-                    break;
-                case 'DateTime':
-                    value = reader.readInt64().toString();
-                    break;
-                case 'FINNetworkTrace':
-                    value = (0, exports.ReadFINNetworkTrace)(reader);
-                    break;
-                case 'FINLuaProcessorStateStorage':
-                    value = {
-                        values: (0, exports.ReadFINLuaProcessorStateStorage)(reader, size)
-                    };
-                    break;
-                case 'FICFrameRange':
-                    value = {
-                        begin: reader.readInt64().toString(),
-                        end: reader.readInt64().toString(),
-                    };
-                    break;
-                default:
-                    value = (0, exports.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;
-                    (0, util_types_1.SerializeCol4BGRA)(writer, value);
-                    break;
-                case 'LinearColor':
-                    value = value;
-                    (0, util_types_1.SerializeCol4RGBA)(writer, value);
-                    break;
-                case 'Vector':
-                case 'Rotator':
-                case 'Vector2D':
-                    value = value;
-                    (0, util_types_1.SerializeVec3)(writer, value);
-                    break;
-                case 'Quat':
-                case 'Vector4':
-                case 'Vector4D':
-                    value = value;
-                    (0, util_types_1.SerializeVec4)(writer, value);
-                    break;
-                case 'Box':
-                    value = value;
-                    (0, util_types_1.SerializeVec3)(writer, value.min);
-                    (0, util_types_1.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);
-                    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;
-                case 'FINNetworkTrace':
-                    value = value;
-                    (0, exports.SerializeFINNetworkTrace)(writer, value);
-                    break;
-                case 'FINLuaProcessorStateStorage':
-                    value = value;
-                    (0, exports.SerializeFINLuaProcessorStateStorage)(writer, value.values);
-                    break;
-                case 'FICFrameRange':
-                    value = value;
-                    writer.writeInt64(BigInt(value.begin));
-                    writer.writeInt64(BigInt(value.end));
-                    break;
-                default:
-                    value = value;
-                    (0, exports.SerializeDynamicStructData)(writer, 0, value);
-            }
-        }
+}
+exports.SetProperty = SetProperty;
+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 = [];
     }
-    exports.StructProperty = StructProperty;
-    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();
-            let property;
-            const elementCount = reader.readInt32();
-            switch (subtype) {
-                case "FloatProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => FloatProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "BoolProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => BoolProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "IntProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
-                    break;
-                case "Int64Property":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int64Property.ReadValue(reader)), ueType, index);
-                    break;
-                case "DoubleProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => DoubleProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "ByteProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ByteProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "StrProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "EnumProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "TextProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty.ParseValue(reader)), ueType, index);
-                    break;
-                case "InterfaceProperty":
-                case "ObjectProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "StructProperty":
-                    const name = reader.readString();
-                    const type = reader.readString();
-                    const binarySize = reader.readInt32();
-                    const allIndex = reader.readInt32();
-                    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(() => {
-                        const struct = new StructProperty(allStructType, type, allIndex, allGuid);
-                        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.');
-                    }
-                    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();
-            }
-        }
+    static Parse(reader, propertyName, buildVersion, size, ueType = 'MapProperty', index = 0) {
+        const start = reader.getBufferPosition();
+        const property = new MapProperty(reader.readString(), reader.readString(), ueType, index);
+        reader.skipBytes(1);
+        property.modeType = reader.readInt32();
+        property.remainingData = Array.from(reader.readBytes(size - 4));
+        return property;
     }
-    exports.ArrayProperty = ArrayProperty;
-    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);
-            reader.skipBytes(4);
-            const elementCount = reader.readInt32();
-            let property;
-            switch (subtype) {
-                case "IntProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
-                    break;
-                case "ObjectProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "NameProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
-                    break;
-                case "StructProperty":
-                    if (propertyName === 'mRemovalLocations') {
-                        property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => (0, util_types_1.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);
-            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":
-                    property.values.forEach(v => (0, util_types_1.SerializeVec3)(writer, v));
-                    break;
-                default:
-                    throw new Error('Not Implemented.');
-            }
-        }
+    static CalcOverhead(property) {
+        return property.keyType.length + 5 + property.valueType.length + 5 + 1;
     }
-    exports.SetProperty = SetProperty;
-    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) {
-            const start = reader.getBufferPosition();
-            const property = new MapProperty(reader.readString(), reader.readString(), ueType, index);
-            reader.skipBytes(1);
-            property.modeType = reader.readInt32();
-            property.remainingData = Array.from(reader.readBytes(size - 4));
-            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);
-        }
+    static Serialize(writer, property) {
+        writer.writeString(property.keyType);
+        writer.writeString(property.valueType);
+        writer.writeByte(0);
+        writer.writeInt32(property.modeType);
+        writer.writeBytesArray(property.remainingData);
     }
-    exports.MapProperty = MapProperty;
-    const ParseDynamicStructData = (reader, buildVersion, type) => {
-        const data = {
-            type, properties: {}
-        };
-        const pos = reader.getBufferPosition();
-        let propertyName = reader.readString();
-        while (propertyName !== 'None') {
-            const property = DataFields_1.DataFields.ParseProperty(reader, buildVersion, propertyName);
-            data.properties[propertyName] = property;
-            propertyName = reader.readString();
-        }
-        return data;
+}
+exports.MapProperty = MapProperty;
+const ParseDynamicStructData = (reader, buildVersion, type) => {
+    const data = {
+        type, properties: {}
     };
-    exports.ParseDynamicStructData = ParseDynamicStructData;
-    const SerializeDynamicStructData = (writer, buildVersion, data) => {
-        for (const key in data.properties) {
-            writer.writeString(key);
-            DataFields_1.DataFields.SerializeProperty(writer, data.properties[key], key, buildVersion);
-        }
-        writer.writeString('None');
-    };
-    exports.SerializeDynamicStructData = SerializeDynamicStructData;
-    const ReadFINNetworkTrace = (reader) => {
-        const networkTrace = {};
-        networkTrace.ref = ObjectReference_1.ObjectReference.Parse(reader);
-        networkTrace.hasPrev = reader.readInt32();
-        if (networkTrace.hasPrev) {
-            networkTrace.prev = (0, exports.ReadFINNetworkTrace)(reader);
-        }
-        networkTrace.hasStep = reader.readInt32();
-        if (networkTrace.hasStep) {
-            networkTrace.step = reader.readString();
-        }
-        return networkTrace;
-    };
-    exports.ReadFINNetworkTrace = ReadFINNetworkTrace;
-    const SerializeFINNetworkTrace = (writer, obj) => {
-        const networkTrace = {};
-        ObjectReference_1.ObjectReference.Serialize(writer, obj.ref);
-        writer.writeInt32(obj.hasPrev);
-        if (obj.hasPrev) {
-            (0, exports.SerializeFINNetworkTrace)(writer, obj.prev);
-        }
-        writer.writeInt32(obj.hasStep);
-        if (obj.hasStep) {
-            writer.writeString(obj.step);
-        }
-    };
-    exports.SerializeFINNetworkTrace = SerializeFINNetworkTrace;
-    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((0, exports.ReadFINNetworkTrace)(reader));
-        }
-        const refCount = reader.readInt32();
-        for (let i = 0; i < refCount; i++) {
-            stateStorage.references.push(ObjectReference_1.ObjectReference.Parse(reader));
-        }
-        stateStorage.thread = reader.readString();
-        stateStorage.globals = reader.readString();
-        const remaining = size - (reader.getBufferPosition() - start);
-        stateStorage.remainingStructData = reader.readBytes(remaining);
-        return stateStorage;
-    };
-    exports.ReadFINLuaProcessorStateStorage = ReadFINLuaProcessorStateStorage;
-    const SerializeFINLuaProcessorStateStorage = (writer, stateStorage) => {
-        writer.writeInt32(stateStorage.traces.length);
-        for (const trace of stateStorage.traces) {
-            (0, exports.SerializeFINNetworkTrace)(writer, trace);
-        }
-        writer.writeInt32(stateStorage.references.length);
-        for (const ref of stateStorage.references) {
-            ObjectReference_1.ObjectReference.Serialize(writer, ref);
-        }
-        writer.writeString(stateStorage.thread);
-        writer.writeString(stateStorage.globals);
-        writer.writeBytes(stateStorage.remainingStructData);
-    };
-    exports.SerializeFINLuaProcessorStateStorage = SerializeFINLuaProcessorStateStorage;
-});
+    const pos = reader.getBufferPosition();
+    let propertyName = reader.readString();
+    while (propertyName !== 'None') {
+        const property = DataFields_1.DataFields.ParseProperty(reader, buildVersion, propertyName);
+        data.properties[propertyName] = property;
+        propertyName = reader.readString();
+    }
+    return data;
+};
+exports.ParseDynamicStructData = ParseDynamicStructData;
+const SerializeDynamicStructData = (writer, buildVersion, data) => {
+    for (const key in data.properties) {
+        writer.writeString(key);
+        DataFields_1.DataFields.SerializeProperty(writer, data.properties[key], key, buildVersion);
+    }
+    writer.writeString('None');
+};
+exports.SerializeDynamicStructData = SerializeDynamicStructData;
+const ReadFINNetworkTrace = (reader) => {
+    const networkTrace = {};
+    networkTrace.ref = ObjectReference_1.ObjectReference.Parse(reader);
+    networkTrace.hasPrev = reader.readInt32();
+    if (networkTrace.hasPrev) {
+        networkTrace.prev = (0, exports.ReadFINNetworkTrace)(reader);
+    }
+    networkTrace.hasStep = reader.readInt32();
+    if (networkTrace.hasStep) {
+        networkTrace.step = reader.readString();
+    }
+    return networkTrace;
+};
+exports.ReadFINNetworkTrace = ReadFINNetworkTrace;
+const SerializeFINNetworkTrace = (writer, obj) => {
+    const networkTrace = {};
+    ObjectReference_1.ObjectReference.Serialize(writer, obj.ref);
+    writer.writeInt32(obj.hasPrev);
+    if (obj.hasPrev) {
+        (0, exports.SerializeFINNetworkTrace)(writer, obj.prev);
+    }
+    writer.writeInt32(obj.hasStep);
+    if (obj.hasStep) {
+        writer.writeString(obj.step);
+    }
+};
+exports.SerializeFINNetworkTrace = SerializeFINNetworkTrace;
+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((0, exports.ReadFINNetworkTrace)(reader));
+    }
+    const refCount = reader.readInt32();
+    for (let i = 0; i < refCount; i++) {
+        stateStorage.references.push(ObjectReference_1.ObjectReference.Parse(reader));
+    }
+    stateStorage.thread = reader.readString();
+    stateStorage.globals = reader.readString();
+    const remaining = size - (reader.getBufferPosition() - start);
+    stateStorage.remainingStructData = reader.readBytes(remaining);
+    return stateStorage;
+};
+exports.ReadFINLuaProcessorStateStorage = ReadFINLuaProcessorStateStorage;
+const SerializeFINLuaProcessorStateStorage = (writer, stateStorage) => {
+    writer.writeInt32(stateStorage.traces.length);
+    for (const trace of stateStorage.traces) {
+        (0, exports.SerializeFINNetworkTrace)(writer, trace);
+    }
+    writer.writeInt32(stateStorage.references.length);
+    for (const ref of stateStorage.references) {
+        ObjectReference_1.ObjectReference.Serialize(writer, ref);
+    }
+    writer.writeString(stateStorage.thread);
+    writer.writeString(stateStorage.globals);
+    writer.writeBytes(stateStorage.remainingStructData);
+};
+exports.SerializeFINLuaProcessorStateStorage = SerializeFINLuaProcessorStateStorage;