@etothepii/satisfactory-file-parser 0.4.5 → 0.4.6

package/build/parser/satisfactory/objects/property/generic/StructProperty.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeFINLuaProcessorStateStorage = exports.ReadFINLuaProcessorStateStorage = exports.SerializeFINNetworkTrace = exports.ReadFINNetworkTrace = exports.SerializeDynamicStructData = exports.ParseDynamicStructData = exports.StructProperty = void 0;
+const util_types_1 = require("../../../structs/util.types");
+const DataFields_1 = require("../../DataFields");
+const ObjectReference_1 = require("../../values/ObjectReference");
+const BasicProperty_1 = require("./BasicProperty");
+class StructProperty extends BasicProperty_1.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 (unk3 !== 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 = util_types_1.col4.ParseBGRA(reader);
+                break;
+            case 'LinearColor':
+                value = util_types_1.col4.ParseRGBA(reader);
+                break;
+            case 'Vector':
+            case 'Rotator':
+            case 'Vector2D':
+                value = (size === 12) ? util_types_1.vec3.ParseF(reader) : util_types_1.vec3.Parse(reader);
+                break;
+            case 'Quat':
+            case 'Vector4':
+            case 'Vector4D':
+                value = (size === 16) ? util_types_1.vec4.ParseF(reader) : util_types_1.vec4.Parse(reader);
+                break;
+            case 'Box':
+                value = (size === 25) ? {
+                    min: util_types_1.vec3.ParseF(reader),
+                    max: util_types_1.vec3.ParseF(reader),
+                    isValid: reader.readByte() >= 1
+                } : {
+                    min: util_types_1.vec3.Parse(reader),
+                    max: util_types_1.vec3.Parse(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 'ClientIdentityInfo':
+                const id = reader.readString();
+                const clientUnk1 = reader.readInt32();
+                const clientUnk2 = reader.readByte();
+                const clientHashSize = reader.readInt32();
+                const someClientHash = Array.from(reader.readBytes(clientHashSize));
+                value = { id, clientUnk1, clientUnk2, clientHashSize, someClientHash };
+                break;
+            case 'InventoryItem':
+                value = {
+                    unk1: reader.readInt32(),
+                    itemName: reader.readString(),
+                    hasItemState: reader.readInt32(),
+                };
+                if (value.hasItemState >= 1) {
+                    const stateUnk = reader.readInt32();
+                    const statePathName = reader.readString();
+                    const stateBinarySize = reader.readInt32();
+                    const itemStateRaw = Array.from(reader.readBytes(stateBinarySize));
+                    value.itemState = {
+                        unk: stateUnk,
+                        pathName: statePathName,
+                        binarySize: stateBinarySize,
+                        itemStateRaw: itemStateRaw
+                    };
+                }
+                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;
+                util_types_1.col4.SerializeBGRA(writer, value);
+                break;
+            case 'LinearColor':
+                value = value;
+                util_types_1.col4.SerializeRGBA(writer, value);
+                break;
+            case 'Vector':
+            case 'Rotator':
+            case 'Vector2D':
+                value = value;
+                util_types_1.vec3.Serialize(writer, value);
+                break;
+            case 'Quat':
+            case 'Vector4':
+            case 'Vector4D':
+                value = value;
+                util_types_1.vec4.Serialize(writer, value);
+                break;
+            case 'Box':
+                value = value;
+                util_types_1.vec3.Serialize(writer, value.min);
+                util_types_1.vec3.Serialize(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 'ClientIdentityInfo':
+                value = value;
+                writer.writeString(value.id);
+                writer.writeInt32(value.clientUnk1);
+                writer.writeByte(value.clientUnk2);
+                writer.writeInt32(value.clientHashSize);
+                writer.writeBytesArray(value.someClientHash);
+                break;
+            case 'InventoryItem':
+                value = value;
+                writer.writeInt32(value.unk1);
+                writer.writeString(value.itemName);
+                writer.writeInt32(value.hasItemState);
+                if (value.hasItemState >= 1) {
+                    writer.writeInt32(value.itemState.unk);
+                    writer.writeString(value.itemState.pathName);
+                    writer.writeInt32(value.itemState.binarySize);
+                    writer.writeBytesArray(value.itemState.itemStateRaw);
+                }
+                break;
+                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.StructProperty = StructProperty;
+const ParseDynamicStructData = (reader, buildVersion, type) => {
+    const data = {
+        type, properties: {}
+    };
+    const pos = reader.getBufferPosition();
+    let propertyName = reader.readString();
+    while (propertyName !== 'None') {
+        const parsedProperty = DataFields_1.DataFields.ParseProperty(reader, buildVersion, propertyName);
+        if (data.properties[propertyName]) {
+            if (!Array.isArray(data.properties[propertyName])) {
+                data.properties[propertyName] = [data.properties[propertyName]];
+            }
+            data.properties[propertyName].push(parsedProperty);
+        }
+        else {
+            data.properties[propertyName] = parsedProperty;
+        }
+        propertyName = reader.readString();
+    }
+    return data;
+};
+exports.ParseDynamicStructData = ParseDynamicStructData;
+const SerializeDynamicStructData = (writer, buildVersion, data) => {
+    for (const key in data.properties) {
+        for (const prop of (Array.isArray(data.properties[key]) ? data.properties[key] : [data.properties[key]])) {
+            writer.writeString(key);
+            DataFields_1.DataFields.SerializeProperty(writer, prop, key, buildVersion);
+        }
+    }
+    writer.writeString('None');
+};
+exports.SerializeDynamicStructData = SerializeDynamicStructData;
+const ReadFINNetworkTrace = (reader) => {
+    const networkTrace = {};
+    networkTrace.ref = ObjectReference_1.ObjectReference.read(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.write(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.read(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.write(writer, ref);
+    }
+    writer.writeString(stateStorage.thread);
+    writer.writeString(stateStorage.globals);
+    writer.writeBytes(stateStorage.remainingStructData);
+};
+exports.SerializeFINLuaProcessorStateStorage = SerializeFINLuaProcessorStateStorage;

package/build/parser/satisfactory/objects/property/generic/TextProperty.d.ts

@@ -0,0 +1,29 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare class TextProperty extends BasicProperty {
+    value: TextPropertyValue;
+    constructor(value: TextPropertyValue, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): TextProperty;
+    static ParseValue(reader: BinaryReadable): TextPropertyValue;
+    static CalcOverhead(property: TextProperty): number;
+    static Serialize(writer: ByteWriter, property: TextProperty): void;
+    static SerializeValue(writer: ByteWriter, value: TextPropertyValue): void;
+}
+export type TextPropertyValue = {
+    flags: number;
+    historyType: number;
+    namespace?: string;
+    key?: string;
+    value?: string;
+    sourceFmt?: TextPropertyValue;
+    arguments?: {
+        name: string;
+        valueType: number;
+        argumentValue: TextPropertyValue;
+    }[];
+    sourceText?: TextPropertyValue;
+    transformType?: number;
+    hasCultureInvariantString?: boolean;
+};

package/build/parser/satisfactory/objects/property/generic/TextProperty.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextProperty = void 0;
+const GUIDInfo_1 = require("../../GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+class TextProperty extends BasicProperty_1.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 = GUIDInfo_1.GUIDInfo.read(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) {
+        GUIDInfo_1.GUIDInfo.write(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);
+        }
+    }
+}
+exports.TextProperty = TextProperty;

package/build/parser/satisfactory/objects/property/generic/Uint32Property.d.ts

@@ -0,0 +1,13 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare class Uint32Property extends BasicProperty {
+    value: number;
+    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Uint32Property;
+    static ReadValue(reader: BinaryReadable): number;
+    static CalcOverhead(property: Uint32Property): number;
+    static Serialize(writer: ByteWriter, property: Uint32Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}

package/build/parser/satisfactory/objects/property/generic/Uint32Property.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uint32Property = void 0;
+const GUIDInfo_1 = require("../../GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+class Uint32Property extends BasicProperty_1.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 = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = Uint32Property.ReadValue(reader);
+        return new Uint32Property(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readUint32();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        Uint32Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeUint32(value);
+    }
+}
+exports.Uint32Property = Uint32Property;

package/build/parser/satisfactory/objects/property/generic/Uint64Property.d.ts

@@ -0,0 +1,13 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare class UInt64Property extends BasicProperty {
+    value: string;
+    constructor(value: string, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): UInt64Property;
+    static ReadValue(reader: BinaryReadable): string;
+    static CalcOverhead(property: UInt64Property): number;
+    static Serialize(writer: ByteWriter, property: UInt64Property): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
+}

package/build/parser/satisfactory/objects/property/generic/Uint64Property.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UInt64Property = void 0;
+const GUIDInfo_1 = require("../../GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+class UInt64Property extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'UInt64Property', guidInfo = undefined, index = 0) {
+        super('UInt64Property', ueType, guidInfo, index);
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = UInt64Property.ReadValue(reader);
+        return new UInt64Property(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readUint64().toString();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        UInt64Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeUint64(BigInt(value));
+    }
+}
+exports.UInt64Property = UInt64Property;

package/build/parser/satisfactory/objects/property/generic/Uint8Property.d.ts

@@ -0,0 +1,13 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare class Uint8Property extends BasicProperty {
+    value: number;
+    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Uint8Property;
+    static ReadValue(reader: BinaryReadable): number;
+    static CalcOverhead(property: Uint8Property): number;
+    static Serialize(writer: ByteWriter, property: Uint8Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}

package/build/parser/satisfactory/objects/property/generic/Uint8Property.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uint8Property = void 0;
+const GUIDInfo_1 = require("../../GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+class Uint8Property extends BasicProperty_1.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 = GUIDInfo_1.GUIDInfo.read(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) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        Uint8Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeUint8(value);
+    }
+}
+exports.Uint8Property = Uint8Property;

package/build/parser/satisfactory/objects/property/special/SpecialAnyProperty.d.ts

@@ -0,0 +1,36 @@
+import { Transform, vec3, vec4 } from '../../../structs/util.types';
+import { ObjectReference } from '../../values/ObjectReference';
+export type SpecialAnyProperty = {} | PowerLineSpecialProperty | PlayerSpecialProperty | ConveyorSpecialProperty | BuildableSubsystemSpecialProperty;
+export type PowerLineSpecialProperty = {
+    num: number;
+    source: ObjectReference;
+    target: ObjectReference;
+    sourceTranslation?: vec3;
+    targetTranslation?: vec3;
+};
+export type PlayerSpecialProperty = {
+    flag: number;
+    eosData?: string;
+    steamPlayerData?: string;
+};
+export type ItemSpecialProperty = {
+    length: number;
+    name: string;
+    position: number;
+    pathName: string;
+};
+export type ConveyorSpecialProperty = {
+    items: ItemSpecialProperty[];
+};
+export type BuildableSubsystemSpecialProperty = {
+    buildables: {
+        typePath: string;
+        instances: {
+            transform: Transform;
+            unknownUseNumbers: [vec4, vec3];
+            swatchSlotTypePath: string;
+            paintFinishPath: string;
+            recipeTypePath: string;
+        }[];
+    }[];
+};

package/build/parser/satisfactory/objects/property/special/SpecialAnyProperty.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.4.5",
+	"version": "0.4.6",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
 	"types": "./build/index.d.ts",
 	"main": "./build/index.js",